diff --git a/.gitattributes b/.gitattributes index 5fa5724e54897f245f26c27db2cbfa288d0b30e3..96ea89cb582cddc02d6b67babe28ca768d80b404 100644 --- a/.gitattributes +++ b/.gitattributes @@ -3777,3 +3777,12 @@ physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/setuptools/_vendor/mo physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_validations.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/__pycache__/base.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/__pycache__/transformations.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text +physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/_yaml.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/__init__.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text +physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/__init__.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text +physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/tix.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text +physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/mock.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text +physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/request.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text +physworld_p1_20261018/envs/p1/lib/sqlite3.40.0/libsqlite3.40.0.so filter=lfs diff=lfs merge=lfs -text +physworld_p1_20261018/envs/p1/lib/tk8.6/demos/images/teapot.ppm filter=lfs diff=lfs merge=lfs -text diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/INSTALLER b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/METADATA b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..8ae9817d43fa372ae9ff875d7633fb4e363dbec9 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/METADATA @@ -0,0 +1,249 @@ +Metadata-Version: 2.4 +Name: trimesh +Version: 5.1.1 +Summary: Import, export, process, analyze and view triangular meshes. +Author-email: Michael Dawson-Haggerty +License: The MIT License (MIT) + + Copyright (c) 2023 Michael Dawson-Haggerty + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + +Project-URL: homepage, https://github.com/mikedh/trimesh +Project-URL: documentation, https://trimesh.org +Keywords: graphics,mesh,geometry,3D +Classifier: Development Status :: 4 - Beta +Classifier: License :: OSI Approved :: MIT License +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Natural Language :: English +Classifier: Topic :: Scientific/Engineering +Classifier: Topic :: Multimedia :: Graphics +Classifier: Topic :: Multimedia :: Graphics :: 3D Modeling +Requires-Python: >=3.10 +Description-Content-Type: text/markdown +License-File: LICENSE.md +Requires-Dist: numpy>=1.21 +Provides-Extra: easy +Requires-Dist: colorlog; extra == "easy" +Requires-Dist: manifold3d>=2.3.0; extra == "easy" +Requires-Dist: charset-normalizer; extra == "easy" +Requires-Dist: lxml; extra == "easy" +Requires-Dist: jsonschema; extra == "easy" +Requires-Dist: networkx; extra == "easy" +Requires-Dist: svg.path; extra == "easy" +Requires-Dist: pycollada; extra == "easy" +Requires-Dist: shapely; extra == "easy" +Requires-Dist: xxhash; extra == "easy" +Requires-Dist: rtree; extra == "easy" +Requires-Dist: httpx; extra == "easy" +Requires-Dist: scipy; extra == "easy" +Requires-Dist: embreex; platform_machine != "aarch64" and extra == "easy" +Requires-Dist: pillow; extra == "easy" +Requires-Dist: vhacdx; extra == "easy" +Requires-Dist: mapbox_earcut>=1.0.2; extra == "easy" +Provides-Extra: recommend +Requires-Dist: sympy; extra == "recommend" +Requires-Dist: pyglet<2; extra == "recommend" +Requires-Dist: scikit-image; extra == "recommend" +Requires-Dist: fast-simplification; extra == "recommend" +Requires-Dist: python-fcl; extra == "recommend" +Requires-Dist: cascadio; extra == "recommend" +Provides-Extra: test +Requires-Dist: pytest-cov; extra == "test" +Requires-Dist: pytest; extra == "test" +Requires-Dist: pyinstrument; extra == "test" +Requires-Dist: ruff; extra == "test" +Provides-Extra: test-more +Requires-Dist: ezdxf; extra == "test-more" +Requires-Dist: meshio; extra == "test-more" +Requires-Dist: xatlas; extra == "test-more" +Requires-Dist: pytest-beartype; extra == "test-more" +Requires-Dist: matplotlib; extra == "test-more" +Requires-Dist: pymeshlab; python_version < "3.14" and extra == "test-more" +Requires-Dist: triangle; python_version < "3.14" and extra == "test-more" +Requires-Dist: ipython; extra == "test-more" +Requires-Dist: marimo; extra == "test-more" +Requires-Dist: requests; extra == "test-more" +Requires-Dist: aiohttp; extra == "test-more" +Requires-Dist: DracoPy>=1.7.0; extra == "test-more" +Provides-Extra: deprecated +Provides-Extra: all +Requires-Dist: trimesh[deprecated,easy,recommend,test,test_more]; extra == "all" +Dynamic: license-file + +[![trimesh](https://trimesh.org/_static/images/logotype-a.svg)](http://trimesh.org) + +----------- +[![Github Actions](https://github.com/mikedh/trimesh/workflows/Release%20Trimesh/badge.svg)](https://github.com/mikedh/trimesh/actions) [![coverage](https://trimesh.org/coverage/badge.svg)](https://trimesh.org/coverage/) [![Docker Image Version (latest by date)](https://img.shields.io/docker/v/trimesh/trimesh?label=docker&sort=semver)](https://hub.docker.com/r/trimesh/trimesh/tags) [![PyPI version](https://badge.fury.io/py/trimesh.svg)](https://badge.fury.io/py/trimesh) + + +Trimesh is a pure Python 3.10+ library for loading and using [triangular meshes](https://en.wikipedia.org/wiki/Triangle_mesh) with an emphasis on watertight surfaces. The goal of the library is to provide a full featured and well tested Trimesh object which allows for easy manipulation and analysis, in the style of the Polygon object in the [Shapely library](https://github.com/Toblerity/Shapely). + +The API is mostly stable, but this should not be relied on and is not guaranteed: install a specific version if you plan on deploying something using `trimesh`. + +Pull requests are appreciated and responded to promptly! If you'd like to contribute, here a quick [development and contributing guide.](https://trimesh.org/contributing.html) + + +## Basic Installation + +Keeping `trimesh` easy to install is a core goal, thus the *only* hard dependency is [`numpy`](http://www.numpy.org/). Installing other packages adds functionality but is not required. For the easiest install with just `numpy`: + +```bash +pip install trimesh +``` + +The minimal install can load many supported formats (STL, PLY, OBJ, GLTF/GLB) into `numpy.ndarray` values. More functionality is available when [soft dependencies are installed](https://trimesh.org/install#dependency-overview), including convex hulls (`scipy`), graph operations (`networkx`), fast ray queries (`embreex`), vector path handling (`shapely` and `rtree`), XML formats like 3DXML/XAML/3MF (`lxml`), preview windows (`pyglet`), faster cache checks (`xxhash`), etc. + +To install `trimesh` with the soft dependencies that generally install cleanly from binaries on Linux x86_64, MacOS ARM, and Windows x86_64 using `pip`: +```bash +pip install trimesh[easy] +``` + +If you are supporting a different platform or are freezing dependencies for an application we recommend you do not use extras, i.e. depend on `trimesh scipy` versus `trimesh[easy]`. Further information is available in the [advanced installation documentation](https://trimesh.org/install.html). + +## Quick Start + +Here is an example of loading a mesh from file and colorizing its faces ([nicely formatted notebook version](https://trimesh.org/quick_start.html) of this example. + +```python +import numpy as np +import trimesh + +# attach to logger so trimesh messages will be printed to console +trimesh.util.attach_to_log() + +# mesh objects can be created from existing faces and vertex data +mesh = trimesh.Trimesh(vertices=[[0, 0, 0], [0, 0, 1], [0, 1, 0]], faces=[[0, 1, 2]]) + +# by default, Trimesh will do a light processing, which will +# remove any NaN values and merge vertices that share position +# if you want to not do this on load, you can pass `process=False` +mesh = trimesh.Trimesh( + vertices=[[0, 0, 0], [0, 0, 1], [0, 1, 0]], faces=[[0, 1, 2]], process=False +) + +# some formats like `glb` represent multiple meshes with multiple instances +# and `load_mesh` will concatenate irreversibly, load it as a Scene +# if you need instance information: +# `scene = trimesh.load_scene('models/CesiumMilkTruck.glb')` +mesh = trimesh.load_mesh("models/CesiumMilkTruck.glb") + +# is the current mesh watertight? +mesh.is_watertight + +# what's the euler number for the mesh? +mesh.euler_number + +# the convex hull is another Trimesh object that is available as a property +# lets compare the volume of our mesh with the volume of its convex hull +print(mesh.volume / mesh.convex_hull.volume) + +# since the mesh is watertight it means there is a volume +# with a center of mass calculated from a surface integral approach +# which we can set as the origin for our mesh. It's perfectly fine to +# alter the vertices directly: +# mesh.vertices -= mesh.center_mass +# although this will completely clear the cache including face normals +# as we don't know that they're still valid. Using the translation +# method will try to save cached values that are still valid: +mesh.apply_translation(-mesh.center_mass) + + +# what's the (3, 3) moment of inertia for the mesh? +mesh.moment_inertia + +# if there are multiple bodies in the mesh we can split the mesh by +# connected components of face adjacency +# since this example mesh is a single watertight body we get a list of one mesh +mesh.split() + +# facets are groups of coplanar adjacent faces +# set each facet to a random color +# colors are 8 bit RGBA by default (n, 4) np.uint8 +for facet in mesh.facets: + mesh.visual.face_colors[facet] = trimesh.visual.random_color() + +# preview mesh in an opengl window if you installed pyglet and scipy with pip +mesh.show() + +# transform method can be passed a (4, 4) matrix and will cleanly apply the transform +mesh.apply_transform(trimesh.transformations.random_rotation_matrix()) + +# axis aligned bounding box is available +mesh.bounding_box.extents + +# a minimum volume oriented bounding box also available +# primitives are subclasses of Trimesh objects which automatically generate +# faces and vertices from data stored in the 'primitive' attribute +mesh.bounding_box_oriented.primitive.extents +mesh.bounding_box_oriented.primitive.transform + +# show the mesh appended with its oriented bounding box +# the bounding box is a trimesh.primitives.Box object, which subclasses +# Trimesh and lazily evaluates to fill in vertices and faces when requested +# (press w in viewer to see triangles) +(mesh + mesh.bounding_box_oriented).show() + +# bounding spheres and bounding cylinders of meshes are also +# available, and will be the minimum volume version of each +# except in certain degenerate cases, where they will be no worse +# than a least squares fit version of the primitive. +print( + mesh.bounding_box_oriented.volume, + mesh.bounding_cylinder.volume, + mesh.bounding_sphere.volume, +) +``` + +## Features + +* Import meshes from binary/ASCII STL, Wavefront OBJ, ASCII OFF, binary/ASCII PLY, GLTF/GLB 2.0, 3MF, XAML, 3DXML, etc. +* Export meshes as GLB/GLTF, binary STL, binary PLY, ASCII OFF, OBJ, COLLADA, etc. +* Import and export 2D or 3D vector paths with DXF or SVG files +* Preview meshes using an OpenGL `pyglet` window, or in-line in jupyter or marimo notebooks using `three.js` +* Automatic hashing from a subclassed numpy array for change tracking using MD5, zlib CRC, or xxhash, and internal caching of expensive values. +* Calculate face adjacencies, face angles, vertex defects, convex hulls, etc. +* Calculate cross sections for a 2D outline, or slice a mesh for a 3D remainder mesh, i.e. slicing for 3D-printing. +* Split mesh based on face connectivity using networkx, or scipy.sparse +* Calculate mass properties, including volume, center of mass, moment of inertia, principal components of inertia, etc. +* Repair simple problems with triangle winding, normals, and quad/triangle holes +* Compute rotation/translation/tessellation invariant identifier and find duplicate meshes +* Check if a mesh is watertight, convex, etc. +* Sample the surface of a mesh +* Ray-mesh queries including location, triangle index, etc. +* Boolean operations on meshes (intersection, union, difference) using Manifold3D or Blender. +* Voxelize watertight meshes +* Smooth watertight meshes using Laplacian smoothing algorithms (Classic, Taubin, Humphrey) +* Subdivide faces of a mesh +* Approximate minimum volume oriented bounding boxes and spheres for meshes. +* Calculate nearest point on mesh surface and signed distance +* Primitive objects (Box, Cylinder, Sphere, Extrusion) which are subclassed Trimesh objects and have all the same features (inertia, viewers, etc) +* Simple scene graph and transform tree which can be rendered (pyglet window, three.js in a jupyter/marimo notebook or exported. +* Many utility functions, like transforming points, unitizing vectors, aligning vectors, tracking numpy arrays for changes, grouping rows, etc. + +## Additional Notes + +- Check out some cool stuff people have done in the [GitHub network](https://github.com/mikedh/trimesh/network/dependents). +- Generally `trimesh` API changes should have a one-year period of [printing a `warnings.DeprecationWarning`](https://trimesh.org/contributing.html#deprecations) although that's not always possible (i.e. the pyglet2 viewer rewrite that's been back-burnered for several years.) +- Docker containers are available on Docker Hub as [`trimesh/trimesh`](https://hub.docker.com/r/trimesh/trimesh/tags) and there's a [container guide](https://trimesh.org/docker.html) in the docs. +- If you're choosing which format to use, you may want to try [GLB](https://trimesh.org/formats.html) as a fast modern option. diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/RECORD b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..3618689f281d967a69d2177f0b989c637cdc5a31 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/RECORD @@ -0,0 +1,261 @@ +../../../bin/trimesh,sha256=6WWrPPhYHZQyedABrLWPV3Rqxv6J19eQ_CcTD9OsoMk,255 +trimesh-5.1.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +trimesh-5.1.1.dist-info/METADATA,sha256=g_9dq972Sj7oLlYPQZwGx9XUBwTjzv4YB-oTbbebAbc,13280 +trimesh-5.1.1.dist-info/RECORD,, +trimesh-5.1.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +trimesh-5.1.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91 +trimesh-5.1.1.dist-info/entry_points.txt,sha256=E8JnT07gjUrdCQjuWPKNykjis4Aa2QWCFN6gVFWNNh0,50 +trimesh-5.1.1.dist-info/licenses/LICENSE.md,sha256=_ie174cQZ2zIUlXaKKMvOU4u8_TORwdaHHMqnqHXvQM,1090 +trimesh-5.1.1.dist-info/top_level.txt,sha256=bHXSeALt9l4__maYNLp93GRZSOJ5iApS2fe3jibIV1U,8 +trimesh/__init__.py,sha256=pQ2KnENG-gxfbKDCNO_9EsVIsb7lgZeruBBsteedM2A,2429 +trimesh/__main__.py,sha256=1QP7e1idyhXpLIj_8BAgJ6wCXGgWh7-HobJxdJ_EdDs,1461 +trimesh/__pycache__/__init__.cpython-311.pyc,, +trimesh/__pycache__/__main__.cpython-311.pyc,, +trimesh/__pycache__/base.cpython-311.pyc,, +trimesh/__pycache__/boolean.cpython-311.pyc,, +trimesh/__pycache__/bounds.cpython-311.pyc,, +trimesh/__pycache__/caching.cpython-311.pyc,, +trimesh/__pycache__/collision.cpython-311.pyc,, +trimesh/__pycache__/comparison.cpython-311.pyc,, +trimesh/__pycache__/constants.cpython-311.pyc,, +trimesh/__pycache__/convex.cpython-311.pyc,, +trimesh/__pycache__/creation.cpython-311.pyc,, +trimesh/__pycache__/curvature.cpython-311.pyc,, +trimesh/__pycache__/decomposition.cpython-311.pyc,, +trimesh/__pycache__/exceptions.cpython-311.pyc,, +trimesh/__pycache__/geometry.cpython-311.pyc,, +trimesh/__pycache__/graph.cpython-311.pyc,, +trimesh/__pycache__/grouping.cpython-311.pyc,, +trimesh/__pycache__/inertia.cpython-311.pyc,, +trimesh/__pycache__/intersections.cpython-311.pyc,, +trimesh/__pycache__/interval.cpython-311.pyc,, +trimesh/__pycache__/iteration.cpython-311.pyc,, +trimesh/__pycache__/nsphere.cpython-311.pyc,, +trimesh/__pycache__/parent.cpython-311.pyc,, +trimesh/__pycache__/permutate.cpython-311.pyc,, +trimesh/__pycache__/points.cpython-311.pyc,, +trimesh/__pycache__/poses.cpython-311.pyc,, +trimesh/__pycache__/primitives.cpython-311.pyc,, +trimesh/__pycache__/proximity.cpython-311.pyc,, +trimesh/__pycache__/registration.cpython-311.pyc,, +trimesh/__pycache__/remesh.cpython-311.pyc,, +trimesh/__pycache__/rendering.cpython-311.pyc,, +trimesh/__pycache__/repair.cpython-311.pyc,, +trimesh/__pycache__/resolvers.cpython-311.pyc,, +trimesh/__pycache__/sample.cpython-311.pyc,, +trimesh/__pycache__/schemas.cpython-311.pyc,, +trimesh/__pycache__/smoothing.cpython-311.pyc,, +trimesh/__pycache__/transformations.cpython-311.pyc,, +trimesh/__pycache__/triangles.cpython-311.pyc,, +trimesh/__pycache__/typed.cpython-311.pyc,, +trimesh/__pycache__/units.cpython-311.pyc,, +trimesh/__pycache__/util.cpython-311.pyc,, +trimesh/__pycache__/version.cpython-311.pyc,, +trimesh/base.py,sha256=tNFkLFqFsdgDhcjCVT_JM3tpJh4UxfUSiOm2wW6rwJg,110248 +trimesh/boolean.py,sha256=cMcnOPcdCxIGnjTDvcUd__RK-BioWbaxTQV82XTYwUU,5898 +trimesh/bounds.py,sha256=e6FJj3AhbGb6baXMyLJkHekdvZGFpjacTNeVrp1NZhk,20977 +trimesh/caching.py,sha256=SqI5pyXpep3JRAjmzlTLhQ1GECa5lAkqjyV6Qz7aEAc,19966 +trimesh/collision.py,sha256=JTfGM-VK6VvLmZuygnXUz8V4L_KGLwUxieKe_uQzTCY,24034 +trimesh/comparison.py,sha256=mQM24IEeq6lFdarFRtGSWzcDnadgK2KUFFA_TAxUQUE,5233 +trimesh/constants.py,sha256=xJ1ln2A1outZwxiniEgY7eaKheZCsJGvn6S-ro36y3g,4937 +trimesh/convex.py,sha256=0BtRUcKQs9rfqESUXg4LtJuiZTBLrrs1o2ZC0m2Jqmo,11644 +trimesh/creation.py,sha256=5DqE1zHk9kqN-15JvqtOaR06Wv9wfrva9LBTYFzMMuo,49403 +trimesh/curvature.py,sha256=W84yWS37-SJIXbxDpPnAm6ir2qJwTLnwCpBwwxooczs,6643 +trimesh/decomposition.py,sha256=TEIQITE_dMBV7yZcQomHYyxB17fIuPhMBpKOtfOqGLs,1472 +trimesh/exceptions.py,sha256=GzU9xHcbuTuMMw1_AmcgPaSB8Q7FmCUfKa3x1Xvxb3A,1464 +trimesh/exchange/__init__.py,sha256=mM-22o0bUVOJdj3EMUGdN3d1cvRI1JD_2TQs57jugIw,297 +trimesh/exchange/__pycache__/__init__.cpython-311.pyc,, +trimesh/exchange/__pycache__/binvox.cpython-311.pyc,, +trimesh/exchange/__pycache__/cascade.cpython-311.pyc,, +trimesh/exchange/__pycache__/common.cpython-311.pyc,, +trimesh/exchange/__pycache__/dae.cpython-311.pyc,, +trimesh/exchange/__pycache__/export.cpython-311.pyc,, +trimesh/exchange/__pycache__/load.cpython-311.pyc,, +trimesh/exchange/__pycache__/misc.cpython-311.pyc,, +trimesh/exchange/__pycache__/obj.cpython-311.pyc,, +trimesh/exchange/__pycache__/off.cpython-311.pyc,, +trimesh/exchange/__pycache__/ply.cpython-311.pyc,, +trimesh/exchange/__pycache__/stl.cpython-311.pyc,, +trimesh/exchange/__pycache__/threedxml.cpython-311.pyc,, +trimesh/exchange/__pycache__/threemf.cpython-311.pyc,, +trimesh/exchange/__pycache__/urdf.cpython-311.pyc,, +trimesh/exchange/__pycache__/xaml.cpython-311.pyc,, +trimesh/exchange/__pycache__/xyz.cpython-311.pyc,, +trimesh/exchange/binvox.py,sha256=h8ITHHDE0Pd6kEdMavhk0h61pNQON-UqBxQJJKKyx88,18602 +trimesh/exchange/cascade.py,sha256=kOApQAk6pqH_Uyd9F9_PJGv6bZ06329A73IadvfSBfM,2097 +trimesh/exchange/common.py,sha256=WKm7MsW1Rgt_4-yMsLF2REm0YyxIIs_JHaZkL0C_viA,457 +trimesh/exchange/dae.py,sha256=jYDDo4NcjHrKlMFJYk8bTQ_L7CgAy074V8yIXOh8pFM,14910 +trimesh/exchange/export.py,sha256=9zgkbp05jsK-PLi4kVb6ldVG4tJWFgsf8_pN-zU0874,10460 +trimesh/exchange/gltf/__init__.py,sha256=C-urs6KKnnV3Pd9BNaURmNwQetYbu89N4oAZFBfiFZw,79987 +trimesh/exchange/gltf/__pycache__/__init__.cpython-311.pyc,, +trimesh/exchange/gltf/__pycache__/extensions.cpython-311.pyc,, +trimesh/exchange/gltf/extensions.py,sha256=Jc9E7vRAoRNOq9XOEOzixAJUuk3nYeWdkzNpFVITpyo,15074 +trimesh/exchange/load.py,sha256=azE8Hw_5KV4c32pVZ1iPXffVwC7qEjU_ydFXQNGank4,21516 +trimesh/exchange/misc.py,sha256=nMNJCchtfRCr6UtOYyIolwxwc1nWoB2ANUvHPPGDNvw,4762 +trimesh/exchange/obj.py,sha256=KFo4CYCnW3T76FhdtrmGlnorm-ZoDiNast0rRqK8tO0,37496 +trimesh/exchange/off.py,sha256=56CDVdrHo5nf1oaF_gYDNMVSSy6dfQtXi40PmYkVdmU,2958 +trimesh/exchange/ply.py,sha256=gTWeQ4ENC_lGZcDvn1bqGr4gy8pNs2mCn6yY5VPvz9Y,37760 +trimesh/exchange/stl.py,sha256=DsnDQGEXLJ_f1Lfp-_pb3qsWqd_QADSN6t524YOOfyg,9957 +trimesh/exchange/threedxml.py,sha256=zV2yftXAS5CdBdJ49qYsaSu04R7bH8FWrBoiOj-zNoo,15995 +trimesh/exchange/threemf.py,sha256=xj13A04L3RKCUy9oqx0nlhA4gcRGRdxC-bX4aPTg-vQ,19650 +trimesh/exchange/urdf.py,sha256=3Uz9TvL3k9e3mdOlZAF50EfAEcSqsjr_MG0inBScchw,5361 +trimesh/exchange/xaml.py,sha256=HgfS_zrHckm0588PtvWM2HsmLXotqdXOGV-m82luwLY,5436 +trimesh/exchange/xyz.py,sha256=p8ilPbWhuwy7kLMHXWABT5BqrzwdwJzDKGAQmNIeIwI,2961 +trimesh/geometry.py,sha256=NTAibuYEGSKHxtgQtpUysLJSKTtdfmpDWV8K60pUNsE,14805 +trimesh/graph.py,sha256=JjQSL5WnfEo6dfN3mIvzCRc5_iZFwYSMDhPapfJdtoU,31460 +trimesh/grouping.py,sha256=9-pbqtMh9wTQfzfcmbj98SulMW-14JotT9VEh-kblXk,27131 +trimesh/inertia.py,sha256=rg9uT0VQC31NnrczngvwsqjP3_2uJjhWJidId5jJMr4,10931 +trimesh/interfaces/__init__.py,sha256=17dhVVvYQG-0ynilMhw2HX1X8vTByVksjwASnNtwoN4,45 +trimesh/interfaces/__pycache__/__init__.cpython-311.pyc,, +trimesh/interfaces/__pycache__/blender.cpython-311.pyc,, +trimesh/interfaces/__pycache__/generic.cpython-311.pyc,, +trimesh/interfaces/blender.py,sha256=6jMWjAjc54eq5hj6IFxvlvxMYn6sWtdpCmn_XfwoFCU,4704 +trimesh/interfaces/generic.py,sha256=7jCalpc1KfTi9ws-BmwMW1wAXQp9N2PGmepDZWNsRRs,3670 +trimesh/intersections.py,sha256=E2T-SxiPCEOqVm63ExfxAUS2zNgQ0rDx4-boliBcfvg,28536 +trimesh/interval.py,sha256=mi0Gny6nfzSZBVBQVSowIMhntlXj0FTdv4V5BAF4iuA,2746 +trimesh/iteration.py,sha256=wQ9V1IAaldh7AvTm02m_c2jhG8-lDrhQXWsaRx5I4B0,5550 +trimesh/nsphere.py,sha256=EVcDMIkUT9lzNpIvZ1JID_ib9b14lN9BJoqhcvDlX2I,5882 +trimesh/parent.py,sha256=7ZJU6D0Pj7KoX4X6JnGaTfRtEw64-FSKPnP7HBe8PFU,12028 +trimesh/path/__init__.py,sha256=Sfnb4j9VssDXhC45phbrFtcR5lw4k3MXQJg0UDz1y58,378 +trimesh/path/__pycache__/__init__.cpython-311.pyc,, +trimesh/path/__pycache__/arc.cpython-311.pyc,, +trimesh/path/__pycache__/creation.cpython-311.pyc,, +trimesh/path/__pycache__/curve.cpython-311.pyc,, +trimesh/path/__pycache__/entities.cpython-311.pyc,, +trimesh/path/__pycache__/intersections.cpython-311.pyc,, +trimesh/path/__pycache__/packing.cpython-311.pyc,, +trimesh/path/__pycache__/path.cpython-311.pyc,, +trimesh/path/__pycache__/polygons.cpython-311.pyc,, +trimesh/path/__pycache__/raster.cpython-311.pyc,, +trimesh/path/__pycache__/repair.cpython-311.pyc,, +trimesh/path/__pycache__/segments.cpython-311.pyc,, +trimesh/path/__pycache__/simplify.cpython-311.pyc,, +trimesh/path/__pycache__/traversal.cpython-311.pyc,, +trimesh/path/__pycache__/util.cpython-311.pyc,, +trimesh/path/arc.py,sha256=9PxotC2p98OXTmYquHNy1eG2ipnrWhKaQQzPTwKyCLg,7689 +trimesh/path/creation.py,sha256=bP5_piTXXdEWwlBod7tKXs-anAgVwsqanNR8JsoJE_c,8553 +trimesh/path/curve.py,sha256=VER431Q72eFiX7ClyYtUDwGpx6Vc-T2XDpdgZjbL47g,3881 +trimesh/path/entities.py,sha256=yFL2M1tjO6gxh-lBojwydYBuh-AOUiY4bUgshV9dgWk,22568 +trimesh/path/exchange/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +trimesh/path/exchange/__pycache__/__init__.cpython-311.pyc,, +trimesh/path/exchange/__pycache__/dxf.cpython-311.pyc,, +trimesh/path/exchange/__pycache__/export.cpython-311.pyc,, +trimesh/path/exchange/__pycache__/load.cpython-311.pyc,, +trimesh/path/exchange/__pycache__/misc.cpython-311.pyc,, +trimesh/path/exchange/__pycache__/svg_io.cpython-311.pyc,, +trimesh/path/exchange/dxf.py,sha256=0_VFx8RZ786WewD4KHNMma8iIb8cT3o-1VtdqmiWS80,33130 +trimesh/path/exchange/export.py,sha256=i0hHHk87-xzJo-aftc7O6yp57zN6yppr-eGIh4-hT54,2004 +trimesh/path/exchange/load.py,sha256=pDeXLbGnjeVFHZs_UyPqxBxPscsISBwrNP8OHyzgRG4,2881 +trimesh/path/exchange/misc.py,sha256=6zAm5HxX1uu8Qhm6HASF0l0ow8FNtRwFBWtJYhuABtQ,6540 +trimesh/path/exchange/svg_io.py,sha256=duQIVwfvBMBx1P6NiB5aKgM5-q4EdzTQYgw3sgUZTBs,26446 +trimesh/path/intersections.py,sha256=G5AGVQxKxmpgHO4JQg44D-Ldfg6IkxtgzEePee_WGC4,2238 +trimesh/path/packing.py,sha256=_cthqydIedFJe6tFcxZ5u_phGcI8HhNuhIV_1v9v_1E,26347 +trimesh/path/path.py,sha256=lP6vHhYoUMAzTpOWgtDQChIFbw3LFfY821IujbWoR_s,48469 +trimesh/path/polygons.py,sha256=dvDi3rUr7aQvEC4qKjWgsuJF5D-laxrL3g-VTg5Flzo,32695 +trimesh/path/raster.py,sha256=V4oucSE0kx1o8UV9kZuLw28AgLyCvGcr8mIf2zRp2dc,3175 +trimesh/path/repair.py,sha256=nxreZyvWvRB3v1LimbgNEAww-ZoNkr5A-CaklyBFrk8,3237 +trimesh/path/segments.py,sha256=KkgbavWND24Z6tg0HAR4Rp2Hc8HIoBjHzoMo-1Kbs1o,16604 +trimesh/path/simplify.py,sha256=zJfUxCRbCnsetjHsltp-bHr8SnhhSo2StK_AsIAXzSw,12553 +trimesh/path/traversal.py,sha256=OHDqMq5nEusvlF049NP1mVdt2cU6GjJyJY6Wnm8BuNo,16259 +trimesh/path/util.py,sha256=aoHsefWw6TFfNCfbjTNLJc4V5ePTL1JTziu2-3MPJwI,1767 +trimesh/permutate.py,sha256=1nNfIzwuIcgYWXktPiGCuXqsDaxSoiGViqc2r13CGPQ,5141 +trimesh/points.py,sha256=zd4m96sCktwElejFisT7JRZzku9yJ3n_s8jQkVJ6WwQ,22283 +trimesh/poses.py,sha256=FX5nBJswYM1Wq-m3zAPClop0JnVdk_XOZjZwnZYJFh8,10437 +trimesh/primitives.py,sha256=qYYZq1Z4VW4RgGxS5-n3a5-wYwVSygxxNqJGzh-_PG8,35345 +trimesh/proximity.py,sha256=6cLcx2jWnSJvlE7p6xLRsgNR9G4IBufvuLR8Kvf7e3o,19445 +trimesh/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +trimesh/ray/__init__.py,sha256=5lNzMoKlQygP28tnIQgXNuoB9sjWdO92ZSdE44l_EI0,346 +trimesh/ray/__pycache__/__init__.cpython-311.pyc,, +trimesh/ray/__pycache__/ray_pyembree.cpython-311.pyc,, +trimesh/ray/__pycache__/ray_triangle.cpython-311.pyc,, +trimesh/ray/__pycache__/ray_util.cpython-311.pyc,, +trimesh/ray/ray_pyembree.py,sha256=ikR-4VB09DvQTVvw81ZXxBbl6vukbBPJkYjE5KoqSng,11555 +trimesh/ray/ray_triangle.py,sha256=Dz5qOH7FXGKsmULoGZ3LpHDQ90P-y-M1-urNC4UjIQE,12741 +trimesh/ray/ray_util.py,sha256=vAJgDSI7q25YK7Geqrh1UJwAwP_RVH6AN4bECMdge7Q,4438 +trimesh/registration.py,sha256=h6e6yea8JKW61yVBY13ipkKYMWEWwEB27DMgLwW8Q2I,41820 +trimesh/remesh.py,sha256=I5BlDSlsE_T4w1No81H-GJEOQb4qx65P0mXkk8e5b1w,16950 +trimesh/rendering.py,sha256=gww6NqyK9tE5o4VKUcqStief6sOYLfgip9I-uCIgyuM,12296 +trimesh/repair.py,sha256=q9uMeEfnL-vEwGRB4EYlAqysN85pjWV2TXrmtgliTdo,12321 +trimesh/resolvers.py,sha256=cuujk5MMvnLVLzSSYDOYO1yBZKHhhPLVvaT2Tu0efiU,21119 +trimesh/resources/__init__.py,sha256=gNYXMa6f-GDU3RFnBl-d0LH4pItbvrfTn0lgrQWAnjU,2597 +trimesh/resources/__pycache__/__init__.cpython-311.pyc,, +trimesh/resources/color_map.json.gzip,sha256=0Edta1aXREyLNZ_ZM-fv_eEAIzKa7dvr8TLYA-wDFzU,16762 +trimesh/resources/creation.json,sha256=i72dHuxNOk2gbnSjYhWGTEL-WzeWdWR1e3t_3iDP0Ys,1084 +trimesh/resources/schema/README.md,sha256=ZwcnLfRg6Qd1eRMm3Kt9S-oi2yYh2RZT8pllnbYe0J0,443 +trimesh/resources/schema/gltf2.schema.zip,sha256=y9Fpkpfke71DmIXJO2gH5X4_gws7LXBvw6lEiOswjKg,24785 +trimesh/resources/schema/primitive/box.schema.json,sha256=STE93MwWVDyIbBTltXkVTXh6RmcALWO3JKAPrW5BpGQ,814 +trimesh/resources/schema/primitive/capsule.schema.json,sha256=347KHrkcRoGmwbTRxmOTDOTNFuf0pGRlOwGMGxOAeJc,774 +trimesh/resources/schema/primitive/cylinder.schema.json,sha256=Qvc2GhCsFDPLLx0PpD_zZE3I09lAjRbK7ZMDvyY7S34,785 +trimesh/resources/schema/primitive/extrusion.schema.json,sha256=HtKJPxN8DYFXDzVocthjZazbyx94TZlumVu_eRSKm0U,688 +trimesh/resources/schema/primitive/primitive.schema.json,sha256=GlsChe96ci2ptVzAn4_VU52xrvNdBewq77qzQQVWtEg,479 +trimesh/resources/schema/primitive/scenegraph.schema.json,sha256=Gn8inknthqkoXDyWjtVZdgO0nvC6aqWP58ESttGPDAU,791 +trimesh/resources/schema/primitive/sphere.schema.json,sha256=VvCqHrhVMSSyTBowtjBnUkeh6SX-pAK66_t6XfMLLvk,522 +trimesh/resources/schema/primitive/transform.schema.json,sha256=y4UBFIkUQ56ZUHcezFKLLnr68-ZQbWRtAGPKQsxSAlw,469 +trimesh/resources/schema/primitive/trimesh.schema.json,sha256=ioYYpvcrxKQirkbyHxKxh2plBtRXaV9fQU0Oq3WYt8U,859 +trimesh/resources/schema/primitive/wkt.polygon.schema.json,sha256=ryizpoS5vuRWC1YA_LrfFgE4D-32wjUu4X_7_opottM,413 +trimesh/resources/schema/urdf.xsd,sha256=qiA_TEiCkEc8JOL91auwwSpa8xPy49OF0eWAtn1BEkE,11705 +trimesh/resources/templates/base.svg,sha256=MYfPqEHyr5ik4RVyHhludqVaPFJ5Wxjd_Pd32XK6y8c,190 +trimesh/resources/templates/blender_boolean.py.tmpl,sha256=uJ8W5QN-Alq-sRpA7MaJ1Xm3BxiIsEWbsUmTlHRPwIg,2012 +trimesh/resources/templates/blender_unwrap.py.template,sha256=GJOEzRKEtskHwD9PfyvNdEgA3umFeKlURrS0m0kp1As,1147 +trimesh/resources/templates/dxf.json,sha256=E3CfXHa_S5NIyt3FPd4WhLBrhJCQqFSdq9LCUtmLxlo,15667 +trimesh/resources/templates/path.svg,sha256=JPEKKh2lPcwuM0JrOl6iCUIjci-yrlUqq8T-AWUYyX0,36 +trimesh/resources/templates/ply.json,sha256=MxeHS5AqDqw4eQb_frkAoywxpkJxjSdcHu9DyPXpNkA,559 +trimesh/resources/templates/viewer.zip,sha256=chvLtgz_KYjO3-VHWSmU3tdAo0W6QJDhft3jgZMHScU,173435 +trimesh/resources/units_to_inches.json,sha256=rq_7NUdr-xptFoMX9ahCu4OLPGLxccKragKi5PdbT2w,1265 +trimesh/sample.py,sha256=jf7T9gbqMUbzOGTbGYkbOTk164JT0tpXaZVKxjfBkFE,8629 +trimesh/scene/__init__.py,sha256=vLW7-tLswsCiiANiRFeZ8LZpCyiEbeBXw9ZzDC64bTg,141 +trimesh/scene/__pycache__/__init__.cpython-311.pyc,, +trimesh/scene/__pycache__/cameras.cpython-311.pyc,, +trimesh/scene/__pycache__/lighting.cpython-311.pyc,, +trimesh/scene/__pycache__/scene.cpython-311.pyc,, +trimesh/scene/__pycache__/transforms.cpython-311.pyc,, +trimesh/scene/cameras.py,sha256=NpkKA6lc5feW8RvO6QvdEjro3ZZ3ScVNx-lsOeaCmi0,12166 +trimesh/scene/lighting.py,sha256=PbjxN_yUxFHIWKzrvTyD2Mnq2nJhiK7kkn97VSExjQE,8723 +trimesh/scene/scene.py,sha256=bdAe_Qntrlj502Q9c_nKlDkEyzU6UvnY9mMyE7aE4Vs,54380 +trimesh/scene/transforms.py,sha256=84vrEYl0FyxCJw0DXzu3frXTdN6MJRqre84aM6--jqI,28938 +trimesh/schemas.py,sha256=EKTwX16mVeQ5IPRQhXCoiDIIet_9DaYVNKnUx0MoMKo,1287 +trimesh/smoothing.py,sha256=5uret7Yp6MGTnwxIspVQDHJuaoDxrtctuAJ6bpTy6h0,12231 +trimesh/transformations.py,sha256=ZEsRJzYSS3gDwCiiSCeZJtEPdIZJY0AG1JOpByLq42A,74801 +trimesh/triangles.py,sha256=uBXNJOqeLAJSzd5ulgJsxH6MfzfUYpbbp-TvD5jORyc,22828 +trimesh/typed.py,sha256=ljmWfdx978-PW8GVmPicqM58Bk-ptSipqcT7aNndWOs,4572 +trimesh/units.py,sha256=B_n8Gp2DC2wvjOM8xQZFtswfoMGmAKaXgUfJVVepyXA,4600 +trimesh/util.py,sha256=JR8stHxeNUfTQUGqWDmwJjjUtJIfhXEIpe1oWvYhP3Y,75569 +trimesh/version.py,sha256=een2lq8n1QFi2zucBxUkfirUmKB7jhHyCDSumq5UeEM,1352 +trimesh/viewer/__init__.py,sha256=GexDehAA_EQNOHrD9v7D50UHzjRb-x6-8YrPCcx87GM,842 +trimesh/viewer/__pycache__/__init__.cpython-311.pyc,, +trimesh/viewer/__pycache__/notebook.cpython-311.pyc,, +trimesh/viewer/__pycache__/trackball.cpython-311.pyc,, +trimesh/viewer/__pycache__/windowed.cpython-311.pyc,, +trimesh/viewer/notebook.py,sha256=yQieeH6aP0T2VrfxhZXUxJfZwmR8PThTJWaY43KU-Xk,4652 +trimesh/viewer/trackball.py,sha256=Ac223FA8TuI5NqtylRjsbwIrKOvohy5k2m3FyFSOXW4,8233 +trimesh/viewer/windowed.py,sha256=N2R8o5S05_Ni4CEtvTLdxlQa2fHHcww2_grm3ReMTas,33883 +trimesh/visual/__init__.py,sha256=dGTdTpHWt66Rt7IvzqQivdlWNgH-ofHUD9iTfRm78_E,828 +trimesh/visual/__pycache__/__init__.cpython-311.pyc,, +trimesh/visual/__pycache__/base.cpython-311.pyc,, +trimesh/visual/__pycache__/color.cpython-311.pyc,, +trimesh/visual/__pycache__/gloss.cpython-311.pyc,, +trimesh/visual/__pycache__/material.cpython-311.pyc,, +trimesh/visual/__pycache__/objects.cpython-311.pyc,, +trimesh/visual/__pycache__/texture.cpython-311.pyc,, +trimesh/visual/base.py,sha256=rLBIbRocEqx_NNgh-YK1Hgd5tY1V5PIEOTLKrd4Bajk,1014 +trimesh/visual/color.py,sha256=Lrbu0Qpe9iZtl_qJL_mvMKAcQ5wif9XnSuoEFVjHWC4,36652 +trimesh/visual/gloss.py,sha256=_jlKRmscbrmuJ_EKdIvMrMXh2GxI25PfWU5ASR0F6Pg,14576 +trimesh/visual/material.py,sha256=6P9cED6GXE6PkD6yG9SIJoBzfXYwtdHOyOjrqUnIilE,36062 +trimesh/visual/objects.py,sha256=zqoB_BEBoMM06_8IlcEZmJCudN7-I6oIYelO2fXZNzs,2554 +trimesh/visual/texture.py,sha256=SiNtJFo_nW3YohFwDqTo14tkT6vx_BK5u5ZyF3BwnFU,10677 +trimesh/voxel/__init__.py,sha256=cRHtVx79ffVWI7GDV9YURMYzuRYqgcGQ4MKBXTFiLjk,88 +trimesh/voxel/__pycache__/__init__.cpython-311.pyc,, +trimesh/voxel/__pycache__/base.cpython-311.pyc,, +trimesh/voxel/__pycache__/creation.cpython-311.pyc,, +trimesh/voxel/__pycache__/encoding.cpython-311.pyc,, +trimesh/voxel/__pycache__/morphology.cpython-311.pyc,, +trimesh/voxel/__pycache__/ops.cpython-311.pyc,, +trimesh/voxel/__pycache__/runlength.cpython-311.pyc,, +trimesh/voxel/__pycache__/transforms.cpython-311.pyc,, +trimesh/voxel/base.py,sha256=XXvxPQ9bFEsCfyQobpiXfg1omJoMdprGfPRSo6VOW0s,12663 +trimesh/voxel/creation.py,sha256=lkFLzbeHzZnrdzu_j1Tu7MnlP__V3o9gyTyHz_ASE8U,9653 +trimesh/voxel/encoding.py,sha256=6pvX8fAHmWtKC6HyHdEOoxLkJqIXmL3qjDnHb2Dm4Is,27740 +trimesh/voxel/morphology.py,sha256=Pv1uqH3NVfGi1oUtt8alywmiAsqVOBGJDlvYpS5qj20,5455 +trimesh/voxel/ops.py,sha256=nrTvlwntHvV1LHHGjckLDxFIVREw-HOojaeJfT9Lo3c,13619 +trimesh/voxel/runlength.py,sha256=hVNppnBruSCQsnTJ7Au9WtHaW0YUKsWg7OiZf_OOwZs,20386 +trimesh/voxel/transforms.py,sha256=EoyMBMIF1F6f5hGf0sgcTKKEh4dR8YbdzntUrHl5ejw,5259 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/REQUESTED b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/WHEEL b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..13013d7b49be5a84c3ee5931b06285b9553cf5d0 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (84.0.0) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/entry_points.txt b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..0e2a43f7435b50856eea3f9bc95c4d8758a7fb0d --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/entry_points.txt @@ -0,0 +1,2 @@ +[console_scripts] +trimesh = trimesh:__main__.main diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/licenses/LICENSE.md b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/licenses/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..d0571124dc68ee63553001f17f043d19250159cc --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/licenses/LICENSE.md @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2023 Michael Dawson-Haggerty + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/top_level.txt b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..f0bbb9c246bd27b6cdd1d786daeb6b058308c5ad --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/top_level.txt @@ -0,0 +1 @@ +trimesh diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/geometry.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/geometry.py new file mode 100644 index 0000000000000000000000000000000000000000..e353985a1b0cb1bb36041a11b4d92e1ccc96d667 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/geometry.py @@ -0,0 +1,470 @@ +import numpy as np + +from . import util +from .constants import log +from .typed import NDArray + +try: + import scipy.sparse +except BaseException as E: + from . import exceptions + + # raise E again if anyone tries to use sparse + scipy = exceptions.ExceptionWrapper(E) + + +def plane_transform(origin, normal): + """ + Given the origin and normal of a plane find the transform + that will move that plane to be coplanar with the XY plane. + + Parameters + ---------- + origin : (3,) float + Point that lies on the plane + normal : (3,) float + Vector that points along normal of plane + + Returns + --------- + transform: (4,4) float + Transformation matrix to move points onto XY plane + """ + transform = align_vectors(normal, [0, 0, 1]) + if origin is not None: + transform[:3, 3] = -np.dot(transform, np.append(origin, 1))[:3] + return transform + + +def align_vectors(a, b, return_angle=False): + """ + Find the rotation matrix that transforms one 3D vector + to another. + + Parameters + ------------ + a : (3,) float + Unit vector + b : (3,) float + Unit vector + return_angle : bool + Return the angle between vectors or not + + Returns + ------------- + matrix : (4, 4) float + Homogeneous transform to rotate from `a` to `b` + angle : float + If `return_angle` angle in radians between `a` and `b` + + """ + a = np.array(a, dtype=np.float64) + b = np.array(b, dtype=np.float64) + if a.shape != (3,) or b.shape != (3,): + raise ValueError("vectors must be (3,)!") + + # find the SVD of the two vectors + au = np.linalg.svd(a.reshape((-1, 1)))[0] + bu = np.linalg.svd(b.reshape((-1, 1)))[0] + + if np.linalg.det(au) < 0: + au[:, -1] *= -1.0 + if np.linalg.det(bu) < 0: + bu[:, -1] *= -1.0 + + # put rotation into homogeneous transformation + matrix = np.eye(4) + matrix[:3, :3] = bu.dot(au.T) + + if return_angle: + # projection of a onto b + # first column of SVD result is normalized source vector + dot = np.dot(au[:, 0], bu[:, 0]) + # clip to avoid floating point error + angle = np.arccos(np.clip(dot, -1.0, 1.0)) + return matrix, angle + + return matrix + + +def faces_to_edges(faces, return_index=False): + """ + Given a list of faces (n,3), return a list of edges (n*3,2) + + Parameters + ----------- + faces : (n, 3) int + Vertex indices representing faces + + Returns + ----------- + edges : (n*3, 2) int + Vertex indices representing edges + """ + faces = np.asanyarray(faces, np.int64) + + # each face has three edges + edges = faces[:, [0, 1, 1, 2, 2, 0]].reshape((-1, 2)) + + if return_index: + # edges are in order of faces due to reshape + face_index = np.tile(np.arange(len(faces)), (3, 1)).T.reshape(-1) + return edges, face_index + return edges + + +def vector_angle(pairs): + """ + Find the angles between pairs of unit vectors. + + Parameters + ---------- + pairs : (n, 2, 3) float + Unit vector pairs + + Returns + ---------- + angles : (n,) float + Angles between vectors in radians + """ + pairs = np.asanyarray(pairs, dtype=np.float64) + if len(pairs) == 0: + return np.array([]) + elif util.is_shape(pairs, (2, 3)): + pairs = pairs.reshape((-1, 2, 3)) + elif not util.is_shape(pairs, (-1, 2, (2, 3))): + raise ValueError("pairs must be (n,2,(2|3))!") + + # do the dot product between vectors + dots = util.diagonal_dot(pairs[:, 0], pairs[:, 1]) + # clip for floating point error + dots = np.clip(dots, -1.0, 1.0) + # do cos and remove arbitrary sign + angles = np.abs(np.arccos(dots)) + + return angles + + +def triangulate_quads(quads, dtype=np.int64, use_fan: bool = True) -> NDArray: + """ + Given an array of quad faces return them as triangle faces, + also handles pure triangles and mixed triangles and quads. + + Parameters + ----------- + quads: (n, 4) int + Vertex indices of quad faces. + dtype + Data type requested for the return + use_fan + Triangulate holes larger than quads with fans, + which may be wrong if the holes are non-convex + + Returns + ----------- + faces : (m, 3) int + Vertex indices of triangular faces. + """ + + if len(quads) == 0: + return np.zeros(0, dtype=dtype) + + try: + # this will fail in newer versions of numpy + # if there are mixed quads and tris + quads = np.array(quads, dtype=dtype) + + if len(quads.shape) == 2 and quads.shape[1] == 3: + # if they are just triangles return immediately + return quads.astype(dtype) + + if len(quads.shape) == 2 and quads.shape[1] == 4: + # if they are just quads stack and return + return np.vstack((quads[:, [0, 1, 2]], quads[:, [2, 3, 0]])).astype(dtype) + except ValueError: + # new numpy raises an error for sequences + pass + + # we made it here so we have mixed tris/quads/polygons + # do one pass to get the lengths + lengths = np.array([len(i) for i in quads], dtype=np.int64) + + # get triangles and quads as clean constant-row numpy arrays + tri = np.array([quads[i] for i in np.nonzero(lengths == 3)[0]], dtype=np.int64) + quad = np.array([quads[i] for i in np.nonzero(lengths == 4)[0]], dtype=np.int64) + + if use_fan: + # get arbitrary polygons as a ragged sequence + poly = [quads[i] for i in np.nonzero(lengths > 4)[0]] + else: + # skip any hole larger than a quad + poly = [] + + if len(quad) == 0 and len(poly) == 0: + # only triangles, return triangles + return tri.astype(dtype) + if len(poly) > 0: + # use numpy slicing to triangulate ragged-sequence polygons + poly = util.triangle_fans_to_faces(poly) + if len(quad) > 0: + # trivially tessellate quads + quad = np.vstack((quad[:, [0, 1, 2]], quad[:, [2, 3, 0]])) + # stack triangles from all three cases + return util.vstack_empty([tri, quad, poly]).astype(dtype) + + +def vertex_face_indices(vertex_count, faces, faces_sparse): + """ + Find vertex face indices from the faces array of vertices + + Parameters + ----------- + vertex_count : int + The number of vertices faces refer to + faces : (n, 3) int + List of vertex indices + faces_sparse : scipy.sparse.COO + Sparse matrix + + Returns + ----------- + vertex_faces : (vertex_count, ) int + Face indices for every vertex + Array padded with -1 in each row for all vertices with fewer + face indices than the max number of face indices. + """ + # Create 2D array with row for each vertex and + # length of max number of faces for a vertex + try: + counts = np.bincount(faces.flatten(), minlength=vertex_count) + except TypeError: + # casting failed on 32 bit Windows + log.warning("casting failed, falling back!") + # fall back to np.unique (usually ~35x slower than bincount) + counts = np.unique(faces.flatten(), return_counts=True)[1] + assert len(counts) == vertex_count + assert faces.max() < vertex_count + + # start cumulative sum at zero and clip off the last value + starts = np.append(0, np.cumsum(counts)[:-1]) + # pack incrementing array into final shape + pack = np.arange(counts.max()) + starts[:, None] + # pad each row with -1 to pad to the max length + padded = -(pack >= (starts + counts)[:, None]).astype(np.int64) + + try: + # do most of the work with a sparse dot product + identity = scipy.sparse.identity(len(faces), dtype=int) + sorted_faces = faces_sparse.dot(identity).nonzero()[1] + # this will fail if any face was degenerate + # TODO + # figure out how to filter out degenerate faces from sparse + # result if sorted_faces.size != faces.size + padded[padded == 0] = sorted_faces + except BaseException: + # fall back to a slow loop + log.warning( + "vertex_faces falling back to slow loop! " + + "mesh probably has degenerate faces", + exc_info=True, + ) + sort = np.zeros(faces.size, dtype=np.int64) + flat = faces.flatten() + for v in range(vertex_count): + # assign the data in order + sort[starts[v] : starts[v] + counts[v]] = (np.where(flat == v)[0] // 3)[::-1] + padded[padded == 0] = sort + return padded + + +def mean_vertex_normals(vertex_count, faces, face_normals, sparse=None, **kwargs): + """ + Find vertex normals from the mean of the faces that contain + that vertex. + + Parameters + ----------- + vertex_count : int + The number of vertices faces refer to + faces : (n, 3) int + List of vertex indices + face_normals : (n, 3) float + Normal vector for each face + + Returns + ----------- + vertex_normals : (vertex_count, 3) float + Normals for every vertex + Vertices unreferenced by faces will be zero. + """ + + def summed_sparse(): + # use a sparse matrix of which face contains each vertex to + # figure out the summed normal at each vertex + # allow cached sparse matrix to be passed + if sparse is None: + matrix = index_sparse(vertex_count, faces) + else: + matrix = sparse + summed = matrix.dot(face_normals) + return summed + + def summed_loop(): + # loop through every face, in tests was ~50x slower than + # doing this with a sparse matrix + summed = np.zeros((vertex_count, 3)) + for face, normal in zip(faces, face_normals): + summed[face] += normal + return summed + + try: + summed = summed_sparse() + except BaseException: + log.warning("unable to use sparse matrix, falling back!", exc_info=True) + summed = summed_loop() + + # invalid normals will be returned as zero + vertex_normals = util.unitize(summed) + + return vertex_normals + + +def weighted_vertex_normals( + vertex_count, faces, face_normals, face_angles, use_loop=False +): + """ + Compute vertex normals from the faces that contain that vertex. + The contribution of a face's normal to a vertex normal is the + ratio of the corner-angle in which the vertex is, with respect + to the sum of all corner-angles surrounding the vertex. + + Grit Thuerrner & Charles A. Wuethrich (1998) + Computing Vertex Normals from Polygonal Facets, + Journal of Graphics Tools, 3:1, 43-46 + + Parameters + ----------- + vertex_count : int + The number of vertices faces refer to + faces : (n, 3) int + List of vertex indices + face_normals : (n, 3) float + Normal vector for each face + face_angles : (n, 3) float + Angles at each vertex in the face + + Returns + ----------- + vertex_normals : (vertex_count, 3) float + Normals for every vertex + Vertices unreferenced by faces will be zero. + """ + + def summed_sparse(): + # use a sparse matrix of which face contains each vertex to + # figure out the summed normal at each vertex + # allow cached sparse matrix to be passed + # fill the matrix with vertex-corner angles as weights + matrix = index_sparse(vertex_count, faces, data=face_angles.ravel()) + return matrix.dot(face_normals) + + def summed_loop(): + summed = np.zeros((vertex_count, 3), np.float64) + for vertex_idx in np.arange(vertex_count): + # loop over all vertices + # compute normal contributions from surrounding faces + # obviously slower than with the sparse matrix + face_idxs, inface_idxs = np.where(faces == vertex_idx) + surrounding_angles = face_angles[face_idxs, inface_idxs] + summed[vertex_idx] = np.dot( + surrounding_angles / surrounding_angles.sum(), face_normals[face_idxs] + ) + + return summed + + # normals should be unit vectors + face_ok = (face_normals**2).sum(axis=1) > 0.5 + # don't consider faces with invalid normals + faces = faces[face_ok] + face_normals = face_normals[face_ok] + face_angles = face_angles[face_ok] + + if not use_loop: + try: + return util.unitize(summed_sparse()) + except BaseException: + log.warning("unable to use sparse matrix, falling back!", exc_info=True) + # we either crashed or were asked to loop + return util.unitize(summed_loop()) + + +def index_sparse(columns, indices, data=None, dtype=None): + """ + Return a sparse matrix for which vertices are contained in which faces. + A data vector can be passed which is then used instead of booleans + + Parameters + ------------ + columns : int + Number of columns, usually number of vertices + indices : (m, d) int + Usually mesh.faces + + Returns + --------- + sparse: scipy.sparse.coo_matrix of shape (columns, len(faces)) + dtype is boolean + + Examples + ---------- + In [1]: sparse = faces_sparse(len(mesh.vertices), mesh.faces) + + In [2]: sparse.shape + Out[2]: (12, 20) + + In [3]: mesh.faces.shape + Out[3]: (20, 3) + + In [4]: mesh.vertices.shape + Out[4]: (12, 3) + + In [5]: dense = sparse.toarray().astype(int) + + In [6]: dense + Out[6]: + array([[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0], + [0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0], + [0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1], + [1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0], + [0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0], + [0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1], + [0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1]]) + + In [7]: dense.sum(axis=0) + Out[7]: array([3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]) + """ + indices = np.asanyarray(indices) + columns = int(columns) + + # flattened list + row = indices.reshape(-1) + col = np.tile( + np.arange(len(indices)).reshape((-1, 1)), (1, indices.shape[1]) + ).reshape(-1) + + shape = (columns, len(indices)) + if data is None: + data = np.ones(len(col), dtype=bool) + elif len(data) != len(col): + raise ValueError("data incorrect length") + + if dtype is not None: + data = data.astype(dtype) + + # assemble into sparse matrix + return scipy.sparse.coo_matrix((data, (row, col)), shape=shape, dtype=data.dtype) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/graph.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/graph.py new file mode 100644 index 0000000000000000000000000000000000000000..44d9e7adb31b154d89b134841452bb97d07675ee --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/graph.py @@ -0,0 +1,1017 @@ +""" +graph.py +------------- + +Deal with graph operations. Primarily deal with graphs in (n, 2) +edge list form, and abstract the backend graph library being used. + +Currently uses networkx or scipy.sparse.csgraph backend. +""" + +import collections + +import numpy as np + +from . import exceptions, grouping, util +from .constants import log, tol +from .geometry import faces_to_edges +from .typed import ( + ArrayLike, + GraphEngineType, + Integer, + NDArray, + Number, + Sequence, + int64, +) + +try: + from scipy.sparse import coo_matrix, csgraph + from scipy.spatial import cKDTree +except BaseException as E: + # re-raise exception when used + cKDTree = exceptions.ExceptionWrapper(E) + csgraph = exceptions.ExceptionWrapper(E) + coo_matrix = exceptions.ExceptionWrapper(E) + +try: + import networkx as nx +except BaseException as E: + # create a dummy module which will raise the ImportError + # or other exception only when someone tries to use networkx + nx = exceptions.ExceptionWrapper(E) + + +def face_adjacency(faces=None, mesh=None, return_edges=False): + """ + Returns an (n, 2) list of face indices. + Each pair of faces in the list shares an edge, making them adjacent. + + + Parameters + ----------- + faces : (n, 3) int, or None + Vertex indices representing triangles + mesh : Trimesh object + If passed will used cached edges + instead of generating from faces + return_edges : bool + Return the edges shared by adjacent faces + + Returns + ---------- + adjacency : (m, 2) int + Indexes of faces that are adjacent + edges: (m, 2) int + Only returned if return_edges is True + Indexes of vertices which make up the + edges shared by the adjacent faces + + Examples + ---------- + This is useful for lots of things such as finding + face- connected components: + ```python + >>> graph = nx.Graph() + >>> graph.add_edges_from(mesh.face_adjacency) + >>> groups = nx.connected_components(graph_connected) + ``` + """ + + if mesh is None: + # first generate the list of edges for the current faces + # also return the index for which face the edge is from + edges, edges_face = faces_to_edges(faces, return_index=True) + # make sure edge rows are sorted + edges.sort(axis=1) + else: + # if passed a mesh, used the cached values + edges = mesh.edges_sorted + edges_face = mesh.edges_face + + # this will return the indices for duplicate edges + # every edge appears twice in a well constructed mesh + # so for every row in edge_idx: + # edges[edge_idx[*][0]] == edges[edge_idx[*][1]] + # in this call to group rows we discard edges which + # don't occur twice + edge_groups = grouping.group_rows(edges, require_count=2) + + if len(edge_groups) == 0: + log.debug("No adjacent faces detected! Did you merge vertices?") + + # the pairs of all adjacent faces + # so for every row in face_idx, self.faces[face_idx[*][0]] and + # self.faces[face_idx[*][1]] will share an edge + adjacency = edges_face[edge_groups] + + # degenerate faces may appear in adjacency as the same value + nondegenerate = adjacency[:, 0] != adjacency[:, 1] + adjacency = adjacency[nondegenerate] + + # sort pairs in-place so we can search for indexes with ordered pairs + adjacency.sort(axis=1) + + if return_edges: + adjacency_edges = edges[edge_groups[:, 0][nondegenerate]] + assert len(adjacency_edges) == len(adjacency) + return adjacency, adjacency_edges + + return adjacency + + +def face_neighborhood(mesh) -> NDArray[int64]: + """ + Find faces that share a vertex i.e. 'neighbors' faces. + Relies on the fact that an adjacency matrix at a power p + contains the number of paths of length p connecting two nodes. + Here we take the bipartite graph from mesh.faces_sparse to the power 2. + The non-zeros are the faces connected by one vertex. + + Returns + ---------- + neighborhood : (n, 2) int + Pairs of faces which share a vertex + """ + + VT = mesh.faces_sparse + TT = VT.T * VT + TT.setdiag(0) + TT.eliminate_zeros() + TT = TT.tocoo() + neighborhood = np.concatenate( + (TT.row[:, None], TT.col[:, None]), axis=-1, dtype=np.int64 + ) + return neighborhood + + +def face_adjacency_unshared(mesh): + """ + Return the vertex index of the two vertices not in the shared + edge between two adjacent faces + + Parameters + ---------- + mesh : Trimesh object + Input mesh + + Returns + ----------- + vid_unshared : (len(mesh.face_adjacency), 2) int + Indexes of mesh.vertices + for degenerate faces without exactly + one unshared vertex per face it will be -1 + """ + + # the non- shared vertex index is the same shape + # as face_adjacency holding vertex indices vs face indices + vid_unshared = np.zeros_like(mesh.face_adjacency, dtype=np.int64) - 1 + # get the shared edges between adjacent faces + edges = mesh.face_adjacency_edges + + # loop through the two columns of face adjacency + for i, fid in enumerate(mesh.face_adjacency.T): + # faces from the current column of face adjacency + faces = mesh.faces[fid] + # should have one True per row of (3,) + # index of vertex not included in shared edge + unshared = np.logical_not( + np.logical_or( + faces == edges[:, 0].reshape((-1, 1)), + faces == edges[:, 1].reshape((-1, 1)), + ) + ) + # each row should have exactly one uncontained verted + row_ok = unshared.sum(axis=1) == 1 + # any degenerate row should be ignored + unshared[~row_ok, :] = False + # set the + vid_unshared[row_ok, i] = faces[unshared] + + return vid_unshared + + +def face_adjacency_radius(mesh): + """ + Compute an approximate radius between adjacent faces. + + Parameters + -------------- + mesh : trimesh.Trimesh + + Returns + ------------- + radii : (len(self.face_adjacency),) float + Approximate radius between faces + Parallel faces will have a value of np.inf + span : (len(self.face_adjacency),) float + Perpendicular projection distance of two + unshared vertices onto the shared edge + """ + + # solve for the radius of the adjacent faces + # distance + # R = --------------- + # 2 * sin(theta) + nonzero = mesh.face_adjacency_angles > np.radians(0.01) + denominator = np.abs(2.0 * np.sin(mesh.face_adjacency_angles[nonzero])) + + # consider the distance between the non- shared vertices of the + # face adjacency pair as the key distance + point_pairs = mesh.vertices[mesh.face_adjacency_unshared] + vectors = np.diff(point_pairs, axis=1).reshape((-1, 3)) + + # the vertex indices of the shared edge for the adjacency pairx + edges = mesh.face_adjacency_edges + # unit vector along shared the edge + edges_vec = util.unitize(np.diff(mesh.vertices[edges], axis=1).reshape((-1, 3))) + + # the vector of the perpendicular projection to the shared edge + perp = np.subtract( + vectors, (util.diagonal_dot(vectors, edges_vec).reshape((-1, 1)) * edges_vec) + ) + # the length of the perpendicular projection + span = util.row_norm(perp) + + # complete the values for non- infinite radii + radii = np.ones(len(mesh.face_adjacency)) * np.inf + radii[nonzero] = span[nonzero] / denominator + + return radii, span + + +def vertex_adjacency_graph(mesh): + """ + Returns a networkx graph representing the vertices and + their connections in the mesh. + + Parameters + ---------- + mesh : Trimesh object + + Returns + --------- + graph : networkx.Graph + Graph representing vertices and edges between + them where vertices are nodes and edges are edges + + Examples + ---------- + This is useful for getting nearby vertices for a given vertex, + potentially for some simple smoothing techniques. + >>> graph = mesh.vertex_adjacency_graph + >>> graph.neighbors(0) + > [1, 3, 4] + """ + g = nx.Graph() + g.add_edges_from(mesh.edges_unique) + return g + + +def shared_edges(faces_a, faces_b): + """ + Given two sets of faces, find the edges which are in both sets. + + Parameters + --------- + faces_a : (n, 3) int + Array of faces + faces_b : (m, 3) int + Array of faces + + Returns + --------- + shared : (p, 2) int + Edges shared between faces + """ + e_a = np.sort(faces_to_edges(faces_a), axis=1) + e_b = np.sort(faces_to_edges(faces_b), axis=1) + shared = grouping.boolean_rows(e_a, e_b, operation=np.intersect1d) + return shared + + +def facets(mesh, engine: GraphEngineType = None, facet_threshold: Number | None = None): + """ + Find the list of parallel adjacent faces. + + Parameters + ----------- + mesh : trimesh.Trimesh + engine + Which graph engine to use + facet_threshold : float + Threshold for two facets to be considered coplanar + + Returns + --------- + facets : sequence of (n,) int + Groups of face indexes of + parallel adjacent faces. + """ + if facet_threshold is None: + facet_threshold = tol.facet_threshold + # what is the radius of a circle that passes through the perpendicular + # projection of the vector between the two non- shared vertices + # onto the shared edge, with the face normal from the two adjacent faces + radii = mesh.face_adjacency_radius + # what is the span perpendicular to the shared edge + span = mesh.face_adjacency_span + # a very arbitrary formula for declaring two adjacent faces + # parallel in a way that is hopefully (and anecdotally) robust + # to numeric error + # a common failure mode is two faces that are very narrow with a slight + # angle between them, so here we divide by the perpendicular span + # to penalize very narrow faces, and then square it just for fun + parallel = np.ones(len(radii), dtype=bool) + # if span is zero we know faces are small/parallel + nonzero = np.abs(span) > tol.zero + # faces with a radii/span ratio larger than a threshold pass + parallel[nonzero] = (radii[nonzero] / span[nonzero]) ** 2 > facet_threshold + + # run connected components on the parallel faces to group them + components = connected_components( + mesh.face_adjacency[parallel], + nodes=np.arange(len(mesh.faces)), + min_len=2, + engine=engine, + ) + + return components + + +def split( + mesh, + only_watertight: bool = True, + repair: bool = True, + adjacency: ArrayLike | None = None, + engine: GraphEngineType = None, + **kwargs, +) -> list: + """ + Split a mesh into multiple meshes from face + connectivity. + + If only_watertight is true it will only return + watertight meshes and will attempt to repair + single triangle or quad holes. + + Parameters + ---------- + mesh : trimesh.Trimesh + The source multibody mesh to split + only_watertight + Only return watertight components and discard + any connected component that isn't fully watertight. + repair + If set try to fill small holes in a mesh, before the + discard step in `only_watertight. + adjacency : (n, 2) int + If passed will be used instead of `mesh.face_adjacency` + engine + Which graph engine to use for the connected components. + + Returns + ---------- + meshes : (m,) trimesh.Trimesh + Results of splitting based on parameters. + """ + if adjacency is None: + adjacency = mesh.face_adjacency + + if only_watertight: + # the smallest watertight mesh has 4 faces + min_len = 4 + else: + # allow any size of connected component + min_len = 1 + + components = connected_components( + edges=adjacency, nodes=np.arange(len(mesh.faces)), min_len=min_len, engine=engine + ) + return mesh.submesh( + components, only_watertight=only_watertight, repair=repair, **kwargs + ) + + +def connected_components( + edges, min_len: Integer = 1, nodes=None, engine: GraphEngineType = None +): + """ + Find groups of connected nodes from an edge list. + + Parameters + ----------- + edges : (n, 2) int + Edges between nodes + nodes : (m, ) int or None + List of nodes that exist + min_len : int + Minimum length of a component group to return + engine : str or None + Which graph engine to use (None for automatic): + (None, 'networkx', 'scipy') + + + Returns + ----------- + components : (n,) sequence of (*,) int + Nodes which are connected + """ + + def components_networkx(): + """ + Find connected components using networkx + """ + graph = nx.from_edgelist(edges) + # make sure every face has a node, so single triangles + # aren't discarded (as they aren't adjacent to anything) + if min_len <= 1: + graph.add_nodes_from(nodes) + return [list(i) for i in nx.connected_components(graph)] + + def components_csgraph(): + """ + Find connected components using scipy.sparse.csgraph + """ + # label each node + labels = connected_component_labels(edges, node_count=node_count) + + # we have to remove results that contain nodes outside + # of the specified node set and reindex + contained = np.zeros(node_count, dtype=bool) + contained[nodes] = True + index = np.arange(node_count, dtype=np.int64)[contained] + components = grouping.group(labels[contained], min_len=min_len) + return [index[c] for c in components] + + return components + + # check input edges + edges = np.asanyarray(edges, dtype=np.int64) + # if no nodes were specified just use unique + if nodes is None: + nodes = np.unique(edges) + + # exit early if we have no nodes + if len(nodes) == 0: + return [] + elif len(edges) == 0: + if min_len <= 1: + return np.reshape(nodes, (-1, 1)).tolist() + else: + return [] + + if not util.is_shape(edges, (-1, 2)): + raise ValueError("edges must be (n, 2)!") + + # find the maximum index referenced in either nodes or edges + counts = [0] + if len(edges) > 0: + counts.append(edges.max()) + if len(nodes) > 0: + counts.append(nodes.max()) + node_count = np.max(counts) + 1 + + # remove edges that don't have both nodes in the node set + mask = np.zeros(node_count, dtype=bool) + mask[nodes] = True + edges_ok = mask[edges].all(axis=1) + edges = edges[edges_ok] + + # networkx is pure python and is usually 5-10x slower than scipy + engines = collections.OrderedDict( + (("scipy", components_csgraph), ("networkx", components_networkx)) + ) + + # if a graph engine has explicitly been requested use it + if engine in engines: + return engines[engine]() + + # otherwise, go through our ordered list of graph engines + # until we get to one that has actually been installed + for function in engines.values(): + try: + return function() + # will be raised if the library didn't import correctly above + except BaseException: + continue + raise ImportError("no graph engines available!") + + +def connected_component_labels(edges, node_count=None): + """ + Label graph nodes from an edge list, using scipy.sparse.csgraph + + Parameters + ----------- + edges : (n, 2) int + Edges of a graph + node_count : int, or None + The largest node in the graph. + + Returns + ---------- + labels : (node_count,) int + Component labels for each node + """ + matrix = edges_to_coo(edges, node_count) + _body_count, labels = csgraph.connected_components(matrix, directed=False) + + if node_count is not None: + assert len(labels) == node_count + + return labels + + +def _split_traversal(traversal: NDArray, edges_tree) -> list[NDArray]: + """ + Given a traversal as a list of nodes split the traversal + if a sequential index pair is not in the given edges. + Useful since the implementation of DFS we're using will + happily return disconnected values in a flat traversal. + + Parameters + -------------- + traversal : (m,) int + Traversal through edges + edges_tree : cKDTree + A way to reconstruct original edge indices from + sorted (n, 2) edge values. This is a slight misuse of a + kdtree since one could just hash the tuples of the integer + edges, but that isn't possible with numpy arrays easily + and this allows a vectorized reconstruction. + + Returns + --------------- + split : sequence of (p,) int + Traversals split into only connected paths. + """ + # turn the (n,) traversal into (n-1, 2) edges + # save the original order of the edges for reconstruction + trav_edge = np.column_stack((traversal[:-1], traversal[1:])) + + # check to see if the traversal edges exists in the original edges + # the tree is holding the sorted edges so query after sorting + exists = edges_tree.query(np.sort(trav_edge, axis=1))[0] < 1e-10 + + if exists.all(): + split = [traversal] + else: + # contiguous groups of edges + blocks = grouping.blocks(exists, min_len=1, only_nonzero=True) + split = [ + np.concatenate([trav_edge[:, 0][b], trav_edge[b[-1]][1:]]) for b in blocks + ] + + # a traversal may be effectively closed so check + # to see if we need to add on the first index to the end + needs_close = np.array( + [ + len(s) > 2 + and s[0] != s[-1] + and edges_tree.query(sorted([s[0], s[-1]]))[0] < 1e-10 + for s in split + ] + ) + + if needs_close.any(): + for i in np.nonzero(needs_close)[0]: + split[i] = np.concatenate([split[i], split[i][:1]]) + + if tol.strict: + for s in split: + check_edge = np.sort(np.column_stack((s[:-1], s[1:])), axis=1) + assert (edges_tree.query(check_edge)[0] < 1e-10).all() + + return split + + +def fill_traversals(traversals: Sequence, edges: ArrayLike) -> Sequence | NDArray: + """ + Convert a traversal of a list of edges into a sequence of + traversals where every pair of consecutive node indexes + is an edge in a passed edge list + + Parameters + ------------- + traversals : sequence of (m,) int + Node indexes of traversals of a graph + edges : (n, 2) int + Pairs of connected node indexes + + Returns + -------------- + splits : sequence of (p,) int + Node indexes of connected traversals + """ + # make sure edges are correct type + edges = np.sort(edges, axis=1) + edges_tree = cKDTree(edges) + + # if there are no traversals just return edges + if len(traversals) == 0: + return edges.copy() + + splits = [] + for nodes in traversals: + # split traversals to remove edges that don't actually exist + splits.extend(_split_traversal(traversal=nodes, edges_tree=edges_tree)) + + # turn the split traversals back into (n, 2) edges + included = util.vstack_empty([np.column_stack((i[:-1], i[1:])) for i in splits]) + if len(included) > 0: + # sort included edges in place + included.sort(axis=1) + # make sure any edges not included in split traversals + # are just added as a length 2 traversal + splits.extend(grouping.boolean_rows(edges, included, operation=np.setdiff1d)) + else: + # no edges were included, so our filled traversal + # is just the original edges copied over + splits = edges.copy() + + return splits + + +def traversals(edges, mode="bfs"): + """ + Given an edge list generate a sequence of ordered depth + first search traversals using scipy.csgraph routines. + + Parameters + ------------ + edges : (n, 2) int + Undirected edges of a graph + mode : str + Traversal type, 'bfs' or 'dfs' + + Returns + ----------- + traversals : (m,) sequence of (p,) int + Ordered DFS or BFS traversals of the graph. + """ + edges = np.array(edges, dtype=np.int64) + if len(edges) == 0: + return [] + elif not util.is_shape(edges, (-1, 2)): + raise ValueError("edges are not (n, 2)!") + + # pick the traversal method + mode = str(mode).lower().strip() + if mode == "bfs": + func = csgraph.breadth_first_order + elif mode == "dfs": + func = csgraph.depth_first_order + else: + raise ValueError("traversal mode must be either dfs or bfs") + + # make sure edges are sorted so we can query + # an ordered pair later + edges.sort(axis=1) + # coo_matrix for csgraph routines + graph = edges_to_coo(edges) + + # get unique nodes AND leaf node info from bincount + bincount = np.bincount(edges.ravel()) + + # a leaf node occurs exactly once + nodes_leaf = np.nonzero(bincount == 1)[0] + # a non-leaf node occurs more than once + nodes = np.nonzero(bincount > 1)[0] + + # collect traversals + traversals = [] + # keep track of which nodes have been visited + visited = np.zeros(len(bincount) + 1, dtype=np.bool_) + + # process leaf nodes first to avoid DFS backtracking + # starting DFS from an interior node of an open path causes + # backtracking, which produces non-edge consecutive pairs that + # fill_traversals then splits a single path into pieces + for start in np.concatenate((nodes_leaf, nodes)): + if visited[start]: + continue + + # get an (n,) ordered traversal from this start + ordered = func( + graph, i_start=start, return_predecessors=False, directed=False + ).astype(np.int64) + + # store the traversal and mark all nodes as visited + traversals.append(ordered) + visited[ordered] = True + + return traversals + + +def edges_to_coo(edges, count=None, data=None): + """ + Given an edge list, return a boolean scipy.sparse.coo_matrix + representing the edges in matrix form. + + Parameters + ------------ + edges : (n, 2) int + Edges of a graph + count : int + The total number of nodes in the graph + if None: count = edges.max() + 1 + data : (n,) any + Assign data to each edge, if None will + be bool True for each specified edge + + Returns + ------------ + matrix: (count, count) scipy.sparse.coo_matrix + Sparse COO + """ + edges = np.asanyarray(edges, dtype=np.int64) + if not (len(edges) == 0 or util.is_shape(edges, (-1, 2))): + raise ValueError("edges must be (n, 2)!") + + # if count isn't specified just set it to largest + # value referenced in edges + if count is None: + count = edges.max() + 1 + count = int(count) + + # if no data is specified set every specified edge + # to True + if data is None: + data = np.ones(len(edges), dtype=bool) + + return coo_matrix((data, edges.T), dtype=data.dtype, shape=(count, count)) + + +def neighbors(edges, max_index=None, directed=False): + """ + Find the neighbors for each node in an edgelist graph. + + TODO : re-write this with sparse matrix operations + + Parameters + ------------ + edges : (n, 2) int + Connected nodes + directed : bool + If True, only connect edges in one direction + + Returns + --------- + neighbors : sequence + Vertex index corresponds to set of other vertex indices + """ + neighbors = collections.defaultdict(set) + if directed: + [neighbors[edge[0]].add(edge[1]) for edge in edges] + else: + [ + (neighbors[edge[0]].add(edge[1]), neighbors[edge[1]].add(edge[0])) + for edge in edges + ] + + if max_index is None: + max_index = edges.max() + 1 + array = [list(neighbors[i]) for i in range(max_index)] + + return array + + +def smooth_shade(mesh, angle: Number | None = None, facet_minarea: Number | None = 10.0): + """ + Return a non-watertight version of the mesh which + will render nicely with smooth shading by + disconnecting faces at sharp angles to each other. + + Parameters + ----------- + mesh : trimesh.Trimesh + Source geometry + angle : float or None + Angle in radians face pairs with angles + smaller than this will appear smoothed + facet_minarea : float or None + Minimum area fraction to consider + IE for `facets_minarea=25` only facets larger + than `mesh.area / 25` will be considered. + + Returns + --------- + smooth : trimesh.Trimesh + Geometry with disconnected face patches + """ + if angle is None: + angle = np.radians(20) + + # if the mesh has no adjacent faces return a copy + if len(mesh.face_adjacency) == 0: + return mesh.copy() + + # face pairs below angle threshold + angle_ok = mesh.face_adjacency_angles < angle + # subset of face adjacency + adjacency = mesh.face_adjacency[angle_ok] + + # coplanar groups of faces + facets = [] + nodes = None + # collect coplanar regions for smoothing + if facet_minarea is not None: + areas = mesh.area_faces + min_area = mesh.area / facet_minarea + try: + # we can survive not knowing facets + # exclude facets with few faces + facets = [f for f in mesh.facets if areas[f].sum() > min_area] + if len(facets) > 0: + # mask for removing adjacency pairs where + # one of the faces is contained in a facet + mask = np.ones(len(mesh.faces), dtype=bool) + mask[np.hstack(facets)] = False + # apply the mask to adjacency + adjacency = adjacency[mask[adjacency].all(axis=1)] + # nodes are no longer every faces + nodes = np.unique(adjacency) + except BaseException: + log.warning("failed to calculate facets", exc_info=True) + # run connected components on facet adjacency + components = connected_components(adjacency, min_len=2, nodes=nodes) + + # add back coplanar groups if any exist + if len(facets) > 0: + components.extend(facets) + + if len(components) == 0: + # if no components for some reason + # just return a copy of the original mesh + return mesh.copy() + + # add back any faces that were missed + unique = np.unique(np.hstack(components)) + if len(unique) != len(mesh.faces): + # things like single loose faces + # or groups below facet_minlen + broke = np.setdiff1d(np.arange(len(mesh.faces)), unique) + components.extend(broke.reshape((-1, 1))) + + # get a submesh as a single appended Trimesh + smooth = mesh.submesh(components, only_watertight=False, append=True) + # store face indices from original mesh + smooth.metadata["original_components"] = components + # smoothed should have exactly the same number of faces + if len(smooth.faces) != len(mesh.faces): + log.warning("face count in smooth wrong!") + return smooth + + +def is_watertight( + edges: ArrayLike, edges_sorted: ArrayLike | None = None +) -> tuple[bool, bool]: + """ + Parameters + ----------- + edges : (n, 2) int + List of vertex indices + edges_sorted : (n, 2) int + Pass vertex indices sorted on axis 1 as a speedup + + Returns + --------- + watertight : boolean + Whether every edge is shared by an even + number of faces + winding : boolean + Whether every shared edge is reversed + """ + # passing edges_sorted is a speedup only + if edges_sorted is None: + edges_sorted = np.sort(edges, axis=1) + + # group sorted edges throwing away any edge + # that doesn't appear exactly twice + groups = grouping.group_rows(edges_sorted, require_count=2) + # if we didn't throw away any edges that means + # every edge shows up exactly twice + watertight = bool((len(groups) * 2) == len(edges)) + + # check that the un-sorted duplicate edges are reversed + opposing = edges[groups].reshape((-1, 4))[:, 1:3].T + winding = bool(np.equal(*opposing).all()) + + return watertight, winding + + +def graph_to_svg(graph): + """ + Turn a networkx graph into an SVG string + using graphviz `dot`. + + Parameters + ---------- + graph: networkx graph + + Returns + --------- + svg: string, pictoral layout in SVG format + """ + + import subprocess + import tempfile + + with tempfile.NamedTemporaryFile() as dot_file: + nx.drawing.nx_agraph.write_dot(graph, dot_file.name) + svg = subprocess.check_output(["dot", dot_file.name, "-Tsvg"]) + return svg + + +def multigraph_paths(G, source, cutoff=None): + """ + For a networkx MultiDiGraph, find all paths from a source node + to leaf nodes. This function returns edge instance numbers + in addition to nodes, unlike networkx.all_simple_paths. + + Parameters + --------------- + G : networkx.MultiDiGraph + Graph to evaluate + source : hashable + Node to start traversal at + cutoff : int + Number of nodes to visit + If None will visit all nodes + + Returns + ---------- + traversals : (n,) list of [(node, edge instance index), ] paths + Traversals of the multigraph + """ + if cutoff is None: + cutoff = (len(G.edges()) * len(G.nodes())) + 1 + + # the path starts at the node specified + current = [(source, 0)] + # traversals we need to go back and do + queue = [] + # completed paths + traversals = [] + + for _ in range(cutoff): + # paths are stored as (node, instance) so + # get the node of the last place visited + current_node = current[-1][0] + # get all the children of the current node + child = G[current_node] + + if len(child) == 0: + # we have no children, so we are at the end of this path + # save the path as a completed traversal + traversals.append(current) + # if there is nothing on the queue, we are done + if len(queue) == 0: + break + # otherwise continue traversing with the next path + # on the queue + current = queue.pop() + else: + # oh no, we have multiple edges from current -> child + start = True + # iterate through child nodes and edge instances + for node in child.keys(): + for instance in child[node].keys(): + if start: + # if this is the first edge, keep it on the + # current traversal and save the others for later + current.append((node, instance)) + start = False + else: + # this child has multiple instances + # so we will need to traverse them multiple times + # we appended a node to current, so only take the + # first n-1 visits + queue.append(current[:-1] + [(node, instance)]) + return traversals + + +def multigraph_collect(G, traversal, attrib=None): + """ + Given a MultiDiGraph traversal, collect attributes along it. + + Parameters + ------------- + G: networkx.MultiDiGraph + traversal: (n) list of (node, instance) tuples + attrib: dict key, name to collect. If None, will return all + + Returns + ------------- + collected: (len(traversal) - 1) list of attributes + """ + + collected = [] + for u, v in util.pairwise(traversal): + attribs = G[u[0]][v[0]][v[1]] + if attrib is None: + collected.append(attribs) + else: + collected.append(attribs[attrib]) + return collected diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/grouping.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/grouping.py new file mode 100644 index 0000000000000000000000000000000000000000..512b101edf40f22736606ac2d50b6342dd349a38 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/grouping.py @@ -0,0 +1,877 @@ +""" +grouping.py +------------- + +Functions for grouping values and rows. +""" + +import numpy as np + +from . import util +from .constants import log, tol +from .typed import ArrayLike, Integer, NDArray, Number, Sequence + +try: + from scipy.spatial import cKDTree +except BaseException as E: + # wrapping just ImportError fails in some cases + # will raise the error when someone tries to use KDtree + from . import exceptions + + cKDTree = exceptions.ExceptionWrapper(E) + + +def merge_vertices( + mesh, + merge_tex: bool | None = None, + merge_norm: bool | None = None, + digits_vertex: Integer | None = None, + digits_norm: Integer | None = None, + digits_uv: Integer | None = None, +): + """ + Removes duplicate vertices, grouped by position and + optionally texture coordinate and normal. + + Parameters + ------------- + mesh : Trimesh object + Mesh to merge vertices on + merge_tex : bool + If True textured meshes with UV coordinates will + have vertices merged regardless of UV coordinates + merge_norm : bool + If True, meshes with vertex normals will have + vertices merged ignoring different normals + digits_vertex : None or int + Number of digits to consider for vertex position + digits_norm : int + Number of digits to consider for unit normals + digits_uv : int + Number of digits to consider for UV coordinates + """ + # no vertices so exit early + if len(mesh.vertices) == 0: + return + if merge_tex is None: + merge_tex = False + if merge_norm is None: + merge_norm = False + if digits_norm is None: + digits_norm = 2 + if digits_uv is None: + digits_uv = 4 + if digits_vertex is None: + # use tol.merge if digit precision not passed + digits_vertex = util.decimal_to_digits(tol.merge) + + # if we have a ton of unreferenced vertices it will + # make the unique_rows call super slow so cull first + if hasattr(mesh, "faces") and len(mesh.faces) > 0: + referenced = np.zeros(len(mesh.vertices), dtype=bool) + referenced[mesh.faces] = True + else: + # this is used for geometry without faces + referenced = np.ones(len(mesh.vertices), dtype=bool) + + # collect vertex attributes into sequence we can stack + stacked = [mesh.vertices * (10**digits_vertex)] + + # UV texture visuals require us to update the + # vertices and normals differently + if ( + not merge_tex + and mesh.visual.defined + and mesh.visual.kind == "texture" + and mesh.visual.uv is not None + and len(mesh.visual.uv) == len(mesh.vertices) + ): + # get an array with vertices and UV coordinates + # converted to integers at requested precision + stacked.append(mesh.visual.uv * (10**digits_uv)) + + # check to see if we have vertex normals + normals = mesh._cache["vertex_normals"] + if not merge_norm and np.shape(normals) == mesh.vertices.shape: + stacked.append(normals * (10**digits_norm)) + + # stack collected vertex properties and round to integer + stacked = np.column_stack(stacked).round().astype(np.int64) + + # check unique rows of referenced vertices + u, i = unique_rows(stacked[referenced], keep_order=True) + + # construct an inverse using the subset + inverse = np.zeros(len(mesh.vertices), dtype=np.int64) + inverse[referenced] = i + # get the vertex mask + mask = np.nonzero(referenced)[0][u] + # run the update including normals and UV coordinates + mesh.update_vertices(mask=mask, inverse=inverse) + + +def group(values, min_len: Integer | None = None, max_len: Integer | None = None): + """ + Return the indices of values that are identical + + Parameters + ---------- + values : (n,) int + Values to group + min_len : int + The shortest group allowed + All groups will have len >= min_length + max_len : int + The longest group allowed + All groups will have len <= max_length + + Returns + ---------- + groups : sequence + Contains indices to form groups + IE [0,1,0,1] returns [[0,2], [1,3]] + """ + original = np.asanyarray(values) + + # save the sorted order and then apply it + order = original.argsort() + values = original[order] + + # find the indexes which are duplicates + if values.dtype.kind == "f": + # for floats in a sorted array, neighbors are not duplicates + # if the difference between them is greater than approximate zero + nondupe = np.greater(np.abs(np.diff(values)), tol.zero) + else: + # for ints and strings we can check exact non- equality + # for all other types this will only work if they defined + # an __eq__ + nondupe = values[1:] != values[:-1] + + dupe_idx = np.append(0, np.nonzero(nondupe)[0] + 1) + + # start with a mask that marks everything as ok + dupe_ok = np.ones(len(dupe_idx), dtype=bool) + + # calculate the length of each group from their index + dupe_len = np.diff(np.concatenate((dupe_idx, [len(values)]))) + + # cull by length if requested + if min_len is not None or max_len is not None: + if min_len is not None: + dupe_ok &= dupe_len >= min_len + if max_len is not None: + dupe_ok &= dupe_len <= max_len + + groups = [order[i : (i + j)] for i, j in zip(dupe_idx[dupe_ok], dupe_len[dupe_ok])] + return groups + + +def hashable_rows( + data: ArrayLike, digits: Integer | None = None, allow_int: bool = True +) -> NDArray: + """ + We turn our array into integers based on the precision + given by digits and then put them in a hashable format. + + Parameters + --------- + data : (n, m) array + Input data + digits : int or None + How many digits to add to hash if data is floating point + If None, tol.merge will be used + + Returns + --------- + hashable : (n,) + May return as a `np.void` or a `np.uint64` + """ + # if there is no data return immediately + if len(data) == 0: + return np.array([], dtype=np.uint64) + + # get array as integer to precision we care about + as_int = float_to_int(data, digits=digits) + + # if it is flat integers already return + if len(as_int.shape) == 1: + return as_int + + # rows without any columns are all identical: return a constant per row + # rather than dividing by the column count below + if as_int.shape[1] == 0: + return np.zeros(len(as_int), dtype=np.uint64) + + # if array is 2D and smallish, we can try bitbanging + # this is significantly faster than the custom dtype + if allow_int and len(as_int.shape) == 2 and as_int.shape[1] <= 4: + # can we pack the whole row into a single 64 bit integer + precision = int(np.floor(64 / as_int.shape[1])) + + # get the extreme values of the data set + d_min, d_max = as_int.min(), as_int.max() + # since we are quantizing the data down we need every value + # to fit in a partial integer so we have to check against extrema + threshold = (2 ** (precision - 1)) - 1 + + # if the data is within the range of our precision threshold + if d_max < threshold and d_min > -threshold: + # the resulting package + hashable = np.zeros(len(as_int), dtype=np.uint64) + # offset to the middle of the unsigned integer range + # this array should contain only positive values + bitbang = (as_int.T + (threshold + 1)).astype(np.uint64) + # loop through each column and bitwise xor to combine + # make sure as_int is int64 otherwise bit offset won't work + for offset, column in enumerate(bitbang): + # will modify hashable in place + np.bitwise_xor(hashable, column << (offset * precision), out=hashable) + return hashable + + # reshape array into magical data type that is weird but works with unique + dtype = np.dtype((np.void, as_int.dtype.itemsize * as_int.shape[1])) + # make sure result is contiguous and flat + result = np.ascontiguousarray(as_int).view(dtype).reshape(-1) + result.flags["WRITEABLE"] = False + + return result + + +def float_to_int(data, digits: Integer | None = None) -> NDArray[np.int64]: + """ + Given a numpy array of float/bool/int, return as integers. + + Parameters + ------------- + data : (n, d) float, int, or bool + Input data + digits : float or int + Precision for float conversion + + Returns + ------------- + as_int : (n, d) int + Data as integers + """ + # convert to any numpy array + data = np.asanyarray(data) + + # we can early-exit if we've been passed data that is already + # an integer, unsigned integer, boolean, or empty + if data.dtype == np.int64: + return data + elif data.dtype.kind in "iub" or data.size == 0: + return data.astype(np.int64) + elif data.dtype.kind != "f": + # if it's not a floating point try to make it one + data = data.astype(np.float64) + + if digits is None: + # get digits from `tol.merge` + digits = util.decimal_to_digits(tol.merge) + elif not isinstance(digits, (int, np.integer)): + raise TypeError(f"Digits must be `None` or `int`, not `{type(digits)}`") + + # multiply by requested power of ten + # then subtract small epsilon to avoid "go either way" rounding + # then do the rounding and convert to integer + return np.round((data * 10**digits) - 1e-6).astype(np.int64) + + +def unique_ordered( + data: ArrayLike, return_index: bool = False, return_inverse: bool = False +): + """ + Returns the same as np.unique, but ordered as per the + first occurrence of the unique value in data. + + Examples + --------- + In [1]: a = [0, 3, 3, 4, 1, 3, 0, 3, 2, 1] + + In [2]: np.unique(a) + Out[2]: array([0, 1, 2, 3, 4]) + + In [3]: trimesh.grouping.unique_ordered(a) + Out[3]: array([0, 3, 4, 1, 2]) + """ + # uniques are the values, sorted + # index is the value in the original `data` + # i.e. `data[index] == unique` + # inverse is how to re-construct `data` from `unique` + # i.e. `unique[inverse] == data` + unique, index, inverse = np.unique(data, return_index=True, return_inverse=True) + + # we want to maintain the original index order + order = index.argsort() + + if not return_index and not return_inverse: + return unique[order] + + # collect return values + # start with the unique values in original order + result = [unique[order]] + # the new index values + if return_index: + # re-order the index in the original array + result.append(index[order]) + if return_inverse: + # create the new inverse from the order of the order + result.append(order.argsort()[inverse]) + + return result + + +def unique_bincount( + values: ArrayLike, + minlength: Integer = 0, + return_inverse: bool = False, + return_counts: bool = False, +): + """ + For arrays of integers find unique values using bin counting. + Roughly 10x faster for correct input than np.unique + + Parameters + -------------- + values : (n,) int + Values to find unique members of + minlength : int + Maximum value that will occur in values (values.max()) + return_inverse : bool + If True, return an inverse such that unique[inverse] == values + return_counts : bool + If True, also return the number of times each + unique item appears in values + + Returns + ------------ + unique : (m,) int + Unique values in original array + inverse : (n,) int, optional + An array such that unique[inverse] == values + Only returned if return_inverse is True + counts : (m,) int, optional + An array holding the counts of each unique item in values + Only returned if return_counts is True + """ + values = np.asanyarray(values) + if len(values.shape) != 1 or values.dtype.kind != "i": + raise ValueError("input must be 1D integers!") + + try: + # count the number of occurrences of each value + counts = np.bincount(values, minlength=minlength) + except TypeError: + # casting failed on 32 bit windows + log.warning("casting failed, falling back!") + # fall back to numpy unique + return np.unique( + values, return_inverse=return_inverse, return_counts=return_counts + ) + + # which bins are occupied at all + # counts are integers so this works + unique_bin = counts.astype(bool) + + # which values are unique + # indexes correspond to original values + unique = np.where(unique_bin)[0] + ret = (unique,) + + if return_inverse: + # find the inverse to reconstruct original + inverse = (np.cumsum(unique_bin) - 1)[values] + ret += (inverse,) + + if return_counts: + unique_counts = counts[unique] + ret += (unique_counts,) + + if len(ret) == 1: + return ret[0] + return ret + + +def merge_runs(data: ArrayLike, digits: Integer | None = None): + """ + Merge duplicate sequential values. This differs from unique_ordered + in that values can occur in multiple places in the sequence, but + only consecutive repeats are removed + + Parameters + ----------- + data: (n,) float or int + + Returns + -------- + merged: (m,) float or int + + Examples + --------- + In [1]: a + Out[1]: + array([-1, -1, -1, 0, 0, 1, 1, 2, 0, + 3, 3, 4, 4, 5, 5, 6, 6, 7, + 7, 8, 8, 9, 9, 9]) + + In [2]: trimesh.grouping.merge_runs(a) + Out[2]: array([-1, 0, 1, 2, 0, 3, 4, 5, 6, 7, 8, 9]) + """ + if digits is None: + epsilon = tol.merge + else: + epsilon = 10 ** (-digits) + + data = np.asanyarray(data) + mask = np.zeros(len(data), dtype=bool) + mask[0] = True + mask[1:] = np.abs(data[1:] - data[:-1]) > epsilon + + return data[mask] + + +def unique_float( + data, + return_index: bool = False, + return_inverse: bool = False, + digits: Integer | None = None, +): + """ + Identical to the numpy.unique command, except evaluates floating point + numbers, using a specified number of digits. + + If digits isn't specified, the library default TOL_MERGE will be used. + """ + data = np.asanyarray(data) + as_int = float_to_int(data, digits) + _junk, unique, inverse = np.unique(as_int, return_index=True, return_inverse=True) + + if (not return_index) and (not return_inverse): + return data[unique] + + result = [data[unique]] + + if return_index: + result.append(unique) + if return_inverse: + result.append(inverse) + return tuple(result) + + +def unique_rows(data, digits=None, keep_order=False): + """ + Returns indices of unique rows. It will return the + first occurrence of a row that is duplicated: + [[1,2], [3,4], [1,2]] will return [0,1] + + Parameters + --------- + data : (n, m) array + Floating point data + digits : int or None + How many digits to consider + + Returns + -------- + unique : (j,) int + Index in data which is a unique row + inverse : (n,) int + Array to reconstruct original + Example: data[unique][inverse] == data + """ + # get rows hashable so we can run unique function on it + rows = hashable_rows(data, digits=digits) + + # we are throwing away the first value which is the + # garbage row-hash and only returning index and inverse + if keep_order: + # keeps order of original occurrence + return unique_ordered(rows, return_index=True, return_inverse=True)[1:] + # returns values sorted by row-hash but since our row-hash + # were pretty much garbage the sort order isn't meaningful + return np.unique(rows, return_index=True, return_inverse=True)[1:] + + +def unique_value_in_row(data, unique=None): + """ + For a 2D array of integers find the position of a + value in each row which only occurs once. + + If there are more than one value per row which + occur once, the last one is returned. + + Parameters + ---------- + data : (n, d) int + Data to check values + unique : (m,) int + List of unique values contained in data. + Generated from np.unique if not passed + + Returns + --------- + result : (n, d) bool + With one or zero True values per row. + + + Examples + ------------------------------------- + In [0]: r = np.array([[-1, 1, 1], + [-1, 1, -1], + [-1, 1, 1], + [-1, 1, -1], + [-1, 1, -1]], dtype=np.int8) + + In [1]: unique_value_in_row(r) + Out[1]: + array([[ True, False, False], + [False, True, False], + [ True, False, False], + [False, True, False], + [False, True, False]], dtype=bool) + + In [2]: unique_value_in_row(r).sum(axis=1) + Out[2]: array([1, 1, 1, 1, 1]) + + In [3]: r[unique_value_in_row(r)] + Out[3]: array([-1, 1, -1, 1, 1], dtype=int8) + """ + if unique is None: + unique = np.unique(data) + data = np.asanyarray(data) + result = np.zeros_like(data, dtype=bool, subok=False) + for value in unique: + test = np.equal(data, value) + test_ok = test.sum(axis=1) == 1 + result[test_ok] = test[test_ok] + return result + + +def group_rows(data, require_count=None, digits=None): + """ + Returns index groups of duplicate rows, for example: + [[1,2], [3,4], [1,2]] will return [[0,2], [1]] + + + Note that using require_count allows numpy advanced + indexing to be used in place of looping and + checking hashes and is ~10x faster. + + + Parameters + ---------- + data : (n, m) array + Data to group + require_count : None or int + Only return groups of a specified length, eg: + require_count = 2 + [[1,2], [3,4], [1,2]] will return [[0,2]] + digits : None or int + If data is floating point how many decimals + to consider, or calculated from tol.merge + + Returns + ---------- + groups : sequence (*,) int + Indices from in indicating identical rows. + """ + + # start with getting a sortable format + hashable = hashable_rows(data, digits=digits) + + # if there isn't a constant column size use more complex logic + if require_count is None: + return group(hashable) + + # record the order of the rows so we can get the original indices back + order = hashable.argsort() + # but for now, we want our hashes sorted + hashable = hashable[order] + # this is checking each neighbour for equality, example: + # example: hashable = [1, 1, 1]; dupe = [0, 0] + dupe = hashable[1:] != hashable[:-1] + # we want the first index of a group, so we can slice from that location + # example: hashable = [0 1 1]; dupe = [1,0]; dupe_idx = [0,1] + dupe_idx = np.append(0, np.nonzero(dupe)[0] + 1) + # if you wanted to use this one function to deal with non- regular groups + # you could use: np.array_split(dupe_idx) + # this is roughly 3x slower than using the group_dict method above. + start_ok = np.diff(np.concatenate((dupe_idx, [len(hashable)]))) == require_count + groups = np.tile(dupe_idx[start_ok].reshape((-1, 1)), require_count) + np.arange( + require_count + ) + groups_idx = order[groups] + + if require_count == 1: + return groups_idx.reshape(-1) + return groups_idx + + +def boolean_rows( + a: ArrayLike, b: ArrayLike, operation=np.intersect1d +) -> NDArray[np.int64]: + """ + Find the rows in two arrays which occur in both rows. + + Parameters + --------- + a: (n, d) int + Array with row vectors + b: (m, d) int + Array with row vectors + operation : function + Numpy boolean set operation function: + -np.intersect1d + -np.setdiff1d + + Returns + -------- + shared : (p, d) int64 + Array containing requested rows in both a and b + """ + a = np.asanyarray(a, dtype=np.int64) + b = np.asanyarray(b, dtype=np.int64) + + av = a.view([("", a.dtype)] * a.shape[1]).ravel() + bv = b.view([("", b.dtype)] * b.shape[1]).ravel() + return operation(av, bv).view(a.dtype).reshape(-1, a.shape[1]) + + +def group_vectors(vectors, angle=1e-4, include_negative=False): + """ + Group vectors based on an angle tolerance, with the option to + include negative vectors. + + Parameters + ----------- + vectors : (n,3) float + Direction vector + angle : float + Group vectors closer than this angle in radians + include_negative : bool + If True consider the same: + [0,0,1] and [0,0,-1] + + Returns + ------------ + new_vectors : (m,3) float + Direction vector + groups : (m,) sequence of int + Indices of source vectors + """ + + vectors = np.asanyarray(vectors, dtype=np.float64) + angle = float(angle) + + if include_negative: + vectors = util.vector_hemisphere(vectors) + + spherical = util.vector_to_spherical(vectors) + angles, groups = group_distance(spherical, angle) + new_vectors = util.spherical_to_vector(angles) + return new_vectors, groups + + +def group_distance( + values: ArrayLike, distance: Number +) -> tuple[NDArray[np.float64], Sequence]: + """ + Find non-overlapping groups of points where no two points in a + group are farther than 2*distance apart. + + Parameters + --------- + values : (n, d) float + Points of dimension d + distance : float + Max distance between points in a cluster + + Returns + ---------- + unique : (m, d) float + Median value of each group + groups : (m) sequence of int + Indexes of points that make up a group + + """ + values = np.asanyarray(values, dtype=np.float64) + + consumed = np.zeros(len(values), dtype=bool) + tree = cKDTree(values) + + # (n, d) set of values that are unique + unique = [] + # (n) sequence of indices in values + groups = [] + + for index, value in enumerate(values): + if consumed[index]: + continue + group = np.array(tree.query_ball_point(value, distance), dtype=np.int64) + group = group[~consumed[group]] + consumed[group] = True + unique.append(np.median(values[group], axis=0)) + groups.append(group) + return np.array(unique), groups + + +def clusters(points, radius): + """ + Find clusters of points which have neighbours closer than radius + + Parameters + --------- + points : (n, d) float + Points of dimension d + radius : float + Max distance between points in a cluster + + Returns + ---------- + groups : (m,) sequence of int + Indices of points in a cluster + + """ + from . import graph + + tree = cKDTree(points) + + # some versions return pairs as a set of tuples + pairs = tree.query_pairs(r=radius, output_type="ndarray") + # group connected components + groups = graph.connected_components(pairs) + + return groups + + +def blocks(data, min_len=2, max_len=np.inf, wrap=False, digits=None, only_nonzero=False): + """ + Find the indices in an array of contiguous blocks + of equal values. + + Parameters + ------------ + data : (n,) array + Data to find blocks on + min_len : int + The minimum length group to be returned + max_len : int + The maximum length group to be retuurned + wrap : bool + Combine blocks on both ends of 1D array + digits : None or int + If dealing with floats how many digits to consider + only_nonzero : bool + Only return blocks of non- zero values + + Returns + --------- + blocks : (m) sequence of (*,) int + Indices referencing data + """ + data = float_to_int(data, digits=digits) + + # keep an integer range around so we can slice + arange = np.arange(len(data)) + arange.flags["WRITEABLE"] = False + + nonzero = arange[1:][data[1:] != data[:-1]] + infl = np.zeros(len(nonzero) + 2, dtype=int) + infl[-1] = len(data) + infl[1:-1] = nonzero + + # the length of each chunk + infl_len = infl[1:] - infl[:-1] + + # check the length of each group + infl_ok = np.logical_and(infl_len >= min_len, infl_len <= max_len) + + if only_nonzero: + # check to make sure the values of each contiguous block + # are True by checking the first value of each block + infl_ok = np.logical_and(infl_ok, data[infl[:-1]]) + + # inflate start/end indexes into full ranges of values + blocks = [arange[infl[i] : infl[i + 1]] for i, ok in enumerate(infl_ok) if ok] + + if wrap: + # wrap only matters if first and last points are the same + if data[0] != data[-1]: + return blocks + # if we are only grouping nonzero things and + # the first and last point are zero we can exit + if only_nonzero and not bool(data[0]): + return blocks + + # if all values are True or False we can exit + if len(blocks) == 1 and len(blocks[0]) == len(data): + return blocks + + # so now first point equals last point, so the cases are: + # - first and last point are in a block: combine two blocks + # - first OR last point are in block: add other point to block + # - neither are in a block: check if combined is eligible block + + # first point is in a block + first = len(blocks) > 0 and blocks[0][0] == 0 + # last point is in a block + last = len(blocks) > 0 and blocks[-1][-1] == (len(data) - 1) + + # CASE: first and last point are BOTH in block: combine blocks + if first and last: + blocks[0] = np.append(blocks[-1], blocks[0]) + blocks.pop() + else: + # combined length + combined = infl_len[0] + infl_len[-1] + # exit if lengths aren't OK + if combined < min_len or combined > max_len: + return blocks + # new block combines both ends + new_block = np.append( + np.arange(infl[-2], infl[-1]), np.arange(infl[0], infl[1]) + ) + # we are in a first OR last situation now + if first: + # first was already in a block so replace it with combined + blocks[0] = new_block + elif last: + # last was already in a block so replace with superset + blocks[-1] = new_block + else: + # both are false + # combined length generated new block + blocks.append(new_block) + + return blocks + + +def group_min(groups, data): + """ + Given a list of groups find the minimum element of data + within each group + + Parameters + ----------- + groups : (n,) sequence of (q,) int + Indexes of each group corresponding to each element in data + data : (m,) + The data that groups indexes reference + + Returns + ----------- + minimums : (n,) + Minimum value of data per group + + """ + # sort with major key groups, minor key data + order = np.lexsort((data, groups)) + groups = groups[order] # this is only needed if groups is unsorted + data = data[order] + # construct an index which marks borders between groups + index = np.zeros(len(groups), "bool") + index[0] = True + index[1:] = groups[1:] != groups[:-1] + return data[index] diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/inertia.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/inertia.py new file mode 100644 index 0000000000000000000000000000000000000000..b31e32710db5de9d0d17dda3d20d6e04b8e3d746 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/inertia.py @@ -0,0 +1,363 @@ +""" +inertia.py +------------- + +Functions for dealing with inertia tensors. + +Results validated against known geometries and checked for +internal consistency. +""" + +import numpy as np + +from .typed import ArrayLike, NDArray, Number, float64 +from .util import multi_dot + + +def cylinder_inertia( + mass: Number, radius: Number, height: Number, transform: ArrayLike | None = None +) -> NDArray[float64]: + """ + Return the inertia tensor of a cylinder. + + Parameters + ------------ + mass : float + Mass of cylinder + radius : float + Radius of cylinder + height : float + Height of cylinder + transform : (4, 4) float + Transformation of cylinder + + Returns + ------------ + inertia : (3, 3) float + Inertia tensor + """ + h2, r2 = height**2, radius**2 + diagonal = np.array( + [ + ((mass * h2) / 12) + ((mass * r2) / 4), + ((mass * h2) / 12) + ((mass * r2) / 4), + (mass * r2) / 2, + ] + ) + inertia = diagonal * np.eye(3) + + if transform is not None: + inertia = transform_inertia(transform, inertia) + + return inertia + + +def sphere_inertia(mass: Number, radius: Number) -> NDArray[float64]: + """ + Return the inertia tensor of a sphere. + + Parameters + ------------ + mass : float + Mass of sphere + radius : float + Radius of sphere + + Returns + ------------ + inertia : (3, 3) float + Inertia tensor + """ + return (2.0 / 5.0) * (radius**2) * mass * np.eye(3) + + +def points_inertia( + points: ArrayLike, + weights: ArrayLike | Number | None = None, + at_center_mass: bool = True, +) -> NDArray[float64]: + """ + Calculate an inertia tensor for an array of point masses + at the center of mass. + + Parameters + ---------- + points : (n, 3) + Points in space. + weights : (n,) or number + Per-point weight to use. + at_center_mass + Calculate at the center of mass of the points, or if False + at the original origin. + + Returns + ----------- + tensor : (3, 3) + Inertia tensor for point masses. + """ + if weights is None: + # by default make the total weight 1.0 to match + # the default mass in other functions, and so that + # if a user didn't specify anything it doesn't blow + # up the scale depending on the number of points + weights = np.full(len(points), 1.0 / float(len(points)), dtype=np.float64) + elif isinstance(weights, (float, np.integer, int)): + # "is it a number" check + weights = np.full(len(points), float(weights), dtype=np.float64) + else: + weights = np.array(weights) + if len(weights) != len(points): + raise ValueError( + f"Weights must correspond to points! {len(weights)} != {len(points)}" + ) + + # make sure the points are an array of correct shape + points = np.asanyarray(points, dtype=np.float64) + if len(points.shape) != 2 or points.shape[1] != 3: + raise ValueError(f"Points must be `(n, 3)` not {points.shape}") + + if at_center_mass: + # get the center of mass of the points + center_mass = np.average(points, weights=weights, axis=0) + # get the points with the origin at their center of mass + points_com = points - center_mass + else: + # calculate at original origin + points_com = points + + # expand into shorthand for the expressions + x, y, z = points_com.T + x2, y2, z2 = (points_com**2).T + + # calculate tensors per-point in a flattened (9, n) array + # from physics.stackexchange.com/questions/614094 + tensors = np.array( + [y2 + z2, -x * y, -x * z, -x * y, x2 + z2, -y * z, -x * z, -y * z, x2 + y2], + dtype=np.float64, + ) + + # combine the weighted tensors and reshape + tensor = (tensors * weights).sum(axis=1).reshape((3, 3)) + + return tensor + + +def principal_axis(inertia: ArrayLike): + """ + Find the principal components and principal axis + of inertia from the inertia tensor. + + Parameters + ------------ + inertia : (3, 3) float + Inertia tensor + + Returns + ------------ + components : (3,) float + Principal components of inertia + vectors : (3, 3) float + Row vectors pointing along the + principal axes of inertia + """ + inertia = np.asanyarray(inertia, dtype=np.float64) + if inertia.shape != (3, 3): + raise ValueError("inertia tensor must be (3, 3)!") + + # you could any of the following to calculate this: + # np.linalg.svd, np.linalg.eig, np.linalg.eigh + # moment of inertia is square symmetric matrix + # eigh has the best precision in tests + components, vectors = np.linalg.eigh(inertia) + + # eigh returns them as column vectors, change them to row vectors + vectors = vectors.T + + return components, vectors + + +def transform_inertia( + transform: ArrayLike, + inertia_tensor: ArrayLike, + parallel_axis: bool = False, + mass: Number | None = None, +): + """ + Transform an inertia tensor to a new frame. + + Note that in trimesh `mesh.moment_inertia` is *axis aligned* + and at `mesh.center_mass`. + + So to transform to a new frame and get the moment of inertia at + the center of mass the translation should be ignored and only + rotation applied. + + If parallel axis is enabled it will compute the inertia + about a new location. + + More details in the MIT OpenCourseWare PDF: + ` MIT16_07F09_Lec26.pdf` + + + Parameters + ------------ + transform : (3, 3) or (4, 4) float + Transformation matrix + inertia_tensor : (3, 3) float + Inertia tensor. + parallel_axis : bool + Apply the parallel axis theorum or not. + If the passed inertia tensor is at the center of mass + and you want the new post-transform tensor also at the + center of mass you DON'T want this enabled as you *only* + want to apply the rotation. Use this to get moment of + inertia at an arbitrary frame that isn't the center of mass. + + Returns + ------------ + transformed : (3, 3) float + Inertia tensor in new frame. + """ + # check inputs and extract rotation + transform = np.asanyarray(transform, dtype=np.float64) + if transform.shape == (4, 4): + rotation = transform[:3, :3] + elif transform.shape == (3, 3): + rotation = transform + else: + raise ValueError("transform must be (3, 3) or (4, 4)!") + + inertia_tensor = np.asanyarray(inertia_tensor, dtype=np.float64) + if inertia_tensor.shape != (3, 3): + raise ValueError("inertia_tensor must be (3, 3)!") + + if parallel_axis: + if transform.shape == (3, 3): + # shorthand for "translation" + a = np.zeros(3, dtype=np.float64) + else: + # get the translation + a = transform[:3, 3] + # First the changed origin of the new transform is taken into + # account. To calculate the inertia tensor + # the parallel axis theorem is used + M = np.array( + [ + [a[1] ** 2 + a[2] ** 2, -a[0] * a[1], -a[0] * a[2]], + [-a[0] * a[1], a[0] ** 2 + a[2] ** 2, -a[1] * a[2]], + [-a[0] * a[2], -a[1] * a[2], a[0] ** 2 + a[1] ** 2], + ] + ) + aligned_inertia = inertia_tensor + mass * M + + return multi_dot([rotation.T, aligned_inertia, rotation]) + + return multi_dot([rotation, inertia_tensor, rotation.T]) + + +def radial_symmetry(mesh): + """ + Check whether a mesh has radial symmetry. + + Returns + ----------- + symmetry : None or str + None No rotational symmetry + 'radial' Symmetric around an axis + 'spherical' Symmetric around a point + axis : None or (3,) float + Rotation axis or point + section : None or (3, 2) float + If radial symmetry provide vectors + to get cross section + """ + + # shortcuts to avoid typing and hitting cache + scalar = mesh.principal_inertia_components.copy() + + # exit early if inertia components are all zero + if (scalar < 1e-30).any(): + return None, None, None + + # normalize the PCI so we can compare them + scalar = scalar / np.linalg.norm(scalar) + vector = mesh.principal_inertia_vectors + # the sorted order of the principal components + order = scalar.argsort() + + # we are checking if a geometry has radial symmetry + # if 2 of the PCI are equal, it is a revolved 2D profile + # if 3 of the PCI (all of them) are equal it is a sphere + diff = np.abs(np.diff(scalar[order])) + # diffs that are within tol of zero + diff_zero = diff < 1e-4 + + if diff_zero.all(): + # this is the case where all 3 PCI are identical + # this means that the geometry is symmetric about a point + # examples of this are a sphere, icosahedron, etc + axis = vector[0] + section = vector[1:] + + return "spherical", axis, section + + elif diff_zero.any(): + # this is the case for 2/3 PCI are identical + # this means the geometry is symmetric about an axis + # probably a revolved 2D profile + + # we know that only 1/2 of the diff values are True + # if the first diff is 0, it means if we take the first element + # in the ordered PCI we will have one of the non- revolve axis + # if the second diff is 0, we take the last element of + # the ordered PCI for the section axis + # if we wanted the revolve axis we would just switch [0,-1] to + # [-1,0] + + # since two vectors are the same, we know the middle + # one is one of those two + section_index = order[np.array([[0, 1], [1, -1]])[diff_zero]].flatten() + section = vector[section_index] + + # we know the rotation axis is the sole unique value + # and is either first or last of the sorted values + axis_index = order[np.array([-1, 0])[diff_zero]][0] + axis = vector[axis_index] + return "radial", axis, section + + return None, None, None + + +def scene_inertia(scene, transform: ArrayLike | None = None) -> NDArray[float64]: + """ + Calculate the inertia of a scene about a specific frame. + + Parameters + ------------ + scene : trimesh.Scene + Scene with geometry. + transform : None or (4, 4) float + Homogeneous transform to compute inertia at. + + Returns + ---------- + moment : (3, 3) + Inertia tensor about requested frame + """ + # shortcuts for tight loop + graph = scene.graph + geoms = scene.geometry + + # get the matrix ang geometry name for + nodes = [graph[n] for n in graph.nodes_geometry] + # get the moment of inertia with the mesh moved to a location + moments = np.array( + [ + geoms[g].moment_inertia_frame(np.dot(np.linalg.inv(mat), transform)) + for mat, g in nodes + if hasattr(geoms[g], "moment_inertia_frame") + ], + dtype=np.float64, + ) + + return moments.sum(axis=0) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..523f2db03d274e1dc4ce940f55b63fe7ca4e9fa0 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/__init__.py @@ -0,0 +1,3 @@ +from . import blender + +__all__ = ["blender"] diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ced4f44201b45adfd63273d52747b068a8f65bec Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/__pycache__/blender.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/__pycache__/blender.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e68ca04a4bd1606ab747f290a9f4548a60a696f4 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/__pycache__/blender.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/__pycache__/generic.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/__pycache__/generic.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f4b71ce2c7fc640ebcee53e0e1e54c31dacd6d63 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/__pycache__/generic.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/blender.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/blender.py new file mode 100644 index 0000000000000000000000000000000000000000..151935bec50691f4dc47deba76a4203ab750b3f1 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/blender.py @@ -0,0 +1,142 @@ +import os +import platform + +from .. import util +from ..constants import log +from ..resources import get_string +from ..typed import BooleanOperationType, Iterable +from .generic import MeshScript + +if platform.system() == "Windows": + # try to find Blender install on Windows + # split existing path by delimiter + _search_path = [i for i in os.environ.get("PATH", "").split(";") if len(i) > 0] + for pf in [r"C:\Program Files", r"C:\Program Files (x86)"]: + pf = os.path.join(pf, "Blender Foundation") + if os.path.exists(pf): + for p in os.listdir(pf): + if "Blender" in p: + _search_path.append(os.path.join(pf, p)) + _search_path = ";".join(set(_search_path)) + log.debug("searching for blender in: %s", _search_path) +elif platform.system() == "Darwin": + # try to find Blender on Mac OSX + _search_path = [i for i in os.environ.get("PATH", "").split(":") if len(i) > 0] + _search_path.extend( + [ + "/Applications/blender.app/Contents/MacOS", + "/Applications/Blender.app/Contents/MacOS", + "/Applications/Blender/blender.app/Contents/MacOS", + ] + ) + _search_path = ":".join(set(_search_path)) + log.debug("searching for blender in: %s", _search_path) +else: + _search_path = os.environ.get("PATH", "") + +_blender_executable = util.which("blender", path=_search_path) +exists = _blender_executable is not None + +# a map that translates: +# `trimesh.BooleanOperationType` -> blender value +_blender_bool = { + "union": "UNION", + "difference": "DIFFERENCE", + "intersection": "INTERSECT", +} + + +def boolean( + meshes: Iterable, + operation: BooleanOperationType = "difference", + use_exact: bool = True, + use_self: bool = False, + debug: bool = False, + check_volume: bool = True, +): + """ + Run a boolean operation with multiple meshes using Blender. + + Parameters + ----------- + meshes + List of mesh objects to be operated on + operation + Type of boolean operation ("difference", "union", "intersect"). + use_exact + Use the "exact" mode as opposed to the "fast" mode. + use_self + Whether to consider self-intersections. + debug + Provide additional output for troubleshooting. + check_volume + Raise an error if not all meshes are watertight + positive volumes. Advanced users may want to ignore + this check as it is expensive. + + Returns + ---------- + result + The result of the boolean operation on the provided meshes. + """ + if not exists: + raise ValueError("No blender available!") + if check_volume and not all(m.is_volume for m in meshes): + raise ValueError("Not all meshes are volumes!") + + # conversions from the trimesh `BooleanOperationType` to the blender option + key = operation.lower().strip() + if key not in _blender_bool: + raise ValueError( + f"`{operation}` is not a valid boolean: `{_blender_bool.keys()}`" + ) + + if use_exact: + solver_options = "EXACT" + else: + solver_options = "FAST" + + # get the template from our resources folder + template = get_string("templates/blender_boolean.py.tmpl") + # use string substitutions rather than `string.Template` as we aren't going + # to be filling in all the values here, `MeshScript` is going to be + # the source of `$MESH_PRE`, etc. + script = ( + template.replace("$OPERATION", _blender_bool[key]) + .replace("$SOLVER_OPTIONS", solver_options) + .replace("$USE_SELF", f"{use_self}") + ) + with MeshScript(meshes=meshes, script=script, debug=debug) as blend: + result = blend.run(_blender_executable + " --background --python $SCRIPT") + + result = util.make_sequence(result) + for m in result: + # blender returns actively incorrect face normals + m.face_normals = None + + return util.concatenate(result) + + +def unwrap( + mesh, angle_limit: float = 66.0, island_margin: float = 0.0, debug: bool = False +): + """ + Run an unwrap operation using blender. + """ + if not exists: + raise ValueError("No blender available!") + + # get the template from our resources folder + template = get_string("templates/blender_unwrap.py.template") + script = template.replace("$ANGLE_LIMIT", f"{angle_limit:.6f}").replace( + "$ISLAND_MARGIN", f"{island_margin:.6f}" + ) + + with MeshScript(meshes=[mesh], script=script, exchange="obj", debug=debug) as blend: + result = blend.run(_blender_executable + " --background --python $SCRIPT") + + for m in util.make_sequence(result): + # blender returns actively incorrect face normals + m.face_normals = None + + return result diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/generic.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/generic.py new file mode 100644 index 0000000000000000000000000000000000000000..cd2787ebf2688187b13cd4a0155047ff3a1bc566 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/generic.py @@ -0,0 +1,101 @@ +import os +import platform +import subprocess +from string import Template +from subprocess import CalledProcessError, check_output +from tempfile import NamedTemporaryFile + +from .. import exchange +from ..util import log + + +class MeshScript: + def __init__(self, meshes, script, exchange="stl", debug=False, **kwargs): + self.debug = debug + self.kwargs = kwargs + self.meshes = meshes + self.script = script + self.exchange = exchange + + def __enter__(self): + # windows has problems with multiple programs using open files so we close + # them at the end of the enter call, and delete them ourselves at exit + # Blender sorts its objects alphabetically + # so prefix the mesh number on the file name + digit_count = len(str(len(self.meshes))) + self.mesh_pre = [ + NamedTemporaryFile( + suffix=f".{self.exchange}", + prefix=f"{str(i).zfill(digit_count)}_", + mode="wb", + delete=False, + ) + for i in range(len(self.meshes)) + ] + self.mesh_post = NamedTemporaryFile( + suffix=f".{self.exchange}", mode="rb", delete=False + ) + self.script_out = NamedTemporaryFile(mode="wb", delete=False) + + # export the meshes to a temporary STL container + for mesh, file_obj in zip(self.meshes, self.mesh_pre): + mesh.export(file_obj=file_obj.name) + + self.replacement = {"MESH_" + str(i): m.name for i, m in enumerate(self.mesh_pre)} + self.replacement["MESH_PRE"] = str([i.name for i in self.mesh_pre]) + self.replacement["MESH_POST"] = self.mesh_post.name + self.replacement["SCRIPT"] = self.script_out.name + + script_text = Template(self.script).substitute(self.replacement) + if platform.system() == "Windows": + script_text = script_text.replace("\\", "\\\\") + self.script_out.write(script_text.encode("utf-8")) + + # close all temporary files + self.script_out.close() + self.mesh_post.close() + for file_obj in self.mesh_pre: + file_obj.close() + return self + + def run(self, command): + # substitute per-token so a replacement containing whitespace + # stays a single argv entry + command_run = [ + Template(part).substitute(self.replacement) for part in command.split() + ] + # run the binary + startupinfo = None + if platform.system() == "Windows": + startupinfo = subprocess.STARTUPINFO() + startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW + + if self.debug: + log.info("executing: {}".format(" ".join(command_run))) + + try: + output = check_output( + command_run, stderr=subprocess.STDOUT, startupinfo=startupinfo + ) + except CalledProcessError as E: + # raise with the output from the process + raise RuntimeError(E.output.decode()) + + if self.debug: + log.info(output.decode()) + + # bring the binaries result back as a set of Trimesh kwargs + mesh_results = exchange.load.load_mesh(self.mesh_post.name, **self.kwargs) + + return mesh_results + + def __exit__(self, *args, **kwargs): + if self.debug: + log.info(f"MeshScript.debug: not deleting {self.script_out.name}") + return + # delete all the temporary files by name + # they are closed but their names are still available + os.remove(self.script_out.name) + for file_obj in self.mesh_pre: + os.remove(file_obj.name) + os.remove(self.mesh_post.name) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/intersections.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/intersections.py new file mode 100644 index 0000000000000000000000000000000000000000..0182e20f3ea0e2100044f284a5ede4da0b40e3b4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/intersections.py @@ -0,0 +1,805 @@ +""" +intersections.py +------------------ + +Primarily mesh-plane intersections (slicing). +""" + +import numpy as np + +from . import geometry, grouping, util +from . import transformations as tf +from . import triangles as tm +from .constants import tol +from .triangles import points_to_barycentric + + +def mesh_plane( + mesh, + plane_normal, + plane_origin, + return_faces=False, + local_faces=None, + cached_dots=None, +): + """ + Find a the intersections between a mesh and a plane, + returning a set of line segments on that plane. + + Parameters + --------- + mesh : Trimesh object + Source mesh to slice + plane_normal : (3,) float + Normal vector of plane to intersect with mesh + plane_origin : (3,) float + Point on plane to intersect with mesh + return_faces : bool + If True return face index each line is from + local_faces : None or (m,) int + Limit section to just these faces. + cached_dots : (n, 3) float + If an external function has stored dot + products pass them here to avoid recomputing. + + Returns + ---------- + lines : (m, 2, 3) float + List of 3D line segments in space. + face_index : (m,) int + Index of mesh.faces for each line + Only returned if return_faces was True + """ + + def triangle_cases(signs): + """ + Figure out which faces correspond to which intersection + case from the signs of the dot product of each vertex. + Does this by bitbang each row of signs into an 8 bit + integer. + + code : signs : intersects + 0 : [-1 -1 -1] : No + 2 : [-1 -1 0] : No + 4 : [-1 -1 1] : Yes; 2 on one side, 1 on the other + 6 : [-1 0 0] : Yes; one edge fully on plane + 8 : [-1 0 1] : Yes; one vertex on plane 2 on different sides + 12 : [-1 1 1] : Yes; 2 on one side, 1 on the other + 14 : [0 0 0] : No (on plane fully) + 16 : [0 0 1] : Yes; one edge fully on plane + 20 : [0 1 1] : No + 28 : [1 1 1] : No + + Parameters + ---------- + signs: (n,3) int, all values are -1,0, or 1 + Each row contains the dot product of all three vertices + in a face with respect to the plane + + Returns + --------- + basic : (n,) bool + Which faces are in the basic intersection case + one_vertex : (n,) bool + Which faces are in the one vertex case + one_edge : (n,) bool + Which faces are in the one edge case + """ + + signs_sorted = np.sort(signs, axis=1) + coded = np.zeros(len(signs_sorted), dtype=np.int8) + 14 + for i in range(3): + coded += signs_sorted[:, i] << 3 - i + + # one edge fully on the plane + # note that we are only accepting *one* of the on- edge cases, + # where the other vertex has a positive dot product (16) instead + # of both on- edge cases ([6, 16]) + # this is so that for regions that are co-planar with the the section plane + # we don't end up with an invalid boundary + key = np.zeros(29, dtype=bool) + key[16] = True + one_edge = key[coded] + + # one vertex on plane, other two on different sides + key[:] = False + key[8] = True + one_vertex = key[coded] + + # one vertex on one side of the plane, two on the other + key[:] = False + key[[4, 12]] = True + basic = key[coded] + + return basic, one_vertex, one_edge + + def handle_on_vertex(signs, faces, vertices): + # case where one vertex is on plane + # and two are on different sides + vertex_plane = faces[signs == 0] + edge_thru = faces[signs != 0].reshape((-1, 2)) + point_intersect, valid = plane_lines( + plane_origin, plane_normal, vertices[edge_thru.T], line_segments=False + ) + lines = np.column_stack((vertices[vertex_plane[valid]], point_intersect)).reshape( + (-1, 2, 3) + ) + return lines + + def handle_on_edge(signs, faces, vertices): + # case where two vertices are on the plane and one is off + edges = faces[signs == 0].reshape((-1, 2)) + points = vertices[edges] + return points + + def handle_basic(signs, faces, vertices): + # case where one vertex is on one side and two are on the other + unique_element = grouping.unique_value_in_row(signs, unique=[-1, 1]) + edges = np.column_stack( + ( + faces[unique_element], + faces[np.roll(unique_element, 1, axis=1)], + faces[unique_element], + faces[np.roll(unique_element, 2, axis=1)], + ) + ).reshape((-1, 2)) + intersections, valid = plane_lines( + plane_origin, plane_normal, vertices[edges.T], line_segments=False + ) + # since the data has been pre- culled, any invalid intersections at all + # means the culling was done incorrectly and thus things are broken + assert valid.all() + return intersections.reshape((-1, 2, 3)) + + # check input plane + plane_normal = np.asanyarray(plane_normal, dtype=np.float64) + plane_origin = np.asanyarray(plane_origin, dtype=np.float64) + if plane_origin.shape != (3,) or plane_normal.shape != (3,): + raise ValueError("Plane origin and normal must be (3,)!") + + if local_faces is None: + # do a cross section against all faces + faces = mesh.faces + else: + local_faces = np.asanyarray(local_faces, dtype=np.int64) + # only take the subset of faces if passed + faces = mesh.faces[local_faces] + + if cached_dots is not None: + dots = cached_dots + else: + # dot product of each vertex with the plane normal indexed by face + # so for each face the dot product of each vertex is a row + # shape is the same as mesh.faces (n,3) + dots = np.dot(mesh.vertices - plane_origin, plane_normal) + + # sign of the dot product is -1, 0, or 1 + # shape is the same as mesh.faces (n,3) + signs = np.zeros(len(mesh.vertices), dtype=np.int8) + signs[dots < -tol.merge] = -1 + signs[dots > tol.merge] = 1 + signs = signs[faces] + + # figure out which triangles are in the cross section, + # and which of the three intersection cases they are in + cases = triangle_cases(signs) + # handlers for each case + handlers = (handle_basic, handle_on_vertex, handle_on_edge) + + # the (m, 2, 3) line segments + lines = np.vstack( + [h(signs[c], faces[c], mesh.vertices) for c, h in zip(cases, handlers)] + ) + + if return_faces: + # everything that hit something + index = np.hstack([np.nonzero(c)[0] for c in cases]) + assert index.dtype.kind == "i" + if local_faces is None: + return lines, index + # we are considering a subset of faces + # so we need to take the indexes from original + return lines, local_faces[index] + return lines + + +def mesh_multiplane(mesh, plane_origin, plane_normal, heights): + """ + A utility function for slicing a mesh by multiple + parallel planes which caches the dot product operation. + + Parameters + ------------- + mesh : trimesh.Trimesh + Geometry to be sliced by planes + plane_origin : (3,) float + Point on a plane + plane_normal : (3,) float + Normal vector of plane + heights : (m,) float + Offset distances from plane to slice at: + at `height=0` it will be exactly on the passed plane. + + Returns + -------------- + lines : (m,) sequence of (n, 2, 2) float + Lines in space for m planes + to_3D : (m, 4, 4) float + Transform to move each section back to 3D + face_index : (m,) sequence of (n,) int + Indexes of mesh.faces for each segment + """ + # check input plane + plane_normal = util.unitize(plane_normal) + plane_origin = np.asanyarray(plane_origin, dtype=np.float64) + heights = np.asanyarray(heights, dtype=np.float64) + + # dot product of every vertex with plane + vertex_dots = np.dot(plane_normal, (mesh.vertices - plane_origin).T) + + # reconstruct transforms for each 2D section + base_transform = geometry.plane_transform(origin=plane_origin, normal=plane_normal) + base_transform = np.linalg.inv(base_transform) + + # alter translation Z inside loop + translation = np.eye(4) + + # store results + transforms = [] + face_index = [] + segments = [] + + # loop through user specified heights + for height in heights: + # offset the origin by the height + new_origin = plane_origin + (plane_normal * height) + # offset the dot products by height and index by faces + new_dots = vertex_dots - height + # run the intersection with the cached dot products + lines, index = mesh_plane( + mesh=mesh, + plane_origin=new_origin, + plane_normal=plane_normal, + return_faces=True, + cached_dots=new_dots, + ) + + # get the transforms to 3D space and back + translation[2, 3] = height + to_3D = np.dot(base_transform, translation) + to_2D = np.linalg.inv(to_3D) + transforms.append(to_3D) + + # transform points to 2D frame + lines_2D = tf.transform_points(lines.reshape((-1, 3)), to_2D) + + # if we didn't screw up the transform all + # of the Z values should be zero + # assert np.allclose(lines_2D[:, 2], 0.0) + + # reshape back in to lines and discard Z + lines_2D = lines_2D[:, :2].reshape((-1, 2, 2)) + # store (n, 2, 2) float lines + segments.append(lines_2D) + # store (n,) int indexes of mesh.faces + face_index.append(index) + + # (n, 4, 4) transforms from 2D to 3D + transforms = np.array(transforms, dtype=np.float64) + + return segments, transforms, face_index + + +def plane_lines(plane_origin, plane_normal, endpoints, line_segments=True): + """ + Calculate plane-line intersections + + Parameters + --------- + plane_origin : (3,) float + Point on plane + plane_normal : (3,) float + Plane normal vector + endpoints : (2, n, 3) float + Points defining lines to be tested + line_segments : bool + If True, only returns intersections as valid if + vertices from endpoints are on different sides + of the plane. + + Returns + --------- + intersections : (m, 3) float + Cartesian intersection points + valid : (n, 3) bool + Indicate whether a valid intersection exists + for each input line segment + """ + endpoints = np.asanyarray(endpoints) + plane_origin = np.asanyarray(plane_origin).reshape(3) + line_dir = util.unitize(endpoints[1] - endpoints[0]) + plane_normal = util.unitize(np.asanyarray(plane_normal).reshape(3)) + + t = np.dot(plane_normal, (plane_origin - endpoints[0]).T) + b = np.dot(plane_normal, line_dir.T) + + # If the plane normal and line direction are perpendicular, it means + # the vector is 'on plane', and there isn't a valid intersection. + # We discard on-plane vectors by checking that the dot product is nonzero + valid = np.abs(b) > tol.zero + if line_segments: + test = np.dot(plane_normal, np.transpose(plane_origin - endpoints[1])) + different_sides = np.sign(t) != np.sign(test) + nonzero = np.logical_or(np.abs(t) > tol.zero, np.abs(test) > tol.zero) + valid = np.logical_and(valid, different_sides) + valid = np.logical_and(valid, nonzero) + + d = np.divide(t[valid], b[valid]) + intersection = endpoints[0][valid] + intersection = intersection + np.reshape(d, (-1, 1)) * line_dir[valid] + + return intersection, valid + + +def planes_lines( + plane_origins, + plane_normals, + line_origins, + line_directions, + return_distance=False, + return_denom=False, +): + """ + Given one line per plane find the intersection points. + + Parameters + ----------- + plane_origins : (n,3) float + Point on each plane + plane_normals : (n,3) float + Normal vector of each plane + line_origins : (n,3) float + Point at origin of each line + line_directions : (n,3) float + Direction vector of each line + return_distance : bool + Return distance from origin to point also + return_denom : bool + Return denominator, so you can check for small values + + Returns + ---------- + on_plane : (n,3) float + Points on specified planes + valid : (n,) bool + Did plane intersect line or not + distance : (n,) float + [OPTIONAL] Distance from point + denom : (n,) float + [OPTIONAL] Denominator + """ + + # check input types + plane_origins = np.asanyarray(plane_origins, dtype=np.float64) + plane_normals = np.asanyarray(plane_normals, dtype=np.float64) + line_origins = np.asanyarray(line_origins, dtype=np.float64) + line_directions = np.asanyarray(line_directions, dtype=np.float64) + + # vector from line to plane + origin_vectors = plane_origins - line_origins + + projection_ori = util.diagonal_dot(origin_vectors, plane_normals) + projection_dir = util.diagonal_dot(line_directions, plane_normals) + + valid = np.abs(projection_dir) > 1e-5 + + distance = np.divide(projection_ori[valid], projection_dir[valid]) + + on_plane = line_directions[valid] * distance.reshape((-1, 1)) + on_plane += line_origins[valid] + + result = [on_plane, valid] + + if return_distance: + result.append(distance) + if return_denom: + result.append(projection_dir) + + return result + + +def slice_faces_plane( + vertices, + faces, + plane_normal, + plane_origin, + uv=None, + face_index=None, + cached_dots=None, +): + """ + Slice a mesh (given as a set of faces and vertices) with a plane, returning a + new mesh (again as a set of faces and vertices) that is the + portion of the original mesh to the positive normal side of the plane. + + Parameters + --------- + vertices : (n, 3) float + Vertices of source mesh to slice + faces : (n, 3) int + Faces of source mesh to slice + plane_normal : (3,) float + Normal vector of plane to intersect with mesh + plane_origin : (3,) float + Point on plane to intersect with mesh + uv : (n, 2) float, optional + UV coordinates of source mesh to slice + face_index : ((m,) int) + Indexes of faces to slice. When no mask is provided, the + default is to slice all faces. + cached_dots : (n, 3) float + If an external function has stored dot + products pass them here to avoid recomputing + + Returns + ---------- + new_vertices : (n, 3) float + Vertices of sliced mesh + new_faces : (n, 3) int + Faces of sliced mesh + new_uv : (n, 2) int or None + UV coordinates of sliced mesh + """ + + if len(vertices) == 0: + return vertices, faces, uv + + have_uv = uv is not None + + # Construct a mask for the faces to slice. + if face_index is not None: + faces = faces[face_index] + + if cached_dots is not None: + dots = cached_dots + else: + # dot product of each vertex with the plane normal indexed by face + # so for each face the dot product of each vertex is a row + # shape is the same as faces (n,3) + dots = np.dot(vertices - plane_origin, plane_normal) + + # Find vertex orientations w.r.t. faces for all triangles: + # -1 -> vertex "inside" plane (positive normal direction) + # 0 -> vertex on plane + # 1 -> vertex "outside" plane (negative normal direction) + signs = np.zeros(len(vertices), dtype=np.int8) + signs[dots < -tol.merge] = 1 + signs[dots > tol.merge] = -1 + signs = signs[faces] + + # Find all triangles that intersect this plane + # onedge <- indices of all triangles intersecting the plane + # inside <- indices of all triangles "inside" the plane (positive normal) + signs_sum = signs.sum(axis=1, dtype=np.int8) + signs_asum = np.abs(signs).sum(axis=1, dtype=np.int8) + + # Cases: + # (0,0,0), (-1,0,0), (-1,-1,0), (-1,-1,-1) <- inside + # (1,0,0), (1,1,0), (1,1,1) <- outside + # (1,0,-1), (1,-1,-1), (1,1,-1) <- onedge + onedge = np.logical_and(signs_asum >= 2, np.abs(signs_sum) <= 1) + + inside = signs_sum == -signs_asum + + # for any faces that lie exactly on-the-plane + # we want to only include them if their normal + # is backwards from the slicing normal + on_plane = signs_asum == 0 + if on_plane.any(): + # compute the normals and whether + # face is degenerate here + check, valid = tm.normals(vertices[faces[on_plane]]) + # only include faces back from normal + dot_check = np.dot(check, plane_normal) + # exclude any degenerate faces from the result + inside[on_plane] = valid + # exclude the degenerate face from our mask + on_plane[on_plane] = valid + # apply results for this subset + inside[on_plane] = dot_check < 0.0 + + # Automatically include all faces that are "inside" + new_faces = faces[inside] + + # Separate faces on the edge into two cases: those which will become + # quads (two vertices inside plane) and those which will become triangles + # (one vertex inside plane) + triangles = vertices[faces] + cut_triangles = triangles[onedge] + cut_faces_quad = faces[np.logical_and(onedge, signs_sum < 0)] + cut_faces_tri = faces[np.logical_and(onedge, signs_sum >= 0)] + cut_signs_quad = signs[np.logical_and(onedge, signs_sum < 0)] + cut_signs_tri = signs[np.logical_and(onedge, signs_sum >= 0)] + + # If no faces to cut, the surface is not in contact with this plane. + # Thus, return a mesh with only the inside faces + if len(cut_faces_quad) + len(cut_faces_tri) == 0: + if len(new_faces) == 0: + # if no new faces at all return empty arrays + empty = ( + np.zeros((0, 3), dtype=np.float64), + np.zeros((0, 3), dtype=np.int64), + np.zeros((0, 2), dtype=np.float64) if have_uv else None, + ) + return empty + + # find the unique indices in the new faces + # using an integer-only unique function + unique, inverse = grouping.unique_bincount( + new_faces.reshape(-1), minlength=len(vertices), return_inverse=True + ) + + # use the unique indices for our final vertices and faces + final_vert = vertices[unique] + final_face = inverse.reshape((-1, 3)) + final_uv = uv[unique] if have_uv else None + + return final_vert, final_face, final_uv + + # Extract the intersections of each triangle's edges with the plane + o = cut_triangles # origins + d = np.roll(o, -1, axis=1) - o # directions + num = (plane_origin - o).dot(plane_normal) # compute num/denom + denom = np.dot(d, plane_normal) + denom[denom == 0.0] = 1e-12 # prevent division by zero + dist = np.divide(num, denom) + # intersection points for each segment + int_points = dist[:, :, None] * d + o + + # Initialize the array of new vertices with the current vertices + new_vertices = vertices + new_quad_vertices = np.zeros((0, 3)) + new_tri_vertices = np.zeros((0, 3)) + + # Handle the case where a new quad is formed by the intersection + # First, extract the intersection points belonging to a new quad + quad_int_points = int_points[(signs_sum < 0)[onedge], :, :] + num_quads = len(quad_int_points) + if num_quads > 0: + # Extract the vertex on the outside of the plane, then get the vertices + # (in CCW order of the inside vertices) + quad_int_inds = np.where(cut_signs_quad == 1)[1] + quad_int_verts = cut_faces_quad[ + np.stack((range(num_quads), range(num_quads)), axis=1), + np.stack(((quad_int_inds + 1) % 3, (quad_int_inds + 2) % 3), axis=1), + ] + + # Fill out new quad faces with the intersection points as vertices + new_quad_faces = np.append( + quad_int_verts, + np.arange(len(new_vertices), len(new_vertices) + 2 * num_quads).reshape( + num_quads, 2 + ), + axis=1, + ) + + # Extract correct intersection points from int_points and order them in + # the same way as they were added to faces + new_quad_vertices = quad_int_points[ + np.stack((range(num_quads), range(num_quads)), axis=1), + np.stack((((quad_int_inds + 2) % 3).T, quad_int_inds.T), axis=1), + :, + ].reshape(2 * num_quads, 3) + + # Add new vertices to existing vertices, triangulate quads, and add the + # resulting triangles to the new faces + new_vertices = np.append(new_vertices, new_quad_vertices, axis=0) + new_tri_faces_from_quads = geometry.triangulate_quads(new_quad_faces) + new_faces = np.append(new_faces, new_tri_faces_from_quads, axis=0) + + # Handle the case where a new triangle is formed by the intersection + # First, extract the intersection points belonging to a new triangle + tri_int_points = int_points[(signs_sum >= 0)[onedge], :, :] + num_tris = len(tri_int_points) + if num_tris > 0: + # Extract the single vertex for each triangle inside the plane and get the + # inside vertices (CCW order) + tri_int_inds = np.where(cut_signs_tri == -1)[1] + tri_int_verts = cut_faces_tri[range(num_tris), tri_int_inds].reshape(num_tris, 1) + + # Fill out new triangles with the intersection points as vertices + new_tri_faces = np.append( + tri_int_verts, + np.arange(len(new_vertices), len(new_vertices) + 2 * num_tris).reshape( + num_tris, 2 + ), + axis=1, + ) + + # Extract correct intersection points and order them in the same way as + # the vertices were added to the faces + new_tri_vertices = tri_int_points[ + np.stack((range(num_tris), range(num_tris)), axis=1), + np.stack((tri_int_inds.T, ((tri_int_inds + 2) % 3).T), axis=1), + :, + ].reshape(2 * num_tris, 3) + + # Append new vertices and new faces + new_vertices = np.append(new_vertices, new_tri_vertices, axis=0) + new_faces = np.append(new_faces, new_tri_faces, axis=0) + + # find the unique indices in the new faces + # using an integer-only unique function + unique, inverse = grouping.unique_bincount( + new_faces.reshape(-1), minlength=len(new_vertices), return_inverse=True + ) + + # use the unique indexes for our final vertex and faces + final_vert = new_vertices[unique] + final_face = inverse.reshape((-1, 3)) + + final_uv = None + if have_uv: + # Generate barycentric coordinates for intersection vertices + quad_barycentrics = points_to_barycentric( + np.repeat(vertices[cut_faces_quad], 2, axis=0), new_quad_vertices + ) + tri_barycentrics = points_to_barycentric( + np.repeat(vertices[cut_faces_tri], 2, axis=0), new_tri_vertices + ) + all_barycentrics = np.concatenate([quad_barycentrics, tri_barycentrics]) + + # Interpolate UVs + cut_uv = np.concatenate([uv[cut_faces_quad], uv[cut_faces_tri]]) + new_uv = np.einsum("ijk,ij->ik", np.repeat(cut_uv, 2, axis=0), all_barycentrics) + final_uv = np.concatenate([uv, new_uv])[unique] + + return final_vert, final_face, final_uv + + +def slice_mesh_plane( + mesh, + plane_normal, + plane_origin, + face_index=None, + cap=False, + engine=None, + **kwargs, +): + """ + Slice a mesh with a plane returning a new mesh that is the + portion of the original mesh to the positive normal side + of the plane. + + Parameters + --------- + mesh : Trimesh object + Source mesh to slice + plane_normal : (3,) float + Normal vector of plane to intersect with mesh + plane_origin : (3,) float + Point on plane to intersect with mesh + cap : bool + If True, cap the result with a triangulated polygon + face_index : ((m,) int) + Indexes of mesh.faces to slice. When no mask is provided, the + default is to slice all faces. + cached_dots : (n, 3) float + If an external function has stored dot + products pass them here to avoid recomputing + engine : None or str + Triangulation engine passed to `triangulate_polygon` + kwargs : dict + Passed to the newly created sliced mesh + + Returns + ---------- + new_mesh : Trimesh object + Sliced mesh + """ + # check input for none + if mesh is None: + return None + + # avoid circular import + from scipy.spatial import cKDTree + + from .base import Trimesh + from .creation import triangulate_polygon + from .path import polygons + from .visual import TextureVisuals + + # check input plane + plane_normal = np.asanyarray(plane_normal, dtype=np.float64) + plane_origin = np.asanyarray(plane_origin, dtype=np.float64) + + # check to make sure origins and normals have acceptable shape + shape_ok = ( + (plane_origin.shape == (3,) or util.is_shape(plane_origin, (-1, 3))) + and (plane_normal.shape == (3,) or util.is_shape(plane_normal, (-1, 3))) + and plane_origin.shape == plane_normal.shape + ) + if not shape_ok: + raise ValueError("plane origins and normals must be (n, 3)!") + + # start with copy of original mesh, faces, and vertices + vertices = mesh.vertices.copy() + faces = mesh.faces.copy() + + # We copy the UV coordinates if available + has_uv = ( + hasattr(mesh.visual, "uv") and np.shape(mesh.visual.uv) == (len(mesh.vertices), 2) + ) and not cap + uv = mesh.visual.uv.copy() if has_uv else None + + if "process" not in kwargs: + kwargs["process"] = False + + # slice away specified planes + for origin, normal in zip( + plane_origin.reshape((-1, 3)), plane_normal.reshape((-1, 3)) + ): + # save the new vertices and faces + vertices, faces, uv = slice_faces_plane( + vertices=vertices, + faces=faces, + uv=uv, + plane_normal=normal, + plane_origin=origin, + face_index=face_index, + ) + # check if cap arg specified + if cap: + if face_index: + # This hasn't been implemented yet. + raise NotImplementedError("face_index and cap can't be used together") + + # start by deduplicating vertices again + unique, inverse = grouping.unique_rows(vertices) + vertices = vertices[unique] + # will collect additional faces + f = inverse[faces] + # remove degenerate faces by checking to make sure + # that each face has three unique indices + f = f[(f[:, :1] != f[:, 1:]).all(axis=1)] + # transform to the cap plane + to_2D = geometry.plane_transform(origin=origin, normal=-normal) + to_3D = np.linalg.inv(to_2D) + + vertices_2D = tf.transform_points(vertices, to_2D) + edges = geometry.faces_to_edges(f) + edges.sort(axis=1) + + on_plane = np.abs(vertices_2D[:, 2]) < 1e-8 + edges = edges[on_plane[edges].all(axis=1)] + edges = edges[edges[:, 0] != edges[:, 1]] + + unique_edge = grouping.group_rows(edges, require_count=1) + if len(unique) < 3: + continue + + tree = cKDTree(vertices) + # collect new faces + faces = [f] + for p in polygons.edges_to_polygons(edges[unique_edge], vertices_2D[:, :2]): + # triangulate cap and raise an error if any new vertices were inserted + vn, fn = triangulate_polygon(p, engine=engine, force_vertices=True) + # collect the original index for the new vertices + vn3 = tf.transform_points(util.stack_3D(vn), to_3D) + distance, vid = tree.query(vn3) + if distance.max() > 1e-8: + util.log.debug("triangulate may have inserted vertex!") + # triangulation should not have inserted vertices + nf = vid[fn] + # hmm but it may have returned faces that are now degenerate + nf_ok = (nf[:, 1:] != nf[:, :1]).all(axis=1) & (nf[:, 1] != nf[:, 2]) + faces.append(nf[nf_ok]) + + faces = np.vstack(faces) + + visual = ( + TextureVisuals(uv=uv, material=mesh.visual.material.copy()) if has_uv else None + ) + + # return the sliced mesh + return Trimesh(vertices=vertices, faces=faces, visual=visual, **kwargs) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interval.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interval.py new file mode 100644 index 0000000000000000000000000000000000000000..9fa8c0d000e77dd2355232d52a81c8f360561edf --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interval.py @@ -0,0 +1,106 @@ +""" +interval.py +-------------- + +Deal with 1D intervals which are defined by: + [start position, end position] +""" + +import numpy as np + +from .typed import ArrayLike, NDArray, float64 + + +def intersection(a: ArrayLike, b: NDArray[float64]) -> NDArray[float64]: + """ + Given pairs of ranges merge them in to + one range if they overlap. + + Parameters + -------------- + a : (2, ) or (n, 2) + Start and end of a 1D interval + b : (2, ) float + Start and end of a 1D interval + + Returns + -------------- + inter : (2, ) or (2, 2) float + The unioned range from the two inputs, + if not np.ptp(`inter, axis=1)` will be zero. + """ + a = np.array(a, dtype=np.float64) + b = np.array(b, dtype=np.float64) + + # convert to vectorized form + is_1D = a.shape == (2,) + a = a.reshape((-1, 2)) + b = b.reshape((-1, 2)) + + # make sure they're min-max + a.sort(axis=1) + b.sort(axis=1) + a_low, a_high = a.T + b_low, b_high = b.T + + # do the checks + check = np.logical_not(np.logical_or(b_low >= a_high, a_low >= b_high)) + overlap = np.zeros(a.shape, dtype=np.float64) + overlap[check] = np.column_stack( + ( + np.array([a_low[check], b_low[check]]).max(axis=0), + np.array([a_high[check], b_high[check]]).min(axis=0), + ) + ) + + if is_1D: + return overlap[0] + + return overlap + + +def union(intervals: ArrayLike, sort: bool = True) -> NDArray[float64]: + """ + For array of multiple intervals union them all into + the subset of intervals. + + For example: + `intervals = [[1,2], [2,3]] -> [[1, 3]]` + `intervals = [[1,2], [2.5,3]] -> [[1, 2], [2.5, 3]]` + + + Parameters + ------------ + intervals : (n, 2) + Pairs of `(min, max)` values. + sort + If the array is already ordered into (min, max) pairs + and then pairs sorted by minimum value you can skip the + sorting in this function. + + Returns + ---------- + unioned : (m, 2) + New intervals where `m <= n` + """ + if len(intervals) == 0: + return np.zeros(0) + + # if the intervals have not been pre-sorted we should apply our sorting logic + # you would only skip this if you are subsetting a larger list elsewhere. + if sort: + # copy inputs and make sure they are (min, max) pairs + intervals = np.sort(intervals, axis=1) + # order them by lowest starting point + intervals = intervals[intervals[:, 0].argsort()] + + # we know we will have at least one interval + unions = [intervals[0].tolist()] + + for begin, end in intervals[1:]: + if unions[-1][1] >= begin: + unions[-1][1] = max(unions[-1][1], end) + else: + unions.append([begin, end]) + + return np.array(unions) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/iteration.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/iteration.py new file mode 100644 index 0000000000000000000000000000000000000000..ac517922c6e239490ebea37b2a8e597e6d2d3f63 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/iteration.py @@ -0,0 +1,187 @@ +from collections import OrderedDict +from math import log2 +from typing import Any + +from .typed import Callable, Iterable, NDArray, Sequence + + +def reduce_cascade(operation: Callable, items: Sequence | NDArray): + """ + Call an operation function in a cascaded pairwise way against a + flat list of items. + + This should produce the same result as `functools.reduce` + if `operation` is commutable like addition or multiplication. + This may be faster for an `operation` that runs with a speed + proportional to its largest input, which mesh booleans appear to. + + The union of a large number of small meshes appears to be + "much faster" using this method. + + This only differs from `functools.reduce` for commutative `operation` + in that it returns `None` on empty inputs rather than `functools.reduce` + which raises a `TypeError`. + + For example on `a b c d e f g` this function would run and return: + a b + c d + e f + ab cd + ef g + abcd efg + -> abcdefg + + Where `functools.reduce` would run and return: + a b + ab c + abc d + abcd e + abcde f + abcdef g + -> abcdefg + + Parameters + ---------- + operation + The function to call on pairs of items. + items + The flat list of items to apply operation against. + """ + if len(items) == 0: + return None + elif len(items) == 1: + # skip the loop overhead for a single item + return items[0] + elif len(items) == 2: + # skip the loop overhead for a single pair + return operation(items[0], items[1]) + + for _ in range(int(1 + log2(len(items)))): + results = [] + + # loop over pairs of items. + items_mod = len(items) % 2 + for i in range(0, len(items) - items_mod, 2): + results.append(operation(items[i], items[i + 1])) + + # if we had a non-even number of items it will have been + # skipped by the loop so append it to our list + if items_mod != 0: + results.append(items[-1]) + + items = results + + # logic should have reduced to a single item + assert len(results) == 1 + + return results[0] + + +def chain(*args: Iterable[Any] | Any | None) -> list[Any]: + """ + A less principled version of `list(itertools.chain(*args))` that + accepts non-iterable values, filters `None`, and returns a list + rather than yielding values. + + If all passed values are iterables this will return identical + results to `list(itertools.chain(*args))`. + + + Examples + ---------- + + In [1]: list(itertools.chain([1,2], [3])) + Out[1]: [1, 2, 3] + + In [2]: trimesh.util.chain([1,2], [3]) + Out[2]: [1, 2, 3] + + In [3]: trimesh.util.chain([1,2], [3], 4) + Out[3]: [1, 2, 3, 4] + + In [4]: list(itertools.chain([1,2], [3], 4)) + ----> 1 list(itertools.chain([1,2], [3], 4)) + TypeError: 'int' object is not iterable + + In [5]: trimesh.util.chain([1,2], None, 3, None, [4], [], [], 5, []) + Out[5]: [1, 2, 3, 4, 5] + + + Parameters + ----------- + args + Will be individually checked to see if they're iterable + before either being appended or extended to a flat list. + + + Returns + ---------- + chained + The values in a flat list. + """ + # collect values to a flat list + chained = [] + # extend if it's a sequence, otherwise append + [ + chained.extend(a) + if (hasattr(a, "__iter__") and not isinstance(a, (str, bytes))) + else chained.append(a) + for a in args + if a is not None + ] + return chained + + +class IndexedDict(OrderedDict): + """ + An append-only `OrderedDict` which knows what position a key was inserted at. + + Useful anywhere values are referenced by *position* but keyed by content so + duplicates are only stored once: the only other spelling is + `list(d.keys()).index(key)`, which allocates every key and scans it, i.e. + quadratic. Looking up the position of all `n` keys once each: + + n list(keys()).index() this class + 2000 0.061s 0.00007s + 4000 0.262s 0.00012s + 8000 1.135s 0.00026s + + Removing or reordering a key would shift the position of every key after it, + so `__delitem__`, `pop`, `popitem`, and `move_to_end` raise: the supported + way to remove is `clear` followed by `update`. + + Examples + ---------- + + In [1]: IndexedDict({"a": 1, "b": 2, "c": 3}).index("c") + Out[1]: 2 + """ + + # subclasses `OrderedDict` rather than `dict` as it routes `__init__`, `update`, + # `setdefault`, `|=`, and `copy` through `__setitem__`: one place records a position + + def __init__(self, *args, **kwargs): + # must exist before `super` starts routing through `__setitem__` + self._position = {} + super().__init__(*args, **kwargs) + + def __setitem__(self, key, value): + if key not in self: + self._position[key] = len(self) + super().__setitem__(key, value) + + def _forbidden(self, *args, **kwargs): + raise TypeError("`IndexedDict` is append-only: use `clear` and `update`") + + # removing or reordering a key shifts the position of every key after it + __delitem__ = pop = popitem = move_to_end = _forbidden + + def clear(self) -> None: + super().clear() + self._position.clear() + + def index(self, key) -> int: + """ + Which position in insertion order was `key` inserted at. + """ + return self._position[key] diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/nsphere.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/nsphere.py new file mode 100644 index 0000000000000000000000000000000000000000..480e8cd7cb7f0740990e21c6c9e14273733862e1 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/nsphere.py @@ -0,0 +1,181 @@ +""" +nsphere.py +-------------- + +Functions for fitting and minimizing nspheres: +circles, spheres, hyperspheres, etc. +""" + +import numpy as np + +from . import convex, util +from .constants import log, tol + +try: + # scipy is a soft dependency + from scipy import spatial + from scipy.optimize import leastsq +except BaseException as E: + # raise the exception when someone tries to use it + from . import exceptions + + leastsq = exceptions.ExceptionWrapper(E) + spatial = exceptions.ExceptionWrapper(E) + + +def minimum_nsphere(obj): + """ + Compute the minimum n- sphere for a mesh or a set of points. + + Uses the fact that the minimum n- sphere will be centered at one of + the vertices of the furthest site voronoi diagram, which is n*log(n) + but should be pretty fast due to using the scipy/qhull implementations + of convex hulls and voronoi diagrams. + + Parameters + ---------- + obj : (n, d) float or trimesh.Trimesh + Points or mesh to find minimum bounding nsphere + + Returns + ---------- + center : (d,) float + Center of fitted n- sphere + radius : float + Radius of fitted n-sphere + """ + + # reduce the input points or mesh to the vertices of the convex hull + # since we are computing the furthest site voronoi diagram this reduces + # the input complexity substantially and returns the same value + points = convex.hull_points(obj) + + # we are scaling the mesh to a unit cube + # this used to pass qhull_options 'QbB' to Voronoi however this had a bug somewhere + # to avoid this we scale to a unit cube ourselves inside this function + points_origin = points.min(axis=0) + points_scale = np.ptp(points, axis=0).min() + points = (points - points_origin) / points_scale + + # if all of the points are on an n-sphere already the voronoi + # method will fail so we check a least squares fit before + # bothering to compute the voronoi diagram + fit_C, fit_R, fit_E = fit_nsphere(points) + # return fit radius and center to global scale + fit_R = (((points - fit_C) ** 2).sum(axis=1).max() ** 0.5) * points_scale + fit_C = (fit_C * points_scale) + points_origin + + if fit_E < 1e-6: + # points were on an n-sphere so just return fit + return fit_C, fit_R + + # calculate a furthest site voronoi diagram + # this will fail if the points are ALL on the surface of + # the n-sphere but hopefully the least squares check caught those cases + # , qhull_options='QbB Pp') + voronoi = spatial.Voronoi(points, furthest_site=True) + + # find the maximum radius^2 point for each of the voronoi vertices + # this is worst case quite expensive but we have taken + # convex hull to reduce n for this operation + # we are doing comparisons on the radius squared then rooting once + try: + # cdist is massivly faster than looping or tiling methods + # although it does create an extremely large intermediate array + # first, get an order of magnitude memory size estimate + # a float64 would be 8 bytes per entry plus overhead + memory_estimate = len(voronoi.vertices) * len(points) * 9 + # if this `cdist` would require more than 4gb of memory fall + # back to the more memory-efficent but much slower loop + if memory_estimate > 4e9: + raise MemoryError + radii_2 = spatial.distance.cdist( + voronoi.vertices, points, metric="sqeuclidean" + ).max(axis=1) + except MemoryError: + # log the MemoryError + log.warning("MemoryError: falling back to slower check!") + # fall back to a potentially very slow list comprehension + radii_2 = np.array( + [((points - v) ** 2).sum(axis=1).max() for v in voronoi.vertices] + ) + + # we want the smallest sphere so take the min of the radii + radii_idx = radii_2.argmin() + + # return voronoi radius and center to global scale + radius_v = np.sqrt(radii_2[radii_idx]) * points_scale + center_v = (voronoi.vertices[radii_idx] * points_scale) + points_origin + + if radius_v > fit_R: + return fit_C, fit_R + + return center_v, radius_v + + +def fit_nsphere(points, prior=None): + """ + Fit an n-sphere to a set of points using least squares. + + Parameters + ------------ + points : (n, d) float + Points in space + prior : (d,) float + Best guess for center of nsphere + + Returns + --------- + center : (d,) float + Location of center + radius : float + Mean radius across circle + error : float + Peak to peak value of deviation from mean radius + """ + # make sure points are numpy array + points = np.asanyarray(points, dtype=np.float64) + # create ones so we can dot instead of using slower sum + ones = np.ones(points.shape[1]) + + def residuals(center): + # do the axis sum with a dot + # this gets called a LOT so worth optimizing + radii_sq = np.dot((points - center) ** 2, ones) + # residuals are difference between mean + # use our sum mean vs .mean() as it is slightly faster + return radii_sq - (radii_sq.sum() / len(radii_sq)) + + if prior is None: + guess = points.mean(axis=0) + else: + guess = np.asanyarray(prior) + + center_result, return_code = leastsq(residuals, guess, xtol=1e-8) + + if return_code not in [1, 2, 3, 4]: + raise ValueError("Least square fit failed!") + + radii = util.row_norm(points - center_result) + radius = radii.mean() + error = np.ptp(radii) + return center_result, radius, error + + +def is_nsphere(points): + """ + Check if a list of points is an nsphere. + + Parameters + ----------- + points : (n, dimension) float + Points in space + + Returns + ----------- + check : bool + True if input points are on an nsphere + """ + _center, _radius, error = fit_nsphere(points) + check = error < tol.merge + return check diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/parent.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/parent.py new file mode 100644 index 0000000000000000000000000000000000000000..267537339944d9324bf07edf67555b2945fece9b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/parent.py @@ -0,0 +1,419 @@ +""" +parent.py +------------- + +The base class for Trimesh, PointCloud, and Scene objects +""" + +import abc +import os +from dataclasses import dataclass +from typing import Any + +import numpy as np + +from . import bounds, caching +from . import transformations as tf +from .caching import cache_decorator +from .constants import tol +from .resolvers import ResolverLike +from .typed import ArrayLike, NDArray, float64 +from .util import ABC + + +@dataclass +class LoadSource: + """ + Save information about where a particular object was loaded from. + """ + + # a file-like object that can be accessed + file_obj: Any | None = None + + # a cleaned file type string, i.e. "stl" + file_type: str | None = None + + # if this was originally loaded from a file path + # save it here so we can check it later. + file_path: str | None = None + + # did we open `file_obj` ourselves? + was_opened: bool = False + + # a resolver for loading assets next to the file + resolver: ResolverLike | None = None + + @property + def file_name(self) -> str | None: + """ + Get just the file name from the path if available. + + Returns + --------- + file_name + Just the file name, i.e. for file_path="/a/b/c.stl" -> "c.stl" + """ + if self.file_path is None: + return None + return os.path.basename(self.file_path) + + def __getstate__(self) -> dict[str, Any]: + # this overrides the `pickle.dump` behavior for this class + # we cannot pickle a file object so return `file_obj: None` for pickles + return {k: v if k != "file_obj" else None for k, v in self.__dict__.items()} + + def __deepcopy__(self, *args): + return LoadSource(**self.__getstate__()) + + +class Geometry(ABC): + """ + `Geometry` is the parent class for all geometry. + + By decorating a method with `abc.abstractmethod` it means + the objects that inherit from `Geometry` MUST implement + those methods. + """ + + # geometry should have a dict to store loose metadata + metadata: dict[str, Any] + + @property + def source(self) -> LoadSource: + """ + Where and what was this current geometry loaded from? + + Returns + -------- + source + If loaded from a file, has the path, type, etc. + """ + # this should have been tacked on by the loader + # but we want to *always* be able to access + # a value like `mesh.source.file_type` so add a default + current = getattr(self, "_source", None) + if current is not None: + return current + self._source = LoadSource() + return self._source + + @property + @abc.abstractmethod + def identifier_hash(self) -> str: + pass + + @property + @abc.abstractmethod + def bounds(self) -> NDArray[np.float64]: + pass + + @property + @abc.abstractmethod + def extents(self) -> NDArray[np.float64]: + pass + + @abc.abstractmethod + def apply_transform(self, matrix: ArrayLike) -> Any: + pass + + @property + @abc.abstractmethod + def is_empty(self) -> bool: + pass + + def __hash__(self): + """ + Get a hash of the current geometry. + + Returns + --------- + hash + Hash of current graph and geometry. + """ + return self._data.__hash__() # type: ignore + + @abc.abstractmethod + def copy(self): + pass + + @abc.abstractmethod + def show(self): + pass + + @abc.abstractmethod + def __add__(self, other): + pass + + @abc.abstractmethod + def export(self, file_obj, file_type=None): + pass + + def __repr__(self) -> str: + """ + Print quick summary of the current geometry without + computing properties. + + Returns + ----------- + repr : str + Human readable quick look at the geometry. + """ + elements = [] + if hasattr(self, "vertices"): + # for Trimesh and PointCloud + elements.append(f"vertices.shape={self.vertices.shape}") + if hasattr(self, "faces"): + # for Trimesh + elements.append(f"faces.shape={self.faces.shape}") + if hasattr(self, "geometry") and isinstance(self.geometry, dict): + # for Scene + elements.append(f"len(geometry)={len(self.geometry)}") + if "Voxel" in type(self).__name__: + # for VoxelGrid objects + elements.append(str(self.shape)[1:-1]) + if "file_name" in self.metadata: + display = self.metadata["file_name"] + elements.append(f"name=`{display}`") + return "".format(type(self).__name__, ", ".join(elements)) + + def apply_translation(self, translation: ArrayLike): + """ + Translate the current mesh. + + Parameters + ---------- + translation : (3,) float + Translation in XYZ + """ + translation = np.asanyarray(translation, dtype=np.float64) + if translation.shape == (2,): + # create a planar matrix if we were passed a 2D offset + return self.apply_transform(tf.planar_matrix(offset=translation)) + elif translation.shape != (3,): + raise ValueError("Translation must be (3,) or (2,)!") + + # manually create a translation matrix + matrix = np.eye(4) + matrix[:3, 3] = translation + return self.apply_transform(matrix) + + def apply_scale(self, scaling): + """ + Scale the mesh. + + Parameters + ---------- + scaling : float or (3,) float + Scale factor to apply to the mesh + """ + matrix = tf.scale_and_translate(scale=scaling) + # apply_transform will work nicely even on negative scales + return self.apply_transform(matrix) + + def __radd__(self, other): + """ + Concatenate the geometry allowing concatenation with + built in `sum()` function: + `sum(Iterable[trimesh.Trimesh])` + + Parameters + ------------ + other : Geometry + Geometry or 0 + + Returns + ---------- + concat : Geometry + Geometry of combined result + """ + + if other == 0: + # adding 0 to a geometry never makes sense + return self + # otherwise just use the regular add function + return self.__add__(type(self)(other)) + + @cache_decorator + def scale(self) -> float: + """ + A loosely specified "order of magnitude scale" for the + geometry which always returns a value and can be used + to make code more robust to large scaling differences. + + It returns the diagonal of the axis aligned bounding box + or if anything is invalid or undefined, `1.0`. + + Returns + ---------- + scale : float + Approximate order of magnitude scale of the geometry. + """ + # if geometry is empty return 1.0 + if self.extents is None: + return 1.0 + + # get the length of the AABB diagonal + scale = float((self.extents**2).sum() ** 0.5) + if scale < tol.zero: + return 1.0 + + return scale + + @property + def units(self) -> str | None: + """ + Definition of units for the mesh. + + Returns + ---------- + units : str + Unit system mesh is in, or None if not defined + """ + return self.metadata.get("units", None) + + @units.setter + def units(self, value: str) -> None: + """ + Define the units of the current mesh. + """ + self.metadata["units"] = str(value).lower().strip() + + +class Geometry3D(Geometry): + """ + The `Geometry3D` object is the parent object of geometry objects + which are three dimensional, including Trimesh, PointCloud, + and Scene objects. + """ + + @caching.cache_decorator + def bounding_box(self): + """ + An axis aligned bounding box for the current mesh. + + Returns + ---------- + aabb : trimesh.primitives.Box + Box object with transform and extents defined + representing the axis aligned bounding box of the mesh + """ + from . import primitives + + transform = np.eye(4) + # translate to center of axis aligned bounds + transform[:3, 3] = self.bounds.mean(axis=0) + + return primitives.Box(transform=transform, extents=self.extents, mutable=False) + + @caching.cache_decorator + def bounding_box_oriented(self): + """ + An oriented bounding box for the current mesh. + + Returns + --------- + obb : trimesh.primitives.Box + Box object with transform and extents defined + representing the minimum volume oriented + bounding box of the mesh + """ + from . import bounds, primitives + + to_origin, extents = bounds.oriented_bounds(self) + return primitives.Box( + transform=np.linalg.inv(to_origin), extents=extents, mutable=False + ) + + @caching.cache_decorator + def bounding_sphere(self): + """ + A minimum volume bounding sphere for the current mesh. + + Note that the Sphere primitive returned has an unpadded + exact `sphere_radius` so while the distance of every vertex + of the current mesh from sphere_center will be less than + sphere_radius, the faceted sphere primitive may not + contain every vertex. + + Returns + -------- + minball : trimesh.primitives.Sphere + Sphere primitive containing current mesh + """ + from . import nsphere, primitives + + center, radius = nsphere.minimum_nsphere(self) + return primitives.Sphere(center=center, radius=radius, mutable=False) + + @caching.cache_decorator + def bounding_cylinder(self): + """ + A minimum volume bounding cylinder for the current mesh. + + Returns + -------- + mincyl : trimesh.primitives.Cylinder + Cylinder primitive containing current mesh + """ + from . import bounds, primitives + + kwargs = bounds.minimum_cylinder(self) + return primitives.Cylinder(mutable=False, **kwargs) + + @caching.cache_decorator + def bounding_primitive(self): + """ + The minimum volume primitive (box, sphere, or cylinder) that + bounds the mesh. + + Returns + --------- + bounding_primitive : object + Smallest primitive which bounds the mesh: + trimesh.primitives.Sphere + trimesh.primitives.Box + trimesh.primitives.Cylinder + """ + options = [ + self.bounding_box_oriented, + self.bounding_sphere, + self.bounding_cylinder, + ] + volume_min = np.argmin([i.volume for i in options]) + return options[volume_min] + + def apply_obb(self, **kwargs) -> NDArray[float64]: + """ + Apply the oriented bounding box transform to the current mesh. + + This will result in a mesh with an AABB centered at the + origin and the same dimensions as the OBB. + + Parameters + ------------ + kwargs + Passed through to `bounds.oriented_bounds` + + Returns + ---------- + matrix : (4, 4) float + Transformation matrix that was applied + to mesh to move it into OBB frame + """ + # save the pre-transform volume + if tol.strict and hasattr(self, "volume"): + volume = self.volume + + # calculate the OBB passing keyword arguments through + matrix, extents = bounds.oriented_bounds(self, **kwargs) + # apply the transform + self.apply_transform(matrix) + + if tol.strict: + # obb transform should not have changed volume + if hasattr(self, "volume") and getattr(self, "is_watertight", False): + assert np.isclose(self.volume, volume) + # overall extents should match what we expected + assert np.allclose(self.extents, extents) + + return matrix diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a3c2e3adf1b6c9a436a9678fbad3beb954216221 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__init__.py @@ -0,0 +1,18 @@ +""" +trimesh.path +------------- + +Handle 2D and 3D vector paths such as those contained in an +SVG or DXF file. +""" + +try: + from .path import Path2D, Path3D +except BaseException as E: + from .. import exceptions + + Path2D = exceptions.ExceptionWrapper(E) + Path3D = exceptions.ExceptionWrapper(E) + +# explicitly add objects to all as per pep8 +__all__ = ["Path2D", "Path3D"] diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d6b491165d0cc75347a5886191de9a408b58926 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/arc.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/arc.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c4b7183e36ed9a684242c4dd6d6871289797f688 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/arc.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/creation.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/creation.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..092d7a05b9f9139fccf56cad0e2d7ecc0f3e84cd Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/creation.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/curve.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/curve.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a8ffa16c385d70560655e9e8fa600d47549e7263 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/curve.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/entities.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/entities.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..456451ff2831a148f74b62fc5efdc50090b2b19c Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/entities.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/intersections.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/intersections.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fa5ae1e9d0a9f9e646180bd44a2f7bb2a19c2629 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/intersections.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/packing.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/packing.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9e1dc4c0c9f77977a3bec9226d51e0ea3be3b46b Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/packing.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/path.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/path.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e26f40324561c10e97c662b45d725a1710274b69 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/path.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/polygons.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/polygons.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4c81ab87341b90c735965016570b1b33bb2de724 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/polygons.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/raster.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/raster.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..91ec2002db19f27dde0dd918dc4b4a72ef0d7bfb Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/raster.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/repair.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/repair.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a274ef69de573c5d0c85ca85a67e7c4be9247ba Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/repair.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/segments.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/segments.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0233da57fbb6f72709863034e3e3c9b924331737 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/segments.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/simplify.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/simplify.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0566c1f2bae96d3ad8e28e54b58ba748c7cc6f61 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/simplify.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/traversal.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/traversal.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..db1cb8e745437e581c89d842cdecc41252211223 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/traversal.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/util.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/util.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..02aaf39c09ed92aea320707120b98fa01c8d32de Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__pycache__/util.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/arc.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/arc.py new file mode 100644 index 0000000000000000000000000000000000000000..b8bc623c7728cc91d5fd91af99816554216edac6 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/arc.py @@ -0,0 +1,245 @@ +from dataclasses import dataclass + +import numpy as np + +from .. import util +from ..constants import res_path as res +from ..constants import tol_path as tol +from ..typed import ArrayLike, NDArray, Number, float64 + +# floating point zero +_TOL_ZERO = 1e-12 + + +@dataclass +class ArcInfo: + # What is the radius of the circular arc? + radius: float + + # what is the center of the circular arc + # it is either 2D or 3D depending on input. + center: NDArray[float64] + + # what is the 3D normal vector of the plane the arc lies on + normal: NDArray[float64] | None = None + + # what is the starting and ending angle of the arc. + angles: NDArray[float64] | None = None + + # what is the angular span of this circular arc. + span: Number | None = None + + def __getitem__(self, item): + # add for backwards compatibility + return getattr(self, item) + + +def arc_center( + points: ArrayLike, return_normal: bool = True, return_angle: bool = True +) -> ArcInfo: + """ + Given three points on a 2D or 3D arc find the center, + radius, normal, and angular span. + + Parameters + --------- + points : (3, dimension) float + Points in space, where dimension is either 2 or 3 + return_normal : bool + If True calculate the 3D normal unit vector + return_angle : bool + If True calculate the start and stop angle and span + + Returns + --------- + info + Arc center, radius, and other information. + """ + points = np.asanyarray(points, dtype=np.float64) + + # get the non-unit vectors of the three points + vectors = points[[2, 0, 1]] - points[[1, 2, 0]] + # we need both the squared row sum and the non-squared + abc2 = np.dot(vectors**2, [1] * points.shape[1]) + # same as np.linalg.norm(vectors, axis=1) + abc = np.sqrt(abc2) + + # perform radius calculation scaled to shortest edge + # to avoid precision issues with small or large arcs + scale = abc.min() + # get the edge lengths scaled to the smallest + edges = abc / scale + # half the total length of the edges + half = edges.sum() / 2.0 + # check the denominator for the radius calculation + denom = half * np.prod(half - edges) + if denom < tol.merge: + raise ValueError("arc is colinear!") + # find the radius and scale back after the operation + radius = scale * ((np.prod(edges) / 4.0) / np.sqrt(denom)) + + # use a barycentric approach to get the center + ba2 = (abc2[[1, 2, 0, 0, 2, 1, 0, 1, 2]] * [1, 1, -1, 1, 1, -1, 1, 1, -1]).reshape( + (3, 3) + ).sum(axis=1) * abc2 + center = points.T.dot(ba2) / ba2.sum() + + if tol.strict: + # all points should be at the calculated radius from center + assert util.allclose(np.linalg.norm(points - center, axis=1), radius) + + # start with initial results + result = {"center": center, "radius": radius} + if return_normal: + if points.shape == (3, 2): + # for 2D arcs still use the cross product so that + # the sign of the normal vector is consistent + result["normal"] = util.unitize( + np.cross(np.append(-vectors[1], 0), np.append(vectors[2], 0)) + ) + else: + # otherwise just take the cross product + result["normal"] = util.unitize(np.cross(-vectors[1], vectors[2])) + + if return_angle: + # vectors from points on arc to center point + vector = util.unitize(points - center) + edge_direction = np.diff(points, axis=0) + # find the angle between the first and last vector + dot = np.dot(*vector[[0, 2]]) + if dot < (_TOL_ZERO - 1): + angle = np.pi + elif dot > 1 - _TOL_ZERO: + angle = 0.0 + else: + angle = np.arccos(dot) + # if the angle is nonzero and vectors are opposite direction + # it means we have a long arc rather than the short path + if abs(angle) > _TOL_ZERO and np.dot(*edge_direction) < 0.0: + angle = (np.pi * 2) - angle + # convoluted angle logic + angles = np.arctan2(*vector[:, :2].T[::-1]) + np.pi * 2 + angles_sorted = np.sort(angles[[0, 2]]) + reverse = angles_sorted[0] < angles[1] < angles_sorted[1] + angles_sorted = angles_sorted[:: (1 - int(not reverse) * 2)] + result["angles"] = angles_sorted + result["span"] = angle + + return ArcInfo(**result) + + +def discretize_arc(points, close=False, scale=1.0): + """ + Returns a version of a three point arc consisting of + line segments. + + Parameters + --------- + points : (3, d) float + Points on the arc where d in [2,3] + close : boolean + If True close the arc into a circle + scale : float + What is the approximate overall drawing scale + Used to establish order of magnitude for precision + + Returns + --------- + discrete : (m, d) float + Connected points in space + """ + # make sure points are (n, 3) + points, is_2D = util.stack_3D(points, return_2D=True) + # find the center of the points + try: + # try to find the center from the arc points + center_info = arc_center(points) + except BaseException: + # if we hit an exception return a very bad but + # technically correct discretization of the arc + if is_2D: + return points[:, :2] + return points + + center, R, N, angle = ( + center_info.center, + center_info.radius, + center_info.normal, + center_info.span, + ) + + # if requested, close arc into a circle + if close: + angle = np.pi * 2 + + # the number of facets for the arc + # which is the maximum of angle and linear criteria + count = max(angle / res.seg_angle, (R * angle) / (res.seg_frac * scale)) + + # force at LEAST 4 points for the arc + # otherwise the endpoints will diverge + count = int(np.ceil(np.clip(count, 4, np.inf))) + + V1 = util.unitize(points[0] - center) + V2 = util.unitize(np.cross(-N, V1)) + # angle spacing + t = np.linspace(0.0, angle, count).reshape((-1, 1)) + + # apply the vector formula + discrete = (np.cos(t) * V1 + np.sin(t) * V2) * R + center + + if close: + # snap closed circles to exactly float-equal + discrete[-1] = discrete[0] + else: + # snap the discrete result to exact control points + discrete[[0, -1]] = points[[0, -1]] + + # clip to the dimension of input + discrete = discrete[:, : (3 - is_2D)] + + return discrete + + +def to_threepoint(center, radius, angles=None): + """ + For 2D arcs, given a center and radius convert them to three + points on the arc. + + Parameters + ----------- + center : (2,) float + Center point on the plane + radius : float + Radius of arc + angles : (2,) float + Angles in radians for start and end angle + if not specified, will default to (0.0, pi) + + Returns + ---------- + three : (3, 2) float + Arc control points + """ + # if no angles provided assume we want a half circle + if angles is None: + angles = [0.0, np.pi] + # force angles to float64 + angles = np.asanyarray(angles, dtype=np.float64) + if angles.shape != (2,): + raise ValueError("angles must be (2,)!") + # provide the wrap around + if angles[1] < angles[0]: + angles[1] += np.pi * 2 + + center = np.asanyarray(center, dtype=np.float64) + if center.shape != (2,): + raise ValueError("only valid on 2D arcs!") + + # turn the angles of [start, end] + # into [start, middle, end] + angles = np.array([angles[0], angles.mean(), angles[1]], dtype=np.float64) + # turn angles into (3, 2) points + three = (np.column_stack((np.cos(angles), np.sin(angles))) * radius) + center + + return three diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/creation.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/creation.py new file mode 100644 index 0000000000000000000000000000000000000000..1d8c730307dcceb8bd4c914a6aeb7311d41f6bfb --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/creation.py @@ -0,0 +1,294 @@ +import numpy as np + +from .. import transformations, util +from ..geometry import plane_transform +from . import arc +from .entities import Arc, Line + + +def circle_pattern( + pattern_radius, circle_radius, count, center=None, angle=None, **kwargs +): + """ + Create a Path2D representing a circle pattern. + + Parameters + ------------ + pattern_radius : float + Radius of circle centers + circle_radius : float + The radius of each circle + count : int + Number of circles in the pattern + center : (2,) float + Center of pattern + angle : float + If defined pattern will span this angle + If None, pattern will be evenly spaced + + Returns + ------------- + pattern : trimesh.path.Path2D + Path containing circular pattern + """ + from .path import Path2D + + if angle is None: + angles = np.linspace(0.0, np.pi * 2.0, count + 1)[:-1] + elif isinstance(angle, float) or isinstance(angle, int): + angles = np.linspace(0.0, angle, count) + else: + raise ValueError("angle must be float or int!") + + if center is None: + center = [0.0, 0.0] + + # centers of circles + centers = np.column_stack((np.cos(angles), np.sin(angles))) * pattern_radius + + vert = [] + ents = [] + for circle_center in centers: + # (3,3) center points of arc + three = arc.to_threepoint( + angles=[0, np.pi], center=circle_center, radius=circle_radius + ) + # add a single circle entity + ents.append(Arc(points=np.arange(3) + len(vert), closed=True)) + # keep flat array by extend instead of append + vert.extend(three) + + # translate vertices to pattern center + vert = np.array(vert) + center + pattern = Path2D(entities=ents, vertices=vert, **kwargs) + return pattern + + +def circle(radius, center=None, **kwargs): + """ + Create a Path2D containing circle with the specified + radius. + + Parameters + -------------- + radius : float + The radius of the circle + center : None or (2,) float + Center of the circle, origin by default + ** kwargs : dict + Passed to trimesh.path.Path2D constructor + + Returns + ------------- + circle : Path2D + Path containing specified circle + """ + from .path import Path2D + + if center is None: + center = [0.0, 0.0] + else: + center = np.asanyarray(center, dtype=np.float64) + # make sure radius is a float + radius = float(radius) + + # (3, 2) float, points on arc + three = arc.to_threepoint(angles=[0, np.pi], center=center, radius=radius) + # generate the path object + result = Path2D( + entities=[Arc(points=np.arange(3), closed=True)], vertices=three, **kwargs + ) + + return result + + +def rectangle(bounds, **kwargs): + """ + Create a Path2D containing a single or multiple rectangles + with the specified bounds. + + Parameters + -------------- + bounds : (2, 2) float, or (m, 2, 2) float + Minimum XY, Maximum XY + + Returns + ------------- + rect : Path2D + Path containing specified rectangles + """ + from .path import Path2D + + # data should be float + bounds = np.asanyarray(bounds, dtype=np.float64) + + # bounds are extents, re- shape to origin- centered rectangle + if bounds.shape == (2,): + half = np.abs(bounds) / 2.0 + bounds = np.array([-half, half]) + + # should have one bounds or multiple bounds + if not (util.is_shape(bounds, (2, 2)) or util.is_shape(bounds, (-1, 2, 2))): + raise ValueError("bounds must be (m, 2, 2) or (2, 2)") + + # hold Line objects + lines = [] + # hold (n, 2) cartesian points + vertices = [] + + # loop through each rectangle + for lower, upper in bounds.reshape((-1, 2, 2)): + lines.append(Line((np.arange(5) % 4) + len(vertices))) + vertices.extend([lower, [upper[0], lower[1]], upper, [lower[0], upper[1]]]) + + # create the Path2D with specified rectangles + rect = Path2D(entities=lines, vertices=vertices, **kwargs) + + return rect + + +def box_outline(extents=None, transform=None, **kwargs): + """ + Return a cuboid. + + Parameters + ------------ + extents : float, or (3,) float + Edge lengths + transform: (4, 4) float + Transformation matrix + **kwargs: + passed to Trimesh to create box + + Returns + ------------ + geometry : trimesh.Path3D + Path outline of a cuboid geometry + """ + from .exchange.load import load_path + + # create vertices for the box + vertices = [0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1] + vertices = np.array(vertices, order="C", dtype=np.float64).reshape((-1, 3)) + vertices -= 0.5 + + # resize the vertices based on passed size + if extents is not None: + extents = np.asanyarray(extents, dtype=np.float64) + if extents.shape != (3,): + raise ValueError("Extents must be (3,)!") + vertices *= extents + + # apply transform if passed + if transform is not None: + vertices = transformations.transform_points(vertices, transform) + + # vertex indices + indices = [0, 1, 3, 2, 0, 4, 5, 7, 6, 4, 0, 2, 6, 7, 3, 1, 5] + outline = load_path(vertices[indices]) + + return outline + + +def grid( + side, + count=5, + transform=None, + plane_origin=None, + plane_normal=None, + include_circle=True, + sections_circle=32, +): + """ + Create a Path3D for a grid visualization of a plane. + + Parameters + ----------- + side : float + Length of half of a grid side + count : int + Number of grid lines per grid half + transform : None or (4, 4) float + Transformation matrix to move grid location. + Takes precedence over plane_origin if both are passed. + plane_origin : None or (3,) float + Plane origin + plane_normal : None or (3,) float + Unit normal vector + include_circle : bool + Include a circular pattern inside the grid + sections_circle : int + How many sections should the smallest circle have + + Returns + ---------- + grid : trimesh.path.Path3D + Path containing grid plane visualization + """ + from .path import Path3D + + # change full side length to half-side + side = float(side) + # make sure count is an integer + count = int(count) + # get a spaced sequence of radius + radii = np.linspace(0.0, side, count + 1)[1:] + # what's the maximum radius + rmax = radii[-1] + + # keep a count of the current vertex count + current = 0 + # collect vertices and entities + vertices = [] + entities = [] + for r in radii: + if include_circle: + # scale the section count by radius + circle_res = int((r / radii[0]) * sections_circle) + # generate a circule pattern + theta = np.linspace(0.0, np.pi * 2, circle_res) + circle = np.column_stack((np.cos(theta), np.sin(theta))) * r + # append the circle pattern + vertices.append(circle) + entities.append(Line(points=np.arange(len(circle)) + current)) + # keep the vertex count correct + current += len(circle) + # generate a series of grid lines + vertices.append( + [ + [-rmax, r], + [rmax, r], + [-rmax, -r], + [rmax, -r], + [r, -rmax], + [r, rmax], + [-r, -rmax], + [-r, rmax], + ] + ) + # append an entity per grid line + for i in [0, 2, 4, 6]: + entities.append(Line(points=np.arange(2) + current + i)) + current += len(vertices[-1]) + + # add the middle lines which were skipped + vertices.append([[0, rmax], [0, -rmax], [-rmax, 0], [rmax, 0]]) + entities.append(Line(points=np.arange(2) + current)) + entities.append(Line(points=np.arange(2) + current + 2)) + # stack vertices into clean (n, 3) float + vertices = np.vstack(vertices) + + # if plane was passed instead of transform create the matrix here + if transform is None and plane_origin is not None and plane_normal is not None: + transform = np.linalg.inv( + plane_transform(origin=plane_origin, normal=plane_normal) + ) + + # stack vertices to 3D + vertices = np.column_stack((vertices, np.zeros(len(vertices)))) + # apply transform if passed + if transform is not None: + vertices = transformations.transform_points(vertices, matrix=transform) + # combine result into a Path3D object + grid_path = Path3D(entities=entities, vertices=vertices) + return grid_path diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/curve.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/curve.py new file mode 100644 index 0000000000000000000000000000000000000000..b095c8a49818c9aa28f8d1aa98d211cee70dfe7c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/curve.py @@ -0,0 +1,136 @@ +import numpy as np + +from ..constants import res_path as res +from ..constants import tol_path as tol +from ..typed import Integer + + +def discretize_bezier(points, count=None, scale=1.0): + """ + Parameters + ---------- + points : (order, dimension) float + Control points of the bezier curve + For a 2D cubic bezier, order=3, dimension=2 + count : int, or None + Number of segments + scale : float + Scale of curve + Returns + ---------- + discrete: (n, dimension) float + Points forming a a polyline representation + """ + # make sure we have a numpy array + points = np.asanyarray(points, dtype=np.float64) + + if count is None: + # how much distance does a small percentage of the curve take + # this is so we can figure out how finely we have to sample t + norm = np.linalg.norm(np.diff(points, axis=0), axis=1).sum() + count = np.ceil(norm / (res.seg_frac * scale)) + count = int( + np.clip(count, res.min_sections * len(points), res.max_sections * len(points)) + ) + count = int(count) + + # parameterize incrementing 0.0 - 1.0 + t = np.linspace(0.0, 1.0, count) + # decrementing 1.0-0.0 + t_d = 1.0 - t + n = len(points) - 1 + # binomial coefficients, i, and each point + iterable = zip(binomial(n), np.arange(len(points)), points) + # run the actual interpolation + stacked = [ + ((t**i) * (t_d ** (n - i))).reshape((-1, 1)) * p * c for c, i, p in iterable + ] + result = np.sum(stacked, axis=0) + + # a bezier curve always starts and ends on control points + if tol.strict: + # test to make sure end points are correct + test = np.sum((result[[0, -1]] - points[[0, -1]]) ** 2, axis=1) + assert (test < tol.merge).all() + assert len(result) >= 2 + + # snap the first and last points to the exact control point + result[[0, -1]] = points[[0, -1]] + + return result + + +def discretize_bspline(control, knots, count=None, scale=1.0): + """ + Given a B-Splines control points and knot vector, return + a sampled version of the curve. + + Parameters + ---------- + control : (o, d) float + Control points of the b- spline + knots : (j,) float + B-spline knots + count : int + Number of line segments to discretize the spline + If not specified will be calculated as something reasonable + + Returns + ---------- + discrete : (count, dimension) float + Points on a polyline version of the B-spline + """ + + # evaluate the b-spline using scipy/fitpack + from scipy.interpolate import splev + + # (n, d) control points where d is the dimension of vertices + control = np.asanyarray(control, dtype=np.float64) + degree = len(knots) - len(control) - 1 + if count is None: + norm = np.linalg.norm(np.diff(control, axis=0), axis=1).sum() + count = int( + np.clip( + norm / (res.seg_frac * scale), + res.min_sections * len(control), + res.max_sections * len(control), + ) + ) + + ipl = np.linspace(knots[0], knots[-1], count) + discrete = splev(ipl, [knots, control.T, degree]) + discrete = np.column_stack(discrete) + + return discrete + + +def binomial(n: Integer) -> list: + """ + Return all binomial coefficients for a given order. + + For n > 5, scipy.special.binom is used, below we hardcode. + + Parameters + -------------- + n : int + Order of binomial + + Returns + --------------- + binom : (n + 1,) int + Binomial coefficients of a given order + """ + if n == 1: + return [1, 1] + elif n == 2: + return [1, 2, 1] + elif n == 3: + return [1, 3, 3, 1] + elif n == 4: + return [1, 4, 6, 4, 1] + elif n == 5: + return [1, 5, 10, 10, 5, 1] + else: + from scipy.special import binom + + return binom(n, np.arange(n + 1)) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/entities.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/entities.py new file mode 100644 index 0000000000000000000000000000000000000000..a65ab6b2d1f009cbb0b055469c7de2f49cd276be --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/entities.py @@ -0,0 +1,838 @@ +""" +entities.py +-------------- + +Basic geometric primitives which only store references to +vertex indices rather than vertices themselves. +""" + +from copy import deepcopy +from logging import getLogger + +import numpy as np + +from .. import util +from ..util import ABC +from .arc import arc_center, discretize_arc +from .curve import discretize_bezier, discretize_bspline + +log = getLogger(__name__) + + +class Entity(ABC): + def __init__( + self, points, closed=None, layer=None, metadata=None, color=None, **kwargs + ): + # points always reference vertex indices and are int + self.points = np.asanyarray(points, dtype=np.int64) + # save explicit closed + if closed is not None: + self.closed = closed + # save the passed layer + if layer is not None: + self.layer = layer + if metadata is not None: + self.metadata.update(metadata) + + self._cache = {} + + # save the passed color + self.color = color + # save any other kwargs for general use + self.kwargs = kwargs + + @property + def metadata(self): + """ + Get any metadata about the entity. + + Returns + --------- + metadata : dict + Bag of properties. + """ + if not hasattr(self, "_metadata"): + self._metadata = {} + # note that we don't let a new dict be assigned + return self._metadata + + @property + def layer(self): + """ + Set the layer the entity resides on as a shortcut + to putting it in the entity metadata. + + Returns + ---------- + layer : any + Hashable layer identifier. + """ + return self.metadata.get("layer") + + @layer.setter + def layer(self, value): + """ + Set the current layer of the entity. + + Returns + ---------- + layer : any + Hashable layer indicator + """ + self.metadata["layer"] = value + + def to_dict(self) -> dict: + """ + Returns a dictionary with all of the information + about the entity. + + Returns + ----------- + as_dict : dict + Has keys 'type', 'points', 'closed' + """ + return { + "type": self.__class__.__name__, + "points": self.points.tolist(), + "closed": self.closed, + } + + @property + def closed(self): + """ + If the first point is the same as the end point + the entity is closed + + Returns + ----------- + closed : bool + Is the entity closed or not? + """ + return len(self.points) > 2 and self.points[0] == self.points[-1] + + @property + def nodes(self): + """ + Returns an (n,2) list of nodes, or vertices on the path. + Note that this generic class function assumes that all of the + reference points are on the path which is true for lines and + three point arcs. + + If you were to define another class where that wasn't the case + (for example, the control points of a bezier curve), + you would need to implement an entity- specific version of this + function. + + The purpose of having a list of nodes is so that they can then be + added as edges to a graph so we can use functions to check + connectivity, extract paths, etc. + + The slicing on this function is essentially just tiling points + so the first and last vertices aren't repeated. Example: + + self.points = [0,1,2] + returns: [[0,1], [1,2]] + """ + return ( + np.column_stack((self.points, self.points)).reshape(-1)[1:-1].reshape((-1, 2)) + ) + + @property + def end_points(self): + """ + Returns the first and last points. Also note that if you + define a new entity class where the first and last vertices + in self.points aren't the endpoints of the curve you need to + implement this function for your class. + + Returns + ------------- + ends : (2,) int + Indices of the two end points of the entity + """ + return self.points[[0, -1]] + + @property + def is_valid(self): + """ + Is the current entity valid. + + Returns + ----------- + valid : bool + Is the current entity well formed + """ + return True + + def reverse(self, direction=-1): + """ + Reverse the current entity in place. + + Parameters + ---------------- + direction : int + If positive will not touch direction + If negative will reverse self.points + """ + if direction < 0: + self._direction = -1 + else: + self._direction = 1 + + def _orient(self, curve): + """ + Reverse a curve if a flag is set. + + Parameters + -------------- + curve : (n, dimension) float + Curve made up of line segments in space + + Returns + ------------ + orient : (n, dimension) float + Original curve, but possibly reversed + """ + if hasattr(self, "_direction") and self._direction < 0: + return curve[::-1] + return curve + + def bounds(self, vertices): + """ + Return the AABB of the current entity. + + Parameters + ----------- + vertices : (n, dimension) float + Vertices in space + + Returns + ----------- + bounds : (2, dimension) float + Coordinates of AABB, in (min, max) form + """ + bounds = np.array( + [vertices[self.points].min(axis=0), vertices[self.points].max(axis=0)] + ) + return bounds + + def length(self, vertices): + """ + Return the total length of the entity. + + Parameters + -------------- + vertices : (n, dimension) float + Vertices in space + + Returns + --------- + length : float + Total length of entity + """ + diff = np.diff(self.discrete(vertices), axis=0) ** 2 + length = (np.dot(diff, [1] * vertices.shape[1]) ** 0.5).sum() + return length + + def explode(self): + """ + Split the entity into multiple entities. + + Returns + ------------ + explode : list of Entity + Current entity split into multiple entities. + """ + return [self.copy()] + + def copy(self): + """ + Return a copy of the current entity. + + Returns + ------------ + copied : Entity + Copy of current entity + """ + copied = deepcopy(self) + # only copy metadata if set + if hasattr(self, "_metadata"): + copied._metadata = deepcopy(self._metadata) + # check for very annoying subtle copy failures + assert id(copied._metadata) != id(self._metadata) + assert id(copied.points) != id(self.points) + return copied + + def __hash__(self): + """ + Return a hash that represents the current entity. + + Returns + ---------- + hashed : int + Hash of current class name, points, and closed + """ + return hash(self._bytes()) + + def _bytes(self): + """ + Get hashable bytes that define the current entity. + + Returns + ------------ + data : bytes + Hashable data defining the current entity + """ + # give consistent ordering of points for hash + if self.points[0] > self.points[-1]: + return self.__class__.__name__.encode("utf-8") + self.points.tobytes() + else: + return self.__class__.__name__.encode("utf-8") + self.points[::-1].tobytes() + + +class Text(Entity): + """ + Text to annotate a 2D or 3D path. + """ + + def __init__( + self, + origin, + text, + height=None, + vector=None, + normal=None, + align=None, + layer=None, + color=None, + metadata=None, + ): + """ + An entity for text labels. + + Parameters + -------------- + origin : int + Index of a single vertex for text origin + text : str + The text to label + height : float or None + The height of text + vector : int or None + An vertex index for which direction text + is written along unitized: vector - origin + normal : int or None + A vertex index for the plane normal: + vector is along unitized: normal - origin + align : (2,) str or None + Where to draw from for [horizontal, vertical]: + 'center', 'left', 'right' + """ + # where is text placed + self.origin = origin + # what direction is the text pointing + self.vector = vector + # what is the normal of the text plane + self.normal = normal + # how high is the text entity + self.height = height + # what layer is the entity on + if layer is not None: + self.layer = layer + + if metadata is not None: + self.metadata.update(metadata) + + # what color is the entity + self.color = color + + # None or (2,) str + if align is None: + # if not set make everything centered + align = ["center", "center"] + elif isinstance(align, str): + # if only one is passed set for both + # horizontal and vertical + align = [align, align] + elif len(align) != 2: + # otherwise raise rror + raise ValueError("align must be (2,) str") + + self.align = align + + # make sure text is a string + if hasattr(text, "decode"): + self.text = text.decode("utf-8") + else: + self.text = str(text) + + @property + def origin(self): + """ + The origin point of the text. + + Returns + ----------- + origin : int + Index of vertices + """ + return self.points[0] + + @origin.setter + def origin(self, value): + value = int(value) + if not hasattr(self, "points") or np.ptp(self.points) == 0: + self.points = np.ones(3, dtype=np.int64) * value + else: + self.points[0] = value + + @property + def vector(self): + """ + A point representing the text direction + along the vector: vertices[vector] - vertices[origin] + + Returns + ---------- + vector : int + Index of vertex + """ + return self.points[1] + + @vector.setter + def vector(self, value): + if value is None: + return + self.points[1] = int(value) + + @property + def normal(self): + """ + A point representing the plane normal along the + vector: vertices[normal] - vertices[origin] + + Returns + ------------ + normal : int + Index of vertex + """ + return self.points[2] + + @normal.setter + def normal(self, value): + if value is None: + return + self.points[2] = int(value) + + def plot(self, vertices, show=False): + """ + Plot the text using matplotlib. + + Parameters + -------------- + vertices : (n, 2) float + Vertices in space + show : bool + If True, call plt.show() + """ + if vertices.shape[1] != 2: + raise ValueError("only for 2D points!") + + import matplotlib.pyplot as plt # noqa + + # get rotation angle in degrees + angle = np.degrees(self.angle(vertices)) + + # TODO: handle text size better + plt.text( + *vertices[self.origin], + s=self.text, + rotation=angle, + ha=self.align[0], + va=self.align[1], + size=18, + ) + + if show: + plt.show() + + def angle(self, vertices): + """ + If Text is 2D, get the rotation angle in radians. + + Parameters + ----------- + vertices : (n, 2) float + Vertices in space referenced by self.points + + Returns + --------- + angle : float + Rotation angle in radians + """ + + if vertices.shape[1] != 2: + raise ValueError("angle only valid for 2D points!") + + # get the vector from origin + direction = vertices[self.vector] - vertices[self.origin] + # get the rotation angle in radians + angle = np.arctan2(*direction[::-1]) + + return angle + + def length(self, vertices): + return 0.0 + + def discrete(self, *args, **kwargs): + return np.array([]) + + @property + def closed(self): + return False + + @property + def is_valid(self): + return True + + @property + def nodes(self): + return np.array([]) + + @property + def end_points(self): + return np.array([]) + + def _bytes(self): + data = b"".join([b"Text", self.points.tobytes(), self.text.encode("utf-8")]) + return data + + +class Line(Entity): + """ + A line or poly-line entity + """ + + def discrete(self, vertices, scale=1.0): + """ + Discretize into a world- space path. + + Parameters + ------------ + vertices: (n, dimension) float + Points in space + scale : float + Size of overall scene for numerical comparisons + + Returns + ------------- + discrete: (m, dimension) float + Path in space composed of line segments + """ + return self._orient(vertices[self.points]) + + @property + def closed(self): + return len(self.points) > 2 and self.points[0] == self.points[-1] + + @closed.setter + def closed(self, value: bool): + current = self.points[0] == self.points[-1] + if value and not current: + # case where we've been asked to close the line + # this seems pretty obvious that we should just append the first pointOB + self.points = np.concatenate((self.points, [self.points[0]])) + elif not value and current: + # case where we've been asked to *disconnect* a closed path + log.debug("ignoring `Line.closed = False`") + + @property + def is_valid(self): + """ + Is the current entity valid. + + Returns + ----------- + valid : bool + Is the current entity well formed + """ + valid = np.any((self.points - self.points[0]) != 0) + return valid + + def explode(self): + """ + If the current Line entity consists of multiple line + break it up into n Line entities. + + Returns + ---------- + exploded: (n,) Line entities + """ + # copy over the current layer + layer = self.layer + points = ( + np.column_stack((self.points, self.points)).ravel()[1:-1].reshape((-1, 2)) + ) + exploded = [Line(i, layer=layer) for i in points] + return exploded + + def _bytes(self): + # give consistent ordering of points for hash + if self.points[0] > self.points[-1]: + return b"Line" + self.points.tobytes() + else: + return b"Line" + self.points[::-1].tobytes() + + def to_dict(self) -> dict: + """ + Returns a dictionary with all of the information + about the Line. `closed` is not additional information + for a Line like it is for Arc where the value determines + if it is a partial or complete circle. Rather it is a check + which indicates the first and last points are identical, + and thus should not be included in the export + + Returns + ----------- + as_dict + Has keys 'type', 'points' + """ + return { + "type": self.__class__.__name__, + "points": self.points.tolist(), + } + + +class Arc(Entity): + @property + def closed(self): + """ + A boolean flag for whether the arc is closed (a circle) or not. + + Returns + ---------- + closed : bool + If set True, Arc will be a closed circle + """ + return getattr(self, "_closed", False) + + @closed.setter + def closed(self, value): + """ + Set the Arc to be closed or not, without + changing the control points + + Parameters + ------------ + value : bool + Should this Arc be a closed circle or not + """ + self._closed = bool(value) + + @property + def is_valid(self): + """ + Is the current Arc entity valid. + + Returns + ----------- + valid : bool + Does the current Arc have exactly 3 control points + """ + return len(np.unique(self.points)) == 3 + + def _bytes(self): + # give consistent ordering of points for hash + order = int(self.points[0] > self.points[-1]) * 2 - 1 + return b"Arc" + bytes(self.closed) + self.points[::order].tobytes() + + def length(self, vertices): + """ + Return the arc length of the 3-point arc. + + Parameter + ---------- + vertices : (n, d) float + Vertices for overall drawing. + + Returns + ----------- + length : float + Length of arc. + """ + # find the actual radius and angle span + if self.closed: + # we don't need the angular span as + # it's indicated as a closed circle + fit = self.center(vertices, return_normal=False, return_angle=False) + return np.pi * fit.radius * 2 + # get the angular span of the circular arc + fit = self.center(vertices, return_normal=False, return_angle=True) + return fit.span * fit.radius + + def discrete(self, vertices, scale=1.0): + """ + Discretize the arc entity into line sections. + + Parameters + ------------ + vertices : (n, dimension) float + Points in space + scale : float + Size of overall scene for numerical comparisons + + Returns + ------------- + discrete : (m, dimension) float + Path in space made up of line segments + """ + + return self._orient( + discretize_arc(vertices[self.points], close=self.closed, scale=scale) + ) + + def center(self, vertices, **kwargs): + """ + Return the center information about the arc entity. + + Parameters + ------------- + vertices : (n, dimension) float + Vertices in space + + Returns + ------------- + info : dict + With keys: 'radius', 'center' + """ + return arc_center(vertices[self.points], **kwargs) + + def bounds(self, vertices): + """ + Return the AABB of the arc entity. + + Parameters + ----------- + vertices: (n, dimension) float + Vertices in space + + Returns + ----------- + bounds : (2, dimension) float + Coordinates of AABB in (min, max) form + """ + if util.is_shape(vertices, (-1, 2)) and self.closed: + # if we have a closed arc (a circle), we can return the actual bounds + # this only works in two dimensions, otherwise this would return the + # AABB of an sphere + info = self.center(vertices, return_normal=False, return_angle=False) + bounds = np.array( + [info.center - info.radius, info.center + info.radius], dtype=np.float64 + ) + else: + # since the AABB of a partial arc is hard, approximate + # the bounds by just looking at the discrete values + discrete = self.discrete(vertices) + bounds = np.array( + [discrete.min(axis=0), discrete.max(axis=0)], dtype=np.float64 + ) + return bounds + + +class Curve(Entity): + """ + The parent class for all wild curves in space. + """ + + @property + def nodes(self): + # a point midway through the curve + mid = self.points[len(self.points) // 2] + return [[self.points[0], mid], [mid, self.points[-1]]] + + +class Bezier(Curve): + """ + An open or closed Bezier curve + """ + + def discrete(self, vertices, scale=1.0, count=None): + """ + Discretize the Bezier curve. + + Parameters + ------------- + vertices : (n, 2) or (n, 3) float + Points in space + scale : float + Scale of overall drawings (for precision) + count : int + Number of segments to return + + Returns + ------------- + discrete : (m, 2) or (m, 3) float + Curve as line segments + """ + return self._orient( + discretize_bezier(vertices[self.points], count=count, scale=scale) + ) + + +class BSpline(Curve): + """ + An open or closed B- Spline. + """ + + def __init__(self, points, knots, layer=None, metadata=None, color=None, **kwargs): + self.points = np.asanyarray(points, dtype=np.int64) + self.knots = np.asanyarray(knots, dtype=np.float64) + if layer is not None: + self.layer = layer + if metadata is not None: + self.metadata.update(metadata) + self._cache = {} + self.kwargs = kwargs + self.color = color + + def discrete(self, vertices, count=None, scale=1.0): + """ + Discretize the B-Spline curve. + + Parameters + ------------- + vertices : (n, 2) or (n, 3) float + Points in space + scale : float + Scale of overall drawings (for precision) + count : int + Number of segments to return + + Returns + ------------- + discrete : (m, 2) or (m, 3) float + Curve as line segments + """ + discrete = discretize_bspline( + control=vertices[self.points], knots=self.knots, count=count, scale=scale + ) + return self._orient(discrete) + + def _bytes(self): + # give consistent ordering of points for hash + if self.points[0] > self.points[-1]: + return b"BSpline" + self.knots.tobytes() + self.points.tobytes() + else: + return b"BSpline" + self.knots[::-1].tobytes() + self.points[::-1].tobytes() + + def to_dict(self) -> dict: + """ + Returns a dictionary with all of the information + about the entity. + """ + return { + "type": self.__class__.__name__, + "points": self.points.tolist(), + "knots": self.knots.tolist(), + "closed": self.closed, + } diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c6ea3a83c4f52e7ee3b4435e0543a53f3589dc4d Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/dxf.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/dxf.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ee0dedcdc648cd1d934c8dc5fd2c1f0050ee0a9e Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/dxf.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/export.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/export.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ac7b1d55a7cafc6b007440513cfb340fc29c5306 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/export.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/load.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/load.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..09b28c78f374eb3cad93c4ff7b1cbd80d03139f1 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/load.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/misc.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/misc.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a5857f5a15abdd52aeedb72fa45370a068fc1733 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/misc.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/svg_io.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/svg_io.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..caabc747be72399735af748bc31a68c9128af171 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/__pycache__/svg_io.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/dxf.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/dxf.py new file mode 100644 index 0000000000000000000000000000000000000000..b8a00c0752548672a91db0fa7af0f0cf7ac0fa77 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/dxf.py @@ -0,0 +1,964 @@ +from collections import defaultdict + +import numpy as np + +from ... import grouping, resources, util +from ... import transformations as tf +from ...constants import log +from ...constants import tol_path as tol +from ...util import multi_dict +from ..arc import to_threepoint +from ..entities import Arc, BSpline, Line, Text + +# unit codes +_DXF_UNITS = { + 1: "inches", + 2: "feet", + 3: "miles", + 4: "millimeters", + 5: "centimeters", + 6: "meters", + 7: "kilometers", + 8: "microinches", + 9: "mils", + 10: "yards", + 11: "angstroms", + 12: "nanometers", + 13: "microns", + 14: "decimeters", + 15: "decameters", + 16: "hectometers", + 17: "gigameters", + 18: "AU", + 19: "light years", + 20: "parsecs", +} +# backwards, for reference +_UNITS_TO_DXF = {v: k for k, v in _DXF_UNITS.items()} + +# a string which we will replace spaces with temporarily +_SAFESPACE = "|<^>|" + +# save metadata to a DXF Xrecord starting here +# Valid values are 1-369 (except 5 and 105) +XRECORD_METADATA = 134 +# the sentinel string for trimesh metadata +# this should be seen at XRECORD_METADATA +XRECORD_SENTINEL = "TRIMESH_METADATA:" +# the maximum line length before we split lines +XRECORD_MAX_LINE = 200 +# the maximum index of XRECORDS +XRECORD_MAX_INDEX = 368 + + +def load_dxf(file_obj, **kwargs): + """ + Load a DXF file to a dictionary containing vertices and + entities. + + Parameters + ---------- + file_obj: file or file- like object (has object.read method) + + Returns + ---------- + result: dict, keys are entities, vertices and metadata + """ + + # in a DXF file, lines come in pairs, + # a group code then the next line is the value + # we are removing all whitespace then splitting with the + # splitlines function which uses the universal newline method + raw = file_obj.read() + # if we've been passed bytes + if hasattr(raw, "decode"): + # search for the sentinel string indicating binary DXF + # do it by encoding sentinel to bytes and subset searching + if raw[:22].find(b"AutoCAD Binary DXF") != -1: + # no converter to ASCII DXF available + raise NotImplementedError("Binary DXF is not supported!") + else: + # we've been passed bytes that don't have the + # header for binary DXF so try decoding as UTF-8 + raw = raw.decode("utf-8", errors="ignore") + + # remove trailing whitespace + raw = str(raw).strip() + # without any spaces and in upper case + cleaned = raw.replace(" ", "").strip().upper() + + # blob with spaces and original case + blob_raw = np.array(str.splitlines(raw)).reshape((-1, 2)) + # if this reshape fails, it means the DXF is malformed + blob = np.array(str.splitlines(cleaned)).reshape((-1, 2)) + + # get the section which contains the header in the DXF file + endsec = np.nonzero(blob[:, 1] == "ENDSEC")[0] + + # store metadata + metadata = {} + + # try reading the header, which may be malformed + header_start = np.nonzero(blob[:, 1] == "HEADER")[0] + if len(header_start) > 0: + header_end = endsec[np.searchsorted(endsec, header_start[0])] + header_blob = blob[header_start[0] : header_end] + + # store some properties from the DXF header + metadata["DXF_HEADER"] = {} + for key, group in [ + ("$ACADVER", "1"), + ("$DIMSCALE", "40"), + ("$DIMALT", "70"), + ("$DIMALTF", "40"), + ("$DIMUNIT", "70"), + ("$INSUNITS", "70"), + ("$LUNITS", "70"), + ]: + value = get_key(header_blob, key, group) + if value is not None: + metadata["DXF_HEADER"][key] = value + + # store unit data pulled from the header of the DXF + # prefer LUNITS over INSUNITS + # I couldn't find a table for LUNITS values but they + # look like they are 0- indexed versions of + # the INSUNITS keys, so for now offset the key value + for offset, key in [(-1, "$LUNITS"), (0, "$INSUNITS")]: + # get the key from the header blob + units = get_key(header_blob, key, "70") + # if it exists add the offset + if units is None: + continue + metadata[key] = units + units += offset + # if the key is in our list of units store it + if units in _DXF_UNITS: + metadata["units"] = _DXF_UNITS[units] + # warn on drawings with no units + if "units" not in metadata: + log.debug("DXF doesn't have units specified!") + + # get the section which contains entities in the DXF file + entity_start = np.nonzero(blob[:, 1] == "ENTITIES")[0][0] + entity_end = endsec[np.searchsorted(endsec, entity_start)] + + blocks = None + check_entity = blob[entity_start:entity_end][:, 1] + # only load blocks if an entity references them via an INSERT + if "INSERT" in check_entity or "BLOCK" in check_entity: + try: + # which part of the raw file contains blocks + block_start = np.nonzero(blob[:, 1] == "BLOCKS")[0][0] + block_end = endsec[np.searchsorted(endsec, block_start)] + + blob_block = blob[block_start:block_end] + blob_block_raw = blob_raw[block_start:block_end] + block_infl = np.nonzero((blob_block == ["0", "BLOCK"]).all(axis=1))[0] + + # collect blocks by name + blocks = {} + for index in np.array_split(np.arange(len(blob_block)), block_infl): + try: + v, e, name = convert_entities( + blob_block[index], blob_block_raw[index], return_name=True + ) + if len(e) > 0: + blocks[name] = (v, e) + except BaseException: + pass + except BaseException: + log.error("failed to parse blocks!", exc_info=True) + + # actually load referenced entities + vertices, entities = convert_entities( + blob[entity_start:entity_end], blob_raw[entity_start:entity_end], blocks=blocks + ) + + # return result as kwargs for trimesh.path.Path2D constructor + result = {"vertices": vertices, "entities": entities, "metadata": metadata} + + return result + + +def convert_entities(blob, blob_raw=None, blocks=None, return_name=False): + """ + Convert a chunk of entities into trimesh entities. + + Parameters + ------------ + blob : (n, 2) str + Blob of entities uppercased + blob_raw : (n, 2) str + Blob of entities not uppercased + blocks : None or dict + Blocks referenced by INSERT entities + return_name : bool + If True return the first '2' value + + Returns + ---------- + """ + + if blob_raw is None: + blob_raw = blob + + def info(e): + """ + Pull metadata based on group code, and return as a dict. + """ + # which keys should we extract from the entity data + # DXF group code : our metadata key + get = {"8": "layer", "2": "name"} + # replace group codes with names and only + # take info from the entity dict if it is in cand + renamed = {get[k]: util.make_sequence(v)[0] for k, v in e.items() if k in get} + return renamed + + def convert_line(e): + """ + Convert DXF LINE entities into trimesh Line entities. + """ + # create a single Line entity + entities.append(Line(points=len(vertices) + np.arange(2), **info(e))) + # add the vertices to our collection + vertices.extend( + np.array([[e["10"], e["20"]], [e["11"], e["21"]]], dtype=np.float64) + ) + + def convert_circle(e): + """ + Convert DXF CIRCLE entities into trimesh Circle entities + """ + R = float(e["40"]) + C = np.array([e["10"], e["20"]]).astype(np.float64) + points = to_threepoint(center=C[:2], radius=R) + entities.append( + Arc(points=(len(vertices) + np.arange(3)), closed=True, **info(e)) + ) + vertices.extend(points) + + def convert_arc(e): + """ + Convert DXF ARC entities into into trimesh Arc entities. + """ + # the radius of the circle + R = float(e["40"]) + # the center point of the circle + C = np.array([e["10"], e["20"]], dtype=np.float64) + # the start and end angle of the arc, in degrees + # this may depend on an AUNITS header data + A = np.radians(np.array([e["50"], e["51"]], dtype=np.float64)) + # convert center/radius/angle representation + # to three points on the arc representation + points = to_threepoint(center=C[:2], radius=R, angles=A) + # add a single Arc entity + entities.append(Arc(points=len(vertices) + np.arange(3), closed=False, **info(e))) + # add the three vertices + vertices.extend(points) + + def convert_polyline(e): + """ + Convert DXF LWPOLYLINE entities into trimesh Line entities. + """ + # load the points in the line + lines = np.column_stack((e["10"], e["20"])).astype(np.float64) + + # save entity info so we don't have to recompute + polyinfo = info(e) + + # 70 is the closed flag for polylines + # if the closed flag is set make sure to close + is_closed = "70" in e and int(e["70"][0]) & 1 + if is_closed: + lines = np.vstack((lines, lines[:1])) + + # 42 is the vertex bulge flag for LWPOLYLINE entities + # "bulge" is autocad for "add a stupid arc using flags + # in my otherwise normal polygon", it's like SVG arc + # flags but somehow even more annoying + if "42" in e: + # get the actual bulge float values + bulge = np.array(e["42"], dtype=np.float64) + # what position were vertices stored at + vid = np.nonzero(chunk[:, 0] == "10")[0] + # what position were bulges stored at in the chunk + bid = np.nonzero(chunk[:, 0] == "42")[0] + # filter out endpoint bulge if we're not closed + if not is_closed: + bid_ok = bid < vid.max() + bid = bid[bid_ok] + bulge = bulge[bid_ok] + # which vertex index is bulge value associated with + bulge_idx = np.searchsorted(vid, bid) + # convert stupid bulge to Line/Arc entities + v, e = bulge_to_arcs( + lines=lines, bulge=bulge, bulge_idx=bulge_idx, is_closed=is_closed + ) + for i in e: + # offset added entities by current vertices length + i.points += len(vertices) + vertices.extend(v) + entities.extend(e) + # done with this polyline + return + + # we have a normal polyline so just add it + # as single line entity and vertices + entities.append(Line(points=np.arange(len(lines)) + len(vertices), **polyinfo)) + vertices.extend(lines) + + def convert_bspline(e): + """ + Convert DXF Spline entities into trimesh BSpline entities. + """ + # in the DXF there are n points and n ordered fields + # with the same group code + + points = np.column_stack((e["10"], e["20"])).astype(np.float64) + knots = np.array(e["40"]).astype(np.float64) + + # if there are only two points, save it as a line + if len(points) == 2: + # create a single Line entity + entities.append(Line(points=len(vertices) + np.arange(2), **info(e))) + # add the vertices to our collection + vertices.extend(points) + return + + # check bit coded flag for closed + # closed = bool(int(e['70'][0]) & 1) + # check euclidean distance to see if closed + closed = np.linalg.norm(points[0] - points[-1]) < tol.merge + + # create a BSpline entity + entities.append( + BSpline( + points=np.arange(len(points)) + len(vertices), + knots=knots, + closed=closed, + **info(e), + ) + ) + # add the vertices + vertices.extend(points) + + def convert_text(e): + """ + Convert a DXF TEXT entity into a native text entity. + """ + # text with leading and trailing whitespace removed + text = e["1"].strip() + # try getting optional height of text + try: + height = float(e["40"]) + except BaseException: + height = None + try: + # rotation angle converted to radians + angle = np.radians(float(e["50"])) + except BaseException: + # otherwise no rotation + angle = 0.0 + # origin point + origin = np.array([e["10"], e["20"]], dtype=np.float64) + # an origin-relative point (so transforms work) + vector = origin + [np.cos(angle), np.sin(angle)] + # try to extract a (horizontal, vertical) text alignment + align = ["center", "center"] + try: + align[0] = ["left", "center", "right"][int(e["72"])] + except BaseException: + pass + # append the entity + entities.append( + Text( + origin=len(vertices), + vector=len(vertices) + 1, + height=height, + text=text, + align=align, + ) + ) + # append the text origin and direction + vertices.append(origin) + vertices.append(vector) + + def convert_insert(e): + """ + Convert an INSERT entity, which inserts a named group of + entities (i.e. a "BLOCK") at a specific location. + """ + if blocks is None: + return + + # name of block to insert + name = e["2"] + # if we haven't loaded the block skip + if name not in blocks: + return + # angle to rotate the block by + angle = float(e.get("50", 0.0)) + # the insertion point of the block + offset = np.array([e.get("10", 0.0), e.get("20", 0.0)], dtype=np.float64) + # what to scale the block by + scale = np.array([e.get("41", 1.0), e.get("42", 1.0)], dtype=np.float64) + + # the current entities and vertices of the referenced block. + cv, ce = blocks[name] + for i in ce: + # copy the referenced entity as it may be included multiple times + entities.append(i.copy()) + # offset its vertices to the current index + entities[-1].points += len(vertices) + # transform the block's vertices based on the entity settings + vertices.extend( + tf.transform_points( + cv, tf.planar_matrix(offset=offset, theta=np.radians(angle), scale=scale) + ) + ) + + # find the start points of entities + # DXF object to trimesh object converters + loaders = { + "LINE": (dict, convert_line), + "LWPOLYLINE": (multi_dict, convert_polyline), + "ARC": (dict, convert_arc), + "CIRCLE": (dict, convert_circle), + "SPLINE": (multi_dict, convert_bspline), + "INSERT": (dict, convert_insert), + "BLOCK": (dict, convert_insert), + } + + # store loaded vertices + vertices = [] + # store loaded entities + entities = [] + # an old-style polyline entity strings its data across + # multiple vertex entities like a real asshole + polyline = None + # chunks of entities are divided by group-code-0 + inflection = np.nonzero(blob[:, 0] == "0")[0] + + unsupported = defaultdict(lambda: 0) + + # loop through chunks of entity information + for index in np.array_split(np.arange(len(blob)), inflection): + # if there is only a header continue + if len(index) < 1: + continue + # chunk will be an (n, 2) array of (group code, data) pairs + chunk = blob[index] + # the string representing entity type + entity_type = chunk[0][1] + + # if we are referencing a block or insert by name make + # sure the name key is in the original case vs upper-case + if entity_type in ("BLOCK", "INSERT"): + try: + index_name = next(i for i, v in enumerate(chunk) if v[0] == "2") + chunk[index_name][1] = blob_raw[index][index_name][1] + except StopIteration: + pass + + # special case old- style polyline entities + if entity_type == "POLYLINE": + polyline = [dict(chunk)] + # if we are collecting vertex entities + elif polyline is not None and entity_type == "VERTEX": + polyline.append(dict(chunk)) + # the end of a polyline + elif polyline is not None and entity_type == "SEQEND": + # pull the geometry information for the entity + lines = np.array([[i["10"], i["20"]] for i in polyline[1:]], dtype=np.float64) + + is_closed = False + # check for a closed flag on the polyline + if "70" in polyline[0]: + # flag is bit- coded integer + flag = int(polyline[0]["70"]) + # first bit represents closed + is_closed = bool(flag & 1) + if is_closed: + lines = np.vstack((lines, lines[:1])) + + # get the index of each bulged vertices + bulge_idx = np.array( + [i for i, e in enumerate(polyline) if "42" in e], dtype=np.int64 + ) + # get the actual bulge value + bulge = np.array( + [float(e["42"]) for i, e in enumerate(polyline) if "42" in e], + dtype=np.float64, + ) + # convert bulge to new entities + cv, ce = bulge_to_arcs( + lines=lines, bulge=bulge, bulge_idx=bulge_idx, is_closed=is_closed + ) + for i in ce: + # offset entities by existing vertices + i.points += len(vertices) + vertices.extend(cv) + entities.extend(ce) + # we no longer have an active polyline + polyline = None + elif entity_type == "TEXT": + # text entities need spaces preserved so take + # group codes from clean representation (0- column) + # and data from the raw representation (1- column) + chunk_raw = blob_raw[index] + # if we didn't use clean group codes we wouldn't + # be able to access them by key as whitespace + # is random and crazy, like: ' 1 ' + chunk_raw[:, 0] = blob[index][:, 0] + try: + convert_text(dict(chunk_raw)) + except BaseException: + log.debug("failed to load text entity!", exc_info=True) + # if the entity contains all relevant data we can + # cleanly load it from inside a single function + elif entity_type in loaders: + # the chunker converts an (n,2) list into a dict + chunker, loader = loaders[entity_type] + # convert data to dict + entity_data = chunker(chunk) + # append data to the lists we're collecting + loader(entity_data) + elif entity_type != "ENTITIES": + unsupported[entity_type] += 1 + if len(unsupported) > 0: + log.debug( + "skipping dxf entities: {}".format( + ", ".join(f"{k}: {v}" for k, v in unsupported.items()) + ) + ) + # stack vertices into single array + vertices = util.vstack_empty(vertices).astype(np.float64) + if return_name: + name = blob_raw[blob[:, 0] == "2"][0][1] + return vertices, entities, name + + return vertices, entities + + +def export_dxf(path, only_layers=None): + """ + Export a 2D path object to a DXF file. + + Parameters + ---------- + path : trimesh.path.path.Path2D + Input geometry to export + only_layers : None or set + If passed only export the layers specified + + Returns + ---------- + export : str + Path formatted as a DXF file + """ + # get the template for exporting DXF files + template = resources.get_json("templates/dxf.json") + + def format_points(points, as_2D=False, increment=True): + """ + Format points into DXF- style point string. + + Parameters + ----------- + points : (n,2) or (n,3) float + Points in space + as_2D : bool + If True only output 2 points per vertex + increment : bool + If True increment group code per point + Example: + [[X0, Y0, Z0], [X1, Y1, Z1]] + Result, new lines replaced with spaces: + True -> 10 X0 20 Y0 30 Z0 11 X1 21 Y1 31 Z1 + False -> 10 X0 20 Y0 30 Z0 10 X1 20 Y1 30 Z1 + + Returns + ----------- + packed : str + Points formatted with group code + """ + points = np.asanyarray(points, dtype=np.float64) + # get points in 3D + three = util.stack_3D(points) + if increment: + group = np.tile( + np.arange(len(three), dtype=np.int64).reshape((-1, 1)), (1, 3) + ) + else: + group = np.zeros((len(three), 3), dtype=np.int64) + group += [10, 20, 30] + + if as_2D: + group = group[:, :2] + three = three[:, :2] + # join into result string + packed = "\n".join( + f"{g:d}\n{v:.12g}" for g, v in zip(group.reshape(-1), three.reshape(-1)) + ) + + return packed + + def entity_info(entity): + """ + Pull layer, color, and name information about an entity + + Parameters + ----------- + entity : entity object + Source entity to pull metadata + + Returns + ---------- + subs : dict + Has keys 'COLOR', 'LAYER', 'NAME' + """ + # TODO : convert RGBA entity.color to index + subs = { + "COLOR": 255, # default is ByLayer + "LAYER": 0, + "NAME": str(id(entity))[:16], + } + if hasattr(entity, "layer"): + # make sure layer name is forced into ASCII + subs["LAYER"] = util.to_ascii(entity.layer) + return subs + + def convert_line(line, vertices): + """ + Convert an entity to a discrete polyline + + Parameters + ------------- + line : entity + Entity which has 'e.discrete' method + vertices : (n, 2) float + Vertices in space + + Returns + ----------- + as_dxf : str + Entity exported as a DXF + """ + # get a discrete representation of entity + points = line.discrete(vertices) + # if one or fewer points return nothing + if len(points) <= 1: + return "" + + # generate a substitution dictionary for template + subs = entity_info(line) + subs["POINTS"] = format_points(points, as_2D=True, increment=False) + subs["TYPE"] = "LWPOLYLINE" + subs["VCOUNT"] = len(points) + # 1 is closed + # 0 is default (open) + subs["FLAG"] = int(bool(line.closed)) + + result = template["line"].format(**subs) + return result + + def convert_arc(arc, vertices): + # get the center of arc and include span angles + info = arc.center(vertices, return_angle=True, return_normal=False) + subs = entity_info(arc) + center = info.center + if len(center) == 2: + center = np.append(center, 0.0) + data = "10\n{:.12g}\n20\n{:.12g}\n30\n{:.12g}".format(*center) + data += f"\n40\n{info.radius:.12g}" + + if arc.closed: + subs["TYPE"] = "CIRCLE" + else: + subs["TYPE"] = "ARC" + # an arc is the same as a circle, with an added start + # and end angle field + data += "\n100\nAcDbArc" + data += "\n50\n{:.12g}\n51\n{:.12g}".format(*np.degrees(info.angles)) + subs["DATA"] = data + result = template["arc"].format(**subs) + + return result + + def convert_bspline(spline, vertices): + # points formatted with group code + points = format_points(vertices[spline.points], increment=False) + + # (n,) float knots, formatted with group code + knots = ("40\n{:.12g}\n" * len(spline.knots)).format(*spline.knots)[:-1] + + # bit coded + flags = {"closed": 1, "periodic": 2, "rational": 4, "planar": 8, "linear": 16} + + flag = flags["planar"] + if spline.closed: + flag = flag | flags["closed"] + + normal = [0.0, 0.0, 1.0] + n_code = [210, 220, 230] + n_str = "\n".join(f"{i:d}\n{j:.12g}" for i, j in zip(n_code, normal)) + + subs = entity_info(spline) + subs.update( + { + "TYPE": "SPLINE", + "POINTS": points, + "KNOTS": knots, + "NORMAL": n_str, + "DEGREE": 3, + "FLAG": flag, + "FCOUNT": 0, + "KCOUNT": len(spline.knots), + "PCOUNT": len(spline.points), + } + ) + # format into string template + result = template["bspline"].format(**subs) + + return result + + def convert_text(txt, vertices): + """ + Convert a Text entity to DXF string. + """ + # start with layer info + sub = entity_info(txt) + # get the origin point of the text + sub["ORIGIN"] = format_points(vertices[[txt.origin]], increment=False) + # rotation angle in degrees + sub["ANGLE"] = np.degrees(txt.angle(vertices)) + # actual string of text with spaces escaped + # force into ASCII to avoid weird encoding issues + sub["TEXT"] = ( + txt.text.replace(" ", _SAFESPACE) + .encode("ascii", errors="ignore") + .decode("ascii") + ) + # height of text + sub["HEIGHT"] = txt.height + result = template["text"].format(**sub) + return result + + def convert_generic(entity, vertices): + """ + For entities we don't know how to handle, return their + discrete form as a polyline + """ + return convert_line(entity, vertices) + + # make sure we're not losing a ton of + # precision in the string conversion + np.set_printoptions(precision=12) + # trimesh entity to DXF entity converters + conversions = { + "Line": convert_line, + "Text": convert_text, + "Arc": convert_arc, + "Bezier": convert_generic, + "BSpline": convert_bspline, + } + collected = [] + for e, layer in zip(path.entities, path.layers): + name = type(e).__name__ + # only export specified layers + if only_layers is not None and layer not in only_layers: + continue + if name in conversions: + converted = conversions[name](e, path.vertices).strip() + if len(converted) > 0: + # only save if we converted something + collected.append(converted) + else: + log.debug("Entity type %s not exported!", name) + + # join all entities into one string + entities_str = "\n".join(collected) + + # add in the extents of the document as explicit XYZ lines + hsub = {f"EXTMIN_{k}": v for k, v in zip("XYZ", np.append(path.bounds[0], 0.0))} + hsub.update({f"EXTMAX_{k}": v for k, v in zip("XYZ", np.append(path.bounds[1], 0.0))}) + # apply a units flag defaulting to `1` + hsub["LUNITS"] = _UNITS_TO_DXF.get(path.units, 1) + # run the format for the header + sections = [template["header"].format(**hsub).strip()] + # do the same for entities + sections.append(template["entities"].format(ENTITIES=entities_str).strip()) + # and the footer + sections.append(template["footer"].strip()) + + # filter out empty sections + # random whitespace causes AutoCAD to fail to load + # although Draftsight, LibreCAD, and Inkscape don't care + # what a giant legacy piece of shit + # create the joined string blob + blob = "\n".join(sections).replace(_SAFESPACE, " ") + # run additional self- checks + if tol.strict: + # check that every line pair is (group code, value) + lines = str.splitlines(str(blob)) + # should be even number of lines + assert (len(lines) % 2) == 0 + # group codes should all be convertible to int and positive + assert all(int(i) >= 0 for i in lines[::2]) + # make sure we didn't slip any unicode in there + blob.encode("ascii") + + return blob + + +def bulge_to_arcs(lines, bulge, bulge_idx, is_closed=False, metadata=None): + """ + Polylines can have "vertex bulge" which means the polyline + has an arc tangent to segments, rather than meeting at a + vertex. + + From Autodesk reference: + The bulge is the tangent of one fourth the included + angle for an arc segment, made negative if the arc + goes clockwise from the start point to the endpoint. + A bulge of 0 indicates a straight segment, and a + bulge of 1 is a semicircle. + + Parameters + ---------------- + lines : (n, 2) float + Polyline vertices in order + bulge : (m,) float + Vertex bulge value + bulge_idx : (m,) float + Which index of lines is bulge associated with + is_closed : bool + Is segment closed + metadata : None, or dict + Entity metadata to add + + Returns + --------------- + vertices : (a, 2) float + New vertices for poly-arc + entities : (b,) entities.Entity + New entities, either line or arc + """ + # make sure lines are 2D array + lines = np.asanyarray(lines, dtype=np.float64) + + # make sure inputs are numpy arrays + bulge = np.asanyarray(bulge, dtype=np.float64) + bulge_idx = np.asanyarray(bulge_idx, dtype=np.int64) + + # filter out zero- bulged polylines + ok = np.abs(bulge) > 1e-5 + bulge = bulge[ok] + bulge_idx = bulge_idx[ok] + + # metadata to apply to new entities + if metadata is None: + metadata = {} + + # if there's no bulge, just return the input curve + if len(bulge) == 0: + index = np.arange(len(lines)) + # add a single line entity and vertices + entities = [Line(index, **metadata)] + return lines, entities + + # use bulge to calculate included angle of the arc + angle = np.arctan(bulge) * 4.0 + # the indexes making up a bulged segment + tid = np.column_stack((bulge_idx, bulge_idx - 1)) + # if it's a closed segment modulus to start vertex + if is_closed: + tid %= len(lines) + + # the vector connecting the two ends of the arc + vector = lines[tid[:, 0]] - lines[tid[:, 1]] + + # the length of the connector segment + length = np.linalg.norm(vector, axis=1) + + # perpendicular vectors by crossing vector with Z + perp = np.cross( + np.column_stack((vector, np.zeros(len(vector)))), + np.ones((len(vector), 3)) * [0, 0, 1], + ) + # strip the zero Z + perp = util.unitize(perp[:, :2]) + + # midpoint of each line + midpoint = lines[tid].mean(axis=1) + + # calculate the signed radius of each arc segment + radius = (length / 2.0) / np.sin(angle / 2.0) + + # offset magnitude to point on arc + offset = radius - np.cos(angle / 2) * radius + + # convert each arc to three points: + # start, any point on arc, end + three = np.column_stack( + (lines[tid[:, 0]], midpoint + perp * offset.reshape((-1, 1)), lines[tid[:, 1]]) + ).reshape((-1, 3, 2)) + + # if we're in strict mode make sure our arcs + # have the same magnitude as the input data + if tol.strict: + from ..arc import arc_center + + check_angle = [arc_center(i).span for i in three] + assert np.allclose(np.abs(angle), np.abs(check_angle)) + + check_radii = [arc_center(i).radius for i in three] + assert np.allclose(check_radii, np.abs(radius)) + + # collect new entities and vertices + entities, vertices = [], [] + # add the entities for each new arc + for arc_points in three: + entities.append(Arc(points=np.arange(3) + len(vertices), **metadata)) + vertices.extend(arc_points) + + # if there are unconsumed line + # segments add them to drawing + if (len(lines) - 1) > len(bulge): + # indexes of line segments + existing = util.stack_lines(np.arange(len(lines))) + # remove line segments replaced with arcs + for line_idx in grouping.boolean_rows( + existing, np.sort(tid, axis=1), np.setdiff1d + ): + # add a single line entity and vertices + entities.append(Line(points=np.arange(2) + len(vertices), **metadata)) + vertices.extend(lines[line_idx].copy()) + + # make sure vertices are clean numpy array + vertices = np.array(vertices, dtype=np.float64) + + return vertices, entities + + +def get_key(blob, field, code): + """ + Given a loaded (n, 2) blob and a field name + get a value by code. + """ + try: + line = blob[np.nonzero(blob[:, 1] == field)[0][0] + 1] + except IndexError: + return None + if line[0] == code: + try: + return int(line[1]) + except ValueError: + return line[1] + else: + return None + + +# store the loaders we have available +_dxf_loaders = {"dxf": load_dxf} diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/export.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/export.py new file mode 100644 index 0000000000000000000000000000000000000000..41e450432e323147ce95bf52520e39abcc1d486b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/export.py @@ -0,0 +1,82 @@ +import os + +from ... import util +from ...exchange import ply +from . import dxf, svg_io + + +def export_path(path, file_type=None, file_obj=None, **kwargs): + """ + Export a Path object to a file- like object, or to a filename + + Parameters + --------- + file_obj: None, str, or file object + A filename string or a file-like object + file_type: None or str + File type, e.g.: 'svg', 'dxf' + kwargs : passed to loader + + Returns + --------- + exported : str or bytes + Data exported + """ + # if file object is a string it is probably a file path + # so we can split the extension to set the file type + if isinstance(file_obj, str): + file_type = util.split_extension(file_obj) + + # run the export + export = _path_exporters[file_type](path, **kwargs) + # if we've been passed files write the data + _write_export(export=export, file_obj=file_obj) + + return export + + +def export_dict(path): + """ + Export a path as a dict of kwargs for the Path constructor. + """ + export_entities = [e.to_dict() for e in path.entities] + export_object = {"entities": export_entities, "vertices": path.vertices.tolist()} + return export_object + + +def _write_export(export, file_obj=None): + """ + Write a string to a file. + If file_obj isn't specified, return the string + + Parameters + --------- + export: a string of the export data + file_obj: a file-like object or a filename + """ + + if file_obj is None: + return export + + if hasattr(file_obj, "write"): + out_file = file_obj + else: + # expand user and relative paths + file_path = os.path.abspath(os.path.expanduser(file_obj)) + out_file = open(file_path, "wb") + try: + out_file.write(export) + except TypeError: + out_file.write(export.encode("utf-8")) + + out_file.close() + + return export + + +_path_exporters = { + "dxf": dxf.export_dxf, + "svg": svg_io.export_svg, + "ply": ply.export_ply, + "dict": export_dict, +} diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/load.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/load.py new file mode 100644 index 0000000000000000000000000000000000000000..1cc4a89388f8ae59c351564652c5cf4c21f124b3 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/load.py @@ -0,0 +1,91 @@ +from ... import util +from ...exceptions import ExceptionWrapper +from ...exchange.ply import load_ply +from ..path import Path +from . import misc +from .dxf import _dxf_loaders +from .svg_io import _svg_loaders + + +def load_path(file_obj, file_type: str | None = None, **kwargs): + """ + Load a file to a Path file_object. + + Parameters + ----------- + file_obj + Accepts many types: + - Path, Path2D, or Path3D file_objects + - open file file_object (dxf or svg) + - file name (dxf or svg) + - shapely.geometry.Polygon + - shapely.geometry.MultiLineString + - dict with kwargs for Path constructor + - `(n, 2, (2|3)) float` line segments + file_type + Type of file is required if file + object is passed. + + Returns + --------- + path : Path, Path2D, Path3D file_object + Data as a native trimesh Path file_object + """ + # avoid a circular import + from ...exchange.load import _load_kwargs, _parse_file_args + + arg = _parse_file_args(file_obj=file_obj, file_type=file_type, **kwargs) + + if isinstance(file_obj, Path): + # we have been passed a file object that is already a loaded + # trimesh.path.Path object so do nothing and return + return file_obj + elif util.is_file(arg.file_obj): + if arg.file_type in path_loaders: + kwargs.update( + path_loaders[arg.file_type]( + file_obj=arg.file_obj, file_type=arg.file_type + ) + ) + elif arg.file_type == "ply": + # we cannot register this exporter to path_loaders since + # this is already reserved by Trimesh in ply format in trimesh.load() + kwargs.update(load_ply(file_obj=arg.file_obj, file_type=arg.file_type)) + elif util.is_instance_named(file_obj, ["Polygon", "MultiPolygon"]): + # convert from shapely polygons to Path2D + kwargs.update(misc.polygon_to_path(file_obj)) + elif util.is_instance_named(file_obj, "MultiLineString"): + # convert from shapely LineStrings to Path2D + kwargs.update(misc.linestrings_to_path(file_obj)) + elif isinstance(file_obj, dict): + # load as kwargs + kwargs = file_obj + elif util.is_sequence(file_obj): + # load as lines in space + kwargs.update(misc.lines_to_path(file_obj)) + else: + raise ValueError("Not a supported object type!") + + # actually load + result = _load_kwargs(kwargs) + result._source = arg + + return result + + +def path_formats() -> set[str]: + """ + Get a list of supported path formats. + + Returns + ------------ + loaders + Extensions of loadable formats, i.e. {'svg', 'dxf'} + """ + + return {k for k, v in path_loaders.items() if not isinstance(v, ExceptionWrapper)} + + +path_loaders = {} +path_loaders.update(_svg_loaders) +path_loaders.update(_dxf_loaders) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/misc.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/misc.py new file mode 100644 index 0000000000000000000000000000000000000000..a74718bedce4426de8237dc696ccc4046a93b569 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/misc.py @@ -0,0 +1,221 @@ +import numpy as np + +from ... import graph, grouping, util +from ...constants import tol_path +from ...typed import ArrayLike, NDArray +from ..entities import Arc, Line + + +def dict_to_path(as_dict): + """ + Turn a pure dict into a dict containing entity objects that + can be sent directly to a Path constructor. + + Parameters + ------------ + as_dict : dict + Has keys: 'vertices', 'entities' + + Returns + ------------ + kwargs : dict + Has keys: 'vertices', 'entities' + """ + # start kwargs with initial value + result = as_dict.copy() + # map of constructors + loaders = {"Arc": Arc, "Line": Line} + # pre- allocate entity array + entities = [None] * len(as_dict["entities"]) + # run constructor for dict kwargs + for entity_index, entity in enumerate(as_dict["entities"]): + if entity["type"] == "Line": + entities[entity_index] = loaders[entity["type"]](points=entity["points"]) + else: + entities[entity_index] = loaders[entity["type"]]( + points=entity["points"], closed=entity["closed"] + ) + result["entities"] = entities + + return result + + +def lines_to_path(lines: ArrayLike, index: NDArray[np.int64] | None = None) -> dict: + """ + Turn line segments into argument to be used for a Path2D or Path3D. + + Parameters + ------------ + lines : (n, 2, dimension) or (n, dimension) float + Line segments or connected polyline curve in 2D or 3D + index : (n,) int64 + If passed save an index for each line segment. + + Returns + ----------- + kwargs : dict + kwargs for Path constructor + """ + lines = np.asanyarray(lines, dtype=np.float64) + + if index is not None: + index = np.asanyarray(index, dtype=np.int64) + + if util.is_shape(lines, (-1, (2, 3))): + # the case where we have a list of points + # we are going to assume they are connected + result = {"entities": np.array([Line(np.arange(len(lines)))]), "vertices": lines} + return result + elif util.is_shape(lines, (-1, 2, (2, 3))): + # case where we have line segments in 2D or 3D + dimension = lines.shape[-1] + # convert lines to even number of (n, dimension) points + lines = lines.reshape((-1, dimension)) + # merge duplicate vertices + unique, inverse = grouping.unique_rows(lines, digits=tol_path.merge_digits) + # use scipy edges_to_path to skip creating + # a bajillion individual line entities which + # will be super slow vs. fewer polyline entities + return edges_to_path(edges=inverse.reshape((-1, 2)), vertices=lines[unique]) + else: + raise ValueError("Lines must be (n,(2|3)) or (n,2,(2|3))") + return result + + +def polygon_to_path(polygon): + """ + Load shapely Polygon objects into a trimesh.path.Path2D object + + Parameters + ------------- + polygon : shapely.geometry.Polygon + Input geometry + + Returns + ----------- + kwargs : dict + Keyword arguments for Path2D constructor + """ + # start with a single polyline for the exterior + entities = [] + # start vertices + vertices = [] + + if hasattr(polygon.boundary, "geoms"): + boundaries = polygon.boundary.geoms + else: + boundaries = [polygon.boundary] + + # append interiors as single Line objects + current = 0 + for boundary in boundaries: + entities.append(Line(np.arange(len(boundary.coords)) + current)) + current += len(boundary.coords) + # append the new vertex array + vertices.append(np.array(boundary.coords)) + + # make sure result arrays are numpy + kwargs = { + "entities": entities, + "vertices": np.vstack(vertices) if len(vertices) > 0 else vertices, + } + + return kwargs + + +def linestrings_to_path(multi) -> dict: + """ + Load shapely LineString objects into arguments to create a Path2D or Path3D. + + Parameters + ------------- + multi : shapely.geometry.LineString or MultiLineString + Input 2D or 3D geometry + + Returns + ------------- + kwargs : dict + Keyword arguments for Path2D or Path3D constructor + """ + import shapely + + # append to result as we go + entities = [] + vertices = [] + + if isinstance(multi, shapely.MultiLineString): + multi = list(multi.geoms) + else: + multi = [multi] + + for line in multi: + # only append geometry with points + if hasattr(line, "coords"): + coords = np.array(line.coords) + if len(coords) < 2: + continue + entities.append(Line(np.arange(len(coords)) + len(vertices))) + vertices.extend(coords) + + kwargs = {"entities": np.array(entities), "vertices": np.array(vertices)} + return kwargs + + +def faces_to_path(mesh, face_ids=None, **kwargs): + """ + Given a mesh and face indices find the outline edges and + turn them into a Path3D. + + Parameters + ------------ + mesh : trimesh.Trimesh + Triangulated surface in 3D + face_ids : (n,) int + Indexes referencing mesh.faces + + Returns + --------- + kwargs : dict + Kwargs for Path3D constructor + """ + if face_ids is None: + edges = mesh.edges_sorted + else: + # take advantage of edge ordering to index as single row + edges = mesh.edges_sorted.reshape((-1, 6))[face_ids].reshape((-1, 2)) + # an edge which occurs onely once is on the boundary + unique_edges = grouping.group_rows(edges, require_count=1) + # add edges and vertices to kwargs + kwargs.update(edges_to_path(edges=edges[unique_edges], vertices=mesh.vertices)) + + return kwargs + + +def edges_to_path(edges: ArrayLike, vertices: ArrayLike, **kwargs) -> dict: + """ + Given an edge list of indices and associated vertices + representing lines, generate kwargs for a Path object. + + Parameters + ----------- + edges : (n, 2) int + Vertex indices of line segments + vertices : (m, dimension) float + Vertex positions where dimension is 2 or 3 + + Returns + ---------- + kwargs : dict + Kwargs for Path constructor + """ + # sequence of ordered traversals + dfs = graph.traversals(edges, mode="dfs") + # make sure every consecutive index in DFS + # traversal is an edge in the source edge list + dfs_connected = graph.fill_traversals(dfs, edges=edges) + # kwargs for Path constructor + # turn traversals into Line objects + lines = [Line(d) for d in dfs_connected] + + kwargs.update({"entities": lines, "vertices": vertices, "process": False}) + return kwargs diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/svg_io.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/svg_io.py new file mode 100644 index 0000000000000000000000000000000000000000..603f2d5f1e74097a35d394d6cce90badc39bbb34 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/exchange/svg_io.py @@ -0,0 +1,808 @@ +import base64 +import json +from collections import defaultdict, deque +from copy import deepcopy + +import numpy as np + +from ... import exceptions, grouping, resources, util +from ...constants import log, tol +from ...transformations import planar_matrix, transform_points +from ...typed import Iterable, Mapping, NDArray, Number +from ...util import jsonify +from ..arc import arc_center, to_threepoint +from ..entities import Arc, Bezier, Line + +# store any additional properties using a trimesh namespace +_ns_name = "trimesh" +_ns_url = "https://github.com/mikedh/trimesh" +_ns = f"{{{_ns_url}}}" + +_IDENTITY = np.eye(3) +_IDENTITY.flags["WRITEABLE"] = False + + +def svg_to_path(file_obj=None, file_type=None, path_string=None): + """ + Load an SVG file into a Path2D object. + + Parameters + ----------- + file_obj : open file object + Contains SVG data + file_type: None + Not used + path_string : None or str + If passed, parse a single path string and ignore `file_obj`. + + Returns + ----------- + loaded : dict + With kwargs for Path2D constructor + """ + + force = None + tree = None + paths = [] + shapes = [] + if file_obj is not None: + # first parse the XML + tree = etree.fromstring( + file_obj.read(), parser=etree.XMLParser(**XML_PARSER_OPTIONS) + ) + # store paths and transforms as + # (path string, 3x3 matrix) + for element in tree.iter("{*}path"): + # store every path element attributes and transform + paths.append((element.attrib, element_transform(element))) + + # now try converting shapes + for shape in tree.iter( + ("{*}circle", "{*}rect", "{*}line", "{*}polyline", "{*}polygon") + ): + shapes.append( + (shape.tag.rsplit("}", 1)[-1], shape.attrib, element_transform(shape)) + ) + + try: + # see if the SVG should be reproduced as a scene + force = tree.attrib[_ns + "class"] + except BaseException: + pass + elif path_string is not None: + # parse a single SVG path string + paths.append(({"d": path_string}, _IDENTITY)) + else: + raise ValueError("`file_obj` or `pathstring` required") + + result = _svg_path_convert(paths=paths, shapes=shapes, force=force) + + try: + if tree is not None: + # get overall metadata from JSON string if it exists + result["metadata"] = _decode(tree.attrib[_ns + "metadata"]) + except KeyError: + # not in the trimesh ns + pass + except BaseException: + # no metadata stored with trimesh ns + log.debug("failed metadata", exc_info=True) + + # if the result is a scene try to get the metadata + # for each subgeometry here + if "geometry" in result: + try: + # get per-geometry metadata if available + bag = _decode(tree.attrib[_ns + "metadata_geometry"]) + for name, meta in bag.items(): + if name in result["geometry"]: + # assign this metadata to the geometry + result["geometry"][name]["metadata"] = meta + except KeyError: + # no stored geometry metadata so ignore + pass + except BaseException: + # failed to load existing metadata + log.debug("failed metadata", exc_info=True) + + return result + + +def _attrib_metadata(attrib: Mapping) -> dict: + try: + # try to retrieve any trimesh attributes as metadata + return { + k.lstrip(_ns): _decode(v) + for k, v in attrib.items() + if k[1:].startswith(_ns_url) + } + except BaseException: + return {} + + +def element_transform(element, max_depth=10): + """ + Find a transformation matrix for an XML element. + + Parameters + -------------- + e : lxml.etree.Element + Element to search upwards from. + max_depth : int + Maximum depth to search for transforms. + """ + matrices = deque() + # start at the passed element + current = element + for _ in range(max_depth): + # get the transforms from a particular element + if "transform" in current.attrib: + matrices.extendleft(transform_to_matrices(current.attrib["transform"])[::-1]) + current = current.getparent() + if current is None: + break + if len(matrices) == 0: + # no transforms is an identity matrix + return _IDENTITY + elif len(matrices) == 1: + return matrices[0] + else: + # evaluate the transforms in the order they were passed + # as this is what the SVG spec says you should do + return util.multi_dot(matrices) + + +def transform_to_matrices(transform: str) -> NDArray[np.float64]: + """ + Convert an SVG transform string to an array of matrices. + + i.e. "rotate(-10 50 100) + translate(-36 45.5) + skewX(40) + scale(1 0.5)" + + Parameters + ----------- + transform : str + Contains transformation information in SVG form + + Returns + ----------- + matrices : (n, 3, 3) float + Multiple transformation matrices from input transform string + """ + # split the transform string in to components of: + # (operation, args) i.e. (translate, '-1.0, 2.0') + components = [ + [j.strip() for j in i.strip().split("(") if len(j) > 0] + for i in transform.lower().split(")") + if len(i) > 0 + ] + # store each matrix without dotting + matrices = [] + for line in components: + if len(line) == 0: + continue + elif len(line) != 2: + raise ValueError("should always have two components!") + key, args = line + # convert string args to array of floats + # support either comma or space delimiter + values = np.array([float(i) for i in args.replace(",", " ").split()]) + if key == "translate": + # convert translation to a (3, 3) homogeneous matrix + matrices.append(_IDENTITY.copy()) + matrices[-1][:2, 2] = values + elif key == "matrix": + # [a b c d e f] -> + # [[a c e], + # [b d f], + # [0 0 1]] + matrices.append(np.vstack((values.reshape((3, 2)).T, [0, 0, 1]))) + elif key == "rotate": + # SVG uses degrees and the opposite rotation sign to planar_matrix. + angle = -np.radians(values[0]) + # if there are three values rotate around point + if len(values) == 3: + point = values[1:] + else: + point = None + matrices.append(planar_matrix(theta=angle, point=point)) + elif key == "scale": + # supports (x_scale, y_scale) or (scale) + mat = _IDENTITY.copy() + mat[:2, :2] *= values + matrices.append(mat) + else: + log.debug(f"unknown SVG transform: {key}") + + return np.array(matrices, dtype=np.float64) + + +def _svg_path_convert(paths: Iterable, shapes: Iterable, force=None): + """ + Convert an SVG path string into a Path2D object + + Parameters + ------------- + paths: list of tuples + Containing (path string, (3, 3) matrix, metadata) + + Returns + ------------- + drawing : dict + Kwargs for Path2D constructor + """ + + def complex_to_float(values): + return np.array([[i.real, i.imag] for i in values], dtype=np.float64) + + def load_multi(multi): + # load a previously parsed multiline + # start the count where indicated + start = counts[name] + # end at the block of our new points + end = start + len(multi.points) + + return (Line(points=np.arange(start, end)), multi.points) + + def load_arc(svg_arc): + # load an SVG arc into a trimesh arc + points = complex_to_float([svg_arc.start, svg_arc.point(0.5), svg_arc.end]) + # create an arc from the now numpy points + arc = Arc( + points=np.arange(3) + counts[name], + # we may have monkey-patched the entity to + # indicate that it is a closed circle + closed=getattr(svg_arc, "closed", False), + ) + return arc, points + + def load_quadratic(svg_quadratic): + # load a quadratic bezier spline + points = complex_to_float( + [svg_quadratic.start, svg_quadratic.control, svg_quadratic.end] + ) + return Bezier(points=np.arange(3) + counts[name]), points + + def load_cubic(svg_cubic): + # load a cubic bezier spline + points = complex_to_float( + [svg_cubic.start, svg_cubic.control1, svg_cubic.control2, svg_cubic.end] + ) + return Bezier(np.arange(4) + counts[name]), points + + class MultiLine: + # An object to hold one or multiple Line entities. + def __init__(self, lines): + if tol.strict: + # in unit tests make sure we only have lines + assert all(type(L).__name__ in ("Line", "Close") for L in lines) + # get the starting point of every line + points = [L.start for L in lines] + # append the endpoint + points.append(lines[-1].end) + # convert to (n, 2) float points + self.points = np.array([[i.real, i.imag] for i in points], dtype=np.float64) + + # load functions for each entity + loaders = { + "Arc": load_arc, + "MultiLine": load_multi, + "CubicBezier": load_cubic, + "QuadraticBezier": load_quadratic, + } + + entities = defaultdict(list) + vertices = defaultdict(list) + counts = defaultdict(lambda: 0) + + for attrib, matrix in paths: + # the path string is stored under `d` + path_string = attrib.get("d", "") + if len(path_string) == 0: + log.debug("empty path string!") + continue + + # get the name of the geometry if trimesh specified it + # note that the get will by default return `None` + name = _decode(attrib.get(_ns + "name")) + # get parsed entities from svg.path + raw = np.array(list(parse_path(path_string))) + + # if there is no path string exit + if len(raw) == 0: + continue + + # create an integer code for entities we can combine + kinds_lookup = {"Line": 1, "Close": 1, "Arc": 2} + # get a code for each entity we parsed + kinds = np.array([kinds_lookup.get(type(i).__name__, 0) for i in raw], dtype=int) + + # find groups of consecutive entities so we can combine + blocks = grouping.blocks(kinds, min_len=1, only_nonzero=False) + + if tol.strict: + # in unit tests make sure we didn't lose any entities + assert util.allclose(np.hstack(blocks), np.arange(len(raw))) + + # Combine consecutive entities that can be represented + # more concisely as a single trimesh entity. + parsed = [] + for b in blocks: + chunk = raw[b] + current = type(raw[b[0]]).__name__ + if current in ("Line", "Close"): + # if entity consists of lines add a multiline + parsed.append(MultiLine(chunk)) + elif len(b) > 1 and current == "Arc": + # if we have multiple arcs check to see if they + # actually represent a single closed circle + # get a single array with the relevant arc points + verts = np.array( + [ + [ + a.start.real, + a.start.imag, + a.end.real, + a.end.imag, + a.center.real, + a.center.imag, + a.radius.real, + a.radius.imag, + a.rotation, + ] + for a in chunk + ], + dtype=np.float64, + ) + # all arcs share the same center radius and rotation + closed = False + if np.ptp(verts[:, 4:], axis=0).mean() < 1e-3: + start, end = verts[:, :2], verts[:, 2:4] + # if every end point matches the start point of a new + # arc that means this is really a closed circle made + # up of multiple arc segments + closed = util.allclose(start, np.roll(end, 1, axis=0)) + if closed: + # hot-patch a closed arc flag + chunk[0].closed = True + # all arcs in this block are now represented by one entity + parsed.append(chunk[0]) + else: + # we don't have a closed circle so add each + # arc entity individually without combining + parsed.extend(chunk) + else: + # otherwise just add the entities + parsed.extend(chunk) + + entity_meta = _attrib_metadata(attrib=attrib) + + # loop through parsed entity objects + for svg_entity in parsed: + # keyed by entity class name + type_name = type(svg_entity).__name__ + if type_name in loaders: + # get new entities and vertices + e, v = loaders[type_name](svg_entity) + e.metadata.update(entity_meta) + # append them to the result + entities[name].append(e) + # transform the vertices by the matrix and append + vertices[name].append(transform_points(v, matrix)) + counts[name] += len(v) + + # load simple shape geometry + for kind, attrib, matrix in shapes: + # get the geometry name (defaults to None) + name = _decode(attrib.get(_ns + "name")) + + if kind == "circle": + points = to_threepoint( + [float(attrib["cx"]), float(attrib["cy"])], float(attrib["r"]) + ) + entity = Arc(points=np.arange(3) + counts[name], closed=True) + + elif kind == "rect": + # todo : support rounded rectangle + origin = np.array([attrib["x"], attrib["y"]], dtype=np.float64) + w, h = np.array([attrib["width"], attrib["height"]], dtype=np.float64) + + points = np.array( + [origin, origin + (w, 0), origin + (w, h), origin + (0, h), origin], + dtype=np.float64, + ) + entity = Line(points=np.arange(len(points)) + counts[name]) + + elif kind == "polyline": + points = np.fromstring( + attrib["points"].strip().replace(",", " "), sep=" ", dtype=np.float64 + ).reshape((-1, 2)) + entity = Line(points=np.arange(len(points)) + counts[name]) + + elif kind == "polygon": + points = np.fromstring( + attrib["points"].strip().replace(",", " "), sep=" ", dtype=np.float64 + ).reshape((-1, 2)) + + # polygon implies forced-closed so check to see if it + # is already closed and if not add the closing index + if (points[0] == points[-1]).all(): + index = np.arange(len(points)) + counts[name] + else: + index = np.arange(len(points) + 1) + counts[name] + index[-1] = index[0] + + entity = Line(points=index) + + elif kind == "line": + points = np.array( + [attrib["x1"], attrib["y1"], attrib["x2"], attrib["y2"]], dtype=np.float64 + ).reshape((2, 2)) + entity = Line(points=np.arange(len(points)) + counts[name]) + else: + log.debug(f"unsupported SVG shape: `{kind}`") + continue + + entities[name].append(entity) + vertices[name].append(transform_points(points, matrix)) + counts[name] += len(points) + + if len(vertices) == 0: + return {"vertices": [], "entities": []} + + geoms = { + name: {"vertices": np.vstack(v), "entities": entities[name]} + for name, v in vertices.items() + } + if len(geoms) > 1 or force == "Scene": + kwargs = {"geometry": geoms} + else: + # return a single Path2D + kwargs = next(iter(geoms.values())) + + return kwargs + + +def _entities_to_str(entities, vertices, name=None, digits=None, only_layers=None): + """ + Convert the entities of a path to path strings. + + Parameters + ------------ + entities : (n,) list + Entity objects + vertices : (m, 2) float + Vertices entities reference + name : any + Trimesh namespace name to assign to entity + digits : int + Number of digits to format exports into + only_layers : set + Only export these layers if passed + """ + if digits is None: + digits = 13 + + points = vertices.copy() + + # generate a format string with the requested digits + temp_digits = f"0.{int(digits)}f" + # generate a format string for circles as two arc segments + temp_circle = ( + "M {x:DI},{y:DI}a{r:DI},{r:DI},0,1,0,{d:DI}," + "0a{r:DI},{r:DI},0,1,0,-{d:DI},0Z" + ).replace("DI", temp_digits) + # generate a format string for an absolute move-to command + temp_move = "M{:DI},{:DI}".replace("DI", temp_digits) + # generate a format string for an absolute-line command + temp_line = "L{:DI},{:DI}".replace("DI", temp_digits) + # generate a format string for a single arc + temp_arc = "M{SX:DI} {SY:DI}A{R},{R} 0 {L:d},{S:d} {EX:DI},{EY:DI}".replace( + "DI", temp_digits + ) + + def _cross_2d(a: NDArray, b: NDArray) -> Number: + """ + Numpy 2.0 depreciated cross products of 2D arrays. + """ + return a[0] * b[1] - a[1] * b[0] + + def svg_arc(arc): + """ + arc string: (rx ry x-axis-rotation large-arc-flag sweep-flag x y)+ + large-arc-flag: greater than 180 degrees + sweep flag: direction (cw/ccw) + """ + vertices = points[arc.points] + info = arc_center(vertices, return_normal=False, return_angle=True) + C, R, angle = info.center, info.radius, info.span + if arc.closed: + return temp_circle.format(x=C[0] - R, y=C[1], r=R, d=2.0 * R) + + vertex_start, vertex_mid, vertex_end = vertices + large_flag = int(angle > np.pi) + sweep_flag = int( + _cross_2d(vertex_mid - vertex_start, vertex_end - vertex_start) > 0.0 + ) + return temp_arc.format( + SX=vertex_start[0], + SY=vertex_start[1], + L=large_flag, + S=sweep_flag, + EX=vertex_end[0], + EY=vertex_end[1], + R=R, + ) + + def svg_discrete(entity): + """ + Use an entities discrete representation to export a + curve as a polyline + """ + discrete = entity.discrete(points) + # if entity contains no geometry return + if len(discrete) == 0: + return "" + # the format string for the SVG path + return (temp_move + (temp_line * (len(discrete) - 1))).format( + *discrete.reshape(-1) + ) + + # tuples of (metadata, path string) + pairs = [] + + for entity in entities: + if only_layers is not None and entity.layer not in only_layers: + continue + # check the class name of the entity + if entity.__class__.__name__ == "Arc": + # export the exact version of the entity + path_string = svg_arc(entity) + else: + # just export the polyline version of the entity + path_string = svg_discrete(entity) + meta = deepcopy(entity.metadata) + if name is not None: + meta["name"] = name + pairs.append((meta, path_string)) + return pairs + + +def export_svg(drawing, return_path=False, only_layers=None, digits=None, **kwargs): + """ + Export a Path2D object into an SVG file. + + Parameters + ----------- + drawing : Path2D + Source geometry + return_path : bool + If True return only path string not wrapped in XML + only_layers : None or set + If passed only export the specified layers + digits : None or int + Number of digits for floating point values + + Returns + ----------- + as_svg : str + XML formatted SVG, or path string + """ + # collect custom attributes for the overall export + attribs = {"class": type(drawing).__name__} + + if util.is_instance_named(drawing, "Scene"): + pairs = [] + geom_meta = {} + for name, geom in drawing.geometry.items(): + if not util.is_instance_named(geom, "Path2D"): + continue + geom_meta[name] = geom.metadata + # a pair of (metadata, path string) + pairs.extend( + _entities_to_str( + entities=geom.entities, + vertices=geom.vertices, + name=name, + digits=digits, + only_layers=only_layers, + ) + ) + if len(geom_meta) > 0: + # encode the whole metadata bundle here to avoid + # polluting the file with a ton of loose attribs + attribs["metadata_geometry"] = _encode(geom_meta) + elif util.is_instance_named(drawing, "Path2D"): + pairs = _entities_to_str( + entities=drawing.entities, + vertices=drawing.vertices, + digits=digits, + only_layers=only_layers, + ) + + else: + raise ValueError("drawing must be Scene or Path2D object!") + + # return path string without XML wrapping + if return_path: + return " ".join(v[1] for v in pairs) + + # fetch the export template for the base SVG file + template_svg = resources.get_string("templates/base.svg") + + elements = [] + for meta, path_string in pairs: + # create a simple path element + elements.append(f'') + + # format as XML + if "stroke_width" in kwargs: + stroke_width = float(kwargs["stroke_width"]) + else: + # set stroke to something OK looking + stroke_width = drawing.extents.max() / 800.0 + try: + # store metadata in XML as JSON -_- + attribs["metadata"] = _encode(drawing.metadata) + except BaseException: + # log failed metadata encoding + log.debug("failed to encode", exc_info=True) + + subs = { + "elements": "\n".join(elements), + "min_x": drawing.bounds[0][0], + "min_y": drawing.bounds[0][1], + "width": drawing.extents[0], + "height": drawing.extents[1], + "stroke_width": stroke_width, + "attribs": _format_attrib(attribs), + } + return template_svg.format(**subs) + + +def _format_attrib(attrib): + """ + Format attribs into the trimesh namespace. + + Parameters + ----------- + attrib : dict + Bag of keys and values. + """ + bag = {k: _encode(v) for k, v in attrib.items()} + return "\n".join( + f'{_ns_name}:{k}="{v}"' + for k, v in bag.items() + if len(k) > 0 and v is not None and len(v) > 0 + ) + + +def _encode(stuff): + """ + Wangle things into a string. + + Parameters + ----------- + stuff : dict, str + Thing to pack + + Returns + ------------ + encoded : str + Packaged into url-safe b64 string + """ + if isinstance(stuff, str) and '"' not in stuff: + return stuff + pack = base64.urlsafe_b64encode( + jsonify( + {k: v for k, v in stuff.items() if not k.startswith("_")}, + separators=(",", ":"), + ).encode("utf-8") + ) + result = "base64," + util.decode_text(pack) + if tol.strict: + # make sure we haven't broken the things + _deep_same(stuff, _decode(result)) + + return result + + +def _deep_same(original, other): + """ + Do a recursive comparison of two items to check + our encoding scheme in unit tests. + + Parameters + ----------- + original : str, bytes, list, dict + Original item + other : str, bytes, list, dict + Item that should be identical + + Raises + ------------ + AssertionError + If items are not the same. + """ + # ndarrays will be converted to lists + # but otherwise types should be identical + if isinstance(original, np.ndarray): + assert isinstance(other, (list, np.ndarray)) + elif isinstance(original, str): + assert isinstance(other, str) + else: + # otherwise they should be the same type + assert isinstance(original, type(other)) + + if isinstance(original, (str, bytes)): + # string and bytes should just be identical + assert original == other + return + elif isinstance(original, (float, int, np.ndarray)): + # for Number classes use numpy magic comparison + # which includes an epsilon for floating point + assert np.allclose(original, other) + return + elif isinstance(original, list): + # lengths should match + assert len(original) == len(other) + # every element should be identical + for a, b in zip(original, other): + _deep_same(a, b) + return + + # we should have special-cased everything else by here + assert isinstance(original, dict) + + # all keys should match + assert set(original.keys()) == set(other.keys()) + # do a recursive comparison of the values + for k in original.keys(): + _deep_same(original[k], other[k]) + + +def _decode(bag): + """ + Decode a base64 bag of stuff. + + Parameters + ------------ + bag : str + Starts with `base64,` + + Returns + ------------- + loaded : dict + Loaded bag of stuff + """ + if bag is None: + return + text = util.decode_text(bag) + if text.startswith("base64,"): + return json.loads( + base64.urlsafe_b64decode(text[7:].encode("utf-8")).decode("utf-8") + ) + return text + + +_svg_loaders = {"svg": svg_to_path} + +try: + # pip install svg.path + from svg.path import parse_path +except BaseException as E: + # will re-raise the import exception when + # someone tries to call `parse_path` + parse_path = exceptions.ExceptionWrapper(E) + _svg_loaders["svg"] = parse_path + +try: + from lxml import etree + + from ...exchange.common import XML_PARSER_OPTIONS +except BaseException as E: + # will re-raise the import exception when + # someone actually tries to use the module + etree = exceptions.ExceptionWrapper(E) + _svg_loaders["svg"] = etree diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/intersections.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/intersections.py new file mode 100644 index 0000000000000000000000000000000000000000..d0f24259ed437cadbde7cdde39fb80fe95579738 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/intersections.py @@ -0,0 +1,73 @@ +import numpy as np + +from .. import util +from ..constants import tol_path as tol + + +def line_line(origins, directions, plane_normal=None): + """ + Find the intersection between two lines. + Uses terminology from: + http://geomalgorithms.com/a05-_intersect-1.html + + line 1: P(s) = p_0 + sU + line 2: Q(t) = q_0 + tV + + Parameters + --------- + origins : (2, d) float + Points on lines (d in [2,3]) + directions : (2, d) float + Direction vectors + plane_normal : (3, ) float + If not passed computed from cross + + Returns + --------- + intersects : bool + Whether the lines intersect. + In 2D, false if the lines are parallel + In 3D, false if lines are not coplanar + intersection : (d,) float or None + Point of intersection + """ + # check so we can accept 2D or 3D points + origins, is_2D = util.stack_3D(origins, return_2D=True) + directions, is_2D = util.stack_3D(directions, return_2D=True) + + # unitize direction vectors + directions /= util.row_norm(directions).reshape((-1, 1)) + + # exit if values are parallel + if np.sum(np.abs(np.diff(directions, axis=0))) < tol.zero: + return False, None + + # using notation from docstring + q_0, p_0 = origins + v, u = directions + w = p_0 - q_0 + + # recompute plane normal if not passed + if plane_normal is None: + # the normal of the plane given by the two direction vectors + plane_normal = np.cross(u, v) + plane_normal /= np.linalg.norm(plane_normal) + + # vectors perpendicular to the two lines + v_perp = np.cross(v, plane_normal) + v_perp /= np.linalg.norm(v_perp) + + # if the vector from origin to origin is on the plane given by + # the direction vector, the dot product with the plane normal + # should be within floating point error of zero + w_norm = np.linalg.norm(w) + if w_norm > tol.zero and abs(np.dot(plane_normal, w / w_norm)) > tol.zero: + # not coplanar + return False, None + + # value of parameter s where intersection occurs + s_I = np.dot(-v_perp, w) / np.dot(v_perp, u) + # plug back into the equation of the line to find the point + intersection = p_0 + s_I * u + + return True, intersection[: (3 - is_2D)] diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/packing.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/packing.py new file mode 100644 index 0000000000000000000000000000000000000000..983ad6d993709cfd1e04ae822c43d3f8c4925e00 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/packing.py @@ -0,0 +1,821 @@ +""" +packing.py +------------ + +Pack rectangular regions onto larger rectangular regions. +""" + +import numpy as np + +from ..constants import log, tol +from ..typed import ArrayLike, Integer, NDArray, Number, Seed, float64 +from ..util import allclose, bounds_tree, random_generator + +# floating point zero +_TOL_ZERO = 1e-12 + + +class RectangleBin: + """ + An N-dimensional binary space partition tree for packing + hyper-rectangles. Split logic is pure `numpy` but behaves + similarly to `scipy.spatial.Rectangle`. + + Mostly useful for packing 2D textures and 3D boxes and + has not been tested outside of 2 and 3 dimensions. + + Original article about using this for packing textures: + http://www.blackpawn.com/texts/lightmaps/ + """ + + def __init__(self, bounds): + """ + Create a rectangular bin. + + Parameters + ------------ + bounds : (2, dimension *) float + Bounds array are `[mins, maxes]` + """ + # this is a *binary* tree so regardless of the dimensionality + # of the rectangles each node has exactly two children + self.child = [] + # is this node occupied. + self.occupied = False + # assume bounds are a list + self.bounds = np.array(bounds, dtype=np.float64) + + @property + def extents(self): + """ + Bounding box size. + + Returns + ---------- + extents : (dimension,) float + Edge lengths of bounding box + """ + bounds = self.bounds + return bounds[1] - bounds[0] + + def insert(self, size, rotate=True): + """ + Insert a rectangle into the bin. + + Parameters + ------------- + size : (dimension,) float + Size of rectangle to insert/ + + Returns + ---------- + inserted : (2,) float or None + Position of insertion in the tree or None + if the insertion was unsuccessful. + """ + for child in self.child: + # try inserting into child cells + attempt = child.insert(size=size, rotate=rotate) + if attempt is not None: + return attempt + + # can't insert into occupied cells + if self.occupied: + return None + + # shortcut for our bounds + bounds = self.bounds.copy() + extents = bounds[1] - bounds[0] + + if rotate: + # we are allowed to rotate the rectangle + for roll in range(len(size)): + size_test = extents - _roll(size, roll) + fits = (size_test > -_TOL_ZERO).all() + if fits: + size = _roll(size, roll) + break + # we tried rotating and none of the directions fit + if not fits: + return None + else: + # compare the bin size to the insertion candidate size + # manually compute extents here to avoid function call + size_test = extents - size + if (size_test < -_TOL_ZERO).any(): + return None + + # since the cell is big enough for the current rectangle, either it + # is going to be inserted here, or the cell is going to be split + # either way the cell is now occupied. + self.occupied = True + + # this means the inserted rectangle fits perfectly + # since we already checked to see if it was negative + # no abs is needed + if (size_test < _TOL_ZERO).all(): + return bounds + + # pick the axis to split along + axis = size_test.argmax() + # split hyper-rectangle along axis + # note that split is *absolute* distance not offset + # so we have to add the current min to the size + splits = np.vstack((bounds, bounds)) + splits[1:3, axis] = bounds[0][axis] + size[axis] + + # assign two children + self.child[:] = RectangleBin(splits[:2]), RectangleBin(splits[2:]) + + # insert the requested item into the first child + return self.child[0].insert(size, rotate=rotate) + + +def _roll(a, count): + """ + A speedup for `numpy.roll` that only works + on flat arrays and is fast on 2D and 3D and + reverts to `numpy.roll` for other cases. + + Parameters + ----------- + a : (n,) any + Array to roll + count : int + Number of places to shift array + + Returns + --------- + rolled : (n,) any + Input array shifted by requested amount + + """ + # a lookup table for roll in 2 and 3 dimensions + lookup = [[[0, 1], [1, 0]], [[0, 1, 2], [2, 0, 1], [1, 2, 0]]] + try: + # roll the array using advanced indexing and a lookup table + return a[lookup[len(a) - 2][count]] + except IndexError: + # failing that return the results using concat + return np.concatenate([a[-count:], a[:-count]]) + + +def rectangles_single( + extents, size=None, shuffle=False, rotate=True, random: Seed = None +): + """ + Execute a single insertion order of smaller rectangles onto + a larger rectangle using a binary space partition tree. + + Parameters + ---------- + extents : (n, dimension) float + The size of the hyper-rectangles to pack. + size : None or (dim,) float + Maximum size of container to pack onto. + If not passed it will re-root the tree when items + larger than any available node are inserted. + shuffle : bool + Whether or not to shuffle the insert order of the + smaller rectangles, as the final packing density depends + on insertion order. + rotate : bool + If True, allow integer-roll rotation. + random : None or int or numpy.random.Generator + Source for the shuffle, pass a `Generator` to draw from + one stream across repeated calls. + + Returns + --------- + bounds : (m, 2, dim) float + Axis aligned resulting bounds in space + transforms : (m, dim + 1, dim + 1) float + Homogeneous transformation including rotation. + consume : (n,) bool + Which of the original rectangles were packed, + i.e. `consume.sum() == m` + """ + + extents = np.asanyarray(extents, dtype=np.float64) + dimension = extents.shape[1] + # the return arrays + offset = np.zeros((len(extents), 2, dimension)) + consume = np.zeros(len(extents), dtype=bool) + # start by ordering them by maximum length + order = np.argsort(extents.max(axis=1))[::-1] + + if shuffle: + # reorder with permutations + order = random_generator(random).permutation(order) + + if size is None: + # if no bounds are passed start it with the size of a large + # rectangle exactly which will require re-rooting for + # subsequent insertions + root_bounds = [[0.0] * dimension, extents[np.ptp(extents, axis=1).argmax()]] + else: + # restrict the bounds to passed size and disallow re-rooting + root_bounds = [[0.0] * dimension, size] + + # the current root node to insert each rectangle + root = RectangleBin(bounds=root_bounds) + + for index in order: + # the current rectangle to be inserted + rectangle = extents[index] + # try to insert the hyper-rectangle into children + inserted = root.insert(rectangle, rotate=rotate) + + if inserted is None and size is None: + # we failed to insert into children + # so we need to create a new parent + # get the size of the current root node + bounds = root.bounds + # current extents + current = np.ptp(bounds, axis=0) + + # pick the direction which has the least hyper-volume. + best = np.inf + for roll in range(len(current)): + stack = np.array([current, _roll(rectangle, roll)]) + # we are going to combine two hyper-rect + # so we have `dim` choices on ways to split + # choose the split that minimizes the new hyper-volume + # the new AABB is going to be the `max` of the lengths + # on every dim except one which will be the `sum` + ch = np.tile(stack.max(axis=0), (len(current), 1)) + np.fill_diagonal(ch, stack.sum(axis=0)) + + # choose the new AABB by which one minimizes hyper-volume + choice_prod = np.prod(ch, axis=1) + if choice_prod.min() < best: + choices = ch + choices_idx = choice_prod.argmin() + best = choice_prod[choices_idx] + if not rotate: + break + + # we now know the full extent of the AABB + new_max = bounds[0] + choices[choices_idx] + + # offset the new bounding box corner + new_min = bounds[0].copy() + new_min[choices_idx] += current[choices_idx] + + # original bounds may be stretched + new_ori_max = np.vstack((bounds[1], new_max)).max(axis=0) + new_ori_max[choices_idx] = bounds[1][choices_idx] + + assert (new_ori_max >= bounds[1]).all() + + # the bounds containing the original sheet + bounds_ori = np.array([bounds[0], new_ori_max]) + # the bounds containing the location to insert + # the new rectangle + bounds_ins = np.array([new_min, new_max]) + + # generate the new root node + new_root = RectangleBin([bounds[0], new_max]) + # this node has children so it is occupied + new_root.occupied = True + # create a bin for both bounds + new_root.child = [RectangleBin(bounds_ori), RectangleBin(bounds_ins)] + + # insert the original sheet into the new tree + root_offset = new_root.child[0].insert(np.ptp(bounds, axis=0), rotate=rotate) + # we sized the cells so original tree would fit + assert root_offset is not None + + # existing inserts need to be moved + if not allclose(root_offset[0][0], 0.0): + offset[consume] += root_offset[0][0] + + # insert the child that didn't fit before into the other child + child = new_root.child[1].insert(rectangle, rotate=rotate) + # since we re-sized the cells to fit insertion should always work + assert child is not None + + offset[index] = child + consume[index] = True + # subsume the existing tree into a new root + root = new_root + + elif inserted is not None: + # we successfully inserted + offset[index] = inserted + consume[index] = True + + if tol.strict: + # in tests make sure we've never returned overlapping bounds + assert not bounds_overlap(offset[consume]) + + return offset[consume], consume + + +def paths(paths, **kwargs): + """ + Pack a list of Path2D objects into a rectangle. + + Parameters + ------------ + paths: (n,) Path2D + Geometry to be packed + + Returns + ------------ + packed : trimesh.path.Path2D + All paths packed into a single path object. + transforms : (m, 3, 3) float + Homogeneous transforms to move paths from their + original position to the new one. + consume : (n,) bool + Which of the original paths were inserted, + i.e. `consume.sum() == m` + """ + from .util import concatenate + + # pack using exterior polygon which will have the + # oriented bounding box calculated before packing + packable = [] + original = [] + for index, path in enumerate(paths): + quantity = path.metadata.get("quantity", 1) + original.extend([index] * quantity) + packable.extend([path.polygons_closed[path.root[0]]] * quantity) + + # pack the polygons using rectangular bin packing + transforms, consume = polygons(polygons=packable, **kwargs) + + positioned = [] + for index, matrix in zip(np.nonzero(consume)[0], transforms): + current = paths[original[index]].copy() + current.apply_transform(matrix) + positioned.append(current) + + # append all packed paths into a single Path object + packed = concatenate(positioned) + + return packed, transforms, consume + + +def polygons(polygons, **kwargs): + """ + Pack polygons into a rectangle by taking each Polygon's OBB + and then packing that as a rectangle. + + Parameters + ------------ + polygons : (n,) shapely.geometry.Polygon + Source geometry + **kwargs : dict + Passed through to `packing.rectangles`. + + Returns + ------------- + transforms : (m, 3, 3) float + Homogeonous transforms from original frame to + packed frame. + consume : (n,) bool + Which of the original polygons was packed, + i.e. `consume.sum() == m` + """ + + from .polygons import polygon_bounds, polygons_obb + + # find the oriented bounding box of the polygons + obb, extents = polygons_obb(polygons) + + # run packing for a number of iterations + bounds, consume = rectangles(extents=extents, **kwargs) + + log.debug("%i/%i parts were packed successfully", consume.sum(), len(polygons)) + + # transformations to packed positions + roll = roll_transform(bounds=bounds, extents=extents[consume]) + + transforms = np.array([np.dot(b, a) for a, b in zip(obb[consume], roll)]) + + if tol.strict: + # original bounds should not overlap + assert not bounds_overlap(bounds) + # confirm transfor + check_bound = np.array( + [ + polygon_bounds(polygons[index], matrix=m) + for index, m in zip(np.nonzero(consume)[0], transforms) + ] + ) + assert not bounds_overlap(check_bound) + + return transforms, consume + + +def rectangles( + extents, + size=None, + density_escape=0.99, + spacing=None, + iterations=50, + rotate=True, + quanta=None, + seed: Seed = None, +): + """ + Run multiple iterations of rectangle packing, this is the + core function for all rectangular packing. + + Parameters + ------------ + extents : (n, dimension) float + Size of hyper-rectangle to be packed + size : None or (dimension,) float + Size of sheet to pack onto. If not passed tree will be allowed + to create new volume-minimizing parent nodes. + density_escape : float + Exit early if rectangular density is above this threshold. + spacing : float + Distance to allow between rectangles + iterations : int + Number of iterations to run + rotate : bool + Allow right angle rotations or not. + quanta : None or float + Discrete "snap" interval. + seed + If deterministic results are needed seed the RNG here. + + Returns + --------- + bounds : (m, 2, dimension) float + Axis aligned bounding boxes of inserted hyper-rectangle. + inserted : (n,) bool + Which of the original rect were packed. + """ + # copy extents and make sure they are floats + extents = np.array(extents, dtype=np.float64) + dim = extents.shape[1] + + if spacing is not None: + # add on any requested spacing + extents += spacing * 2.0 + + # hyper-volume: area in 2D, volume in 3D, party in 4D + area = np.prod(extents, axis=1) + # best density percentage in 0.0 - 1.0 + best_density = 0.0 + # how many rect were inserted + best_count = 0 + + # hoist the generator so the loop below draws from one stream + # rather than re-collecting OS entropy on every iteration + random = random_generator(seed) + + for i in range(iterations): + # run a single insertion order + # don't shuffle the first run, shuffle subsequent runs + bounds, insert = rectangles_single( + extents=extents, size=size, shuffle=(i != 0), rotate=rotate, random=random + ) + + count = insert.sum() + extents_all = np.ptp(bounds.reshape((-1, dim)), axis=0) + + if quanta is not None: + # compute the density using an upsized quanta + extents = np.ceil(extents_all / quanta) * quanta + + # calculate the packing density + density = area[insert].sum() / np.prod(extents_all) + + # compare this packing density against our best + if density > best_density or count > best_count: + best_density = density + best_count = count + # save the result + result = [bounds, insert] + # exit early if everything is inserted and + # we have exceeded our target density + if density > density_escape and insert.all(): + break + + if spacing is not None: + # shrink the bounds by spacing + result[0] += [[[spacing], [-spacing]]] + + log.debug(f"{iterations} iterations packed with density {best_density:0.3f}") + + return result + + +def images( + images, + power_resize: bool = False, + deduplicate: bool = False, + iterations: Integer | None = 50, + seed: Seed = None, + spacing: Number | None = None, + mode: str | None = None, +): + """ + Pack a list of images and return result and offsets. + + Parameters + ------------ + images : (n,) PIL.Image + Images to be packed + power_resize : bool + Should the result image be upsized to the nearest + power of two? Not every GPU supports materials that + aren't a power of two size. + deduplicate + Should images that have identical hashes be inserted + more than once? + mode + If passed return an output image with the + requested mode, otherwise will be picked + from the input images. + + Returns + ----------- + packed : PIL.Image + Multiple images packed into result + offsets : (n, 2) int + Offsets for original image to pack + """ + from PIL import Image + + if deduplicate: + # only pack duplicate images once + _, index, inverse = np.unique( + [hash(i.tobytes()) for i in images], return_index=True, return_inverse=True + ) + # use the number of pixels as the rectangle size + bounds, insert = rectangles( + extents=[images[i].size for i in index], + rotate=False, + iterations=iterations, + seed=seed, + spacing=spacing, + ) + # really should have inserted all the rect + assert insert.all() + # re-index bounds back to original indexes + bounds = bounds[inverse] + assert np.allclose(np.ptp(bounds, axis=1), [i.size for i in images]) + else: + # use the number of pixels as the rectangle size + bounds, insert = rectangles( + extents=[i.size for i in images], + rotate=False, + iterations=iterations, + seed=seed, + spacing=spacing, + ) + # really should have inserted all the rect + assert insert.all() + + if spacing is None: + spacing = 0 + else: + spacing = int(spacing) + + # offsets should be integer multiple of pizels + offset = bounds[:, 0].round().astype(int) + extents = np.ptp(bounds.reshape((-1, 2)), axis=0) + (spacing * 2) + size = extents.round().astype(int) + if power_resize: + # round up all dimensions to powers of 2 + size = (2 ** np.ceil(np.log2(size))).astype(np.int64) + + if mode is None: + # get the mode of every input image + modes = list({i.mode for i in images}) + # pick the longest mode as a simple heuristic + # which prefers "RGBA" over "RGB" + mode = modes[np.argmax([len(m) for m in modes])] + + # create the image in the mode of the first image + result = Image.new(mode, tuple(size)) + + done = set() + # paste each image into the result + for img, off in zip(images, offset): + if tuple(off) not in done: + # box is upper left corner + corner = (off[0], size[1] - img.size[1] - off[1]) + result.paste(img, box=corner) + else: + done.add(tuple(off)) + + return result, offset + + +def meshes(meshes, **kwargs): + """ + Pack 3D meshes into a rectangular volume using box packing. + + Parameters + ------------ + meshes : (n,) trimesh.Trimesh + Input geometry to pack + **kwargs : dict + Passed to `packing.rectangles` + + Returns + ------------ + placed : (m,) trimesh.Trimesh + Meshes moved into the rectangular volume. + transforms : (m, 4, 4) float + Homogeneous transform moving mesh from original + position to being packed in a rectangular volume. + consume : (n,) bool + Which of the original meshes were inserted, + i.e. `consume.sum() == m` + """ + # pack meshes relative to their oriented bounding boxes + obbs = [i.bounding_box_oriented for i in meshes] + obb_extent = np.array([i.primitive.extents for i in obbs]) + obb_transform = np.array([o.primitive.transform for o in obbs]) + + # run packing + bounds, consume = rectangles(obb_extent, **kwargs) + + # generate the transforms from an origin centered AABB + # to the final placed and rotated AABB + transforms = np.array( + [ + np.dot(r, np.linalg.inv(o)) + for o, r in zip( + obb_transform[consume], + roll_transform(bounds=bounds, extents=obb_extent[consume]), + ) + ], + dtype=np.float64, + ) + + # copy the meshes and move into position + placed = [ + meshes[index].copy().apply_transform(T) + for index, T in zip(np.nonzero(consume)[0], transforms) + ] + + return placed, transforms, consume + + +def visualize(extents, bounds): + """ + Visualize a 3D box packing. + + Parameters + ------------ + extents : (n, 3) float + AABB size before packing. + bounds : (n, 2, 3) float + AABB location after packing. + + Returns + ------------ + scene : trimesh.Scene + Scene with boxes at requested locations. + """ + from ..creation import box + from ..scene import Scene + from ..visual import random_color + + # use a roll transform to verify extents + transforms = roll_transform(bounds=bounds, extents=extents) + meshes = [box(extents=e) for e in extents] + + for m, matrix, check in zip(meshes, transforms, bounds): + m.apply_transform(matrix) + assert np.allclose(m.bounds, check) + m.visual.face_colors = random_color() + return Scene(meshes) + + +def roll_transform(bounds: ArrayLike, extents: ArrayLike) -> NDArray[float64]: + """ + Packing returns rotations with integer "roll" which + needs to be converted into a homogeneous rotation matrix. + + Currently supports `dimension=2` and `dimension=3`. + + Parameters + -------------- + bounds : (n, 2, dimension) float + Axis aligned bounding boxes of packed position + extents : (n, dimension) float + Original pre-rolled extents will be used + to determine rotation to move to `bounds`. + + Returns + ---------- + transforms : (n, dimension + 1, dimension + 1) float + Homogeneous transformation to move cuboid at the origin + into the position determined by `bounds`. + """ + if len(bounds) != len(extents): + raise ValueError("`bounds` must match `extents`") + if len(extents) == 0: + return [] + + # find the size of the AABB of the passed bounds + passed = np.ptp(bounds, axis=1) + # zeroth index is 2D, `1` is 3D + dimension = passed.shape[1] + + # store the resulting transformation matrices + result = np.tile(np.eye(dimension + 1), (len(bounds), 1, 1)) + + # a lookup table for rotations for rolling cuboiods + # as `lookup[dimension - 2][roll]` + # implemented for 2D and 3D + lookup = [ + np.array( + [np.eye(3), np.array([[0.0, -1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]])] + ), + np.array( + [ + np.eye(4), + [ + [-0.0, -0.0, -1.0, -0.0], + [-1.0, -0.0, -0.0, -0.0], + [0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 1.0], + ], + [ + [-0.0, -1.0, -0.0, -0.0], + [0.0, 0.0, 1.0, 0.0], + [-1.0, -0.0, -0.0, -0.0], + [0.0, 0.0, 0.0, 1.0], + ], + ] + ), + ] + + # rectangular rotation involves rolling + for roll in range(extents.shape[1]): + # find all the passed bounding boxes represented by + # rolling the original extents by this amount + rolled = np.roll(extents, roll, axis=1) + # check to see if the rolled original extents + # match the requested bounding box + ok = np.ptp((passed - rolled), axis=1) < _TOL_ZERO + if not ok.any(): + continue + + # the base rotation for this + mat = lookup[dimension - 2][roll] + # the lower corner of the AABB plus the rolled extent + offset = np.tile(np.eye(dimension + 1), (ok.sum(), 1, 1)) + offset[:, :dimension, dimension] = bounds[:, 0][ok] + rolled[ok] / 2.0 + result[ok] = [np.dot(o, mat) for o in offset] + + if tol.strict: + if dimension == 3: + # make sure bounds match inputs + from ..creation import box + + assert all( + allclose(box(extents=e).apply_transform(m).bounds, b) + for b, e, m in zip(bounds, extents, result) + ) + elif dimension == 2: + # in 2D check with a rectangle + from .creation import rectangle + + assert all( + allclose(rectangle(bounds=[-e / 2, e / 2]).apply_transform(m).bounds, b) + for b, e, m in zip(bounds, extents, result) + ) + else: + raise ValueError("unsupported dimension") + + return result + + +def bounds_overlap(bounds, epsilon=1e-8): + """ + Check to see if multiple axis-aligned bounding boxes + contains overlaps using `rtree`. + + Parameters + ------------ + bounds : (n, 2, dimension) float + Axis aligned bounding boxes + epsilon : float + Amount to shrink AABB to avoid spurious floating + point hits. + + Returns + -------------- + overlap : bool + True if any bound intersects any other bound. + """ + # pad AABB by epsilon for deterministic intersections + padded = np.array(bounds) + np.reshape([epsilon, -epsilon], (1, 2, 1)) + tree = bounds_tree(padded) + # every returned AABB should not overlap with any other AABB + return any( + set(tree.intersection(current.ravel())) != {i} for i, current in enumerate(bounds) + ) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/path.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/path.py new file mode 100644 index 0000000000000000000000000000000000000000..6a0f3a33e2f7fa2e00652c131793342b21b8447d --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/path.py @@ -0,0 +1,1598 @@ +""" +path.py +----------- + +A module designed to work with vector paths such as +those stored in a DXF or SVG file. +""" + +import collections +import warnings +from copy import deepcopy +from hashlib import sha256 + +import numpy as np + +from .. import ( + bounds, + caching, + comparison, + convex, + exceptions, + grouping, + parent, + units, + util, +) +from .. import transformations as tf +from ..caching import cache_decorator +from ..constants import log +from ..constants import tol_path as tol +from ..geometry import plane_transform +from ..points import plane_fit +from ..typed import ( + ArrayLike, + Iterable, + Mapping, + NDArray, + Self, + float64, +) +from ..visual import to_rgba +from . import ( + creation, # NOQA + raster, + segments, # NOQA + simplify, + traversal, +) +from .entities import Entity +from .exchange.export import export_path +from .util import concatenate + +# now import things which require non-minimal install of Trimesh +# create a dummy module which will raise the ImportError +# or other exception only when someone tries to use that function +try: + from . import repair +except BaseException as E: + repair = exceptions.ExceptionWrapper(E) +try: + from . import polygons +except BaseException as E: + polygons = exceptions.ExceptionWrapper(E) +try: + from scipy.spatial import cKDTree +except BaseException as E: + cKDTree = exceptions.ExceptionWrapper(E) +try: + from shapely.geometry import Polygon +except BaseException as E: + Polygon = exceptions.ExceptionWrapper(E) + +try: + import networkx as nx +except BaseException as E: + nx = exceptions.ExceptionWrapper(E) + + +class Path(parent.Geometry): + """ + A Path object consists of vertices and entities. Vertices + are a simple (n, dimension) float array of points in space. + + Entities are a list of objects representing geometric + primitives, such as Lines, Arcs, BSpline, etc. All entities + reference vertices by index, so any transform applied to the + simple vertex array is applied to the entity. + """ + + def __init__( + self, + entities: ArrayLike | Iterable[Entity] | None = None, + vertices: ArrayLike | None = None, + metadata: Mapping | None = None, + process: bool = True, + colors: ArrayLike | None = None, + vertex_attributes: Mapping | None = None, + **kwargs, + ): + """ + Instantiate a path object. + + Parameters + ----------- + entities : (m,) trimesh.path.entities.Entity + Contains geometric entities + vertices : (n, dimension) float + The vertices referenced by entities + metadata : dict + Any metadata about the path + process : bool + Run simple cleanup or not + colors + Set any per-entity colors. + vertex_attributes + Set any per-vertex array data. + """ + + self.entities = entities + self.vertices = vertices + + # assign each color to each entity + self.colors = colors + # collect metadata + self.metadata = {} + if isinstance(metadata, dict): + self.metadata.update(metadata) + + self.vertex_attributes = {} + if vertex_attributes is not None: + self.vertex_attributes.update(vertex_attributes) + + # cache will dump whenever self.crc changes + self._cache = caching.Cache(id_function=self.__hash__) + + if process: + # if our input had disconnected but identical points + # pretty much nothing will work if vertices aren't merged properly + self.merge_vertices() + + def __repr__(self): + """ + Print a quick summary of the number of vertices and entities. + """ + return f"" + + def process(self) -> Self: + """ + Apply basic cleaning functions to the Path object in-place. + """ + with self._cache: + self.merge_vertices() + self.remove_duplicate_entities() + self.remove_unreferenced_vertices() + return self + + @property + def colors(self) -> NDArray | None: + """ + Colors are stored per-entity. + + Returns + ------------ + colors : (len(entities), 4) uint8 + RGBA colors for each entity + """ + # start with default colors + raw = [e.color for e in self.entities] + if not any(c is not None for c in raw): + return None + + colors = np.array([to_rgba(c) for c in raw]) + # don't allow parts of the color array to be written + colors.flags["WRITEABLE"] = False + return colors + + @colors.setter + def colors(self, values: ArrayLike | None): + """ + Set the color for every entity in the Path. + + Parameters + ------------ + values : (len(entities), 4) uint8 + Color of each entity + """ + # if not set return + if values is None: + return + # make sure colors are RGBA + colors = to_rgba(values) + if len(colors) != len(self.entities): + raise ValueError("colors must be per-entity!") + # otherwise assign each color to the entity + for c, e in zip(colors, self.entities): + e.color = c + + @property + def vertices(self) -> NDArray[float64]: + return self._vertices + + @vertices.setter + def vertices(self, values: ArrayLike | None): + if values is None: + self._vertices = caching.tracked_array([], dtype=np.float64) + else: + self._vertices = caching.tracked_array(values, dtype=np.float64) + + @property + def entities(self): + """ + The actual entities making up the path. + + Returns + ----------- + entities : (n,) trimesh.path.entities.Entity + Entities such as Line, Arc, or BSpline curves + """ + return self._entities + + @entities.setter + def entities(self, values): + if values is None: + self._entities = np.array([]) + else: + self._entities = np.asanyarray(values) + + @property + def layers(self): + """ + Get a list of the layer for every entity. + + Returns + --------- + layers : (len(entities), ) any + Whatever is stored in each `entity.layer` + """ + # layer is a required meta-property for entities + return [e.layer for e in self.entities] + + def __hash__(self): + """ + A hash of the current vertices and entities. + + Returns + ------------ + hash : long int + Appended hashes + """ + # get the hash of the trackedarray vertices + hashable = [hex(self.vertices.__hash__()).encode("utf-8")] + # get the bytes for each entity + hashable.extend(e._bytes() for e in self.entities) + # hash the combined result + return caching.hash_fast(b"".join(hashable)) + + @cache_decorator + def identifier_hash(self): + """ + Return a hash of the identifier. + + Returns + ---------- + hashed : (64,) str + SHA256 hash of the identifier vector. + """ + as_int = (self.identifier * 1e4).astype(np.int64) + return sha256(as_int.tobytes(order="C")).hexdigest() + + @cache_decorator + def paths(self): + """ + Sequence of closed paths, encoded by entity index. + + Returns + --------- + paths : (n,) sequence of (*,) int + Referencing self.entities + """ + paths = traversal.closed_paths(self.entities, self.vertices) + return paths + + @cache_decorator + def dangling(self): + """ + List of entities that aren't included in a closed path + + Returns + ---------- + dangling : (n,) int + Index of self.entities + """ + if len(self.paths) == 0: + return np.arange(len(self.entities)) + + return np.setdiff1d(np.arange(len(self.entities)), np.hstack(self.paths)) + + @cache_decorator + def kdtree(self): + """ + A KDTree object holding the vertices of the path. + + Returns + ---------- + kdtree : scipy.spatial.cKDTree + Object holding self.vertices + """ + kdtree = cKDTree(self.vertices.view(np.ndarray)) + return kdtree + + @cache_decorator + def length(self): + """ + The total discretized length of every entity. + + Returns + -------- + length : float + Summed length of every entity + """ + length = float(sum(i.length(self.vertices) for i in self.entities)) + return length + + @cache_decorator + def bounds(self): + """ + Return the axis aligned bounding box of the current path. + + Returns + ---------- + bounds : (2, dimension) float + AABB with (min, max) coordinates + """ + # get the exact bounds of each entity + # some entities (aka 3- point Arc) have bounds that can't + # be generated from just bound box of vertices + + points = np.array( + [e.bounds(self.vertices) for e in self.entities], dtype=np.float64 + ) + + # flatten bound extrema into (n, dimension) array + points = points.reshape((-1, self.vertices.shape[1])) + # get the max and min of all bounds + return np.array([points.min(axis=0), points.max(axis=0)], dtype=np.float64) + + @cache_decorator + def centroid(self) -> NDArray[float64]: + """ + Return the centroid of axis aligned bounding box enclosing + all entities of the path object. + + Returns + ----------- + centroid : (d,) float + Approximate centroid of the path + """ + return self.bounds.mean(axis=0) + + @property + def extents(self) -> NDArray[float64]: + """ + The size of the axis aligned bounding box. + + Returns + --------- + extents : (dimension,) float + Edge length of AABB + """ + return np.ptp(self.bounds, axis=0) + + def convert_units(self, desired: str, guess: bool = False): + """ + Convert the units of the current drawing in place. + + Parameters + ----------- + desired : str + Unit system to convert to + guess : bool + If True will attempt to guess units + """ + units._convert_units(self, desired=desired, guess=guess) + + def explode(self): + """ + Turn every multi- segment entity into single segment + entities in- place. + """ + new_entities = [] + for entity in self.entities: + # explode into multiple entities + new_entities.extend(entity.explode()) + # avoid setter and assign new entities + self._entities = np.array(new_entities) + # explicitly clear cache + self._cache.clear() + + def fill_gaps(self, distance=0.025): + """ + Find vertices without degree 2 and try to connect to + other vertices. Operations are done in-place. + + Parameters + ---------- + distance : float + Connect vertices up to this distance + """ + repair.fill_gaps(self, distance=distance) + + @property + def is_closed(self): + """ + Are all entities connected to other entities. + + Returns + ----------- + closed : bool + Every entity is connected at its ends + """ + closed = all(i == 2 for i in dict(self.vertex_graph.degree()).values()) + + return closed + + @property + def is_empty(self): + """ + Are any entities defined for the current path. + + Returns + ---------- + empty : bool + True if no entities are defined + """ + return len(self.entities) == 0 + + @cache_decorator + def vertex_graph(self): + """ + Return a networkx.Graph object for the entity connectivity + + graph : networkx.Graph + Holds vertex indexes + """ + graph, _closed = traversal.vertex_graph(self.entities) + return graph + + @cache_decorator + def vertex_nodes(self): + """ + Get a list of which vertex indices are nodes, + which are either endpoints or points where the + entity makes a direction change. + + Returns + -------------- + nodes : (n, 2) int + Indexes of self.vertices which are nodes + """ + nodes = np.vstack([e.nodes for e in self.entities]) + return nodes + + def apply_transform(self, transform: ArrayLike) -> Self: + """ + Apply a transformation matrix to the current path in- place + + Parameters + ----------- + transform : (d+1, d+1) float + Homogeneous transformations for vertices + """ + dimension = self.vertices.shape[1] + transform = np.asanyarray(transform, dtype=np.float64) + + if transform.shape != (dimension + 1, dimension + 1): + raise ValueError("transform is incorrect shape!") + elif np.abs(transform - np.eye(dimension + 1)).max() < 1e-8: + # if we've been passed an identity matrix do nothing + return self + + # make sure cache is up to date + self._cache.verify() + # new cache to transfer items + cache = {} + # apply transform to discretized paths + if "discrete" in self._cache.cache: + cache["discrete"] = [ + tf.transform_points(d, matrix=transform) for d in self.discrete + ] + + # things we can just straight up copy + # as they are topological not geometric + for key in [ + "root", + "paths", + "path_valid", + "dangling", + "vertex_graph", + "enclosure", + "enclosure_shell", + "enclosure_directed", + ]: + # if they're in cache save them from the purge + if key in self._cache.cache: + cache[key] = self._cache.cache[key] + + # transform vertices in place + self.vertices = tf.transform_points(self.vertices, matrix=transform) + # explicitly clear the cache + self._cache.clear() + self._cache.id_set() + + # populate the things we wangled + self._cache.cache.update(cache) + return self + + def apply_layer(self, name: str) -> None: + """ + Apply a layer name to every entity in the path. + + Parameters + ------------ + name : str + Apply layer name to every entity + """ + for e in self.entities: + e.layer = name + + def rezero(self): + """ + Translate so that every vertex is positive in the current + mesh is positive. + + Returns + ----------- + matrix : (dimension + 1, dimension + 1) float + Homogeneous transformations that was applied + to the current Path object. + """ + # transform to the lower left corner + matrix = tf.translation_matrix(-self.bounds[0]) + # cleanly apply trransformation matrix + self.apply_transform(matrix) + + return matrix + + def merge_vertices(self, digits=None): + """ + Merges vertices which are identical and replace references + by altering `self.entities` and `self.vertices` + + Parameters + -------------- + digits : None, or int + How many digits to consider when merging vertices + """ + if len(self.vertices) == 0: + return + if digits is None: + digits = util.decimal_to_digits(tol.merge * self.scale, min_digits=1) + + unique, inverse = grouping.unique_rows(self.vertices, digits=digits) + self.vertices = self.vertices[unique] + self.vertex_attributes = { + key: np.array(value)[unique] for key, value in self.vertex_attributes.items() + } + + entities_ok = np.ones(len(self.entities), dtype=bool) + + for index, entity in enumerate(self.entities): + # what kind of entity are we dealing with + kind = type(entity).__name__ + + # entities that don't need runs merged + # don't screw up control- point- knot relationship + if kind in "BSpline Bezier Text": + entity.points = inverse[entity.points] + continue + # if we merged duplicate vertices, the entity may + # have multiple references to the same vertex + points = grouping.merge_runs(inverse[entity.points]) + # if there are three points and two are identical fix it + if kind == "Line": + if len(points) == 3 and points[0] == points[-1]: + points = points[:2] + elif len(points) < 2: + # lines need two or more vertices + entities_ok[index] = False + elif kind == "Arc" and len(points) != 3: + # three point arcs need three points + entities_ok[index] = False + + # store points in entity + entity.points = points + + # remove degenerate entities + self.entities = self.entities[entities_ok] + + def replace_vertex_references(self, mask): + """ + Replace the vertex index references in every entity. + + Parameters + ------------ + mask : (len(self.vertices), ) int + Contains new vertex indexes + + Notes + ------------ + entity.points in self.entities + Replaced by mask[entity.points] + """ + for entity in self.entities: + entity.points = mask[entity.points] + + def remove_entities(self, entity_ids): + """ + Remove entities by index. + + Parameters + ----------- + entity_ids : (n,) int + Indexes of self.entities to remove + """ + if len(entity_ids) == 0: + return + keep = np.ones(len(self.entities), dtype=bool) + keep[entity_ids] = False + self.entities = self.entities[keep] + + def remove_invalid(self): + """ + Remove entities which declare themselves invalid + + Notes + ---------- + self.entities: shortened + """ + valid = np.array([i.is_valid for i in self.entities], dtype=bool) + self.entities = self.entities[valid] + + def remove_duplicate_entities(self): + """ + Remove entities that are duplicated + + Notes + ------- + self.entities: length same or shorter + """ + entity_hashes = np.array([hash(i) for i in self.entities]) + unique, _inverse = grouping.unique_rows(entity_hashes) + if len(unique) != len(self.entities): + self.entities = self.entities[unique] + + @cache_decorator + def referenced_vertices(self): + """ + Which vertices are referenced by an entity. + + Returns + ----------- + referenced_vertices: (n,) int, indexes of self.vertices + """ + # no entities no reference + if len(self.entities) == 0: + return np.array([], dtype=np.int64) + return np.unique( + np.concatenate([e.points for e in self.entities]).astype(np.int64) + ) + + def remove_unreferenced_vertices(self): + """ + Removes all vertices which aren't used by an entity. + + Notes + --------- + self.vertices : reordered and shortened + self.entities : entity.points references updated + """ + + unique = self.referenced_vertices + + mask = np.ones(len(self.vertices), dtype=np.int64) * -1 + mask[unique] = np.arange(len(unique), dtype=np.int64) + + self.replace_vertex_references(mask=mask) + self.vertices = self.vertices[unique] + + @cache_decorator + def discrete(self) -> list[NDArray[float64]]: + """ + A sequence of connected vertices in space, corresponding to + self.paths. + + Returns + --------- + discrete : (len(self.paths),) + A sequence of (m*, dimension) float + """ + # avoid cache hits in the loop + scale = self.scale + entities = self.entities + vertices = self.vertices + + # discretize each path + return [ + traversal.discretize_path( + entities=entities, vertices=vertices, path=path, scale=scale + ) + for path in self.paths + ] + + def export(self, file_obj=None, file_type=None, **kwargs): + """ + Export the path to a file object or return data. + + Parameters + --------------- + file_obj : None, str, or file object + File object or string to export to + file_type : None or str + Type of file: dxf, dict, svg + + Returns + --------------- + exported : bytes or str + Exported as specified type + """ + return export_path(self, file_type=file_type, file_obj=file_obj, **kwargs) + + def to_dict(self) -> dict: + return self.export(file_type="dict") + + def copy(self, layers: str | Iterable[str | None] | None = None): + """ + Get a copy of the current mesh + + Parameters + ------------ + layers + If passed an iterable of layer names which will + only include those layers in the copy of the path. + + Returns + --------- + copied : Path object + Copy of self + """ + + metadata = {} + # grab all the keys into a list so if something is added + # in another thread it probably doesn't stomp on our loop + for key in list(self.metadata.keys()): + try: + metadata[key] = deepcopy(self.metadata[key]) + except RuntimeError: + # multiple threads + log.warning(f"key {key} changed during copy") + + if layers is not None: + # get layers as a set for in-loop checks + if isinstance(layers, str): + # the `set` constructor would split in to char + layers = {layers} + else: + # a set of strings + layers = set(layers) + # cherry pick the entities we want + entities = [e for e in self.entities if e.layer in layers] + else: + entities = self.entities + + # copy the core data + copied = type(self)( + entities=deepcopy(entities), + vertices=deepcopy(self.vertices), + metadata=metadata, + process=False, + ) + + # skip the cache wangling for a subset copy + if layers is not None: + return copied + + cache = {} + # try to copy the cache over to the new object + try: + # save dict keys before doing slow iteration + keys = list(self._cache.cache.keys()) + # run through each key and copy into new cache + for k in keys: + cache[k] = deepcopy(self._cache.cache[k]) + except RuntimeError: + # if we have multiple threads this may error and is NBD + log.debug("unable to copy cache") + except BaseException: + # catch and log errors we weren't expecting + log.error("unable to copy cache", exc_info=True) + copied._cache.cache = cache + copied._cache.id_set() + + return copied + + def scene(self): + """ + Get a scene object containing the current Path3D object. + + Returns + -------- + scene: trimesh.scene.Scene object containing current path + """ + from ..scene import Scene + + scene = Scene(self) + return scene + + def __add__(self, other): + """ + Concatenate two Path objects by appending vertices and + reindexing point references. + + Parameters + ----------- + other: Path object + + Returns + ----------- + concat: Path object, appended from self and other + """ + concat = concatenate([self, other]) + return concat + + +class Path3D(Path): + """ + Hold multiple vector curves (lines, arcs, splines, etc) in 3D. + """ + + def to_planar(self, *args, **kwargs): + """ + DEPRECATED: replace `path.to_planar`->`path.to_2D), removal 1/1/2026 + """ + warnings.warn( + "DEPRECATED: replace `path.to_planar`->`path.to_2D), removal 1/1/2026", + category=DeprecationWarning, + stacklevel=2, + ) + return self.to_2D(*args, **kwargs) + + def to_2D( + self, + to_2D: ArrayLike | None = None, + normal: ArrayLike | None = None, + check: bool = True, + ) -> tuple["Path2D", NDArray[float64]]: + """ + Check to see if current vectors are all coplanar. + + If they are, return a Path2D and a transform which will + transform the 2D representation back into 3 dimensions + + Parameters + ----------- + to_2D : (4, 4) float + Homogeneous transformation matrix to apply, + if not passed a plane will be fitted to vertices. + normal : (3,) float or None + Normal of direction of plane to use. + check + Raise a ValueError if points aren't coplanar. + + Returns + ----------- + planar + Current path transformed onto plane + to_3D : (4, 4) float + Homeogenous transformations to move planar + back into the original 3D frame. + """ + # which vertices are actually referenced + referenced = self.referenced_vertices + # if nothing is referenced return an empty path + if len(referenced) == 0: + return Path2D(), np.eye(4) + + # support (n, 2) and (n, 3) vertices here + dim = self.vertices.shape[1] + + # already flat + if dim == 2: + to_2D = np.eye(4) + elif dim != 3: + raise ValueError(f"vertices are `{dim}D != 2D | 3D`!") + + # no explicit transform passed + if to_2D is None: + # fit a plane to our vertices + C, N = plane_fit(self.vertices[referenced]) + # apply the normal sign hint + if normal is not None: + # make sure normal is a 3D vector + normal = np.array(normal, dtype=np.float64).reshape(3) + # apply the sign from the passed normal + N *= np.sign(np.dot(N, normal)) + # create a transform from fit plane to XY + to_2D = plane_transform(origin=C, normal=N) + + # make sure we've extracted a transform + to_2D = np.array(to_2D, dtype=np.float64) + if to_2D.shape != (4, 4): + raise ValueError("unable to create transform!") + + if dim == 3: + # transform all vertices to 2D plane + flat = tf.transform_points(self.vertices, to_2D) + # Z values of vertices which are referenced + heights = flat[referenced][:, 2] + # points are not on a plane because Z varies + if np.ptp(heights) > tol.planar: + # since Z is inconsistent set height to zero + height = 0.0 + if check: + raise ValueError("points are not flat!") + else: + # if the points were planar store the height + height = heights.mean() + elif dim == 2: + flat = self.vertices.copy() + height = 0.0 + + # the transform from 2D to 3D + to_3D = np.linalg.inv(to_2D) + + # if the transform didn't move the path to + # exactly Z=0 adjust it so the returned transform does + if np.abs(height) > tol.planar: + # adjust to_3D transform by height + adjust = tf.translation_matrix([0, 0, height]) + # apply the height adjustment to_3D + to_3D = np.dot(to_3D, adjust) + + # copy metadata to new object + metadata = deepcopy(self.metadata) + # store transform we used to move it onto the plane + metadata["to_3D"] = to_3D + + # create the Path2D with the same entities + # and XY values of vertices projected onto the plane + planar = Path2D( + entities=deepcopy(self.entities), + vertices=flat[:, :2], + metadata=metadata, + process=False, + ) + + return planar, to_3D + + @cache_decorator + def identifier(self) -> NDArray[float64]: + """ + Return a simple identifier for the 3D path. + """ + return np.concatenate( + (comparison.identifier_simple(self.convex_hull), [self.length]) + ) + + @cache_decorator + def convex_hull(self): + """ + Return a convex hull of the 3D path. + + Returns + -------- + hull : trimesh.Trimesh + A mesh of the convex hull of the 3D path. + """ + return convex.convex_hull(self.vertices[self.referenced_vertices]) + + def show(self, **kwargs): + """ + Show the current Path3D object. + """ + scene = self.scene() + return scene.show(**kwargs) + + +class Path2D(Path): + """ + Hold multiple vector curves (lines, arcs, splines, etc) in 3D. + """ + + def show(self, annotations=True): + """ + Plot the current Path2D object using matplotlib. + """ + if self.is_closed: + self.plot_discrete(show=True, annotations=annotations) + else: + self.plot_entities(show=True, annotations=annotations) + + def apply_obb(self): + """ + Transform the current path so that its OBB is axis aligned + and OBB center is at the origin. + + Returns + ----------- + obb : (3, 3) float + Homogeneous transformation matrix + """ + matrix = self.obb + self.apply_transform(matrix) + return matrix + + def apply_scale(self, scale): + """ + Apply a 2D scale to the current Path2D. + + Parameters + ------------- + scale : float or (2,) float + Scale to apply in-place. + """ + matrix = np.eye(3) + matrix[:2, :2] *= scale + return self.apply_transform(matrix) + + @cache_decorator + def obb(self): + """ + Get a transform that centers and aligns the OBB of the + referenced vertices with the XY axis. + + Returns + ----------- + obb : (3, 3) float + Homogeneous transformation matrix + """ + matrix = bounds.oriented_bounds_2D(self.vertices[self.referenced_vertices])[0] + return matrix + + @cache_decorator + def convex_hull(self) -> "Path2D": + """ + Return a convex hull of the 2D path. + + Returns + -------- + hull + A convex hull of included vertices from this path. + """ + from scipy.spatial import ConvexHull + + from .exchange.misc import edges_to_path + + # include referenced vertices + candidates = [self.vertices[self.referenced_vertices]] + # include all points from discretized closed curves + # this prevents arcs from being collapsed past the + # discretization parameters set globally + candidates.extend(self.discrete) + candidates = np.vstack(candidates) + + # if there's only 2 points this is a zero-area hull + if len(candidates) < 3: + return Path2D() + + try: + # calculate a 2D convex hull for our candidate vertices + hull = ConvexHull(candidates) + except BaseException: + # this may raise if the geometry is colinear in + # which case an empty path is correct + log.debug("Failed to construct convex hull", exc_info=True) + return Path2D() + + # map edges to throw away unused vertices + # as `hull.points` includes all input points + remap = np.arange(len(hull.points)) + remap[hull.vertices] = np.arange(len(hull.vertices)) + + # get zero-indexed edges and only included vertices + edges = remap[hull.simplices] + vertices = hull.points[hull.vertices] + + return Path2D(**edges_to_path(edges=edges, vertices=vertices)) + + def rasterize( + self, pitch=None, origin=None, resolution=None, fill=True, width=None, **kwargs + ): + """ + Rasterize a Path2D object into a boolean image ("mode 1"). + + Parameters + ------------ + pitch : float or (2,) float + Length(s) in model space of pixel edges + origin : (2,) float + Origin position in model space + resolution : (2,) int + Resolution in pixel space + fill : bool + If True will return closed regions as filled + width : int + If not None will draw outline this wide (pixels) + + Returns + ------------ + raster : PIL.Image object, mode 1 + Rasterized version of closed regions. + """ + image = raster.rasterize( + self, + pitch=pitch, + origin=origin, + resolution=resolution, + fill=fill, + width=width, + ) + return image + + def sample(self, count, **kwargs): + """ + Use rejection sampling to generate random points inside a + polygon. + + Parameters + ----------- + count : int + Number of points to return + If there are multiple bodies, there will + be up to count * bodies points returned + factor : float + How many points to test per loop + IE, count * factor + max_iter : int, + Maximum number of intersection loops + to run, total points sampled is + count * factor * max_iter + + Returns + ----------- + hit : (n, 2) float + Random points inside polygon + """ + + poly = self.polygons_full + if len(poly) == 0: + samples = np.array([]) + elif len(poly) == 1: + samples = polygons.sample(poly[0], count=count, **kwargs) + else: + samples = util.vstack_empty( + [polygons.sample(i, count=count, **kwargs) for i in poly] + ) + + return samples + + @property + def body_count(self): + """ + Returns a count of the number of unconnected polygons that + may contain other curves but aren't contained themselves. + + Returns + --------- + body_count : int + Number of unconnected independent polygons. + """ + return len(self.root) + + def to_3D(self, transform=None): + """ + Convert 2D path to 3D path on the XY plane. + + Parameters + ------------- + transform : (4, 4) float + If passed, will transform vertices. + If not passed and 'to_3D' is in self.metadata + that transform will be used. + + Returns + ----------- + path_3D : Path3D + 3D version of current path + """ + # if there is a stored 'to_3D' transform in metadata use it + if transform is None and "to_3D" in self.metadata: + transform = self.metadata["to_3D"] + + # copy vertices and stack with zeros from (n, 2) to (n, 3) + vertices = np.column_stack( + (deepcopy(self.vertices), np.zeros(len(self.vertices))) + ) + if transform is not None: + vertices = tf.transform_points(vertices, transform) + # make sure everything is deep copied + path_3D = Path3D( + entities=deepcopy(self.entities), + vertices=vertices, + metadata=deepcopy(self.metadata), + ) + return path_3D + + @cache_decorator + def polygons_closed(self) -> NDArray: + """ + Cycles in the vertex graph, as shapely.geometry.Polygons. + These are polygon objects for every closed circuit, with no notion + of whether a polygon is a hole or an area. Every polygon in this + list will have an exterior, but NO interiors. + + Returns + --------- + polygons_closed : (n,) list of shapely.geometry.Polygon objects + """ + # will attempt to recover invalid garbage geometry + # and will be None if geometry is unrecoverable + return polygons.paths_to_polygons(self.discrete) + + @cache_decorator + def polygons_full(self) -> list: + """ + A list of shapely.geometry.Polygon objects with interiors created + by checking which closed polygons enclose which other polygons. + + Returns + --------- + full : (len(self.root),) shapely.geometry.Polygon + Polygons containing interiors. An entry is `None` when the + root curve's geometry could not be recovered (i.e. `None` + in `polygons_closed`), preserving correspondence with + `self.root`. + """ + # pre- allocate the list to avoid indexing problems + full = [None] * len(self.root) + # store the graph to avoid cache thrashing + enclosure = self.enclosure_directed + # store closed polygons to avoid cache hits + closed = self.polygons_closed + + # loop through root curves + for i, root in enumerate(self.root): + # `polygons_closed` may contain `None` for degenerate + # geometry it could not recover: leave the entry as `None` + # rather than raising an AttributeError on `None.exterior` + if closed[root] is None: + continue + # a list of multiple Polygon objects that + # are fully contained by the root curve + children = [closed[child] for child in enclosure[root].keys()] + # all polygons_closed are CCW, so for interiors reverse them + holes = [np.array(p.exterior.coords)[::-1] for p in children if p is not None] + # a single Polygon object + shell = closed[root].exterior + # create a polygon with interiors + full[i] = polygons.repair_invalid(Polygon(shell=shell, holes=holes)) + + return full + + @cache_decorator + def area(self): + """ + Return the area of the polygons interior. + + Returns + --------- + area : float + Total area of polygons minus interiors + """ + area = float(sum(i.area for i in self.polygons_full)) + return area + + def extrude(self, height, **kwargs): + """ + Extrude the current 2D path into a 3D mesh. + + Parameters + ---------- + height: float, how far to extrude the profile + kwargs: passed directly to meshpy.triangle.build: + triangle.build(mesh_info, + verbose=False, + refinement_func=None, + attributes=False, + volume_constraints=True, + max_volume=None, + allow_boundary_steiner=True, + allow_volume_steiner=True, + quality_meshing=True, + generate_edges=None, + generate_faces=False, + min_angle=None) + Returns + -------- + mesh: trimesh object representing extruded polygon + """ + from ..primitives import Extrusion + + result = [ + Extrusion(polygon=i, height=height, **kwargs) for i in self.polygons_full + ] + if len(result) == 1: + return result[0] + return result + + def triangulate(self, **kwargs): + """ + Create a region- aware triangulation of the 2D path. + + Parameters + ------------- + **kwargs : dict + Passed to `trimesh.creation.triangulate_polygon` + + Returns + ------------- + vertices : (n, 2) float + 2D vertices of triangulation + faces : (n, 3) int + Indexes of vertices for triangles + """ + from ..creation import triangulate_polygon + + # append vertices and faces into sequence + v_seq = [] + f_seq = [] + + # loop through polygons with interiors + for polygon in self.polygons_full: + v, f = triangulate_polygon(polygon, **kwargs) + v_seq.append(v) + f_seq.append(f) + + return util.append_faces(v_seq, f_seq) + + def medial_axis(self, resolution=None, clip=None): + """ + Find the approximate medial axis based + on a voronoi diagram of evenly spaced points on the + boundary of the polygon. + + Parameters + ---------- + resolution : None or float + Distance between each sample on the polygon boundary + clip : None, or (2,) float + Min, max number of samples + + Returns + ---------- + medial : Path2D object + Contains only medial axis of Path + """ + if resolution is None: + resolution = self.scale / 1000.0 + + # convert the edges to Path2D kwargs + from .exchange.misc import edges_to_path + + # edges and vertices + edge_vert = [ + polygons.medial_axis(i, resolution, clip) for i in self.polygons_full + ] + # create a Path2D object for each region + medials = [Path2D(**edges_to_path(edges=e, vertices=v)) for e, v in edge_vert] + + # get a single Path2D of medial axis + medial = concatenate(medials) + + return medial + + def connected_paths(self, path_id, include_self=False): + """ + Given an index of self.paths find other paths which + overlap with that path. + + Parameters + ----------- + path_id : int + Index of self.paths + include_self : bool + Should the result include path_id or not + + Returns + ----------- + path_ids : (n, ) int + Indexes of self.paths that overlap input path_id + """ + if len(self.root) == 1: + path_ids = np.arange(len(self.polygons_closed)) + else: + path_ids = list(nx.node_connected_component(self.enclosure, path_id)) + if include_self: + return np.array(path_ids) + return np.setdiff1d(path_ids, [path_id]) + + def simplify(self, **kwargs): + """ + Return a version of the current path with colinear segments + merged, and circles entities replacing segmented circular paths. + + Returns + --------- + simplified : Path2D object + """ + return simplify.simplify_basic(self, **kwargs) + + def simplify_spline(self, smooth=0.0002, verbose=False): + """ + Convert paths into b-splines. + + Parameters + ----------- + smooth : float + How much the spline should smooth the curve + verbose : bool + Print detailed log messages + + Returns + ------------ + simplified : Path2D + Discrete curves replaced with splines + """ + return simplify.simplify_spline(self, smooth=smooth, verbose=verbose) + + def split(self, **kwargs): + """ + If the current Path2D consists of n 'root' curves, + split them into a list of n Path2D objects + + Returns + ---------- + split: (n,) list of Path2D objects + Each connected region and interiors + """ + return traversal.split(self) + + def plot_discrete(self, show=False, annotations=True): + """ + Plot the closed curves of the path. + """ + import matplotlib.pyplot as plt # noqa + + axis = plt.gca() + axis.set_aspect("equal", "datalim") + + for i, points in enumerate(self.discrete): + color = ["g", "k"][i in self.root] + axis.plot(*points.T, color=color) + + if annotations: + for e in self.entities: + if not hasattr(e, "plot"): + continue + e.plot(self.vertices) + + if show: + plt.show() + return axis + + def plot_entities(self, show=False, annotations=True, color=None): + """ + Plot the entities of the path with no notion of topology. + + Parameters + ------------ + show : bool + Open a window immediately or not + annotations : bool + Call an entities custom plot function. + color : str + Override entity colors and make them all this color. + """ + import matplotlib.pyplot as plt # noqa + + # keep plot axis scaled the same + axis = plt.gca() + axis.set_aspect("equal", "datalim") + # hardcode a format for each entity type + eformat = { + "Line0": {"color": "g", "linewidth": 1}, + "Line1": {"color": "y", "linewidth": 1}, + "Arc0": {"color": "r", "linewidth": 1}, + "Arc1": {"color": "b", "linewidth": 1}, + "Bezier0": {"color": "k", "linewidth": 1}, + "Bezier1": {"color": "k", "linewidth": 1}, + "BSpline0": {"color": "m", "linewidth": 1}, + "BSpline1": {"color": "m", "linewidth": 1}, + } + for entity in self.entities: + # if the entity has it's own plot method use it + if annotations and hasattr(entity, "plot"): + entity.plot(self.vertices) + continue + # otherwise plot the discrete curve + discrete = entity.discrete(self.vertices) + # a unique key for entities + e_key = entity.__class__.__name__ + str(int(entity.closed)) + + fmt = eformat[e_key].copy() + if color is not None: + # passed color will override other options + fmt["color"] = color + elif hasattr(entity, "color"): + # if entity has specified color use it + fmt["color"] = entity.color + axis.plot(*discrete.T, **fmt) + if show: + plt.show() + + @property + def identifier(self): + """ + A unique identifier for the path. + + Returns + --------- + identifier : (5,) float + Unique identifier + """ + hasher = polygons.identifier + target = self.polygons_full + if len(target) == 1: + return hasher(self.polygons_full[0]) + elif len(target) == 0: + return np.zeros(5) + return np.sum([hasher(p) for p in target], axis=0) + + @property + def path_valid(self): + """ + Returns + ---------- + path_valid : (n,) bool + Indexes of self.paths self.polygons_closed + which are valid polygons. + """ + return np.array([i is not None for i in self.polygons_closed], dtype=bool) + + @cache_decorator + def root(self) -> NDArray[np.int64]: + """ + Which indexes of self.paths/self.polygons_closed + are root curves, also known as 'shell' or 'exterior. + + Returns + --------- + root : (n,) int + List of indexes + """ + populate = self.enclosure_directed # NOQA + return self._cache["root"] + + @cache_decorator + def enclosure(self): + """ + Undirected graph object of polygon enclosure. + + Returns + ----------- + enclosure : networkx.Graph + Enclosure graph of self.polygons by index. + """ + with self._cache: + undirected = self.enclosure_directed.to_undirected() + return undirected + + @cache_decorator + def enclosure_directed(self): + """ + Directed graph of polygon enclosure. + + Returns + ---------- + enclosure_directed : networkx.DiGraph + Directed graph: child nodes are fully + contained by their parent node. + """ + root, enclosure = polygons.enclosure_tree(self.polygons_closed) + self._cache["root"] = root + return enclosure + + @cache_decorator + def enclosure_shell(self): + """ + A dictionary of path indexes which are 'shell' paths, and values + of 'hole' paths. + + Returns + ---------- + corresponding : dict + {index of self.paths of shell : [indexes of holes]} + """ + pairs = [(r, self.connected_paths(r, include_self=False)) for r in self.root] + # OrderedDict to maintain corresponding order + return collections.OrderedDict(pairs) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/polygons.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/polygons.py new file mode 100644 index 0000000000000000000000000000000000000000..f436e238ae2a2b38227a0a707a6223c6dcbb98ba --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/polygons.py @@ -0,0 +1,992 @@ +import numpy as np +from shapely import ops +from shapely.geometry import Polygon + +from .. import bounds, geometry, graph, grouping +from ..constants import log +from ..constants import tol_path as tol +from ..iteration import reduce_cascade +from ..transformations import transform_points +from ..typed import ArrayLike, Iterable, NDArray, Number, Seed, float64, int64 +from ..util import random_generator +from .simplify import fit_circle_check +from .traversal import resample_path + +try: + import networkx as nx +except BaseException as E: + # create a dummy module which will raise the ImportError + # or other exception only when someone tries to use networkx + from ..exceptions import ExceptionWrapper + + nx = ExceptionWrapper(E) +try: + from rtree.index import Index +except BaseException as E: + # create a dummy module which will raise the ImportError + from ..exceptions import ExceptionWrapper + + Index = ExceptionWrapper(E) + + +def enclosure_tree(polygons): + """ + Given a list of shapely polygons with only exteriors, + find which curves represent the exterior shell or root curve + and which represent holes which penetrate the exterior. + + This is done with an R-tree for rough overlap detection, + and then exact polygon queries for a final result. + + Parameters + ----------- + polygons : (n,) shapely.geometry.Polygon + Polygons which only have exteriors and may overlap + + Returns + ----------- + roots : (m,) int + Index of polygons which are root + contains : networkx.DiGraph + Edges indicate a polygon is + contained by another polygon + """ + + # nodes are indexes in polygons + contains = nx.DiGraph() + + if len(polygons) == 0: + return np.array([], dtype=np.int64), contains + elif len(polygons) == 1: + # `paths_to_polygons` may produce `None` for unrecoverable + # geometry: never emit it as a root, matching the multi-polygon + # code path below where `None` is excluded by the bounds check + if polygons[0] is None: + return np.array([], dtype=np.int64), contains + # add an early exit for only a single polygon + contains.add_node(0) + return np.array([0], dtype=np.int64), contains + + # get the bounds for every valid polygon + bounds = { + k: v + for k, v in { + i: getattr(polygon, "bounds", []) for i, polygon in enumerate(polygons) + }.items() + if len(v) == 4 + } + + # make sure we don't have orphaned polygon + contains.add_nodes_from(bounds.keys()) + + if len(bounds) > 0: + # if there are no valid bounds tree creation will fail + # and we won't be calling `tree.intersection` anywhere + # we could return here but having multiple return paths + # seems more dangerous than iterating through an empty graph + tree = Index(zip(bounds.keys(), bounds.values(), [None] * len(bounds))) + + # loop through every polygon + for i, b in bounds.items(): + # we first query for bounding box intersections from the R-tree + for j in tree.intersection(b): + # if we are checking a polygon against itself continue + if i == j: + continue + # do a more accurate polygon in polygon test + # for the enclosure tree information + if polygons[i].contains(polygons[j]): + contains.add_edge(i, j) + elif polygons[j].contains(polygons[i]): + contains.add_edge(j, i) + + # a root or exterior curve has an even number of parents + # wrap in dict call to avoid networkx view + degree = dict(contains.in_degree()) + # convert keys and values to numpy arrays + indexes = np.array(list(degree.keys())) + degrees = np.array(list(degree.values())) + # roots are curves with an even inward degree (parent count) + roots = indexes[(degrees % 2) == 0] + # if there are multiple nested polygons split the graph + # so the contains logic returns the individual polygons + if len(degrees) > 0 and degrees.max() > 1: + # collect new edges for graph + edges = [] + # order the roots so they are sorted by degree + roots = roots[np.argsort([degree[r] for r in roots])] + # find edges of subgraph for each root and children + for root in roots: + children = indexes[degrees == degree[root] + 1] + edges.extend(contains.subgraph(np.append(children, root)).edges()) + # stack edges into new directed graph + contains = nx.from_edgelist(edges, nx.DiGraph()) + # if roots have no children add them anyway + contains.add_nodes_from(roots) + + return roots, contains + + +def edges_to_polygons(edges: NDArray[int64], vertices: NDArray[float64]): + """ + Given an edge list of indices and associated vertices + representing lines, generate a list of polygons. + + Parameters + ----------- + edges : (n, 2) + Indexes of vertices which represent lines + vertices : (m, 2) + Vertices in 2D space. + + Returns + ---------- + polygons : (p,) shapely.geometry.Polygon + Polygon objects with interiors + """ + + assert isinstance(vertices, np.ndarray) + + # create closed polygon objects + polygons = [] + # loop through a sequence of ordered traversals + for dfs in graph.traversals(edges, mode="dfs"): + try: + # try to recover polygons before they are more complicated + repaired = repair_invalid(Polygon(vertices[dfs])) + # if it returned a multipolygon extend into a flat list + if hasattr(repaired, "geoms"): + polygons.extend(repaired.geoms) + else: + polygons.append(repaired) + except ValueError: + continue + + # if there is only one polygon, just return it + if len(polygons) == 1: + return polygons + + # find which polygons contain which other polygons + roots, tree = enclosure_tree(polygons) + + # generate polygons with proper interiors + return [ + Polygon( + shell=polygons[root].exterior, + holes=[polygons[i].exterior for i in tree[root].keys()], + ) + for root in roots + ] + + +def polygons_obb(polygons: Iterable[Polygon] | ArrayLike): + """ + Find the OBBs for a list of shapely.geometry.Polygons + """ + rectangles = [None] * len(polygons) + transforms = [None] * len(polygons) + for i, p in enumerate(polygons): + transforms[i], rectangles[i] = polygon_obb(p) + return np.array(transforms), np.array(rectangles) + + +def polygon_obb(polygon: Polygon | NDArray): + """ + Find the oriented bounding box of a Shapely polygon. + + The OBB is always aligned with an edge of the convex hull of the polygon. + + Parameters + ------------- + polygons : shapely.geometry.Polygon + Input geometry + + Returns + ------------- + transform : (3, 3) float + Transformation matrix + which will move input polygon from its original position + to the first quadrant where the AABB is the OBB + extents : (2,) float + Extents of transformed polygon + """ + if hasattr(polygon, "exterior"): + points = np.asanyarray(polygon.exterior.coords) + elif isinstance(polygon, np.ndarray): + points = polygon + else: + raise ValueError("polygon or points must be provided") + + transform, extents = bounds.oriented_bounds_2D(points) + + if tol.strict: + moved = transform_points(points=points, matrix=transform) + assert np.allclose(-extents / 2.0, moved.min(axis=0)) + assert np.allclose(extents / 2.0, moved.max(axis=0)) + + return transform, extents + + +def transform_polygon(polygon, matrix): + """ + Transform a polygon by a a 2D homogeneous transform. + + Parameters + ------------- + polygon : shapely.geometry.Polygon + 2D polygon to be transformed. + matrix : (3, 3) float + 2D homogeneous transformation. + + Returns + -------------- + result : shapely.geometry.Polygon + Polygon transformed by matrix. + """ + matrix = np.asanyarray(matrix, dtype=np.float64) + + if hasattr(polygon, "geoms"): + result = [transform_polygon(p, t) for p, t in zip(polygon, matrix)] + return result + # transform the outer shell + shell = transform_points(np.array(polygon.exterior.coords), matrix)[:, :2] + # transform the interiors + holes = [ + transform_points(np.array(i.coords), matrix)[:, :2] for i in polygon.interiors + ] + # create a new polygon with the result + result = Polygon(shell=shell, holes=holes) + return result + + +def polygon_bounds(polygon, matrix=None): + """ + Get the transformed axis aligned bounding box of a + shapely Polygon object. + + Parameters + ------------ + polygon : shapely.geometry.Polygon + Polygon pre-transform + matrix : (3, 3) float or None. + Homogeneous transform moving polygon in space + + Returns + ------------ + bounds : (2, 2) float + Axis aligned bounding box of transformed polygon. + """ + if matrix is not None: + assert matrix.shape == (3, 3) + points = transform_points(points=np.array(polygon.exterior.coords), matrix=matrix) + else: + points = np.array(polygon.exterior.coords) + + bounds = np.array([points.min(axis=0), points.max(axis=0)]) + assert bounds.shape == (2, 2) + return bounds + + +def plot(polygon=None, show=True, axes=None, **kwargs): + """ + Plot a shapely polygon using matplotlib. + + Parameters + ------------ + polygon : shapely.geometry.Polygon + Polygon to be plotted + show : bool + If True will display immediately + **kwargs + Passed to plt.plot + """ + import matplotlib.pyplot as plt # noqa + + def plot_single(single): + axes.plot(*single.exterior.xy, **kwargs) + for interior in single.interiors: + axes.plot(*interior.xy, **kwargs) + + # make aspect ratio non-stupid + if axes is None: + axes = plt.axes() + axes.set_aspect("equal", "datalim") + + if polygon.__class__.__name__ == "MultiPolygon": + [plot_single(i) for i in polygon.geoms] + elif hasattr(polygon, "__iter__"): + [plot_single(i) for i in polygon] + elif polygon is not None: + plot_single(polygon) + + if show: + plt.show() + + return axes + + +def resample_boundaries(polygon: Polygon, resolution: float, clip=None): + """ + Return a version of a polygon with boundaries re-sampled + to a specified resolution. + + Parameters + ------------- + polygon : shapely.geometry.Polygon + Source geometry + resolution : float + Desired distance between points on boundary + clip : (2,) int + Upper and lower bounds to clip + number of samples to avoid exploding count + + Returns + ------------ + kwargs : dict + Keyword args for a Polygon constructor `Polygon(**kwargs)` + """ + + def resample_boundary(boundary): + # add a polygon.exterior or polygon.interior to + # the deque after resampling based on our resolution + count = boundary.length / resolution + count = int(np.clip(count, *clip)) + return resample_path(boundary.coords, count=count) + + if clip is None: + clip = [8, 200] + # create a sequence of [(n,2)] points + kwargs = {"shell": resample_boundary(polygon.exterior), "holes": []} + for interior in polygon.interiors: + kwargs["holes"].append(resample_boundary(interior)) + + return kwargs + + +def stack_boundaries(boundaries): + """ + Stack the boundaries of a polygon into a single + (n, 2) list of vertices. + + Parameters + ------------ + boundaries : dict + With keys 'shell', 'holes' + + Returns + ------------ + stacked : (n, 2) float + Stacked vertices + """ + if len(boundaries["holes"]) == 0: + return boundaries["shell"] + return np.vstack((boundaries["shell"], np.vstack(boundaries["holes"]))) + + +def medial_axis(polygon: Polygon, resolution: Number | None = None, clip=None): + """ + Given a shapely polygon, find the approximate medial axis + using a voronoi diagram of evenly spaced points on the + boundary of the polygon. + + Parameters + ---------- + polygon : shapely.geometry.Polygon + The source geometry + resolution : float + Distance between each sample on the polygon boundary + clip : None, or (2,) int + Clip sample count to min of clip[0] and max of clip[1] + + Returns + ---------- + edges : (n, 2) int + Vertex indices representing line segments + on the polygon's medial axis + vertices : (m, 2) float + Vertex positions in space + """ + # a circle will have a single point medial axis + if len(polygon.interiors) == 0: + # what is the approximate scale of the polygon + scale = np.ptp(np.reshape(polygon.bounds, (2, 2)), axis=0).max() + # a (center, radius, error) tuple + fit = fit_circle_check(polygon.exterior.coords, scale=scale) + # is this polygon in fact a circle + if fit is not None: + # return an edge that has the center as the midpoint + epsilon = np.clip(fit["radius"] / 500, 1e-5, np.inf) + vertices = np.array( + [fit["center"] + [0, epsilon], fit["center"] - [0, epsilon]], + dtype=np.float64, + ) + # return a single edge to avoid consumers needing to special case + edges = np.array([[0, 1]], dtype=np.int64) + return edges, vertices + + from scipy.spatial import Voronoi + from shapely import vectorized + + if resolution is None: + resolution = np.ptp(np.reshape(polygon.bounds, (2, 2)), axis=0).max() / 100 + + # get evenly spaced points on the polygons boundaries + samples = resample_boundaries(polygon=polygon, resolution=resolution, clip=clip) + # stack the boundary into a (m,2) float array + samples = stack_boundaries(samples) + # create the voronoi diagram on 2D points + voronoi = Voronoi(samples) + # which voronoi vertices are contained inside the polygon + contains = vectorized.contains(polygon, *voronoi.vertices.T) + # ridge vertices of -1 are outside, make sure they are False + contains = np.append(contains, False) + # make sure ridge vertices is numpy array + ridge = np.asanyarray(voronoi.ridge_vertices, dtype=np.int64) + # only take ridges where every vertex is contained + edges = ridge[contains[ridge].all(axis=1)] + + # now we need to remove uncontained vertices + contained = np.unique(edges) + mask = np.zeros(len(voronoi.vertices), dtype=np.int64) + mask[contained] = np.arange(len(contained)) + + # mask voronoi vertices + vertices = voronoi.vertices[contained] + # re-index edges + edges_final = mask[edges] + + if tol.strict: + # make sure we didn't screw up indexes + assert np.ptp(vertices[edges_final] - voronoi.vertices[edges]) < 1e-5 + + return edges_final, vertices + + +def identifier(polygon: Polygon) -> NDArray[float64]: + """ + Return a vector containing values representative of + a particular polygon. + + Parameters + --------- + polygon : shapely.geometry.Polygon + Input geometry + + Returns + --------- + identifier : (8,) float + Values which should be unique for this polygon. + """ + result = [ + len(polygon.interiors), + polygon.convex_hull.area, + polygon.convex_hull.length, + polygon.area, + polygon.length, + polygon.exterior.length, + ] + # include the principal second moments of inertia of the polygon + # this is invariant to rotation and translation + _, principal, _, _ = second_moments(polygon, return_centered=True) + result.extend(principal) + + return np.array(result, dtype=np.float64) + + +def random_polygon(segments=8, radius=1.0, seed: Seed = None): + """ + Generate a random polygon with a maximum number of sides and approximate radius. + + Parameters + --------- + segments : int + The maximum number of sides the random polygon will have + radius : float + The approximate radius of the polygon desired + seed : None or int + Seed for deterministic results, otherwise OS entropy. + + Returns + --------- + polygon : shapely.geometry.Polygon + Geometry object with random exterior and no interiors. + """ + random = random_generator(seed) + angles = np.sort(np.cumsum(random.random(segments) * np.pi * 2) % (np.pi * 2)) + radii = random.random(segments) * radius + + points = np.column_stack((np.cos(angles), np.sin(angles))) * radii.reshape((-1, 1)) + points = np.vstack((points, points[0])) + polygon = Polygon(points).buffer(0.0) + if hasattr(polygon, "geoms"): + return polygon.geoms[0] + return polygon + + +def polygon_scale(polygon): + """ + For a Polygon object return the diagonal length of the AABB. + + Parameters + ------------ + polygon : shapely.geometry.Polygon + Source geometry + + Returns + ------------ + scale : float + Length of AABB diagonal + """ + extents = np.ptp(np.reshape(polygon.bounds, (2, 2)), axis=0) + scale = (extents**2).sum() ** 0.5 + + return scale + + +def paths_to_polygons(paths, scale=None): + """ + Given a sequence of connected points turn them into + valid shapely Polygon objects. + + Parameters + ----------- + paths : (n,) sequence + Of (m, 2) float closed paths + scale : float + Approximate scale of drawing for precision + + Returns + ----------- + polys : (p,) list + Filled with Polygon or None + + """ + polygons = [None] * len(paths) + for i, path in enumerate(paths): + if len(path) < 4: + # since the first and last vertices are identical in + # a closed loop a 4 vertex path is the minimum for + # non-zero area + continue + try: + polygon = Polygon(path) + if polygon.is_valid: + polygons[i] = polygon + else: + polygons[i] = repair_invalid(polygon, scale) + except ValueError: + # raised if a polygon is unrecoverable + continue + except BaseException: + log.error("unrecoverable polygon", exc_info=True) + polygons = np.array(polygons) + + return polygons + + +def sample(polygon, count, factor=1.5, max_iter=10, seed: Seed = None): + """ + Use rejection sampling to generate random points inside a + polygon. Note that this function may return fewer or no + points, in particular if the polygon as very little area + compared to the area of the axis-aligned bounding box. + + Parameters + ----------- + polygon : shapely.geometry.Polygon + Polygon that will contain points + count : int + Number of points to return + factor : float + How many points to test per loop + max_iter : int + Maximum number of intersection checks is: + > count * factor * max_iter + seed : None or int + Seed for deterministic results, otherwise OS entropy. + + Returns + ----------- + hit : (n, 2) float + Random points inside polygon + where n <= count + """ + # do batch point-in-polygon queries + from shapely import vectorized + + # TODO : this should probably have some option to + # sample from the *oriented* bounding box which would + # make certain cases much, much more efficient. + + # get size of bounding box + bounds = np.reshape(polygon.bounds, (2, 2)) + extents = np.ptp(bounds, axis=0) + + # how many points to check per loop iteration + per_loop = int(count * factor) + + # start with some rejection sampling + random = random_generator(seed) + points = bounds[0] + extents * random.random((per_loop, 2)) + # do the point in polygon test and append resulting hits + mask = vectorized.contains(polygon, *points.T) + hit = [points[mask]] + hit_count = len(hit[0]) + # if our first non-looping check got enough samples exit + if hit_count >= count: + return hit[0][:count] + + # if we have to do iterations loop here slowly + for _ in range(max_iter): + # generate points inside polygons AABB + points = (random.random((per_loop, 2)) * extents) + bounds[0] + # do the point in polygon test and append resulting hits + mask = vectorized.contains(polygon, *points.T) + hit.append(points[mask]) + # keep track of how many points we've collected + hit_count += len(hit[-1]) + # if we have enough points exit the loop + if hit_count > count: + break + + # stack the hits into an (n,2) array and truncate + hit = np.vstack(hit)[:count] + + return hit + + +def repair_invalid(polygon, scale=None, rtol=0.5): + """ + Given a shapely.geometry.Polygon, attempt to return a + valid version of the polygon through buffering tricks. + + Parameters + ----------- + polygon : shapely.geometry.Polygon + Source geometry + rtol : float + How close does a perimeter have to be + scale : float or None + For numerical precision reference + + Returns + ---------- + repaired : shapely.geometry.Polygon + Repaired polygon + + Raises + ---------- + ValueError + If polygon can't be repaired + """ + if hasattr(polygon, "is_valid") and polygon.is_valid: + return polygon + + # basic repair involves buffering the polygon outwards + # this will fix a subset of problems. + basic = polygon.buffer(tol.zero) + # if it returned multiple polygons check the largest + if hasattr(basic, "geoms"): + basic = basic.geoms[np.argmax([i.area for i in basic.geoms])] + + # check perimeter of result against original perimeter + if basic.is_valid and np.isclose(basic.length, polygon.length, rtol=rtol): + return basic + + if scale is None: + distance = 0.002 * np.ptp(np.reshape(polygon.bounds, (2, 2)), axis=0).mean() + else: + distance = 0.002 * scale + + # if there are no interiors, we can work with just the exterior + # ring, which is often more reliable + if len(polygon.interiors) == 0: + # try buffering the exterior of the polygon + # the interior will be offset by -tol.buffer + rings = polygon.exterior.buffer(distance).interiors + if len(rings) == 1: + # reconstruct a single polygon from the interior ring + recon = Polygon(shell=rings[0]).buffer(distance) + # check perimeter of result against original perimeter + if recon.is_valid and np.isclose(recon.length, polygon.length, rtol=rtol): + return recon + + # try de-deuplicating the outside ring + points = np.array(polygon.exterior.coords) + # remove any segments shorter than tol.merge + # this is a little risky as if it was discretized more + # finely than 1-e8 it may remove detail + unique = np.append(True, (np.diff(points, axis=0) ** 2).sum(axis=1) ** 0.5 > 1e-8) + # make a new polygon with result + dedupe = Polygon(shell=points[unique]) + # check result + if dedupe.is_valid and np.isclose(dedupe.length, polygon.length, rtol=rtol): + return dedupe + + # buffer and unbuffer the whole polygon + buffered = polygon.buffer(distance).buffer(-distance) + # if it returned multiple polygons check the largest + if hasattr(buffered, "geoms"): + areas = np.array([b.area for b in buffered.geoms]) + return buffered.geoms[areas.argmax()] + + # check perimeter of result against original perimeter + if buffered.is_valid and np.isclose(buffered.length, polygon.length, rtol=rtol): + log.debug("Recovered invalid polygon through double buffering") + return buffered + + raise ValueError("unable to recover polygon!") + + +def projected( + mesh, + normal, + origin=None, + ignore_sign=True, + rpad=1e-5, + apad=None, + tol_dot=1e-10, + precise: bool = False, + precise_eps: float = 1e-10, +): + """ + Project a mesh onto a plane and then extract the polygon + that outlines the mesh projection on that plane. + + Note that this will ignore back-faces, which is only + relevant if the source mesh isn't watertight. + + Also padding: this generates a result by unioning the + polygons of multiple connected regions, which requires + the polygons be padded by a distance so that a polygon + union produces a single coherent result. This distance + is calculated as: `apad + (rpad * scale)` + + Parameters + ---------- + mesh : trimesh.Trimesh + Source geometry + normal : (3,) float + Normal to extract flat pattern along + origin : None or (3,) float + Origin of plane to project mesh onto + ignore_sign : bool + Allow a projection from the normal vector in + either direction: this provides a substantial speedup + on watertight meshes where the direction is irrelevant + but if you have a triangle soup and want to discard + backfaces you should set this to False. + rpad : float + Proportion to pad polygons by before unioning + and then de-padding result by to avoid zero-width gaps. + apad : float + Absolute padding to pad polygons by before unioning + and then de-padding result by to avoid zero-width gaps. + tol_dot : float + Tolerance for discarding on-edge triangles. + precise : bool + Use the precise projection computation using shapely. + precise_eps : float + Tolerance for precise triangle checks. + + Returns + ---------- + projected : shapely.geometry.Polygon or None + Outline of source mesh + + Raises + --------- + ValueError + If max_regions is exceeded + """ + # make sure normal is a unitized copy + normal = np.array(normal, dtype=np.float64) + normal /= np.linalg.norm(normal) + + # the projection of each face normal onto facet normal + dot_face = np.dot(normal, mesh.face_normals.T) + if ignore_sign: + # for watertight mesh speed up projection by handling side with less faces + # check if face lies on front or back of normal + front = dot_face > tol_dot + back = dot_face < -tol_dot + # divide the mesh into front facing section and back facing parts + # and discard the faces perpendicular to the axis. + # since we are doing a unary_union later we can use the front *or* + # the back so we use which ever one has fewer triangles + # we want the largest nonzero group + count = np.array([front.sum(), back.sum()]) + if count.min() == 0: + # if one of the sides has zero faces we need the other + pick = count.argmax() + else: + # otherwise use the normal direction with the fewest faces + pick = count.argmin() + # use the picked side + side = [front, back][pick] + else: + # if explicitly asked to care about the sign + # only handle the front side of normal + side = dot_face > tol_dot + + # subset the adjacency pairs to ones which have both faces included + # on the side we are currently looking at + adjacency_check = side[mesh.face_adjacency].all(axis=1) + adjacency = mesh.face_adjacency[adjacency_check] + + # transform from the mesh frame in 3D to the XY plane + to_2D = geometry.plane_transform(origin=origin, normal=normal) + # transform mesh vertices to 2D and clip the zero Z + vertices_2D = transform_points(mesh.vertices, to_2D)[:, :2] + + if precise: + # precise mode just unions triangles as one shapely + # polygon per triangle which historically has been very slow + # but it is more defensible intellectually + faces = mesh.faces[side] + # round the 2D vertices with slightly more precision + # than our final dilate-erode cleanup + digits = int(np.abs(np.log10(precise_eps)) + 2) + rounded = np.round(vertices_2D, digits) + # get the triangles as closed 4-vertex polygons + triangles = rounded[np.column_stack((faces, faces[:, :1]))] + # do a check for exactly-degenerate triangles where any two + # vertices are exactly identical which means the triangle has + # zero area + valid = ~(triangles[:, [0, 0, 2]] == triangles[:, [1, 2, 1]]).all(axis=2).any( + axis=1 + ) + # union the valid triangles and then dilate-erode to clean up + # any holes or defects smaller than precise_eps + return ( + ops.unary_union([Polygon(f) for f in triangles[valid]]) + .buffer(precise_eps) + .buffer(-precise_eps) + ) + + # a sequence of face indexes that are connected + face_groups = graph.connected_components(adjacency, nodes=np.nonzero(side)[0]) + + # reshape edges into shape length of faces for indexing + edges = mesh.edges_sorted.reshape((-1, 6)) + + polygons = [] + for faces in face_groups: + # index edges by face then shape back to individual edges + edge = edges[faces].reshape((-1, 2)) + # edges that occur only once are on the boundary + group = grouping.group_rows(edge, require_count=1) + # turn each region into polygons + polygons.extend(edges_to_polygons(edges=edge[group], vertices=vertices_2D)) + + padding = 0.0 + if apad is not None: + # set padding by absolute value + padding += float(apad) + if rpad is not None: + # get the 2D scale as the longest side of the AABB + scale = np.ptp(vertices_2D, axis=0).max() + # apply the scale-relative padding + padding += float(rpad) * scale + + # if there is only one region we don't need to run a union + elif len(polygons) == 1: + return polygons[0] + elif len(polygons) == 0: + return None + + # in my tests this was substantially faster than `shapely.ops.unary_union` + reduced = reduce_cascade(lambda a, b: a.union(b), polygons) + + # can be None + if reduced is not None: + return reduced.buffer(padding).buffer(-padding) + + +def second_moments(polygon: Polygon, return_centered=False): + """ + Calculate the second moments of area of a polygon + from the boundary. + + Parameters + ------------ + polygon : shapely.geometry.Polygon + Closed polygon. + return_centered : bool + Get second moments for a frame with origin at the centroid + and perform a principal axis transformation. + + Returns + ---------- + moments : (3,) float + The values of `[Ixx, Iyy, Ixy]` + principal_moments : (2,) float + Principal second moments of inertia: `[Imax, Imin]` + Only returned if `centered`. + alpha : float + Angle by which the polygon needs to be rotated, so the + principal axis align with the X and Y axis. + Only returned if `centered`. + transform : (3, 3) float + Transformation matrix which rotates the polygon by alpha. + Only returned if `centered`. + """ + + transform = np.eye(3) + if return_centered: + # calculate centroid and move polygon + transform[:2, 2] = -np.array(polygon.centroid.coords) + polygon = transform_polygon(polygon, transform) + + # start with the exterior + coords = np.array(polygon.exterior.coords) + # shorthand the coordinates + x1, y1 = np.vstack((coords[-1], coords[:-1])).T + x2, y2 = coords.T + # do vectorized operations + v = x1 * y2 - x2 * y1 + Ixx = np.sum(v * (y1 * y1 + y1 * y2 + y2 * y2)) / 12.0 + Iyy = np.sum(v * (x1 * x1 + x1 * x2 + x2 * x2)) / 12.0 + Ixy = np.sum(v * (x1 * y2 + 2 * x1 * y1 + 2 * x2 * y2 + x2 * y1)) / 24.0 + + for interior in polygon.interiors: + coords = np.array(interior.coords) + # shorthand the coordinates + x1, y1 = np.vstack((coords[-1], coords[:-1])).T + x2, y2 = coords.T + # do vectorized operations + v = x1 * y2 - x2 * y1 + Ixx -= np.sum(v * (y1 * y1 + y1 * y2 + y2 * y2)) / 12.0 + Iyy -= np.sum(v * (x1 * x1 + x1 * x2 + x2 * x2)) / 12.0 + Ixy -= np.sum(v * (x1 * y2 + 2 * x1 * y1 + 2 * x2 * y2 + x2 * y1)) / 24.0 + + moments = [Ixx, Iyy, Ixy] + + if not return_centered: + return moments + + # get the principal moments + root = np.sqrt(((Iyy - Ixx) / 2.0) ** 2 + Ixy**2) + Imax = (Ixx + Iyy) / 2.0 + root + Imin = (Ixx + Iyy) / 2.0 - root + principal_moments = [Imax, Imin] + + # do the principal axis transform + if np.isclose(Ixy, 0.0, atol=1e-12): + alpha = 0 + elif np.isclose(Ixx, Iyy): + # prevent division by 0 + alpha = 0.25 * np.pi + else: + alpha = 0.5 * np.arctan(2.0 * Ixy / (Ixx - Iyy)) + + # construct transformation matrix + cos_alpha = np.cos(alpha) + sin_alpha = np.sin(alpha) + + transform[0, 0] = cos_alpha + transform[1, 1] = cos_alpha + transform[0, 1] = -sin_alpha + transform[1, 0] = sin_alpha + + return moments, principal_moments, alpha, transform diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/raster.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/raster.py new file mode 100644 index 0000000000000000000000000000000000000000..e09d1fecd8759a1c7fe3ff2fa114353a158ddebd --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/raster.py @@ -0,0 +1,111 @@ +""" +raster.py +------------ + +Turn 2D vector paths into raster images using `pillow` +""" + +import numpy as np + +try: + # keep pillow as a soft dependency + from PIL import Image, ImageChops, ImageDraw +except BaseException as E: + from .. import exceptions + + # re-raise the useful exception when called + _handle = exceptions.ExceptionWrapper(E) + Image = _handle + ImageDraw = _handle + ImageChops = _handle + +from ..typed import ArrayLike, Floating + + +def rasterize( + path: "trimesh.path.Path2D", # noqa + pitch: Floating | ArrayLike | None = None, + origin: ArrayLike | None = None, + resolution=None, + fill=True, + width=None, +): + """ + Rasterize a Path2D object into a boolean image ("mode 1"). + + Parameters + ------------ + path : Path2D + Original geometry + pitch : float or (2,) float + Length(s) in model space of pixel edges + origin : (2,) float + Origin position in model space + resolution : (2,) int + Resolution in pixel space + fill : bool + If True will return closed regions as filled + width : int + If not None will draw outline this wide in pixels + + Returns + ------------ + raster : PIL.Image + Rasterized version of input as `mode 1` image + """ + + if pitch is None: + if resolution is not None: + resolution = np.array(resolution, dtype=np.int64) + # establish pitch from passed resolution + pitch = (path.extents / (resolution + 2)).max() + else: + pitch = path.extents.max() / 2048 + + if origin is None: + origin = path.bounds[0] - (pitch * 2.0) + + # check inputs + pitch = np.asanyarray(pitch, dtype=np.float64) + origin = np.asanyarray(origin, dtype=np.float64) + + # if resolution is None make it larger than path + if resolution is None: + span = np.ptp(np.vstack((path.bounds, origin)), axis=0) + resolution = np.ceil(span / pitch) + 2 + # get resolution as a (2,) int tuple + resolution = np.asanyarray(resolution, dtype=np.int64) + resolution = tuple(resolution.tolist()) + + # convert all discrete paths to pixel space + discrete = [((i - origin) / pitch).round().astype(np.int64) for i in path.discrete] + + # the path indexes that are exteriors + # needed to know what to fill/empty but expensive + roots = path.root + enclosure = path.enclosure_directed + + # draw the exteriors + result = Image.new(mode="1", size=resolution) + draw = ImageDraw.Draw(result) + + # if a width is specified draw the outline + if width is not None: + width = int(width) + for coords in discrete: + draw.line(coords.flatten().tolist(), fill=1, width=width) + # if we are not filling the polygon exit + if not fill: + return result + + # roots are ordered by degree + # so we draw the outermost one first + # and then go in as we progress + for root in roots: + # draw the exterior + draw.polygon(discrete[root].flatten().tolist(), fill=1) + # draw the interior children + for child in enclosure[root]: + draw.polygon(discrete[child].flatten().tolist(), fill=0) + + return result diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/repair.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/repair.py new file mode 100644 index 0000000000000000000000000000000000000000..568c9fb6200aa668b643c0aefe6321b2a681d3f0 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/repair.py @@ -0,0 +1,103 @@ +""" +repair.py +-------------- + +Try to fix problems with closed regions. +""" + +import numpy as np +from scipy.spatial import cKDTree + +from .. import util +from . import segments + + +def fill_gaps(path, distance=0.025): + """ + Find vertices without degree 2 and try to connect to + other vertices. Operations are done in-place. + + Parameters + ------------ + segments : trimesh.path.Path2D + Line segments defined by start and end points + """ + + # find any vertex without degree 2 (connected to two things) + broken = np.array([k for k, d in dict(path.vertex_graph.degree()).items() if d != 2]) + + # if all vertices have correct connectivity, exit + if len(broken) == 0: + return + + # first find broken vertices with distance + tree = cKDTree(path.vertices[broken]) + pairs = tree.query_pairs(r=distance, output_type="ndarray") + + connect_seg = [] + if len(pairs) > 0: + end_points = {tuple(sorted(e.end_points)) for e in path.entities} + pair_set = {tuple(i) for i in np.sort(broken[pairs], axis=1)} + + # we don't want to connect entities to themselves so do a set + # difference + mask = np.array(list(pair_set.difference(end_points))) + + if len(mask) > 0: + connect_seg = path.vertices[mask] + + # a set of values we can query intersections with quickly + broken_set = set(broken) + # query end points set vs path.dangling to avoid having + # to compute every single path and discrete curve + dangle = [ + i + for i, e in enumerate(path.entities) + if len(broken_set.intersection(e.end_points)) > 0 + ] + + segs = [] + # mask for which entities to keep + keep = np.ones(len(path.entities), dtype=bool) + # save a reference to the line class to avoid circular import + line_class = None + + for entity_index in dangle: + # only consider line entities + if path.entities[entity_index].__class__.__name__ != "Line": + continue + + if line_class is None: + line_class = path.entities[entity_index].__class__ + + # get discrete version of entity + points = path.entities[entity_index].discrete(path.vertices) + # turn connected curve into segments + seg_idx = util.stack_lines(np.arange(len(points))) + # append the segments to our collection + segs.append(points[seg_idx]) + # remove this entity and replace with segments + keep[entity_index] = False + + # combine segments with connection segments + all_segs = util.vstack_empty((util.vstack_empty(segs), connect_seg)) + + # go home early + if len(all_segs) == 0: + return + + # split segments at broken vertices so topology can happen + split = segments.split(all_segs, path.vertices[broken]) + # merge duplicate segments + final_seg = segments.unique(split) + + # add line segments in as line entities + entities = [] + for i in range(len(final_seg)): + entities.append(line_class(points=np.arange(2) + (i * 2) + len(path.vertices))) + + # replace entities with new entities + path.entities = np.append(path.entities[keep], entities) + path.vertices = np.vstack((path.vertices, np.vstack(final_seg))) + path._cache.clear() + path.process() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/segments.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/segments.py new file mode 100644 index 0000000000000000000000000000000000000000..01943c2fce830e78de80ce34163956aa87c67364 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/segments.py @@ -0,0 +1,535 @@ +""" +segments.py +-------------- + +Deal with (n, 2, 3) line segments. +""" + +import numpy as np + +from .. import geometry, transformations, util +from ..constants import tol +from ..grouping import group_rows, unique_rows +from ..interval import union +from ..typed import ArrayLike, Integer, NDArray, Number, float64 + + +def segments_to_parameters(segments: ArrayLike): + """ + For 3D line segments defined by two points, turn + them in to an origin defined as the closest point along + the line to the zero origin as well as a direction vector + and start and end parameter. + + Parameters + ------------ + segments : (n, 2, 3) float + Line segments defined by start and end points + + Returns + -------------- + origins : (n, 3) float + Point on line closest to [0, 0, 0] + vectors : (n, 3) float + Unit line directions + parameters : (n, 2) float + Start and end distance pairs for each line + """ + segments = np.asanyarray(segments, dtype=np.float64) + if not util.is_shape(segments, (-1, 2, (2, 3))): + raise ValueError("incorrect segment shape!", segments.shape) + + # make the initial origin one of the end points + endpoint = segments[:, 0] + vectors = segments[:, 1] - endpoint + vectors_norm = util.row_norm(vectors) + vectors /= vectors_norm.reshape((-1, 1)) + + # find the point along the line nearest the origin + offset = util.diagonal_dot(endpoint, vectors) + # points nearest [0, 0, 0] will be our new origin + origins = endpoint + (offset.reshape((-1, 1)) * -vectors) + + # parametric start and end of line segment + parameters = np.column_stack((offset, offset + vectors_norm)) + # make sure signs are consistent + vectors, signs = util.vector_hemisphere(vectors, return_sign=True) + parameters *= signs.reshape((-1, 1)) + + return origins, vectors, parameters + + +def parameters_to_segments( + origins: NDArray[float64], vectors: ArrayLike, parameters: NDArray[float64] +): + """ + Convert a parametric line segment representation to + a two point line segment representation + + Parameters + ------------ + origins : (n, 3) float + Line origin point + vectors : (n, 3) float + Unit line directions + parameters : (n, 2) float + Start and end distance pairs for each line + + Returns + -------------- + segments : (n, 2, 3) float + Line segments defined by start and end points + """ + # don't copy input + origins = np.asanyarray(origins, dtype=np.float64) + vectors = np.asanyarray(vectors, dtype=np.float64) + parameters = np.asanyarray(parameters, dtype=np.float64) + + # turn the segments into a reshapable 2D array + segments = np.hstack( + (origins + vectors * parameters[:, :1], origins + vectors * parameters[:, 1:]) + ) + + return segments.reshape((-1, 2, origins.shape[1])) + + +def colinear_pairs( + segments: ArrayLike, + radius: Number = 0.01, + angle: Number = 0.01, + length: Number | None = None, +) -> NDArray[np.int64]: + """ + Find pairs of segments which are colinear. + + Parameters + ------------- + segments : (n, 2, (2, 3)) float + Two or three dimensional line segments + radius + Maximum radius line origins can differ + and be considered colinear + angle + Maximum angle in radians segments can + differ and still be considered colinear + length + If specified, will additionally require + that pairs have a *vertex* within this distance. + + Returns + ------------ + pairs : (m, 2) int + Indexes of segments which are colinear + """ + from scipy import spatial + + # convert segments to parameterized origins + # which are the closest point on the line to + # the actual zero- origin + origins, vectors, _param = segments_to_parameters(segments) + + # create a kdtree for origins + tree = spatial.cKDTree(origins) + + # find origins closer than specified radius + pairs = tree.query_pairs(r=radius, output_type="ndarray") + + # calculate angles between pairs + angles = geometry.vector_angle(vectors[pairs]) + + # angles can be within tolerance of 180 degrees or 0.0 degrees + angle_ok = np.logical_or( + util.isclose(angles, np.pi, atol=angle), util.isclose(angles, 0.0, atol=angle) + ) + + # apply angle threshold + colinear = pairs[angle_ok] + + # if length is specified check endpoint proximity + if length is not None: + # `segments` index of colinear pairs + a, b = colinear.T + + # we want the minimum distance of any of these pairs: + # a[0] - b[0] + # a[1] - b[0] + # a[0] - b[1] + # a[1] - b[1] + # do it in the most confusing possible vectorized way + min_vertex = np.linalg.norm( + segments[a][:, [0, 1, 0, 1], :] - segments[b][:, [0, 0, 1, 1], :], axis=2 + ).min(axis=1) + + # remove pairs that don't meet the distance metric + colinear = colinear[min_vertex < length] + + return colinear + + +def clean(segments: ArrayLike, digits: Integer = 10) -> NDArray[float64]: + """ + Clean up line segments by unioning the ranges of colinear segments. + + Parameters + ------------ + segments : (n, 2, 2) or (n, 2, 3) + Line segments in space. + digits + How many digits to consider. + + Returns + ----------- + cleaned : (m, 2, 2) or (m, 2, 3) + Where `m <= n` + """ + # convert segments to parameterized origins + # which are the closest point on the line to + # the actual zero- origin + origins, vectors, param = segments_to_parameters(segments) + + # make sure parameters are in min-max order + param.sort(axis=1) + + # find the groups of values with identical origins and vectors + groups = group_rows(np.column_stack((origins, vectors)), digits=digits) + + # get the union of every interval range for colinear segments + unions = [union(param[g][param[g][:, 0].argsort()], sort=False) for g in groups] + # reconstruct indexes for the origins and vectors + indexes = np.concatenate([g[: len(u)] for g, u in zip(groups, unions)]) + + # convert parametric form back into vertex-segment form + return parameters_to_segments( + origins=origins[indexes], vectors=vectors[indexes], parameters=np.vstack(unions) + ) + + +def split(segments: ArrayLike, points: ArrayLike, atol: Number = 1e-5): + """ + Find any points that lie on a segment (not an endpoint) + and then split that segment into two segments. + + We are basically going to find the distance between + point and both segment vertex, and see if it is with + tolerance of the segment length. + + Parameters + -------------- + segments : (n, 2, (2, 3) float + Line segments in space + points : (n, (2, 3)) float + Points in space + atol : float + Absolute tolerance for distances + + Returns + ------------- + split : (n, 2, (3 | 3) float + Line segments in space, split at vertices + """ + + points = np.asanyarray(points, dtype=np.float64) + segments = np.asanyarray(segments, dtype=np.float64) + # reshape to a flat 2D (n, dimension) array + seg_flat = segments.reshape((-1, segments.shape[2])) + + # find the length of every segment + length = ((segments[:, 0, :] - segments[:, 1, :]) ** 2).sum(axis=1) ** 0.5 + + # a mask to remove segments we split at the end + keep = np.ones(len(segments), dtype=bool) + # append new segments to a list + new_seg = [] + + # loop through every point + for p in points: + # note that you could probably get a speedup + # by using scipy.spatial.distance.cdist here + + # find the distance from point to every segment endpoint + pair = ((seg_flat - p) ** 2).sum(axis=1).reshape((-1, 2)) ** 0.5 + # point is on a segment if it is not on a vertex + # and the sum length is equal to the actual segment length + on_seg = np.logical_and( + util.isclose(length, pair.sum(axis=1), atol=atol), + ~util.isclose(pair, 0.0, atol=atol).any(axis=1), + ) + + # if we have any points on the segment split it in twain + if on_seg.any(): + # remove the original segment + keep = np.logical_and(keep, ~on_seg) + # split every segment that this point lies on + for seg in segments[on_seg]: + new_seg.append([p, seg[0]]) + new_seg.append([p, seg[1]]) + + if len(new_seg) > 0: + return np.vstack((segments[keep], new_seg)) + else: + return segments + + +def unique(segments: ArrayLike, digits: Integer = 5): + """ + Find unique non-zero line segments. + + Parameters + ------------ + segments : (n, 2, (2|3)) float + Line segments in space + digits : int + How many digits to consider when merging vertices + + Returns + ----------- + unique : (m, 2, (2|3)) float + Segments with duplicates merged + """ + segments = np.asanyarray(segments, dtype=np.float64) + + # find segments as unique indexes so we can find duplicates + inverse = unique_rows(segments.reshape((-1, segments.shape[2])), digits=digits)[ + 1 + ].reshape((-1, 2)) + # make sure rows are sorted + inverse.sort(axis=1) + # remove segments where both indexes are the same + mask = np.zeros(len(segments), dtype=bool) + # only include the first occurrence of a segment + mask[unique_rows(inverse)[0]] = True + # remove segments that are zero-length + mask[inverse[:, 0] == inverse[:, 1]] = False + # apply the unique mask + unique = segments[mask] + + return unique + + +def extrude(segments: ArrayLike, height: Number, double_sided: bool = False): + """ + Extrude 2D line segments into 3D triangles. + + Parameters + ------------- + segments : (n, 2, 2) float + 2D line segments + height : float + Distance to extrude along Z + double_sided : bool + If true, return 4 triangles per segment + + Returns + ------------- + vertices : (n, 3) float + Vertices in space + faces : (n, 3) int + Indices of vertices forming triangles + """ + segments = np.asanyarray(segments, dtype=np.float64) + if not util.is_shape(segments, (-1, 2, 2)): + raise ValueError("segments shape incorrect") + + # we are creating two vertices triangles for every 2D line segment + # on the segments of the 2D triangulation + vertices = np.column_stack( + ( + np.tile(segments.reshape((-1, 2)), 2).reshape((-1, 2)), + np.tile([0, height, 0, height], len(segments)), + ) + ) + faces = ( + np.tile([3, 1, 2, 2, 1, 0], (len(segments), 1)) + + np.arange(len(segments)).reshape((-1, 1)) * 4 + ).reshape((-1, 3)) + + if double_sided: + # stack so they will render from the back + faces = np.vstack((faces, np.fliplr(faces))) + + return vertices, faces + + +def length(segments: ArrayLike, summed: bool = True) -> np.float64 | NDArray[np.float64]: + """ + Return the lengths of an array of line segments. + + Parameters + ------------- + segments : (n, 2, 2) float + 2D line segments + summed + Return the total length, not the per-segment length. + + Returns + ------------- + length + Either total length or per-segment length. + """ + segments = np.asanyarray(segments, dtype=np.float64) + norms = util.row_norm(segments[:, 0, :] - segments[:, 1, :]) + if summed: + return norms.sum() + return norms + + +def resample( + segments: ArrayLike, + maxlen: Number, + return_index: bool = False, + return_count: bool = False, +): + """ + Resample line segments until no segment + is longer than maxlen. + + Parameters + ------------- + segments : (n, 2, 2|3) float + 2D line segments + maxlen : float + The maximum length of a line segment + return_index : bool + Return the index of the source segment + return_count : bool + Return how many segments each original was split into + + Returns + ------------- + resampled : (m, 2, 2|3) float + Line segments where no segment is longer than maxlen + index : (m,) int + [OPTIONAL] The index of segments resampled came from + count : (n,) int + [OPTIONAL] The count of the original segments + """ + # check arguments + maxlen = float(maxlen) + segments = np.array(segments, dtype=np.float64) + if len(segments.shape) != 3: + raise ValueError(f"{segments.shape} != (n, 2, 2|3)") + + dimension = segments.shape[2] + + # shortcut for endpoints + pt1 = segments[:, 0] + pt2 = segments[:, 1] + # vector between endpoints + vec = pt2 - pt1 + # the integer number of times a segment needs to be split + splits = np.ceil(util.row_norm(vec) / maxlen).astype(np.int64) + + # save resulting segments + result = [] + # save index of original segment + index = [] + + tile = np.tile + # generate the line indexes ahead of time + stacks = util.stack_lines(np.arange(splits.max() + 1)) + + # loop through each count of unique splits needed + for split in np.unique(splits): + # get a mask of which segments need to be split + mask = splits == split + # the vector for each incremental length + increment = vec[mask] / split + # stack the increment vector into the shape needed + v = tile(increment, split + 1).reshape((-1, dimension)) * tile( + np.arange(split + 1), len(increment) + ).reshape((-1, 1)) + # stack the origin points correctly + o = tile(pt1[mask], split + 1).reshape((-1, dimension)) + # now get each segment as an (split, 3) polyline + poly = (o + v).reshape((-1, split + 1, dimension)) + # save the resulting segments + # magical slicing is equivalent to: + # > [p[stack] for p in poly] + result.extend(poly[:, stacks[:split]]) + + if return_index: + # get the original index from the mask + index_original = np.nonzero(mask)[0].reshape((-1, 1)) + # save one entry per split segment + index.append( + (np.ones((len(poly), split), dtype=np.int64) * index_original).ravel() + ) + if tol.strict: + # check to make sure every start and end point + # from the reconstructed result corresponds + for original, recon in zip(segments[mask], poly): + assert np.allclose(original[0], recon[0]) + assert np.allclose(original[-1], recon[-1]) + # make sure stack slicing was OK + assert np.allclose(util.stack_lines(np.arange(split + 1)), stacks[:split]) + + # stack into (n, 2, 3) segments + result = [np.concatenate(result)] + + if tol.strict: + # make sure resampled segments have the same length as input + assert np.isclose(length(segments), length(result[0]), atol=1e-3) + + # stack additional return options + if return_index: + # stack original indexes + index = np.concatenate(index) + if tol.strict: + # index should correspond to result + assert len(index) == len(result[0]) + # every segment should be represented + assert set(index) == set(range(len(segments))) + result.append(index) + + if return_count: + result.append(splits) + + if len(result) == 1: + return result[0] + return result + + +def to_svg( + segments: ArrayLike, + digits: Integer = 4, + matrix: ArrayLike | None = None, + merge: bool = True, +) -> str: + """ + Convert (n, 2, 2) line segments to an SVG path string. + + Parameters + ------------ + segments : (n, 2, 2) float + Line segments to convert + digits : int + Number of digits to include in SVG string + matrix : None or (3, 3) float + Homogeneous 2D transformation to apply before export + + Returns + ----------- + path : str + SVG path string with one line per segment + IE: 'M 0.1 0.2 L 10 12' + """ + segments = np.array(segments, copy=True) + if not util.is_shape(segments, (-1, 2, 2)): + raise ValueError("only for (n, 2, 2) segments!") + + # create the array to export + # apply 2D transformation if passed + if matrix is not None: + segments = transformations.transform_points( + segments.reshape((-1, 2)), matrix=matrix + ).reshape((-1, 2, 2)) + + if merge: + # remove duplicate and zero-length segments + segments = unique(segments, digits=digits) + + # create the format string for a single line segment + base = "M_ _L_ _".replace("_", "{:0." + str(int(digits)) + "f}") + # create one large format string then apply points + result = (base * len(segments)).format(*segments.ravel()) + return result diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/simplify.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/simplify.py new file mode 100644 index 0000000000000000000000000000000000000000..df5859ddbc75816b56767245fa126914c68e81f3 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/simplify.py @@ -0,0 +1,426 @@ +import collections +import copy + +import numpy as np + +from .. import util +from ..constants import log +from ..constants import tol_path as tol +from ..nsphere import fit_nsphere +from . import arc, entities + + +def fit_circle_check(points, scale, prior=None, final=False, verbose=False): + """ + Fit a circle, and reject the fit if: + * the radius is larger than tol.radius_min*scale or tol.radius_max*scale + * any segment spans more than tol.seg_angle + * any segment is longer than tol.seg_frac*scale + * the fit deviates by more than tol.radius_frac*radius + * the segments on the ends deviate from tangent by more than tol.tangent + + Parameters + --------- + points : (n, d) + List of points which represent a path + prior : (center, radius) tuple + Best guess or None if unknown + scale : float + What is the overall scale of the set of points + verbose : bool + Output log.debug messages for the reasons + for fit rejection only suggested for manual debugging + + Returns + ----------- + if fit is acceptable: + (center, radius) tuple + else: + None + """ + # an arc needs at least three points + if len(points) < 3: + return None + # make sure our points are a numpy array + points = np.asanyarray(points, dtype=np.float64) + + # do a least squares fit on the points + C, R, r_deviation = fit_nsphere(points, prior=prior) + + # check to make sure radius is between min and max allowed + if not tol.radius_min < (R / scale) < tol.radius_max: + if verbose: + log.debug("circle fit error: R %f", R / scale) + return None + + # check point radius error + r_error = r_deviation / R + if r_error > tol.radius_frac: + if verbose: + log.debug("circle fit error: fit %s", str(r_error)) + return None + + vectors = np.diff(points, axis=0) + segment = util.row_norm(vectors) + + # approximate angle in radians, segments are linear length + # not arc length but this is close and avoids a cosine + angle = segment / R + if (angle > tol.seg_angle).any(): + if verbose: + log.debug("circle fit error: angle %s", str(angle)) + return None + + if final and (angle > tol.seg_angle_min).sum() < 3: + log.debug("final: angle %s", str(angle)) + return None + + # check segment length as a fraction of drawing scale + scaled = segment / scale + + if (scaled > tol.seg_frac).any(): + if verbose: + log.debug("circle fit error: segment %s", str(scaled)) + return None + + # check to make sure the line segments on the ends are actually + # tangent with the candidate circle fit + mid_pt = points[[0, -2]] + (vectors[[0, -1]] * 0.5) + radial = util.unitize(mid_pt - C) + ends = util.unitize(vectors[[0, -1]]) + tangent = np.abs(np.arccos(util.diagonal_dot(radial, ends))) + tangent = np.abs(tangent - np.pi / 2).max() + + if tangent > tol.tangent: + if verbose: + log.debug("circle fit error: tangent %f", np.degrees(tangent)) + return None + + result = {"center": C, "radius": R} + + return result + + +def is_circle(points, scale, verbose=False): + """ + Given a set of points, quickly determine if they represent + a circle or not. + + Parameters + ------------- + points : (n,2 ) float + Points in space + scale : float + Scale of overall drawing + verbose : bool + Print all fit messages or not + + Returns + ------------- + control: (3,2) float, points in space, OR + None, if not a circle + """ + + # make sure input is a numpy array + points = np.asanyarray(points) + scale = float(scale) + + # can only be a circle if the first and last point are the + # same (AKA is a closed path) + if np.linalg.norm(points[0] - points[-1]) > tol.merge: + return None + + box = np.ptp(points, axis=0) + # the bounding box size of the points + # check aspect ratio as an early exit if the path is not a circle + aspect = np.divide(*box) + if np.abs(aspect - 1.0) > tol.aspect_frac: + return None + + # fit a circle with tolerance checks + CR = fit_circle_check(points, scale=scale) + if CR is None: + return None + + # return the circle as three control points + control = arc.to_threepoint(**CR) + return control + + +def merge_colinear(points, scale): + """ + Given a set of points representing a path in space, + merge points which are colinear. + + Parameters + ---------- + points : (n, dimension) float + Points in space + scale : float + Scale of drawing for precision + + Returns + ---------- + merged : (j, d) float + Points with colinear and duplicate + points merged, where (j < n) + """ + points = np.asanyarray(points, dtype=np.float64) + scale = float(scale) + + if len(points.shape) != 2 or points.shape[1] != 2: + raise ValueError("only for 2D points!") + + # if there's less than 3 points nothing to merge + if len(points) < 3: + return points.copy() + + # the vector from one point to the next + direction = points[1:] - points[:-1] + # the length of the direction vector + direction_norm = util.row_norm(direction) + # make sure points don't have zero length + direction_ok = direction_norm > tol.merge + + # remove duplicate points + points = np.vstack((points[0], points[1:][direction_ok])) + direction = direction[direction_ok] + direction_norm = direction_norm[direction_ok] + + # create a vector between every other point, then turn it perpendicular + # if we have points A B C D + # and direction vectors A-B, B-C, etc + # these will be perpendicular to the vectors A-C, B-D, etc + perp = (points[2:] - points[:-2]).T[::-1].T + perp[:, 0] *= -1 + perp_norm = util.row_norm(perp) + perp_nonzero = perp_norm > tol.merge + perp[perp_nonzero] /= perp_norm[perp_nonzero].reshape((-1, 1)) + + # find the projection of each direction vector + # onto the perpendicular vector + projection = np.abs(util.diagonal_dot(perp, direction[:-1])) + + projection_ratio = np.max( + (projection / direction_norm[1:], projection / direction_norm[:-1]), axis=0 + ) + + mask = np.ones(len(points), dtype=bool) + # since we took diff, we need to offset by one + mask[1:-1][projection_ratio < 1e-4 * scale] = False + + merged = points[mask] + return merged + + +def resample_spline(points, smooth=0.001, count=None, degree=3): + """ + Resample a path in space, smoothing along a b-spline. + + Parameters + ----------- + points : (n, dimension) float + Points in space + smooth : float + Smoothing distance + count : int or None + Number of samples desired in output + degree : int + Degree of spline polynomial + + Returns + --------- + resampled : (count, dimension) float + Points in space + """ + from scipy.interpolate import splev, splprep + + if count is None: + count = len(points) + points = np.asanyarray(points) + closed = np.linalg.norm(points[0] - points[-1]) < tol.merge + + tpl = splprep(points.T, s=smooth, k=degree)[0] + i = np.linspace(0.0, 1.0, count) + resampled = np.column_stack(splev(i, tpl)) + + if closed: + shared = resampled[[0, -1]].mean(axis=0) + resampled[0] = shared + resampled[-1] = shared + + return resampled + + +def points_to_spline_entity(points, smooth=None, count=None): + """ + Create a spline entity from a curve in space + + Parameters + ----------- + points : (n, dimension) float + Points in space + smooth : float + Smoothing distance + count : int or None + Number of samples desired in result + + Returns + --------- + entity : entities.BSpline + Entity object with points indexed at zero + control : (m, dimension) float + New vertices for entity + """ + + from scipy.interpolate import splprep + + if count is None: + count = len(points) + if smooth is None: + smooth = 0.002 + + points = np.asanyarray(points, dtype=np.float64) + closed = np.linalg.norm(points[0] - points[-1]) < tol.merge + + knots, control, _degree = splprep(points.T, s=smooth)[0] + control = np.transpose(control) + index = np.arange(len(control)) + + if closed: + control[0] = control[[0, -1]].mean(axis=0) + control = control[:-1] + index[-1] = index[0] + + entity = entities.BSpline(points=index, knots=knots, closed=closed) + + return entity, control + + +def simplify_basic(drawing, process=False, **kwargs): + """ + Merge colinear segments and fit circles. + + Parameters + ----------- + drawing : Path2D + Source geometry, will not be modified + + Returns + ----------- + simplified : Path2D + Original path but with some closed line-loops converted to circles + """ + + if any(entity.__class__.__name__ != "Line" for entity in drawing.entities): + log.debug("Skipping path containing entities other than `Line`") + return drawing + + # we are going to do a bookkeeping to avoid having + # to recompute literally everything when simplification is ran + cache = copy.deepcopy(drawing._cache) + + # store new values + vertices_new = collections.deque() + entities_new = collections.deque() + + # avoid thrashing cache in loop + scale = drawing.scale + + # loop through (n, 2) closed paths + for discrete in drawing.discrete: + # check to see if the closed entity is a circle + circle = is_circle(discrete, scale=scale) + if circle is not None: + # the points are circular enough for our high standards + # so replace them with a closed Arc entity + entities_new.append( + entities.Arc(points=np.arange(3) + len(vertices_new), closed=True) + ) + vertices_new.extend(circle) + else: + # not a circle, so clean up colinear segments + # then save it as a single line entity + points = merge_colinear(discrete, scale=scale) + # references for new vertices + indexes = np.arange(len(points)) + len(vertices_new) + # discrete curves are always closed + indexes[-1] = indexes[0] + # append new vertices and entity + entities_new.append(entities.Line(points=indexes)) + vertices_new.extend(points) + + # create the new drawing object + simplified = type(drawing)( + entities=entities_new, + vertices=vertices_new, + metadata=copy.deepcopy(drawing.metadata), + process=process, + ) + # we have changed every path to a single closed entity + # either a closed arc, or a closed line + # so all closed paths are now represented by a single entity + cache.cache.update( + { + "paths": np.arange(len(entities_new)).reshape((-1, 1)), + "path_valid": np.ones(len(entities_new), dtype=bool), + "dangling": np.array([]), + } + ) + + # force recompute of exact bounds + if "bounds" in cache.cache: + cache.cache.pop("bounds") + + simplified._cache = cache + # set the cache ID so it won't dump when a value is requested + simplified._cache.id_set() + + return simplified + + +def simplify_spline(path, smooth=None, verbose=False): + """ + Replace discrete curves with b-spline or Arc and + return the result as a new Path2D object. + + Parameters + ------------ + path : trimesh.path.Path2D + Input geometry + smooth : float + Distance to smooth + + Returns + ------------ + simplified : Path2D + Consists of Arc and BSpline entities + """ + + new_vertices = [] + new_entities = [] + scale = path.scale + + for discrete in path.discrete: + circle = is_circle(discrete, scale=scale, verbose=verbose) + if circle is not None: + # the points are circular enough for our high standards + # so replace them with a closed Arc entity + new_entities.append( + entities.Arc(points=np.arange(3) + len(new_vertices), closed=True) + ) + new_vertices.extend(circle) + continue + + # entities for this path + entity, vertices = points_to_spline_entity(discrete, smooth=smooth) + # reindex returned control points + entity.points += len(new_vertices) + # save entity and vertices + new_vertices.extend(vertices) + new_entities.append(entity) + + # create the Path2D object for the result + simplified = type(path)(entities=new_entities, vertices=new_vertices) + + return simplified diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/traversal.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/traversal.py new file mode 100644 index 0000000000000000000000000000000000000000..2579536ebbf9c5c97c40c7e75b802b7f74a77347 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/traversal.py @@ -0,0 +1,494 @@ +import copy +import itertools + +import numpy as np + +from .. import constants, grouping, util +from ..typed import ArrayLike, Integer, NDArray, Number +from .util import is_ccw + +try: + import networkx as nx +except BaseException as E: + # create a dummy module which will raise the ImportError + # or other exception only when someone tries to use networkx + from ..exceptions import ExceptionWrapper + + nx = ExceptionWrapper(E) + + +def vertex_graph(entities): + """ + Given a set of entity objects generate a networkx.Graph + that represents their vertex nodes. + + Parameters + -------------- + entities : list + Objects with 'closed' and 'nodes' attributes + + Returns + ------------- + graph : networkx.Graph + Graph where node indexes represent vertices + closed : (n,) int + Indexes of entities which are 'closed' + """ + graph = nx.Graph() + closed = [] + for index, entity in enumerate(entities): + if entity.closed: + closed.append(index) + else: + # or `entity.end_points` + graph.add_edges_from(entity.nodes, entity_index=index) + return graph, np.array(closed) + + +def vertex_to_entity_path(vertex_path, graph, entities, vertices=None): + """ + Convert a path of vertex indices to a path of entity indices. + + Parameters + ---------- + vertex_path : (n,) int + Ordered list of vertex indices representing a path + graph : nx.Graph + Vertex connectivity + entities : (m,) list + Entity objects + vertices : (p, dimension) float + Vertex points in space + + Returns + ---------- + entity_path : (q,) int + Entity indices which make up vertex_path + """ + + def edge_direction(a, b): + """ + Given two edges, figure out if the first needs to be + reversed to keep the progression forward. + + [1,0] [1,2] -1 1 + [1,0] [2,1] -1 -1 + [0,1] [1,2] 1 1 + [0,1] [2,1] 1 -1 + + Parameters + ------------ + a : (2,) int + b : (2,) int + + Returns + ------------ + a_direction : int + b_direction : int + """ + if a[0] == b[0]: + return -1, 1 + elif a[0] == b[1]: + return -1, -1 + elif a[1] == b[0]: + return 1, 1 + elif a[1] == b[1]: + return 1, -1 + else: + constants.log.debug( + "\n".join( + [ + "edges not connected!", + "vertex path %s", + "entity path: %s", + "entity[a]: %s,", + "entity[b]: %s", + ] + ), + vertex_path, + entity_path, + entities[ea].points, + entities[eb].points, + ) + + return None, None + + if vertices is None or vertices.shape[1] != 2: + ccw_direction = 1 + else: + ccw_check = is_ccw(vertices[np.append(vertex_path, vertex_path[0])]) + ccw_direction = (ccw_check * 2) - 1 + + # make sure vertex path is correct type + vertex_path = np.asanyarray(vertex_path, dtype=np.int64) + # we will be saving entity indexes + entity_path = [] + # loop through pairs of vertices + for i in np.arange(len(vertex_path) + 1): + # get two wrapped vertex positions + vertex_path_pos = np.mod(np.arange(2) + i, len(vertex_path)) + vertex_index = vertex_path[vertex_path_pos] + entity_index = graph.get_edge_data(*vertex_index)["entity_index"] + entity_path.append(entity_index) + # remove duplicate entities and order CCW + entity_path = grouping.unique_ordered(entity_path)[::ccw_direction] + # check to make sure there is more than one entity + if len(entity_path) == 1: + # apply CCW reverse in place if necessary + if ccw_direction < 0: + index = entity_path[0] + entities[index].reverse() + + return entity_path + # traverse the entity path and reverse entities in place to + # align with this path ordering + round_trip = np.append(entity_path, entity_path[0]) + round_trip = itertools.pairwise(round_trip) + for ea, eb in round_trip: + da, db = edge_direction(entities[ea].end_points, entities[eb].end_points) + if da is not None: + entities[ea].reverse(direction=da) + entities[eb].reverse(direction=db) + + entity_path = np.array(entity_path) + + return entity_path + + +def closed_paths(entities, vertices): + """ + Paths are lists of entity indices. + We first generate vertex paths using graph cycle algorithms, + and then convert them to entity paths. + + This will also change the ordering of entity.points in place + so a path may be traversed without having to reverse the entity. + + Parameters + ------------- + entities : (n,) entity objects + Entity objects + vertices : (m, dimension) float + Vertex points in space + + Returns + ------------- + entity_paths : sequence of (n,) int + Ordered traversals of entities + """ + # get a networkx graph of entities + graph, closed = vertex_graph(entities) + # add entities that are closed as single- entity paths + entity_paths = np.reshape(closed, (-1, 1)).tolist() + # look for cycles in the graph, or closed loops + vertex_paths = nx.cycles.cycle_basis(graph) + + # loop through every vertex cycle + for vertex_path in vertex_paths: + # a path has no length if it has fewer than 2 vertices + if len(vertex_path) < 2: + continue + # convert vertex indices to entity indices + entity_paths.append(vertex_to_entity_path(vertex_path, graph, entities, vertices)) + + return entity_paths + + +def discretize_path(entities, vertices, path, scale=1.0): + """ + Turn a list of entity indices into a path of connected points. + + Parameters + ----------- + entities : (j,) entity objects + Objects like 'Line', 'Arc', etc. + vertices: (n, dimension) float + Vertex points in space. + path : (m,) int + Indexes of entities + scale : float + Overall scale of drawing used for + Number tolerances in certain cases + + Returns + ----------- + discrete : (p, dimension) float + Connected points in space that lie on the + path and can be connected with line segments. + """ + # make sure vertices are numpy array + vertices = np.asanyarray(vertices) + path_len = len(path) + if path_len == 0: + raise ValueError("Cannot discretize empty path!") + if path_len == 1: + # case where we only have one entity + discrete = np.asanyarray(entities[path[0]].discrete(vertices, scale=scale)) + else: + # run through path appending each entity + discrete = [] + for i, entity_id in enumerate(path): + # the current (n, dimension) discrete curve of an entity + current = entities[entity_id].discrete(vertices, scale=scale) + # check if we are on the final entity + if i >= (path_len - 1): + # if we are on the last entity include the last point + discrete.append(current) + else: + # slice off the last point so we don't get duplicate + # points from the end of one entity and the start of another + discrete.append(current[:-1]) + # stack all curves to one nice (n, dimension) curve + discrete = np.vstack(discrete) + # make sure 2D curves are are counterclockwise + if vertices.shape[1] == 2 and not is_ccw(discrete): + # reversing will make array non c- contiguous + discrete = np.ascontiguousarray(discrete[::-1]) + + return discrete + + +class PathSample: + def __init__(self, points: ArrayLike): + # make sure input array is numpy + self._points = np.array(points) + # find the direction of each segment + self._vectors = np.diff(self._points, axis=0) + # find the length of each segment + self._norms = util.row_norm(self._vectors) + # unit vectors for each segment + nonzero = self._norms > constants.tol_path.zero + self._unit_vec = self._vectors.copy() + self._unit_vec[nonzero] /= self._norms[nonzero].reshape((-1, 1)) + # total distance in the path + self.length = self._norms.sum() + # cumulative sum of section length + # note that this is sorted + self._cum_norm = np.cumsum(self._norms) + + def sample( + self, distances: ArrayLike, include_original: bool = False + ) -> NDArray[np.float64]: + """ + Return points at the distances along the path requested. + + Parameters + ---------- + distances + Distances along the path to sample at. + include_original + Include the original vertices even if they are not + specified in `distance`. Useful as this will return + a result with identical area and length, however + indexes of `distance` will not correspond with result. + + Returns + -------- + samples : (n, dimension) + Samples requested. + `n==len(distances)` if not `include_original` + """ + # return the indices in cum_norm that each sample would + # need to be inserted at to maintain the sorted property + positions = np.searchsorted(self._cum_norm, distances) + positions = np.clip(positions, 0, len(self._unit_vec) - 1) + offsets = np.append(0, self._cum_norm)[positions] + # the distance past the reference vertex we need to travel + projection = distances - offsets + # find out which direction we need to project + direction = self._unit_vec[positions] + # find out which vertex we're offset from + origin = self._points[positions] + + # just the parametric equation for a line + resampled = origin + (direction * projection.reshape((-1, 1))) + + if include_original: + # find the original positions that were not inserted + # note that this checks *exact float equal* + uninserted = ~np.isin(np.append(self._cum_norm, 0.0), projection) + + if uninserted.any(): + # find the index of the uninserted original points in the new sampling + index = np.searchsorted(positions, np.nonzero(uninserted)[0]) + # insert the original points at the index + resampled = np.insert(resampled, index, self._points[uninserted], axis=0) + + return resampled + + def truncate(self, distance: Number) -> NDArray[np.float64]: + """ + Return a truncated version of the path. + Only one vertex (at the endpoint) will be added. + + Parameters + ---------- + distance + Distance along the path to truncate at. + + Returns + ---------- + path + Path clipped to `distance` requested. + """ + position = np.searchsorted(self._cum_norm, distance) + offset = distance - self._cum_norm[position - 1] + + if offset < constants.tol_path.merge: + truncated = self._points[: position + 1] + else: + vector = util.unitize( + np.diff(self._points[np.arange(2) + position], axis=0).reshape(-1) + ) + vector *= offset + endpoint = self._points[position] + vector + truncated = np.vstack((self._points[: position + 1], endpoint)) + assert ( + util.row_norm(np.diff(truncated, axis=0)).sum() - distance + ) < constants.tol_path.merge + + return truncated + + +def resample_path( + points: ArrayLike, + count: Integer | None = None, + step: Number | None = None, + step_round: bool = True, + include_original: bool = False, +) -> NDArray[np.float64]: + """ + Given a path along (n,d) points, resample them such that the + distance traversed along the path is constant in between each + of the resampled points. Note that this can produce clipping at + corners, as the original vertices are NOT guaranteed to be in the + new, resampled path. + + ONLY ONE of count or step can be specified + Result can be uniformly distributed (np.linspace) by specifying count + Result can have a specific distance (np.arange) by specifying step + + + Parameters + ---------- + points: (n, d) float + Points in space + count : int, + Number of points to sample evenly (aka np.linspace) + step : float + Distance each step should take along the path (aka np.arange) + step_round + Alter `step` to the nearest integer division of overall length. + include_original + Include the exact original points in the output. + + Returns + ---------- + resampled : (j,d) float + Points on the path + """ + points = np.array(points, dtype=np.float64) + # generate samples along the perimeter from kwarg count or step + if (count is not None) and (step is not None): + raise ValueError("Only step OR count can be specified") + if (count is None) and (step is None): + raise ValueError("Either step or count must be specified") + + sampler = PathSample(points) + if step is not None and step_round: + if step >= sampler.length: + return points[[0, -1]] + + count = int(np.ceil(sampler.length / step)) + + if count is not None: + samples = np.linspace(0, sampler.length, count) + elif step is not None: + samples = np.arange(0, sampler.length, step) + + resampled = sampler.sample(samples, include_original=include_original) + + if constants.tol.strict: + check = util.row_norm(points[[0, -1]] - resampled[[0, -1]]) + assert check[0] < constants.tol_path.merge + if count is not None: + assert check[1] < constants.tol_path.merge + + return resampled + + +def split(path): + """ + Split a Path2D into multiple Path2D objects where each + one has exactly one root curve. + + Parameters + -------------- + path : trimesh.path.Path2D + Input geometry + + Returns + ------------- + split : list of trimesh.path.Path2D + Original geometry as separate paths + """ + # avoid a circular import by referencing class of path + Path2D = type(path) + + # save the results of the split to an array + split = [] + + # get objects from cache to avoid a bajillion + # cache checks inside the tight loop + paths = path.paths + discrete = path.discrete + polygons_closed = path.polygons_closed + enclosure_directed = path.enclosure_directed + + for root_index, root in enumerate(path.root): + # get a list of the root curve's children + connected = list(enclosure_directed[root].keys()) + # add the root node to the list + connected.append(root) + + # store new paths and entities + new_paths = [] + new_entities = [] + + for index in connected: + nodes = paths[index] + # add a path which is just sequential indexes + new_paths.append(np.arange(len(nodes)) + len(new_entities)) + # save the entity indexes + new_entities.extend(nodes) + + # store the root index from the original drawing + metadata = copy.deepcopy(path.metadata) + metadata["split_2D"] = root_index + # we made the root path the last index of connected + new_root = np.array([len(new_paths) - 1]) + + # prevents the copying from nuking our cache + with path._cache: + # create the Path2D + split.append( + Path2D( + entities=copy.deepcopy(path.entities[new_entities]), + vertices=copy.deepcopy(path.vertices), + metadata=metadata, + ) + ) + + # add back expensive things to the cache + split[-1]._cache.update( + { + "paths": new_paths, + "polygons_closed": polygons_closed[connected], + "discrete": [discrete[c] for c in connected], + "root": new_root, + } + ) + # set the cache ID + split[-1]._cache.id_set() + + return np.array(split) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/util.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/util.py new file mode 100644 index 0000000000000000000000000000000000000000..196f81c0a72de9c36093abee0666bafe5cf77601 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/util.py @@ -0,0 +1,59 @@ +import numpy as np + +from ..util import is_ccw # NOQA + + +def concatenate(paths, **kwargs): + """ + Concatenate multiple paths into a single path. + + Parameters + ------------- + paths : (n,) Path + Path objects to concatenate + kwargs + Passed through to the path constructor + + Returns + ------------- + concat : Path, Path2D, or Path3D + Concatenated result + """ + # if only one path object just return copy + if len(paths) == 1: + return paths[0].copy() + + # upgrade to 3D if we have mixed 2D and 3D paths + dimensions = {i.vertices.shape[1] for i in paths} + if len(dimensions) > 1: + paths = [i.to_3D() if hasattr(i, "to_3D") else i for i in paths] + + # length of vertex arrays + vert_len = np.array([len(i.vertices) for i in paths]) + # how much to offset each paths vertex indices by + offsets = np.append(0.0, np.cumsum(vert_len))[:-1].astype(np.int64) + + # resulting entities + entities = [] + # resulting vertices + vertices = [] + # resulting metadata + metadata = {} + for path, offset in zip(paths, offsets): + # update metadata + metadata.update(path.metadata) + # copy vertices, we will stack later + vertices.append(path.vertices.copy()) + # copy entity then reindex points + for entity in path.entities: + # cleanly copy the entity into a new object + copied = entity.copy() + # offset the indexes + copied.points += offset + entities.append(copied) + # generate the single new concatenated path + # use input types so we don't have circular imports + concat = type(path)( + metadata=metadata, entities=entities, vertices=np.vstack(vertices), **kwargs + ) + return concat diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/permutate.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/permutate.py new file mode 100644 index 0000000000000000000000000000000000000000..c201c3c1764a57181a4338e3da7c7adf95c40e6e --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/permutate.py @@ -0,0 +1,162 @@ +""" +permutate.py +------------- + +Randomly deform meshes in different ways. +""" + +import numpy as np + +from . import transformations, util +from . import triangles as triangles_module +from .typed import Number, Seed + + +def transform(mesh, translation_scale: Number = 1000.0, seed: Seed = None): + """ + Return a permutated variant of a mesh by randomly reordering faces + and rotatating + translating a mesh by a random matrix. + + Parameters + ---------- + mesh : trimesh.Trimesh + Mesh, will not be altered by this function + seed : None or int + Seed for deterministic results, otherwise OS entropy. + + Returns + ---------- + permutated : trimesh.Trimesh + Mesh with same faces as input mesh but reordered + and rigidly transformed in space. + """ + # thread one generator through so the rotation and the reordering + # below aren't each handed an identically re-seeded stream + random = util.random_generator(seed) + matrix = transformations.random_rotation_matrix( + translate=translation_scale, seed=random + ) + + # randomly re-order triangles + triangles = random.permutation(mesh.triangles).reshape((-1, 3)) + # apply rigid transform + triangles = transformations.transform_points(triangles, matrix) + + # extract the class from the input object + mesh_type = util.type_named(mesh, "Trimesh") + # generate a new mesh from the permutated data + permutated = mesh_type(**triangles_module.to_kwargs(triangles.reshape((-1, 3, 3)))) + + return permutated + + +def noise(mesh, magnitude=None, seed: Seed = None): + """ + Add gaussian noise to every vertex of a mesh, making + no effort to maintain topology or sanity. + + Parameters + ---------- + mesh : trimesh.Trimesh + Input geometry, will not be altered + magnitude : float + What is the maximum distance per axis we can displace a vertex. + If None, value defaults to (mesh.scale / 100.0) + seed : None or int + Seed for deterministic results, otherwise OS entropy. + + Returns + ---------- + permutated : trimesh.Trimesh + Input mesh with noise applied + """ + if magnitude is None: + magnitude = mesh.scale / 100.0 + + random = util.random_generator(seed) + offset = (random.random(mesh.vertices.shape) - 0.5) * magnitude + vertices_noise = mesh.vertices.copy() + offset + + # make sure we've re- ordered faces randomly + triangles = random.permutation(vertices_noise[mesh.faces]) + + mesh_type = util.type_named(mesh, "Trimesh") + permutated = mesh_type(**triangles_module.to_kwargs(triangles)) + + return permutated + + +def tessellation(mesh, seed: Seed = None): + """ + Subdivide each face of a mesh into three faces with the new vertex + randomly placed inside the old face. + + This produces a mesh with exactly the same surface area and volume + but with different tessellation. + + Parameters + ------------ + mesh : trimesh.Trimesh + Input geometry + seed : None or int + Seed for deterministic results, otherwise OS entropy. + + Returns + ---------- + permutated : trimesh.Trimesh + Mesh with remeshed facets + """ + random = util.random_generator(seed) + + # create random barycentric coordinates for each face + # pad all coordinates by a small amount to bias new vertex towards center + barycentric = random.random(mesh.faces.shape) + 0.05 + barycentric /= barycentric.sum(axis=1).reshape((-1, 1)) + + # create one new vertex somewhere in a face + vertex_face = (barycentric.reshape((-1, 3, 1)) * mesh.triangles).sum(axis=1) + vertex_face_id = np.arange(len(vertex_face)) + len(mesh.vertices) + + # new vertices are the old vertices stacked on the vertices in the faces + vertices = np.vstack((mesh.vertices, vertex_face)) + # there are three new faces per old face, and we maintain correct winding + faces = np.vstack( + ( + np.column_stack((mesh.faces[:, [0, 1]], vertex_face_id)), + np.column_stack((mesh.faces[:, [1, 2]], vertex_face_id)), + np.column_stack((mesh.faces[:, [2, 0]], vertex_face_id)), + ) + ) + # make sure the order of the faces is permutated + faces = random.permutation(faces) + + mesh_type = util.type_named(mesh, "Trimesh") + permutated = mesh_type(vertices=vertices, faces=faces) + return permutated + + +class Permutator: + def __init__(self, mesh): + """ + A convenience object to get permutated versions of a mesh. + """ + self._mesh = mesh + + def transform(self, translation_scale=1000, seed: Seed = None): + return transform(self._mesh, translation_scale=translation_scale, seed=seed) + + def noise(self, magnitude=None, seed: Seed = None): + return noise(self._mesh, magnitude, seed=seed) + + def tessellation(self, seed: Seed = None): + return tessellation(self._mesh, seed=seed) + + +try: + # copy the function docstrings to the helper object + Permutator.noise.__doc__ = noise.__doc__ + Permutator.transform.__doc__ = transform.__doc__ + Permutator.tessellation.__doc__ = tessellation.__doc__ +except AttributeError: + # no docstrings in Python2 + pass diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/points.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/points.py new file mode 100644 index 0000000000000000000000000000000000000000..af01109342d5081069a3abbe8611dc8212ecf444 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/points.py @@ -0,0 +1,790 @@ +""" +points.py +------------- + +Functions dealing with (n, d) points. +""" + +import copy +from hashlib import sha256 + +import numpy as np +from numpy import float64 + +from . import caching, grouping, transformations, util +from .constants import tol +from .geometry import plane_transform +from .inertia import points_inertia +from .parent import Geometry3D +from .typed import ArrayLike, NDArray, NDArray2D +from .visual.color import VertexColor + + +def point_plane_distance(points, plane_normal, plane_origin=None): + """ + The minimum perpendicular distance of a point to a plane. + + Parameters + ----------- + points : (n, 3) float + Points in space + plane_normal : (3,) float + Unit normal vector + plane_origin : (3,) float + Plane origin in space + + Returns + ------------ + distances : (n,) float + Distance from point to plane + """ + points = np.asanyarray(points, dtype=float64) + if plane_origin is None: + w = points + else: + w = points - plane_origin + distances = np.dot(plane_normal, w.T) / np.linalg.norm(plane_normal) + return distances + + +def major_axis(points): + """ + Returns an approximate vector representing the major + axis of the passed points. + + Parameters + ------------- + points : (n, dimension) float + Points in space + + Returns + ------------- + axis : (dimension,) float + Vector along approximate major axis + """ + _U, S, V = np.linalg.svd(points) + axis = util.unitize(np.dot(S, V)) + return axis + + +def plane_fit(points): + """ + Fit a plane to points using SVD. + + Parameters + --------- + points : (n, 3) float or (p, n, 3,) float + 3D points in space + Second option allows to simultaneously compute + p centroids and normals + + Returns + --------- + C : (3,) float or (p, 3,) float + Point on the plane + N : (3,) float or (p, 3,) float + Unit normal vector of plane + """ + # make sure input is numpy array + points = np.asanyarray(points, dtype=float64) + assert points.ndim == 2 or points.ndim == 3 + # with only one point set, np.dot is faster + if points.ndim == 2: + # make the plane origin the mean of the points + C = points.mean(axis=0) + # points offset by the plane origin + x = points - C[None, :] + # create a (3, 3) matrix + M = np.dot(x.T, x) + else: + # make the plane origin the mean of the points + C = points.mean(axis=1) + # points offset by the plane origin + x = points - C[:, None, :] + # create a (p, 3, 3) matrix + M = x.swapaxes(1, 2) @ x + # run SVD + N = np.linalg.svd(M)[0][..., -1] + # return the centroid(s) and normal(s) + return C, N + + +def radial_sort(points, origin, normal, start=None): + """ + Sorts a set of points radially (by angle) around an + axis specified by origin and normal vector. + + Parameters + -------------- + points : (n, 3) float + Points in space + origin : (3,) float + Origin to sort around + normal : (3,) float + Vector to sort around + start : (3,) float + Vector to specify start position in counter-clockwise + order viewing in direction of normal, MUST not be + parallel with normal + + Returns + -------------- + ordered : (n, 3) float + Same as input points but reordered + """ + + # create two axis perpendicular to each other and + # the normal and project the points onto them + if start is None: + axis0 = [normal[0], normal[2], -normal[1]] + axis1 = np.cross(normal, axis0) + else: + normal, start = util.unitize([normal, start]) + if np.abs(1 - np.abs(np.dot(normal, start))) < tol.zero: + raise ValueError("start must not parallel with normal") + axis0 = np.cross(start, normal) + axis1 = np.cross(axis0, normal) + vectors = points - origin + # calculate the angles of the points on the axis + angles = np.arctan2(np.dot(vectors, axis0), np.dot(vectors, axis1)) + # return the points sorted by angle + return points[angles.argsort()[::-1]] + + +def project_to_plane( + points, + plane_normal, + plane_origin, + transform=None, + return_transform=False, + return_planar=True, +): + """ + Project (n, 3) points onto a plane. + + Parameters + ----------- + points : (n, 3) float + Points in space. + plane_normal : (3,) float + Unit normal vector of plane + plane_origin : (3,) + Origin point of plane + transform : None or (4, 4) float + Homogeneous transform, if specified, normal+origin are overridden + return_transform : bool + Returns the (4, 4) matrix used or not + return_planar : bool + Return (n, 2) points rather than (n, 3) points + """ + + if np.all(np.abs(plane_normal) < tol.zero): + raise NameError("Normal must be nonzero!") + + if transform is None: + transform = plane_transform(plane_origin, plane_normal) + + transformed = transformations.transform_points(points, transform) + transformed = transformed[:, 0 : (3 - int(return_planar))] + + if return_transform: + polygon_to_3D = np.linalg.inv(transform) + return transformed, polygon_to_3D + return transformed + + +def remove_close(points, radius): + """ + Given an (n, m) array of points return a subset of + points where no point is closer than radius. + + Parameters + ------------ + points : (n, dimension) float + Points in space + radius : float + Minimum radius between result points + + Returns + ------------ + culled : (m, dimension) float + Points in space + mask : (n,) bool + Which points from the original points were returned + """ + from scipy.spatial import cKDTree + + tree = cKDTree(points) + # get the index of every pair of points closer than our radius + pairs = tree.query_pairs(radius, output_type="ndarray") + + # how often each vertex index appears in a pair + # this is essentially a cheaply computed "vertex degree" + # in the graph that we could construct for connected points + count = np.bincount(pairs.ravel(), minlength=len(points)) + + # for every pair we know we have to remove one of them + # which of the two options we pick can have a large impact + # on how much over-culling we end up doing + column = count[pairs].argmax(axis=1) + + # take the value in each row with the highest degree + # there is probably better numpy slicing you could do here + highest = pairs.ravel()[column + 2 * np.arange(len(column))] + + # mask the vertices by index + mask = np.ones(len(points), dtype=bool) + mask[highest] = False + + if tol.strict: + # verify we actually did what we said we'd do + test = cKDTree(points[mask]) + assert len(test.query_pairs(radius)) == 0 + + return points[mask], mask + + +def k_means(points, k, **kwargs): + """ + Find k centroids that attempt to minimize the k- means problem: + https://en.wikipedia.org/wiki/Metric_k-center + + Parameters + ---------- + points: (n, d) float + Points in space + k : int + Number of centroids to compute + **kwargs : dict + Passed directly to scipy.cluster.vq.kmeans + + Returns + ---------- + centroids : (k, d) float + Points in some space + labels: (n) int + Indexes for which points belong to which centroid + """ + from scipy.cluster.vq import kmeans + from scipy.spatial import cKDTree + + points = np.asanyarray(points, dtype=float64) + points_std = points.std(axis=0) + points_std[points_std < tol.zero] = 1 + whitened = points / points_std + centroids_whitened, _distortion = kmeans(whitened, k, **kwargs) + centroids = centroids_whitened * points_std + + # find which centroid each point is closest to + tree = cKDTree(centroids) + labels = tree.query(points, k=1)[1] + + return centroids, labels + + +def tsp(points, start=0): + """ + Find an ordering of points where each is visited and + the next point is the closest in euclidean distance, + and if there are multiple points with equal distance + go to an arbitrary one. + + Assumes every point is visitable from every other point, + i.e. the travelling salesman problem on a fully connected + graph. It is not a MINIMUM traversal; rather it is a + "not totally goofy traversal, quickly." On random points + this traversal is often ~20x shorter than random ordering, + and executes on 1000 points in around 29ms on a 2014 i7. + + Parameters + --------------- + points : (n, dimension) float + ND points in space + start : int + The index of points we should start at + + Returns + --------------- + traversal : (n,) int + Ordered traversal visiting every point + distances : (n - 1,) float + The euclidean distance between points in traversal + """ + # points should be float + points = np.asanyarray(points, dtype=float64) + + if len(points.shape) != 2: + raise ValueError("points must be (n, dimension)!") + + # start should be an index + start = int(start) + + # a mask of unvisited points by index + unvisited = np.ones(len(points), dtype=bool) + unvisited[start] = False + + # traversal of points by index + traversal = np.zeros(len(points), dtype=np.int64) - 1 + traversal[0] = start + # list of distances + distances = np.zeros(len(points) - 1, dtype=float64) + # a mask of indexes in order + index_mask = np.arange(len(points), dtype=np.int64) + + # in the loop we want to call distances.sum(axis=1) + # a lot and it's actually kind of slow for "reasons" + # dot products with ones is equivalent and ~2x faster + sum_ones = np.ones(points.shape[1]) + + # loop through all points + for i in range(len(points) - 1): + # which point are we currently on + current = points[traversal[i]] + + # do NlogN distance query + # use dot instead of .sum(axis=1) or np.linalg.norm + # as it is faster, also don't square root here + dist = np.dot((points[unvisited] - current) ** 2, sum_ones) + + # minimum distance index + min_index = dist.argmin() + # successor is closest unvisited point + successor = index_mask[unvisited][min_index] + # update the mask + unvisited[successor] = False + # store the index to the traversal + traversal[i + 1] = successor + # store the distance + distances[i] = dist[min_index] + + # we were comparing distance^2 so take square root + distances **= 0.5 + + return traversal, distances + + +def plot_points(points, show=True): + """ + Plot an (n, 3) list of points using matplotlib + + Parameters + ------------- + points : (n, 3) float + Points in space + show : bool + If False, will not show until plt.show() is called + """ + # TODO : should this just use SceneViewer? + import matplotlib.pyplot as plt # noqa + from mpl_toolkits.mplot3d import Axes3D # noqa + + points = np.asanyarray(points, dtype=float64) + + if len(points.shape) != 2: + raise ValueError("Points must be (n, 2|3)!") + + if points.shape[1] == 3: + fig = plt.figure() + ax = fig.add_subplot(111, projection="3d") + ax.scatter(*points.T) + elif points.shape[1] == 2: + plt.scatter(*points.T) + else: + raise ValueError(f"points not 2D/3D: {points.shape}") + + if show: + plt.show() + + +class PointCloud(Geometry3D): + """ + Hold 3D points in an object which can be visualized + in a scene. + """ + + def __init__(self, vertices, colors=None, metadata=None, **kwargs): + """ + Load an array of points into a PointCloud object. + + Parameters + ------------- + vertices : (n, 3) float + Points in space + colors : (n, 4) uint8 or None + RGBA colors for each point + metadata : dict or None + Metadata about points + """ + self._data = caching.DataStore() + self._cache = caching.Cache(self._data.__hash__) + self.metadata = {} + if metadata is not None: + self.metadata.update(metadata) + + # load vertices + self.vertices = vertices + + if "vertex_colors" in kwargs and colors is None: + colors = kwargs["vertex_colors"] + + # save visual data to vertex color object + self.visual = VertexColor(colors=colors, obj=self) + + def __setitem__(self, *args, **kwargs): + return self.vertices.__setitem__(*args, **kwargs) + + def __getitem__(self, *args, **kwargs): + return self.vertices.__getitem__(*args, **kwargs) + + @property + def shape(self): + """ + Get the shape of the pointcloud + + Returns + ---------- + shape : (2,) int + Shape of vertex array + """ + return self.vertices.shape + + @property + def is_empty(self): + """ + Are there any vertices defined or not. + + Returns + ---------- + empty : bool + True if no vertices defined + """ + return len(self.vertices) == 0 + + def copy(self): + """ + Safely get a copy of the current point cloud. + + Copied objects will have emptied caches to avoid memory + issues and so may be slow on initial operations until + caches are regenerated. + + Current object will *not* have its cache cleared. + + Returns + --------- + copied : trimesh.PointCloud + Copy of current point cloud + """ + copied = PointCloud(vertices=None) + + # copy vertex and face data + copied._data.data = copy.deepcopy(self._data.data) + + # copy visual data + copied.visual = copy.deepcopy(self.visual) + + # get metadata + copied.metadata = copy.deepcopy(self.metadata) + + # make sure cache is set from here + copied._cache.clear() + + return copied + + def hash(self): + """ + Get a hash of the current vertices. + + Returns + ---------- + hash : str + Hash of self.vertices + """ + return self._data.__hash__() + + @property + def identifier(self) -> NDArray[float64]: + """ + Return a simple array representing this PointCloud + that can be used to identify identical arrays. + + Returns + ---------- + identifier : (9,) + A flat array of data representing the cloud. + """ + return self.moment_inertia.ravel() + + @property + def identifier_hash(self) -> str: + """ + A hash of the PointCloud's identifier that can be used + to detect duplicates. + """ + return sha256( + (self.identifier * 1e5).round().astype(np.int64).tobytes() + ).hexdigest() + + def merge_vertices(self): + """ + Merge vertices closer than tol.merge (default: 1e-8) + """ + # run unique rows + unique, inverse = grouping.unique_rows(self.vertices) + + # apply unique mask to vertices + self.vertices = self.vertices[unique] + + # apply unique mask to colors + if self.colors is not None and len(self.colors) == len(inverse): + self.colors = self.colors[unique] + + def apply_transform(self, transform): + """ + Apply a homogeneous transformation to the PointCloud + object in- place. + + Parameters + -------------- + transform : (4, 4) float + Homogeneous transformation to apply to PointCloud + """ + self.vertices = transformations.transform_points(self.vertices, matrix=transform) + return self + + @property + def bounds(self): + """ + The axis aligned bounds of the PointCloud + + Returns + ------------ + bounds : (2, 3) float + Minimum, Maximum verteex + """ + return np.array([self.vertices.min(axis=0), self.vertices.max(axis=0)]) + + @property + def extents(self): + """ + The size of the axis aligned bounds + + Returns + ------------ + extents : (3,) float + Edge length of axis aligned bounding box + """ + return np.ptp(self.bounds, axis=0) + + @property + def centroid(self): + """ + The mean vertex position + + Returns + ------------ + centroid : (3,) float + Mean vertex position + """ + return self.vertices.mean(axis=0) + + @caching.cache_decorator + def moment_inertia(self) -> NDArray[float64]: + return points_inertia(points=self.vertices, weights=self.weights) + + @property + def weights(self) -> NDArray[float64]: + """ + If each point has a specific weight assigned to it. + + Returns + ----------- + weights : (n,) + A per-vertex weight. + """ + current = self._data.get("weights") + if current is None: + ones = np.ones(len(self.vertices), dtype=np.float64) + self._data["weights"] = ones + return ones + + return current + + @weights.setter + def weights(self, values: ArrayLike): + """ + Assign a weight to each point for later computation. + + Parameters + ----------- + values : (n,) + Weights for each vertex. + """ + values = np.asanyarray(values, dtype=np.float64) + if values.shape != (self.shape[0],): + raise ValueError("Weights must match vertices!") + self._data["weights"] = values + + @property + def vertices(self): + """ + Vertices of the PointCloud + + Returns + ------------ + vertices : (n, 3) float + Points in the PointCloud + """ + return self._data.get("vertices", np.zeros(shape=(0, 3), dtype=float64)) + + @vertices.setter + def vertices(self, values): + """ + Assign vertex values to the point cloud. + + Parameters + -------------- + values : (n, 3) float + Points in space + """ + if values is None or len(values) == 0: + return self._data.data.pop("vertices", None) + self._data["vertices"] = np.asanyarray(values, order="C", dtype=float64) + + @property + def colors(self): + """ + Stored per- point color + + Returns + ---------- + colors : (len(self.vertices), 4) np.uint8 + Per- point RGBA color + """ + return self.visual.vertex_colors + + @colors.setter + def colors(self, data): + self.visual.vertex_colors = data + + @caching.cache_decorator + def kdtree(self): + """ + Return a scipy.spatial.cKDTree of the vertices of the mesh. + Not cached as this lead to observed memory issues and segfaults. + + Returns + --------- + tree : scipy.spatial.cKDTree + Contains mesh.vertices + """ + + from scipy.spatial import cKDTree + + tree = cKDTree(self.vertices.view(np.ndarray)) + return tree + + @caching.cache_decorator + def convex_hull(self): + """ + A convex hull of every point. + + Returns + ------------- + convex_hull : trimesh.Trimesh + A watertight mesh of the hull of the points + """ + from . import convex + + return convex.convex_hull(self.vertices) + + def scene(self): + """ + A scene containing just the PointCloud + + Returns + ---------- + scene : trimesh.Scene + Scene object containing this PointCloud + """ + from .scene.scene import Scene + + return Scene(self) + + def show(self, **kwargs): + """ + Open a viewer window displaying the current PointCloud + """ + self.scene().show(**kwargs) + + def export(self, file_obj=None, file_type=None, **kwargs): + """ + Export the current pointcloud to a file object. + If file_obj is a filename, file will be written there. + Supported formats are xyz + Parameters + ------------ + file_obj: open writeable file object + str, file name where to save the pointcloud + None, if you would like this function to return the export blob + file_type: str + Which file type to export as. + If file name is passed this is not required + """ + from .exchange.export import export_mesh + + return export_mesh(self, file_obj=file_obj, file_type=file_type, **kwargs) + + def query(self, input_points, **kwargs): + """ + Find the the closest points and associated attributes from this PointCloud. + Parameters + ------------ + input_points : (n, 3) float + Input query points + kwargs : dict + Arguments for proximity.query_from_points + result : proximity.NearestQueryResult + Result of the query. + """ + from .proximity import query_from_points + + return query_from_points(self.vertices, input_points, self.kdtree, **kwargs) + + def __add__(self, other): + if len(other.colors) == len(self.colors) == 0: + colors = None + else: + # preserve colors + # if one point cloud has no color property use black + other_colors = ( + [[0, 0, 0, 255]] * len(other.vertices) + if len(other.colors) == 0 + else other.colors + ) + self_colors = ( + [[0, 0, 0, 255]] * len(self.vertices) + if len(self.colors) == 0 + else self.colors + ) + colors = np.vstack((self_colors, other_colors)) + return PointCloud( + vertices=np.vstack((self.vertices, other.vertices)), colors=colors + ) + + def estimate_normals(self, cluster_size=30) -> NDArray2D[np.float64]: + """ + Estimate normals of PointCloud from nearest neighbor points + + Parameters + ------------ + cluster_size : float + Number of nearest neighbors for each point to compute normals from + """ + _, indices = self.kdtree.query(self.vertices, k=cluster_size) + points = self.vertices[indices] + centroids = np.mean(points, axis=1, keepdims=True) + C = points - centroids + covariances = np.matmul(C.transpose(0, 2, 1), C) / (cluster_size - 1) + _, v = np.linalg.eigh(covariances) + return v[:, :, 0] diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/poses.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/poses.py new file mode 100644 index 0000000000000000000000000000000000000000..030550458637557032d4af358670374ac01ab38d --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/poses.py @@ -0,0 +1,327 @@ +""" +poses.py +----------- + +Find stable orientations of meshes. +""" + +import numpy as np + +from .triangles import points_to_barycentric +from .typed import Seed +from .util import diagonal_dot, random_generator + +try: + import networkx as nx +except BaseException as E: + # create a dummy module which will raise the ImportError + # or other exception only when someone tries to use networkx + from .exceptions import ExceptionWrapper + + nx = ExceptionWrapper(E) + + +def compute_stable_poses( + mesh, center_mass=None, sigma=0.0, n_samples=1, threshold=0.0, seed: Seed = None +): + """ + Computes stable orientations of a mesh and their quasi-static probabilities. + + This method samples the location of the center of mass from a multivariate + gaussian with the mean at the center of mass, and a covariance + equal to and identity matrix times sigma, over n_samples. + + For each sample, it computes the stable resting poses of the mesh on a + a planar workspace and evaluates the probabilities of landing in + each pose if the object is dropped onto the table randomly. + + This method returns the 4x4 homogeneous transform matrices that place + the shape against the planar surface with the z-axis pointing upwards + and a list of the probabilities for each pose. + + The transforms and probabilities that are returned are sorted, with the + most probable pose first. + + Parameters + ---------- + mesh : trimesh.Trimesh + The target mesh + com : (3,) float + Rhe object center of mass. If None, this method + assumes uniform density and watertightness and + computes a center of mass explicitly + sigma : float + Rhe covariance for the multivariate gaussian used + to sample center of mass locations + n_samples : int + The number of samples of the center of mass location + threshold : float + The probability value at which to threshold + returned stable poses + + seed : None or int + Seed for deterministic results, otherwise OS entropy. + + Returns + ------- + transforms : (n, 4, 4) float + The homogeneous matrices that transform the + object to rest in a stable pose, with the + new z-axis pointing upwards from the table + and the object just touching the table. + probs : (n,) float + Probability in (0, 1) for each pose + """ + + # save convex hull mesh to avoid a cache check + cvh = mesh.convex_hull + + if center_mass is None: + center_mass = mesh.center_mass + + # Sample center of mass, rejecting points outside of conv hull + random = random_generator(seed) + sample_coms = [] + while len(sample_coms) < n_samples: + remaining = n_samples - len(sample_coms) + coms = random.multivariate_normal(center_mass, sigma * np.eye(3), remaining) + for c in coms: + dots = diagonal_dot(c - cvh.triangles_center, cvh.face_normals) + if np.all(dots < 0): + sample_coms.append(c) + + norms_to_probs = {} # Map from normal to probabilities + + # For each sample, compute the stable poses + for sample_com in sample_coms: + # Create toppling digraph + dg = _create_topple_graph(cvh, sample_com) + + # Propagate probabilities to sink nodes with a breadth-first traversal + nodes = [n for n in dg.nodes() if dg.in_degree(n) == 0] + n_iters = 0 + while len(nodes) > 0 and n_iters <= len(mesh.faces): + new_nodes = [] + for node in nodes: + if dg.out_degree(node) == 0: + continue + successor = next(iter(dg.successors(node))) + dg.nodes[successor]["prob"] += dg.nodes[node]["prob"] + dg.nodes[node]["prob"] = 0.0 + new_nodes.append(successor) + nodes = new_nodes + n_iters += 1 + + # Collect stable poses + for node in dg.nodes(): + if dg.nodes[node]["prob"] > 0.0: + normal = cvh.face_normals[node] + prob = dg.nodes[node]["prob"] + key = tuple(np.around(normal, decimals=3)) + if key in norms_to_probs: + norms_to_probs[key]["prob"] += 1.0 / n_samples * prob + else: + norms_to_probs[key] = { + "prob": 1.0 / n_samples * prob, + "normal": normal, + } + + transforms = [] + probs = [] + + # Filter stable poses + for key in norms_to_probs: + prob = norms_to_probs[key]["prob"] + if prob > threshold: + tf = np.eye(4) + + # Compute a rotation matrix for this stable pose + z = -1.0 * norms_to_probs[key]["normal"] + x = np.array([-z[1], z[0], 0]) + if np.linalg.norm(x) == 0.0: + x = np.array([1, 0, 0]) + else: + x = x / np.linalg.norm(x) + y = np.cross(z, x) + y = y / np.linalg.norm(y) + tf[:3, :3] = np.array([x, y, z]) + + # Compute the necessary translation for this stable pose + m = cvh.copy() + m.apply_transform(tf) + z = -m.bounds[0][2] + tf[:3, 3] = np.array([0, 0, z]) + + transforms.append(tf) + probs.append(prob) + + # Sort the results + transforms = np.array(transforms) + probs = np.array(probs) + inds = np.argsort(-probs) + + return transforms[inds], probs[inds] + + +def _orient3dfast(plane, pd): + """ + Performs a fast 3D orientation test. + + Parameters + ---------- + plane: (3,3) float, three points in space that define a plane + pd: (3,) float, a single point + + Returns + ------- + result: float, if greater than zero then pd is above the plane through + the given three points, if less than zero then pd is below + the given plane, and if equal to zero then pd is on the + given plane. + """ + pa, pb, pc = plane + adx = pa[0] - pd[0] + bdx = pb[0] - pd[0] + cdx = pc[0] - pd[0] + ady = pa[1] - pd[1] + bdy = pb[1] - pd[1] + cdy = pc[1] - pd[1] + adz = pa[2] - pd[2] + bdz = pb[2] - pd[2] + cdz = pc[2] - pd[2] + + return ( + adx * (bdy * cdz - bdz * cdy) + + bdx * (cdy * adz - cdz * ady) + + cdx * (ady * bdz - adz * bdy) + ) + + +def _compute_static_prob(tri, com): + """ + For an object with the given center of mass, compute + the probability that the given tri would be the first to hit the + ground if the object were dropped with a pose chosen uniformly at random. + + Parameters + ---------- + tri: (3,3) float, the vertices of a triangle + cm: (3,) float, the center of mass of the object + + Returns + ------- + prob: float, the probability in [0,1] for the given triangle + """ + sv = [(v - com) / np.linalg.norm(v - com) for v in tri] + + # Use L'Huilier's Formula to compute spherical area + a = np.arccos(min(1, max(-1, np.dot(sv[0], sv[1])))) + b = np.arccos(min(1, max(-1, np.dot(sv[1], sv[2])))) + c = np.arccos(min(1, max(-1, np.dot(sv[2], sv[0])))) + s = (a + b + c) / 2.0 + + # Prevents weirdness with arctan + try: + return ( + 1.0 + / np.pi + * np.arctan( + np.sqrt( + np.tan(s / 2) + * np.tan((s - a) / 2) + * np.tan((s - b) / 2) + * np.tan((s - c) / 2) + ) + ) + ) + except BaseException: + s = s + 1e-8 + return ( + 1.0 + / np.pi + * np.arctan( + np.sqrt( + np.tan(s / 2) + * np.tan((s - a) / 2) + * np.tan((s - b) / 2) + * np.tan((s - c) / 2) + ) + ) + ) + + +def _create_topple_graph(cvh_mesh, com): + """ + Constructs a toppling digraph for the given convex hull mesh and + center of mass. + + Each node n_i in the digraph corresponds to a face f_i of the mesh and is + labelled with the probability that the mesh will land on f_i if dropped + randomly. Not all faces are stable, and node n_i has a directed edge to + node n_j if the object will quasi-statically topple from f_i to f_j if it + lands on f_i initially. + + This computation is described in detail in + http://goldberg.berkeley.edu/pubs/eps.pdf. + + Parameters + ---------- + cvh_mesh : trimesh.Trimesh + Rhe convex hull of the target shape + com : (3,) float + The 3D location of the target shape's center of mass + + Returns + ------- + graph : networkx.DiGraph + Graph representing static probabilities and toppling + order for the convex hull + """ + adj_graph = nx.Graph() + topple_graph = nx.DiGraph() + + # Create face adjacency graph + face_pairs = cvh_mesh.face_adjacency + edges = cvh_mesh.face_adjacency_edges + + graph_edges = [] + for fp, e in zip(face_pairs, edges): + verts = cvh_mesh.vertices[e] + graph_edges.append([fp[0], fp[1], {"verts": verts}]) + + adj_graph.add_edges_from(graph_edges) + + # Compute static probabilities of landing on each face + for i, tri in enumerate(cvh_mesh.triangles): + prob = _compute_static_prob(tri, com) + topple_graph.add_node(i, prob=prob) + + # Compute COM projections onto planes of each triangle in cvh_mesh + proj_dists = diagonal_dot(cvh_mesh.face_normals, com - cvh_mesh.triangles[:, 0]) + proj_coms = com - proj_dists[:, None] * cvh_mesh.face_normals + barys = points_to_barycentric(cvh_mesh.triangles, proj_coms) + unstable_face_indices = np.where(np.any(barys < 0, axis=1))[0] + + # For each unstable face, compute the face it topples to + for fi in unstable_face_indices: + proj_com = proj_coms[fi] + centroid = cvh_mesh.triangles_center[fi] + norm = cvh_mesh.face_normals[fi] + + for tfi in adj_graph[fi]: + v1, v2 = adj_graph[fi][tfi]["verts"] + if np.dot(np.cross(v1 - centroid, v2 - centroid), norm) < 0: + tmp = v2 + v2 = v1 + v1 = tmp + plane1 = [centroid, v1, v1 + norm] + plane2 = [centroid, v2 + norm, v2] + if ( + _orient3dfast(plane1, proj_com) >= 0 + and _orient3dfast(plane2, proj_com) >= 0 + ): + break + + topple_graph.add_edge(fi, tfi) + + return topple_graph diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/primitives.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/primitives.py new file mode 100644 index 0000000000000000000000000000000000000000..07a18dab225f5088258c213bbb072f6011432a4a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/primitives.py @@ -0,0 +1,1149 @@ +""" +primitives.py +---------------- + +Subclasses of Trimesh objects that are parameterized as primitives. + +Useful because you can move boxes and spheres around +and then use trimesh operations on them at any point. +""" + +import abc + +import numpy as np + +from . import creation, inertia, sample, triangles, util +from . import transformations as tf +from .base import Trimesh +from .caching import cache_decorator +from .constants import log, tol +from .typed import ArrayLike, Integer, Number, Seed + +# immutable identity matrix for checks +_IDENTITY = np.eye(4) +_IDENTITY.flags.writeable = False + + +class Primitive(Trimesh): + """ + Geometric Primitives which are a subclass of Trimesh. + Mesh is generated lazily when vertices or faces are requested. + """ + + # ignore superclass copy directives + __copy__ = None + __deepcopy__ = None + + def __init__(self): + # run the Trimesh constructor with no arguments + super().__init__() + + # remove any data + self._data.clear() + self._validate = False + + # make sure any cached numpy arrays have + # set `array.flags.writable = False` + self._cache.force_immutable = True + + def __repr__(self): + return f"" + + @property + def faces(self): + stored = self._cache["faces"] + if util.is_shape(stored, (-1, 3)): + return stored + self._create_mesh() + return self._cache["faces"] + + @faces.setter + def faces(self, values): + if values is not None: + raise ValueError("primitive faces are immutable: not setting!") + + @property + def vertices(self): + stored = self._cache["vertices"] + if util.is_shape(stored, (-1, 3)): + return stored + + self._create_mesh() + return self._cache["vertices"] + + @vertices.setter + def vertices(self, values): + if values is not None: + raise ValueError("primitive vertices are immutable: not setting!") + + @property + def face_normals(self): + # if the mesh hasn't been created yet do that + # before checking to see if the mesh creation + # already populated the face normals + if "vertices" not in self._cache: + self._create_mesh() + + # we need to avoid the logic in the superclass that + # is specific to the data model prioritizing faces + stored = self._cache["face_normals"] + if util.is_shape(stored, (-1, 3)): + return stored + + # if the creation did not populate normals we have to do it + # just calculate if not stored + unit, valid = triangles.normals(self.triangles) + normals = np.zeros((len(valid), 3)) + normals[valid] = unit + # store and return + self._cache["face_normals"] = normals + return normals + + @face_normals.setter + def face_normals(self, values): + if values is not None: + log.warning("Primitive face normals are immutable!") + + @property + def transform(self): + """ + The transform of the Primitive object. + + Returns + ------------- + transform : (4, 4) float + Homogeneous transformation matrix + """ + return self.primitive.transform + + @abc.abstractmethod + def to_dict(self): + """ + Should be implemented by each primitive. + """ + raise NotImplementedError() + + def copy(self, include_visual=True, **kwargs): + """ + Return a copy of the Primitive object. + + Returns + ------------- + copied : object + Copy of current primitive + """ + # get the constructor arguments + kwargs.update(self.to_dict()) + # remove the type indicator, i.e. `Cylinder` + kwargs.pop("kind") + # create a new object with kwargs + primitive_copy = type(self)(**kwargs) + + if include_visual: + # copy visual information + primitive_copy.visual = self.visual.copy() + + # copy metadata + primitive_copy.metadata = self.metadata.copy() + + for k, v in self._data.data.items(): + if k not in primitive_copy._data: + primitive_copy._data[k] = v + + return primitive_copy + + def to_mesh(self, **kwargs): + """ + Return a copy of the Primitive object as a Trimesh. + + Parameters + ----------- + kwargs : dict + Passed to the Trimesh object constructor. + + Returns + ------------ + mesh : trimesh.Trimesh + Tessellated version of the primitive. + """ + result = Trimesh( + vertices=self.vertices.copy(), + faces=self.faces.copy(), + face_normals=self.face_normals.copy(), + process=kwargs.pop("process", False), + **kwargs, + ) + return result + + def apply_transform(self, matrix): + """ + Apply a transform to the current primitive by + applying a new transform on top of existing + `self.primitive.transform`. If the matrix + contains scaling it will change parameters + like `radius` or `height` automatically. + + Parameters + ------------ + matrix: (4, 4) float + Homogeneous transformation + """ + matrix = np.asanyarray(matrix, order="C", dtype=np.float64) + if matrix.shape != (4, 4): + raise ValueError("matrix must be `(4, 4)`!") + if util.allclose(matrix, _IDENTITY, 1e-8): + # identity matrix is a no-op + return self + + prim = self.primitive + # copy the current transform + current = prim.transform.copy() + # see if matrix has scaling from the matrix + scale = np.linalg.det(matrix[:3, :3]) ** (1.0 / 3.0) + + # the objects we handle re-scaling for + # note that `Extrusion` is NOT supported + kinds = (Box, Cylinder, Capsule, Sphere) + if isinstance(self, kinds) and abs(scale - 1.0) > 1e-8: + # scale the primitive attributes + if hasattr(prim, "height"): + prim.height *= scale + if hasattr(prim, "radius"): + prim.radius *= scale + if hasattr(prim, "extents"): + prim.extents *= scale + # scale the translation of the current matrix + current[:3, 3] *= scale + # apply new matrix, rescale, translate, current + updated = util.multi_dot([matrix, tf.scale_matrix(1.0 / scale), current]) + else: + # without scaling just multiply + updated = np.dot(matrix, current) + + # make sure matrix is a rigid transform + if not tf.is_rigid(updated): + raise ValueError("Couldn't produce rigid transform!") + + # apply the new matrix + self.primitive.transform = updated + + return self + + def _create_mesh(self): + raise ValueError("Primitive doesn't define mesh creation!") + + +class PrimitiveAttributes: + """ + Hold the mutable data which defines a primitive. + """ + + def __init__(self, parent, defaults, kwargs, mutable=True): + """ + Hold the attributes for a Primitive. + + Parameters + ------------ + parent : Primitive + Parent object reference. + defaults : dict + The default values for this primitive type. + kwargs : dict + User-passed values, i.e. {'radius': 10.0} + """ + # store actual data in parent object + self._data = parent._data + # default values define the keys + self._defaults = defaults + # store a reference to the parent ubject + self._parent = parent + # start with a copy of all default objects + self._data.update(defaults) + # store whether this data is mutable after creation + self._mutable = mutable + # assign the keys passed by the user only if + # they are a property of this primitive + for key, default in defaults.items(): + value = kwargs.get(key, None) + if value is not None: + # convert passed data into type of defaults + self._data[key] = util.convert_like(value, default) + # make sure stored values are immutable after setting + if not self._mutable: + self._data.mutable = False + + @property + def __doc__(self): + # this is generated dynamically as the format + # operation can be surprisingly slow and most + # people never call it + import pprint + + doc = ( + "Store the attributes of a {name} object.\n\n" + + "When these values are changed, the mesh geometry will \n" + + "automatically be updated to reflect the new values.\n\n" + + "Available properties and their default values are:\n {defaults}" + + "\n\nExample\n---------------\n" + + "p = trimesh.primitives.{name}()\n" + + "p.primitive.radius = 10\n" + + "\n" + ).format( + name=self._parent.__class__.__name__, + defaults=pprint.pformat(self._defaults, width=-1)[1:-1], + ) + return doc + + def __getattr__(self, key): + if key.startswith("_"): + return super().__getattr__(key) + elif key == "center": + # this whole __getattr__ is a little hacky + return self._data["transform"][:3, 3] + elif key in self._defaults: + return util.convert_like(self._data[key], self._defaults[key]) + raise AttributeError(f"primitive object has no attribute '{key}' ") + + def __setattr__(self, key, value): + if key.startswith("_"): + return super().__setattr__(key, value) + elif key == "center": + value = np.array(value, dtype=np.float64) + transform = np.eye(4) + transform[:3, 3] = value + self._data["transform"] = transform + return + elif key in self._defaults: + if self._mutable: + self._data[key] = util.convert_like(value, self._defaults[key]) + else: + raise ValueError( + "Primitive is configured as immutable! Cannot set attribute!" + ) + else: + keys = list(self._defaults.keys()) + raise ValueError(f"Only default attributes {keys} can be set!") + + def __dir__(self): + result = sorted(dir(type(self)) + list(self._defaults.keys())) + return result + + +class Cylinder(Primitive): + def __init__(self, radius=1.0, height=1.0, transform=None, sections=32, mutable=True): + """ + Create a Cylinder Primitive, a subclass of Trimesh. + + Parameters + ------------- + radius : float + Radius of cylinder + height : float + Height of cylinder + transform : (4, 4) float + Homogeneous transformation matrix + sections : int + Number of facets in circle. + mutable : bool + Are extents and transform mutable after creation. + """ + super().__init__() + + defaults = {"height": 10.0, "radius": 1.0, "transform": np.eye(4), "sections": 32} + self.primitive = PrimitiveAttributes( + self, + defaults=defaults, + kwargs={ + "height": height, + "radius": radius, + "transform": transform, + "sections": sections, + }, + mutable=mutable, + ) + + @cache_decorator + def volume(self): + """ + The analytic volume of the cylinder primitive. + + Returns + --------- + volume : float + Volume of the cylinder + """ + return (np.pi * self.primitive.radius**2) * self.primitive.height + + @cache_decorator + def area(self) -> float: + """ + The analytical area of the cylinder primitive + """ + # circumfrence * height + end-cap-area + radius, height = self.primitive.radius, self.primitive.height + return (np.pi * 2 * radius * height) + (2 * np.pi * radius**2) + + @cache_decorator + def moment_inertia(self): + """ + The analytic inertia tensor of the cylinder primitive. + + Returns + ---------- + tensor: (3, 3) float + 3D inertia tensor + """ + + tensor = inertia.cylinder_inertia( + mass=self.volume, + radius=self.primitive.radius, + height=self.primitive.height, + transform=self.primitive.transform, + ) + return tensor + + @cache_decorator + def direction(self): + """ + The direction of the cylinder's axis. + + Returns + -------- + axis: (3,) float, vector along the cylinder axis + """ + axis = np.dot(self.primitive.transform, [0, 0, 1, 0])[:3] + return axis + + @property + def segment(self): + """ + A line segment which if inflated by cylinder radius + would represent the cylinder primitive. + + Returns + ------------- + segment : (2, 3) float + Points representing a single line segment + """ + # half the height + half = self.primitive.height / 2.0 + # apply the transform to the Z- aligned segment + points = np.dot( + self.primitive.transform, np.transpose([[0, 0, -half, 1], [0, 0, half, 1]]) + ).T[:, :3] + return points + + def to_dict(self): + """ + Get a copy of the current Cylinder primitive as + a JSON-serializable dict that matches the schema + in `trimesh/resources/schema/cylinder.schema.json` + + Returns + ---------- + as_dict : dict + Serializable data for this primitive. + """ + return { + "kind": "cylinder", + "transform": self.primitive.transform.tolist(), + "radius": float(self.primitive.radius), + "height": float(self.primitive.height), + } + + def buffer(self, distance): + """ + Return a cylinder primitive which covers the source + cylinder by distance: radius is inflated by distance + height by twice the distance. + + Parameters + ------------ + distance : float + Distance to inflate cylinder radius and height + + Returns + ------------- + buffered : Cylinder + Cylinder primitive inflated by distance + """ + distance = float(distance) + buffered = Cylinder( + height=self.primitive.height + distance * 2, + radius=self.primitive.radius + distance, + transform=self.primitive.transform.copy(), + ) + return buffered + + def _create_mesh(self): + log.debug("creating mesh for Cylinder primitive") + mesh = creation.cylinder( + radius=self.primitive.radius, + height=self.primitive.height, + sections=self.primitive.sections, + transform=self.primitive.transform, + ) + + self._cache["vertices"] = mesh.vertices + self._cache["faces"] = mesh.faces + self._cache["face_normals"] = mesh.face_normals + + +class Capsule(Primitive): + def __init__( + self, radius=1.0, height=10.0, transform=None, sections=32, mutable=True + ): + """ + Create a Capsule Primitive, a subclass of Trimesh. + + Parameters + ---------- + radius : float + Radius of cylinder + height : float + Height of cylinder + transform : (4, 4) float + Transformation matrix + sections : int + Number of facets in circle + mutable : bool + Are extents and transform mutable after creation. + """ + super().__init__() + + defaults = {"height": 1.0, "radius": 1.0, "transform": np.eye(4), "sections": 32} + self.primitive = PrimitiveAttributes( + self, + defaults=defaults, + kwargs={ + "height": height, + "radius": radius, + "transform": transform, + "sections": sections, + }, + mutable=mutable, + ) + + @property + def transform(self): + return self.primitive.transform + + @cache_decorator + def volume(self) -> float: + """ + The analytic volume of the capsule primitive. + + Returns + --------- + volume : float + Volume of the capsule + """ + radius, height = self.primitive.radius, self.primitive.height + return (np.pi * radius**2) * ((4.0 / 3.0) * radius + height) + + @cache_decorator + def area(self) -> float: + """ + The analytic area of the capsule primitive. + + Returns + --------- + area : float + Area of the capsule + """ + radius, height = self.primitive.radius, self.primitive.height + return (2 * np.pi * radius * height) + (4 * np.pi * radius**2) + + def to_dict(self): + """ + Get a copy of the current Capsule primitive as + a JSON-serializable dict that matches the schema + in `trimesh/resources/schema/capsule.schema.json` + + Returns + ---------- + as_dict : dict + Serializable data for this primitive. + """ + return { + "kind": "capsule", + "transform": self.primitive.transform.tolist(), + "height": float(self.primitive.height), + "radius": float(self.primitive.radius), + } + + @cache_decorator + def direction(self): + """ + The direction of the capsule's axis. + + Returns + -------- + axis : (3,) float + Vector along the cylinder axis + """ + axis = np.dot(self.primitive.transform, [0, 0, 1, 0])[:3] + return axis + + def _create_mesh(self): + log.debug("creating mesh for `Capsule` primitive") + + mesh = creation.capsule( + radius=self.primitive.radius, + height=self.primitive.height, + count=[self.primitive.sections, self.primitive.sections * 2], + transform=self.primitive.transform, + ) + + self._cache["vertices"] = mesh.vertices + self._cache["faces"] = mesh.faces + self._cache["face_normals"] = mesh.face_normals + + +class Sphere(Primitive): + def __init__( + self, + radius: Number = 1.0, + center: ArrayLike | None = None, + transform: ArrayLike | None = None, + subdivisions: Integer = 3, + mutable: bool = True, + ): + """ + Create a Sphere Primitive, a subclass of Trimesh. + + Parameters + ---------- + radius + Radius of sphere + center : None or (3,) float + Center of sphere. + transform : None or (4, 4) float + Full homogeneous transform. Pass `center` OR `transform. + subdivisions + Number of subdivisions for icosphere. + mutable + Are extents and transform mutable after creation. + """ + + super().__init__() + + constructor = {"radius": float(radius), "subdivisions": int(subdivisions)} + # center is a helper method for "transform" + # since a sphere is rotationally symmetric + if center is not None: + if transform is not None: + raise ValueError("only one of `center` and `transform` may be passed!") + translate = np.eye(4) + translate[:3, 3] = center + constructor["transform"] = translate + elif transform is not None: + constructor["transform"] = transform + + # create the attributes object + self.primitive = PrimitiveAttributes( + self, + defaults={"radius": 1.0, "transform": np.eye(4), "subdivisions": 3}, + kwargs=constructor, + mutable=mutable, + ) + + @property + def center(self): + return self.primitive.center + + @center.setter + def center(self, value): + self.primitive.center = value + + def to_dict(self): + """ + Get a copy of the current Sphere primitive as + a JSON-serializable dict that matches the schema + in `trimesh/resources/schema/sphere.schema.json` + + Returns + ---------- + as_dict : dict + Serializable data for this primitive. + """ + return { + "kind": "sphere", + "transform": self.primitive.transform.tolist(), + "radius": float(self.primitive.radius), + } + + @property + def bounds(self): + # no docstring so will inherit Trimesh docstring + # return exact bounds from primitive center and radius (rather than faces) + # self.extents will also use this information + bounds = np.array( + [ + self.primitive.center - self.primitive.radius, + self.primitive.center + self.primitive.radius, + ] + ) + return bounds + + @property + def bounding_box_oriented(self): + # for a sphere the oriented bounding box is the same as the axis aligned + # bounding box, and a sphere is the absolute slowest case for the OBB calculation + # as it is a convex surface with a ton of face normals that all need to + # be checked + return self.bounding_box + + @cache_decorator + def area(self): + """ + Surface area of the current sphere primitive. + + Returns + -------- + area: float, surface area of the sphere Primitive + """ + + area = 4.0 * np.pi * (self.primitive.radius**2) + return area + + @cache_decorator + def volume(self): + """ + Volume of the current sphere primitive. + + Returns + -------- + volume: float, volume of the sphere Primitive + """ + + volume = (4.0 * np.pi * (self.primitive.radius**3)) / 3.0 + return volume + + @cache_decorator + def moment_inertia(self): + """ + The analytic inertia tensor of the sphere primitive. + + Returns + ---------- + tensor: (3, 3) float + 3D inertia tensor. + """ + return inertia.sphere_inertia(mass=self.volume, radius=self.primitive.radius) + + def _create_mesh(self): + log.debug("creating mesh for Sphere primitive") + unit = creation.icosphere( + subdivisions=self.primitive.subdivisions, radius=self.primitive.radius + ) + + # apply the center offset here + self._cache["vertices"] = unit.vertices + self.primitive.center + self._cache["faces"] = unit.faces + self._cache["face_normals"] = unit.face_normals + + +class Box(Primitive): + def __init__(self, extents=None, transform=None, bounds=None, mutable=True): + """ + Create a Box Primitive as a subclass of Trimesh + + Parameters + ---------- + extents : ndarray (3,) float or None + Length of each side of the 3D box. + transform : ndarray (4, 4) float or None + Homogeneous transformation matrix for box center. + bounds : ndarray (2, 3) float or None + Axis aligned bounding box, if passed extents and + transform will be derived from this. + mutable : bool + Are extents and transform mutable after creation. + """ + super().__init__() + defaults = {"transform": np.eye(4), "extents": np.ones(3)} + + if bounds is not None: + # validate the multiple forms of input available here + if extents is not None or transform is not None: + raise ValueError( + "if `bounds` is passed `extents` and `transform` must not be!" + ) + bounds = np.array(bounds, dtype=np.float64) + if bounds.shape != (2, 3): + raise ValueError("`bounds` must be (2, 3) float") + # create extents from AABB + extents = np.ptp(bounds, axis=0) + # translate to the center of the box + # use the min corner (not `bounds[0]`) so the result is + # independent of the order the two corners are passed in + transform = np.eye(4) + transform[:3, 3] = np.min(bounds, axis=0) + extents / 2.0 + + self.primitive = PrimitiveAttributes( + self, + defaults=defaults, + kwargs={"extents": extents, "transform": transform}, + mutable=mutable, + ) + + def to_dict(self): + """ + Get a copy of the current Box primitive as + a JSON-serializable dict that matches the schema + in `trimesh/resources/schema/box.schema.json` + + Returns + ---------- + as_dict : dict + Serializable data for this primitive. + """ + return { + "kind": "box", + "transform": self.primitive.transform.tolist(), + "extents": self.primitive.extents.tolist(), + } + + @property + def transform(self): + return self.primitive.transform + + def sample_volume(self, count, seed: Seed = None): + """ + Return random samples from inside the volume of the box. + + Parameters + ------------- + count : int + Number of samples to return + seed : None or int + Seed for deterministic results, otherwise OS entropy. + + Returns + ---------- + samples : (count, 3) float + Points inside the volume + """ + samples = sample.volume_rectangular( + extents=self.primitive.extents, + count=count, + transform=self.primitive.transform, + seed=seed, + ) + return samples + + def sample_grid(self, count=None, step=None): + """ + Return a 3D grid which is contained by the box. + Samples are either 'step' distance apart, or there are + 'count' samples per box side. + + Parameters + ----------- + count : int or (3,) int + If specified samples are spaced with np.linspace + step : float or (3,) float + If specified samples are spaced with np.arange + + Returns + ----------- + grid : (n, 3) float + Points inside the box + """ + + if count is not None and step is not None: + raise ValueError("only step OR count can be specified!") + + # create pre- transform bounds from extents + bounds = np.array([-self.primitive.extents, self.primitive.extents]) * 0.5 + + if step is not None: + grid = util.grid_arange(bounds, step=step) + elif count is not None: + grid = util.grid_linspace(bounds, count=count) + else: + raise ValueError("either count or step must be specified!") + + transformed = tf.transform_points(grid, matrix=self.primitive.transform) + return transformed + + @property + def is_oriented(self): + """ + Returns whether or not the current box is rotated at all. + """ + if util.is_shape(self.primitive.transform, (4, 4)): + return not np.allclose(self.primitive.transform[0:3, 0:3], np.eye(3)) + else: + return False + + @cache_decorator + def volume(self): + """ + Volume of the box Primitive. + + Returns + -------- + volume : float + Volume of box. + """ + volume = float(np.prod(self.primitive.extents)) + return volume + + def _create_mesh(self): + log.debug("creating mesh for Box primitive") + box = creation.box( + extents=self.primitive.extents, transform=self.primitive.transform + ) + + self._cache.cache.update(box._cache.cache) + self._cache["vertices"] = box.vertices + self._cache["faces"] = box.faces + self._cache["face_normals"] = box.face_normals + + def as_outline(self): + """ + Return a Path3D containing the outline of the box. + + Returns + ----------- + outline : trimesh.path.Path3D + Outline of box primitive + """ + # do the import in function to keep soft dependency + from .path.creation import box_outline + + # return outline with same size as primitive + return box_outline( + extents=self.primitive.extents, transform=self.primitive.transform + ) + + +class Extrusion(Primitive): + def __init__( + self, + polygon=None, + transform: ArrayLike | None = None, + height: Number = 1.0, + mutable: bool = True, + mid_plane: bool = False, + ): + """ + Create an Extrusion primitive, which + is a subclass of Trimesh. + + Parameters + ---------- + polygon : shapely.geometry.Polygon + Polygon to extrude + transform : (4, 4) float + Transform to apply after extrusion + height : float + Height to extrude polygon by + mutable : bool + Are extents and transform mutable after creation. + """ + # do the import here, fail early if Shapely isn't installed + from shapely.geometry import Point + + # run the Trimesh init + super().__init__() + # set default values + defaults = { + "polygon": Point([0, 0]).buffer(1.0), + "transform": np.eye(4), + "height": 1.0, + "mid_plane": False, + } + + self.primitive = PrimitiveAttributes( + self, + defaults=defaults, + kwargs={ + "transform": transform, + "polygon": polygon, + "height": height, + "mid_plane": mid_plane, + }, + mutable=mutable, + ) + + @cache_decorator + def area(self): + """ + The surface area of the primitive extrusion. + + Calculated from polygon and height to avoid mesh creation. + + Returns + ---------- + area: float + Surface area of 3D extrusion + """ + # area of the sides of the extrusion + area = abs(self.primitive.height * self.primitive.polygon.length) + # area of the two caps of the extrusion + area += self.primitive.polygon.area * 2 + return area + + @cache_decorator + def volume(self): + """ + The volume of the Extrusion primitive. + Calculated from polygon and height to avoid mesh creation. + + Returns + ---------- + volume : float + Volume of 3D extrusion + """ + # height may be negative + volume = abs(self.primitive.polygon.area * self.primitive.height) + return volume + + @cache_decorator + def direction(self): + """ + Based on the extrudes transform what is the + vector along which the polygon will be extruded. + + Returns + --------- + direction : (3,) float + Unit direction vector + """ + # only consider rotation and signed height + direction = np.dot( + self.primitive.transform[:3, :3], [0.0, 0.0, np.sign(self.primitive.height)] + ) + return direction + + @property + def origin(self): + """ + Based on the extrude transform what is the + origin of the plane it is extruded from. + + Returns + ----------- + origin : (3,) float + Origin of extrusion plane + """ + return self.primitive.transform[:3, 3] + + @property + def transform(self): + return self.primitive.transform + + @cache_decorator + def bounding_box_oriented(self): + # no docstring for inheritance + # calculate OBB using 2D polygon and known axis + from . import bounds + + # find the 2D bounding box using the polygon + to_origin, box = bounds.oriented_bounds_2D(self.primitive.polygon.exterior.coords) + # 3D extents + extents = np.append(box, abs(self.primitive.height)) + # calculate to_3D transform from 2D obb + rotation_Z = np.linalg.inv(tf.planar_matrix_to_3D(to_origin)) + rotation_Z[2, 3] = self.primitive.height / 2.0 + # combine the 2D OBB transformation with the 2D projection transform + to_3D = np.dot(self.primitive.transform, rotation_Z) + return Box(transform=to_3D, extents=extents, mutable=False) + + def slide(self, distance): + """ + Alter the transform of the current extrusion to slide it + along its extrude_direction vector + + Parameters + ----------- + distance : float + Distance along self.extrude_direction to move + """ + distance = float(distance) + translation = np.eye(4) + translation[2, 3] = distance + new_transform = np.dot(self.primitive.transform.copy(), translation.copy()) + self.primitive.transform = new_transform + + def buffer(self, distance, distance_height=None, **kwargs): + """ + Return a new Extrusion object which is expanded in profile + and in height by a specified distance. + + Parameters + -------------- + distance : float + Distance to buffer polygon + distance_height : float + Distance to buffer above and below extrusion + kwargs : dict + Passed to Extrusion constructor + + Returns + ---------- + buffered : primitives.Extrusion + Extrusion object with new values + """ + distance = float(distance) + # if not specified use same distance for everything + if distance_height is None: + distance_height = distance + + # start with current height + height = self.primitive.height + # if current height is negative offset by negative amount + height += np.sign(height) * 2.0 * distance_height + + # create a new extrusion with a buffered polygon + # use type(self) vs Extrusion to handle subclasses + buffered = type(self)( + transform=self.primitive.transform.copy(), + polygon=self.primitive.polygon.buffer(distance), + height=height, + **kwargs, + ) + + # slide the stock along the axis + buffered.slide(-np.sign(height) * distance_height) + + return buffered + + def to_dict(self): + """ + Get a copy of the current Extrusion primitive as + a JSON-serializable dict that matches the schema + in `trimesh/resources/schema/extrusion.schema.json` + + Returns + ---------- + as_dict : dict + Serializable data for this primitive. + """ + return { + "kind": "extrusion", + "polygon": self.primitive.polygon.wkt, + "transform": self.primitive.transform.tolist(), + "height": float(self.primitive.height), + } + + def _create_mesh(self): + log.debug("creating mesh for Extrusion primitive") + # extrude the polygon along Z + mesh = creation.extrude_polygon( + polygon=self.primitive.polygon, + height=self.primitive.height, + transform=self.primitive.transform, + mid_plane=self.primitive.mid_plane, + ) + + # check volume here in unit tests + if tol.strict and mesh.volume < 0.0: + raise ValueError("matrix inverted mesh!") + + # cache mesh geometry in the primitive + self._cache["vertices"] = mesh.vertices + self._cache["faces"] = mesh.faces diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/proximity.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/proximity.py new file mode 100644 index 0000000000000000000000000000000000000000..1dd5c89424b6d2492a0d4df65128c541f28a2d84 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/proximity.py @@ -0,0 +1,595 @@ +""" +proximity.py +--------------- + +Query mesh- point proximity. +""" + +import numpy as np + +from . import util +from .constants import log_time, tol +from .grouping import group_min +from .triangles import closest_point as _corresponding +from .triangles import points_to_barycentric +from .typed import ArrayLike +from .util import diagonal_dot + +try: + from scipy.spatial import cKDTree +except BaseException as E: + from .exceptions import ExceptionWrapper + + cKDTree = ExceptionWrapper(E) + + +def nearby_faces(mesh, points: ArrayLike): + """ + For each point find nearby faces relatively quickly. + + The closest point on the mesh to the queried point is guaranteed to be + on one of the faces listed. + + Does this by finding the nearest vertex on the mesh to each point, and + then returns all the faces that intersect the axis aligned bounding box + centered at the queried point and extending to the nearest vertex. + + Parameters + ---------- + mesh : trimesh.Trimesh + Mesh to query. + points : (n, 3) float + Points in space + + Returns + ----------- + candidates : (points,) int + Sequence of indexes for mesh.faces + """ + points = np.asanyarray(points, dtype=np.float64) + # empty points lists should get empty candidates + if len(points) == 0: + return [] + + # mishapen points should error + if not util.is_shape(points, (-1, 3)): + raise ValueError("points must be (n,3)!") + + # an r-tree containing the axis aligned bounding box for every triangle + rtree = mesh.triangles_tree + # a kd-tree containing every vertex of the mesh + kdtree = cKDTree(mesh.vertices[mesh.referenced_vertices]) + + # query the distance to the nearest vertex to get AABB of a sphere + distance_vertex = kdtree.query(points)[0].reshape((-1, 1)) + distance_vertex += tol.merge + + # axis aligned bounds + bounds = np.column_stack((points - distance_vertex, points + distance_vertex)) + + try: + # use the batch API added in 1.4.0 and fixed to actually work in 1.4.1 + hit_ids, hit_counts = rtree.intersection_v(bounds[:, :3], bounds[:, 3:]) + return np.array_split(hit_ids, np.cumsum(hit_counts)[:-1]) + except BaseException: + # fall back to a list comprehension + return [list(rtree.intersection(b)) for b in bounds] + + +def closest_point_naive(mesh, points): + """ + Given a mesh and a list of points find the closest point + on any triangle. + + Does this by constructing a very large intermediate array and + comparing every point to every triangle. + + Parameters + ---------- + mesh : Trimesh + Takes mesh to have same interfaces as `closest_point` + points : (m, 3) float + Points in space + + Returns + ---------- + closest : (m, 3) float + Closest point on triangles for each point + distance : (m,) float + Distances between point and triangle + triangle_id : (m,) int + Index of triangle containing closest point + """ + # get triangles from mesh + triangles = mesh.triangles.view(np.ndarray) + # establish that input points are sane + points = np.asanyarray(points, dtype=np.float64) + if not util.is_shape(triangles, (-1, 3, 3)): + raise ValueError("triangles shape incorrect") + if not util.is_shape(points, (-1, 3)): + raise ValueError("points must be (n,3)") + + # create a giant tiled array of each point tiled len(triangles) times + points_tiled = np.tile(points, (1, len(triangles))) + on_triangle = np.array( + [_corresponding(triangles, i.reshape((-1, 3))) for i in points_tiled] + ) + + # distance squared + distance_2 = [((i - q) ** 2).sum(axis=1) for i, q in zip(on_triangle, points)] + + triangle_id = np.array([i.argmin() for i in distance_2]) + + # closest cartesian point + closest = np.array([g[i] for i, g in zip(triangle_id, on_triangle)]) + distance = np.array([g[i] for i, g in zip(triangle_id, distance_2)]) ** 0.5 + + return closest, distance, triangle_id + + +def closest_point(mesh, points): + """ + Given a mesh and a list of points find the closest point + on any triangle. + + Parameters + ---------- + mesh : trimesh.Trimesh + Mesh to query + points : (m, 3) float + Points in space + + Returns + ---------- + closest : (m, 3) float + Closest point on triangles for each point + distance : (m,) float + Distance to mesh. + triangle_id : (m,) int + Index of triangle containing closest point + """ + points = np.asanyarray(points, dtype=np.float64) + if not util.is_shape(points, (-1, 3)): + raise ValueError("points must be (n,3)!") + + # do a tree- based query for faces near each point + candidates = nearby_faces(mesh, points) + # view triangles as an ndarray so we don't have to recompute + # the MD5 during all of the subsequent advanced indexing + triangles = mesh.triangles.view(np.ndarray) + + # create the corresponding list of triangles + # and query points to send to the closest_point function + all_candidates = np.concatenate(candidates) + + num_candidates = list(map(len, candidates)) + tile_idxs = np.repeat(np.arange(len(points)), num_candidates) + query_point = points[tile_idxs, :] + + query_tri = triangles[all_candidates] + + # do the computation for closest point + query_close = _corresponding(query_tri, query_point) + query_group = np.cumsum(num_candidates)[:-1] + + # vectors and distances for + # closest point to query point + query_vector = query_point - query_close + query_distance = util.diagonal_dot(query_vector, query_vector) + + # get best two candidate indices by arg-sorting the per-query_distances + qds = np.array_split(query_distance, query_group) + idxs = np.int32([qd.argsort()[:2] if len(qd) > 1 else [0, 0] for qd in qds]) + idxs[1:] += query_group.reshape(-1, 1) + + # points, distances and triangle ids for best two candidates + two_points = query_close[idxs] + two_dists = query_distance[idxs] + two_candidates = all_candidates[idxs] + + # the first candidate is the best result for unambiguous cases + result_close = query_close[idxs[:, 0]] + result_tid = two_candidates[:, 0] + result_distance = two_dists[:, 0] + + # however: same closest point on two different faces + # find the best one and correct triangle ids if necessary + check_distance = np.ptp(two_dists, axis=1) < tol.merge + check_magnitude = np.all(np.abs(two_dists) > tol.merge, axis=1) + + # mask results where corrections may be apply + c_mask = np.bitwise_and(check_distance, check_magnitude) + + # get two face normals for the candidate points + normals = mesh.face_normals[two_candidates[c_mask]] + # compute normalized surface-point to query-point vectors + vectors = query_vector[idxs[c_mask]] / two_dists[c_mask].reshape(-1, 2, 1) ** 0.5 + # compare enclosed angle for both face normals + dots = (normals * vectors).sum(axis=2) + + # take the idx with the most positive angle + # allows for selecting the correct candidate triangle id + c_idxs = dots.argmax(axis=1) + + # correct triangle ids where necessary + # closest point and distance remain valid + result_tid[c_mask] = two_candidates[c_mask, c_idxs] + result_distance[c_mask] = two_dists[c_mask, c_idxs] + result_close[c_mask] = two_points[c_mask, c_idxs] + + # we were comparing the distance squared so + # now take the square root in one vectorized operation + result_distance **= 0.5 + + return result_close, result_distance, result_tid + + +def signed_distance(mesh, points): + """ + Find the signed distance from a mesh to a list of points. + + * Points OUTSIDE the mesh will have NEGATIVE distance + * Points within tol.merge of the surface will have POSITIVE distance + * Points INSIDE the mesh will have POSITIVE distance + + Parameters + ----------- + mesh : trimesh.Trimesh + Mesh to query. + points : (n, 3) float + Points in space + + Returns + ---------- + signed_distance : (n,) float + Signed distance from point to mesh + """ + # make sure we have a numpy array + points = np.asanyarray(points, dtype=np.float64) + + # find the closest point on the mesh to the queried points + closest, distance, triangle_id = closest_point(mesh, points) + + # we only care about nonzero distances + nonzero = distance > tol.merge + + if not nonzero.any(): + return distance + + # For closest points that project directly in to the triangle, compute sign from + # triangle normal Project each point in to the closest triangle plane + nonzero = np.where(nonzero)[0] + normals = mesh.face_normals[triangle_id] + projection = ( + points[nonzero] + - ( + normals[nonzero].T + * diagonal_dot(points[nonzero] - closest[nonzero], normals[nonzero]) + ).T + ) + + # Determine if the projection lies within the closest triangle + barycentric = points_to_barycentric(mesh.triangles[triangle_id[nonzero]], projection) + ontriangle = ~( + ((barycentric < -tol.merge) | (barycentric > 1 + tol.merge)).any(axis=1) + ) + + # Where projection does lie in the triangle, compare vector to projection to the + # triangle normal to compute sign + sign = np.sign( + diagonal_dot( + normals[nonzero[ontriangle]], + points[nonzero[ontriangle]] - projection[ontriangle], + ) + ) + distance[nonzero[ontriangle]] *= -1.0 * sign + + # For all other triangles, resort to raycasting against the entire mesh + inside = mesh.ray.contains_points(points[nonzero[~ontriangle]]) + sign = (inside.astype(int) * 2) - 1.0 + + # apply sign to previously computed distance + distance[nonzero[~ontriangle]] *= sign + + return distance + + +class NearestQueryResult: + """ + Stores the nearest points and attributes for nearest points queries. + """ + + def __init__(self): + self.nearest = None + self.distances = None + self.normals = None + self.triangle_indices = None + self.barycentric_coordinates = None + self.interpolated_normals = None + self.vertex_indices = None + + def has_normals(self): + return self.normals is not None or self.interpolated_normals is not None + + +class ProximityQuery: + """ + Proximity queries for the current mesh. + """ + + def __init__(self, mesh): + self._mesh = mesh + + @log_time + def on_surface(self, points): + """ + Given list of points, for each point find the closest point + on any triangle of the mesh. + + Parameters + ---------- + points : (m,3) float, points in space + + Returns + ---------- + closest : (m, 3) float + Closest point on triangles for each point + distance : (m,) float + Distance to surface + triangle_id : (m,) int + Index of closest triangle for each point. + """ + return closest_point(mesh=self._mesh, points=points) + + def vertex(self, points): + """ + Given a set of points, return the closest vertex index to each point + + Parameters + ---------- + points : (n, 3) float + Points in space + + Returns + ---------- + distance : (n,) float + Distance from source point to vertex. + vertex_id : (n,) int + Index of mesh.vertices for closest vertex. + """ + tree = self._mesh.kdtree + return tree.query(points) + + def signed_distance(self, points): + """ + Find the signed distance from a mesh to a list of points. + + * Points OUTSIDE the mesh will have NEGATIVE distance + * Points within tol.merge of the surface will have POSITIVE distance + * Points INSIDE the mesh will have POSITIVE distance + + Parameters + ----------- + points : (n, 3) float + Points in space + + Returns + ---------- + signed_distance : (n,) float + Signed distance from point to mesh. + """ + return signed_distance(self._mesh, points) + + +def longest_ray(mesh, points, directions): + """ + Find the lengths of the longest rays which do not intersect the mesh + cast from a list of points in the provided directions. + + Parameters + ----------- + points : (n, 3) float + Points in space. + directions : (n, 3) float + Directions of rays. + + Returns + ---------- + signed_distance : (n,) float + Length of rays. + """ + points = np.asanyarray(points, dtype=np.float64) + if not util.is_shape(points, (-1, 3)): + raise ValueError("points must be (n,3)!") + + directions = np.asanyarray(directions, dtype=np.float64) + if not util.is_shape(directions, (-1, 3)): + raise ValueError("directions must be (n,3)!") + + if len(points) != len(directions): + raise ValueError("number of points must equal number of directions!") + + _faces, rays, locations = mesh.ray.intersects_id( + points, directions, return_locations=True, multiple_hits=True + ) + if len(rays) > 0: + distances = np.linalg.norm(locations - points[rays], axis=1) + else: + distances = np.array([]) + + # Reject intersections at distance less than tol.planar + rays = rays[distances > tol.planar] + distances = distances[distances > tol.planar] + + # Add infinite length for those with no valid intersection + no_intersections = np.setdiff1d(np.arange(len(points)), rays) + rays = np.concatenate((rays, no_intersections)) + distances = np.concatenate((distances, np.repeat(np.inf, len(no_intersections)))) + return group_min(rays, distances) + + +def max_tangent_sphere( + mesh, points, inwards=True, normals=None, threshold=1e-6, max_iter=100 +): + """ + Find the center and radius of the sphere which is tangent to + the mesh at the given point and at least one more point with no + non-tangential intersections with the mesh. + + Masatomo Inui, Nobuyuki Umezu & Ryohei Shimane (2016) + Shrinking sphere: + A parallel algorithm for computing the thickness of 3D objects, + Computer-Aided Design and Applications, 13:2, 199-207, + DOI: 10.1080/16864360.2015.1084186 + + Parameters + ---------- + points : (n, 3) float + Points in space. + inwards : bool + Whether to have the sphere inside or outside the mesh. + normals : (n, 3) float or None + Normals of the mesh at the given points + if is None computed automatically. + + Returns + ---------- + centers : (n,3) float + Centers of spheres + radii : (n,) float + Radii of spheres + """ + points = np.asanyarray(points, dtype=np.float64) + if not util.is_shape(points, (-1, 3)): + raise ValueError("points must be (n,3)!") + + if normals is not None: + normals = np.asanyarray(normals, dtype=np.float64) + if not util.is_shape(normals, (-1, 3)): + raise ValueError("normals must be (n,3)!") + + if len(points) != len(normals): + raise ValueError("number of points must equal number of normals!") + else: + normals = mesh.face_normals[closest_point(mesh, points)[2]] + + if inwards: + normals = -normals + + # Find initial tangent spheres + distances = longest_ray(mesh, points, normals) + radii = distances * 0.5 + not_converged = np.ones(len(points), dtype=bool) # boolean mask + + # If ray is infinite, find the vertex which is furthest from our point + # when projected onto the ray. I.e. find v which maximises + # (v-p).n = v.n - p.n. + # We use a loop rather a vectorised approach to reduce memory cost + # it also seems to run faster. + for i in np.where(np.isinf(distances))[0]: + projections = np.dot(mesh.vertices - points[i], normals[i]) + + # If no points lie outside the tangent plane, then the radius is infinite + # otherwise we have a point outside the tangent plane, take the one with maximal + # projection + if projections.max() < tol.planar: + radii[i] = np.inf + not_converged[i] = False + else: + vertex = mesh.vertices[projections.argmax()] + radii[i] = np.dot(vertex - points[i], vertex - points[i]) / ( + 2 * np.dot(vertex - points[i], normals[i]) + ) + + # Compute centers + centers = points + normals * np.nan_to_num(radii.reshape(-1, 1)) + centers[np.isinf(radii)] = [np.nan, np.nan, np.nan] + + # Our iterative process terminates when the difference in sphere + # radius is less than threshold*D + D = np.linalg.norm(mesh.bounds[1] - mesh.bounds[0]) + convergence_threshold = threshold * D + n_iter = 0 + while not_converged.sum() > 0 and n_iter < max_iter: + n_iter += 1 + n_points, n_dists, _n_faces = mesh.nearest.on_surface(centers[not_converged]) + + # If the distance to the nearest point is the same as the distance + # to the start point then we are done. + done = ( + np.abs( + n_dists + - np.linalg.norm(centers[not_converged] - points[not_converged], axis=1) + ) + < tol.planar + ) + not_converged[np.where(not_converged)[0][done]] = False + + # Otherwise find the radius and center of the sphere tangent to the mesh + # at the point and the nearest point. + diff = n_points[~done] - points[not_converged] + old_radii = radii[not_converged].copy() + radii[not_converged] = diagonal_dot(diff, diff) / ( + 2 * diagonal_dot(diff, normals[not_converged]) + ) + centers[not_converged] = points[not_converged] + normals[not_converged] * radii[ + not_converged + ].reshape(-1, 1) + + # If change in radius is less than threshold we have converged + cvged = old_radii - radii[not_converged] < convergence_threshold + not_converged[np.where(not_converged)[0][cvged]] = False + + return centers, radii + + +def thickness(mesh, points, exterior=False, normals=None, method="max_sphere"): + """ + Find the thickness of the mesh at the given points. + + Parameters + ---------- + points : (n, 3) float + Points in space + exterior : bool + Whether to compute the exterior thickness + (a.k.a. reach) + normals : (n, 3) float + Normals of the mesh at the given points + If is None computed automatically. + method : string + One of 'max_sphere' or 'ray' + + Returns + ---------- + thickness : (n,) float + Thickness at given points. + """ + points = np.asanyarray(points, dtype=np.float64) + if not util.is_shape(points, (-1, 3)): + raise ValueError("points must be (n,3)!") + + if normals is not None: + normals = np.asanyarray(normals, dtype=np.float64) + if not util.is_shape(normals, (-1, 3)): + raise ValueError("normals must be (n,3)!") + + if len(points) != len(normals): + raise ValueError("number of points must equal number of normals!") + else: + normals = mesh.face_normals[closest_point(mesh, points)[2]] + + if method == "max_sphere": + _centers, radius = max_tangent_sphere( + mesh=mesh, points=points, inwards=not exterior, normals=normals + ) + thickness = radius * 2 + return thickness + + elif method == "ray": + if exterior: + return longest_ray(mesh, points, normals) + else: + return longest_ray(mesh, points, -normals) + else: + raise ValueError('Invalid method, use "max_sphere" or "ray"') diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/py.typed b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fa8812a9865f5bea03775823dfdaf8380f227279 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/__init__.py @@ -0,0 +1,15 @@ +from . import ray_triangle + +# optionally load an interface to the embree raytracer +try: + from . import ray_pyembree + + has_embree = True +except BaseException as E: + from .. import exceptions + + ray_pyembree = exceptions.ExceptionWrapper(E) + has_embree = False + +# add to __all__ as per pep8 +__all__ = ["ray_pyembree", "ray_triangle"] diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ab0171198837db4169290c759bcf194d8a16f19 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/__pycache__/ray_pyembree.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/__pycache__/ray_pyembree.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..539b4c5cfd9abee76bc93672e31aefe56cb5cc80 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/__pycache__/ray_pyembree.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/__pycache__/ray_triangle.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/__pycache__/ray_triangle.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..999d7d9bc0f3ca40cbeb197ecd196f455254dfc3 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/__pycache__/ray_triangle.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/__pycache__/ray_util.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/__pycache__/ray_util.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..31b2189771269e5694a6e65818af377a4ddb1d8b Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/__pycache__/ray_util.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/ray_pyembree.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/ray_pyembree.py new file mode 100644 index 0000000000000000000000000000000000000000..48ef28f51d8b693fca92842208df59187323cadb --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/ray_pyembree.py @@ -0,0 +1,343 @@ +""" +Ray queries using the embreex package with the +API wrapped to match our native raytracer. +""" + +import numpy as np + +# `pip install embreex` installs from wheels +from embreex import rtcore_scene +from embreex.mesh_construction import TriangleMesh + +from .. import caching, intersections, util +from ..constants import log_time +from ..typed import ArrayLike, Integer +from .ray_util import contains_points + +# embree operates on float32 values +_embree_dtype = np.float32 + +# scale-aware base ray offset to step past hit triangles above f32 ULP +_ray_offset_factor = 1e-6 +_ray_offset_floor = 1e-8 + + +class RayMeshIntersector: + def __init__(self, geometry, scale_to_box: bool = True): + """ + Do ray- mesh queries. + + Parameters + ------------- + geometry : Trimesh object + Mesh to do ray tests on + scale_to_box : bool + If true, will scale mesh to approximate + unit cube to avoid problems with extreme + large or small meshes. + """ + self.mesh = geometry + self._scale_to_box = scale_to_box + self._cache = caching.Cache(id_function=self.mesh.__hash__) + + @property + def _scale(self): + """ + Scaling factor for precision. + """ + if self._scale_to_box: + # scale vertices to approximately a cube to help with + # numerical issues at very large/small scales + scale = 100.0 / self.mesh.scale + else: + scale = 1.0 + return scale + + @caching.cache_decorator + def _scene(self): + """ + A cached version of the embreex scene. + """ + return _EmbreeWrap( + vertices=self.mesh.vertices, faces=self.mesh.faces, scale=self._scale + ) + + def intersects_location( + self, + ray_origins: ArrayLike, + ray_directions: ArrayLike, + multiple_hits: bool = True, + ): + """ + Return the location of where a ray hits a surface. + + Parameters + ---------- + ray_origins : (n, 3) float + Origins of rays + ray_directions : (n, 3) float + Direction (vector) of rays + + Returns + --------- + locations : (m) sequence of (p, 3) float + Intersection points + index_ray : (m,) int + Indexes of ray + index_tri : (m,) int + Indexes of mesh.faces + """ + (index_tri, index_ray, locations) = self.intersects_id( + ray_origins=ray_origins, + ray_directions=ray_directions, + multiple_hits=multiple_hits, + return_locations=True, + ) + + return locations, index_ray, index_tri + + @log_time + def intersects_id( + self, + ray_origins: ArrayLike, + ray_directions: ArrayLike, + multiple_hits: bool = True, + max_hits: Integer = 100, + return_locations: bool = False, + ): + """ + Find the triangles hit by a list of rays, including + optionally multiple hits along a single ray. + + + Parameters + ---------- + ray_origins : (n, 3) float + Origins of rays + ray_directions : (n, 3) float + Direction (vector) of rays + multiple_hits : bool + If True will return every hit along the ray + If False will only return first hit + max_hits : int + Maximum number of hits per ray + return_locations : bool + Should we return hit locations or not + + Returns + --------- + index_tri : (m,) int + Indexes of mesh.faces + index_ray : (m,) int + Indexes of ray + locations : (m) sequence of (p, 3) float + Intersection points, only returned if return_locations + """ + + # make sure input is _dtype for embree + ray_origins = np.array(ray_origins, dtype=np.float64) + ray_directions = np.array(ray_directions, dtype=np.float64) + if ray_origins.shape != ray_directions.shape: + raise ValueError("Ray origin and direction don't match!") + ray_directions = util.unitize(ray_directions) + + # stack results for multiple hits into a sequence + result_triangle = [np.zeros(0, dtype=np.int64)] + result_ray_idx = [np.zeros(0, dtype=np.int64)] + result_locations = [np.zeros((0, 3), dtype=np.float64)] + + if multiple_hits or return_locations: + # how much to offset ray to transport to the other side of face + base_offset = max(_ray_offset_floor, self.mesh.scale * _ray_offset_factor) + ray_offsets = ray_directions * base_offset + + # grab the planes from triangles + plane_origins = self.mesh.triangles[:, 0, :] + plane_normals = self.mesh.face_normals + + # what each ray hit last iteration; -1 means nothing, used to + # detect a ray stuck on the same face due to precision issues + last_hit = np.full(len(ray_origins), -1, dtype=np.int64) + # absolute indices of rays still being queried; shrinks each + # iteration as rays miss, escape, or get culled + live = np.arange(len(ray_origins)) + + # use a for loop rather than a while to ensure this exits + # if a ray is offset from a triangle and then is reported + # hitting itself this could get stuck on that one triangle + for _depth in range(max_hits): + # if you set output=1 embreex returns distance along the ray + # which is bizarrely slower than our own plane-line calc + # TODO: switch `run(..., output=True)` once embreex>=4.4.0rc1 is stable + query = self._scene.run(ray_origins[live], ray_directions[live]) + hit = query != -1 + if not hit.any(): + break + + # absolute indices and triangle indices for rays that hit + hit_rays = live[hit] + hit_tris = query[hit] + + # first-hit-only fast path: no duplicates or locations to track + if not multiple_hits and not return_locations: + result_triangle.append(hit_tris) + result_ray_idx.append(hit_rays) + break + + # rays that hit the same triangle as last iteration are stuck + dupe = last_hit[hit_rays] == hit_tris + # store the last hit so we can track duplicates + last_hit[hit_rays] = hit_tris + # subset to separate duplicates and non-duplicates + ok_rays = hit_rays[~dupe] + ok_tris = hit_tris[~dupe] + dupe_rays = hit_rays[dupe] + + # compute where clean hits actually land on their triangle; + # planes_lines silently drops near-parallel rays, so `valid` + # shortens new_origins — we must trim ok_rays / ok_tris to match + new_origins, valid = intersections.planes_lines( + plane_origins=plane_origins[ok_tris], + plane_normals=plane_normals[ok_tris], + line_origins=ray_origins[ok_rays], + line_directions=ray_directions[ok_rays], + ) + ok_rays, ok_tris = ok_rays[valid], ok_tris[valid] + + result_locations.append(new_origins) + result_triangle.append(ok_tris) + result_ray_idx.append(ok_rays) + + if not multiple_hits: + break + + # clean hits step onto the new face with a fresh base offset + ray_origins[ok_rays] = new_origins + ray_offsets[ok_rays] + ray_offsets[ok_rays] = ray_directions[ok_rays] * base_offset + # stuck rays double their offset and step further to try to clear + ray_offsets[dupe_rays] *= 2.0 + ray_origins[dupe_rays] += ray_offsets[dupe_rays] + + # carry forward only rays we successfully advanced; + # dropped rays (misses, near-parallel planes) die here + live = np.concatenate([ok_rays, dupe_rays]) + + index_tri = np.concatenate(result_triangle) + index_ray = np.concatenate(result_ray_idx) + if return_locations: + return index_tri, index_ray, np.concatenate(result_locations) + return index_tri, index_ray + + @log_time + def intersects_first(self, ray_origins, ray_directions): + """ + Find the index of the first triangle a ray hits. + + + Parameters + ---------- + ray_origins : (n, 3) float + Origins of rays + ray_directions : (n, 3) float + Direction (vector) of rays + + Returns + ---------- + triangle_index : (n,) int + Index of triangle ray hit, or -1 if not hit + """ + # make sure our arrays are in the `embree` dtype + ray_origins = np.array(ray_origins, dtype=_embree_dtype) + ray_directions = np.array(ray_directions, dtype=_embree_dtype) + if ray_origins.shape != ray_directions.shape: + raise ValueError("Ray origin and direction don't match!") + ray_directions = util.unitize(ray_directions) + + return self._scene.run(ray_origins, ray_directions) + + def intersects_any(self, ray_origins, ray_directions): + """ + Check if a list of rays hits the surface. + + + Parameters + ----------- + ray_origins : (n, 3) float + Origins of rays + ray_directions : (n, 3) float + Direction (vector) of rays + + Returns + ---------- + hit : (n,) bool + Did each ray hit the surface + """ + + first = self.intersects_first( + ray_origins=ray_origins, ray_directions=ray_directions + ) + hit = first != -1 + return hit + + def contains_points(self, points): + """ + Check if a mesh contains a list of points, using ray tests. + + If the point is on the surface of the mesh, behavior is undefined. + + Parameters + --------- + points: (n, 3) points in space + + Returns + --------- + contains: (n,) bool + Whether point is inside mesh or not + """ + return contains_points(self, points) + + def __getstate__(self): + state = self.__dict__.copy() + # don't pickle cache + state.pop("_cache", None) + return state + + def __setstate__(self, state): + self.__dict__.update(state) + # Add cache back since it doesn't exist in the pickle + self._cache = caching.Cache(id_function=self.mesh.__hash__) + + def __deepcopy__(self, *args): + return self.__copy__() + + def __copy__(self, *args): + return RayMeshIntersector(geometry=self.mesh, scale_to_box=self._scale_to_box) + + +class _EmbreeWrap: + """ + A light wrapper for Embreex scene objects which + allows queries to be scaled to help with precision + issues, as well as selecting the correct dtypes. + """ + + def __init__(self, vertices, faces, scale): + scaled = np.array(vertices, dtype=np.float64) + self.origin = scaled.min(axis=0) + self.scale = float(scale) + scaled = (scaled - self.origin) * self.scale + + self.scene = rtcore_scene.EmbreeScene() + # assign the geometry to the scene + TriangleMesh( + scene=self.scene, + vertices=scaled.astype(_embree_dtype), + indices=faces.view(np.ndarray).astype(np.int32), + ) + + def run(self, origins, normals, **kwargs): + scaled = (np.array(origins, dtype=np.float64) - self.origin) * self.scale + + return self.scene.run( + scaled.astype(_embree_dtype), normals.astype(_embree_dtype), **kwargs + ) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/ray_triangle.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/ray_triangle.py new file mode 100644 index 0000000000000000000000000000000000000000..48ad767e194df93ca4cd1d404291476cc3bb12fd --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/ray_triangle.py @@ -0,0 +1,402 @@ +""" +A basic slow implementation of ray- triangle queries. +""" + +import numpy as np + +from .. import caching, grouping, intersections, util +from .. import triangles as triangles_mod +from ..constants import tol +from .ray_util import contains_points + + +class RayMeshIntersector: + """ + An object to query a mesh for ray intersections. + Precomputes an r-tree for each triangle on the mesh. + """ + + def __init__(self, mesh): + self.mesh = mesh + self._cache = caching.Cache(self.mesh.__hash__) + + def intersects_id( + self, + ray_origins, + ray_directions, + return_locations=False, + multiple_hits=True, + **kwargs, + ): + """ + Find the intersections between the current mesh and an + array of rays. + + Parameters + ------------ + ray_origins : (m, 3) float + Ray origin points + ray_directions : (m, 3) float + Ray direction vectors + multiple_hits : bool + Consider multiple hits of each ray or not + return_locations : bool + Return hit locations or not + + Returns + ----------- + index_triangle : (h,) int + Index of triangles hit + index_ray : (h,) int + Index of ray that hit triangle + locations : (h, 3) float + [optional] Position of intersection in space + """ + (index_tri, index_ray, locations) = ray_triangle_id( + triangles=self.mesh.triangles, + ray_origins=ray_origins, + ray_directions=ray_directions, + tree=self.mesh.triangles_tree, + multiple_hits=multiple_hits, + triangles_normal=self.mesh.face_normals, + ) + if return_locations: + if len(index_tri) == 0: + return index_tri, index_ray, locations + unique = grouping.unique_rows(np.column_stack((locations, index_ray)))[0] + return index_tri[unique], index_ray[unique], locations[unique] + return index_tri, index_ray + + def intersects_location(self, ray_origins, ray_directions, **kwargs): + """ + Return unique cartesian locations where rays hit the mesh. + If you are counting the number of hits a ray had, this method + should be used as if only the triangle index is used on- edge hits + will be counted twice. + + Parameters + ------------ + ray_origins : (m, 3) float + Ray origin points + ray_directions : (m, 3) float + Ray direction vectors + + Returns + --------- + locations : (n) sequence of (m,3) float + Intersection points + index_ray : (n,) int + Array of ray indexes + index_tri: (n,) int + Array of triangle (face) indexes + """ + (index_tri, index_ray, locations) = self.intersects_id( + ray_origins=ray_origins, + ray_directions=ray_directions, + return_locations=True, + **kwargs, + ) + return locations, index_ray, index_tri + + def intersects_first(self, ray_origins, ray_directions, **kwargs): + """ + Find the index of the first triangle a ray hits. + + + Parameters + ---------- + ray_origins : (n, 3) float + Origins of rays + ray_directions : (n, 3) float + Direction (vector) of rays + + Returns + ---------- + triangle_index : (n,) int + Index of triangle ray hit, or -1 if not hit + """ + + (index_tri, index_ray) = self.intersects_id( + ray_origins=ray_origins, + ray_directions=ray_directions, + return_locations=False, + multiple_hits=False, + **kwargs, + ) + + # put the result into the form of "one triangle index per ray" + result = np.ones(len(ray_origins), dtype=np.int64) * -1 + result[index_ray] = index_tri + + return result + + def intersects_any(self, ray_origins, ray_directions, **kwargs): + """ + Find out if each ray hit any triangle on the mesh. + + Parameters + ------------ + ray_origins : (m, 3) float + Ray origin points + ray_directions : (m, 3) float + Ray direction vectors + + Returns + --------- + hit : (m,) bool + Whether any ray hit any triangle on the mesh + """ + _index_tri, index_ray = self.intersects_id(ray_origins, ray_directions) + hit_any = np.zeros(len(ray_origins), dtype=bool) + hit_idx = np.unique(index_ray) + if len(hit_idx) > 0: + hit_any[hit_idx] = True + return hit_any + + def contains_points(self, points): + """ + Check if a mesh contains a list of points, using ray tests. + + If the point is on the surface of the mesh the behavior + is undefined. + + Parameters + ------------ + points : (n, 3) float + Points in space + + Returns + --------- + contains : (n,) bool + Whether point is inside mesh or not + """ + + return contains_points(self, points) + + +def ray_triangle_id( + triangles, + ray_origins, + ray_directions, + triangles_normal=None, + tree=None, + multiple_hits=True, +): + """ + Find the intersections between a group of triangles and rays + + Parameters + ------------- + triangles : (n, 3, 3) float + Triangles in space + ray_origins : (m, 3) float + Ray origin points + ray_directions : (m, 3) float + Ray direction vectors + triangles_normal : (n, 3) float + Normal vector of triangles, optional + tree : rtree.Index + Rtree object holding triangle bounds + + Returns + ----------- + index_triangle : (h,) int + Index of triangles hit + index_ray : (h,) int + Index of ray that hit triangle + locations : (h, 3) float + Position of intersection in space + """ + triangles = np.asanyarray(triangles, dtype=np.float64) + ray_origins = np.asanyarray(ray_origins, dtype=np.float64) + ray_directions = np.asanyarray(ray_directions, dtype=np.float64) + + # if we didn't get passed an r-tree for the bounds of each + # triangle create one here + if tree is None: + tree = triangles_mod.bounds_tree(triangles) + + # find the list of likely triangles and which ray they + # correspond with, via rtree queries + ray_candidates, ray_id = ray_triangle_candidates( + ray_origins=ray_origins, ray_directions=ray_directions, tree=tree + ) + + # get subsets which are corresponding rays and triangles + # (c,3,3) triangle candidates + triangle_candidates = triangles[ray_candidates] + # (c,3) origins and vectors for the rays + line_origins = ray_origins[ray_id] + line_directions = ray_directions[ray_id] + + # get the plane origins and normals from the triangle candidates + plane_origins = triangle_candidates[:, 0, :] + if triangles_normal is None: + plane_normals, triangle_ok = triangles_mod.normals(triangle_candidates) + if not triangle_ok.all(): + raise ValueError("Invalid triangles!") + else: + plane_normals = triangles_normal[ray_candidates] + + # find the intersection location of the rays with the planes + location, valid = intersections.planes_lines( + plane_origins=plane_origins, + plane_normals=plane_normals, + line_origins=line_origins, + line_directions=line_directions, + ) + + if len(triangle_candidates) == 0 or not valid.any(): + # we got no hits so return early with empty array + return ( + np.array([], dtype=np.int64), + np.array([], dtype=np.int64), + np.array([], dtype=np.float64), + ) + + # find the barycentric coordinates of each plane intersection on the + # triangle candidates + barycentric = triangles_mod.points_to_barycentric( + triangle_candidates[valid], location + ) + + # the plane intersection is inside the triangle if all barycentric + # coordinates are between 0.0 and 1.0 + hit = np.logical_and( + (barycentric > -tol.zero).all(axis=1), (barycentric < (1 + tol.zero)).all(axis=1) + ) + + # the result index of the triangle is a candidate with a valid + # plane intersection and a triangle which contains the plane + # intersection point + index_tri = ray_candidates[valid][hit] + # the ray index is a subset with a valid plane intersection and + # contained by a triangle + index_ray = ray_id[valid][hit] + # locations are already valid plane intersections, just mask by hits + location = location[hit] + + # only return points that are forward from the origin + vector = location - ray_origins[index_ray] + distance = util.diagonal_dot(vector, ray_directions[index_ray]) + forward = distance > -1e-6 + + index_tri = index_tri[forward] + index_ray = index_ray[forward] + location = location[forward] + distance = distance[forward] + + if multiple_hits: + return index_tri, index_ray, location + + # since we are not returning multiple hits, we need to + # figure out which hit is first + if len(index_ray) == 0: + return index_tri, index_ray, location + + # find the first hit + first = np.array([g[distance[g].argmin()] for g in grouping.group(index_ray)]) + + return index_tri[first], index_ray[first], location[first] + + +def ray_triangle_candidates(ray_origins, ray_directions, tree): + """ + Do broad- phase search for triangles that the rays + may intersect. + + Does this by creating a bounding box for the ray as it + passes through the volume occupied by the tree + + Parameters + ------------ + ray_origins : (m, 3) float + Ray origin points. + ray_directions : (m, 3) float + Ray direction vectors + tree : rtree object + Ccontains AABB of each triangle + + Returns + ---------- + ray_candidates : (n,) int + Triangle indexes + ray_id : (n,) int + Corresponding ray index for a triangle candidate + """ + bounding = ray_bounds( + ray_origins=ray_origins, ray_directions=ray_directions, bounds=tree.bounds + ) + + index = [] + candidates = [] + for i, bounds in enumerate(bounding): + cand = list(tree.intersection(bounds)) + candidates.extend(cand) + index.extend([i] * len(cand)) + return np.array(candidates, dtype=np.int64), np.array(index, dtype=np.int64) + + +def ray_bounds(ray_origins, ray_directions, bounds, buffer_dist=1e-5): + """ + Given a set of rays and a bounding box for the volume of interest + where the rays will be passing through, find the bounding boxes + of the rays as they pass through the volume. + + Parameters + ------------ + ray_origins: (m,3) float, ray origin points + ray_directions: (m,3) float, ray direction vectors + bounds: (2,3) bounding box (min, max) + buffer_dist: float, distance to pad zero width bounding boxes + + Returns + --------- + ray_bounding: (n) set of AABB of rays passing through volume + """ + + ray_origins = np.asanyarray(ray_origins, dtype=np.float64) + ray_directions = np.asanyarray(ray_directions, dtype=np.float64) + + # bounding box we are testing against + bounds = np.asanyarray(bounds) + + # find the primary axis of the vector + axis = np.abs(ray_directions).argmax(axis=1) + axis_bound = bounds.reshape((2, -1)).T[axis] + axis_ori = np.array([ray_origins[i][a] for i, a in enumerate(axis)]).reshape((-1, 1)) + axis_dir = np.array([ray_directions[i][a] for i, a in enumerate(axis)]).reshape( + (-1, 1) + ) + + # parametric equation of a line + # point = direction*t + origin + # p = dt + o + # t = (p-o)/d + nonzero = (axis_dir != 0.0).reshape(-1) + t = np.zeros_like(axis_bound) + t[nonzero] = (axis_bound[nonzero] - axis_ori[nonzero]) / axis_dir[nonzero] + + # prevent the bounding box from including triangles + # behind the ray origin + t[t < buffer_dist] = buffer_dist + + # the value of t for both the upper and lower bounds + t_a = t[:, 0].reshape((-1, 1)) + t_b = t[:, 1].reshape((-1, 1)) + + # the cartesian point for where the line hits the plane defined by + # axis + on_a = (ray_directions * t_a) + ray_origins + on_b = (ray_directions * t_b) + ray_origins + + on_plane = np.column_stack((on_a, on_b)).reshape((-1, 2, ray_directions.shape[1])) + + ray_bounding = np.hstack((on_plane.min(axis=1), on_plane.max(axis=1))) + # pad the bounding box by TOL_BUFFER + # not sure if this is necessary, but if the ray is axis aligned + # this function will otherwise return zero volume bounding boxes + # which may or may not screw up the r-tree intersection queries + ray_bounding += np.array([-1, -1, -1, 1, 1, 1]) * buffer_dist + + return ray_bounding diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/ray_util.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/ray_util.py new file mode 100644 index 0000000000000000000000000000000000000000..9ffd85d52ce4c825acb1681d26295c1faa9ef4f9 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/ray/ray_util.py @@ -0,0 +1,120 @@ +import numpy as np + +from .. import bounds, constants, util +from ..typed import ArrayLike + + +@constants.log_time +def contains_points(intersector, points: ArrayLike, check_direction: bool | None = None): + """ + Check if a mesh contains a set of points, using ray tests. + + If the point is on the surface of the mesh, behavior is + undefined. + + Parameters + --------- + mesh: Trimesh object + points: (n,3) points in space + + Returns + --------- + contains : (n) bool + Whether point is inside mesh or not + """ + # convert points to float and make sure they are 3D + points = np.asanyarray(points, dtype=np.float64) + if not util.is_shape(points, (-1, 3)): + raise ValueError("points must be (n,3)") + + # placeholder result with no hits we'll fill in later + contains = np.zeros(len(points), dtype=bool) + + # cull points outside of the axis aligned bounding box + # this avoids running ray tests unless points are close + inside_aabb = bounds.contains(intersector.mesh.bounds, points) + + # if everything is outside the AABB, exit early + if not inside_aabb.any(): + return contains + + # default ray direction is random, but we are not generating + # uniquely each time so the behavior of this function is easier to debug + default_direction = np.array([0.4395064455, 0.617598629942, 0.652231566745]) + if check_direction is None: + # if no check direction is specified use the default + # stack it only for points inside the AABB + ray_directions = np.tile(default_direction, (inside_aabb.sum(), 1)) + else: + # if a direction is passed use it + ray_directions = np.tile( + np.array(check_direction).reshape(3), (inside_aabb.sum(), 1) + ) + + # cast a ray both forwards and backwards + # need multiple_hits=True so the parity test counts cavity walls + _location, index_ray, _c = intersector.intersects_location( + np.vstack((points[inside_aabb], points[inside_aabb])), + np.vstack((ray_directions, -ray_directions)), + multiple_hits=True, + ) + + # if we hit nothing in either direction just return with no hits + if len(index_ray) == 0: + return contains + + # reshape so bi_hits[0] is the result in the forward direction and + # bi_hits[1] is the result in the backwards directions + bi_hits = np.bincount(index_ray, minlength=len(ray_directions) * 2).reshape((2, -1)) + # a point is probably inside if it hits a surface an odd number of times + bi_contains = np.mod(bi_hits, 2) == 1 + + # if the mod of the hit count is the same in both + # directions, we can save that result and move on + agree = np.equal(*bi_contains) + + # in order to do an assignment we can only have one + # level of boolean indexes, for example this doesn't work: + # contains[inside_aabb][agree] = bi_contains[0][agree] + # no error is thrown, but nothing gets assigned + # to get around that, we create a single mask for assignment + mask = inside_aabb.copy() + mask[mask] = agree + + # set contains flags for things inside the AABB and who have + # ray tests that agree in both directions + contains[mask] = bi_contains[0][agree] + + # if one of the rays in either direction hit nothing + # it is a very solid indicator we are in free space + # as the edge cases we are working around tend to + # add hits rather than miss hits + one_freespace = (bi_hits == 0).any(axis=0) + + # rays where they don't agree and one isn't in free space + # are deemed to be broken + broken = np.logical_and(np.logical_not(agree), np.logical_not(one_freespace)) + + # if all rays agree return + if not broken.any(): + return contains + + # try to run again with a new random vector + # only do it if check_direction isn't specified + # to avoid infinite recursion + if check_direction is None: + # we're going to run the check again in a random direction + new_direction = util.unitize(util.random_generator().random(3) - 0.5) + # do the mask trick again to be able to assign results + mask = inside_aabb.copy() + mask[mask] = broken + + contains[mask] = contains_points( + intersector, points[inside_aabb][broken], check_direction=new_direction + ) + + constants.log.debug( + "detected %d broken contains test, attempted to fix", broken.sum() + ) + + return contains diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/registration.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/registration.py new file mode 100644 index 0000000000000000000000000000000000000000..3d59370c4c1d40ed080df277ba509774ceab7552 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/registration.py @@ -0,0 +1,1135 @@ +""" +registration.py +--------------- + +Functions for registering (aligning) point clouds with meshes. +""" + +import numpy as np + +from . import bounds, transformations, util +from .geometry import weighted_vertex_normals +from .points import PointCloud, plane_fit +from .transformations import transform_points +from .triangles import angles, cross, normals +from .typed import ArrayLike, Integer, Seed + +try: + import scipy.sparse as sparse + from scipy.spatial import cKDTree +except BaseException as E: + # wrapping just ImportError fails in some cases + # will raise the error when someone tries to use KDtree + from . import exceptions + + cKDTree = exceptions.ExceptionWrapper(E) + sparse = exceptions.ExceptionWrapper(E) + + +# permutations of cube rotations +# the principal inertia transform has arbitrary sign +# along the 3 major axis so try all combinations of +# 180 degree rotations with a quick first ICP pass +_cube_diagonals = np.array( + [ + [1, 1, 1, 1], + [1, 1, -1, 1], + [1, -1, 1, 1], + [-1, 1, 1, 1], + [-1, -1, 1, 1], + [-1, 1, -1, 1], + [1, -1, -1, 1], + [-1, -1, -1, 1], + ], + dtype=np.float64, +) + + +def mesh_other( + mesh, + other, + samples: Integer = 500, + scale: bool = False, + icp_first: Integer = 10, + icp_final: Integer = 50, + reflection: bool = True, + seed: Seed = None, + **kwargs, +): + """ + Align a mesh with another mesh or a PointCloud using + the principal axes of inertia as a starting point which + is refined by iterative closest point. + + Parameters + ------------ + mesh : trimesh.Trimesh object + Mesh to align with other + other : trimesh.Trimesh or (n, 3) float + Mesh or points in space + samples : int + Number of samples from mesh surface to align + scale : bool + Allow scaling in transform + icp_first : int + How many ICP iterations for the 9 possible + combinations of sign flippage + icp_final : int + How many ICP iterations for the closest + candidate from the wider search + seed : None or int + Seed the surface sampling this uses to pick key points: + pass an integer for deterministic results. + kwargs : dict + Passed through to `icp`, which passes through to `procrustes` + + Returns + ----------- + mesh_to_other : (4, 4) float + Transform to align mesh to the other object + cost : float + Average squared distance per point + """ + + def key_points(m, count): + """ + Return a combination of mesh vertices and surface samples + with vertices chosen by likelihood to be important + to registration. + """ + if len(m.vertices) < (count / 2): + return np.vstack((m.vertices, m.sample(count - len(m.vertices), seed=seed))) + else: + return m.sample(count, seed=seed) + + if not util.is_instance_named(mesh, "Trimesh"): + raise ValueError("mesh must be Trimesh object!") + + inverse = True + search = mesh + # if both are meshes use the smaller one for searching + if util.is_instance_named(other, "Trimesh"): + if len(mesh.vertices) > len(other.vertices): + # do the expensive tree construction on the + # smaller mesh and query the others points + search = other + inverse = False + points = key_points(m=mesh, count=samples) + points_mesh = mesh + else: + points_mesh = other + points = key_points(m=other, count=samples) + + if points_mesh.is_volume: + points_PIT = points_mesh.principal_inertia_transform + else: + points_PIT = points_mesh.bounding_box_oriented.principal_inertia_transform + + elif util.is_shape(other, (-1, 3)): + # case where other is just points + points = other + points_PIT = bounds.oriented_bounds(points)[0] + else: + raise ValueError("other must be mesh or (n, 3) points!") + + # get the transform that aligns the search mesh principal + # axes of inertia with the XYZ axis at the origin + if search.is_volume: + search_PIT = search.principal_inertia_transform + else: + search_PIT = search.bounding_box_oriented.principal_inertia_transform + + # transform that moves the principal axes of inertia + # of the search mesh to be aligned with the best- guess + # principal axes of the points + search_to_points = np.dot(np.linalg.inv(points_PIT), search_PIT) + if not reflection: + # drop the negative-determinant seeds — icp can only refine + # proper rotations so a reflected seed stays reflected, #2482 + diagonals = _cube_diagonals[np.prod(_cube_diagonals, axis=1) > 0.0] + else: + diagonals = _cube_diagonals + + # expand the diagonals into (n, 4, 4) transforms + cubes = np.eye(4) * diagonals[:, None, :] + + # loop through permutations and run iterative closest point + costs = np.ones(len(cubes)) * np.inf + transforms = [None] * len(cubes) + centroid = search.centroid + + for i, flip in enumerate(cubes): + # transform from points to search mesh + # flipped around the centroid of search + a_to_b = np.dot( + transformations.transform_around(flip, centroid), + np.linalg.inv(search_to_points), + ) + + # run first pass ICP + matrix, _junk, cost = icp( + a=points, + b=search, + initial=a_to_b, + max_iterations=int(icp_first), + scale=scale, + reflection=reflection, + **kwargs, + ) + + # save transform and costs from ICP + transforms[i] = matrix + costs[i] = cost + + # run a final ICP refinement step + matrix, _junk, cost = icp( + a=points, + b=search, + initial=transforms[np.argmin(costs)], + max_iterations=int(icp_final), + scale=scale, + reflection=reflection, + **kwargs, + ) + + # convert to per- point distance average + cost /= len(points) + + # we picked the smaller mesh to construct the tree + # on so we may have calculated a transform backwards + # to save computation, so just invert matrix here + if inverse: + mesh_to_other = np.linalg.inv(matrix) + else: + mesh_to_other = matrix + + return mesh_to_other, cost + + +def procrustes( + a: ArrayLike, + b: ArrayLike, + weights: ArrayLike | None = None, + reflection: bool = True, + translation: bool = True, + scale: bool = True, + return_cost: bool = True, +): + """ + Perform Procrustes' analysis to quickly align two corresponding + point clouds subject to constraints. This is much cheaper than + any other registration method but only applies if the two inputs + correspond in order. + + Finds the transformation T mapping a to b which minimizes the + square sum distances between Ta and b, also called the cost. + + Optionally filter the points in a and b via a binary weights array. + Non-uniform weights are also supported, but won't yield the optimal rotation. + + Parameters + ---------- + a : (n,3) float + List of points in space + b : (n,3) float + List of points in space + weights : (n,) float + List of floats representing how much weight is assigned to each point. + Binary entries can be used to filter the arrays; normalization is not required. + Translation and scaling are adjusted according to the weighting. + Note, however, that this method does not yield the optimal rotation for + non-uniform weighting, + as this would require an iterative, nonlinear optimization approach. + reflection : bool + If the transformation is allowed reflections + translation : bool + If the transformation is allowed translation and rotation. + scale : bool + If the transformation is allowed scaling + return_cost : bool + Whether to return the cost and transformed a as well + + Returns + ---------- + matrix : (4,4) float + The transformation matrix sending a to b + transformed : (n,3) float + The image of a under the transformation + cost : float + The cost of the transformation + """ + + a_original = np.asanyarray(a, dtype=np.float64) + b_original = np.asanyarray(b, dtype=np.float64) + if not util.is_shape(a_original, (-1, 3)) or not util.is_shape(b_original, (-1, 3)): + raise ValueError("points must be (n,3)!") + if len(a_original) != len(b_original): + raise ValueError("a and b must contain same number of points!") + # weights are set to uniform if not provided. + if weights is None: + weights = np.ones(len(a_original)) + w = np.maximum(np.asanyarray(weights, dtype=np.float64), 0) + if len(w) != len(a): + raise ValueError("weights must have same length as a and b!") + w_norm = (w / w.sum()).reshape((-1, 1)) + + # All zero entries are removed from further computations. + # If weights is a binary array, the optimal solution can still be found by + # simply removing the zero entries. + nonzero_weights = w_norm[:, 0] > 0.0 + a_nonzero = a_original[nonzero_weights] + b_nonzero = b_original[nonzero_weights] + w_norm = w_norm[nonzero_weights] + + # Remove translation component + if translation: + # centers are (weighted) averages of the individual points. + acenter = (a_nonzero * w_norm).sum(axis=0) + bcenter = (b_nonzero * w_norm).sum(axis=0) + else: + acenter = np.zeros(a_nonzero.shape[1]) + bcenter = np.zeros(b_nonzero.shape[1]) + + # Remove scale component + if scale: + # scale is the square root of the (weighted) average of the + # squared difference between each point and the center. + ascale = np.sqrt((((a_nonzero - acenter) ** 2) * w_norm).sum()) + bscale = np.sqrt((((b_nonzero - bcenter) ** 2) * w_norm).sum()) + else: + ascale = 1 + bscale = 1 + + # Use SVD to find optimal orthogonal matrix R + # constrained to det(R) = 1 if necessary. + + target = np.dot(((b_nonzero - bcenter) / bscale).T, ((a_nonzero - acenter) / ascale)) + + u, _s, vh = np.linalg.svd(target) + + if reflection: + R = np.dot(u, vh) + else: + # no reflection allowed, so determinant must be 1.0 + R = np.dot(np.dot(u, np.diag([1, 1, np.linalg.det(np.dot(u, vh))])), vh) + + # Compute our 4D transformation matrix encoding + # a -> (R @ (a - acenter)/ascale) * bscale + bcenter + # = (bscale/ascale)R @ a + (bcenter - (bscale/ascale)R @ acenter) + translation = bcenter - (bscale / ascale) * np.dot(R, acenter) + matrix = np.hstack((bscale / ascale * R, translation.reshape(-1, 1))) + matrix = np.vstack((matrix, np.array([0.0] * (a.shape[1]) + [1.0]).reshape(1, -1))) + + if return_cost: + # Transform the original input array, including zero-weighted points + transformed = transform_points(a_original, matrix) + # The cost is the (weighted) sum of the euclidean distances between + # the transformed source points and the target points. + cost = (((b_nonzero - transformed[nonzero_weights]) ** 2) * w_norm).sum() + return matrix, transformed, cost + + return matrix + + +def icp(a, b, initial=None, threshold=1e-5, max_iterations=20, **kwargs): + """ + Apply the iterative closest point algorithm to align a point cloud with + another point cloud or mesh. Will only produce reasonable results if the + initial transformation is roughly correct. Initial transformation can be + found by applying Procrustes' analysis to a suitable set of landmark + points (often picked manually). + + Parameters + ---------- + a : (n,3) float + List of points in space. + b : (m,3) float or Trimesh + List of points in space or mesh. + initial : (4,4) float + Initial transformation. + threshold : float + Stop when change in cost is less than threshold + max_iterations : int + Maximum number of iterations + kwargs : dict + Args to pass to procrustes + + Returns + ---------- + matrix : (4,4) float + The transformation matrix sending a to b + transformed : (n,3) float + The image of a under the transformation + cost : float + The cost of the transformation + """ + + a = np.asanyarray(a, dtype=np.float64) + if not util.is_shape(a, (-1, 3)): + raise ValueError("points must be (n,3)!") + + if initial is None: + initial = np.eye(4) + + is_mesh = util.is_instance_named(b, "Trimesh") + if not is_mesh: + b = np.asanyarray(b, dtype=np.float64) + if not util.is_shape(b, (-1, 3)): + raise ValueError("points must be (n,3)!") + btree = cKDTree(b) + + # transform a under initial_transformation + a = transform_points(a, initial) + total_matrix = initial + + # start with infinite cost + old_cost = np.inf + + # avoid looping forever by capping iterations + for _ in range(max_iterations): + # Closest point in b to each point in a + if is_mesh: + closest, _distance, _faces = b.nearest.on_surface(a) + else: + _distances, ix = btree.query(a, 1) + closest = b[ix] + + # align a with closest points + matrix, transformed, cost = procrustes(a=a, b=closest, **kwargs) + + # update a with our new transformed points + a = transformed + total_matrix = np.dot(matrix, total_matrix) + + if old_cost - cost < threshold: + break + else: + old_cost = cost + + return total_matrix, transformed, cost + + +def _normalize_by_source(source_mesh, target_geometry, target_positions): + # Utility function to put the source mesh in [-1, 1]^3 and transform + # target geometry accordingly + if not util.is_instance_named(target_geometry, "Trimesh") and not isinstance( + target_geometry, PointCloud + ): + vertices = np.asanyarray(target_geometry) + target_geometry = PointCloud(vertices) + centroid, scale = source_mesh.centroid, source_mesh.scale + source_mesh.vertices = (source_mesh.vertices - centroid[None, :]) / scale + # Dont forget to also transform the target positions + target_geometry.vertices = (target_geometry.vertices - centroid[None, :]) / scale + if target_positions is not None: + target_positions = (target_positions - centroid[None, :]) / scale + return target_geometry, target_positions, centroid, scale + + +def _denormalize_by_source( + source_mesh, target_geometry, target_positions, result, centroid, scale +): + # Utility function to transform source mesh from + # [-1, 1]^3 to its original transform + # and transform target geometry accordingly + source_mesh.vertices = scale * source_mesh.vertices + centroid[None, :] + target_geometry.vertices = scale * target_geometry.vertices + centroid[None, :] + if target_positions is not None: + target_positions = scale * target_positions + centroid[None, :] + if isinstance(result, list): + result = [scale * x + centroid[None, :] for x in result] + else: + result = scale * result + centroid[None, :] + return result + + +def nricp_amberg( + source_mesh, + target_geometry, + source_landmarks=None, + target_positions=None, + steps=None, + eps=0.0001, + gamma=1, + distance_threshold=0.1, + return_records=False, + use_faces=True, + use_vertex_normals=True, + neighbors_count=8, +): + """ + Non Rigid Iterative Closest Points + + Implementation of "Amberg et al. 2007: Optimal Step + Nonrigid ICP Algorithms for Surface Registration." + Allows to register non-rigidly a mesh on another or + on a point cloud. The core algorithm is explained + at the end of page 3 of the paper. + + Comparison between nricp_amberg and nricp_sumner: + * nricp_amberg fits to the target mesh in less steps + * nricp_amberg can generate sharp edges + * only vertices and their neighbors are considered + * nricp_sumner tend to preserve more the original shape + * nricp_sumner parameters are easier to tune + * nricp_sumner solves for triangle positions whereas + nricp_amberg solves for vertex transforms + * nricp_sumner is less optimized when wn > 0 + + Parameters + ---------- + source_mesh : Trimesh + Source mesh containing both vertices and faces. + target_geometry : Trimesh or PointCloud or (n, 3) float + Target geometry. It can contain no faces or be a PointCloud. + source_landmarks : (n,) int or ((n,) int, (n, 3) float) + n landmarks on the the source mesh. + Represented as vertex indices (n,) int. + It can also be represented as a tuple of triangle + indices and barycentric coordinates ((n,) int, (n, 3) float,). + target_positions : (n, 3) float + Target positions assigned to source landmarks + steps : Core parameters of the algorithm + Iterable of iterables (ws, wl, wn, max_iter,). + ws is smoothness term, wl weights landmark importance, wn normal importance + and max_iter is the maximum number of iterations per step. + eps : float + If the error decrease if inferior to this value, the current step ends. + gamma : float + Weight the translation part against the rotational/skew part. + Recommended value : 1. + distance_threshold : float + Distance threshold to account for a vertex match or not. + return_records : bool + If True, also returns all the intermediate results. It can help debugging + and tune the parameters to match a specific case. + use_faces : bool + If True and if target geometry has faces, use proximity.closest_point to find + matching points. Else use scipy's cKDTree object. + use_vertex_normals : bool + If True and if target geometry has faces, interpolate the normals of the target + geometry matching points. + Else use face normals or estimated normals if target geometry has no faces. + neighbors_count : int + number of neighbors used for normal estimation. Only used if target geometry has + no faces or if use_faces is False. + + Returns + ---------- + result : (n, 3) float or list[(n, 3) float] + The vertices positions of source_mesh such that it is registered non-rigidly + onto the target geometry. + If return_records is True, it returns the list of the vertex positions at each + iteration. + """ + + def _solve_system(M_kron_G, D, vertices_weight, nearest, ws, nE, nV, Dl, Ul, wl): + # Solve for Eq. 12 + U = nearest * vertices_weight[:, None] + use_landmarks = Dl is not None and Ul is not None + A_stack = [ws * M_kron_G, D.multiply(vertices_weight[:, None])] + B_shape = (4 * nE + nV, 3) + if use_landmarks: + A_stack.append(wl * Dl) + B_shape = (4 * nE + nV + Ul.shape[0], 3) + A = sparse.csr_matrix(sparse.vstack(A_stack)) + B = sparse.lil_matrix(B_shape, dtype=np.float32) + B[4 * nE : (4 * nE + nV), :] = U + if use_landmarks: + B[4 * nE + nV : (4 * nE + nV + Ul.shape[0]), :] = Ul * wl + X = sparse.linalg.spsolve(A.T * A, A.T * B).toarray() + return X + + def _node_arc_incidence(mesh, do_weight): + # Computes node-arc incidence matrix of mesh (Eq.10) + nV = mesh.edges.max() + 1 + nE = len(mesh.edges) + rows = np.repeat(np.arange(nE), 2) + cols = mesh.edges.flatten() + data = np.ones(2 * nE, np.float32) + data[1::2] = -1 + if do_weight: + edge_lengths = np.linalg.norm( + mesh.vertices[mesh.edges[:, 0]] - mesh.vertices[mesh.edges[:, 1]], axis=-1 + ) + data *= np.repeat(1 / edge_lengths, 2) + return sparse.coo_matrix((data, (rows, cols)), shape=(nE, nV)) + + def _create_D(vertex_3d_data): + # Create Data matrix (Eq. 8) + nV = len(vertex_3d_data) + rows = np.repeat(np.arange(nV), 4) + cols = np.arange(4 * nV) + data = np.concatenate((vertex_3d_data, np.ones((nV, 1))), axis=-1).flatten() + return sparse.csr_matrix((data, (rows, cols)), shape=(nV, 4 * nV)) + + def _create_X(nV): + # Create Unknowns Matrix (Eq. 1) + X_ = np.concatenate((np.eye(3), np.array([[0, 0, 0]])), axis=0) + return np.tile(X_, (nV, 1)) + + def _create_Dl_Ul(D, source_mesh, source_landmarks, target_positions): + # Create landmark terms (Eq. 11) + Dl, Ul = None, None + + if source_landmarks is None or target_positions is None: + # If no landmarks are provided, return None for both + return Dl, Ul + + if isinstance(source_landmarks, tuple): + source_tids, source_barys = source_landmarks + source_tri_vids = source_mesh.faces[source_tids] + # u * x1, v * x2 and w * x3 combined + Dl = D[source_tri_vids.flatten(), :] + Dl.data *= source_barys.flatten().repeat(np.diff(Dl.indptr)) + x0 = source_mesh.vertices[source_tri_vids[:, 0]] + x1 = source_mesh.vertices[source_tri_vids[:, 1]] + x2 = source_mesh.vertices[source_tri_vids[:, 2]] + Ul0 = ( + target_positions + - x1 * source_barys[:, 1, None] + - x2 * source_barys[:, 2, None] + ) + Ul1 = ( + target_positions + - x0 * source_barys[:, 0, None] + - x2 * source_barys[:, 2, None] + ) + Ul2 = ( + target_positions + - x0 * source_barys[:, 0, None] + - x1 * source_barys[:, 1, None] + ) + Ul = np.zeros((Ul0.shape[0] * 3, 3)) + Ul[0::3] = Ul0 # y - v * x2 + w * x3 + Ul[1::3] = Ul1 # y - u * x1 + w * x3 + Ul[2::3] = Ul2 # y - u * x1 + v * x2 + else: + Dl = D[source_landmarks, :] + Ul = target_positions + return Dl, Ul + + target_geometry, target_positions, centroid, scale = _normalize_by_source( + source_mesh, target_geometry, target_positions + ) + + # Number of edges and vertices in source mesh + nE = len(source_mesh.edges) + nV = len(source_mesh.vertices) + + # Initialize transformed vertices + transformed_vertices = source_mesh.vertices.copy() + # Node-arc incidence (M in Eq. 10) + M = _node_arc_incidence(source_mesh, True) + # G (Eq. 10) + G = np.diag([1, 1, 1, gamma]) + # M kronecker G (Eq. 10) + M_kron_G = sparse.kron(M, G) + # D (Eq. 8) + D = _create_D(source_mesh.vertices) + # D but for normal computation from the transformations X + DN = _create_D(source_mesh.vertex_normals) + # Unknowns 4x3 transformations X (Eq. 1) + X = _create_X(nV) + # Landmark related terms (Eq. 11) + Dl, Ul = _create_Dl_Ul(D, source_mesh, source_landmarks, target_positions) + + # Parameters of the algorithm (Eq. 6) + # order : Alpha, Beta, normal weighting, and max iteration for step + if steps is None: + steps = [ + [0.01, 10, 0.5, 10], + [0.02, 5, 0.5, 10], + [0.03, 2.5, 0.5, 10], + [0.01, 0, 0.0, 10], + ] + if return_records: + records = [transformed_vertices] + + # Main loop + for ws, wl, wn, max_iter in steps: + # If normals are estimated from points and if there are less + # than 3 points per query, avoid normal estimation + if not use_faces and neighbors_count < 3: + wn = 0 + + last_error = np.finfo(np.float32).max + error = np.finfo(np.float16).max + cpt_iter = 0 + + # Current step iterations loop + while last_error - error > eps and (max_iter is None or cpt_iter < max_iter): + qres = _from_mesh( + target_geometry, + transformed_vertices, + from_vertices_only=not use_faces, + return_normals=wn > 0, + return_interpolated_normals=wn > 0 and use_vertex_normals, + neighbors_count=neighbors_count, + ) + + # Data weighting + vertices_weight = np.ones(nV) + vertices_weight[qres["distances"] > distance_threshold] = 0 + + if wn > 0 and "normals" in qres: + target_normals = qres["normals"] + if use_vertex_normals and "interpolated_normals" in qres: + target_normals = qres["interpolated_normals"] + # Normal weighting = multiplying weights by cosines^wn + source_normals = DN * X + dot = util.diagonal_dot(source_normals, target_normals) + # Normal orientation is only known for meshes as target + dot = np.clip(dot, 0, 1) if use_faces else np.abs(dot) + vertices_weight = vertices_weight * dot**wn + + # Actual system solve + X = _solve_system( + M_kron_G, D, vertices_weight, qres["nearest"], ws, nE, nV, Dl, Ul, wl + ) + transformed_vertices = D * X + last_error = error + error_vec = np.linalg.norm(qres["nearest"] - transformed_vertices, axis=-1) + error = (error_vec * vertices_weight).mean() + if return_records: + records.append(transformed_vertices) + cpt_iter += 1 + + if return_records: + result = records + else: + result = transformed_vertices + + result = _denormalize_by_source( + source_mesh, target_geometry, target_positions, result, centroid, scale + ) + return result + + +def _from_mesh( + mesh, + input_points, + from_vertices_only=False, + return_barycentric_coordinates=False, + return_normals=False, + return_interpolated_normals=False, + neighbors_count=10, + **kwargs, +): + """ + Find the the closest points and associated attributes from a Trimesh. + + Parameters + ----------- + mesh : Trimesh + Trimesh from which the query is performed + input_points : (m, 3) float + Input query points + from_vertices_only : bool + If True, consider only the vertices and not the faces + return_barycentric_coordinates : bool + If True, return the barycentric coordinates + return_normals : bool + If True, compute the normals at each closest point + return_interpolated_normals : bool + If True, return the interpolated normal at each closest point + neighbors_count : int + The number of closest neighbors to query + kwargs : dict + Dict to accept other key word arguments (not used) + Returns + ---------- + qres : dict + Dictionary containing : + - nearest points (m, 3) with key 'nearest' + - distances to nearest point (m,) with key 'distances' + - support triangle indices of the nearest points (m,) with key 'tids' + - [optional] normals at nearest points (m,3) with key 'normals' + - [optional] barycentric coordinates in support triangles (m,3) with key + 'barycentric_coordinates' + - [optional] interpolated normals (m,3) with key 'interpolated_normals' + """ + input_points = np.asanyarray(input_points) + neighbors_count = min(neighbors_count, len(mesh.vertices)) + + if from_vertices_only or len(mesh.faces) == 0: + # Consider only the vertices + return _from_points( + mesh.vertices, + input_points, + mesh.kdtree, + return_normals=return_normals, + neighbors_count=neighbors_count, + ) + # Else if we consider faces, use proximity.closest_point + qres = {} + from .proximity import closest_point + from .triangles import points_to_barycentric + + qres["nearest"], qres["distances"], qres["tids"] = closest_point(mesh, input_points) + + if return_normals: + qres["normals"] = mesh.face_normals[qres["tids"]] + if return_barycentric_coordinates or return_interpolated_normals: + qres["barycentric_coordinates"] = points_to_barycentric( + mesh.vertices[mesh.faces[qres["tids"]]], qres["nearest"] + ) + + if return_interpolated_normals: + # Interpolation from barycentric coordinates + qres["interpolated_normals"] = np.einsum( + "ij,ijk->ik", + qres["barycentric_coordinates"], + mesh.vertex_normals[mesh.faces[qres["tids"]]], + ) + return qres + + +def _from_points( + target_points, + input_points, + kdtree=None, + return_normals=False, + neighbors_count=10, + **kwargs, +): + """ + Find the the closest points and associated attributes + from a set of 3D points. + + Parameters + ----------- + target_points : (n, 3) float + Points from which the query is performed + input_points : (m, 3) float + Input query points + kdtree : scipy.cKDTree + KDTree used for query. Computed if not provided + return_normals : bool + If True, compute the normals at each nearest point + neighbors_count : int + The number of closest neighbors to query + kwargs : dict + Dict to accept other key word arguments (not used) + + Returns + ---------- + qres : dict + Dictionary containing : + - nearest points (m, 3) with key 'nearest' + - distances to nearest point (m,) with key 'distances' + - vertex indices of the nearest points (m,) with key 'vertex_indices' + - [optional] normals at nearest points (m,3) with key 'normals' + """ + # Empty result + target_points = np.asanyarray(target_points) + input_points = np.asanyarray(input_points) + neighbors_count = min(neighbors_count, len(target_points)) + qres = {} + if kdtree is None: + kdtree = cKDTree(target_points) + + if return_normals: + assert neighbors_count >= 3 + distances, indices = kdtree.query(input_points, k=neighbors_count) + nearest = target_points[indices, :] + qres["normals"] = plane_fit(nearest)[1] + qres["nearest"] = nearest[:, 0] + qres["distances"] = distances[:, 0] + qres["vertex_indices"] = indices[:, 0] + else: + qres["distances"], qres["vertex_indices"] = kdtree.query(input_points) + qres["nearest"] = target_points[qres["vertex_indices"], :] + + return qres + + +def nricp_sumner( + source_mesh, + target_geometry, + source_landmarks=None, + target_positions=None, + steps=None, + distance_threshold=0.1, + return_records=False, + use_faces=True, + use_vertex_normals=True, + neighbors_count=8, + face_pairs_type="vertex", +): + """ + Non Rigid Iterative Closest Points + + Implementation of the correspondence computation part of + "Sumner and Popovic 2004: Deformation Transfer for Triangle Meshes" + Allows to register non-rigidly a mesh on another geometry. + + Comparison between nricp_amberg and nricp_sumner: + * nricp_amberg fits to the target mesh in less steps + * nricp_amberg can generate sharp edges + * only vertices and their neighbors are considered + * nricp_sumner tend to preserve more the original shape + * nricp_sumner parameters are easier to tune + * nricp_sumner solves for triangle positions whereas + nricp_amberg solves for vertex transforms + * nricp_sumner is less optimized when wn > 0 + + Parameters + ---------- + source_mesh : Trimesh + Source mesh containing both vertices and faces. + target_geometry : Trimesh or PointCloud or (n, 3) float + Target geometry. It can contain no faces or be a PointCloud. + source_landmarks : (n,) int or ((n,) int, (n, 3) float) + n landmarks on the the source mesh. + Represented as vertex indices (n,) int. + It can also be represented as a tuple of triangle indices and barycentric + coordinates ((n,) int, (n, 3) float,). + target_positions : (n, 3) float + Target positions assigned to source landmarks + steps : Core parameters of the algorithm + Iterable of iterables (wc, wi, ws, wl, wn). + wc is the correspondence term (strength of fitting), wi is the identity term + (recommended value : 0.001), ws is smoothness term, wl weights the landmark + importance and wn the normal importance. + distance_threshold : float + Distance threshold to account for a vertex match or not. + return_records : bool + If True, also returns all the intermediate results. It can help debugging + and tune the parameters to match a specific case. + use_faces : bool + If True and if target geometry has faces, use proximity.closest_point to find + matching points. Else use scipy's cKDTree object. + use_vertex_normals : bool + If True and if target geometry has faces, interpolate the normals of the target + geometry matching points. + Else use face normals or estimated normals if target geometry has no faces. + neighbors_count : int + number of neighbors used for normal estimation. Only used if target geometry has + no faces or if use_faces is False. + face_pairs_type : str 'vertex' or 'edge' + Method to determine face pairs used in the smoothness cost. 'vertex' yields + smoother results. + + + Returns + ---------- + result : (n, 3) float or list[(n, 3) float] + The vertices positions of source_mesh such that it is registered non-rigidly + onto the target geometry. + If return_records is True, it returns the list of the vertex positions at each + iteration. + """ + + def _construct_transform_matrix(faces, Vinv, size): + # Utility function for constructing the per-frame transforms + _construct_transform_matrix._row = np.array([0, 1, 2] * 4) + nV = len(Vinv) + rows = np.tile(_construct_transform_matrix._row, nV) + 3 * np.repeat( + np.arange(nV), 12 + ) + cols = np.repeat(faces.flat, 3) + minus_inv_sum = -Vinv.sum(axis=1) + Vinv_flat = Vinv.reshape(nV, 9) + data = np.concatenate((minus_inv_sum, Vinv_flat), axis=-1).flatten() + return sparse.coo_matrix((data, (rows, cols)), shape=(3 * nV, size), dtype=float) + + def _build_tetrahedrons(mesh): + # UUtility function for constructing the frames + v4_vec = mesh.face_normals + v1 = mesh.triangles[:, 0] + v2 = mesh.triangles[:, 1] + v3 = mesh.triangles[:, 2] + v4 = v1 + v4_vec + vertices = np.concatenate((mesh.vertices, v4)) + nV, nT = len(mesh.vertices), len(mesh.faces) + v4_indices = np.arange(nV, nV + nT)[:, None] + tetrahedrons = np.concatenate((mesh.faces, v4_indices), axis=-1) + frames = np.concatenate( + ((v2 - v1)[..., None], (v3 - v1)[..., None], v4_vec[..., None]), axis=-1 + ) + return vertices, tetrahedrons, frames + + def _construct_identity_cost(vtet, tet, Vinv): + # Utility function for constructing the identity cost + AEi = _construct_transform_matrix( + tet, + Vinv, + len(vtet), + ).tocsr() + Bi = np.tile(np.identity(3, dtype=float), (len(tet), 1)) + return AEi, Bi + + def _construct_smoothness_cost(vtet, tet, Vinv, face_pairs): + # Utility function for constructing the smoothness (stiffness) cost + AEs_r = _construct_transform_matrix( + tet[face_pairs[:, 0]], Vinv[face_pairs[:, 0]], len(vtet) + ).tocsr() + AEs_l = _construct_transform_matrix( + tet[face_pairs[:, 1]], Vinv[face_pairs[:, 1]], len(vtet) + ).tocsr() + AEs = (AEs_r - AEs_l).tocsc() + AEs.eliminate_zeros() + Bs = np.zeros((len(face_pairs) * 3, 3)) + return AEs, Bs + + def _construct_landmark_cost(vtet, source_mesh, source_landmarks): + # Utility function for constructing the landmark cost + if source_landmarks is None: + return None, np.ones(len(source_mesh.vertices), dtype=bool) + if isinstance(source_landmarks, tuple): + # If the input source landmarks are in barycentric form + source_landmarks_tids, source_landmarks_barys = source_landmarks + source_landmarks_vids = source_mesh.faces[source_landmarks_tids] + nL, nVT = len(source_landmarks_tids), len(vtet) + + rows = np.repeat(np.arange(nL), 3) + cols = source_landmarks_vids.flat + data = source_landmarks_barys.flat + + AEl = sparse.coo_matrix((data, (rows, cols)), shape=(nL, nVT)) + marker_vids = source_landmarks_vids[ + source_landmarks_barys > np.finfo(np.float16).eps + ] + non_markers_mask = np.ones(len(source_mesh.vertices), dtype=bool) + non_markers_mask[marker_vids] = False + else: + # Else if they are in vertex index form + nL, nVT = len(source_landmarks), len(vtet) + rows = np.arange(nL) + cols = source_landmarks.flat + data = np.ones(nL) + AEl = sparse.coo_matrix((data, (rows, cols)), shape=(nL, nVT)) + non_markers_mask = np.ones(len(source_mesh.vertices), dtype=bool) + non_markers_mask[source_landmarks] = False + return AEl, non_markers_mask + + def _construct_correspondence_cost(points, non_markers_mask, size): + # Utility function for constructing the correspondence cost + AEc = sparse.identity(size, dtype=float, format="csc")[: len(non_markers_mask)] + AEc = AEc[non_markers_mask] + Bc = points[non_markers_mask] + return AEc, Bc + + def _compute_vertex_normals(vertices, faces): + # Utility function for computing source vertex normals + mesh_triangles = vertices[faces] + mesh_triangles_cross = cross(mesh_triangles) + mesh_face_normals = normals( + triangles=mesh_triangles, crosses=mesh_triangles_cross + )[0] + mesh_face_angles = angles(mesh_triangles) + mesh_normals = weighted_vertex_normals( + vertex_count=nV, + faces=faces, + face_normals=mesh_face_normals, + face_angles=mesh_face_angles, + ) + return mesh_normals + + # First, normalize the source and target to [-1, 1]^3 + (target_geometry, target_positions, centroid, scale) = _normalize_by_source( + source_mesh, target_geometry, target_positions + ) + nV = len(source_mesh.vertices) + use_landmarks = source_landmarks is not None and target_positions is not None + + if steps is None: + steps = [ + # [wc, wi, ws, wl, wn], + [1, 0.001, 1.0, 1000, 0], + [1, 0.001, 1.0, 1000, 0], + [10, 0.001, 1.0, 1000, 0], + [100, 0.001, 1.0, 1000, 0], + ] + + source_vtet, source_tet, V = _build_tetrahedrons(source_mesh) + Vinv = np.linalg.inv(V) + + # List of (n, 2) faces index which share a vertex + if face_pairs_type == "vertex": + face_pairs = source_mesh.face_neighborhood + else: + face_pairs = source_mesh.face_adjacency + + # Construct the cost matrices + # Identity cost (Eq. 12) + AEi, Bi = _construct_identity_cost(source_vtet, source_tet, Vinv) + # Smoothness cost (Eq. 11) + AEs, Bs = _construct_smoothness_cost(source_vtet, source_tet, Vinv, face_pairs) + # Landmark cost (Eq. 13) + AEl, non_markers_mask = _construct_landmark_cost( + source_vtet, source_mesh, source_landmarks + ) + + transformed_vertices = source_vtet.copy() + if return_records: + records = [transformed_vertices[:nV]] + + # Main loop + for i, (wc, wi, ws, wl, wn) in enumerate(steps): + Astack = [AEi * wi, AEs * ws] + Bstack = [Bi * wi, Bs * ws] + + if use_landmarks: + Astack.append(AEl * wl) + Bstack.append(target_positions * wl) + + if (i > 0 or not use_landmarks) and wc > 0: + # Query the nearest points + qres = _from_mesh( + target_geometry, + transformed_vertices[:nV], + from_vertices_only=not use_faces, + return_normals=wn > 0, + return_interpolated_normals=(use_vertex_normals and wn > 0), + neighbors_count=neighbors_count, + ) + + # Correspondence cost (Eq. 13) + AEc, Bc = _construct_correspondence_cost( + qres["nearest"], non_markers_mask, len(source_vtet) + ) + vertices_weight = np.ones(nV) + vertices_weight[qres["distances"] > distance_threshold] = 0 + if wn > 0 or "normals" in qres: + target_normals = qres["normals"] + if use_vertex_normals and "interpolated_normals" in qres: + target_normals = qres["interpolated_normals"] + # Normal weighting : multiplying weights by cosines^wn + source_normals = _compute_vertex_normals( + transformed_vertices, source_mesh.faces + ) + dot = util.diagonal_dot(source_normals, target_normals) + # Normal orientation is only known for meshes as target + dot = np.clip(dot, 0, 1) if use_faces else np.abs(dot) + vertices_weight = vertices_weight * dot**wn + + # Account for vertices' weight + AEc.data *= vertices_weight[non_markers_mask][AEc.indices] + Bc *= vertices_weight[non_markers_mask, None] + + Astack.append(AEc * wc) + Bstack.append(Bc * wc) + + # Now solve Eq. 14 ... + A = sparse.vstack(Astack, format="csc") + A.eliminate_zeros() + b = np.concatenate(Bstack) + + LU = sparse.linalg.splu((A.T * A).tocsc()) + transformed_vertices = LU.solve(A.T * b) + # done ! + + if return_records: + records.append(transformed_vertices[:nV]) + + if return_records: + result = records + else: + result = transformed_vertices[:nV] + + result = _denormalize_by_source( + source_mesh, target_geometry, target_positions, result, centroid, scale + ) + return result diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/remesh.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/remesh.py new file mode 100644 index 0000000000000000000000000000000000000000..1038af23854ea7219896b779dd287d810a0a9181 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/remesh.py @@ -0,0 +1,454 @@ +""" +remesh.py +------------- + +Deal with re- triangulation of existing meshes. +""" + +from itertools import zip_longest + +import numpy as np + +from . import graph, grouping +from .constants import tol +from .geometry import faces_to_edges + + +def subdivide( + vertices, faces, face_index=None, vertex_attributes=None, return_index=False +): + """ + Subdivide a mesh into smaller triangles. + + Note that if `face_index` is passed, only those + faces will be subdivided and their neighbors won't + be modified making the mesh no longer "watertight." + + Parameters + ------------ + vertices : (n, 3) float + Vertices in space + faces : (m, 3) int + Indexes of vertices which make up triangular faces + face_index : faces to subdivide. + if None: all faces of mesh will be subdivided + if (n,) int array of indices: only specified faces + vertex_attributes : dict + Contains (n, d) attribute data + return_index : bool + If True, return index of original face for new faces + + Returns + ---------- + new_vertices : (q, 3) float + Vertices in space + new_faces : (p, 3) int + Remeshed faces + index_dict : dict + Only returned if `return_index`, {index of + original face : index of new faces}. + """ + if face_index is None: + face_mask = np.ones(len(faces), dtype=bool) + else: + face_mask = np.zeros(len(faces), dtype=bool) + face_mask[face_index] = True + + # the (c, 3) int array of vertex indices + faces_subset = faces[face_mask] + + # find the unique edges of our faces subset + edges = np.sort(faces_to_edges(faces_subset), axis=1) + unique, inverse = grouping.unique_rows(edges) + # then only produce one midpoint per unique edge + mid = vertices[edges[unique]].mean(axis=1) + mid_idx = inverse.reshape((-1, 3)) + len(vertices) + + # the new faces_subset with correct winding + f = np.column_stack( + [ + faces_subset[:, 0], + mid_idx[:, 0], + mid_idx[:, 2], + mid_idx[:, 0], + faces_subset[:, 1], + mid_idx[:, 1], + mid_idx[:, 2], + mid_idx[:, 1], + faces_subset[:, 2], + mid_idx[:, 0], + mid_idx[:, 1], + mid_idx[:, 2], + ] + ).reshape((-1, 3)) + + # add the 3 new faces_subset per old face all on the end + # by putting all the new faces after all the old faces + # it makes it easier to understand the indexes + new_faces = np.vstack((faces[~face_mask], f)) + # stack the new midpoint vertices on the end + new_vertices = np.vstack((vertices, mid)) + + if vertex_attributes is not None: + new_attributes = {} + for key, values in vertex_attributes.items(): + if len(values) != len(vertices): + continue + attr_mid = values[edges[unique]].mean(axis=1) + new_attributes[key] = np.vstack((values, attr_mid)) + return new_vertices, new_faces, new_attributes + + if return_index: + # turn the mask back into integer indexes + nonzero = np.nonzero(face_mask)[0] + # new faces start past the original faces + # but we've removed all the faces in face_mask + start = len(faces) - len(nonzero) + # indexes are just offset from start + stack = np.arange(start, start + len(f) * 4).reshape((-1, 4)) + # reformat into a slightly silly dict for some reason + index_dict = dict(zip(nonzero, stack)) + + return new_vertices, new_faces, index_dict + + return new_vertices, new_faces + + +def subdivide_to_size(vertices, faces, max_edge, max_iter=10, return_index=False): + """ + Subdivide a mesh until every edge is shorter than a + specified length. + + Every edge longer than `max_edge` is bisected at a single shared + midpoint, so the two faces on either side stay in sync and a + watertight input stays watertight — no T-junctions (cracks) are + introduced. Faces already small enough are left untouched. + + Parameters + ------------ + vertices : (n, 3) float + Vertices in space + faces : (m, 3) int + Indices of vertices which make up triangles + max_edge : float + Maximum length of any edge in the result + max_iter : int + The maximum number of times to run subdivision + return_index : bool + If True, return index of original face for new faces + + Returns + ------------ + vertices : (j, 3) float + Vertices in space + faces : (q, 3) int + Indices of vertices + index : (q,) int + Only returned if `return_index`, index of + original face for each new face. + """ + # copy inputs and make sure dtype is correct + vertices = np.array(vertices, dtype=np.float64, copy=True) + faces = np.array(faces, dtype=np.int64, copy=True) + # map each current face back to its original face index + index = np.arange(len(faces)) + + for i in range(max_iter + 1): + # the unique edges of the current mesh and the length of each + edges = np.sort(faces_to_edges(faces), axis=1) + unique, inverse = grouping.unique_rows(edges) + edges_unique = edges[unique] + # length uses xyz only — callers may hstack extra columns (e.g. uv) + lengths = ( + (vertices[edges_unique[:, 0], :3] - vertices[edges_unique[:, 1], :3]) ** 2 + ).sum(axis=1) ** 0.5 + long_edge = lengths > max_edge + + # every edge is short enough so we're done + if not long_edge.any(): + break + # check max_iter before refining again + if i >= max_iter: + raise ValueError("max_iter exceeded!") + + # one shared midpoint vertex per long edge, -1 where left intact + midpoint = np.full(len(unique), -1, dtype=np.int64) + midpoint[long_edge] = np.arange(int(long_edge.sum())) + len(vertices) + vertices = np.vstack((vertices, vertices[edges_unique[long_edge]].mean(axis=1))) + + # midpoint id for each face's 3 edges, columns (v0v1, v1v2, v2v0) + face_mid = midpoint[inverse].reshape((-1, 3)) + split = face_mid >= 0 + # number of edges marked for bisection on each face: 0, 1, 2, or 3 + count = split.sum(axis=1) + + # 0 marked edges — face passes through unchanged + keep = count == 0 + faces_keep = faces[keep] + index_keep = index[keep] + + # 1 marked edge — rotate so the split edge is (a, b) so a single + # template handles all three cases: fan the midpoint to the + # opposite vertex as [a, p, c], [p, b, c] + one = count == 1 + j = np.argmax(split[one], axis=1) + r = np.arange(len(j)) + f1, mid1 = faces[one], face_mid[one] + a, b, c = f1[r, j], f1[r, (j + 1) % 3], f1[r, (j + 2) % 3] + p = mid1[r, j] + faces_one = np.column_stack((a, p, c, p, b, c)).reshape((-1, 3)) + index_one = np.repeat(index[one], 2) + + # 2 marked edges — rotate so the unsplit edge is (c, a), again so + # one template covers all three cases: a corner triangle [p, b, q] + # plus the quad (a, p, q, c) cut along its shorter diagonal + two = count == 2 + j = (np.argmin(split[two], axis=1) + 1) % 3 + r = np.arange(len(j)) + f2, mid2 = faces[two], face_mid[two] + a, b, c = f2[r, j], f2[r, (j + 1) % 3], f2[r, (j + 2) % 3] + p, q = mid2[r, j], mid2[r, (j + 1) % 3] + # the shorter of the two quad diagonals: a-q versus p-c (xyz only) + use_aq = ( + ((vertices[a, :3] - vertices[q, :3]) ** 2).sum(axis=1) + <= ((vertices[p, :3] - vertices[c, :3]) ** 2).sum(axis=1) + )[:, None] + corner = np.column_stack((p, b, q)) + quad_a = np.where(use_aq, np.column_stack((a, p, q)), np.column_stack((a, p, c))) + quad_b = np.where(use_aq, np.column_stack((a, q, c)), np.column_stack((p, q, c))) + faces_two = np.vstack((corner, quad_a, quad_b)) + index_two = np.tile(index[two], 3) + + # 3 marked edges — the regular 1 -> 4 split, same winding as subdivide + three = count == 3 + f3, mid3 = faces[three], face_mid[three] + v0, v1, v2 = f3.T + m0, m1, m2 = mid3.T + faces_three = np.column_stack( + (v0, m0, m2, m0, v1, m1, m2, m1, v2, m0, m1, m2) + ).reshape((-1, 3)) + index_three = np.repeat(index[three], 4) + + faces = np.vstack((faces_keep, faces_one, faces_two, faces_three)).astype( + np.int64 + ) + index = np.concatenate((index_keep, index_one, index_two, index_three)) + + if return_index: + assert len(index) == len(faces) + return vertices, faces, index + + return vertices, faces + + +def subdivide_loop(vertices, faces, iterations=None): + """ + Subdivide a mesh by dividing each triangle into four triangles + and approximating their smoothed surface (loop subdivision). + This function is an array-based implementation of loop subdivision, + which avoids slow for loop and enables faster calculation. + + Overall process: + 1. Calculate odd vertices. + Assign a new odd vertex on each edge and + calculate the value for the boundary case and the interior case. + The value is calculated as follows. + v2 + / f0 \\ 0 + v0--e--v1 / \\ + \\f1 / v0--e--v1 + v3 + - interior case : 3:1 ratio of mean(v0,v1) and mean(v2,v3) + - boundary case : mean(v0,v1) + 2. Calculate even vertices. + The new even vertices are calculated with the existing + vertices and their adjacent vertices. + 1---2 + / \\/ \\ 0---1 + 0---v---3 / \\/ \\ + \\ /\\/ b0---v---b1 + k...4 + - interior case : (1-kB):B ratio of v and k adjacencies + - boundary case : 3:1 ratio of v and mean(b0,b1) + 3. Compose new faces with new vertices. + + Parameters + ------------ + vertices : (n, 3) float + Vertices in space + faces : (m, 3) int + Indices of vertices which make up triangles + + Returns + ------------ + vertices : (j, 3) float + Vertices in space + faces : (q, 3) int + Indices of vertices + iterations : int + Number of iterations to run subdivision + """ + if iterations is None: + iterations = 1 + + def _subdivide(vertices, faces): + # find the unique edges of our faces + edges, edges_face = faces_to_edges(faces, return_index=True) + edges.sort(axis=1) + unique, inverse = grouping.unique_rows(edges) + + # set interior edges if there are two edges and boundary if there is + # one. + edge_inter = np.sort(grouping.group_rows(edges, require_count=2), axis=1) + edge_bound = grouping.group_rows(edges, require_count=1) + # make sure that one edge is shared by only one or two faces. + if not len(edge_inter) * 2 + len(edge_bound) == len(edges): + # we have multiple bodies it's a party! + # edges shared by 2 faces are "connected" + # so this connected components operation is + # essentially identical to `face_adjacency` + faces_group = graph.connected_components(edges_face[edge_inter]) + + if len(faces_group) == 1: + raise ValueError("Some edges are shared by more than 2 faces") + + # collect a subdivided copy of each body + seq_verts = [] + seq_faces = [] + # keep track of vertex count as we go so + # we can do a single vstack at the end + count = 0 + # loop through original face indexes + for f in faces_group: + # a lot of the complexity in this operation + # is computing vertex neighbors so we only + # want to pass forward the referenced vertices + # for this particular group of connected faces + unique, inverse = grouping.unique_bincount( + faces[f].reshape(-1), return_inverse=True + ) + + # subdivide this subset of faces + cur_verts, cur_faces = _subdivide( + vertices=vertices[unique], faces=inverse.reshape((-1, 3)) + ) + + # increment the face references to match + # the vertices when we stack them later + cur_faces += count + # increment the total vertex count + count += len(cur_verts) + # append to the sequence + seq_verts.append(cur_verts) + seq_faces.append(cur_faces) + + # return results as clean (n, 3) arrays + return np.vstack(seq_verts), np.vstack(seq_faces) + + # set interior, boundary mask for unique edges + edge_bound_mask = np.zeros(len(edges), dtype=bool) + edge_bound_mask[edge_bound] = True + edge_bound_mask = edge_bound_mask[unique] + edge_inter_mask = ~edge_bound_mask + + # find the opposite face for each edge + edge_pair = np.zeros(len(edges)).astype(int) + edge_pair[edge_inter[:, 0]] = edge_inter[:, 1] + edge_pair[edge_inter[:, 1]] = edge_inter[:, 0] + opposite_face1 = edges_face[unique] + opposite_face2 = edges_face[edge_pair[unique]] + + # set odd vertices to the middle of each edge (default as boundary + # case). + odd = vertices[edges[unique]].mean(axis=1) + # modify the odd vertices for the interior case + e = edges[unique[edge_inter_mask]] + e_v0 = vertices[e][:, 0] + e_v1 = vertices[e][:, 1] + e_f0 = faces[opposite_face1[edge_inter_mask]] + e_f1 = faces[opposite_face2[edge_inter_mask]] + e_v2_idx = e_f0[~(e_f0[:, :, None] == e[:, None, :]).any(-1)] + e_v3_idx = e_f1[~(e_f1[:, :, None] == e[:, None, :]).any(-1)] + e_v2 = vertices[e_v2_idx] + e_v3 = vertices[e_v3_idx] + + # simplified from: + # # 3 / 8 * (e_v0 + e_v1) + 1 / 8 * (e_v2 + e_v3) + odd[edge_inter_mask] = 0.375 * e_v0 + 0.375 * e_v1 + e_v2 / 8.0 + e_v3 / 8.0 + + # find vertex neighbors of each vertex + neighbors = graph.neighbors(edges=edges[unique], max_index=len(vertices)) + # convert list type of array into a fixed-shaped numpy array (set -1 to + # empties) + neighbors = np.array(list(zip_longest(*neighbors, fillvalue=-1))).T + # if the neighbor has -1 index, its point is (0, 0, 0), so that + # it is not included in the summation of neighbors when calculating the + # even + vertices_ = np.vstack([vertices, [0.0, 0.0, 0.0]]) + # number of neighbors + k = (neighbors + 1).astype(bool).sum(axis=1) + + # calculate even vertices for the interior case + even = np.zeros_like(vertices) + + # beta = 1 / k * (5 / 8 - (3 / 8 + 1 / 4 * np.cos(2 * np.pi / k)) ** 2) + # simplified with sympy.parse_expr('...').simplify() + beta = (40.0 - (2.0 * np.cos(2 * np.pi / k) + 3) ** 2) / (64 * k) + even = ( + beta[:, None] * vertices_[neighbors].sum(1) + + (1 - k[:, None] * beta[:, None]) * vertices + ) + + # calculate even vertices for the boundary case + if edge_bound_mask.any(): + # boundary vertices from boundary edges + vrt_bound_mask = np.zeros(len(vertices), dtype=bool) + vrt_bound_mask[np.unique(edges[unique][~edge_inter_mask])] = True + # one boundary vertex has two neighbor boundary vertices (set + # others as -1) + boundary_neighbors = neighbors[vrt_bound_mask] + boundary_neighbors[~vrt_bound_mask[neighbors[vrt_bound_mask]]] = -1 + + even[vrt_bound_mask] = ( + vertices_[boundary_neighbors].sum(axis=1) / 8.0 + + (3.0 / 4.0) * vertices[vrt_bound_mask] + ) + + # the new faces with odd vertices + odd_idx = inverse.reshape((-1, 3)) + len(vertices) + new_faces = np.column_stack( + [ + faces[:, 0], + odd_idx[:, 0], + odd_idx[:, 2], + odd_idx[:, 0], + faces[:, 1], + odd_idx[:, 1], + odd_idx[:, 2], + odd_idx[:, 1], + faces[:, 2], + odd_idx[:, 0], + odd_idx[:, 1], + odd_idx[:, 2], + ] + ).reshape((-1, 3)) + + # stack the new even vertices and odd vertices + new_vertices = np.vstack((even, odd)) + + return new_vertices, new_faces + + for _ in range(iterations): + vertices, faces = _subdivide(vertices, faces) + + if tol.strict or True: + assert np.isfinite(vertices).all() + assert np.isfinite(faces).all() + # should raise if faces are malformed + assert np.isfinite(vertices[faces]).all() + + # none of the faces returned should be degenerate + # i.e. every face should have 3 unique vertices + assert (faces[:, 1:] != faces[:, :1]).all() + + return vertices, faces diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/rendering.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/rendering.py new file mode 100644 index 0000000000000000000000000000000000000000..6585711f774d38ee701d42db1b332d738e48c740 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/rendering.py @@ -0,0 +1,417 @@ +""" +rendering.py +-------------- + +Functions to convert trimesh objects to pyglet/opengl objects. +""" + +import numpy as np + +from . import util + +# avoid importing pyglet or pyglet.gl +# as pyglet does things on import +GL_POINTS, GL_LINES, GL_TRIANGLES = (0, 1, 4) + + +def convert_to_vertexlist(geometry, **kwargs): + """ + Try to convert various geometry objects to the constructor + args for a pyglet indexed vertex list. + + Parameters + ------------ + obj : Trimesh, Path2D, Path3D, (n,2) float, (n,3) float + Object to render + + Returns + ------------ + args : tuple + Args to be passed to pyglet indexed vertex list + constructor. + """ + if util.is_instance_named(geometry, "Trimesh"): + return mesh_to_vertexlist(geometry, **kwargs) + elif util.is_instance_named(geometry, "Path"): + # works for Path3D and Path2D + # both of which inherit from Path + return path_to_vertexlist(geometry, **kwargs) + elif util.is_instance_named(geometry, "PointCloud"): + # pointcloud objects contain colors + return points_to_vertexlist(geometry.vertices, colors=geometry.colors, **kwargs) + elif util.is_instance_named(geometry, "ndarray"): + # (n,2) or (n,3) points + return points_to_vertexlist(geometry, **kwargs) + elif util.is_instance_named(geometry, "VoxelGrid"): + # for voxels view them as a bunch of boxes + return mesh_to_vertexlist(geometry.as_boxes(**kwargs), **kwargs) + else: + raise ValueError("Geometry passed is not a viewable type!") + + +def mesh_to_vertexlist(mesh, group=None, smooth=True, smooth_threshold=60000): + """ + Convert a Trimesh object to arguments for an + indexed vertex list constructor. + + Parameters + ------------- + mesh : trimesh.Trimesh + Mesh to be rendered + group : str + Rendering group for the vertex list + smooth : bool + Should we try to smooth shade the mesh + smooth_threshold : int + Maximum number of faces to smooth shade + + Returns + -------------- + args : (7,) tuple + Args for vertex list constructor + + """ + # nominally support 2D vertices + if len(mesh.vertices.shape) == 2 and mesh.vertices.shape[1] == 2: + vertices = np.column_stack((mesh.vertices, np.zeros(len(mesh.vertices)))) + else: + vertices = mesh.vertices + + if hasattr(mesh.visual, "uv"): + # if the mesh has texture defined pass it to pyglet + vertex_count = len(vertices) + normals = mesh.vertex_normals + faces = mesh.faces + + # get the per-vertex UV coordinates + uv = mesh.visual.uv + + # shortcut for the material + material = mesh.visual.material + if hasattr(material, "image"): + # does the material actually have an image specified + no_image = material.image is None + elif hasattr(material, "baseColorTexture"): + no_image = material.baseColorTexture is None + else: + no_image = True + + # didn't get valid texture so skip it + if uv is None or no_image or len(uv) != vertex_count: + # if no UV coordinates on material, just set face colors + # to the diffuse color of the material + color_gl = colors_to_gl(material.main_color, vertex_count) + else: + # if someone passed (n, 3) UVR cut it off here + if uv.shape[1] > 2: + uv = uv[:, :2] + # texcoord as (2,) float + color_gl = ("t2f/static", uv.astype(np.float64).reshape(-1).tolist()) + + elif smooth and len(mesh.faces) < smooth_threshold: + # if we have a small number of faces and colors defined + # smooth the mesh by merging vertices of faces below + # the threshold angle + smooth = mesh.smooth_shaded + vertices = smooth.vertices + vertex_count = len(vertices) + normals = smooth.vertex_normals + faces = smooth.faces + color_gl = colors_to_gl(smooth.visual.vertex_colors, vertex_count) + else: + # we don't have textures or want to smooth so + # send a polygon soup of disconnected triangles to opengl + vertex_count = len(mesh.faces) * 3 + normals = np.tile(mesh.face_normals, (1, 3)) + vertices = vertices[mesh.faces] + faces = np.arange(vertex_count, dtype=np.int64) + colors = np.tile(mesh.visual.face_colors, (1, 3)).reshape((-1, 4)) + color_gl = colors_to_gl(colors, vertex_count) + + # create the ordered tuple for pyglet, use like: + # `batch.add_indexed(*args)` + args = ( + vertex_count, # number of vertices + GL_TRIANGLES, # mode + group, # group + faces.reshape(-1).tolist(), # indices + ("v3f/static", vertices.reshape(-1).tolist()), + ("n3f/static", normals.reshape(-1).tolist()), + color_gl, + ) + + return args + + +def path_to_vertexlist(path, group=None, **kwargs): + """ + Convert a Path3D object to arguments for a + pyglet indexed vertex list constructor. + + Parameters + ------------- + path : trimesh.path.Path3D object + Mesh to be rendered + group : str + Rendering group for the vertex list + + Returns + -------------- + args : (7,) tuple + Args for vertex list constructor + """ + # avoid cache check inside tight loop + vertices = path.vertices + + # get (n, 2, (2|3)) lines + stacked = [util.stack_lines(e.discrete(vertices)) for e in path.entities] + lines = util.vstack_empty(stacked) + count = len(lines) + + # stack zeros for 2D lines + if util.is_shape(vertices, (-1, 2)): + lines = lines.reshape((-1, 2)) + lines = np.column_stack((lines, np.zeros(len(lines)))) + # index for GL is one per point + index = np.arange(count).tolist() + # convert from entity color to the color of + # each vertex in the line segments + colors = path.colors + if colors is not None: + colors = np.vstack( + [ + (np.ones((len(s), 4)) * c).astype(np.uint8) + for s, c in zip(stacked, path.colors) + ] + ) + # convert to gl-friendly colors + gl_colors = colors_to_gl(colors, count=count) + + # collect args for vertexlist constructor + args = ( + count, # number of lines + GL_LINES, # mode + group, # group + index, # indices + ("v3f/static", lines.reshape(-1)), + gl_colors, + ) + return args + + +def points_to_vertexlist(points, colors=None, group=None, **kwargs): + """ + Convert a numpy array of 3D points to args for + a vertex list constructor. + + Parameters + ------------- + points : (n, 3) float + Points to be rendered + colors : (n, 3) or (n, 4) float + Colors for each point + group : str + Rendering group for the vertex list + + Returns + -------------- + args : (7,) tuple + Args for vertex list constructor + """ + points = np.asanyarray(points, dtype=np.float64) + + if util.is_shape(points, (-1, 2)): + points = np.column_stack((points, np.zeros(len(points)))) + elif not util.is_shape(points, (-1, 3)): + raise ValueError("Pointcloud must be (n,3)!") + + index = np.arange(len(points)).tolist() + + args = ( + len(points), # number of vertices + GL_POINTS, # mode + group, # group + index, # indices + ("v3f/static", points.reshape(-1)), + colors_to_gl(colors, len(points)), + ) + return args + + +def colors_to_gl(colors, count): + """ + Given a list of colors (or None) return a GL-acceptable + list of colors. + + Parameters + ------------ + colors: (count, (3 or 4)) float + Input colors as an array + + Returns + --------- + colors_type : str + Color type + colors_gl : (count,) list + Colors to pass to pyglet + """ + + colors = np.asanyarray(colors) + count = int(count) + # get the GL kind of color we have + colors_dtypes = {"f": "f", "i": "B", "u": "B"} + + if colors.dtype.kind in colors_dtypes: + dtype = colors_dtypes[colors.dtype.kind] + else: + dtype = None + + if dtype is not None and util.is_shape(colors, (count, (3, 4))): + # save the shape and dtype for opengl color string + colors_type = f"c{colors.shape[1]}{dtype}/static" + # reshape the 2D array into a 1D one and then convert to a python list + gl_colors = colors.reshape(-1).tolist() + elif dtype is not None and colors.shape in [(3,), (4,)]: + # we've been passed a single color so tile them + gl_colors = ( + (np.ones((count, colors.size), dtype=colors.dtype) * colors) + .reshape(-1) + .tolist() + ) + # we know we're tiling + colors_type = f"c{colors.size}{dtype}/static" + else: + # case where colors are wrong shape + # use black as the default color + gl_colors = np.tile([0.0, 0.0, 0.0], (count, 1)).reshape(-1).tolist() + # we're returning RGB float colors + colors_type = "c3f/static" + + return colors_type, gl_colors + + +def material_to_texture(material, upsize=True): + """ + Convert a trimesh.visual.texture.Material object into + a pyglet-compatible texture object. + + Parameters + -------------- + material : trimesh.visual.texture.Material + Material to be converted + upsize: bool + If True, will upscale textures to their nearest power + of two resolution to avoid weirdness + + Returns + --------------- + texture : pyglet.image.Texture + Texture loaded into pyglet form + """ + import pyglet + + # try to extract a PIL image from material + if hasattr(material, "image"): + img = material.image + elif hasattr(material, "baseColorTexture"): + img = material.baseColorTexture + else: + return None + + # if no images in texture return now + if img is None: + return None + + # if we're not powers of two upsize + if upsize: + from .visual.texture import power_resize + + img = power_resize(img) + + # use a PNG export to exchange into pyglet + # probably a way to do this with a PIL converter + with util.BytesIO() as f: + # export PIL image as PNG + img.save(f, format="png") + f.seek(0) + # filename used for format guess + gl_image = pyglet.image.load(filename=".png", file=f) + + # turn image into pyglet texture + texture = gl_image.get_texture() + + return texture + + +def matrix_to_gl(matrix): + """ + Convert a numpy row-major homogeneous transformation matrix + to a flat column-major GLfloat transformation. + + Parameters + ------------- + matrix : (4,4) float + Row-major homogeneous transform + + Returns + ------------- + glmatrix : (16,) gl.GLfloat + Transform in pyglet format + """ + from pyglet import gl + + # convert to GLfloat, switch to column major and flatten to (16,) + return (gl.GLfloat * 16)(*np.array(matrix, dtype=np.float32).T.ravel()) + + +def vector_to_gl(array, *args): + """ + Convert an array and an optional set of args into a + flat vector of gl.GLfloat + """ + from pyglet import gl + + array = np.array(array) + if len(args) > 0: + array = np.append(array, args) + vector = (gl.GLfloat * len(array))(*array) + return vector + + +def light_to_gl(light, transform, lightN): + """ + Convert trimesh.scene.lighting.Light objects into + args for gl.glLightFv calls + + Parameters + -------------- + light : trimesh.scene.lighting.Light + Light object to be converted to GL + transform : (4, 4) float + Transformation matrix of light + lightN : int + Result of gl.GL_LIGHT0, gl.GL_LIGHT1, etc + + Returns + -------------- + multiarg : [tuple] + List of args to pass to gl.glLightFv eg: + [gl.glLightfb(*a) for a in multiarg] + """ + from pyglet import gl + + # convert color to opengl + gl_color = vector_to_gl(light.color.astype(np.float64) / 255.0) + assert len(gl_color) == 4 + + # cartesian translation from matrix + gl_position = vector_to_gl(transform[:3, 3]) + + # create the different position and color arguments + args = [ + (lightN, gl.GL_POSITION, gl_position), + (lightN, gl.GL_SPECULAR, gl_color), + (lightN, gl.GL_DIFFUSE, gl_color), + (lightN, gl.GL_AMBIENT, gl_color), + ] + return args diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/repair.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/repair.py new file mode 100644 index 0000000000000000000000000000000000000000..d1e35e90bea8d16b27cefb97bb085df3d2a54a88 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/repair.py @@ -0,0 +1,379 @@ +""" +repair.py +------------- + +Fill holes and fix winding and normals of meshes. +""" + +import numpy as np + +from . import graph, triangles +from .constants import log +from .geometry import faces_to_edges, triangulate_quads +from .graph import connected_components +from .grouping import group_rows, hashable_rows + +try: + import networkx as nx +except BaseException as E: + # create a dummy module which will raise the ImportError + # or other exception only when someone tries to use networkx + from .exceptions import ExceptionWrapper + + nx = ExceptionWrapper(E) + +try: + from .path.exchange.misc import faces_to_path +except BaseException as E: + from .exceptions import ExceptionWrapper + + faces_to_path = ExceptionWrapper(E) + + +def fix_winding(mesh): + """ + Traverse and change mesh faces in-place to make sure + winding is correct with edges on adjacent faces in + opposite directions. + + Parameters + ------------- + mesh : Trimesh + Source geometry to alter in-place. + """ + # anything we would fix is already done + if mesh.is_winding_consistent: + return + + graph_all = nx.from_edgelist(mesh.face_adjacency) + flipped = 0 + + faces = mesh.faces.view(np.ndarray).copy() + + # we are going to traverse the graph using BFS + # start a traversal for every connected component + for components in nx.connected_components(graph_all): + # get a subgraph for this component + g = graph_all.subgraph(components) + # get the first node in the graph in a way that works on nx's + # new API and their old API + start = next(iter(g.nodes())) + + # we traverse every pair of faces in the graph + # we modify mesh.faces and mesh.face_normals in place + for face_pair in nx.bfs_edges(g, start): + # for each pair of faces, we convert them into edges, + # find the edge that both faces share and then see if edges + # are reversed in order as you would expect + # (2, ) int + face_pair = np.ravel(face_pair) + # (2, 3) int + pair = faces[face_pair] + # (6, 2) int + edges = faces_to_edges(pair) + overlap = group_rows(np.sort(edges, axis=1), require_count=2) + if len(overlap) == 0: + # only happens on non-watertight meshes + continue + edge_pair = edges[overlap[0]] + if edge_pair[0][0] == edge_pair[1][0]: + # if the edges aren't reversed, invert the order of one face + flipped += 1 + faces[face_pair[1]] = faces[face_pair[1]][::-1] + + if flipped > 0: + mesh.faces = faces + + log.debug("flipped %d/%d edges", flipped, len(mesh.faces) * 3) + + +def fix_inversion(mesh, multibody: bool = False): + """ + Check to see if a mesh has normals pointing "out." + + Parameters + ------------- + mesh : trimesh.Trimesh + Mesh to fix in-place. + multibody : bool + If True will try to fix normals on every body + """ + + # we are not considering multiple bodies so we only need to + # do anything if the mesh is watertight and the volume is negative + if not multibody: + if mesh.is_watertight and mesh.volume < 0.0: + # this will make things worse for non-watertight meshes + mesh.invert() + return + + # get groups of connected faces + groups = connected_components(mesh.face_adjacency) + + # mask of faces to flip + flip = np.zeros(len(mesh.faces), dtype=bool) + + # save these to avoid thrashing cache in a loop + tri = mesh.triangles + cross = mesh.triangles_cross + # get the edges indexable as faces + face_edges = mesh.edges.reshape((-1, 6)) + + # loop through indexes of `mesh.faces` + for face_index in groups: + # we need watertight bodies to do anything so immediately + # skip anything smaller than 4 faces (tetrahedron) + if len(face_index) < 4: + continue + # check the watertightness and winding of this group + is_tight, is_wound = graph.is_watertight(face_edges[face_index].reshape((-1, 2))) + + # if we're not completely correct skip it as flipping faces will make it worse + if not (is_tight and is_wound): + continue + + # check the volume for just this body + volume = triangles.mass_properties( + tri[face_index], crosses=cross[face_index], skip_inertia=True + ).volume + # if that volume is negative it is either + # inverted or just total garbage + if volume < 0.0: + flip[face_index] = True + + # one or more faces needs flipping + if flip.any(): + if "face_normals" in mesh._cache: + # flip normals of necessary faces + normals = mesh.face_normals.copy() + normals[flip] *= -1.0 + else: + normals = None + # flip faces + mesh.faces[flip] = np.fliplr(mesh.faces[flip]) + # assign corrected normals + if normals is not None: + mesh.face_normals = normals + + +def fix_normals(mesh, multibody=False): + """ + Fix the winding and direction of a mesh face and + face normals in-place. + + Really only meaningful on watertight meshes but will orient all + faces and winding in a uniform way for non-watertight face + patches as well. + + Parameters + ------------- + mesh : trimesh.Trimesh + Mesh to fix normals on + multibody : bool + if True try to correct normals direction + on every body rather than just one + + Notes + -------------- + mesh.faces : will flip columns on inverted faces + """ + # traverse face adjacency to correct winding + fix_winding(mesh) + # check to see if a mesh is inverted + fix_inversion(mesh, multibody=multibody) + + +def broken_faces(mesh, color=None): + """ + Return the index of faces in the mesh which break the + watertight status of the mesh. + + Parameters + -------------- + mesh : trimesh.Trimesh + Mesh to check broken faces on + color: (4,) uint8 or None + Will set broken faces to this color if not None + + Returns + --------------- + broken : (n, ) int + Indexes of mesh.faces + """ + adjacency = nx.from_edgelist(mesh.face_adjacency) + broken = [k for k, v in dict(adjacency.degree()).items() if v != 3] + broken = np.array(broken) + if color is not None and broken.size != 0: + # if someone passed a broken color + color = np.array(color) + if not (color.shape == (4,) or color.shape == (3,)): + color = [255, 0, 0, 255] + mesh.visual.face_colors[broken] = color + return broken + + +def fill_holes(mesh, use_fan: bool = False): + """ + Fill boundary holes in-place using fans, which may result + in bad answers if the holes are non convex! + + Face colors and attributes will be padded with default values + so shapes match. + + Parameters + ---------- + mesh : trimesh.Trimesh + Mesh will be repaired in-place. + use_fan + If passed, holes larger than quads will be triangulated + using fans which are only valid for non-convex holes. + """ + if len(mesh.faces) < 3: + return False + if mesh.is_watertight: + return True + + # any edge that occurs once is on the boundary + boundary_groups = group_rows(mesh.edges_sorted, require_count=1) + # either watertight or broken in a weird way + if len(boundary_groups) < 3: + return False + + # ordered edges on the boundary + boundary = mesh.edges[boundary_groups] + + # use networkx to find cycles of boundary edges + holes = nx.cycle_basis(nx.from_edgelist(boundary)) + + # this handles mixed tris, quads, and arbitrary polygons + new_faces = triangulate_quads(holes, use_fan=use_fan) + if len(new_faces) == 0: + return False + + # now we need to fix the winding for every new face + new_edges = faces_to_edges(new_faces) + + # the hashable rows for the mesh boundary edges + # and the boundary of the original hole in the mesh + # a well-constructed mesh has edges that are REVERSED + # so we're going to try a cheap indexing operation + hashable_new = hashable_rows(new_edges) + hashable_old = hashable_rows(boundary) + + # the magic trick: if any ordered edge of the NEW face is contained + # in the OLD boundary edges, it means the new face has edges that + # are in the same order as the boundary, and that new face + # needs to be reversed and since new_edges has exactly three + # edges per triangle we can compact indexes back to triangles + needs_reverse = np.isin(hashable_new, hashable_old).reshape((-1, 3)).any(axis=1) + + # now we have some shiny new faces that might even be wound correctly! + new_faces[needs_reverse] = np.fliplr(new_faces[needs_reverse]) + + # do the bookkeeping to preserve face normals and pad attributes + mesh.extend_faces(new_faces) + + return mesh.is_watertight + + +def stitch(mesh, faces=None, insert_vertices=False): + """ + Create a fan stitch over the boundary of the specified + faces. If the boundary is non-convex a triangle fan + is going to be extremely wonky. + + Parameters + ----------- + mesh : trimesh.Trimesh + Mesh to create fan stitch on. + faces : (n,) int + Face indexes to stitch with triangle fans. + insert_vertices : bool + Allow stitching to insert new vertices? + + Returns + ---------- + fan : (m, 3) int + New triangles referencing mesh.vertices. + vertices : (p, 3) float + Inserted vertices (only returned `if insert_vertices`) + """ + if faces is None: + faces = np.arange(len(mesh.faces)) + + # get a sequence of vertex indices representing the + # boundary of the specified faces + # will be referencing the same indexes of `mesh.vertices` + points = [ + e.points + for e in faces_to_path(mesh, faces)["entities"] + if len(e.points) > 3 and e.points[0] == e.points[-1] + ] + + # get properties to avoid querying in loop + vertices = mesh.vertices + normals = mesh.face_normals + + # find which faces are associated with an edge + edges_face = mesh.edges_face + tree_edge = mesh.edges_sorted_tree + + if insert_vertices: + # create one new vertex per curve at the centroid + centroids = np.array([vertices[p].mean(axis=0) for p in points]) + # save the original length of the vertices + count = len(vertices) + # for the normal check stack our local vertices + vertices = np.vstack((vertices, centroids)) + # create a triangle between our new centroid vertex + # and each one of the boundary curves + fan = [ + np.column_stack((np.ones(len(p) - 1, dtype=int) * (count + i), p[:-1], p[1:])) + for i, p in enumerate(points) + ] + else: + # since we're not allowed to insert new vertices + # create a triangle fan for each boundary curve + fan = [ + np.column_stack((np.ones(len(p) - 3, dtype=int) * p[0], p[1:-2], p[2:-1])) + for p in points + ] + + # now we do a normal check against an adjacent face + # to see if each region needs to be flipped + for i, t in zip(range(len(fan)), fan): + # get the edges from the original mesh + # for the first `n` new triangles + e = t[:10, 1:].copy() + e.sort(axis=1) + + # find which indexes of `mesh.edges` these + # new edges correspond with by finding edges + # that exactly correspond with the tree + query = tree_edge.query_ball_point(e, r=1e-10) + if len(query) == 0: + continue + # stack all the indices that exist + edge_index = np.concatenate(query) + + # get the normals from the original mesh + original = normals[edges_face[edge_index]] + + # calculate the normals for a few new faces + check, valid = triangles.normals(vertices[t[:3]]) + if not valid.any(): + continue + # take the first valid normal from our new faces + check = check[0] + + # if our new faces are reversed from the original + # Adjacent face flip them along their axis + sign = np.dot(original, check) + if sign.mean() < 0: + fan[i] = np.fliplr(t) + + fan = np.vstack(fan) + + if insert_vertices: + return fan, centroids + return fan diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resolvers.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resolvers.py new file mode 100644 index 0000000000000000000000000000000000000000..2e733694877b9411b8ac9548abbf01305fc0f33e --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resolvers.py @@ -0,0 +1,710 @@ +""" +resolvers.py +--------------- + +Provides a common interface to load assets referenced by name +like MTL files, texture images, etc. Assets can be from ZIP +archives, web assets, or a local file path. +""" + +import abc +import itertools +import os +from pathlib import Path +from typing import TypeAlias + +# URL parsing for remote resources via WebResolver +from urllib.parse import urlparse + +from . import caching, util +from .typed import HttpSessionLike, Mapping + + +class Resolver(util.ABC): + """ + The base class for resolvers. + """ + + @abc.abstractmethod + def __init__(self, *args, **kwargs): + raise NotImplementedError("Use a resolver subclass!") + + @abc.abstractmethod + def get(self, key): + raise NotImplementedError() + + @abc.abstractmethod + def write(self, name: str, data): + raise NotImplementedError("`write` not implemented!") + + @abc.abstractmethod + def namespaced(self, namespace: str): + raise NotImplementedError("`namespaced` not implemented!") + + @abc.abstractmethod + def keys(self): + raise NotImplementedError("`keys` not implemented!") + + def __getitem__(self, key: str): + return self.get(key) + + def __setitem__(self, key: str, value): + return self.write(key, value) + + def __contains__(self, key: str) -> bool: + return key in self.keys() + + +class FilePathResolver(Resolver): + """ + Resolve files from a source path on the file system. + """ + + def __init__(self, source: str, allow_anywhere: bool = False): + """ + Resolve files based on a source path. + + Parameters + ------------ + source : str + File path where mesh was loaded from + allow_anywhere : bool + If True allow assets to reference paths outside the + resolver root, i.e. `../textures/thing.png` — the + pre-5.0 behavior. + """ + # remove everything other than absolute path + clean = os.path.expanduser(os.path.abspath(str(source))) + + self.allow_anywhere = bool(allow_anywhere) + + self.clean = clean + if os.path.isdir(clean): + # if we were passed a directory use it + self.parent = clean + else: + # otherwise get the parent directory we've been passed + split = os.path.split(clean) + self.parent = split[0] + + # exit if directory doesn't exist + if not os.path.isdir(self.parent): + raise ValueError(f"path `{self.parent} `not a directory!") + + self.file_path = source + self.file_name = os.path.basename(source) + + def keys(self): + """ + List all files available to be loaded. + + Yields + ----------- + name : str + Name of a file which can be accessed. + """ + parent = self.parent + for path, _, names in os.walk(self.parent): + # strip any leading parent key + if path.startswith(parent): + path = path[len(parent) :] + # yield each name + for name in names: + yield os.path.join(path, name) + + def namespaced(self, namespace: str) -> "FilePathResolver": + """ + Return a resolver which changes the root of the + resolver by an added namespace. + + Parameters + ------------- + namespace : str + Probably a subdirectory + + Returns + -------------- + resolver : FilePathResolver + Resolver with root directory changed. + """ + return FilePathResolver( + os.path.join(self.parent, namespace), allow_anywhere=self.allow_anywhere + ) + + def absolute(self, name: str) -> Path: + """ + Resolve an asset name to an absolute path under the + resolver root. + + Parameters + ------------ + name : str + Name of an asset relative to the resolver root. + + Returns + ------------ + path : pathlib.Path + Absolute resolved path. + + Raises + ------------ + ValueError + If the path escapes the resolver root and + `allow_anywhere` was not set. + """ + parent = Path(self.parent).resolve() + path = (parent / name.strip()).resolve() + if not self.allow_anywhere and not path.is_relative_to(parent): + raise ValueError( + f"'{name}' escapes resolver root '{parent}' — pass " + + "`FilePathResolver(path, allow_anywhere=True)` to allow it" + ) + return path + + def get(self, name: str): + """ + Get an asset, restricted to the resolver root. + + Parameters + ------------- + name : str + Name of the asset. Must resolve inside the resolver root. + + Returns + ------------ + data : bytes + Loaded data from asset. + """ + candidates = ( + name.strip(), + name.strip().lstrip("/"), + os.path.split(name)[-1], + ) + for candidate in candidates: + try: + path = self.absolute(candidate) + except ValueError: + continue + if path.exists(): + with open(path, "rb") as f: + return f.read() + # if the requested name escaped the root this raises + # the actionable error instead of a plain not-found + self.absolute(name) + raise FileNotFoundError(name) + + def write(self, name: str, data: str | bytes): + """ + Write an asset to a file path, restricted to the resolver root. + + Parameters + ----------- + name : str + Name of the file to write. Must resolve inside the resolver root. + data : str or bytes + Data to write to the file. + """ + with open(self.absolute(name), "wb") as f: + # handle encodings correctly for str/bytes + util.write_encoded(file_obj=f, stuff=data) + + +class ZipResolver(Resolver): + """ + Resolve files inside a ZIP archive. + """ + + def __init__(self, archive: dict | None = None, namespace: str | None = None): + """ + Resolve files inside a ZIP archive as loaded by + trimesh.util.decompress + + Parameters + ------------- + archive : dict + Contains resources as file object + namespace : None or str + If passed will only show keys that start + with this value and this substring must be + removed for any get calls. + """ + self.archive = archive + if isinstance(namespace, str): + self.namespace = namespace.strip().rstrip("/") + "/" + else: + self.namespace = None + + def keys(self): + """ + Get the available keys in the current archive. + + Returns + ----------- + keys : iterable + Keys in the current archive. + """ + if self.namespace is not None: + namespace = self.namespace + length = len(namespace) + # only return keys that start with the namespace + # and strip off the namespace from the returned + # keys. + return [ + k[length:] + for k in self.archive.keys() + if k.startswith(namespace) and len(k) > length + ] + return self.archive.keys() + + def write(self, key: str, value) -> None: + """ + Store a value in the current archive. + + Parameters + ----------- + key : hashable + Key to store data under. + value : str, bytes, file-like + Value to store. + """ + if self.archive is None: + self.archive = {} + self.archive[key] = value + + def get(self, name: str) -> bytes: + """ + Get an asset from the ZIP archive. + + Parameters + ------------- + name : str + Name of the asset + + Returns + ------------- + data : bytes + Loaded data from asset + """ + # not much we can do with None + if name is None: + return + # make sure name is a string + if hasattr(name, "decode"): + name = name.decode("utf-8") + # store reference to archive inside this function + archive = self.archive + # requested name not identical in + # storage so attempt to recover + if name not in archive: + # loop through unique results + for option in nearby_names(name, self.namespace): + if option in archive: + # cleaned option is in archive + # so store value and exit + name = option + break + + # get the stored data + obj = archive[name] + # if the dict is storing data as bytes just return + if isinstance(obj, (bytes, str)): + return obj + # otherwise get it as a file object + # read file object from beginning + obj.seek(0) + # data is stored as a file object + data = obj.read() + obj.seek(0) + return data + + def namespaced(self, namespace: str) -> "ZipResolver": + """ + Return a "sub-resolver" with a root namespace. + + Parameters + ------------- + namespace : str + The root of the key to clip off, i.e. if + this resolver has key `a/b/c` you can get + 'a/b/c' with resolver.namespaced('a/b').get('c') + + Returns + ----------- + resolver : Resolver + Namespaced resolver. + """ + return ZipResolver(archive=self.archive, namespace=namespace) + + def export(self) -> bytes: + """ + Export the contents of the current archive as + a ZIP file. + + Returns + ------------ + compressed : bytes + Compressed data in ZIP format. + """ + return util.compress(self.archive) + + +class WebResolver(Resolver): + """ + Resolve assets from a remote URL. + """ + + def __init__( + self, + url: str, + session: HttpSessionLike | None = None, + timeout: float = 30.0, + ): + """ + Resolve assets from a base URL. + + Parameters + -------------- + url : str + Location where a mesh was stored or + directory where mesh was stored. + session : HttpSessionLike or None + Optional HTTP session used for fetches. Accepts + `httpx.Client` or `requests.Session`. + timeout : float + Per-request timeout in seconds. + """ + if hasattr(url, "decode"): + url = url.decode("utf-8") + + # parse string into namedtuple + parsed = urlparse(url) + # only http(s) is supported, reject `file://`, `gopher://`, etc. + if parsed.scheme not in ("http", "https"): + raise ValueError(f"scheme {parsed.scheme!r} not in ('http', 'https')") + + if session is None: + # an explicit session will be required in a future release + import warnings + + warnings.warn( + "`WebResolver` without a `session` is deprecated " + + "and will require one in a future release. " + + "pass an `httpx.Client` or `requests.Session`.", + category=DeprecationWarning, + stacklevel=2, + ) + + self.session = session + self.timeout = timeout + + # per-library request kwargs: httpx and requests disagree on + # the redirect kwarg name — this is also where any future + # library-specific options should live + library = "httpx" if session is None else type(session).__module__.split(".")[0] + if library == "httpx": + # also the bare httpx module fallback when no session was passed + self.request_kwargs = {"follow_redirects": True, "timeout": timeout} + elif library == "requests": + self.request_kwargs = {"allow_redirects": True, "timeout": timeout} + elif library == "aiohttp": + # an aiohttp session can only be constructed inside a running + # event loop and its connector binds to that loop, so a + # synchronous fetch can never legally drive one + raise ValueError( + "`aiohttp` sessions are async-only and bound to their creation " + + "loop: pass an `httpx.Client` or `requests.Session` instead" + ) + else: + # a duck-typed session gets `get(url)` with no assumed kwargs + self.request_kwargs = {} + + # we want a base url + split = [i for i in parsed.path.split("/") if len(i) > 0] + + # if the last item in the url path is a filename + # move up a "directory" for the base path + if len(split) == 0: + path = "" + elif "." in split[-1]: + # clip off last item + path = "/".join(split[:-1]) + else: + # recombine into string ignoring any double slashes + path = "/".join(split) + + # save the URL we were created with, i.e. + # `https://stuff.com/models/thing.glb` + self.url = url + # save the root url, i.e. `https://stuff.com/models` + self.base_url = ( + "/".join( + i + for i in [parsed.scheme + ":/", parsed.netloc.strip("/"), path.strip("/")] + if len(i) > 0 + ) + + "/" + ) + + # our string handling should have never inserted double slashes + assert "//" not in self.base_url[len(parsed.scheme) + 3 :] + # we should always have ended with a single slash + assert self.base_url.endswith("/") + + self.file_name = url.split("/")[-1] + + def get(self, name: str) -> bytes: + """ + Get a resource from the remote site. + + Parameters + ------------- + name : str + Asset name, i.e. 'quadknot.obj.mtl' + """ + import httpx + + # remove leading and trailing whitespace + name = name.strip() + + # the caller's session or the bare httpx module, both expose `.get` + client = self.session or httpx + response = client.get(self.base_url + name, **self.request_kwargs) + + if response.status_code >= 300: + # try to strip off filesystem crap + if name.startswith("./"): + name = name[2:] + response = client.get(self.base_url + name, **self.request_kwargs) + + # now raise if we don't have + response.raise_for_status() + + # return the bytes of the response + return response.content + + def get_base(self) -> bytes: + """ + Fetch the data at the full URL this resolver was + instantiated with, i.e. `https://stuff.com/hi.glb` + this will return the response. + + Returns + -------- + content + The value at `self.url` + """ + import httpx + + # just fetch the url we were created with + response = (self.session or httpx).get(self.url, **self.request_kwargs) + response.raise_for_status() + return response.content + + def namespaced(self, namespace: str) -> "WebResolver": + """ + Return a namespaced version of current resolver. + + Parameters + ------------- + namespace : str + URL fragment + + Returns + ----------- + resolver : WebResolver + With sub-url: `https://example.com/{namespace}` + """ + # propagate session/timeout so the child keeps the same posture + return WebResolver( + url=self.base_url + namespace, + session=self.session, + timeout=self.timeout, + ) + + def write(self, key, value): + raise NotImplementedError("`WebResolver` is read-only!") + + def keys(self): + raise NotImplementedError("`WebResolver` can't list keys") + + +class GithubResolver(Resolver): + def __init__( + self, + repo: str, + branch: str | None = None, + commit: str | None = None, + save: str | None = None, + session: HttpSessionLike | None = None, + timeout: float = 30.0, + ): + """ + Get files from a remote Github repository by + downloading a zip file with the entire branch + or a specific commit. + + Parameters + ------------- + repo + In the format of `owner/repo`. + branch + The remote branch you want to get files from. + commit + The full commit hash: pass either this OR branch. + save + A path if you want to save results locally. + session : HttpSessionLike or None + Optional HTTP session used for fetches. Accepts + `httpx.Client` or `requests.Session`. + timeout : float + Per-request timeout in seconds. + """ + + if commit is not None: + # just get the exact commit + self.url = f"https://github.com/{repo}/archive/{commit}.zip" + elif branch is not None: + # gets the latest commit on the specified branch. + self.url = f"https://github.com/{repo}/archive/refs/heads/{branch}.zip" + else: + raise ValueError("`commit` or `branch` must be passed!") + + # reuse the session handling and deprecation warning + self.resolver = WebResolver(url=self.url, session=session, timeout=timeout) + + if save is not None: + self.cache = caching.DiskCache(save) + else: + self.cache = None + + def keys(self): + """ + List the available files in the repository. + + Returns + ---------- + keys : iterable + Keys available to the resolved. + """ + return self.zipped.keys() + + def write(self, name, data): + raise NotImplementedError("`write` not implemented!") + + @property + def zipped(self) -> ZipResolver: + """ + - opened zip file + - locally saved zip file + - retrieve zip file and saved + """ + + if hasattr(self, "_zip"): + return self._zip + # download the archive or get from disc + raw = self.cache.get(self.url, self.resolver.get_base) + # create a zip resolver for the archive + # the root directory in the zip is the repo+commit so strip that off + # so the keys are usable, i.e. "models" instead of "trimesh-2232323/models" + self._zip = ZipResolver( + { + k.split("/", 1)[1]: v + for k, v in util.decompress( + util.wrap_as_stream(raw), file_type="zip" + ).items() + } + ) + + return self._zip + + def get(self, key): + return self.zipped.get(key) + + def namespaced(self, namespace): + """ + Return a "sub-resolver" with a root namespace. + + Parameters + ------------- + namespace : str + The root of the key to clip off, i.e. if + this resolver has key `a/b/c` you can get + 'a/b/c' with resolver.namespaced('a/b').get('c') + + Returns + ----------- + resolver : Resolver + Namespaced resolver. + """ + return self.zipped.namespaced(namespace) + + +def nearby_names(name, namespace=None): + """ + Try to find nearby variants of a specified name. + + Parameters + ------------ + name : str + Initial name. + + Yields + ----------- + nearby : str + Name that is a lightly permutated version + of the initial name. + """ + + # the various operations that *might* result in a correct key + def trim(prefix, item): + if item.startswith(prefix): + return item[len(prefix) :] + return item + + cleaners = [ + lambda x: x, + lambda x: x.strip(), + lambda x: trim("./", x), + lambda x: trim(".\\", x), + lambda x: trim("\\", x), + lambda x: os.path.split(x)[-1], + lambda x: x.replace("%20", " "), + ] + + if namespace is None: + namespace = "" + + # make sure we don't return repeat values + hit = set() + for f in cleaners: + # try just one cleaning function + current = f(name) + if current in hit: + continue + hit.add(current) + yield namespace + current + + for a, b in itertools.combinations(cleaners, 2): + # apply both clean functions + current = a(b(name)) + if current in hit: + continue + hit.add(current) + yield namespace + current + + # try applying in reverse order + current = b(a(name)) + if current in hit: + continue + hit.add(current) + yield namespace + current + + if ".." in name and namespace is not None: + # if someone specified relative paths give it one attempt + strip = namespace.strip("/").split("/")[: -name.count("..")] + strip.extend(name.split("..")[-1].strip("/").split("/")) + yield "/".join(strip) + + +# most loaders can use a mapping in addition to a resolver +ResolverLike: TypeAlias = Resolver | Mapping diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..dc767a69cd4459a83c3478ae0c760d2e1317d454 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/__init__.py @@ -0,0 +1,117 @@ +import gzip +import json +import os +from io import BytesIO + +# find the current absolute path to this directory +_pwd = os.path.expanduser(os.path.abspath(os.path.dirname(__file__))) +# once resources are loaded cache them +_cache = {} + + +def get_schema(name: str) -> dict: + """ + Load a schema and evaluate the referenced files. + + Parameters + ------------ + name : str + Filename of schema. + + Returns + ---------- + schema + Loaded and resolved schema. + """ + from ..resolvers import FilePathResolver + from ..schemas import resolve + + # get a resolver for our base path + resolver = FilePathResolver(os.path.join(_pwd, "schema", name)) + # recursively load `$ref` keys + return resolve(json.loads(resolver.get(name).decode("utf-8")), resolver=resolver) + + +def get_json(name: str) -> dict: + """ + Get a resource from the `trimesh/resources` folder as a decoded string. + + Parameters + ------------- + name : str + File path relative to `trimesh/resources/{name}` + + Returns + ------------- + resource + File data decoded from JSON. + """ + raw = get_bytes(name) + if name.endswith(".gzip"): + raw = gzip.decompress(raw) + else: + raw = raw.decode("utf-8") + return json.loads(raw) + + +def get_string(name: str) -> str: + """ + Get a resource from the `trimesh/resources` folder as a decoded string. + + Parameters + ------------- + name + File path relative to `trimesh/resources` + + Returns + ------------- + resource + File data as a string. + """ + return get_bytes(name).decode("utf-8") + + +def get_bytes(name: str) -> bytes: + """ + Get a resource from the `trimesh/resources` folder as binary data. + + Parameters + ------------- + name + File path relative to `trimesh/resources` + + Returns + ------------- + resource + File data as raw bytes. + """ + cached = _cache.get(name, None) + if cached is not None: + return cached + + # get the resource using relative names + # all templates are using POSIX relative paths + # so fix them to be platform-specific + with open(os.path.join(_pwd, *name.split("/")), "rb") as f: + resource = f.read() + + _cache[name] = resource + return resource + + +def get_stream(name: str) -> BytesIO: + """ + Get a resource from the `trimesh/resources` folder as a binary stream. + + Parameters + ------------- + name : str + File path relative to `trimesh/resources` + + Returns + ------------- + resource + File data as a binary stream. + """ + + return BytesIO(get_bytes(name)) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..710519319501ed549ae1af10fd00b919bc348f10 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/color_map.json.gzip b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/color_map.json.gzip new file mode 100644 index 0000000000000000000000000000000000000000..f55d4cc00f7282a34776c0486909e246b5007d87 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/color_map.json.gzip differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/creation.json b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/creation.json new file mode 100644 index 0000000000000000000000000000000000000000..91d55801503b9e2e3267e708474215bbad9b19cc --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/creation.json @@ -0,0 +1 @@ +{"box":{"vertices":[[0.0,0.0,0.0],[0.0,0.0,1.0],[0.0,1.0,0.0],[0.0,1.0,1.0],[1.0,0.0,0.0],[1.0,0.0,1.0],[1.0,1.0,0.0],[1.0,1.0,1.0]],"faces":[[1,3,0],[4,1,0],[0,3,2],[2,4,0],[1,7,3],[5,1,4],[5,7,1],[3,7,2],[6,4,2],[2,7,6],[6,5,4],[7,5,6]],"face_normals":[[-1,0,0],[0,-1,0],[-1,0,0],[0,0,-1],[0,0,1],[0,-1,0],[0,0,1],[0,1,0],[0,0,-1],[0,1,0],[1,0,0],[1,0,0]]},"icosahedron":{"vertices":[[-0.5257311121191336,0.85065080835204,0.0],[0.5257311121191336,0.85065080835204,0.0],[-0.5257311121191336,-0.85065080835204,0.0],[0.5257311121191336,-0.85065080835204,0.0],[0.0,-0.5257311121191336,0.85065080835204],[0.0,0.5257311121191336,0.85065080835204],[0.0,-0.5257311121191336,-0.85065080835204],[0.0,0.5257311121191336,-0.85065080835204],[0.85065080835204,0.0,-0.5257311121191336],[0.85065080835204,0.0,0.5257311121191336],[-0.85065080835204,0.0,-0.5257311121191336],[-0.85065080835204,0.0,0.5257311121191336]],"faces":[[0,11,5],[0,5,1],[0,1,7],[0,7,10],[0,10,11],[1,5,9],[5,11,4],[11,10,2],[10,7,6],[7,1,8],[3,9,4],[3,4,2],[3,2,6],[3,6,8],[3,8,9],[4,9,5],[2,4,11],[6,2,10],[8,6,7],[9,8,1]]}} \ No newline at end of file diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/README.md b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/README.md new file mode 100644 index 0000000000000000000000000000000000000000..13c3ff5421f477eac52575e6c6479c6120075197 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/README.md @@ -0,0 +1,5 @@ +# trimesh/resources/schemas + +Contain schemas for formats when available. They are currently mostly [JSON schema](https://json-schema.org/) although if formats have an XSD, DTD, or other schema format we are happy to include it here. + +The `primitive` schema directory is a [JSON schema](https://json-schema.org/) for `trimesh` exports. The goal is if we implement a `to_dict` method to have a well-defined schema we can validate in unit tests. diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/gltf2.schema.zip b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/gltf2.schema.zip new file mode 100644 index 0000000000000000000000000000000000000000..7e189603979bf9d6e0f727ebb0e2a93636cb1323 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/gltf2.schema.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cbd1699297e47bbd439885c93b6807e57e3f830b3b2d706fc3a94488eb308ca8 +size 24785 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/box.schema.json b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/box.schema.json new file mode 100644 index 0000000000000000000000000000000000000000..9227dadb1cf8f83548a6b8d6db34e97377360d92 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/box.schema.json @@ -0,0 +1,29 @@ +{ + "$id": "https://github.com/mikedh/trimesh/blob/main/trimesh/resources/schema/primitive/box.schema.json", + "$schema": "https://json-schema.org/draft/2020-12/schema", + "additionalProperties": false, + "description": "A 3D box primitive.", + "properties": { + "extents": { + "description": "The length of each side of the 3D box. The center of mass will be at the origin, and the minimum values will be at (-extents / 2) and the maximum values will be at (extents / 2).", + "items": { + "maxItems": 3, + "minItems": 3, + "type": "number" + }, + "type": "array" + }, + "kind": { + "pattern": "(^box$)", + "type": "string" + }, + "transform": { + "$ref": "transform.schema.json" + } + }, + "required": [ + "extents", + "kind" + ], + "type": "object" +} \ No newline at end of file diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/capsule.schema.json b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/capsule.schema.json new file mode 100644 index 0000000000000000000000000000000000000000..fc223c1a1f107bdba068ea8a1e2b54b66337873a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/capsule.schema.json @@ -0,0 +1,29 @@ +{ + "$id": "https://github.com/mikedh/trimesh/blob/main/trimesh/resources/schema/primitive/capsule.schema.json", + "$schema": "https://json-schema.org/draft/2020-12/schema", + "additionalProperties": false, + "description": "A 3D capsule primitive: a cylinder capped by tangent hemispheres.", + "properties": { + "height": { + "description": "The total height of the capsule including caps.", + "type": "number" + }, + "kind": { + "pattern": "(^capsule$)", + "type": "string" + }, + "radius": { + "description": "The radius of the cylinder and hemispherical caps.", + "type": "number" + }, + "transform": { + "$ref": "transform.schema.json" + } + }, + "required": [ + "radius", + "height", + "kind" + ], + "type": "object" +} \ No newline at end of file diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/cylinder.schema.json b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/cylinder.schema.json new file mode 100644 index 0000000000000000000000000000000000000000..e7e7e66b3a0f23fa14d057f0034f9c893ace56f1 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/cylinder.schema.json @@ -0,0 +1,29 @@ +{ + "$id": "https://github.com/mikedh/trimesh/blob/main/trimesh/resources/schema/primitive/cylinder.schema.json", + "$schema": "https://json-schema.org/draft/2020-12/schema", + "additionalProperties": false, + "description": "A 3D cylinder primitive.", + "properties": { + "height": { + "description": "The height of the cylinder along Z. The maximum Z value will be at (height / 2) and the minimum will be at (-height / 2)", + "type": "number" + }, + "kind": { + "pattern": "(^cylinder$)", + "type": "string" + }, + "radius": { + "description": "The radius of the cylinder.", + "type": "number" + }, + "transform": { + "$ref": "transform.schema.json" + } + }, + "required": [ + "radius", + "height", + "kind" + ], + "type": "object" +} \ No newline at end of file diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/extrusion.schema.json b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/extrusion.schema.json new file mode 100644 index 0000000000000000000000000000000000000000..5bbc23b05c5dcd9b30aab131ef90049c8b540bba --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/extrusion.schema.json @@ -0,0 +1,27 @@ +{ + "$id": "https://github.com/mikedh/trimesh/blob/main/trimesh/resources/schema/primitive/extrusion.schema.json", + "$schema": "https://json-schema.org/draft/2020-12/schema", + "additionalProperties": false, + "description": "A 2D polygon extruded from Z=0 along positive Z by `height` then transformed by the `transform` matrix.", + "properties": { + "height": { + "type": "number" + }, + "kind": { + "pattern": "(^extrusion$)", + "type": "string" + }, + "polygon": { + "$ref": "wkt.polygon.schema.json" + }, + "transform": { + "$ref": "transform.schema.json" + } + }, + "required": [ + "kind", + "polygon", + "height" + ], + "type": "object" +} \ No newline at end of file diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/primitive.schema.json b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/primitive.schema.json new file mode 100644 index 0000000000000000000000000000000000000000..f611c8304099218e5139ebc0c0908bd86cbd3f04 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/primitive.schema.json @@ -0,0 +1,22 @@ +{ + "$id": "https://github.com/mikedh/trimesh/blob/main/trimesh/resources/schema/primitive/primitive.schema.json", + "$schema": "https://json-schema.org/draft/2020-12/schema", + "anyOf": [ + { + "$ref": "box.schema.json" + }, + { + "$ref": "sphere.schema.json" + }, + { + "$ref": "capsule.schema.json" + }, + { + "$ref": "cylinder.schema.json" + }, + { + "$ref": "extrusion.schema.json" + } + ], + "description": "A geometric primitive." +} \ No newline at end of file diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/scenegraph.schema.json b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/scenegraph.schema.json new file mode 100644 index 0000000000000000000000000000000000000000..044aa5a47ced5fb01ca71767ac90ec0aab95f9b3 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/scenegraph.schema.json @@ -0,0 +1,25 @@ +{ + "$id": "https://github.com/mikedh/trimesh/blob/main/trimesh/resources/schema/primitive/scenegraph.schema.json", + "$schema": "https://json-schema.org/draft/2020-12/schema", + + "description": "A scene graph in the simplest possible JSON format.", + "type": "array", + "items": { + "type": "array", + "prefixItems": [ + { "type": "string", "description": "Node name of frame from." }, + { "type": "string", "description": "Node name of frame to." }, + { + "type": "object", + "additionalProperties": false, + "properties": { + "geometry": { + "type": "string", + "description": "Name of the geometry transformed to this frame." + }, + "matrix": { "$ref": "transform.schema.json" } + } + } + ] + } +} diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/sphere.schema.json b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/sphere.schema.json new file mode 100644 index 0000000000000000000000000000000000000000..92dd6b74f68282f1ad255c91356a42e2b6e43471 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/sphere.schema.json @@ -0,0 +1,23 @@ +{ + "$id": "https://github.com/mikedh/trimesh/blob/main/trimesh/resources/schema/primitive/sphere.schema.json", + "$schema": "https://json-schema.org/draft/2020-12/schema", + "additionalProperties": false, + "description": "A 3D sphere primitive.", + "properties": { + "kind": { + "pattern": "(^sphere$)", + "type": "string" + }, + "radius": { + "type": "number" + }, + "transform": { + "$ref": "transform.schema.json" + } + }, + "required": [ + "radius", + "kind" + ], + "type": "object" +} \ No newline at end of file diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/transform.schema.json b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/transform.schema.json new file mode 100644 index 0000000000000000000000000000000000000000..2e8a75ae4448addcd6fb7f9286a4448c24cea6e6 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/transform.schema.json @@ -0,0 +1,16 @@ +{ + "$id": "https://github.com/mikedh/trimesh/blob/main/trimesh/resources/schema/primitive/transform.schema.json", + "$schema": "https://json-schema.org/draft/2020-12/schema", + "description": "A homogeneous transformation matrix. If not passed it is assumed to be an identity matrix ", + "items": { + "items": { + "maxItems": 4, + "minItems": 4, + "type": "number" + }, + "maxItems": 4, + "minItems": 4, + "type": "array" + }, + "type": "array" +} \ No newline at end of file diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/trimesh.schema.json b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/trimesh.schema.json new file mode 100644 index 0000000000000000000000000000000000000000..58842deb9d6d1175983120eb47f718d44ad2a187 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/trimesh.schema.json @@ -0,0 +1,39 @@ +{ + "$id": "https://github.com/mikedh/trimesh/blob/main/trimesh/resources/schema/primitive/trimesh.schema.json", + "$schema": "https://json-schema.org/draft/2020-12/schema", + "additionalProperties": false, + "description": "A 3D triangular mesh in the simplest possible JSON format.", + "properties": { + "faces": { + "items": { + "items": { + "maxItems": 3, + "minItems": 3, + "type": "integer" + }, + "type": "array" + }, + "type": "array" + }, + "kind": { + "pattern": "(^trimesh$)", + "type": "string" + }, + "vertices": { + "items": { + "items": { + "maxItems": 3, + "minItems": 3, + "type": "number" + }, + "type": "array" + }, + "type": "array" + } + }, + "required": [ + "vertices", + "faces" + ], + "type": "object" +} \ No newline at end of file diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/wkt.polygon.schema.json b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/wkt.polygon.schema.json new file mode 100644 index 0000000000000000000000000000000000000000..d49947d5b1af7349f8c1c5f38b0c466aab8b0807 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/primitive/wkt.polygon.schema.json @@ -0,0 +1,7 @@ +{ + "$id": "https://github.com/mikedh/trimesh/blob/main/trimesh/resources/schema/primitive/wkt.polygon.schema.json", + "$schema": "https://json-schema.org/draft/2020-12/schema", + "description": "A single polygon in the Well Known Text format (WKT).", + "pattern": " *POLYGON *\\( *\\( *([+-]?([0-9]*[.])?[0-9]+([eE][+-]?[0-9]+)? *[+-]?([0-9]*[.])?[0-9]+([eE][+-]?[0-9]+)? *,* *)*\\) *\\) *", + "type": "string" +} \ No newline at end of file diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/urdf.xsd b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/urdf.xsd new file mode 100644 index 0000000000000000000000000000000000000000..ea21e2f13048bad464868604fe767331c20b3ad9 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/schema/urdf.xsd @@ -0,0 +1,324 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/base.svg b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/base.svg new file mode 100644 index 0000000000000000000000000000000000000000..d1761f9e8804badae2f4d03e3bb3af30a6259570 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/base.svg @@ -0,0 +1,10 @@ + +{elements} + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/blender_boolean.py.tmpl b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/blender_boolean.py.tmpl new file mode 100644 index 0000000000000000000000000000000000000000..209c6caf91cea8295f52bcc00e2717c0821ab676 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/blender_boolean.py.tmpl @@ -0,0 +1,67 @@ +# flake8: noqa + +import bpy +import os + + +def delete_nonresult(bpy): + objects = bpy.data.objects # use data.objects instead of context.scene.objects + if len(objects) <= 1: + return + + try: + # earlier than blender <2.8 + objects[0].select = False # keep the first object + for other in objects[1:]: # remove all other objects + other.select = True + bpy.ops.object.delete() + objects[0].select = True + except AttributeError: + # blender 2.8 changed this + objects[0].select_set(False) + for other in objects[1:]: + other.select_set(True) + bpy.ops.object.delete() + objects[0].select_set(True) + + +if __name__ == '__main__': + # clear scene of default box + bpy.ops.wm.read_homefile() + try: + bpy.ops.object.mode_set(mode='OBJECT') + except BaseException: + pass + bpy.ops.object.select_all(action='SELECT') + bpy.ops.object.delete(use_global=True) + + # get temporary files from templated locations + mesh_pre = $MESH_PRE + mesh_post = os.path.abspath(r'$MESH_POST') + + for filename in mesh_pre: # use data.objects instead of context.scene.objects + bpy.ops.wm.stl_import(filepath=os.path.abspath(filename)) + + mesh = bpy.data.objects[0] + # Make sure mesh is the active object + try: + # earlier than blender <2.8 + bpy.context.scene.objects.active = mesh + except AttributeError: + # blender 2.8 changed this + bpy.context.view_layer.objects.active = mesh + + for other in bpy.data.objects[1:]: + # add boolean modifier + mod = mesh.modifiers.new('boolean', 'BOOLEAN') + mod.object = other + mod.operation = '$OPERATION' + mod.solver = '$SOLVER_OPTIONS' + mod.use_self = $USE_SELF + # used mod.name instead of hard-coded "boolean" + bpy.ops.object.modifier_apply(modifier=mod.name) + + delete_nonresult(bpy) + bpy.ops.wm.stl_export( + filepath=mesh_post, + apply_modifiers=True) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/blender_unwrap.py.template b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/blender_unwrap.py.template new file mode 100644 index 0000000000000000000000000000000000000000..d1879bef81c98e5b41a2c70dfbb7a2376e179b36 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/blender_unwrap.py.template @@ -0,0 +1,40 @@ +# flake8: noqa + +import bpy +from bl_operators.uvcalc_smart_project import main as smart_proj +import os + + +if __name__ == '__main__': + # clear scene of default box + bpy.ops.wm.read_homefile() + try: + bpy.ops.object.mode_set(mode='OBJECT') + except BaseException: + pass + bpy.ops.object.select_all(action='SELECT') + bpy.ops.object.delete(use_global=True) + + # get temporary files from templated locations + mesh_pre = $MESH_PRE + mesh_post = os.path.abspath(r'$MESH_POST') + + # use data.objects instead of context.scene.objects + bpy.ops.import_scene.obj(filepath=os.path.abspath(mesh_pre[0])) + bpy.ops.object.select_all(action='SELECT') + + mesh = bpy.data.objects[0] + # Make sure mesh is the active object + try: + # earlier than blender <2.8 + bpy.context.scene.objects.active = mesh + except AttributeError: + # blender 2.8 changed this + bpy.context.view_layer.objects.active = mesh + + smart_proj(bpy.context, $ISLAND_MARGIN, $ANGLE_LIMIT, 0, True, True) + + bpy.ops.export_scene.obj( + filepath=mesh_post, + use_mesh_modifiers=False, + use_uvs=True) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/dxf.json b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/dxf.json new file mode 100644 index 0000000000000000000000000000000000000000..cf8845247d73ee1a413b9c1ea55916f2406b83d4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/dxf.json @@ -0,0 +1,11 @@ +{ + "footer": "0\nSECTION\n2\nOBJECTS\n0\nDICTIONARY\n5\nC\n100\nAcDbDictionary\n281\n1\n3\nACAD_GROUP\n350\nD\n0\nDICTIONARY\n5\nD\n330\nC\n100\nAcDbDictionary\n281\n1\n0\nENDSEC\n0\nEOF", + "bspline": "0\nSPLINE\n5\n{NAME}\n330\n1F\n100\nAcDbEntity\n8\n{LAYER}\n6\nCONTINUOUS\n62\n{COLOR}\n100\nAcDbSpline\n{NORMAL}\n70\n{FLAG}\n71\n{DEGREE}\n72\n{KCOUNT}\n73\n{PCOUNT}\n74\n{FCOUNT}\n42\n0.000000001\n43\n0.00000001\n{KNOTS}\n{POINTS}", + "objects": "0\nSECTION\n2\nOBJECTS\n{OBJECTS}\n0\nENDSEC", + "xrecord": "100\nAcDbXrecord\n{INDEX}\n{DATA}", + "line": "0\nLWPOLYLINE\n5\n{NAME}\n330\n1F\n100\nAcDbEntity\n8\n{LAYER}\n62\n{COLOR}\n100\nAcDbPolyline\n90\n{VCOUNT}\n70\n{FLAG}\n43\n0.0\n{POINTS}", + "text": "0\nTEXT\n5\n{NAME}\n100\nAcDbEntity\n8\n{LAYER}\n6\nByLayer\n62\n256\n100\nAcDbText\n{ORIGIN}\n40\n{HEIGHT}\n1\n{TEXT}\n50\n{ANGLE}\n41\n1\n51\n0\n71\n0\n210\n0\n220\n0\n230\n1\n100\nAcDbText", + "arc": "0\n{TYPE}\n5\n{NAME}\n330\n1F\n100\nAcDbEntity\n8\n{LAYER}\n62\n{COLOR}\n100\nAcDbCircle\n{DATA}", + "header": "999\ntrimesh\n0\nSECTION\n2\nHEADER\n9\n$ACADVER\n1\nAC1014\n9\n$DWGCODEPAGE\n3\nANSI_1252\n9\n$INSBASE\n10\n0\n20\n0\n30\n0\n9\n$EXTMIN\n10\n{EXTMIN_X:0.12g}\n20\n{EXTMIN_Y:0.12g}\n30\n{EXTMIN_Z:0.12g}\n9\n$EXTMAX\n10\n{EXTMAX_X:0.12g}\n20\n{EXTMAX_Y:0.12g}\n30\n{EXTMAX_Z:0.12g}\n9\n$LIMMIN\n10\n0\n20\n0\n9\n$LIMMAX\n10\n12\n20\n9\n9\n$ORTHOMODE\n70\n0\n9\n$REGENMODE\n70\n1\n9\n$FILLMODE\n70\n1\n9\n$QTEXTMODE\n70\n0\n9\n$MIRRTEXT\n70\n1\n9\n$LTSCALE\n40\n1\n9\n$ATTMODE\n70\n1\n9\n$TEXTSIZE\n40\n0.2\n9\n$TRACEWID\n40\n0.05\n9\n$TEXTSTYLE\n7\nSTANDARD\n9\n$CLAYER\n8\n0\n9\n$CELTYPE\n6\nBYBLOCK\n9\n$CECOLOR\n62\n256\n9\n$CELTSCALE\n40\n1\n9\n$DISPSILH\n70\n0\n9\n$DIMSCALE\n40\n1\n9\n$DIMASZ\n40\n0.18\n9\n$DIMEXO\n40\n0.0625\n9\n$DIMDLI\n40\n0.38\n9\n$DIMRND\n40\n0\n9\n$DIMDLE\n40\n0\n9\n$DIMEXE\n40\n0.18\n9\n$DIMTP\n40\n0\n9\n$DIMTM\n40\n0\n9\n$DIMTXT\n40\n0.18\n9\n$DIMCEN\n40\n0.09\n9\n$DIMTSZ\n40\n0\n9\n$DIMTOL\n70\n0\n9\n$DIMLIM\n70\n0\n9\n$DIMTIH\n70\n1\n9\n$DIMTOH\n70\n1\n9\n$DIMSE1\n70\n0\n9\n$DIMSE2\n70\n0\n9\n$DIMTAD\n70\n0\n9\n$DIMZIN\n70\n0\n9\n$DIMASO\n70\n1\n9\n$DIMSHO\n70\n1\n9\n$DIMALT\n70\n0\n9\n$DIMALTD\n70\n2\n9\n$DIMALTF\n40\n25.4\n9\n$DIMLFAC\n40\n1\n9\n$DIMTOFL\n70\n0\n9\n$DIMTVP\n40\n0\n9\n$DIMTIX\n70\n0\n9\n$DIMSOXD\n70\n0\n9\n$DIMSAH\n70\n0\n9\n$DIMSTYLE\n2\nSTANDARD\n9\n$DIMCLRD\n70\n0\n9\n$DIMCLRE\n70\n0\n9\n$DIMCLRT\n70\n0\n9\n$DIMTFAC\n40\n1\n9\n$DIMGAP\n40\n0.09\n9\n$DIMJUST\n70\n0\n9\n$DIMSD1\n70\n0\n9\n$DIMSD2\n70\n0\n9\n$DIMTOLJ\n70\n1\n9\n$DIMTZIN\n70\n0\n9\n$DIMALTZ\n70\n0\n9\n$DIMALTTZ\n70\n0\n9\n$DIMUPT\n70\n0\n9\n$DIMDEC\n70\n4\n9\n$DIMTDEC\n70\n4\n9\n$DIMALTU\n70\n2\n9\n$DIMALTTD\n70\n2\n9\n$DIMTXSTY\n7\nSTANDARD\n9\n$DIMAUNIT\n70\n0\n9\n$DIMADEC\n70\n0\n9\n$DIMALTRND\n40\n0\n9\n$DIMAZIN\n70\n0\n9\n$DIMDSEP\n70\n44\n9\n$DIMATFIT\n70\n3\n9\n$DIMFRAC\n70\n0\n9\n$DIMLDRBLK\n1\nSTANDARD\n9\n$DIMUNIT\n70\n2\n9\n$DIMLWD\n70\n-2\n9\n$DIMLWE\n70\n-2\n9\n$DIMTMOVE\n70\n0\n9\n$LUNITS\n70\n{LUNITS:d}\n9\n$LUPREC\n70\n4\n9\n$SKETCHINC\n40\n0.1\n9\n$FILLETRAD\n40\n0.5\n9\n$AUNITS\n70\n0\n9\n$AUPREC\n70\n0\n9\n$MENU\n1\n.\n9\n$ELEVATION\n40\n0\n9\n$PELEVATION\n40\n0\n9\n$THICKNESS\n40\n0\n9\n$LIMCHECK\n70\n0\n9\n$BLIPMODE\n70\n0\n9\n$CHAMFERA\n40\n0\n9\n$CHAMFERB\n40\n0\n9\n$CHAMFERC\n40\n0\n9\n$CHAMFERD\n40\n0\n9\n$SKPOLY\n70\n0\n9\n$USRTIMER\n70\n1\n9\n$ANGBASE\n50\n0\n9\n$ANGDIR\n70\n0\n9\n$PDMODE\n70\n0\n9\n$PDSIZE\n40\n0\n9\n$PLINEWID\n40\n0\n9\n$SPLFRAME\n70\n0\n9\n$SPLINETYPE\n70\n6\n9\n$SPLINESEGS\n70\n8\n9\n$HANDSEED\n5\n20000\n9\n$SURFTAB1\n70\n6\n9\n$SURFTAB2\n70\n6\n9\n$SURFTYPE\n70\n6\n9\n$SURFU\n70\n6\n9\n$SURFV\n70\n6\n9\n$UCSORG\n10\n0\n20\n0\n30\n0\n9\n$UCSXDIR\n10\n1\n20\n0\n30\n0\n9\n$UCSYDIR\n10\n0\n20\n1\n30\n0\n9\n$UCSORTHOVIEW\n70\n0\n9\n$UCSORGTOP\n10\n0\n20\n0\n30\n0\n9\n$UCSORGBOTTOM\n10\n0\n20\n0\n30\n0\n9\n$UCSORGLEFT\n10\n0\n20\n0\n30\n0\n9\n$UCSORGRIGHT\n10\n0\n20\n0\n30\n0\n9\n$UCSORGFRONT\n10\n0\n20\n0\n30\n0\n9\n$UCSORGBACK\n10\n0\n20\n0\n30\n0\n9\n$PUCSORG\n10\n0\n20\n0\n30\n0\n9\n$PUCSXDIR\n10\n1\n20\n0\n30\n0\n9\n$PUCSYDIR\n10\n0\n20\n1\n30\n0\n9\n$PUCSORTHOVIEW\n70\n0\n9\n$PUCSORGTOP\n10\n0\n20\n0\n30\n0\n9\n$PUCSORGBOTTOM\n10\n0\n20\n0\n30\n0\n9\n$PUCSORGLEFT\n10\n0\n20\n0\n30\n0\n9\n$PUCSORGRIGHT\n10\n0\n20\n0\n30\n0\n9\n$PUCSORGFRONT\n10\n0\n20\n0\n30\n0\n9\n$PUCSORGBACK\n10\n0\n20\n0\n30\n0\n9\n$USERI1\n70\n0\n9\n$USERI2\n70\n0\n9\n$USERI3\n70\n0\n9\n$USERI4\n70\n0\n9\n$USERI5\n70\n0\n9\n$USERR1\n40\n0\n9\n$USERR2\n40\n0\n9\n$USERR3\n40\n0\n9\n$USERR4\n40\n0\n9\n$USERR5\n40\n0\n9\n$WORLDVIEW\n70\n1\n9\n$SHADEDGE\n70\n3\n9\n$SHADEDIF\n70\n70\n9\n$TILEMODE\n70\n1\n9\n$MAXACTVP\n70\n64\n9\n$PINSBASE\n10\n0\n20\n0\n30\n0\n9\n$PLIMCHECK\n70\n0\n9\n$PEXTMIN\n10\n1e+20\n20\n1e+20\n30\n1e+20\n9\n$PEXTMAX\n10\n-1e+20\n20\n-1e+20\n30\n-1e+20\n9\n$GRIDMODE\n70\n0\n9\n$SNAPSTYLE\n70\n0\n9\n$PLIMMIN\n10\n0\n20\n0\n9\n$PLIMMAX\n10\n0\n20\n0\n9\n$UNITMODE\n70\n0\n9\n$VISRETAIN\n70\n1\n9\n$PLINEGEN\n70\n0\n9\n$PSLTSCALE\n70\n1\n9\n$TREEDEPTH\n70\n3020\n9\n$CMLSTYLE\n2\nSTANDARD\n9\n$CMLJUST\n70\n0\n9\n$CMLSCALE\n40\n1\n9\n$PROXYGRAPHICS\n70\n1\n9\n$MEASUREMENT\n70\n0\n9\n$CELWEIGHT\n370\n-1\n9\n$ENDCAPS\n280\n0\n9\n$JOINSTYLE\n280\n0\n9\n$LWDISPLAY\n290\n0\n9\n$XEDIT\n290\n1\n9\n$CEPSNTYPE\n380\n0\n9\n$PSTYLEMODE\n290\n1\n9\n$EXTNAMES\n290\n1\n9\n$PSVPSCALE\n40\n1\n9\n$OLESTARTUP\n290\n0\n0\nENDSEC\n0\nSECTION\n2\nCLASSES\n0\nENDSEC\n0\nSECTION\n2\nTABLES\n0\nTABLE\n2\nVPORT\n5\n8\n100\nAcDbSymbolTable\n70\n1\n0\nVPORT\n5\n31\n330\n2\n100\nAcDbSymbolTableRecord\n100\nAcDbViewportTableRecord\n2\n*ACTIVE\n70\n0\n10\n0\n20\n0\n11\n1\n21\n1\n12\n354.791887455375\n22\n270.82508654025\n13\n0\n23\n0\n14\n10\n24\n10\n15\n10\n25\n10\n16\n0\n26\n0\n36\n1\n17\n0\n27\n0\n37\n0\n40\n650.7886407907502\n41\n1.281197063805759\n42\n50\n43\n0\n44\n0\n50\n0\n51\n0\n71\n0\n72\n100\n73\n1\n74\n3\n75\n0\n76\n0\n77\n0\n78\n0\n0\nENDTAB\n0\nTABLE\n2\nLTYPE\n5\n5\n100\nAcDbSymbolTable\n70\n4\n0\nLTYPE\n5\n14\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nByBlock\n70\n0\n72\n65\n73\n0\n40\n0\n0\nLTYPE\n5\n15\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nByLayer\n70\n0\n72\n65\n73\n0\n40\n0\n0\nLTYPE\n5\n16\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nContinuous\n70\n0\n3\nSolid|<^>|line\n72\n65\n73\n0\n40\n0\n0\nLTYPE\n5\n32\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nDOT\n70\n0\n3\nDot|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.|<^>|.\n72\n65\n73\n2\n40\n6.35\n49\n0\n74\n0\n49\n-6.35\n74\n0\n0\nLTYPE\n5\n33\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nDOTTINY\n70\n0\n3\nDot|<^>|(.15x)|<^>|.....................................\n72\n65\n73\n2\n40\n0.9525\n49\n0\n74\n0\n49\n-0.9525\n74\n0\n0\nLTYPE\n5\n34\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nDOT2\n70\n0\n3\nDot|<^>|(.5x)|<^>|.....................................\n72\n65\n73\n2\n40\n3.175\n49\n0\n74\n0\n49\n-3.175\n74\n0\n0\nLTYPE\n5\n35\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nDOTX2\n70\n0\n3\nDot|<^>|(2x)|<^>|.|<^>||<^>|.|<^>||<^>|.|<^>||<^>|.|<^>||<^>|.|<^>||<^>|.|<^>||<^>|.|<^>||<^>|.|<^>||<^>|.|<^>||<^>|.|<^>||<^>|.|<^>||<^>|.|<^>||<^>|.\n72\n65\n73\n2\n40\n12.7\n49\n0\n74\n0\n49\n-12.7\n74\n0\n0\nLTYPE\n5\n36\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nDASHED\n70\n0\n3\nDashed|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_\n72\n65\n73\n2\n40\n19.05\n49\n12.7\n74\n0\n49\n-6.35\n74\n0\n0\nLTYPE\n5\n37\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nDASHEDTINY\n70\n0\n3\nDashed|<^>|(.15x)|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_\n72\n65\n73\n2\n40\n2.8575\n49\n1.905\n74\n0\n49\n-0.9525\n74\n0\n0\nLTYPE\n5\n38\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nDASHED2\n70\n0\n3\nDashed|<^>|(.5x)|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_|<^>|_\n72\n65\n73\n2\n40\n9.524999999999999\n49\n6.35\n74\n0\n49\n-3.175\n74\n0\n0\nLTYPE\n5\n39\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nDASHEDX2\n70\n0\n3\nDashed|<^>|(2x)|<^>|____|<^>||<^>|____|<^>||<^>|____|<^>||<^>|____|<^>||<^>|____|<^>||<^>|___\n72\n65\n73\n2\n40\n38.09999999999999\n49\n25.4\n74\n0\n49\n-12.7\n74\n0\n0\nLTYPE\n5\n3A\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nDASHDOT\n70\n0\n3\nDash|<^>|dot|<^>|__|<^>|.|<^>|__|<^>|.|<^>|__|<^>|.|<^>|__|<^>|.|<^>|__|<^>|.|<^>|__|<^>|.|<^>|__|<^>|.|<^>|__\n72\n65\n73\n4\n40\n25.4\n49\n12.7\n74\n0\n49\n-6.35\n74\n0\n49\n0\n74\n0\n49\n-6.35\n74\n0\n0\nLTYPE\n5\n3B\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nDASHDOTTINY\n70\n0\n3\nDash|<^>|dot|<^>|(.15x)|<^>|_._._._._._._._._._._._._._._.\n72\n65\n73\n4\n40\n3.81\n49\n1.905\n74\n0\n49\n-0.9525\n74\n0\n49\n0\n74\n0\n49\n-0.9525\n74\n0\n0\nLTYPE\n5\n3C\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nDASHDOT2\n70\n0\n3\nDash|<^>|dot|<^>|(.5x)|<^>|_._._._._._._._._._._._._._._.\n72\n65\n73\n4\n40\n12.7\n49\n6.35\n74\n0\n49\n-3.175\n74\n0\n49\n0\n74\n0\n49\n-3.175\n74\n0\n0\nLTYPE\n5\n3D\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nDASHDOTX2\n70\n0\n3\nDash|<^>|dot|<^>|(2x)|<^>|____|<^>||<^>|.|<^>||<^>|____|<^>||<^>|.|<^>||<^>|____|<^>||<^>|.|<^>||<^>|___\n72\n65\n73\n4\n40\n50.8\n49\n25.4\n74\n0\n49\n-12.7\n74\n0\n49\n0\n74\n0\n49\n-12.7\n74\n0\n0\nLTYPE\n5\n3E\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nDIVIDE\n70\n0\n3\nDivide|<^>|____|<^>|.|<^>|.|<^>|____|<^>|.|<^>|.|<^>|____|<^>|.|<^>|.|<^>|____|<^>|.|<^>|.|<^>|____\n72\n65\n73\n6\n40\n31.75\n49\n12.7\n74\n0\n49\n-6.35\n74\n0\n49\n0\n74\n0\n49\n-6.35\n74\n0\n49\n0\n74\n0\n49\n-6.35\n74\n0\n0\nLTYPE\n5\n3F\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nDIVIDETINY\n70\n0\n3\nDivide|<^>|(.15x)|<^>|__..__..__..__..__..__..__..__.._\n72\n65\n73\n6\n40\n4.7625\n49\n1.905\n74\n0\n49\n-0.9525\n74\n0\n49\n0\n74\n0\n49\n-0.9525\n74\n0\n49\n0\n74\n0\n49\n-0.9525\n74\n0\n0\nLTYPE\n5\n40\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nDIVIDE2\n70\n0\n3\nDivide|<^>|(.5x)|<^>|__..__..__..__..__..__..__..__.._\n72\n65\n73\n6\n40\n15.875\n49\n6.35\n74\n0\n49\n-3.175\n74\n0\n49\n0\n74\n0\n49\n-3.175\n74\n0\n49\n0\n74\n0\n49\n-3.175\n74\n0\n0\nLTYPE\n5\n41\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nDIVIDEX2\n70\n0\n3\nDivide|<^>|(2x)|<^>|________|<^>||<^>|.|<^>||<^>|.|<^>||<^>|________|<^>||<^>|.|<^>||<^>|.|<^>||<^>|_\n72\n65\n73\n6\n40\n63.5\n49\n25.4\n74\n0\n49\n-12.7\n74\n0\n49\n0\n74\n0\n49\n-12.7\n74\n0\n49\n0\n74\n0\n49\n-12.7\n74\n0\n0\nLTYPE\n5\n42\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nBORDER\n70\n0\n3\nBorder|<^>|__|<^>|__|<^>|.|<^>|__|<^>|__|<^>|.|<^>|__|<^>|__|<^>|.|<^>|__|<^>|__|<^>|.|<^>|__|<^>|__|<^>|.\n72\n65\n73\n6\n40\n44.45\n49\n12.7\n74\n0\n49\n-6.35\n74\n0\n49\n12.7\n74\n0\n49\n-6.35\n74\n0\n49\n0\n74\n0\n49\n-6.35\n74\n0\n0\nLTYPE\n5\n43\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nBORDERTINY\n70\n0\n3\nBorder|<^>|(.15x)|<^>|__.__.__.__.__.__.__.__.__.__.__.\n72\n65\n73\n6\n40\n6.6675\n49\n1.905\n74\n0\n49\n-0.9525\n74\n0\n49\n1.905\n74\n0\n49\n-0.9525\n74\n0\n49\n0\n74\n0\n49\n-0.9525\n74\n0\n0\nLTYPE\n5\n44\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nBORDER2\n70\n0\n3\nBorder|<^>|(.5x)|<^>|__.__.__.__.__.__.__.__.__.__.__.\n72\n65\n73\n6\n40\n22.225\n49\n6.35\n74\n0\n49\n-3.175\n74\n0\n49\n6.35\n74\n0\n49\n-3.175\n74\n0\n49\n0\n74\n0\n49\n-3.175\n74\n0\n0\nLTYPE\n5\n45\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nBORDERX2\n70\n0\n3\nBorder|<^>|(2x)|<^>|____|<^>||<^>|____|<^>||<^>|.|<^>||<^>|____|<^>||<^>|____|<^>||<^>|.|<^>||<^>|___\n72\n65\n73\n6\n40\n88.89999999999999\n49\n25.4\n74\n0\n49\n-12.7\n74\n0\n49\n25.4\n74\n0\n49\n-12.7\n74\n0\n49\n0\n74\n0\n49\n-12.7\n74\n0\n0\nLTYPE\n5\n46\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nCENTER\n70\n0\n3\nCenter|<^>|____|<^>|_|<^>|____|<^>|_|<^>|____|<^>|_|<^>|____|<^>|_|<^>|____|<^>|_|<^>|____\n72\n65\n73\n4\n40\n50.8\n49\n31.75\n74\n0\n49\n-6.35\n74\n0\n49\n6.35\n74\n0\n49\n-6.35\n74\n0\n0\nLTYPE\n5\n47\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nCENTERTINY\n70\n0\n3\nCenter|<^>|(.15x)|<^>|___|<^>|_|<^>|___|<^>|_|<^>|___|<^>|_|<^>|___|<^>|_|<^>|___|<^>|_|<^>|___\n72\n65\n73\n4\n40\n7.619999999999999\n49\n4.7625\n74\n0\n49\n-0.9525\n74\n0\n49\n0.9525\n74\n0\n49\n-0.9525\n74\n0\n0\nLTYPE\n5\n48\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nCENTER2\n70\n0\n3\nCenter|<^>|(.5x)|<^>|___|<^>|_|<^>|___|<^>|_|<^>|___|<^>|_|<^>|___|<^>|_|<^>|___|<^>|_|<^>|___\n72\n65\n73\n4\n40\n28.575\n49\n19.05\n74\n0\n49\n-3.175\n74\n0\n49\n3.175\n74\n0\n49\n-3.175\n74\n0\n0\nLTYPE\n5\n49\n330\n5\n100\nAcDbSymbolTableRecord\n100\nAcDbLinetypeTableRecord\n2\nCENTERX2\n70\n0\n3\nCenter|<^>|(2x)|<^>|________|<^>||<^>|__|<^>||<^>|________|<^>||<^>|__|<^>||<^>|_____\n72\n65\n73\n4\n40\n101.6\n49\n63.5\n74\n0\n49\n-12.7\n74\n0\n49\n12.7\n74\n0\n49\n-12.7\n74\n0\n0\nENDTAB\n0\nTABLE\n2\nLAYER\n5\n2\n100\nAcDbSymbolTable\n70\n1\n0\nLAYER\n5\n10\n330\n2\n100\nAcDbSymbolTableRecord\n100\nAcDbLayerTableRecord\n2\n0\n70\n0\n62\n7\n6\nCONTINUOUS\n370\n0\n390\nF\n0\nLAYER\n5\n4A\n330\n2\n100\nAcDbSymbolTableRecord\n100\nAcDbLayerTableRecord\n2\nNone\n70\n0\n62\n7\n6\nCONTINUOUS\n370\n-3\n390\nF\n0\nENDTAB\n0\nTABLE\n2\nSTYLE\n5\n3\n100\nAcDbSymbolTable\n70\n3\n0\nSTYLE\n5\n4B\n330\n2\n100\nAcDbSymbolTableRecord\n100\nAcDbTextStyleTableRecord\n2\nStandard\n70\n0\n40\n0\n41\n1\n50\n0\n71\n0\n42\n1\n3\ntxt\n0\nENDTAB\n0\nTABLE\n2\nVIEW\n5\n6\n100\nAcDbSymbolTable\n70\n0\n0\nENDTAB\n0\nTABLE\n2\nUCS\n5\n7\n100\nAcDbSymbolTable\n70\n0\n0\nENDTAB\n0\nTABLE\n2\nAPPID\n5\n9\n100\nAcDbSymbolTable\n70\n1\n0\nAPPID\n5\n12\n100\nAcDbSymbolTableRecord\n100\nAcDbRegAppTableRecord\n2\nACAD\n70\n0\n0\nAPPID\n5\n4C\n100\nAcDbSymbolTableRecord\n100\nAcDbRegAppTableRecord\n2\nLibreCad\n70\n0\n0\nENDTAB\n0\nTABLE\n2\nDIMSTYLE\n5\nA\n100\nAcDbSymbolTable\n70\n1\n0\nDIMSTYLE\n105\n4D\n330\nA\n100\nAcDbSymbolTableRecord\n100\nAcDbDimStyleTableRecord\n2\nStandard\n70\n0\n40\n1\n41\n0.18\n42\n0.0625\n43\n0.38\n44\n0.18\n45\n0\n46\n0\n47\n0\n48\n0\n49\n1\n140\n0.18\n141\n0.09\n142\n0\n143\n25.4\n144\n1\n145\n0\n146\n1\n147\n0.09\n71\n0\n72\n0\n73\n1\n74\n1\n75\n0\n76\n0\n77\n0\n78\n0\n170\n0\n171\n2\n172\n0\n173\n0\n174\n0\n175\n0\n176\n0\n177\n0\n178\n0\n270\n2\n271\n4\n272\n4\n273\n2\n274\n2\n275\n0\n280\n0\n281\n0\n282\n0\n283\n1\n284\n0\n285\n0\n286\n0\n287\n3\n288\n0\n340\nSTANDARD\n0\nENDTAB\n0\nTABLE\n2\nBLOCK_RECORD\n5\n1\n100\nAcDbSymbolTable\n70\n2\n0\nBLOCK_RECORD\n5\n1F\n100\nAcDbSymbolTableRecord\n100\nAcDbBlockTableRecord\n2\n*Model_Space\n0\nBLOCK_RECORD\n5\n1E\n100\nAcDbSymbolTableRecord\n100\nAcDbBlockTableRecord\n2\n*Paper_Space\n0\nENDTAB\n0\nENDSEC\n0\nSECTION\n2\nBLOCKS\n0\nBLOCK\n5\n20\n100\nAcDbEntity\n8\n0\n100\nAcDbBlockBegin\n2\n*Model_Space\n70\n0\n10\n0\n20\n0\n30\n0\n3\n*Model_Space\n0\nENDBLK\n5\n21\n100\nAcDbEntity\n8\n0\n100\nAcDbBlockEnd\n0\nBLOCK\n5\n1C\n100\nAcDbEntity\n8\n0\n100\nAcDbBlockBegin\n2\n*Paper_Space\n70\n0\n10\n0\n20\n0\n30\n0\n3\n*Paper_Space\n0\nENDBLK\n5\n1D\n100\nAcDbEntity\n8\n0\n100\nAcDbBlockEnd\n0\nENDSEC", + "entities": "0\nSECTION\n2\nENTITIES\n{ENTITIES}\n0\nENDSEC" +} \ No newline at end of file diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/path.svg b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/path.svg new file mode 100644 index 0000000000000000000000000000000000000000..7697ca92dc28fbbe98d75e6ba5c3f3180f85aaa3 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/path.svg @@ -0,0 +1 @@ + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/ply.json b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/ply.json new file mode 100644 index 0000000000000000000000000000000000000000..1798240c7ae9c9544f4b05b6deac97cf7ce24e11 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/ply.json @@ -0,0 +1,9 @@ +{ + "face": "element face $face_count\nproperty list uchar int vertex_indices\n", + "vertex": "element vertex $vertex_count\nproperty float x\nproperty float y\nproperty float z\n", + "vertex_normal": "property float nx\nproperty float ny\nproperty float nz\n", + "color": "property uchar red\nproperty uchar green\nproperty uchar blue\nproperty uchar alpha\n", + "edge": "element edge $edge_count\nproperty int vertex1\nproperty int vertex2\n", + "intro": "ply\nformat $encoding 1.0\ncomment https://github.com/mikedh/trimesh\n", + "outro": "end_header\n" +} diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/viewer.zip b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/viewer.zip new file mode 100644 index 0000000000000000000000000000000000000000..ef2e97c03420ffb17a04f2526533ffe08d856675 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/templates/viewer.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:721bcbb60cff2988cedfe547592994ded740a345ba4090e17edde381930749c5 +size 173435 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/units_to_inches.json b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/units_to_inches.json new file mode 100644 index 0000000000000000000000000000000000000000..ef098d335f3f8b2e98a8b020e26f698fd6850d6a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/resources/units_to_inches.json @@ -0,0 +1,47 @@ +{ + "microinches": 1e-06, + "mils": 0.001, + "inches": 1.0, + "feet": 12.0, + "foot": 12.0, + "yards": 36.0, + "miles": 63360.0, + "angstroms": 3.937007874015748e-9, + "nanometers": 3.937007874015748e-8, + "microns": 3.937007874015748e-5, + "millimeters": 0.03937007874015748, + "centimeters": 0.39370078740157477, + "cm": 0.39370078740157477, + "meters": 39.37007874015748, + "kilometers": 39370.07874015748, + "decimeters": 3.937007874015748, + "decameters": 393.70078740157476, + "hectometers": 3937.0078740157483, + "gigameters": 39370078740.15748, + "au": 5889679948818.897, + "light years": 3.72461748e17, + "parsecs": 1.21483369e18, + "mm": 0.03937007874015748, + "millimeter": 0.03937007874015748, + "in": 1.0, + "\"": 1.0, + "inch": 1.0, + "'": 12.0, + "m": 39.37007874015748, + "meter": 39.37007874015748, + "microinch": 1e-06, + "mil": 0.001, + "yard": 36.0, + "mile": 63360.0, + "angstrom": 3.937007874015748e-9, + "nanometer": 3.937007874015748e-8, + "micron": 3.937007874015748e-5, + "centimeter": 0.39370078740157477, + "kilometer": 39370.07874015748, + "decimeter": 3.937007874015748, + "decameter": 393.70078740157476, + "hectometer": 3937.0078740157483, + "gigameter": 39370078740.15748, + "light year": 3.72461748e17, + "parsec": 1.21483369e18 +} diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/sample.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/sample.py new file mode 100644 index 0000000000000000000000000000000000000000..d86957acf31faebd5e830a3859996739b7884e84 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/sample.py @@ -0,0 +1,278 @@ +""" +sample.py +------------ + +Randomly sample surface and volume of meshes. +""" + +from logging import getLogger + +import numpy as np + +from . import transformations +from .typed import ArrayLike, Integer, NDArray, Number, Seed, float64 +from .util import random_generator, spherical_to_vector +from .visual import uv_to_interpolated_color + +log = getLogger(__name__) + + +def sample_surface( + mesh, + count: Integer, + face_weight: ArrayLike | None = None, + sample_color=False, + return_barycentric: bool = False, + seed: Seed = None, +): + """ + Sample the surface of a mesh, returning the specified + number of points + + For individual triangle sampling uses this method: + http://mathworld.wolfram.com/TrianglePointPicking.html + + Parameters + ----------- + mesh : trimesh.Trimesh + Geometry to sample the surface of + count : int + Number of points to return + face_weight : None or len(mesh.faces) float + Weight faces by a factor other than face area. + If None will be the same as face_weight=mesh.area + sample_color : bool + Option to calculate the color of the sampled points. + Default is False. + return_barycentric : bool + If True will also return the barycentric coordinates + of each sampled point. + seed : None or int + Seed for deterministic results, otherwise OS entropy. + + Returns + --------- + samples : (count, 3) float + Points in space on the surface of mesh + face_index : (count,) int + Indices of faces for each sampled point + colors : (count, 4) float + Colors of each sampled point + Returns only when the sample_color is True + barycentric : (count, 3) float + Coordinates on `mesh.faces[face_index]` + Returned only when return_barycentric is True + """ + + if face_weight is None: + # len(mesh.faces) float, array of the areas + # of each face of the mesh + face_weight = mesh.area_faces + + # cumulative sum of weights (len(mesh.faces)) + weight_cum = np.cumsum(face_weight) + + random = random_generator(seed).random + + # last value of cumulative sum is total summed weight/area + face_pick = random(count) * weight_cum[-1] + # get the index of the selected faces + face_index = np.searchsorted(weight_cum, face_pick) + + # pull triangles into the form of an origin + 2 vectors + tri_origins = mesh.vertices[mesh.faces[:, 0]] + tri_vectors = mesh.vertices[mesh.faces[:, 1:]].copy() + tri_vectors -= np.tile(tri_origins, (1, 2)).reshape((-1, 2, 3)) + + # pull the vectors for the faces we are going to sample from + tri_origins = tri_origins[face_index] + tri_vectors = tri_vectors[face_index] + + if sample_color and hasattr(mesh.visual, "uv"): + uv_origins = mesh.visual.uv[mesh.faces[:, 0]] + uv_vectors = mesh.visual.uv[mesh.faces[:, 1:]].copy() + uv_origins_tile = np.tile(uv_origins, (1, 2)).reshape((-1, 2, 2)) + uv_vectors -= uv_origins_tile + uv_origins = uv_origins[face_index] + uv_vectors = uv_vectors[face_index] + + # randomly generate two 0-1 scalar components to multiply edge vectors b + random_lengths = random((len(tri_vectors), 2, 1)) + + # points will be distributed on a quadrilateral if we use 2 0-1 samples + # if the two scalar components sum less than 1.0 the point will be + # inside the triangle, so we find vectors longer than 1.0 and + # transform them to be inside the triangle + random_test = random_lengths.sum(axis=1).reshape(-1) > 1.0 + random_lengths[random_test] -= 1.0 + random_lengths = np.abs(random_lengths) + + if return_barycentric: + # the two random lengths are the barycentric coordinates of the + # second and third vertex - the first vertex is what remains + barycentric = np.hstack((1 - random_lengths.sum(axis=1), random_lengths[:, :, 0])) + + # multiply triangle edge vectors by the random lengths and sum + sample_vector = (tri_vectors * random_lengths).sum(axis=1) + + # finally, offset by the origin to generate + # (n,3) points in space on the triangle + samples = sample_vector + tri_origins + + if sample_color: + if hasattr(mesh.visual, "uv"): + sample_uv_vector = (uv_vectors * random_lengths).sum(axis=1) + uv_samples = sample_uv_vector + uv_origins + texture = mesh.visual.material.image + colors = uv_to_interpolated_color(uv_samples, texture) + else: + colors = mesh.visual.face_colors[face_index] + + if return_barycentric: + return samples, face_index, colors, barycentric + + return samples, face_index, colors + + if return_barycentric: + return samples, face_index, barycentric + + return samples, face_index + + +def volume_mesh(mesh, count: Integer, seed: Seed = None) -> NDArray[float64]: + """ + Use rejection sampling to produce points randomly + distributed in the volume of a mesh. + + + Parameters + ----------- + mesh : trimesh.Trimesh + Geometry to sample + count : int + Number of points to return + seed : None or int + Seed for deterministic results, otherwise OS entropy. + + Returns + --------- + samples : (n, 3) float + Points in the volume of the mesh where n <= count + """ + random = random_generator(seed).random + points = (random((count, 3)) * mesh.extents) + mesh.bounds[0] + contained = mesh.contains(points) + samples = points[contained][:count] + return samples + + +def volume_rectangular( + extents, + count: Integer, + transform: ArrayLike | None = None, + seed: Seed = None, +) -> NDArray[float64]: + """ + Return random samples inside a rectangular volume, + useful for sampling inside oriented bounding boxes. + + Parameters + ----------- + extents : (3,) float + Side lengths of rectangular solid + count : int + Number of points to return + transform : (4, 4) float + Homogeneous transformation matrix + seed : None or int + Seed for deterministic results, otherwise OS entropy. + + Returns + --------- + samples : (count, 3) float + Points in requested volume + """ + samples = (random_generator(seed).random((count, 3)) - 0.5) * extents + if transform is not None: + samples = transformations.transform_points(samples, transform) + return samples + + +def sample_surface_even( + mesh, count: Integer, radius: Number | None = None, seed: Seed = None +): + """ + Sample the surface of a mesh, returning samples which are + VERY approximately evenly spaced. This is accomplished by + sampling and then rejecting pairs that are too close together. + + Note that since it is using rejection sampling it may return + fewer points than requested (i.e. n < count). If this is the + case a log.warning will be emitted. + + Parameters + ----------- + mesh : trimesh.Trimesh + Geometry to sample the surface of + count : int + Number of points to return + radius : None or float + Removes samples below this radius + seed : None or int + Provides deterministic values + + Returns + --------- + samples : (n, 3) float + Points in space on the surface of mesh + face_index : (n,) int + Indices of faces for each sampled point + """ + from .points import remove_close + + # guess radius from area + if radius is None: + radius = np.sqrt(mesh.area / (3 * count)) + + # get points on the surface + points, index = sample_surface(mesh, count * 3, seed=seed) + + # remove the points closer than radius + points, mask = remove_close(points, radius) + + # we got all the samples we expect + if len(points) >= count: + return points[:count], index[mask][:count] + + # warn if we didn't get all the samples we expect + log.warning(f"only got {len(points)}/{count} samples!") + + return points, index[mask] + + +def sample_surface_sphere(count: int, seed: Seed = None) -> NDArray[float64]: + """ + Correctly pick random points on the surface of a unit sphere + + Uses this method: + http://mathworld.wolfram.com/SpherePointPicking.html + + Parameters + ----------- + count : int + Number of points to return + seed : None or int + Seed for deterministic results, otherwise OS entropy. + + Returns + ---------- + points : (count, 3) float + Random points on the surface of a unit sphere + """ + # get random values 0.0-1.0 + u, v = random_generator(seed).random((2, count)) + # convert to two angles + theta = np.pi * 2 * u + phi = np.arccos((2 * v) - 1) + # convert spherical coordinates to cartesian + return spherical_to_vector(np.column_stack((theta, phi))) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2ab1a162a9179018061d0aad59c6aa67e0bb0fce --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__init__.py @@ -0,0 +1,5 @@ +from .cameras import Camera +from .scene import Scene, split_scene + +# add to __all__ as per pep8 +__all__ = ["Camera", "Scene", "split_scene"] diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b5f4ff9b86af43fd3b4f0d266e80f9d00e19a824 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__pycache__/cameras.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__pycache__/cameras.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..19dfb15d7d50ba4f5a0c5bd4e4622bdd002d2ead Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__pycache__/cameras.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__pycache__/lighting.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__pycache__/lighting.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dd95e9b76e69691045282d79fa133bd120fbf37a Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__pycache__/lighting.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__pycache__/scene.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__pycache__/scene.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..639597fad7fc43cf826b8cff37d32627e6654e1a Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__pycache__/scene.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__pycache__/transforms.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__pycache__/transforms.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..77f7cc0bc0d6f375eee6d61c17bbd9fb6dbe804e Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/__pycache__/transforms.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/cameras.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/cameras.py new file mode 100644 index 0000000000000000000000000000000000000000..2b83efd36c51dcea65b71846608c545aa2132030 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/cameras.py @@ -0,0 +1,423 @@ +import copy + +import numpy as np + +from .. import util + + +class Camera: + def __init__( + self, name=None, resolution=None, focal=None, fov=None, z_near=0.01, z_far=1000.0 + ): + """ + Create a new Camera object that stores camera intrinsic + and extrinsic parameters. + + TODO: skew is not supported + TODO: cx and cy that are not half of width and height + + Parameters + ------------ + name : str or None + Name for camera to be used as node name + resolution : (2,) int + Pixel size in (height, width) + focal : (2,) float + Focal length in pixels. Either pass this OR FOV + but not both. focal = (K[0][0], K[1][1]) + fov : (2,) float + Field of view (fovx, fovy) in degrees + z_near : float + What is the closest + """ + + if name is None: + # if name is not passed, make it something unique + self.name = f"camera_{util.unique_id(6).upper()}" + else: + # otherwise assign it + self.name = name + + if fov is None and focal is None: + raise ValueError("either focal length or FOV required!") + + # store whether or not we computed the focal length + self._focal_computed = False + + # set the passed (2,) float focal length + self.focal = focal + + # set the passed (2,) float FOV in degrees + self.fov = fov + + if resolution is None: + # if unset make resolution 30 pixels per degree + resolution = (self.fov * 30.0).round().astype(np.int64) + self.resolution = resolution + + # what is the farthest from the camera it should render + self.z_far = float(z_far) + # what is the closest to the camera it should render + self.z_near = float(z_near) + + def copy(self): + """ + Safely get a copy of the current camera. + """ + return Camera( + name=copy.deepcopy(self.name), + resolution=copy.deepcopy(self.resolution), + focal=copy.deepcopy(self.focal), + fov=copy.deepcopy(self.fov), + ) + + @property + def resolution(self): + """ + Get the camera resolution in pixels. + + Returns + ------------ + resolution (2,) float + Camera resolution in pixels + """ + return self._resolution + + @resolution.setter + def resolution(self, values): + """ + Set the camera resolution in pixels. + + Parameters + ------------ + resolution (2,) float + Camera resolution in pixels + """ + values = np.asanyarray(values, dtype=np.int64) + if values.shape != (2,): + raise ValueError("resolution must be (2,) float") + values.flags.writeable = False + self._resolution = values + # unset computed value that depends on the other plus resolution + if self._focal_computed: + self._focal = None + else: + # fov must be computed + self._fov = None + + @property + def focal(self): + """ + Get the focal length in pixels for the camera. + + Returns + ------------ + focal : (2,) float + Focal length in pixels + """ + if self._focal is None: + # calculate focal length from FOV + focal = self._resolution / (2.0 * np.tan(np.radians(self._fov / 2.0))) + focal.flags.writeable = False + self._focal = focal + + return self._focal + + @focal.setter + def focal(self, values): + """ + Set the focal length in pixels for the camera. + + Returns + ------------ + focal : (2,) float + Focal length in pixels. + """ + if values is None: + self._focal = None + else: + # flag this as not computed (hence fov must be) + # this is necessary so changes to resolution can reset the + # computed quantity without changing the explicitly set quantity + self._focal_computed = False + values = np.asanyarray(values, dtype=np.float64) + if values.shape != (2,): + raise ValueError("focal length must be (2,) float") + values.flags.writeable = False + # assign passed values to focal length + self._focal = values + # focal overrides FOV + self._fov = None + + @property + def K(self): + """ + Get the intrinsic matrix for the Camera object. + + Returns + ----------- + K : (3, 3) float + Intrinsic matrix for camera + """ + K = np.eye(3, dtype=np.float64) + K[0, 0] = self.focal[0] + K[1, 1] = self.focal[1] + K[:2, 2] = self.resolution / 2.0 + return K + + @K.setter + def K(self, values): + if values is None: + return + values = np.asanyarray(values, dtype=np.float64) + if values.shape != (3, 3): + raise ValueError("matrix must be (3,3)!") + + if not np.allclose(values.flatten()[[1, 3, 6, 7, 8]], [0, 0, 0, 0, 1]): + raise ValueError("matrix should only have focal length and resolution!") + + # set focal length from matrix + self.focal = [values[0, 0], values[1, 1]] + # set resolution from matrix + self.resolution = values[:2, 2] * 2 + + @property + def fov(self): + """ + Get the field of view in degrees. + + Returns + ------------- + fov : (2,) float + XY field of view in degrees + """ + if self._fov is None: + fov = 2.0 * np.degrees(np.arctan((self._resolution / 2.0) / self._focal)) + fov.flags.writeable = False + self._fov = fov + return self._fov + + @fov.setter + def fov(self, values): + """ + Set the field of view in degrees. + + Parameters + ------------- + values : (2,) float + Size of FOV to set in degrees + """ + if values is None: + self._fov = None + else: + # flag this as computed (hence fov must not be) + # this is necessary so changes to resolution can reset the + # computed quantity without changing the explicitly set quantity + self._focal_computed = True + values = np.asanyarray(values, dtype=np.float64) + if values.shape != (2,): + raise ValueError("fov length must be (2,) int") + values.flags.writeable = False + # assign passed values to FOV + self._fov = values + # fov overrides focal + self._focal = None + + def to_rays(self): + """ + Calculate ray direction vectors. + + Will return one ray per pixel, as set in self.resolution. + + Returns + -------------- + vectors : (n, 3) float + Ray direction vectors in camera frame with z == -1 + """ + return camera_to_rays(self) + + def angles(self): + """ + Get ray spherical coordinates in radians. + + + Returns + -------------- + angles : (n, 2) float + Ray spherical coordinate angles in radians. + """ + return np.arctan(-ray_pixel_coords(self)) + + def look_at(self, points, **kwargs): + """ + Generate transform for a camera to keep a list + of points in the camera's field of view. + + Parameters + ------------- + points : (n, 3) float + Points in space + rotation : None, or (4, 4) float + Rotation matrix for initial rotation + distance : None or float + Distance from camera to center + center : None, or (3,) float + Center of field of view. + + Returns + -------------- + transform : (4, 4) float + Transformation matrix from world to camera + """ + return look_at(points, fov=self.fov, **kwargs) + + def __repr__(self): + return f" FOV: {self.fov} Resolution: {self.resolution}" + + +def look_at(points, fov, rotation=None, distance=None, center=None, pad=None): + """ + Generate transform for a camera to keep a list + of points in the camera's field of view. + + Examples + ------------ + ```python + points = np.array([0, 0, 0], [1, 1, 1]) + scene.camera_transform = scene.camera.look_at(points) + ``` + + Parameters + ------------- + points : (n, 3) float + Points in space + fov : (2,) float + Field of view, in DEGREES + rotation : None, or (4, 4) float + Rotation matrix for initial rotation + distance : None or float + Distance from camera to center + center : None, or (3,) float + Center of field of view. + + Returns + -------------- + transform : (4, 4) float + Transformation matrix from world to camera + """ + + if rotation is None: + rotation = np.eye(4) + else: + rotation = np.asanyarray(rotation, dtype=np.float64) + points = np.asanyarray(points, dtype=np.float64) + + # Transform points to camera frame (just use the rotation part) + rinv = rotation[:3, :3].T + points_c = rinv.dot(points.T).T + + if center is None: + # Find the center of the points' AABB in camera frame + center_c = points_c.min(axis=0) + 0.5 * np.ptp(points_c, axis=0) + else: + # Transform center to camera frame + center_c = rinv.dot(center) + + # Re-center the points around the camera-frame origin + points_c -= center_c + + # Find the minimum distance for the camera from the origin + # so that all points fit in the view frustum + tfov = np.tan(np.radians(fov) / 2.0) + + if distance is None: + distance = np.max(np.abs(points_c[:, :2]) / tfov + points_c[:, 2][:, np.newaxis]) + + if pad is not None: + distance *= pad + + # set the pose translation + center_w = rotation[:3, :3].dot(center_c) + cam_pose = rotation.copy() + cam_pose[:3, 3] = center_w + distance * cam_pose[:3, 2] + + return cam_pose + + +def ray_pixel_coords(camera): + """ + Get the x-y coordinates of rays in camera coordinates at + z == -1. + + One coordinate pair will be given for each pixel as defined in + camera.resolution. If reshaped, the returned array corresponds + to pixels of the rendered image. + + Examples + ------------ + ```python + xy = ray_pixel_coords(camera).reshape( + tuple(camera.coordinates) + (2,)) + top_left == xy[0, 0] + bottom_right == xy[-1, -1] + ``` + + Parameters + -------------- + camera : trimesh.scene.Camera + Camera object to generate rays from + + Returns + -------------- + xy : (n, 2) float + x-y coordinates of intersection of each camera ray + with the z == -1 frame + """ + # shorthand + res = camera.resolution + half_fov = np.radians(camera.fov) / 2.0 + + right_top = np.tan(half_fov) + # move half a pixel width in + right_top *= 1 - (1.0 / res) + left_bottom = -right_top + # we are looking down the negative z axis, so + # right_top corresponds to maximum x/y values + # bottom_left corresponds to minimum x/y values + right, top = right_top + left, bottom = left_bottom + + # create a grid of vectors + xy = util.grid_linspace( + bounds=[[left, top], [right, bottom]], count=camera.resolution + ) + + # create a matching array of pixel indexes for the rays + pixels = util.grid_linspace( + bounds=[[0, res[1] - 1], [res[0] - 1, 0]], count=res + ).astype(np.int64) + assert xy.shape == pixels.shape + + return xy, pixels + + +def camera_to_rays(camera: Camera): + """ + Calculate the trimesh.scene.Camera object to direction vectors. + + Will return one ray per pixel, as set in camera.resolution. + + Parameters + -------------- + camera : trimesh.scene.Camera + + Returns + -------------- + vectors : (n, 3) float + Ray direction vectors in camera frame with z == -1 + """ + # get the on-plane coordinates + xy, pixels = ray_pixel_coords(camera) + # convert vectors to 3D unit vectors + vectors = util.unitize(np.column_stack((xy, -np.ones_like(xy[:, :1])))) + return vectors, pixels diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/lighting.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/lighting.py new file mode 100644 index 0000000000000000000000000000000000000000..49a3b17f8289af3b0889a359730a002f6ebcf98f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/lighting.py @@ -0,0 +1,254 @@ +""" +lighting.py +-------------- + +Hold basic information about lights. + +Forked from the light model in `pyrender`: +https://github.com/mmatl/pyrender +""" + +import numpy as np + +from .. import transformations, util, visual +from ..typed import NDArray, float64 + +# default light color +_DEFAULT_RGBA = np.array([60, 60, 60, 255], dtype=np.uint8) + + +class Light(util.ABC): + """ + Base class for all light objects. + + Attributes + ---------- + name : str, optional + Name of the light. + color : (4,) uint8 + RGBA value for the light's color in linear space. + intensity : float + Brightness of light. The units that this is defined in depend + on the type of light: point and spot lights use luminous intensity + in candela (lm/sr) while directional lights use illuminance + in lux (lm/m2). + radius : float + Cutoff distance at which light's intensity may be considered to + have reached zero. Supported only for point and spot lights + Must be > 0.0 + If None, the radius is assumed to be infinite. + """ + + def __init__(self, name=None, color=None, intensity=None, radius=None): + if name is None: + # if name is not passed, make it something unique + self.name = f"light_{util.unique_id(6).upper()}" + else: + # otherwise assign it + self.name = name + + self.color = color + self.intensity = intensity + self.radius = radius + + @property + def color(self): + return self._color + + @color.setter + def color(self, value): + if value is None: + self._color = _DEFAULT_RGBA + else: + value = visual.to_rgba(value) + if len(value.shape) == 2: + value = value[0] + if value.shape != (4,): + raise ValueError("couldn't convert color to RGBA!") + # uint8 RGB color + self._color = value + + @property + def intensity(self): + return self._intensity + + @intensity.setter + def intensity(self, value): + if value is not None: + self._intensity = float(value) + else: + self._intensity = 1.0 + + @property + def radius(self): + return self._radius + + @radius.setter + def radius(self, value): + if value is None or value < 0.0: + self._radius = value + else: + self._radius = float(value) + + +class DirectionalLight(Light): + """ + Directional lights are light sources that act as though they are + infinitely far away and emit light in the direction of the local -z axis. + This light type inherits the orientation of the node that it belongs to; + position and scale are ignored except for their effect on the inherited + node orientation. Because it is at an infinite distance, the light is + not attenuated. Its intensity is defined in lumens per metre squared, + or lux (lm/m2). + + Attributes + ---------- + name : str, optional + Name of the light. + color : (4,) unit8 + RGBA value for the light's color in linear space. + intensity : float + Brightness of light. The units that this is defined in depend + on the type of light. + point and spot lights use luminous intensity in candela (lm/sr), + while directional lights use illuminance in lux (lm/m2). + radius : float + Cutoff distance at which light's intensity may be considered to + have reached zero. Supported only for point and spot lights, must be > 0. + If None, the radius is assumed to be infinite. + """ + + def __init__(self, name=None, color=None, intensity=None, radius=None): + super().__init__(name=name, color=color, intensity=intensity, radius=radius) + + +class PointLight(Light): + """ + Point lights emit light in all directions from their position in space; + rotation and scale are ignored except for their effect on the inherited + node position. The brightness of the light attenuates in a physically + correct manner as distance increases from the light's position (i.e. + brightness goes like the inverse square of the distance). Point light + intensity is defined in candela, which is lumens per square radian (lm/sr). + + Attributes + ---------- + name : str, optional + Name of the light. + color : (4,) uint8 + RGBA value for the light's color in linear space. + intensity : float + Brightness of light. The units that this is defined in depend + on the type of light. + point and spot lights use luminous intensity in candela (lm/sr), + while directional lights use illuminance in lux (lm/m2). + radius : float + Cutoff distance at which light's intensity may be considered to + have reached zero. Supported only for point and spot lights, must be > 0. + If None, the radius is assumed to be infinite. + """ + + def __init__(self, name=None, color=None, intensity=None, radius=None): + super().__init__(name=name, color=color, intensity=intensity, radius=radius) + + +class SpotLight(Light): + """ + Spot lights emit light in a cone in the direction of the local -z axis. + The angle and falloff of the cone is defined using two numbers, the + `innerConeAngle` and `outerConeAngle`. As with point lights, the brightness + also attenuates in a physically correct manner as distance increases from + the light's position (i.e. brightness goes like the inverse square of the + distance). Spot light intensity refers to the brightness inside the + `innerConeAngle` (and at the location of the light) and is defined in + candela, which is lumens per square radian (lm/sr). A spot light's position + and orientation are inherited from its node transform. Inherited scale does + not affect cone shape, and is ignored except for its effect on position + and orientation. + + Attributes + ---------- + name : str, optional + Name of the light. + color : (4,) uint8 + RGBA value for the light's color in linear space. + intensity : float + Brightness of light. The units that this is defined in depend + on the type of light. + point and spot lights use luminous intensity in candela (lm/sr), + while directional lights use illuminance in lux (lm/m2). + radius : float + Cutoff distance at which light's intensity may be considered to + have reached zero. Supported only for point and spot lights, must be > 0. + If None, the radius is assumed to be infinite. + innerConeAngle : float + Angle, in radians, from centre of spotlight where falloff begins. + Must be greater than or equal to `0` and less than `outerConeAngle`. + outerConeAngle : float + Angle, in radians, from centre of spotlight where falloff ends. + Must be greater than `innerConeAngle` and less than or equal to `PI / 2.0`. + """ + + def __init__( + self, + name=None, + color=None, + intensity=None, + radius=None, + innerConeAngle=0.0, + outerConeAngle=np.pi / 4.0, + ): + super().__init__(name=name, color=color, intensity=intensity, radius=radius) + self.outerConeAngle = outerConeAngle + self.innerConeAngle = innerConeAngle + + @property + def innerConeAngle(self): + return self._innerConeAngle + + @innerConeAngle.setter + def innerConeAngle(self, value): + if value < 0.0 or value > self.outerConeAngle: + raise ValueError("Invalid value for inner cone angle") + self._innerConeAngle = float(value) + + @property + def outerConeAngle(self): + return self._outerConeAngle + + @outerConeAngle.setter + def outerConeAngle(self, value): + if value < 0.0 or value > np.pi / 2.0 + 1e-9: + raise ValueError("Invalid value for outer cone angle") + self._outerConeAngle = float(value) + + +def autolight(scene) -> tuple[list[Light], list[NDArray[float64]]]: + """ + Generate a list of lights for a scene that looks decent. + + Parameters + -------------- + scene : trimesh.Scene + Scene with geometry + + Returns + -------------- + lights : [Light] + List of light objects + transforms : (len(lights), 4, 4) float + Transformation matrices for light positions. + """ + + # start with empty lights and transforms + lights = [] + transforms = [] + + # if there are no objects in the scene don't crash + bounds = scene.bounds + if bounds is not None: + # create two translation matrices for bounds corners + transforms.extend(transformations.translation_matrix(b) for b in bounds) + lights.extend(PointLight() for _ in range(2)) + + return lights, transforms diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/scene.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/scene.py new file mode 100644 index 0000000000000000000000000000000000000000..ac3de2dd15707265ac9264f2b724755b90d9488f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/scene.py @@ -0,0 +1,1637 @@ +import collections +import uuid +import warnings +from copy import deepcopy +from hashlib import sha256 +from typing import TypeAlias + +# ruff doesn't recognize this correctly when we re-import it from trimesh.typed -_- +import numpy as np + +from .. import caching, convex, grouping, inertia, transformations, units, util +from ..constants import log +from ..exchange import export +from ..parent import Geometry, Geometry3D +from ..registration import procrustes +from ..typed import ( + ArrayLike, + Floating, + Hashable, + Integer, + Iterable, + NDArray, + Sequence, + ViewerType, + float64, + int64, +) +from ..util import unique_name +from . import cameras, lighting +from .transforms import SceneGraph + +# the types of objects we can create a scene from +GeometryInput: TypeAlias = Geometry | Iterable[Geometry] | dict[str, Geometry] | ArrayLike + + +class Scene(Geometry3D): + """ + A simple scene graph which can be rendered directly via + pyglet/openGL or through other endpoints such as a + raytracer. Meshes are added by name, which can then be + moved by updating transform in the transform tree. + """ + + def __init__( + self, + geometry: GeometryInput | None = None, + base_frame: Hashable = "world", + metadata: dict | None = None, + graph: SceneGraph | None = None, + camera: cameras.Camera | None = None, + lights: Sequence[lighting.Light] | None = None, + camera_transform: NDArray | None = None, + ): + """ + Create a new Scene object. + + Parameters + ------------- + geometry : Trimesh, Path2D, Path3D PointCloud or list + Geometry to initially add to the scene + base_frame + Name of base frame + metadata + Any metadata about the scene + graph + A passed transform graph to use + camera : Camera or None + A passed camera to use + lights : [trimesh.scene.lighting.Light] or None + A passed lights to use + camera_transform + Homogeneous (4, 4) camera transform in the base frame + """ + # mesh name : Trimesh object + self.geometry = collections.OrderedDict() + + # create a new graph + self.graph = SceneGraph(base_frame=base_frame) + + # create our cache + self._cache = caching.Cache(id_function=self.__hash__) + + if geometry is not None: + # add passed geometry to scene + self.add_geometry(geometry) + + # hold metadata about the scene + self.metadata = {} + if isinstance(metadata, dict): + self.metadata.update(metadata) + + if graph is not None: + # if we've been passed a graph override the default + self.graph = graph + + if lights is not None: + self.lights = lights + if camera is not None: + self.camera = camera + if camera_transform is not None: + self.camera_transform = camera_transform + + def apply_transform(self, transform): + """ + Apply a transform to all children of the base frame + without modifying any geometry. + + Parameters + -------------- + transform : (4, 4) + Homogeneous transformation matrix. + """ + base = self.graph.base_frame + for child in self.graph.transforms.children[base]: + combined = np.dot(transform, self.graph[child][0]) + self.graph.update(frame_from=base, frame_to=child, matrix=combined) + return self + + def add_geometry( + self, + geometry: GeometryInput, + node_name: Hashable | None = None, + geom_name: str | None = None, + parent_node_name: Hashable | None = None, + transform: NDArray | None = None, + metadata: dict | None = None, + ): + """ + Add a geometry to the scene. + + If the mesh has multiple transforms defined in its + metadata, they will all be copied into the + TransformForest of the current scene automatically. + + Parameters + ---------- + geometry : Trimesh, Path2D, Path3D PointCloud or list + Geometry to initially add to the scene + node_name : None or str + Name of the added node. + geom_name : None or str + Name of the added geometry. + parent_node_name : None or str + Name of the parent node in the graph. + transform : None or (4, 4) float + Transform that applies to the added node. + metadata : None or dict + Optional metadata for the node. + + Returns + ---------- + node_name : str + Name of single node in self.graph (passed in) or None if + node was not added (eg. geometry was null or a Scene). + """ + + if geometry is None: + return + # PointCloud objects will look like a sequence + elif util.is_sequence(geometry): + # if passed a sequence add all elements + return [ + self.add_geometry( + geometry=value, + node_name=node_name, + geom_name=geom_name, + parent_node_name=parent_node_name, + transform=transform, + metadata=metadata, + ) + for value in geometry # type: ignore + ] + elif isinstance(geometry, dict): + # if someone passed us a dict of geometry + return { + k: self.add_geometry(geometry=v, geom_name=k, metadata=metadata) + for k, v in geometry.items() + } + + elif isinstance(geometry, Scene): + # concatenate current scene with passed scene + concat = self + geometry + # replace geometry in-place + self.geometry.clear() + self.geometry.update(concat.geometry) + # replace graph data with concatenated graph + self.graph.transforms = concat.graph.transforms + return + + # get or create a name to reference the geometry by + if geom_name is not None: + # if name is passed use it + name = geom_name + elif "name" in geometry.metadata: + # if name is in metadata use it + name = geometry.metadata["name"] + elif geometry.source.file_name is not None: + name = geometry.source.file_name + else: + # try to create a simple name + name = "geometry_" + str(len(self.geometry)) + + # if its already taken use our unique name logic + name = unique_name(start=name, contains=self.geometry.keys()) + # save the geometry reference + self.geometry[name] = geometry + + # create a unique node name if not passed + if node_name is None: + # if the name of the geometry is also a transform node + # which graph nodes already exist + existing = self.graph.transforms.node_data.keys() + # find a name that isn't contained already starting + # at the name we have + node_name = unique_name(name, existing) + assert node_name not in existing + + if transform is None: + # create an identity transform from parent_node + transform = np.eye(4) + + self.graph.update( + frame_to=node_name, + frame_from=parent_node_name, + matrix=transform, + geometry=name, + geometry_flags={"visible": True}, + metadata=metadata, + ) + + return node_name + + def delete_geometry(self, names: set | str | Sequence) -> None: + """ + Delete one more multiple geometries from the scene and also + remove any node in the transform graph which references it. + + Parameters + -------------- + name : hashable + Name that references self.geometry + """ + # make sure we have a set we can check + if isinstance(names, str): + names = [names] + names = set(names) + + # remove the geometry reference from relevant nodes + self.graph.remove_geometries(names) + # remove the geometries from our geometry store + [self.geometry.pop(name, None) for name in names] + + def strip_visuals(self) -> None: + """ + Strip visuals from every Trimesh geometry + and set them to an empty `ColorVisuals`. + """ + from ..visual.color import ColorVisuals + + for geometry in self.geometry.values(): + if util.is_instance_named(geometry, "Trimesh"): + geometry.visual = ColorVisuals(mesh=geometry) + + def simplify_quadric_decimation( + self, + percent: Floating | None = None, + face_count: Integer | None = None, + aggression: Integer | None = None, + ) -> None: + """ + Apply in-place `mesh.simplify_quadric_decimation` to any meshes + in the scene. + + Parameters + ----------- + percent + A number between 0.0 and 1.0 for how much + face_count + Target number of faces desired in the resulting mesh. + aggression + An integer between `0` and `10`, the scale being roughly + `0` is "slow and good" and `10` being "fast and bad." + + """ + # save the updates for after the loop + updates = {} + for k, v in self.geometry.items(): + if hasattr(v, "simplify_quadric_decimation"): + updates[k] = v.simplify_quadric_decimation( + percent=percent, face_count=face_count, aggression=aggression + ) + self.geometry.update(updates) + + def __hash__(self) -> int: + """ + Return information about scene which is hashable. + + Returns + --------- + hashed + String hashing scene. + """ + # avoid accessing attribute in tight loop + geometry = self.geometry + # hash of geometry and transforms + # start with the last modified time of the scene graph + hashable = [hex(self.graph.transforms.__hash__())] + # take the re-hex string of the hash + hashable.extend(hex(geometry[k].__hash__()) for k in geometry.keys()) + return caching.hash_fast("".join(hashable).encode("utf-8")) + + @property + def is_empty(self) -> bool: + """ + Does the scene have anything in it. + + Returns + ---------- + is_empty + True if nothing is in the scene + """ + + return len(self.geometry) == 0 + + @property + def is_valid(self) -> bool: + """ + Is every geometry connected to the root node. + + Returns + ----------- + is_valid : bool + Does every geometry have a transform + """ + if len(self.geometry) == 0: + return True + + try: + referenced = {self.graph[i][1] for i in self.graph.nodes_geometry} + except BaseException: + # if connectivity to world frame is broken return false + return False + + # every geometry is referenced + return referenced == set(self.geometry.keys()) + + @caching.cache_decorator + def bounds_corners(self) -> dict[str, NDArray[float64]]: + """ + Get the post-transform AABB for each node + which has geometry defined. + + Returns + ----------- + corners + Bounds for each node with vertices: + {node_name : (2, 3) float} + """ + # collect AABB for each geometry + corners = {} + # collect vertices for every mesh + vertices = { + k: m.vertices if hasattr(m, "vertices") and len(m.vertices) > 0 else m.bounds + for k, m in self.geometry.items() + } + # handle 2D geometries + vertices.update( + { + k: np.column_stack((v, np.zeros(len(v)))) + for k, v in vertices.items() + if v is not None and v.shape[1] == 2 + } + ) + + # loop through every node with geometry + for node_name in self.graph.nodes_geometry: + # access the transform and geometry name from node + transform, geometry_name = self.graph[node_name] + # will be None if no vertices for this node + points = vertices.get(geometry_name) + # skip empty geometries + if points is None: + continue + # apply just the rotation to skip N multiplies + dot = np.dot(transform[:3, :3], points.T) + # append the AABB with translation applied after + corners[node_name] = np.array( + [dot.min(axis=1) + transform[:3, 3], dot.max(axis=1) + transform[:3, 3]] + ) + return corners + + @caching.cache_decorator + def bounds(self) -> NDArray[float64] | None: + """ + Return the overall bounding box of the scene. + + Returns + -------- + bounds : (2, 3) float or None + Position of [min, max] bounding box + Returns None if no valid bounds exist + """ + bounds_corners = self.bounds_corners + if len(bounds_corners) == 0: + return None + # combine each geometry node AABB into a larger list + corners = np.vstack(list(self.bounds_corners.values())) + return np.array([corners.min(axis=0), corners.max(axis=0)], dtype=np.float64) + + @caching.cache_decorator + def extents(self) -> NDArray[float64] | None: + """ + Return the axis aligned box size of the current scene + or None if the scene is empty. + + Returns + ---------- + extents + Bounding box sides length or None for empty scene. + """ + bounds = self.bounds + if bounds is None: + return None + return np.diff(bounds, axis=0).reshape(-1) + + @caching.cache_decorator + def scale(self) -> float: + """ + The approximate scale of the mesh + + Returns + ----------- + scale : float + The mean of the bounding box edge lengths + """ + extents = self.extents + if extents is None: + return 1.0 + return float((extents**2).sum() ** 0.5) + + @caching.cache_decorator + def centroid(self) -> NDArray[float64] | None: + """ + Return the center of the bounding box for the scene. + + Returns + -------- + centroid : (3) float + Point for center of bounding box + """ + bounds = self.bounds + if bounds is None: + return None + centroid = np.mean(self.bounds, axis=0) + return centroid + + @caching.cache_decorator + def center_mass(self) -> NDArray: + """ + Find the center of mass for every instance in the scene. + + Returns + ------------ + center_mass : (3,) float + The center of mass of the scene + """ + # get the center of mass and volume for each geometry + center_mass = { + k: m.center_mass + for k, m in self.geometry.items() + if hasattr(m, "center_mass") + } + mass = {k: m.mass for k, m in self.geometry.items() if hasattr(m, "mass")} + + # get the geometry name and transform for each instance + graph = self.graph + instance = [graph[n] for n in graph.nodes_geometry] + + # get the transformed center of mass for each instance + transformed = np.array( + [ + np.dot(mat, np.append(center_mass[g], 1))[:3] + for mat, g in instance + if g in center_mass + ], + dtype=np.float64, + ) + # weight the center of mass locations by volume + weights = np.array([mass[g] for _, g in instance], dtype=np.float64) + weights /= weights.sum() + return (transformed * weights.reshape((-1, 1))).sum(axis=0) + + @caching.cache_decorator + def moment_inertia(self): + """ + Return the moment of inertia of the current scene with + respect to the center of mass of the current scene. + + Returns + ------------ + inertia : (3, 3) float + Inertia with respect to cartesian axis at `scene.center_mass` + """ + return inertia.scene_inertia( + scene=self, transform=transformations.translation_matrix(self.center_mass) + ) + + def moment_inertia_frame(self, transform): + """ + Return the moment of inertia of the current scene relative + to a transform from the base frame. + + Parameters + transform : (4, 4) float + Homogeneous transformation matrix. + + Returns + ------------- + inertia : (3, 3) float + Inertia tensor at requested frame. + """ + return inertia.scene_inertia(scene=self, transform=transform) + + @caching.cache_decorator + def area(self) -> float: + """ + What is the summed area of every geometry which + has area. + + Returns + ------------ + area : float + Summed area of every instanced geometry + """ + # get the area of every geometry that has an area property + areas = {n: g.area for n, g in self.geometry.items() if hasattr(g, "area")} + # sum the area including instancing + return sum( + (areas.get(self.graph[n][1], 0.0) for n in self.graph.nodes_geometry), 0.0 + ) + + @caching.cache_decorator + def volume(self) -> float64: + """ + What is the summed volume of every geometry which + has volume + + Returns + ------------ + volume : float + Summed area of every instanced geometry + """ + # get the area of every geometry that has a volume attribute + volume = {n: g.volume for n, g in self.geometry.items() if hasattr(g, "area")} + # sum the area including instancing + return sum( + (volume.get(self.graph[n][1], 0.0) for n in self.graph.nodes_geometry), 0.0 + ) + + @caching.cache_decorator + def triangles(self) -> NDArray[float64]: + """ + Return a correctly transformed polygon soup of the + current scene. + + Returns + ---------- + triangles : (n, 3, 3) float + Triangles in space + """ + triangles = [] + triangles_node = [] + for node_name in self.graph.nodes_geometry: + # which geometry does this node refer to + transform, geometry_name = self.graph[node_name] + + # get the actual potential mesh instance + geometry = self.geometry[geometry_name] + if not hasattr(geometry, "triangles"): + continue + # append the (n, 3, 3) triangles to a sequence + triangles.append( + transformations.transform_points( + geometry.triangles.copy().reshape((-1, 3)), matrix=transform + ) + ) + # save the node names for each triangle + triangles_node.append(np.tile(node_name, len(geometry.triangles))) + # save the resulting nodes to the cache + self._cache["triangles_node"] = np.hstack(triangles_node) + return np.vstack(triangles).reshape((-1, 3, 3)) + + @caching.cache_decorator + def triangles_node(self): + """ + Which node of self.graph does each triangle come from. + + Returns + --------- + triangles_index : (len(self.triangles),) + Node name for each triangle + """ + populate = self.triangles # NOQA + return self._cache["triangles_node"] + + @caching.cache_decorator + def geometry_identifiers(self) -> dict[str, str]: + """ + Look up geometries by identifier hash. + + Returns + --------- + identifiers + {Identifier hash: key in self.geometry} + """ + return {mesh.identifier_hash: name for name, mesh in self.geometry.items()} + + @caching.cache_decorator + def identifier_hash(self) -> str: + """ + Get a unique identifier for the scene. + """ + dump = "".join(g.identifier_hash for g in self.geometry.values()) + str( + hash(self.graph) + ) + return sha256(dump.encode()).hexdigest() + + @caching.cache_decorator + def duplicate_nodes(self) -> list[list[str]]: + """ + Return a sequence of node keys of identical meshes. + + Will include meshes with different geometry but identical + spatial hashes as well as meshes repeated by self.nodes. + + Returns + ----------- + duplicates + Keys of self.graph that represent identical geometry + """ + # if there is no geometry we can have no duplicate nodes + if len(self.geometry) == 0: + return [] + + # geometry name : hash of mesh + hashes = { + k: int(m.identifier_hash, 16) + for k, m in self.geometry.items() + if hasattr(m, "identifier_hash") + } + + # bring into local scope for loop + graph = self.graph + # get a hash for each node name + # scene.graph node name : hashed geometry + node_hash = {node: hashes.get(graph[node][1]) for node in graph.nodes_geometry} + + # collect node names for each hash key + duplicates = collections.defaultdict(list) + # use a slightly off-label list comprehension + # for debatable function call overhead avoidance + [ + duplicates[hashed].append(node) + for node, hashed in node_hash.items() + if hashed is not None + ] + + # we only care about the values keys are garbage + return list(duplicates.values()) + + def reconstruct_instances(self, cost_threshold: Floating = 1e-5) -> "Scene": + """ + If a scene has been "baked" with meshes it means that + the duplicate nodes have *corresponding vertices* but are + rigidly transformed to different places. + + This means the problem of finding ab instance transform can + use the `procrustes` analysis which is *very* fast relative + to more complicated registration problems that require ICP + and nearest-point-on-surface calculations. + + TODO : construct a parent non-geometry node for containing every group. + + Parameters + ---------- + scene + The scene to handle. + cost_threshold + The maximum value for `procrustes` cost which is "squared mean + vertex distance between pair". If the fit is above this value + the instance will be left even if it is a duplicate. + + Returns + --------- + dedupe + A copy of the scene de-duplicated as much as possible. + """ + return reconstruct_instances(self, cost_threshold=cost_threshold) + + def set_camera( + self, angles=None, distance=None, center=None, resolution=None, fov=None + ) -> cameras.Camera: + """ + Create a camera object for self.camera, and add + a transform to self.graph for it. + + If arguments are not passed sane defaults will be figured + out which show the mesh roughly centered. + + Parameters + ----------- + angles : (3,) float + Initial euler angles in radians + distance : float + Distance from centroid + center : (3,) float + Point camera should be center on + camera : Camera object + Object that stores camera parameters + """ + + if fov is None: + fov = np.array([60, 45]) + + # if no geometry nothing to set camera to + if len(self.geometry) == 0: + self._camera = cameras.Camera(fov=fov) + self.graph[self._camera.name] = np.eye(4) + return self._camera + # set with no rotation by default + if angles is None: + angles = np.zeros(3) + + rotation = transformations.euler_matrix(*angles) + transform = cameras.look_at( + self.bounds, fov=fov, rotation=rotation, distance=distance, center=center + ) + + if hasattr(self, "_camera") and self._camera is not None: + self._camera.fov = fov + if resolution is not None: + self._camera.resolution = resolution + else: + # create a new camera object + self._camera = cameras.Camera(fov=fov, resolution=resolution) + + self.graph[self._camera.name] = transform + + return self._camera + + @property + def camera_transform(self): + """ + Get camera transform in the base frame. + + Returns + ------- + camera_transform : (4, 4) float + Camera transform in the base frame + """ + return self.graph[self.camera.name][0] + + @camera_transform.setter + def camera_transform(self, matrix: ArrayLike): + """ + Set the camera transform in the base frame + + Parameters + ---------- + camera_transform : (4, 4) float + Camera transform in the base frame + """ + self.graph[self.camera.name] = matrix + + def camera_rays(self) -> tuple[NDArray[float64], NDArray[float64], NDArray[int64]]: + """ + Calculate the trimesh.scene.Camera origin and ray + direction vectors. Returns one ray per pixel as set + in camera.resolution + + Returns + -------------- + origin: (n, 3) float + Ray origins in space + vectors: (n, 3) float + Ray direction unit vectors in world coordinates + pixels : (n, 2) int + Which pixel does each ray correspond to in an image + """ + # get the unit vectors of the camera + vectors, pixels = self.camera.to_rays() + # find our scene's transform for the camera + transform = self.camera_transform + # apply the rotation to the unit ray direction vectors + vectors = transformations.transform_points(vectors, transform, translate=False) + # camera origin is single point so extract from + origins = np.ones_like(vectors) * transformations.translation_from_matrix( + transform + ) + return origins, vectors, pixels + + @property + def camera(self) -> cameras.Camera: + """ + Get the single camera for the scene. If not manually + set one will abe automatically generated. + + Returns + ---------- + camera : trimesh.scene.Camera + Camera object defined for the scene + """ + # no camera set for the scene yet + if not self.has_camera: + # will create a camera with everything in view + return self.set_camera() + assert self._camera is not None + + return self._camera + + @camera.setter + def camera(self, camera: cameras.Camera | None): + """ + Set a camera object for the Scene. + + Parameters + ----------- + camera : trimesh.scene.Camera + Camera object for the scene + """ + if camera is None: + return + self._camera = camera + + @property + def has_camera(self) -> bool: + return hasattr(self, "_camera") and self._camera is not None + + @property + def lights(self) -> list[lighting.Light]: + """ + Get a list of the lights in the scene. If nothing is + set it will generate some automatically. + + Returns + ------------- + lights : [trimesh.scene.lighting.Light] + Lights in the scene. + """ + if not hasattr(self, "_lights") or self._lights is None: + # do some automatic lighting + lights, transforms = lighting.autolight(self) + # assign the transforms to the scene graph + for L, T in zip(lights, transforms): + self.graph[L.name] = T + # set the lights + self._lights = lights + return self._lights + + @lights.setter + def lights(self, lights: Sequence[lighting.Light]): + """ + Assign a list of light objects to the scene + + Parameters + -------------- + lights : [trimesh.scene.lighting.Light] + Lights in the scene. + """ + self._lights = lights + + def rezero(self) -> None: + """ + Move the current scene so that the AABB of the whole + scene is centered at the origin. + + Does this by changing the base frame to a new, offset + base frame. + """ + if self.is_empty or np.allclose(self.centroid, 0.0): + # early exit since what we want already exists + return + + # the transformation to move the overall scene to AABB centroid + matrix = np.eye(4) + matrix[:3, 3] = -self.centroid + + # we are going to change the base frame + new_base = str(self.graph.base_frame) + "_I" + self.graph.update( + frame_from=new_base, frame_to=self.graph.base_frame, matrix=matrix + ) + self.graph.base_frame = new_base + + def dump(self, concatenate: bool = False) -> list[Geometry]: + """ + Get a list of every geometry moved to its instance position, + i.e. freezing or "baking" transforms. + + Parameters + ------------ + concatenate + KWARG IS DEPRECATED FOR REMOVAL APRIL 2025 + Concatenate results into single geometry. + This keyword argument will make the type hint incorrect and + you should replace `Scene.dump(concatenate=True)` with: + - `Scene.to_geometry()` for a Trimesh, Path2D or Path3D + - `Scene.to_mesh()` for only `Trimesh` components. + + Returns + ---------- + dumped + Copies of `Scene.geometry` transformed to their instance position. + """ + + result = [] + for node_name in self.graph.nodes_geometry: + transform, geometry_name = self.graph[node_name] + # get a copy of the geometry + current = self.geometry[geometry_name].copy() + + # if the geometry is 2D see if we have to upgrade to 3D + if hasattr(current, "to_3D"): + # check to see if the scene is transforming the path out of plane + check = util.isclose(transform, util._IDENTITY, atol=1e-8) + check[:2, :3] = True + if not check.all(): + # transform moves in 3D so we put this on the Z=0 plane + current = current.to_3D() + else: + # transform moves in 2D so clip off the last row and column + transform = transform[:3, :3] + + # move the geometry vertices into the requested frame + current.apply_transform(transform) + current.metadata["name"] = geometry_name + current.metadata["node"] = node_name + + # save to our list of meshes + result.append(current) + + if concatenate: + warnings.warn( + "`Scene.dump(concatenate=True)` DEPRECATED FOR REMOVAL APRIL 2025: replace with `Scene.to_geometry()`", + category=DeprecationWarning, + stacklevel=2, + ) + # if scene has mixed geometry this may drop some of it + return util.concatenate(result) # type: ignore + + return result + + def to_mesh(self) -> "trimesh.Trimesh": # noqa: F821 + """ + Concatenate every mesh instances in the scene into a single mesh, + applying transforms and "baking" the result. Will drop any geometry + in the scene that is not a `Trimesh` object. + + Returns + ---------- + mesh + All meshes in the scene concatenated into one. + """ + from ..base import Trimesh + + # concatenate only meshes + return util.concatenate([d for d in self.dump() if isinstance(d, Trimesh)]) + + def to_geometry(self) -> Geometry: + """ + Concatenate geometry in the scene into a single like-typed geometry, + applying the transforms and "baking" the result. May drop geometry + if the scene has mixed geometry. + + Returns + --------- + concat + Either a Trimesh, Path2D, or Path3D depending on what is in the scene. + """ + # concatenate everything and return the most-occurring type. + return util.concatenate(self.dump()) + + def subscene(self, node: Hashable) -> "Scene": + """ + Get part of a scene that succeeds a specified node. + + Parameters + ------------ + node + Hashable key in `scene.graph` + + Returns + ----------- + subscene + Partial scene generated from current. + """ + # get every node that is a successor to specified node + # this includes `node` + graph = self.graph + nodes = graph.transforms.successors(node) + # get every edge that has an included node + edges = [e for e in graph.to_edgelist() if e[0] in nodes] + + # create a scene graph when + graph = SceneGraph(base_frame=node) + graph.from_edgelist(edges) + + geometry_names = {e[2]["geometry"] for e in edges if "geometry" in e[2]} + geometry = {k: self.geometry[k] for k in geometry_names} + result = Scene(geometry=geometry, graph=graph) + return result + + @caching.cache_decorator + def convex_hull(self): + """ + The convex hull of the whole scene. + + Returns + --------- + hull : trimesh.Trimesh + Trimesh object which is a convex hull of all meshes in scene + """ + points = util.vstack_empty([m.vertices for m in self.dump()]) # type: ignore + return convex.convex_hull(points) + + def export(self, file_obj=None, file_type=None, **kwargs): + """ + Export a snapshot of the current scene. + + Parameters + ---------- + file_obj : str, file-like, or None + File object to export to + file_type : str or None + What encoding to use for meshes + IE: dict, dict64, stl + + Returns + ---------- + export : bytes + Only returned if file_obj is None + """ + return export.export_scene( + scene=self, file_obj=file_obj, file_type=file_type, **kwargs + ) + + def save_image(self, resolution=None, **kwargs) -> bytes: + """ + Get a PNG image of a scene. + + Parameters + ----------- + resolution : (2,) int + Resolution to render image + **kwargs + Passed to SceneViewer constructor + + Returns + ----------- + png : bytes + Render of scene as a PNG + """ + from ..viewer.windowed import render_scene + + return render_scene( + scene=self, resolution=resolution, fullscreen=False, resizable=False, **kwargs + ) + + @property + def units(self) -> str | None: + """ + Get the units for every model in the scene. If the scene has + mixed units or no units this will return None. + + Returns + ----------- + units + Units for every model in the scene or None + if there are no units or mixed units + """ + # get a set of the units of every geometry + existing = {i.units for i in self.geometry.values()} + if len(existing) == 1: + return existing.pop() + elif len(existing) > 1: + log.warning(f"Mixed units `{existing}` returning None") + return None + + @units.setter + def units(self, value: str): + """ + Set the units for every model in the scene without + converting any units just setting the tag. + + Parameters + ------------ + value : str + Value to set every geometry unit value to + """ + value = value.strip().lower() + for m in self.geometry.values(): + m.units = value + + def convert_units(self, desired: str, guess: bool = False) -> "Scene": + """ + If geometry has units defined convert them to new units. + + Returns a new scene with geometries and transforms scaled. + + Parameters + ---------- + desired : str + Desired final unit system: 'inches', 'mm', etc. + guess : bool + Is the converter allowed to guess scale when models + don't have it specified in their metadata. + + Returns + ---------- + scaled : trimesh.Scene + Copy of scene with scaling applied and units set + for every model + """ + # if there is no geometry do nothing + if len(self.geometry) == 0: + return self.copy() + + current = self.units + if current is None: + # will raise ValueError if not in metadata + # and not allowed to guess + current = units.units_from_metadata(self, guess=guess) + + # find the float conversion + scale = units.unit_conversion(current=current, desired=desired) + + # apply scaling factor or exit early if scale ~= 1.0 + result = self.scaled(scale=scale) + + # apply the units to every geometry of the scaled result + result.units = desired + + return result + + def explode(self, vector=None, origin=None) -> None: + """ + Explode the current scene in-place around a point and vector. + + Parameters + ----------- + vector : (3,) float or float + Explode radially around a direction vector or spherically + origin : (3,) float + Point to explode around + """ + if origin is None: + origin = self.centroid + if vector is None: + vector = self.scale / 25.0 + + vector = np.asanyarray(vector, dtype=np.float64) + origin = np.asanyarray(origin, dtype=np.float64) + + for node_name in self.graph.nodes_geometry: + transform, geometry_name = self.graph[node_name] + centroid = self.geometry[geometry_name].centroid + # transform centroid into nodes location + centroid = np.dot(transform, np.append(centroid, 1))[:3] + + if vector.shape == (): + # case where our vector is a single number + offset = (centroid - origin) * vector + elif np.shape(vector) == (3,): + projected = np.dot(vector, (centroid - origin)) + offset = vector * projected + else: + raise ValueError("explode vector wrong shape!") + + # original transform is read-only + T_new = transform.copy() + T_new[:3, 3] += offset + self.graph[node_name] = T_new + + def scaled(self, scale: Floating | ArrayLike) -> "Scene": + """ + Return a copy of the current scene, with meshes and scene + transforms scaled to the requested factor. + + Parameters + ----------- + scale : float or (3,) float + Factor to scale meshes and transforms + + Returns + ----------- + scaled : trimesh.Scene + A copy of the current scene but scaled + """ + result = self.copy() + + # a scale of 1.0 is a no-op + if np.allclose(scale, 1.0): + return result + + # convert 2D geometries to 3D for 3D scaling factors + scale_is_3D = isinstance(scale, (list, tuple, np.ndarray)) and len(scale) == 3 + + if scale_is_3D and np.all(np.asarray(scale) == scale[0]): + # scale is uniform + scale = float(scale[0]) + scale_is_3D = False + elif not scale_is_3D: + scale = float(scale) + + # result is a copy + + if scale_is_3D: + # Copy all geometries that appear multiple times in the scene, + # such that no two nodes share the same geometry. + # This is required since the non-uniform scaling will most likely + # affect the same geometry in different poses differently. + # Note, that this is not needed in the case of uniform scaling. + for geom_name in result.graph.geometry_nodes: + nodes_with_geom = result.graph.geometry_nodes[geom_name] + if len(nodes_with_geom) > 1: + geom = result.geometry[geom_name] + for n in nodes_with_geom: + p = result.graph.transforms.parents[n] + result.add_geometry( + geometry=geom.copy(), + geom_name=geom_name, + node_name=n, + parent_node_name=p, + transform=result.graph.transforms.edge_data[(p, n)].get( + "matrix", None + ), + metadata=result.graph.transforms.edge_data[(p, n)].get( + "metadata", None + ), + ) + result.delete_geometry(geom_name) + + # Convert all 2D paths to 3D paths + for geom_name in result.geometry: + if result.geometry[geom_name].vertices.shape[1] == 2: + result.geometry[geom_name] = result.geometry[geom_name].to_3D() + + for key in result.graph.nodes_geometry: + T, geom_name = result.graph.get(key) + # transform from graph should be read-only + T = T.copy() + T[:3, 3] = 0.0 + + # Get geometry transform w.r.t. base frame + result.geometry[geom_name].apply_transform(T).apply_scale( + scale + ).apply_transform(np.linalg.inv(T)) + + # Scale all transformations in the scene graph + edge_data = result.graph.transforms.edge_data + for uv in edge_data: + if "matrix" in edge_data[uv]: + props = edge_data[uv] + T = edge_data[uv]["matrix"].copy() + T[:3, 3] *= scale + props["matrix"] = T + result.graph.update(frame_from=uv[0], frame_to=uv[1], **props) + # Clear cache + result.graph.transforms._cache = {} + result.graph.transforms._modified = str(uuid.uuid4()) + result.graph._cache.clear() + else: + # matrix for 2D scaling + scale_2D = np.eye(3) * scale + # matrix for 3D scaling + scale_3D = np.eye(4) * scale + + # preallocate transforms and geometries + nodes = np.array(self.graph.nodes_geometry) + transforms = np.zeros((len(nodes), 4, 4)) + geometries = [None] * len(nodes) + + # collect list of transforms + for i, node in enumerate(nodes): + transforms[i], geometries[i] = self.graph[node] + + # remove all existing transforms + result.graph.clear() + + for group in grouping.group(geometries): + # hashable reference to self.geometry + geometry = geometries[group[0]] + # original transform from world to geometry + original = transforms[group[0]] + # transform for geometry + new_geom = np.dot(scale_3D, original) + + if result.geometry[geometry].vertices.shape[1] == 2: + # if our scene is 2D only scale in 2D + result.geometry[geometry].apply_transform(scale_2D) + else: + # otherwise apply the full transform + result.geometry[geometry].apply_transform(new_geom) + + for node, T in zip(nodes[group], transforms[group]): + # generate the new transforms + transform = util.multi_dot([scale_3D, T, np.linalg.inv(new_geom)]) + # apply scale to translation + transform[:3, 3] *= scale + # update scene with new transforms + result.graph.update( + frame_to=node, matrix=transform, geometry=geometry + ) + + # remove camera from copied + result._camera = None + + return result + + def copy(self) -> "Scene": + """ + Return a deep copy of the current scene + + Returns + ---------- + copied : trimesh.Scene + Copy of the current scene + """ + # use the geometries copy method to + # allow them to handle references to unpickle-able objects + geometry = {n: g.copy() for n, g in self.geometry.items()} + + if not hasattr(self, "_camera") or self._camera is None: + # if no camera set don't include it + camera = None + else: + # otherwise get a copy of the camera + camera = self.camera.copy() + # create a new scene with copied geometry and graph + copied = Scene( + geometry=geometry, + graph=self.graph.copy(), + metadata=self.metadata.copy(), + camera=camera, + ) + return copied + + def show( + self, + viewer: ViewerType = None, + **kwargs, + ): + """ + Display the current scene. + + Parameters + ----------- + viewer + What kind of viewer to use, such as + `gl` to open a pyglet window + `jupyter` for a jupyter notebook + `marimo'` for a marimo notebook + None for a "best guess" + kwargs + Passed to viewer, such as `smooth=False` which will turn + off automatic smooth shading + """ + + if viewer is None: + # check to see if we are in a notebook or not + from ..viewer import in_notebook + + # returns a literal for what kind of notebook, or False + viewer = in_notebook() + if not viewer: + viewer = "gl" + + if viewer == "gl": + # this imports pyglet, and will raise an ImportError + # if pyglet is not available + from ..viewer import SceneViewer + + return SceneViewer(self, **kwargs) + elif viewer == "jupyter": + from ..viewer import scene_to_notebook + + return scene_to_notebook(self, **kwargs) + elif viewer == "marimo": + from ..viewer import scene_to_mo_notebook + + return scene_to_mo_notebook(self, **kwargs) + elif callable(viewer): + # if a callable method like a custom class + # constructor was passed run using that + return viewer(self, **kwargs) + else: + raise ValueError( + "Invalid value for viewer: not 'gl', 'jupyter', 'marimo', callable, or None" + ) + + def __add__(self, other): + """ + Concatenate the current scene with another scene or mesh. + + Parameters + ------------ + other : trimesh.Scene, trimesh.Trimesh, trimesh.Path + Other object to append into the result scene + + Returns + ------------ + appended : trimesh.Scene + Scene with geometry from both scenes + """ + result = append_scenes([self, other], common=[self.graph.base_frame]) + return result + + +def split_scene(geometry, **kwargs): + """ + Given a geometry, list of geometries, or a Scene + return them as a single Scene object. + + Parameters + ---------- + geometry : splittable + + Returns + --------- + scene: trimesh.Scene + """ + # already a scene, so return it + if isinstance(geometry, Scene): + return geometry + + # save metadata + metadata = {} + + # a list of things + if util.is_sequence(geometry): + [metadata.update(getattr(g, "metadata", {})) for g in geometry] + + scene = Scene(geometry, metadata=metadata) + scene._source = next((g.source for g in geometry if g.source is not None), None) + else: + # a single geometry so we are going to split + scene = Scene( + geometry.split(**kwargs), + metadata=deepcopy(geometry.metadata), + ) + scene._source = deepcopy(geometry.source) + + return scene + + +def append_scenes(iterable, common=None, base_frame="world"): + """ + Concatenate multiple scene objects into one scene. + + Parameters + ------------- + iterable : (n,) Trimesh or Scene + Geometries that should be appended + common : (n,) str + Nodes that shouldn't be remapped + base_frame : str + Base frame of the resulting scene + + Returns + ------------ + result : trimesh.Scene + Scene containing all geometry + """ + if isinstance(iterable, Scene): + return iterable + + if common is None: + common = [base_frame] + + # save geometry in dict + geometry = {} + # save transforms as edge tuples + edges = [] + + # nodes which shouldn't be remapped + common = set(common) + # nodes which are consumed and need to be remapped + consumed = set() + + def node_remap(node): + """ + Remap node to new name if necessary + + Parameters + ------------- + node : hashable + Node name in original scene + + Returns + ------------- + name : hashable + Node name in concatenated scene + """ + + # if we've already remapped a node use it + if node in map_node: + return map_node[node] + + # if a node is consumed and isn't one of the nodes + # we're going to hold common between scenes remap it + if node not in common and node in consumed: + # generate a name not in consumed + name = node + util.unique_id() + map_node[node] = name + node = name + + # keep track of which nodes have been used + # in the current scene + current.add(node) + return node + + # loop through every geometry + for s in iterable: + # allow Trimesh/Path2D geometry to be passed + if hasattr(s, "scene"): + s = s.scene() + # if we don't have a scene raise an exception + if not isinstance(s, Scene): + raise ValueError(f"{type(s).__name__} is not a scene!") + + # remap geometries if they have been consumed + map_geom = {} + for k, v in s.geometry.items(): + # if a geometry already exists add a UUID to the name + name = unique_name(start=k, contains=geometry.keys()) + # store name mapping + map_geom[k] = name + # store geometry with new name + geometry[name] = v + + # remap nodes and edges so duplicates won't + # stomp all over each other + map_node = {} + # the nodes used in this scene + current = set() + for a, b, attr in s.graph.to_edgelist(): + # remap node names from local names + a, b = node_remap(a), node_remap(b) + # remap geometry keys + # if key is not in map_geom it means one of the scenes + # referred to geometry that doesn't exist + # rather than crash here we ignore it as the user + # possibly intended to add in geometries back later + if "geometry" in attr and attr["geometry"] in map_geom: + attr["geometry"] = map_geom[attr["geometry"]] + # save the new edge + edges.append((a, b, attr)) + # mark nodes from current scene as consumed + consumed.update(current) + + # add all data to a new scene + result = Scene(base_frame=base_frame) + result.graph.from_edgelist(edges) + result.geometry.update(geometry) + + return result + + +def reconstruct_instances(scene: Scene, cost_threshold: Floating = 1e-6) -> Scene: + """ + If a scene has been "baked" with meshes it means that + the duplicate nodes have *corresponding vertices* but are + rigidly transformed to different places. + + This means the problem of finding ab instance transform can + use the `procrustes` analysis which is *very* fast relative + to more complicated registration problems that require ICP + and nearest-point-on-surface calculations. + + TODO : construct a parent non-geometry node for containing every group. + + Parameters + ---------- + scene + The scene to handle. + cost_threshold + The maximum value for `procrustes` cost which is "squared mean + vertex distance between pair". If the fit is above this value + the instance will be left even if it is a duplicate. + + Returns + --------- + dedupe + A copy of the scene de-duplicated as much as possible. + """ + # start with the original scene graph and modify in-loop + graph = scene.graph.copy() + + for group in scene.duplicate_nodes: + # not sure if this ever includes + if len(group) < 2: + continue + + # we are going to use one of the geometries and try to register the others to it + node_base = group[0] + # get the geometry name for this base node + _, geom_base = scene.graph[node_base] + # get the vertices of the base model + base = scene.geometry[geom_base].vertices.view(np.ndarray) + + for node in group[1:]: + # the original pose of this node in the scene + node_mat, node_geom = scene.graph[node] + # procrustes matches corresponding point arrays very quickly + # but we have to make sure that they actual correspond in shape + node_vertices = scene.geometry[node_geom].vertices.view(np.ndarray) + + # procrustes only works on corresponding point clouds! + if node_vertices.shape != base.shape: + continue + + # solve for a pose moving this instance into position + matrix, _p, cost = procrustes( + base, node_vertices, translation=True, scale=False, reflection=False + ) + if cost < cost_threshold: + # add the transform we found + graph.update(node, matrix=np.dot(node_mat, matrix), geometry=geom_base) + + # get from the new graph which geometry ends up with a reference + referenced = set(graph.geometry_nodes.keys()) + + # return a scene with the de-duplicated graph and a copy of any geometry + return Scene( + geometry={k: v.copy() for k, v in scene.geometry.items() if k in referenced}, + graph=graph, + ) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/transforms.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/transforms.py new file mode 100644 index 0000000000000000000000000000000000000000..9915735df5de7933fe87e63bc614d17df0f01d92 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/scene/transforms.py @@ -0,0 +1,874 @@ +import collections +import itertools +from copy import deepcopy + +import numpy as np + +from .. import caching, util +from ..caching import hash_fast +from ..transformations import fix_rigid, quaternion_matrix, rotation_matrix +from ..typed import ArrayLike, Floating, Hashable, NDArray, Sequence + +# we compare to identity a lot +_identity = np.eye(4) +_identity.flags["WRITEABLE"] = False + +# default name for the root frame of a scene graph +DEFAULT_BASE_FRAME = "world" + + +class SceneGraph: + """ + Hold data about positions and instances of geometry + in a scene. This includes a forest (i.e. multi-root tree) + of transforms and information on which node is the base + frame, and which geometries are affiliated with which + nodes. + """ + + def __init__( + self, base_frame: Hashable | None = None, repair_rigid: Floating | None = 1e-5 + ): + """ + Create a scene graph, holding homogeneous transformation + matrices and instance information about geometry. + + Parameters + ----------- + base_frame + The root node transforms will be positioned from. + repair_rigid + If a float will attempt to repair rotation matrices + where `M @ M.T` differs from an identity matrix by + more than floating point zero but less than this value. + This can happen in a deep tree with a lot of matrix + multiplies. + """ + + # a graph structure, subclass of networkx DiGraph + self.transforms = EnforcedForest() + # hashable, the base or root frame — only replace None + # as falsy frames like `0` or `""` are valid node names + self.base_frame = base_frame if base_frame is not None else DEFAULT_BASE_FRAME + # if passed as a float try to repair rigid transforms + # that have accumulated floating point error + self.repair_rigid = repair_rigid + # cache transformation matrices keyed with tuples + self._cache = caching.Cache(self.__hash__) + + def update(self, frame_to, frame_from=None, **kwargs): + """ + Update a transform in the tree. + + Parameters + ------------ + frame_from : hashable object + Usually a string (eg 'world'). + If left as None it will be set to self.base_frame + frame_to : hashable object + Usually a string (eg 'mesh_0') + matrix : (4,4) float + Homogeneous transformation matrix + quaternion : (4,) float + Quaternion ordered [w, x, y, z] + axis : (3,) float + Axis of rotation + angle : float + Angle of rotation, in radians + translation : (3,) float + Distance to translate + geometry : hashable + Geometry object name, e.g. 'mesh_0' + metadata: dictionary + Optional metadata attached to the new frame + (exports to glTF node 'extras'). + """ + # if no frame specified, use base frame + if frame_from is None: + frame_from = self.base_frame + + # pass through + attr = {k: v for k, v in kwargs.items() if k in {"geometry", "metadata"}} + # convert various kwargs to a single matrix + attr["matrix"] = kwargs_to_matrix(**kwargs) + + # add the edges for the transforms + # wi ll return if it changed anything + self.transforms.add_edge(frame_from, frame_to, **attr) + + # set the node attribute with the geometry information + if "geometry" in kwargs: + self.transforms.node_data[frame_to]["geometry"] = kwargs["geometry"] + + def get( + self, frame_to: Hashable, frame_from: Hashable | None = None + ) -> tuple[NDArray[np.float64], Hashable | None]: + """ + Get the transform from one frame to another. + + Parameters + ------------ + frame_to : hashable + Node name, usually a string (eg 'mesh_0') + frame_from : hashable + Node name, usually a string (eg 'world'). + If None it will be set to self.base_frame + + Returns + ---------- + transform : (4, 4) float + Homogeneous transformation matrix + geometry + The name of the geometry if it exists + + Raises + ----------- + ValueError + If the frames aren't connected. + """ + + # use base frame if not specified + if frame_from is None: + frame_from = self.base_frame + + # look up transform to see if we have it already + key = (frame_from, frame_to) + if key in self._cache: + return self._cache[key] + + # get the geometry at the final node if any + geometry = self.transforms.node_data[frame_to].get("geometry") + + # get a local reference to edge data + data = self.transforms.edge_data + + if frame_from == frame_to: + # if we're going from ourself return identity + matrix = _identity + elif key in data: + # if the path is just an edge return early + matrix = data[key]["matrix"] + else: + # we have a 3+ node path + # get the path from the forest always going from + # parent -> child -> child + path = self.transforms.shortest_path(frame_from, frame_to) + # the path should always start with `frame_from` + assert path[0] == frame_from + # and end with the `frame_to` node + assert path[-1] == frame_to + + # loop through pairs of the path + matrices = [] + for u, v in itertools.pairwise(path): + forward = data.get((u, v)) + if forward is not None: + if "matrix" in forward: + # append the matrix from u to v + matrices.append(forward["matrix"]) + continue + # since forwards didn't exist backward must + # exist otherwise this is a disconnected path + # and we should raise an error anyway + backward = data[(v, u)] + if "matrix" in backward: + # append the inverted backwards matrix + matrices.append(np.linalg.inv(backward["matrix"])) + # filter out any identity matrices + matrices = [m for m in matrices if np.abs(m - _identity).max() > 1e-8] + if len(matrices) == 0: + matrix = _identity + elif len(matrices) == 1: + matrix = matrices[0] + else: + # multiply matrices into single transform + matrix = util.multi_dot(matrices) + + # if instructed to repair rigid transforms do it here + if self.repair_rigid is not None: + matrix = fix_rigid(matrix, max_deviance=self.repair_rigid) + + # matrix being edited in-place leads to subtle bugs + matrix.flags["WRITEABLE"] = False + + # store the result + self._cache[key] = (matrix, geometry) + + return matrix, geometry + + def __hash__(self): + return self.transforms.__hash__() + + def copy(self): + """ + Return a copy of the current TransformForest. + + Returns + ------------ + copied : TransformForest + Copy of current object. + """ + # create a copy without transferring cache + copied = SceneGraph() + copied.base_frame = deepcopy(self.base_frame) + copied.transforms = deepcopy(self.transforms) + return copied + + def to_flattened(self): + """ + Export the current transform graph with all + transforms baked into world->instance. + + Returns + --------- + flat : dict + Keyed {node : {transform, geometry} + """ + flat = {} + base_frame = self.base_frame + for node in self.nodes: + if node == base_frame: + continue + # get the matrix and geometry name + matrix, geometry = self.get(frame_to=node, frame_from=base_frame) + # store matrix as list rather than numpy array + flat[node] = {"transform": matrix.tolist(), "geometry": geometry} + + return flat + + def to_gltf(self, scene, mesh_index=None): + """ + Export a transforms as the 'nodes' section of the + GLTF header dict. + + Parameters + ------------ + scene : trimesh.Scene + Scene with geometry. + mesh_index : dict or None + Mapping { key in scene.geometry : int } + + Returns + -------- + gltf : dict + With 'nodes' referencing a list of dicts and 'scene_roots' + referencing the node indices the scene should start from. + """ + + if mesh_index is None: + # geometry is an OrderedDict + # map mesh name to index: {geometry key : index} + mesh_index = {name: i for i, name in enumerate(scene.geometry.keys())} + + # get graph information into local scope before loop + graph = self.transforms + # get the stored node data + node_data = graph.node_data + edge_data = graph.edge_data + base_frame = self.base_frame + # does the scene have a defined camera to export + has_camera = scene.has_camera + children = graph.children + + # the base frame is a synthetic wrapper: when it carries nothing + # export its children as the scene roots instead of writing it — + # a file node named like the base frame is renamed on import so + # writing one would grow a wrapper node on every round-trip + skip_base = ( + "geometry" not in node_data.get(base_frame, {}) + and not (has_camera and base_frame == scene.camera.name) + and len(children.get(base_frame, [])) > 0 + ) + + # list of dict, in gltf format + # {node name : node index in gltf} + if skip_base: + result = [] + lookup = {} + else: + result = [{"name": base_frame}] + lookup = {base_frame: 0} + + # collect the nodes in order + for node in node_data.keys(): + if node == base_frame: + continue + # assign the index to the node-name lookup + lookup[node] = len(result) + # populate a result at the correct index + result.append({"name": node}) + + extensions_used = set() + + # then iterate through to collect data + for info in result: + # name of the scene node + node = info["name"] + + # get the original node names for children + childs = children.get(node, []) + if len(childs) > 0: + info["children"] = [lookup[k] for k in childs] + + # if we have a mesh store by index + if "geometry" in node_data[node]: + mesh_key = node_data[node]["geometry"] + if mesh_key in mesh_index: + info["mesh"] = mesh_index[mesh_key] + # check to see if we have camera node + if has_camera and node == scene.camera.name: + info["camera"] = 0 + + if node != base_frame: + parent = graph.parents[node] + node_edge = edge_data[(parent, node)] + + # get the matrix from this edge + matrix = node_edge["matrix"] + # only include if it's not an identify matrix + if not util.allclose(matrix, _identity): + info["matrix"] = matrix.T.reshape(-1).tolist() + + # if an extra was stored on this edge + extras = node_edge.get("metadata") + if extras: + extras = extras.copy() + + # if extensionss were stored on this edge + extensions = extras.pop("gltf_extensions", None) + if isinstance(extensions, dict): + info["extensions"] = extensions + extensions_used = extensions_used.union(set(extensions.keys())) + + # convert any numpy arrays to lists + extras.update( + {k: v.tolist() for k, v in extras.items() if hasattr(v, "tolist")} + ) + info["extras"] = extras + + if skip_base: + roots = [lookup[c] for c in children[base_frame]] + else: + roots = [lookup[base_frame]] + + gltf = {"nodes": result, "scene_roots": roots} + if len(extensions_used) > 0: + gltf["extensionsUsed"] = list(extensions_used) + return gltf + + def to_edgelist(self): + """ + Export the current transforms as a list of + edge tuples, with each tuple having the format: + (node_a, node_b, {metadata}) + + Returns + --------- + edgelist : (n,) list + Of edge tuples + """ + # save local reference to node_data + nodes = self.transforms.node_data + # save cleaned edges + export = [] + # loop through (node, node, edge attributes) + for edge, attr in self.transforms.edge_data.items(): + # node indexes from edge + a, b = edge + # geometry is a node property but save it to the + # edge so we don't need two dictionaries + b_attr = nodes[b] + # make sure we're not stomping on original + attr_new = attr.copy() + # apply node geometry to edge attributes + if "geometry" in b_attr: + attr_new["geometry"] = b_attr["geometry"] + # convert any numpy arrays to regular lists + attr_new.update( + {k: v.tolist() for k, v in attr_new.items() if hasattr(v, "tolist")} + ) + export.append([a, b, attr_new]) + return export + + def from_edgelist(self, edges, strict=True): + """ + Load transform data from an edge list into the current + scene graph. + + Parameters + ------------- + edgelist : (n,) tuples + Keyed (node_a, node_b, {key: value}) + strict : bool + If True raise a ValueError when a + malformed edge is passed in a tuple. + """ + + # loop through each edge + for edge in edges: + # edge contains attributes + if len(edge) == 3: + self.update(edge[1], edge[0], **edge[2]) + # edge just contains nodes + elif len(edge) == 2: + self.update(edge[1], edge[0]) + # edge is broken + elif strict: + raise ValueError("edge incorrect shape: %s", str(edge)) + + def to_networkx(self): + """ + Return a `networkx` copy of this graph. + + Returns + ---------- + graph : networkx.DiGraph + Directed graph. + """ + import networkx + + return networkx.from_edgelist(self.to_edgelist(), create_using=networkx.DiGraph) + + def show(self, **kwargs): + """ + Plot the scene graph using `networkx.draw_networkx` + which uses matplotlib to display the graph. + + Parameters + ----------- + kwargs : dict + Passed to `networkx.draw_networkx` + """ + import matplotlib.pyplot as plt # noqa + import networkx + + # default kwargs will only be set if not + # passed explicitly to the show command + defaults = {"with_labels": True} + kwargs.update(**{k: v for k, v in defaults.items() if k not in kwargs}) + networkx.draw_networkx(G=self.to_networkx(), **kwargs) + + plt.show() + + def load(self, edgelist): + """ + Load transform data from an edge list into the current + scene graph. + + Parameters + ------------- + edgelist : (n,) tuples + Structured (node_a, node_b, {key: value}) + """ + self.from_edgelist(edgelist, strict=True) + + @caching.cache_decorator + def nodes(self): + """ + A list of every node in the graph. + + Returns + ------------- + nodes : (n,) array + All node names. + """ + return self.transforms.nodes + + @caching.cache_decorator + def nodes_geometry(self): + """ + The nodes in the scene graph with geometry attached. + + Returns + ------------ + nodes_geometry : (m,) array + Node names which have geometry associated + """ + return [n for n, attr in self.transforms.node_data.items() if "geometry" in attr] + + @caching.cache_decorator + def geometry_nodes(self): + """ + Which nodes have this geometry? Inverse + of `nodes_geometry`. + + Returns + ------------ + geometry_nodes : dict + Keyed {geometry_name : node name} + """ + res = collections.defaultdict(list) + for node, attr in self.transforms.node_data.items(): + if "geometry" in attr: + res[attr["geometry"]].append(node) + return res + + def remove_geometries(self, geometries: str | set | Sequence): + """ + Remove the reference for specified geometries + from nodes without deleting the node. + + Parameters + ------------ + geometries : list or str + Name of scene.geometry to dereference. + """ + # make sure we have a set of geometries to remove + if isinstance(geometries, str): + geometries = [geometries] + geometries = set(geometries) + + # remove the geometry reference from the node without deleting nodes + # this lets us keep our cached paths, and will not screw up children + for attrib in self.transforms.node_data.values(): + if "geometry" in attrib and attrib["geometry"] in geometries: + attrib.pop("geometry") + + # it would be safer to just run _cache.clear + # but the only property using the geometry should be + # nodes_geometry: if this becomes not true change this to clear! + self._cache.cache.pop("nodes_geometry", None) + self.transforms._hash = None + + def __contains__(self, key: Hashable) -> bool: + return key in self.transforms.node_data + + def __getitem__(self, key: Hashable) -> tuple[NDArray[np.float64], Hashable | None]: + return self.get(key) + + def __setitem__(self, key: Hashable, value: ArrayLike): + value = np.asanyarray(value, dtype=np.float64) + if value.shape != (4, 4): + raise ValueError("Matrix must be specified!") + return self.update(key, matrix=value) + + def clear(self): + self.transforms = EnforcedForest() + self._cache.clear() + + +class EnforcedForest: + """ + A simple forest graph data structure: every node + is allowed to have exactly one parent. This makes + traversal and implementation much simpler than a + full graph data type; by storing only one parent + reference, it enforces the structure for "free." + """ + + def __init__(self): + # since every node can have only one parent + # this data structure transparently enforces + # the forest data structure without checks + # a dict {child : parent} + self.parents = {} + + # store data for a particular edge keyed by tuple + # {(u, v) : data } + self.edge_data = collections.defaultdict(dict) + # {u: data} + self.node_data = collections.defaultdict(dict) + + # if multiple calls are made for the same path + # but the connectivity hasn't changed return cached + self._cache = {} + + def add_edge(self, u, v, **kwargs): + """ + Add an edge to the forest cleanly. + + Parameters + ----------- + u : any + Hashable node key. + v : any + Hashable node key. + kwargs : dict + Stored as (u, v) edge data. + + Returns + -------- + changed : bool + Return if this operation changed anything. + """ + self._hash = None + + # topology has changed so clear cache + if (u, v) not in self.edge_data: + self._cache = {} + else: + # check to see if matrix and geometry are identical + edge = self.edge_data[(u, v)] + if util.allclose( + kwargs.get("matrix", _identity), edge.get("matrix", _identity), 1e-8 + ) and (edge.get("geometry") == kwargs.get("geometry")): + return False + + # store a parent reference for traversal + self.parents[v] = u + # store kwargs for edge data keyed with tuple + self.edge_data[(u, v)] = kwargs + # set empty node data + self.node_data[u].update({}) + if "geometry" in kwargs: + self.node_data[v].update({"geometry": kwargs["geometry"]}) + else: + self.node_data[v].update({}) + + return True + + def remove_node(self, u): + """ + Remove a node from the forest. + + Parameters + ----------- + u : any + Hashable node key. + + Returns + -------- + changed : bool + Return if this operation changed anything. + """ + # check if node is part of forest + if u not in self.node_data: + return False + + # topology will change so clear cache + self._cache = {} + self._hash = None + + # delete all children's references and parent reference + children = [child for (child, parent) in self.parents.items() if parent == u] + for c in children: + del self.parents[c] + if u in self.parents: + del self.parents[u] + + # delete edge data + edges = [(a, b) for (a, b) in self.edge_data if a == u or b == u] + for e in edges: + del self.edge_data[e] + + # delete node data + del self.node_data[u] + + return True + + def shortest_path(self, u, v): + """ + Find the shortest path between `u` and `v`, returning + a path where the first element is always `u` and the + last element is always `v`, disregarding edge direction. + + Parameters + ----------- + u : any + Hashable node key. + v : any + Hashable node key. + + Returns + ----------- + path : (n,) + Path between `u` and `v` + """ + # see if we've already computed this path + if u == v: + # the path between itself is an edge case + return [] + elif (u, v) in self._cache: + # return the same path for either direction + return self._cache[(u, v)] + elif (v, u) in self._cache: + return self._cache[(v, u)][::-1] + + # local reference to parent dict for performance + parents = self.parents + # store both forward and backwards traversal + forward = [u] + backward = [v] + + # cap iteration to number of total nodes + for _ in range(len(parents) + 1): + # store the parent both forwards and backwards + f = parents.get(forward[-1]) + b = parents.get(backward[-1]) + forward.append(f) + backward.append(b) + + if f == v: + self._cache[(u, v)] = forward + return forward + elif b == u: + # return reversed path + backward = backward[::-1] + self._cache[(u, v)] = backward + return backward + elif (b in forward) or (f is None and b is None): + # we have a either a common node between both + # traversal directions or we have consumed the whole + # tree in both directions so try to find the common node + common = set(backward).intersection(forward).difference({None}) + if len(common) == 0: + raise ValueError(f"No path from {u}->{v}!") + elif len(common) > 1: + # get the first occurring common element in "forward" + link = next(f for f in forward if f in common) + assert link in common + else: + # take the only common element + link = next(iter(common)) + + # combine the forward and backwards traversals + a = forward[: forward.index(link) + 1] + b = backward[: backward.index(link)] + path = a + b[::-1] + + # verify we didn't screw up the order + assert path[0] == u + assert path[-1] == v + + self._cache[(u, v)] = path + + return path + + raise ValueError("Iteration limit exceeded!") + + @property + def nodes(self): + """ + Get a set of every node. + + Returns + ----------- + nodes : set + Every node currently stored. + """ + return self.node_data.keys() + + @property + def children(self): + """ + Get the children of each node. + + Returns + ---------- + children : dict + Keyed {node : [child, child, ...]} + """ + if "children" in self._cache: + return self._cache["children"] + child = collections.defaultdict(list) + # append children to parent references + # skip self-references to avoid a node loop + [child[v].append(u) for u, v in self.parents.items() if u != v] + + # cache and return as a vanilla dict + self._cache["children"] = dict(child) + return self._cache["children"] + + def successors(self, node): + """ + Get all nodes that are successors to specified node, + including the specified node. + + Parameters + ------------- + node : any + Hashable key for a node. + + Returns + ------------ + successors : set + Nodes that succeed specified node. + """ + # get mapping of {parent : child} + children = self.children + # if node doesn't exist return early + if node not in children: + return {node} + + # children we need to collect + queue = [node] + # start collecting values with children of source + collected = set(queue) + + # cap maximum iterations + for _ in range(len(self.node_data) + 1): + if len(queue) == 0: + # no more nodes to visit so we're done + return collected + # add the children of this node to be processed + childs = children.get(queue.pop()) + if childs is not None: + queue.extend(childs) + collected.update(childs) + return collected + + def __hash__(self): + """ + Actually hash all of the data, but use a "dirty" mechanism + in functions that modify the data, which MUST + # all invalidate the hash by setting `self._hash = None` + + This was optimized a bit, and is evaluating on an + older laptop on a scene with 77 nodes and 76 edges + 10,000 times in 0.7s which seems fast enough. + """ + # see if there is an available hash value + # if you are seeing cache bugs this is the thing + # to try eliminating because it is very likely that + # someone somewhere is modifying the data without + # setting `self._hash = None` + hashed = getattr(self, "_hash", None) + if hashed is not None: + return hashed + + hashed = hash_fast( + ( + "".join( + str(hash(k)) + v.get("geometry", "") + for k, v in self.edge_data.items() + ) + + "".join( + str(k) + v.get("geometry", "") for k, v in self.node_data.items() + ) + ).encode("utf-8") + + b"".join( + v["matrix"].tobytes() for v in self.edge_data.values() if "matrix" in v + ) + ) + self._hash = hashed + return hashed + + +def kwargs_to_matrix( + matrix=None, quaternion=None, translation=None, axis=None, angle=None, **kwargs +): + """ + Take multiple keyword arguments and parse them + into a homogeneous transformation matrix. + + Returns + --------- + matrix : (4, 4) float + Homogeneous transformation matrix. + """ + if matrix is not None: + # a matrix takes immediate precedence over other options + return np.array(matrix, dtype=np.float64) + elif quaternion is not None: + matrix = quaternion_matrix(quaternion) + elif axis is not None and angle is not None: + matrix = rotation_matrix(angle, axis) + else: + matrix = np.eye(4) + + if translation is not None: + # translation can be used in conjunction with any + # of the methods specifying transforms + matrix[:3, 3] += translation + + return matrix diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/schemas.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/schemas.py new file mode 100644 index 0000000000000000000000000000000000000000..faac7db2a56bbd97534140af9f34818d85e6d6ea --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/schemas.py @@ -0,0 +1,46 @@ +""" +schemas.py +------------- + +Tools for dealing with schemas, particularly JSONschema +""" + +import json + +from .util import decode_text + + +def resolve(item, resolver): + """ + Given a JSON Schema containing `$ref` keys recursively + evaluate to find and replace referenced files with their + actual values using trimesh.resolvers.Resolver objects. + + Parameters + --------------- + item : any + JSON schema including `$ref` to other files + resolver : trimesh.visual.resolver.Resolver + Resolver to fetch referenced assets + + Returns + ---------- + result : any + JSONSchema with references replaced + """ + if isinstance(item, list): + # run the resolver on every list item + return [resolve(i, resolver) for i in item] + elif isinstance(item, dict): + if "$ref" in item: + # if we have a reference to a file pop the key + # and update the dict with the reference in-place + raw = decode_text(resolver.get(item.pop("$ref"))) + item.update(json.loads(raw)) + # run the resolver on the dict again + resolve(item, resolver) + else: + # make sure all keys are evaluated + for i in item.values(): + resolve(i, resolver) + return item diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/smoothing.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/smoothing.py new file mode 100644 index 0000000000000000000000000000000000000000..dcec0cff8a85abaa58f3a2a917ce6e2aaede3524 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/smoothing.py @@ -0,0 +1,386 @@ +import numpy as np + +from .typed import ArrayLike + +try: + from scipy.sparse import coo_matrix, eye + from scipy.sparse.linalg import spsolve +except ImportError as E: + from .exceptions import ExceptionWrapper + + wrapper = ExceptionWrapper(E) + eye, spsolve, coo_matrix = wrapper, wrapper, wrapper + +from . import graph, triangles +from .base import Trimesh +from .geometry import index_sparse +from .triangles import mass_properties +from .util import unitize + + +def filter_laplacian( + mesh, + lamb=0.5, + iterations=10, + implicit_time_integration=False, + volume_constraint=True, + laplacian_operator=None, +): + """ + Smooth a mesh in-place using laplacian smoothing. + Articles + 1 - "Improved Laplacian Smoothing of Noisy Surface Meshes" + J. Vollmer, R. Mencl, and H. Muller + 2 - "Implicit Fairing of Irregular Meshes using Diffusion + and Curvature Flow". M. Desbrun, M. Meyer, + P. Schroder, A.H.B. Caltech + Parameters + ------------ + mesh : trimesh.Trimesh + Mesh to be smoothed in place + lamb : float + Diffusion speed constant + If 0.0, no diffusion + If > 0.0, diffusion occurs + implicit_time_integration: boolean + if False: explicit time integration + -lamb <= 1.0 - Stability Limit (Article 1) + if True: implicit time integration + -lamb no limit (Article 2) + iterations : int + Number of passes to run filter + volume_constraint : bool + If True, restore the initial volume after each iteration + by rescaling about the mesh center of mass + laplacian_operator : None or scipy.sparse.coo.coo_matrix + Sparse matrix laplacian operator + Will be autogenerated if None + """ + + # if the laplacian operator was not passed create it here + if laplacian_operator is None: + laplacian_operator = laplacian_calculation(mesh) + + # save initial volume and center of mass + if volume_constraint: + vol_ini = mesh.volume + center_mass = mesh.center_mass + + # get mesh vertices and faces as vanilla numpy array + vertices = mesh.vertices.copy().view(np.ndarray) + faces = mesh.faces.copy().view(np.ndarray) + + # Set matrix for linear system of equations + if implicit_time_integration: + dlap = laplacian_operator.shape[0] + AA = eye(dlap) + lamb * (eye(dlap) - laplacian_operator) + + # Number of passes + for _index in range(iterations): + # Classic Explicit Time Integration - Article 1 + if not implicit_time_integration: + dot = laplacian_operator.dot(vertices) - vertices + vertices += lamb * dot + + # Implicit Time Integration - Article 2 + else: + vertices = spsolve(AA, vertices) + + # volume constraint + if volume_constraint: + # find the volume with new vertex positions + vol_new = triangles.mass_properties(vertices[faces], skip_inertia=True)[ + "volume" + ] + # scale by volume ratio + scale = (vol_ini / vol_new) ** (1.0 / 3.0) + vertices = (vertices - center_mass) * scale + center_mass + + # assign modified vertices back to mesh + mesh.vertices = vertices + return mesh + + +def filter_humphrey(mesh, alpha=0.1, beta=0.5, iterations=10, laplacian_operator=None): + """ + Smooth a mesh in-place using laplacian smoothing + and Humphrey filtering. + Articles + "Improved Laplacian Smoothing of Noisy Surface Meshes" + J. Vollmer, R. Mencl, and H. Muller + Parameters + ------------ + mesh : trimesh.Trimesh + Mesh to be smoothed in place + alpha : float + Controls shrinkage, range is 0.0 - 1.0 + If 0.0, not considered + If 1.0, no smoothing + beta : float + Controls how aggressive smoothing is + If 0.0, no smoothing + If 1.0, full aggressiveness + iterations : int + Number of passes to run filter + laplacian_operator : None or scipy.sparse.coo.coo_matrix + Sparse matrix laplacian operator + Will be autogenerated if None + """ + # if the laplacian operator was not passed create it here + if laplacian_operator is None: + laplacian_operator = laplacian_calculation(mesh) + + # get mesh vertices as vanilla numpy array + vertices = mesh.vertices.copy().view(np.ndarray) + # save original unmodified vertices + original = vertices.copy() + + # run through iterations of filter + for _index in range(iterations): + vert_q = vertices.copy() + vertices = laplacian_operator.dot(vertices) + vert_b = vertices - (alpha * original + (1.0 - alpha) * vert_q) + vertices -= beta * vert_b + (1.0 - beta) * laplacian_operator.dot(vert_b) + + # assign modified vertices back to mesh + mesh.vertices = vertices + return mesh + + +def filter_taubin(mesh, lamb=0.5, nu=0.5, iterations=10, laplacian_operator=None): + """ + Smooth a mesh in-place using laplacian smoothing + and taubin filtering. + Articles + "Improved Laplacian Smoothing of Noisy Surface Meshes" + J. Vollmer, R. Mencl, and H. Muller + Parameters + ------------ + mesh : trimesh.Trimesh + Mesh to be smoothed in place. + lamb : float + Controls shrinkage, range is 0.0 - 1.0 + nu : float + Controls dilation, range is 0.0 - 1.0 + Nu shall be between 0.0 < 1.0/lambda - 1.0/nu < 0.1 + iterations : int + Number of passes to run the filter + laplacian_operator : None or scipy.sparse.coo.coo_matrix + Sparse matrix laplacian operator + Will be autogenerated if None + """ + # if the laplacian operator was not passed create it here + if laplacian_operator is None: + laplacian_operator = laplacian_calculation(mesh) + + # get mesh vertices as vanilla numpy array + vertices = mesh.vertices.copy().view(np.ndarray) + + # run through multiple passes of the filter + for index in range(iterations): + # do a sparse dot product on the vertices + dot = laplacian_operator.dot(vertices) - vertices + # alternate shrinkage and dilation + if index % 2 == 0: + vertices += lamb * dot + else: + vertices -= nu * dot + + # assign updated vertices back to mesh + mesh.vertices = vertices + return mesh + + +def filter_mut_dif_laplacian( + mesh, lamb=0.5, iterations=10, volume_constraint=True, laplacian_operator=None +): + """ + Smooth a mesh in-place using laplacian smoothing using a + mutable diffusion laplacian. + + Articles + Barroqueiro, B., Andrade-Campos, A., Dias-de-Oliveira, + J., and Valente, R. (January 21, 2021). + "Bridging between topology optimization and additive + manufacturing via Laplacian smoothing." ASME. J. Mech. Des. + + + Parameters + ------------ + mesh : trimesh.Trimesh + Mesh to be smoothed in place + lamb : float + Diffusion speed constant + If 0.0, no diffusion + If > 0.0, diffusion occurs + iterations : int + Number of passes to run filter + laplacian_operator : None or scipy.sparse.coo.coo_matrix + Sparse matrix laplacian operator + Will be autogenerated if None + """ + + # if the laplacian operator was not passed create it here + if laplacian_operator is None: + laplacian_operator = laplacian_calculation(mesh) + + # Set volume constraint + if volume_constraint: + v_ini = mesh.volume + + # get mesh vertices as vanilla numpy array + vertices = mesh.vertices.copy().view(np.ndarray) + faces = mesh.faces.copy().view(np.ndarray) + eps = 0.01 * (np.max(mesh.area_faces) ** 0.5) + + # Number of passes + for _index in range(iterations): + # Mutable diffusion + normals = get_vertices_normals(mesh) + qi = laplacian_operator.dot(vertices) + pi_qi = vertices - qi + + adil = np.abs((normals * pi_qi).dot(np.ones((3, 1)))) + adil = 1.0 / np.maximum(1e-12, adil) + lamber = np.maximum(0.2 * lamb, np.minimum(1.0, lamb * adil / np.mean(adil))) + + # Filter + dot = laplacian_operator.dot(vertices) + vertices += lamber * (dot - vertices) + + # Volume constraint + if volume_constraint: + vol = mass_properties(vertices[faces], skip_inertia=True)["volume"] + if _index == 0: + slope = dilate_slope(vertices, faces, normals, vol, eps) + vertices += normals * slope * (v_ini - vol) + + # assign modified vertices back to mesh + mesh.vertices = vertices + + return mesh + + +def laplacian_calculation( + mesh: Trimesh, + equal_weight: bool = True, + pinned_vertices: ArrayLike | None = None, +): + """ + Calculate a sparse matrix for laplacian operations. + + Note that setting equal_weight to False significantly hampers performance. + + Parameters + ------------- + mesh : trimesh.Trimesh + Input geometry + equal_weight : bool + If True, all neighbors will be considered equally + If False, all neighbors will be weighted by inverse distance + pinned_vertices : None or list of ints + If None, no vertices are pinned + If list, vertices will be pinned, such that they will not be moved + Returns + ---------- + laplacian : scipy.sparse.coo.coo_matrix + Laplacian operator + """ + if equal_weight: + laplacian = graph.edges_to_coo(mesh.edges) + + if pinned_vertices is not None: + # Set pinned vertices to only have themselves as neighbours + laplacian.data[np.isin(laplacian.row, pinned_vertices)] = False + laplacian.row = np.concatenate((laplacian.row, pinned_vertices)) + laplacian.col = np.concatenate((laplacian.col, pinned_vertices)) + laplacian.data = np.concatenate( + (laplacian.data, np.ones(len(pinned_vertices), dtype=bool)) + ) + + laplacian = laplacian / laplacian.sum(axis=1) + + else: + # get the vertex neighbors from the cache + neighbors = mesh.vertex_neighbors + + # if a node is pinned, it will average his coordinates by himself + # in practice it will not move + if pinned_vertices is not None: + for i in pinned_vertices: + neighbors[i] = [i] + + # avoid hitting crc checks in loops + vertices = mesh.vertices.view(np.ndarray) + + # stack neighbors to 1D arrays + col = np.concatenate(neighbors) + row = np.concatenate([[i] * len(n) for i, n in enumerate(neighbors)]) + + # umbrella weights, distance-weighted + # use dot product of ones to replace array.sum(axis=1) + ones = np.ones(3) + # the distance from verticesex to neighbors + norms = [ + 1.0 + / np.maximum(1e-6, np.sqrt(np.dot((vertices[i] - vertices[n]) ** 2, ones))) + for i, n in enumerate(neighbors) + ] + # normalize group and stack into single array + data = np.concatenate([i / i.sum() for i in norms]) + + # create the sparse matrix + laplacian = coo_matrix((data, (row, col)), shape=[len(vertices)] * 2) + + return laplacian + + +def get_vertices_normals(mesh): + """ + Compute Vertex normals using equal weighting of neighbors faces. + Parameters + ------------- + mesh : trimesh.Trimesh + Input geometry + Returns + ---------- + vertices_normals: array + Vertices normals + """ + + # get mesh vertices and faces + vertices = mesh.vertices + faces = mesh.faces + + # get face normals + face_normals = mesh.face_normals + + # Compute Vert normals + vert_normals = index_sparse(len(vertices), faces).dot(face_normals) + + return unitize(vert_normals) + + +def dilate_slope(vertices, faces, normals, v, eps): + """ + Get the derivate of dilation scalar by the volume variation by finite differences + Thus, Vertices += vertex_normals*dilate_slope*(Initial_Volume - Srinked_Volume) + Parameters + ------------- + mesh : trimesh.Trimesh + Input geometry + vertices: mesh.vertices + faces: mesh.faces + normals: array + vertices normals + Returns + ---------- + dilate_slope: float + derivative + """ + + # finite difference derivative + vertices2 = vertices + normals * eps + v2 = mass_properties(vertices2[faces], skip_inertia=True)["volume"] + + return (eps) / (v2 - v) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/transformations.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/transformations.py new file mode 100644 index 0000000000000000000000000000000000000000..4e7e658ac092e064efa22c3982cd0763b9a92dc5 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/transformations.py @@ -0,0 +1,2336 @@ +# transformations.py + +# Modified for inclusion in the `trimesh` library +# https://github.com/mikedh/trimesh +# ----------------------------------------------------------------------- +# +# Copyright (c) 2006-2017, Christoph Gohlke +# Copyright (c) 2006-2017, The Regents of the University of California +# Produced at the Laboratory for Fluorescence Dynamics +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# * Neither the name of the copyright holders nor the names of any +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +"""Homogeneous Transformation Matrices and Quaternions. + +A library for calculating 4x4 matrices for translating, rotating, reflecting, +scaling, shearing, projecting, orthogonalizing, and superimposing arrays of +3D homogeneous coordinates as well as for converting between rotation matrices, +Euler angles, and quaternions. Also includes an Arcball control object and +functions to decompose transformation matrices. + +:Author: + `Christoph Gohlke `_ + +:Organization: + Laboratory for Fluorescence Dynamics, University of California, Irvine + +:Version: 2017.02.17 + +Requirements +------------ +* `CPython 2.7 or 3.4 `_ +* `numpy 1.9 `_ +* `Transformations.c 2015.03.19 `_ + (recommended for speedup of some functions) + +Notes +----- +The API is not stable yet and is expected to change between revisions. + +This Python code is not optimized for speed. Refer to the transformations.c +module for a faster implementation of some functions. + +Documentation in HTML format can be generated with epydoc. + +Matrices (M) can be inverted using np.linalg.inv(M), be concatenated using +np.dot(M0, M1), or transform homogeneous coordinate arrays (v) using +np.dot(M, v) for shape (4, *) column vectors, respectively +np.dot(v, M.T) for shape (*, 4) row vectors ("array of points"). + +This module follows the "column vectors on the right" and "row major storage" +(C contiguous) conventions. The translation components are in the right column +of the transformation matrix, i.e. M[:3, 3]. +The transpose of the transformation matrices may have to be used to interface +with other graphics systems, e.g. with OpenGL's glMultMatrixd(). See also [16]. + +Calculations are carried out with np.float64 precision. + +Vector, point, quaternion, and matrix function arguments are expected to be +"array like", i.e. tuple, list, or numpy arrays. + +Return types are numpy arrays unless specified otherwise. + +Angles are in radians unless specified otherwise. + +Quaternions w+ix+jy+kz are represented as [w, x, y, z]. + +A triple of Euler angles can be applied/interpreted in 24 ways, which can +be specified using a 4 character string or encoded 4-tuple: + + *Axes 4-string*: e.g. 'sxyz' or 'ryxy' + + - first character : rotations are applied to 's'tatic or 'r'otating frame + - remaining characters : successive rotation axis 'x', 'y', or 'z' + + *Axes 4-tuple*: e.g. (0, 0, 0, 0) or (1, 1, 1, 1) + + - inner axis: code of axis ('x':0, 'y':1, 'z':2) of rightmost matrix. + - parity : even (0) if inner axis 'x' is followed by 'y', 'y' is followed + by 'z', or 'z' is followed by 'x'. Otherwise odd (1). + - repetition : first and last axis are same (1) or different (0). + - frame : rotations are applied to static (0) or rotating (1) frame. + +Other Python packages and modules for 3D transformations and quaternions: + +* `Transforms3d `_ + includes most code of this module. +* `Blender.mathutils `_ +* `numpy-dtypes `_ + +References +---------- +(1) Matrices and transformations. Ronald Goldman. + In "Graphics Gems I", pp 472-475. Morgan Kaufmann, 1990. +(2) More matrices and transformations: shear and pseudo-perspective. + Ronald Goldman. In "Graphics Gems II", pp 320-323. Morgan Kaufmann, 1991. +(3) Decomposing a matrix into simple transformations. Spencer Thomas. + In "Graphics Gems II", pp 320-323. Morgan Kaufmann, 1991. +(4) Recovering the data from the transformation matrix. Ronald Goldman. + In "Graphics Gems II", pp 324-331. Morgan Kaufmann, 1991. +(5) Euler angle conversion. Ken Shoemake. + In "Graphics Gems IV", pp 222-229. Morgan Kaufmann, 1994. +(6) Arcball rotation control. Ken Shoemake. + In "Graphics Gems IV", pp 175-192. Morgan Kaufmann, 1994. +(7) Representing attitude: Euler angles, unit quaternions, and rotation + vectors. James Diebel. 2006. +(8) A discussion of the solution for the best rotation to relate two sets + of vectors. W Kabsch. Acta Cryst. 1978. A34, 827-828. +(9) Closed-form solution of absolute orientation using unit quaternions. + BKP Horn. J Opt Soc Am A. 1987. 4(4):629-642. +(10) Quaternions. Ken Shoemake. + http://www.sfu.ca/~jwa3/cmpt461/files/quatut.pdf +(11) From quaternion to matrix and back. JMP van Waveren. 2005. + http://www.intel.com/cd/ids/developer/asmo-na/eng/293748.htm +(12) Uniform random rotations. Ken Shoemake. + In "Graphics Gems III", pp 124-132. Morgan Kaufmann, 1992. +(13) Quaternion in molecular modeling. CFF Karney. + J Mol Graph Mod, 25(5):595-604 +(14) New method for extracting the quaternion from a rotation matrix. + Itzhack Y Bar-Itzhack, J Guid Contr Dynam. 2000. 23(6): 1085-1087. +(15) Multiple View Geometry in Computer Vision. Hartley and Zissermann. + Cambridge University Press; 2nd Ed. 2004. Chapter 4, Algorithm 4.7, p 130. +(16) Column Vectors vs. Row Vectors. + http://steve.hollasch.net/cgindex/math/matrix/column-vec.html + +Examples +-------- +>>> alpha, beta, gamma = 0.123, -1.234, 2.345 +>>> origin, xaxis, yaxis, zaxis = [0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1] +>>> I = identity_matrix() +>>> Rx = rotation_matrix(alpha, xaxis) +>>> Ry = rotation_matrix(beta, yaxis) +>>> Rz = rotation_matrix(gamma, zaxis) +>>> R = concatenate_matrices(Rx, Ry, Rz) +>>> euler = euler_from_matrix(R, 'rxyz') +>>> np.allclose([alpha, beta, gamma], euler) +True +>>> Re = euler_matrix(alpha, beta, gamma, 'rxyz') +>>> is_same_transform(R, Re) +True +>>> al, be, ga = euler_from_matrix(Re, 'rxyz') +>>> is_same_transform(Re, euler_matrix(al, be, ga, 'rxyz')) +True +>>> qx = quaternion_about_axis(alpha, xaxis) +>>> qy = quaternion_about_axis(beta, yaxis) +>>> qz = quaternion_about_axis(gamma, zaxis) +>>> q = quaternion_multiply(qx, qy) +>>> q = quaternion_multiply(q, qz) +>>> Rq = quaternion_matrix(q) +>>> is_same_transform(R, Rq) +True +>>> S = scale_matrix(1.23, origin) +>>> T = translation_matrix([1, 2, 3]) +>>> Z = shear_matrix(beta, xaxis, origin, zaxis) +>>> R = random_rotation_matrix(np.random.rand(3)) +>>> M = concatenate_matrices(T, R, Z, S) +>>> scale, shear, angles, trans, persp = decompose_matrix(M) +>>> np.allclose(scale, 1.23) +True +>>> np.allclose(trans, [1, 2, 3]) +True +>>> np.allclose(shear, [0, np.tan(beta), 0]) +True +>>> is_same_transform(R, euler_matrix(axes='sxyz', *angles)) +True +>>> M1 = compose_matrix(scale, shear, angles, trans, persp) +>>> is_same_transform(M, M1) +True +>>> v0, v1 = random_vector(3), random_vector(3) +>>> M = rotation_matrix(angle_between_vectors(v0, v1), vector_product(v0, v1)) +>>> v2 = np.dot(v0, M[:3,:3].T) +>>> np.allclose(unit_vector(v1), unit_vector(v2)) +True + +""" + +import numpy as np +from numpy.typing import ArrayLike, NDArray + +from .typed import Integer, Number, Seed +from .util import diagonal_dot, random_generator + +# a cached immutable identity matrix provides a speedup sometimes +_IDENTITY = np.eye(4) +_IDENTITY.flags["WRITEABLE"] = False + + +def identity_matrix(): + """Return 4x4 identity/unit matrix. + + >>> I = identity_matrix() + >>> np.allclose(I, np.dot(I, I)) + True + >>> float(np.sum(I)), float(np.trace(I)) + (4.0, 4.0) + >>> np.allclose(I, np.identity(4)) + True + + """ + return np.identity(4) + + +def translation_matrix(direction): + """ + Return matrix to translate by direction vector. + + >>> v = np.random.random(3) - 0.5 + >>> np.allclose(v, translation_matrix(v)[:3, 3]) + True + + """ + # are we 2D or 3D + dim = len(direction) + + # start with identity matrix + + if any("sympy" in str(type(v)) for v in direction): + # if we have been passed input values as sympy.Symbol + from sympy import eye + + M = eye(dim + 1) + else: + M = np.eye(dim + 1) + + # apply the offset + M[:dim, dim] = direction[:dim] + + return M + + +def translation_from_matrix(matrix): + """Return translation vector from translation matrix. + + >>> v0 = np.random.random(3) - 0.5 + >>> v1 = translation_from_matrix(translation_matrix(v0)) + >>> np.allclose(v0, v1) + True + + """ + return np.asarray(matrix)[:3, 3].copy() + + +def reflection_matrix(point, normal): + """Return matrix to mirror at plane defined by point and normal vector. + + >>> v0 = np.random.random(4) - 0.5 + >>> v0[3] = 1. + >>> v1 = np.random.random(3) - 0.5 + >>> R = reflection_matrix(v0, v1) + >>> np.allclose(2, np.trace(R)) + True + >>> np.allclose(v0, np.dot(R, v0)) + True + >>> v2 = v0.copy() + >>> v2[:3] += v1 + >>> v3 = v0.copy() + >>> v2[:3] -= v1 + >>> np.allclose(v2, np.dot(R, v3)) + True + + """ + normal = unit_vector(normal[:3]) + M = np.identity(4) + M[:3, :3] -= 2.0 * np.outer(normal, normal) + M[:3, 3] = (2.0 * np.dot(point[:3], normal)) * normal + return M + + +def reflection_from_matrix(matrix): + """Return mirror plane point and normal vector from reflection matrix. + + >>> v0 = np.random.random(3) - 0.5 + >>> v1 = np.random.random(3) - 0.5 + >>> M0 = reflection_matrix(v0, v1) + >>> point, normal = reflection_from_matrix(M0) + >>> M1 = reflection_matrix(point, normal) + >>> is_same_transform(M0, M1) + True + + """ + M = np.asarray(matrix, dtype=np.float64) + # normal: unit eigenvector corresponding to eigenvalue -1 + w, V = np.linalg.eig(M[:3, :3]) + i = np.where(abs(np.real(w) + 1.0) < 1e-8)[0] + if not len(i): + raise ValueError("no unit eigenvector corresponding to eigenvalue -1") + normal = np.real(V[:, i[0]]).squeeze() + # point: any unit eigenvector corresponding to eigenvalue 1 + w, V = np.linalg.eig(M) + i = np.where(abs(np.real(w) - 1.0) < 1e-8)[0] + if not len(i): + raise ValueError("no unit eigenvector corresponding to eigenvalue 1") + point = np.real(V[:, i[-1]]).squeeze() + point /= point[3] + return point, normal + + +def rotation_matrix(angle, direction, point=None): + """ + Return matrix to rotate about axis defined by point and + direction. + + Parameters + ------------- + angle : float, or sympy.Symbol + Angle, in radians or symbolic angle + direction : (3,) float + Any vector along rotation axis + point : (3, ) float, or None + Origin point of rotation axis + + Returns + ------------- + matrix : (4, 4) float, or (4, 4) sympy.Matrix + Homogeneous transformation matrix + + Examples + ------------- + >>> R = rotation_matrix(np.pi/2, [0, 0, 1], [1, 0, 0]) + >>> np.allclose(np.dot(R, [0, 0, 0, 1]), [1, -1, 0, 1]) + True + >>> angle = (random.random() - 0.5) * (2*np.pi) + >>> direc = np.random.random(3) - 0.5 + >>> point = np.random.random(3) - 0.5 + >>> R0 = rotation_matrix(angle, direc, point) + >>> R1 = rotation_matrix(angle-2*np.pi, direc, point) + >>> is_same_transform(R0, R1) + True + >>> R0 = rotation_matrix(angle, direc, point) + >>> R1 = rotation_matrix(-angle, -direc, point) + >>> is_same_transform(R0, R1) + True + >>> I = np.identity(4, np.float64) + >>> np.allclose(I, rotation_matrix(np.pi*2, direc)) + True + >>> np.allclose(2, np.trace(rotation_matrix(np.pi/2,direc,point))) + True + + """ + if "sympy" in str(type(angle)): + # special case sympy symbolic angles + import sympy as sp + + symbolic = True + sina = sp.sin(angle) + cosa = sp.cos(angle) + else: + symbolic = False + sina = np.sin(angle) + cosa = np.cos(angle) + + direction = unit_vector(direction[:3]) + + # rotation matrix around unit vector + M = np.diag([cosa, cosa, cosa, 1.0]) + M[:3, :3] += np.outer(direction, direction) * (1.0 - cosa) + + direction = direction * sina + M[:3, :3] += np.array( + [ + [0.0, -direction[2], direction[1]], + [direction[2], 0.0, -direction[0]], + [-direction[1], direction[0], 0.0], + ] + ) + + # if point is specified, rotation is not around origin + if point is not None: + point = np.asarray(point[:3], dtype=np.float64) + M[:3, 3] = point - np.dot(M[:3, :3], point) + + # return symbolic angles as sympy Matrix objects + if symbolic: + return sp.Matrix(M) + + return M + + +def rotation_from_matrix(matrix): + """Return rotation angle and axis from rotation matrix. + + >>> angle = (random.random() - 0.5) * (2*np.pi) + >>> direc = np.random.random(3) - 0.5 + >>> point = np.random.random(3) - 0.5 + >>> R0 = rotation_matrix(angle, direc, point) + >>> angle, direc, point = rotation_from_matrix(R0) + >>> R1 = rotation_matrix(angle, direc, point) + >>> is_same_transform(R0, R1) + True + + """ + R = np.asarray(matrix, dtype=np.float64) + R33 = R[:3, :3] + # direction: unit eigenvector of R33 corresponding to eigenvalue of 1 + w, W = np.linalg.eig(R33.T) + i = np.where(abs(np.real(w) - 1.0) < 1e-8)[0] + if not len(i): + raise ValueError("no unit eigenvector corresponding to eigenvalue 1") + direction = np.real(W[:, i[-1]]).squeeze() + # point: unit eigenvector of R33 corresponding to eigenvalue of 1 + w, Q = np.linalg.eig(R) + i = np.where(abs(np.real(w) - 1.0) < 1e-8)[0] + if not len(i): + raise ValueError("no unit eigenvector corresponding to eigenvalue 1") + point = np.real(Q[:, i[-1]]).squeeze() + point /= point[3] + # rotation angle depending on direction + cosa = (np.trace(R33) - 1.0) / 2.0 + if abs(direction[2]) > 1e-8: + sina = (R[1, 0] + (cosa - 1.0) * direction[0] * direction[1]) / direction[2] + elif abs(direction[1]) > 1e-8: + sina = (R[0, 2] + (cosa - 1.0) * direction[0] * direction[2]) / direction[1] + else: + sina = (R[2, 1] + (cosa - 1.0) * direction[1] * direction[2]) / direction[0] + angle = np.arctan2(sina, cosa) + return angle, direction, point + + +def scale_matrix(factor, origin=None, direction=None): + """Return matrix to scale by factor around origin in direction. + + Use factor -1 for point symmetry. + + >>> v = (np.random.rand(4, 5) - 0.5) * 20 + >>> v[3] = 1 + >>> S = scale_matrix(-1.234) + >>> np.allclose(np.dot(S, v)[:3], -1.234*v[:3]) + True + >>> factor = random.random() * 10 - 5 + >>> origin = np.random.random(3) - 0.5 + >>> direct = np.random.random(3) - 0.5 + >>> S = scale_matrix(factor, origin) + >>> S = scale_matrix(factor, origin, direct) + + """ + if direction is None: + # uniform scaling + M = np.diag([factor, factor, factor, 1.0]) + if origin is not None: + M[:3, 3] = origin[:3] + M[:3, 3] *= 1.0 - factor + else: + # nonuniform scaling + direction = unit_vector(direction[:3]) + factor = 1.0 - factor + M = np.identity(4) + M[:3, :3] -= factor * np.outer(direction, direction) + if origin is not None: + M[:3, 3] = (factor * np.dot(origin[:3], direction)) * direction + return M + + +def scale_from_matrix(matrix): + """Return scaling factor, origin and direction from scaling matrix. + + >>> factor = random.random() * 10 - 5 + >>> origin = np.random.random(3) - 0.5 + >>> direct = np.random.random(3) - 0.5 + >>> S0 = scale_matrix(factor, origin) + >>> factor, origin, direction = scale_from_matrix(S0) + >>> S1 = scale_matrix(factor, origin, direction) + >>> is_same_transform(S0, S1) + True + >>> S0 = scale_matrix(factor, origin, direct) + >>> factor, origin, direction = scale_from_matrix(S0) + >>> S1 = scale_matrix(factor, origin, direction) + >>> is_same_transform(S0, S1) + True + + """ + M = np.asarray(matrix, dtype=np.float64) + M33 = M[:3, :3] + factor = np.trace(M33) - 2.0 + try: + # direction: unit eigenvector corresponding to eigenvalue factor + w, V = np.linalg.eig(M33) + i = np.where(abs(np.real(w) - factor) < 1e-8)[0][0] + direction = np.real(V[:, i]).squeeze() + direction /= vector_norm(direction) + except IndexError: + # uniform scaling + factor = (factor + 2.0) / 3.0 + direction = None + # origin: any eigenvector corresponding to eigenvalue 1 + w, V = np.linalg.eig(M) + i = np.where(abs(np.real(w) - 1.0) < 1e-8)[0] + if not len(i): + raise ValueError("no eigenvector corresponding to eigenvalue 1") + origin = np.real(V[:, i[-1]]).squeeze() + origin /= origin[3] + return factor, origin, direction + + +def projection_matrix(point, normal, direction=None, perspective=None, pseudo=False): + """Return matrix to project onto plane defined by point and normal. + + Using either perspective point, projection direction, or none of both. + + If pseudo is True, perspective projections will preserve relative depth + such that Perspective = dot(Orthogonal, PseudoPerspective). + + >>> P = projection_matrix([0, 0, 0], [1, 0, 0]) + >>> np.allclose(P[1:, 1:], np.identity(4)[1:, 1:]) + True + >>> point = np.random.random(3) - 0.5 + >>> normal = np.random.random(3) - 0.5 + >>> direct = np.random.random(3) - 0.5 + >>> persp = np.random.random(3) - 0.5 + >>> P0 = projection_matrix(point, normal) + >>> P1 = projection_matrix(point, normal, direction=direct) + >>> P2 = projection_matrix(point, normal, perspective=persp) + >>> P3 = projection_matrix(point, normal, perspective=persp, pseudo=True) + >>> is_same_transform(P2, np.dot(P0, P3)) + True + >>> P = projection_matrix([3, 0, 0], [1, 1, 0], [1, 0, 0]) + >>> v0 = (np.random.rand(4, 5) - 0.5) * 20 + >>> v0[3] = 1 + >>> v1 = np.dot(P, v0) + >>> np.allclose(v1[1], v0[1]) + True + >>> np.allclose(v1[0], 3-v1[1]) + True + + """ + M = np.identity(4) + point = np.asarray(point[:3], dtype=np.float64) + normal = unit_vector(normal[:3]) + if perspective is not None: + # perspective projection + perspective = np.asarray(perspective[:3], dtype=np.float64) + M[0, 0] = M[1, 1] = M[2, 2] = np.dot(perspective - point, normal) + M[:3, :3] -= np.outer(perspective, normal) + if pseudo: + # preserve relative depth + M[:3, :3] -= np.outer(normal, normal) + M[:3, 3] = np.dot(point, normal) * (perspective + normal) + else: + M[:3, 3] = np.dot(point, normal) * perspective + M[3, :3] = -normal + M[3, 3] = np.dot(perspective, normal) + elif direction is not None: + # parallel projection + direction = np.asarray(direction[:3], dtype=np.float64) + scale = np.dot(direction, normal) + M[:3, :3] -= np.outer(direction, normal) / scale + M[:3, 3] = direction * (np.dot(point, normal) / scale) + else: + # orthogonal projection + M[:3, :3] -= np.outer(normal, normal) + M[:3, 3] = np.dot(point, normal) * normal + return M + + +def projection_from_matrix(matrix, pseudo=False): + """Return projection plane and perspective point from projection matrix. + + Return values are same as arguments for projection_matrix function: + point, normal, direction, perspective, and pseudo. + + >>> point = np.random.random(3) - 0.5 + >>> normal = np.random.random(3) - 0.5 + >>> direct = np.random.random(3) - 0.5 + >>> persp = np.random.random(3) - 0.5 + >>> P0 = projection_matrix(point, normal) + >>> result = projection_from_matrix(P0) + >>> P1 = projection_matrix(*result) + >>> is_same_transform(P0, P1) + True + >>> P0 = projection_matrix(point, normal, direct) + >>> result = projection_from_matrix(P0) + >>> P1 = projection_matrix(*result) + >>> is_same_transform(P0, P1) + True + >>> P0 = projection_matrix(point, normal, perspective=persp, pseudo=False) + >>> result = projection_from_matrix(P0, pseudo=False) + >>> P1 = projection_matrix(*result) + >>> is_same_transform(P0, P1) + True + >>> P0 = projection_matrix(point, normal, perspective=persp, pseudo=True) + >>> result = projection_from_matrix(P0, pseudo=True) + >>> P1 = projection_matrix(*result) + >>> is_same_transform(P0, P1) + True + + """ + M = np.asarray(matrix, dtype=np.float64) + M33 = M[:3, :3] + w, V = np.linalg.eig(M) + i = np.where(abs(np.real(w) - 1.0) < 1e-8)[0] + if not pseudo and len(i): + # point: any eigenvector corresponding to eigenvalue 1 + point = np.real(V[:, i[-1]]).squeeze() + point /= point[3] + # direction: unit eigenvector corresponding to eigenvalue 0 + w, V = np.linalg.eig(M33) + i = np.where(abs(np.real(w)) < 1e-8)[0] + if not len(i): + raise ValueError("no eigenvector corresponding to eigenvalue 0") + direction = np.real(V[:, i[0]]).squeeze() + direction /= vector_norm(direction) + # normal: unit eigenvector of M33.T corresponding to eigenvalue 0 + w, V = np.linalg.eig(M33.T) + i = np.where(abs(np.real(w)) < 1e-8)[0] + if len(i): + # parallel projection + normal = np.real(V[:, i[0]]).squeeze() + normal /= vector_norm(normal) + return point, normal, direction, None, False + else: + # orthogonal projection, where normal equals direction vector + return point, direction, None, None, False + else: + # perspective projection + i = np.where(abs(np.real(w)) > 1e-8)[0] + if not len(i): + raise ValueError("no eigenvector not corresponding to eigenvalue 0") + point = np.real(V[:, i[-1]]).squeeze() + point /= point[3] + normal = -M[3, :3] + perspective = M[:3, 3] / np.dot(point[:3], normal) + if pseudo: + perspective -= normal + return point, normal, None, perspective, pseudo + + +def clip_matrix(left, right, bottom, top, near, far, perspective=False): + """Return matrix to obtain normalized device coordinates from frustum. + + The frustum bounds are axis-aligned along x (left, right), + y (bottom, top) and z (near, far). + + Normalized device coordinates are in range [-1, 1] if coordinates are + inside the frustum. + + If perspective is True the frustum is a truncated pyramid with the + perspective point at origin and direction along z axis, otherwise an + orthographic canonical view volume (a box). + + Homogeneous coordinates transformed by the perspective clip matrix + need to be dehomogenized (divided by w coordinate). + + >>> frustum = np.random.rand(6) + >>> frustum[1] += frustum[0] + >>> frustum[3] += frustum[2] + >>> frustum[5] += frustum[4] + >>> M = clip_matrix(perspective=False, *frustum) + >>> a = np.dot(M, [frustum[0], frustum[2], frustum[4], 1]) + >>> np.allclose(a, [-1., -1., -1., 1.]) + True + >>> b = np.dot(M, [frustum[1], frustum[3], frustum[5], 1]) + >>> np.allclose(b, [ 1., 1., 1., 1.]) + True + >>> M = clip_matrix(perspective=True, *frustum) + >>> v = np.dot(M, [frustum[0], frustum[2], frustum[4], 1]) + >>> c = v / v[3] + >>> np.allclose(c, [-1., -1., -1., 1.]) + True + >>> v = np.dot(M, [frustum[1], frustum[3], frustum[4], 1]) + >>> d = v / v[3] + >>> np.allclose(d, [ 1., 1., -1., 1.]) + True + + """ + if left >= right or bottom >= top or near >= far: + raise ValueError("invalid frustum") + if perspective: + if near <= _EPS: + raise ValueError("invalid frustum: near <= 0") + t = 2.0 * near + M = [ + [t / (left - right), 0.0, (right + left) / (right - left), 0.0], + [0.0, t / (bottom - top), (top + bottom) / (top - bottom), 0.0], + [0.0, 0.0, (far + near) / (near - far), t * far / (far - near)], + [0.0, 0.0, -1.0, 0.0], + ] + else: + M = [ + [2.0 / (right - left), 0.0, 0.0, (right + left) / (left - right)], + [0.0, 2.0 / (top - bottom), 0.0, (top + bottom) / (bottom - top)], + [0.0, 0.0, 2.0 / (far - near), (far + near) / (near - far)], + [0.0, 0.0, 0.0, 1.0], + ] + return np.array(M) + + +def shear_matrix(angle, direction, point, normal): + """Return matrix to shear by angle along direction vector on shear plane. + + The shear plane is defined by a point and normal vector. The direction + vector must be orthogonal to the plane's normal vector. + + A point P is transformed by the shear matrix into P" such that + the vector P-P" is parallel to the direction vector and its extent is + given by the angle of P-P'-P", where P' is the orthogonal projection + of P onto the shear plane. + + >>> angle = (random.random() - 0.5) * 4*np.pi + >>> direct = np.random.random(3) - 0.5 + >>> point = np.random.random(3) - 0.5 + >>> normal = np.cross(direct, np.random.random(3)) + >>> S = shear_matrix(angle, direct, point, normal) + >>> np.allclose(1, np.linalg.det(S)) + True + + """ + normal = unit_vector(normal[:3]) + direction = unit_vector(direction[:3]) + if abs(np.dot(normal, direction)) > 1e-6: + raise ValueError("direction and normal vectors are not orthogonal") + angle = np.tan(angle) + M = np.identity(4) + M[:3, :3] += angle * np.outer(direction, normal) + M[:3, 3] = -angle * np.dot(point[:3], normal) * direction + return M + + +def shear_from_matrix(matrix): + """Return shear angle, direction and plane from shear matrix. + + >>> angle = np.pi / 2.0 + >>> direct = [0.0, 1.0, 0.0] + >>> point = [0.0, 0.0, 0.0] + >>> normal = np.cross(direct, np.roll(direct,1)) + >>> S0 = shear_matrix(angle, direct, point, normal) + >>> angle, direct, point, normal = shear_from_matrix(S0) + >>> S1 = shear_matrix(angle, direct, point, normal) + >>> is_same_transform(S0, S1) + True + + """ + M = np.asarray(matrix, dtype=np.float64) + M33 = M[:3, :3] + # normal: cross independent eigenvectors corresponding to the eigenvalue 1 + w, V = np.linalg.eig(M33) + + i = np.where(abs(np.real(w) - 1.0) < 1e-4)[0] + if len(i) < 2: + raise ValueError(f"no two linear independent eigenvectors found {w}") + V = np.real(V[:, i]).squeeze().T + lenorm = -1.0 + for i0, i1 in ((0, 1), (0, 2), (1, 2)): + n = np.cross(V[i0], V[i1]) + w = vector_norm(n) + if w > lenorm: + lenorm = w + normal = n + normal /= lenorm + # direction and angle + direction = np.dot(M33 - np.identity(3), normal) + angle = vector_norm(direction) + direction /= angle + angle = np.arctan(angle) + # point: eigenvector corresponding to eigenvalue 1 + w, V = np.linalg.eig(M) + + i = np.where(abs(np.real(w) - 1.0) < 1e-8)[0] + if not len(i): + raise ValueError("no eigenvector corresponding to eigenvalue 1") + point = np.real(V[:, i[-1]]).squeeze() + point /= point[3] + return angle, direction, point, normal + + +def decompose_matrix(matrix): + """Return sequence of transformations from transformation matrix. + + matrix : array_like + Non-degenerative homogeneous transformation matrix + + Return tuple of: + scale : vector of 3 scaling factors + shear : list of shear factors for x-y, x-z, y-z axes + angles : list of Euler angles about static x, y, z axes + translate : translation vector along x, y, z axes + perspective : perspective partition of matrix + + Raise ValueError if matrix is of wrong type or degenerative. + + >>> T0 = translation_matrix([1, 2, 3]) + >>> scale, shear, angles, trans, persp = decompose_matrix(T0) + >>> T1 = translation_matrix(trans) + >>> np.allclose(T0, T1) + True + >>> S = scale_matrix(0.123) + >>> scale, shear, angles, trans, persp = decompose_matrix(S) + >>> bool(np.isclose(scale[0], 0.123)) + True + >>> R0 = euler_matrix(1, 2, 3) + >>> scale, shear, angles, trans, persp = decompose_matrix(R0) + >>> R1 = euler_matrix(*angles) + >>> np.allclose(R0, R1) + True + + """ + M = np.array(matrix, dtype=np.float64).T + if abs(M[3, 3]) < _EPS: + raise ValueError("M[3, 3] is zero") + M /= M[3, 3] + P = M.copy() + P[:, 3] = 0.0, 0.0, 0.0, 1.0 + if not np.linalg.det(P): + raise ValueError("matrix is singular") + + scale = np.zeros((3,)) + shear = [0.0, 0.0, 0.0] + angles = [0.0, 0.0, 0.0] + + if any(abs(M[:3, 3]) > _EPS): + perspective = np.dot(M[:, 3], np.linalg.inv(P.T)) + M[:, 3] = 0.0, 0.0, 0.0, 1.0 + else: + perspective = np.array([0.0, 0.0, 0.0, 1.0]) + + translate = M[3, :3].copy() + M[3, :3] = 0.0 + + row = M[:3, :3].copy() + scale[0] = vector_norm(row[0]) + row[0] /= scale[0] + shear[0] = np.dot(row[0], row[1]) + row[1] -= row[0] * shear[0] + scale[1] = vector_norm(row[1]) + row[1] /= scale[1] + shear[0] /= scale[1] + shear[1] = np.dot(row[0], row[2]) + row[2] -= row[0] * shear[1] + shear[2] = np.dot(row[1], row[2]) + row[2] -= row[1] * shear[2] + scale[2] = vector_norm(row[2]) + row[2] /= scale[2] + shear[1:] /= scale[2] + + if np.dot(row[0], np.cross(row[1], row[2])) < 0: + np.negative(scale, scale) + np.negative(row, row) + + angles[1] = np.arcsin(-row[0, 2]) + if np.cos(angles[1]): + angles[0] = np.arctan2(row[1, 2], row[2, 2]) + angles[2] = np.arctan2(row[0, 1], row[0, 0]) + else: + angles[0] = np.arctan2(-row[2, 1], row[1, 1]) + angles[2] = 0.0 + + return scale, shear, angles, translate, perspective + + +def compose_matrix(scale=None, shear=None, angles=None, translate=None, perspective=None): + """Return transformation matrix from sequence of transformations. + + This is the inverse of the decompose_matrix function. + + Sequence of transformations: + scale : vector of 3 scaling factors + shear : list of shear factors for x-y, x-z, y-z axes + angles : list of Euler angles about static x, y, z axes + translate : translation vector along x, y, z axes + perspective : perspective partition of matrix + + >>> scale = np.random.random(3) - 0.5 + >>> shear = np.random.random(3) - 0.5 + >>> angles = (np.random.random(3) - 0.5) * (2*np.pi) + >>> trans = np.random.random(3) - 0.5 + >>> persp = np.random.random(4) - 0.5 + >>> M0 = compose_matrix(scale, shear, angles, trans, persp) + >>> result = decompose_matrix(M0) + >>> M1 = compose_matrix(*result) + >>> is_same_transform(M0, M1) + True + + """ + M = np.identity(4) + if perspective is not None: + P = np.identity(4) + P[3, :] = perspective[:4] + M = np.dot(M, P) + if translate is not None: + T = np.identity(4) + T[:3, 3] = translate[:3] + M = np.dot(M, T) + if angles is not None: + R = euler_matrix(angles[0], angles[1], angles[2], "sxyz") + M = np.dot(M, R) + if shear is not None: + Z = np.identity(4) + Z[1, 2] = shear[2] + Z[0, 2] = shear[1] + Z[0, 1] = shear[0] + M = np.dot(M, Z) + if scale is not None: + S = np.identity(4) + S[0, 0] = scale[0] + S[1, 1] = scale[1] + S[2, 2] = scale[2] + M = np.dot(M, S) + M /= M[3, 3] + return M + + +def orthogonalization_matrix(lengths, angles): + """Return orthogonalization matrix for crystallographic cell coordinates. + + Angles are expected in degrees. + + The de-orthogonalization matrix is the inverse. + + >>> O = orthogonalization_matrix([10, 10, 10], [90, 90, 90]) + >>> np.allclose(O[:3, :3], np.identity(3, float) * 10) + True + >>> O = orthogonalization_matrix([9.8, 12.0, 15.5], [87.2, 80.7, 69.7]) + >>> np.allclose(np.sum(O), 43.063229) + True + + """ + a, b, c = lengths + angles = np.radians(angles) + sina, sinb, _ = np.sin(angles) + cosa, cosb, cosg = np.cos(angles) + co = (cosa * cosb - cosg) / (sina * sinb) + return np.array( + [ + [a * sinb * np.sqrt(1.0 - co * co), 0.0, 0.0, 0.0], + [-a * sinb * co, b * sina, 0.0, 0.0], + [a * cosb, b * cosa, c, 0.0], + [0.0, 0.0, 0.0, 1.0], + ] + ) + + +def affine_matrix_from_points(v0, v1, shear=True, scale=True, usesvd=True): + """Return affine transform matrix to register two point sets. + + v0 and v1 are shape (ndims, *) arrays of at least ndims non-homogeneous + coordinates, where ndims is the dimensionality of the coordinate space. + + If shear is False, a similarity transformation matrix is returned. + If also scale is False, a rigid/Euclidean transformation matrix + is returned. + + By default the algorithm by Hartley and Zissermann [15] is used. + If usesvd is True, similarity and Euclidean transformation matrices + are calculated by minimizing the weighted sum of squared deviations + (RMSD) according to the algorithm by Kabsch [8]. + Otherwise, and if ndims is 3, the quaternion based algorithm by Horn [9] + is used, which is slower when using this Python implementation. + + The returned matrix performs rotation, translation and uniform scaling + (if specified). + + >>> v0 = [[0, 1031, 1031, 0], [0, 0, 1600, 1600]] + >>> v1 = [[675, 826, 826, 677], [55, 52, 281, 277]] + >>> mat = affine_matrix_from_points(v0, v1) + >>> T = translation_matrix(np.random.random(3)-0.5) + >>> R = random_rotation_matrix(np.random.random(3)) + >>> S = scale_matrix(random.random()) + >>> M = concatenate_matrices(T, R, S) + >>> v0 = (np.random.rand(4, 100) - 0.5) * 20 + >>> v0[3] = 1 + >>> v1 = np.dot(M, v0) + >>> v0[:3] += np.random.normal(0, 1e-8, 300).reshape(3, -1) + >>> M = affine_matrix_from_points(v0[:3], v1[:3]) + >>> check = np.allclose(v1, np.dot(M, v0)) + + More examples in superimposition_matrix() + + """ + v0 = np.array(v0, dtype=np.float64) + v1 = np.array(v1, dtype=np.float64) + + ndims = v0.shape[0] + if ndims < 2 or v0.shape[1] < ndims or v0.shape != v1.shape: + raise ValueError("input arrays are of wrong shape or type") + + # move centroids to origin + t0 = -np.mean(v0, axis=1) + M0 = np.identity(ndims + 1) + M0[:ndims, ndims] = t0 + v0 += t0.reshape(ndims, 1) + t1 = -np.mean(v1, axis=1) + M1 = np.identity(ndims + 1) + M1[:ndims, ndims] = t1 + v1 += t1.reshape(ndims, 1) + + if shear: + # Affine transformation + A = np.concatenate((v0, v1), axis=0) + u, s, vh = np.linalg.svd(A.T) + vh = vh[:ndims].T + B = vh[:ndims] + C = vh[ndims : 2 * ndims] + t = np.dot(C, np.linalg.pinv(B)) + t = np.concatenate((t, np.zeros((ndims, 1))), axis=1) + M = np.vstack((t, ((0.0,) * ndims) + (1.0,))) + elif usesvd or ndims != 3: + # Rigid transformation via SVD of covariance matrix + u, s, vh = np.linalg.svd(np.dot(v1, v0.T)) + # rotation matrix from SVD orthonormal bases + R = np.dot(u, vh) + if np.linalg.det(R) < 0.0: + # R does not constitute right handed system + R -= np.outer(u[:, ndims - 1], vh[ndims - 1, :] * 2.0) + s[-1] *= -1.0 + # homogeneous transformation matrix + M = np.identity(ndims + 1) + M[:ndims, :ndims] = R + else: + # Rigid transformation matrix via quaternion + # compute symmetric matrix N + xx, yy, zz = np.sum(v0 * v1, axis=1) + xy, yz, zx = np.sum(v0 * np.roll(v1, -1, axis=0), axis=1) + xz, yx, zy = np.sum(v0 * np.roll(v1, -2, axis=0), axis=1) + N = [ + [xx + yy + zz, 0.0, 0.0, 0.0], + [yz - zy, xx - yy - zz, 0.0, 0.0], + [zx - xz, xy + yx, yy - xx - zz, 0.0], + [xy - yx, zx + xz, yz + zy, zz - xx - yy], + ] + # quaternion: eigenvector corresponding to most positive eigenvalue + w, V = np.linalg.eigh(N) + q = V[:, np.argmax(w)] + q /= vector_norm(q) # unit quaternion + # homogeneous transformation matrix + M = quaternion_matrix(q) + + if scale and not shear: + # Affine transformation; scale is ratio of RMS deviations from centroid + v0 *= v0 + v1 *= v1 + M[:ndims, :ndims] *= np.sqrt(np.sum(v1) / np.sum(v0)) + + # move centroids back + M = np.dot(np.linalg.inv(M1), np.dot(M, M0)) + M /= M[ndims, ndims] + return M + + +def superimposition_matrix(v0, v1, scale=False, usesvd=True): + """Return matrix to transform given 3D point set into second point set. + + v0 and v1 are shape (3, *) or (4, *) arrays of at least 3 points. + + The parameters scale and usesvd are explained in the more general + affine_matrix_from_points function. + + The returned matrix is a similarity or Euclidean transformation matrix. + This function has a fast C implementation in transformations.c. + + >>> v0 = np.random.rand(3, 10) + >>> M = superimposition_matrix(v0, v0) + >>> np.allclose(M, np.identity(4)) + True + >>> R = random_rotation_matrix(np.random.random(3)) + >>> v0 = [[1,0,0], [0,1,0], [0,0,1], [1,1,1]] + >>> v1 = np.dot(R, v0) + >>> M = superimposition_matrix(v0, v1) + >>> np.allclose(v1, np.dot(M, v0)) + True + >>> v0 = (np.random.rand(4, 100) - 0.5) * 20 + >>> v0[3] = 1 + >>> v1 = np.dot(R, v0) + >>> M = superimposition_matrix(v0, v1) + >>> np.allclose(v1, np.dot(M, v0)) + True + >>> S = scale_matrix(random.random()) + >>> T = translation_matrix(np.random.random(3)-0.5) + >>> M = concatenate_matrices(T, R, S) + >>> v1 = np.dot(M, v0) + >>> v0[:3] += np.random.normal(0, 1e-9, 300).reshape(3, -1) + >>> M = superimposition_matrix(v0, v1, scale=True) + >>> np.allclose(v1, np.dot(M, v0)) + True + >>> M = superimposition_matrix(v0, v1, scale=True, usesvd=False) + >>> np.allclose(v1, np.dot(M, v0)) + True + >>> v = np.zeros((4, 100, 3)) + >>> v[:, :, 0] = v0 + >>> M = superimposition_matrix(v0, v1, scale=True, usesvd=False) + >>> np.allclose(v1, np.dot(M, v[:, :, 0])) + True + + """ + v0 = np.asarray(v0, dtype=np.float64)[:3] + v1 = np.asarray(v1, dtype=np.float64)[:3] + return affine_matrix_from_points(v0, v1, shear=False, scale=scale, usesvd=usesvd) + + +def euler_matrix(ai, aj, ak, axes="sxyz"): + """Return homogeneous rotation matrix from Euler angles and axis sequence. + + ai, aj, ak : Euler's roll, pitch and yaw angles + axes : One of 24 axis sequences as string or encoded tuple + + >>> R = euler_matrix(1, 2, 3, 'syxz') + >>> np.allclose(np.sum(R[0]), -1.34786452) + True + >>> R = euler_matrix(1, 2, 3, (0, 1, 0, 1)) + >>> np.allclose(np.sum(R[0]), -0.383436184) + True + >>> ai, aj, ak = (4*np.pi) * (np.random.random(3) - 0.5) + >>> for axes in _AXES2TUPLE.keys(): + ... R = euler_matrix(ai, aj, ak, axes) + >>> for axes in _TUPLE2AXES.keys(): + ... R = euler_matrix(ai, aj, ak, axes) + + """ + try: + firstaxis, parity, repetition, frame = _AXES2TUPLE[axes] + except (AttributeError, KeyError): + _TUPLE2AXES[axes] # validation + firstaxis, parity, repetition, frame = axes + + i = firstaxis + j = _NEXT_AXIS[i + parity] + k = _NEXT_AXIS[i - parity + 1] + + if frame: + ai, ak = ak, ai + if parity: + ai, aj, ak = -ai, -aj, -ak + + if "sympy" in str(type(ai)): + # if we have been passed input values as sympy.Symbol + # use symbolic cosine and identity matrix + from sympy import cos, eye, sin + + M = eye(4) + else: + sin, cos = np.sin, np.cos + M = np.eye(4) + + si, sj, sk = sin(ai), sin(aj), sin(ak) + ci, cj, ck = cos(ai), cos(aj), cos(ak) + cc, cs = ci * ck, ci * sk + sc, ss = si * ck, si * sk + + if repetition: + M[i, i] = cj + M[i, j] = sj * si + M[i, k] = sj * ci + M[j, i] = sj * sk + M[j, j] = -cj * ss + cc + M[j, k] = -cj * cs - sc + M[k, i] = -sj * ck + M[k, j] = cj * sc + cs + M[k, k] = cj * cc - ss + else: + M[i, i] = cj * ck + M[i, j] = sj * sc - cs + M[i, k] = sj * cc + ss + M[j, i] = cj * sk + M[j, j] = sj * ss + cc + M[j, k] = sj * cs - sc + M[k, i] = -sj + M[k, j] = cj * si + M[k, k] = cj * ci + return M + + +def euler_from_matrix(matrix, axes="sxyz"): + """Return Euler angles from rotation matrix for specified axis sequence. + + axes : One of 24 axis sequences as string or encoded tuple + + Note that many Euler angle triplets can describe one matrix. + + >>> R0 = euler_matrix(1, 2, 3, 'syxz') + >>> al, be, ga = euler_from_matrix(R0, 'syxz') + >>> R1 = euler_matrix(al, be, ga, 'syxz') + >>> np.allclose(R0, R1) + True + >>> angles = (4*np.pi) * (np.random.random(3) - 0.5) + >>> for axes in _AXES2TUPLE.keys(): + ... R0 = euler_matrix(axes=axes, *angles) + ... R1 = euler_matrix(axes=axes, *euler_from_matrix(R0, axes)) + ... if not np.allclose(R0, R1): print(axes, "failed") + + """ + try: + firstaxis, parity, repetition, frame = _AXES2TUPLE[axes.lower()] + except (AttributeError, KeyError): + _TUPLE2AXES[axes] # validation + firstaxis, parity, repetition, frame = axes + + i = firstaxis + j = _NEXT_AXIS[i + parity] + k = _NEXT_AXIS[i - parity + 1] + + M = np.asarray(matrix, dtype=np.float64)[:3, :3] + if repetition: + sy = np.sqrt(M[i, j] * M[i, j] + M[i, k] * M[i, k]) + if sy > _EPS: + ax = np.arctan2(M[i, j], M[i, k]) + ay = np.arctan2(sy, M[i, i]) + az = np.arctan2(M[j, i], -M[k, i]) + else: + ax = np.arctan2(-M[j, k], M[j, j]) + ay = np.arctan2(sy, M[i, i]) + az = 0.0 + else: + cy = np.sqrt(M[i, i] * M[i, i] + M[j, i] * M[j, i]) + if cy > _EPS: + ax = np.arctan2(M[k, j], M[k, k]) + ay = np.arctan2(-M[k, i], cy) + az = np.arctan2(M[j, i], M[i, i]) + else: + ax = np.arctan2(-M[j, k], M[j, j]) + ay = np.arctan2(-M[k, i], cy) + az = 0.0 + + if parity: + ax, ay, az = -ax, -ay, -az + if frame: + ax, az = az, ax + return ax, ay, az + + +def euler_from_quaternion(quaternion, axes="sxyz"): + """Return Euler angles from quaternion for specified axis sequence. + + >>> angles = euler_from_quaternion([0.99810947, 0.06146124, 0, 0]) + >>> np.allclose(angles, [0.123, 0, 0]) + True + + """ + return euler_from_matrix(quaternion_matrix(quaternion), axes) + + +def quaternion_from_euler(ai, aj, ak, axes="sxyz"): + """Return quaternion from Euler angles and axis sequence. + + ai, aj, ak : Euler's roll, pitch and yaw angles + axes : One of 24 axis sequences as string or encoded tuple + + >>> q = quaternion_from_euler(1, 2, 3, 'ryxz') + >>> np.allclose(q, [0.435953, 0.310622, -0.718287, 0.444435]) + True + + """ + try: + firstaxis, parity, repetition, frame = _AXES2TUPLE[axes.lower()] + except (AttributeError, KeyError): + _TUPLE2AXES[axes] # validation + firstaxis, parity, repetition, frame = axes + + i = firstaxis + 1 + j = _NEXT_AXIS[i + parity - 1] + 1 + k = _NEXT_AXIS[i - parity] + 1 + + if frame: + ai, ak = ak, ai + if parity: + aj = -aj + + ai /= 2.0 + aj /= 2.0 + ak /= 2.0 + ci = np.cos(ai) + si = np.sin(ai) + cj = np.cos(aj) + sj = np.sin(aj) + ck = np.cos(ak) + sk = np.sin(ak) + cc = ci * ck + cs = ci * sk + sc = si * ck + ss = si * sk + + q = np.zeros((4,)) + if repetition: + q[0] = cj * (cc - ss) + q[i] = cj * (cs + sc) + q[j] = sj * (cc + ss) + q[k] = sj * (cs - sc) + else: + q[0] = cj * cc + sj * ss + q[i] = cj * sc - sj * cs + q[j] = cj * ss + sj * cc + q[k] = cj * cs - sj * sc + if parity: + q[j] *= -1.0 + + return q + + +def quaternion_about_axis(angle, axis): + """Return quaternion for rotation about axis. + + >>> q = quaternion_about_axis(0.123, [1, 0, 0]) + >>> np.allclose(q, [0.99810947, 0.06146124, 0, 0]) + True + + """ + q = np.array([0.0, axis[0], axis[1], axis[2]]) + qlen = vector_norm(q) + if qlen > _EPS: + q *= np.sin(angle / 2.0) / qlen + q[0] = np.cos(angle / 2.0) + return q + + +def quaternion_matrix(quaternion): + """ + Return a homogeneous rotation matrix from quaternion. + + >>> M = quaternion_matrix([0.99810947, 0.06146124, 0, 0]) + >>> np.allclose(M, rotation_matrix(0.123, [1, 0, 0])) + True + >>> M = quaternion_matrix([1, 0, 0, 0]) + >>> np.allclose(M, np.identity(4)) + True + >>> M = quaternion_matrix([0, 1, 0, 0]) + >>> np.allclose(M, np.diag([1, -1, -1, 1])) + True + >>> M = quaternion_matrix([[1, 0, 0, 0],[0, 1, 0, 0]]) + >>> np.allclose(M, np.array([np.identity(4), np.diag([1, -1, -1, 1])])) + True + + + """ + q = np.array(quaternion, dtype=np.float64).reshape((-1, 4)) + n = diagonal_dot(q, q) + # how many entries do we have + num_qs = len(n) + identities = n < _EPS + q[~identities, :] *= np.sqrt(2.0 / n[~identities, None]) + q = q[:, None, :] * q[:, :, None] + + # store the result + ret = np.zeros((num_qs, 4, 4)) + + # pack the values into the result + ret[:, 0, 0] = 1.0 - q[:, 2, 2] - q[:, 3, 3] + ret[:, 0, 1] = q[:, 1, 2] - q[:, 3, 0] + ret[:, 0, 2] = q[:, 1, 3] + q[:, 2, 0] + ret[:, 1, 0] = q[:, 1, 2] + q[:, 3, 0] + ret[:, 1, 1] = 1.0 - q[:, 1, 1] - q[:, 3, 3] + ret[:, 1, 2] = q[:, 2, 3] - q[:, 1, 0] + ret[:, 2, 0] = q[:, 1, 3] - q[:, 2, 0] + ret[:, 2, 1] = q[:, 2, 3] + q[:, 1, 0] + ret[:, 2, 2] = 1.0 - q[:, 1, 1] - q[:, 2, 2] + ret[:, 3, 3] = 1.0 + # set any identities + ret[identities] = np.eye(4)[None, ...] + + return ret.squeeze() + + +def quaternion_from_matrix(matrix, isprecise=False): + """Return quaternion from rotation matrix. + + If isprecise is True, the input matrix is assumed to be a precise rotation + matrix and a faster algorithm is used. + + >>> q = quaternion_from_matrix(np.identity(4), True) + >>> np.allclose(q, [1, 0, 0, 0]) + True + >>> q = quaternion_from_matrix(np.diag([1, -1, -1, 1])) + >>> np.allclose(q, [0, 1, 0, 0]) or np.allclose(q, [0, -1, 0, 0]) + True + >>> R = rotation_matrix(0.123, (1, 2, 3)) + >>> q = quaternion_from_matrix(R, True) + >>> np.allclose(q, [0.9981095, 0.0164262, 0.0328524, 0.0492786]) + True + >>> R = [[-0.545, 0.797, 0.260, 0], [0.733, 0.603, -0.313, 0], + ... [-0.407, 0.021, -0.913, 0], [0, 0, 0, 1]] + >>> q = quaternion_from_matrix(R) + >>> np.allclose(q, [0.19069, 0.43736, 0.87485, -0.083611]) + True + >>> R = [[0.395, 0.362, 0.843, 0], [-0.626, 0.796, -0.056, 0], + ... [-0.677, -0.498, 0.529, 0], [0, 0, 0, 1]] + >>> q = quaternion_from_matrix(R) + >>> np.allclose(q, [0.82336615, -0.13610694, 0.46344705, -0.29792603]) + True + >>> R = random_rotation_matrix() + >>> q = quaternion_from_matrix(R) + >>> is_same_transform(R, quaternion_matrix(q)) + True + >>> is_same_quaternion(quaternion_from_matrix(R, isprecise=False), + ... quaternion_from_matrix(R, isprecise=True)) + True + >>> R = euler_matrix(0.0, 0.0, np.pi/2.0) + >>> is_same_quaternion(quaternion_from_matrix(R, isprecise=False), + ... quaternion_from_matrix(R, isprecise=True)) + True + + """ + M = np.asarray(matrix, dtype=np.float64)[:4, :4] + if isprecise: + q = np.zeros((4,)) + t = np.trace(M) + if t > M[3, 3]: + q[0] = t + q[3] = M[1, 0] - M[0, 1] + q[2] = M[0, 2] - M[2, 0] + q[1] = M[2, 1] - M[1, 2] + else: + i, j, k = 0, 1, 2 + if M[1, 1] > M[0, 0]: + i, j, k = 1, 2, 0 + if M[2, 2] > M[i, i]: + i, j, k = 2, 0, 1 + t = M[i, i] - (M[j, j] + M[k, k]) + M[3, 3] + q[i] = t + q[j] = M[i, j] + M[j, i] + q[k] = M[k, i] + M[i, k] + q[3] = M[k, j] - M[j, k] + q = q[[3, 0, 1, 2]] + q *= 0.5 / np.sqrt(t * M[3, 3]) + else: + m00 = M[0, 0] + m01 = M[0, 1] + m02 = M[0, 2] + m10 = M[1, 0] + m11 = M[1, 1] + m12 = M[1, 2] + m20 = M[2, 0] + m21 = M[2, 1] + m22 = M[2, 2] + # symmetric matrix K + K = np.array( + [ + [m00 - m11 - m22, 0.0, 0.0, 0.0], + [m01 + m10, m11 - m00 - m22, 0.0, 0.0], + [m02 + m20, m12 + m21, m22 - m00 - m11, 0.0], + [m21 - m12, m02 - m20, m10 - m01, m00 + m11 + m22], + ] + ) + K /= 3.0 + # quaternion is eigenvector of K that corresponds to largest eigenvalue + w, V = np.linalg.eigh(K) + q = V[[3, 0, 1, 2], np.argmax(w)] + if q[0] < 0.0: + np.negative(q, q) + return q + + +def quaternion_multiply(quaternion1, quaternion0): + """Return multiplication of two quaternions. + + >>> q = quaternion_multiply([4, 1, -2, 3], [8, -5, 6, 7]) + >>> np.allclose(q, [28, -44, -14, 48]) + True + + """ + w0, x0, y0, z0 = quaternion0 + w1, x1, y1, z1 = quaternion1 + return np.array( + [ + -x1 * x0 - y1 * y0 - z1 * z0 + w1 * w0, + x1 * w0 + y1 * z0 - z1 * y0 + w1 * x0, + -x1 * z0 + y1 * w0 + z1 * x0 + w1 * y0, + x1 * y0 - y1 * x0 + z1 * w0 + w1 * z0, + ], + dtype=np.float64, + ) + + +def quaternion_conjugate(quaternion): + """Return conjugate of quaternion. + + >>> q0 = random_quaternion() + >>> q1 = quaternion_conjugate(q0) + >>> q1[0] == q0[0] and all(q1[1:] == -q0[1:]) + True + + """ + q = np.array(quaternion, dtype=np.float64) + np.negative(q[1:], q[1:]) + return q + + +def quaternion_inverse(quaternion): + """Return inverse of quaternion. + + >>> q0 = random_quaternion() + >>> q1 = quaternion_inverse(q0) + >>> np.allclose(quaternion_multiply(q0, q1), [1, 0, 0, 0]) + True + + """ + q = np.array(quaternion, dtype=np.float64) + np.negative(q[1:], q[1:]) + return q / np.dot(q, q) + + +def quaternion_real(quaternion): + """Return real part of quaternion. + + >>> quaternion_real([3, 0, 1, 2]) + 3.0 + + """ + return float(quaternion[0]) + + +def quaternion_imag(quaternion): + """Return imaginary part of quaternion. + + >>> quaternion_imag([3, 0, 1, 2]) + array([0., 1., 2.]) + + """ + return np.array(quaternion[1:4], dtype=np.float64) + + +def quaternion_slerp(quat0, quat1, fraction, spin=0, shortestpath=True): + """Return spherical linear interpolation between two quaternions. + + >>> q0 = random_quaternion() + >>> q1 = random_quaternion() + >>> q = quaternion_slerp(q0, q1, 0) + >>> np.allclose(q, q0) + True + >>> q = quaternion_slerp(q0, q1, 1, 1) + >>> np.allclose(q, q1) + True + >>> q = quaternion_slerp(q0, q1, 0.5) + >>> angle = np.arccos(np.dot(q0, q)) + >>> np.allclose(2, np.arccos(np.dot(q0, q1)) / angle) or \ + np.allclose(2, np.arccos(-np.dot(q0, q1)) / angle) + True + + """ + q0 = unit_vector(quat0[:4]) + q1 = unit_vector(quat1[:4]) + if fraction == 0.0: + return q0 + elif fraction == 1.0: + return q1 + d = np.dot(q0, q1) + if abs(abs(d) - 1.0) < _EPS: + return q0 + if shortestpath and d < 0.0: + # invert rotation + d = -d + np.negative(q1, q1) + angle = np.arccos(d) + spin * np.pi + if abs(angle) < _EPS: + return q0 + isin = 1.0 / np.sin(angle) + q0 *= np.sin((1.0 - fraction) * angle) * isin + q1 *= np.sin(fraction * angle) * isin + q0 += q1 + return q0 + + +def random_quaternion(rand=None, num=1, seed: Seed = None): + """Return uniform random unit quaternion. + + rand: array like or None + Three independent random variables that are uniformly distributed + between 0 and 1. + seed : None or int + Seed for deterministic results, otherwise OS entropy. + + >>> q = random_quaternion() + >>> np.allclose(1, vector_norm(q)) + True + >>> q = random_quaternion(num=10) + >>> np.allclose(1, vector_norm(q, axis=1)) + True + >>> q = random_quaternion(random_vector(3)) + >>> len(q.shape), q.shape[0]==4 + (1, True) + >>> bool(np.allclose(random_quaternion(seed=0), random_quaternion(seed=0))) + True + + """ + if rand is None: + rand = random_generator(seed).random(3 * num).reshape((3, -1)) + else: + assert rand.shape[0] == 3 + r1 = np.sqrt(1.0 - rand[0]) + r2 = np.sqrt(rand[0]) + pi2 = np.pi * 2.0 + t1 = pi2 * rand[1] + t2 = pi2 * rand[2] + return np.array( + [np.cos(t2) * r2, np.sin(t1) * r1, np.cos(t1) * r1, np.sin(t2) * r2] + ).T.squeeze() + + +def random_rotation_matrix( + rand: ArrayLike | None = None, + num: Integer = 1, + translate: Number | None = None, + seed: Seed = None, +): + """ + Return uniform random rotation matrix. + + Parameters + ------------ + rand : (3,) + Three independent random variables that are uniformly distributed + between 0 and 1 for each returned quaternion. + num + Number of matrices to return. + translate + If passed the rotation matrix will include translation + that is random and between positive and negative half this value. + seed + Seed for deterministic results, otherwise OS entropy. + + >>> R = random_rotation_matrix() + >>> np.allclose(np.dot(R.T, R), np.identity(4)) + True + >>> R = random_rotation_matrix(num=10) + >>> np.allclose(np.einsum('...ji,...jk->...ik', R, R), np.identity(4)) + True + >>> bool(np.allclose(random_rotation_matrix(seed=0, translate=10), + ... random_rotation_matrix(seed=0, translate=10))) + True + + """ + # thread one generator through so a passed `seed` doesn't hand the + # translation the same values as the quaternion below + random = random_generator(seed) + matrix = quaternion_matrix(random_quaternion(rand=rand, num=num, seed=random)) + if translate: + # apply random translation with the order of magnitude requested + matrix[:3, 3] = (random.random(3) - 0.5) * float(translate) + + return matrix + + +class Arcball: + """Virtual Trackball Control. + + >>> ball = Arcball() + >>> ball = Arcball(initial=np.identity(4)) + >>> ball.place([320, 320], 320) + >>> ball.down([500, 250]) + >>> ball.drag([475, 275]) + >>> R = ball.matrix() + >>> np.allclose(np.sum(R), 3.90583455) + True + >>> ball = Arcball(initial=[1, 0, 0, 0]) + >>> ball.place([320, 320], 320) + >>> ball.setaxes([1, 1, 0], [-1, 1, 0]) + >>> ball.constrain = True + >>> ball.down([400, 200]) + >>> ball.drag([200, 400]) + >>> R = ball.matrix() + >>> np.allclose(np.sum(R), 0.2055924) + True + >>> ball.next() + + """ + + def __init__(self, initial=None): + """Initialize virtual trackball control. + + initial : quaternion or rotation matrix + + """ + self._axis = None + self._axes = None + self._radius = 1.0 + self._center = [0.0, 0.0] + self._vdown = np.array([0.0, 0.0, 1.0]) + self._constrain = False + if initial is None: + self._qdown = np.array([1.0, 0.0, 0.0, 0.0]) + else: + initial = np.array(initial, dtype=np.float64) + if initial.shape == (4, 4): + self._qdown = quaternion_from_matrix(initial) + elif initial.shape == (4,): + initial /= vector_norm(initial) + self._qdown = initial + else: + raise ValueError("initial not a quaternion or matrix") + self._qnow = self._qpre = self._qdown + + def place(self, center, radius): + """Place Arcball, e.g. when window size changes. + + center : sequence[2] + Window coordinates of trackball center. + radius : float + Radius of trackball in window coordinates. + + """ + self._radius = float(radius) + self._center[0] = center[0] + self._center[1] = center[1] + + def setaxes(self, *axes): + """Set axes to constrain rotations.""" + if axes is None: + self._axes = None + else: + self._axes = [unit_vector(axis) for axis in axes] + + @property + def constrain(self): + """Return state of constrain to axis mode.""" + return self._constrain + + @constrain.setter + def constrain(self, value): + """Set state of constrain to axis mode.""" + self._constrain = bool(value) + + def down(self, point): + """Set initial cursor window coordinates and pick constrain-axis.""" + self._vdown = arcball_map_to_sphere(point, self._center, self._radius) + self._qdown = self._qpre = self._qnow + if self._constrain and self._axes is not None: + self._axis = arcball_nearest_axis(self._vdown, self._axes) + self._vdown = arcball_constrain_to_axis(self._vdown, self._axis) + else: + self._axis = None + + def drag(self, point): + """Update current cursor window coordinates.""" + vnow = arcball_map_to_sphere(point, self._center, self._radius) + if self._axis is not None: + vnow = arcball_constrain_to_axis(vnow, self._axis) + self._qpre = self._qnow + t = np.cross(self._vdown, vnow) + if np.dot(t, t) < _EPS: + self._qnow = self._qdown + else: + q = [np.dot(self._vdown, vnow), t[0], t[1], t[2]] + self._qnow = quaternion_multiply(q, self._qdown) + + def next(self, acceleration=0.0): + """Continue rotation in direction of last drag.""" + q = quaternion_slerp(self._qpre, self._qnow, 2.0 + acceleration, False) + self._qpre, self._qnow = self._qnow, q + + def matrix(self): + """Return homogeneous rotation matrix.""" + return quaternion_matrix(self._qnow) + + +def arcball_map_to_sphere(point, center, radius): + """Return unit sphere coordinates from window coordinates.""" + v0 = (point[0] - center[0]) / radius + v1 = (center[1] - point[1]) / radius + n = v0 * v0 + v1 * v1 + if n > 1.0: + # position outside of sphere + n = np.sqrt(n) + return np.array([v0 / n, v1 / n, 0.0]) + else: + return np.array([v0, v1, np.sqrt(1.0 - n)]) + + +def arcball_constrain_to_axis(point, axis): + """Return sphere point perpendicular to axis.""" + v = np.array(point, dtype=np.float64) + a = np.array(axis, dtype=np.float64) + v -= a * np.dot(a, v) # on plane + n = vector_norm(v) + if n > _EPS: + if v[2] < 0.0: + np.negative(v, v) + v /= n + return v + if a[2] == 1.0: + return np.array([1.0, 0.0, 0.0]) + return unit_vector([-a[1], a[0], 0.0]) + + +def arcball_nearest_axis(point, axes): + """Return axis, which arc is nearest to point.""" + point = np.asarray(point, dtype=np.float64) + nearest = None + mx = -1.0 + for axis in axes: + t = np.dot(arcball_constrain_to_axis(point, axis), point) + if t > mx: + nearest = axis + mx = t + return nearest + + +# epsilon for testing whether a number is close to zero +_EPS = np.finfo(float).eps * 4.0 + +# axis sequences for Euler angles +_NEXT_AXIS = [1, 2, 0, 1] + +# map axes strings to/from tuples of inner axis, parity, repetition, frame +_AXES2TUPLE = { + "sxyz": (0, 0, 0, 0), + "sxyx": (0, 0, 1, 0), + "sxzy": (0, 1, 0, 0), + "sxzx": (0, 1, 1, 0), + "syzx": (1, 0, 0, 0), + "syzy": (1, 0, 1, 0), + "syxz": (1, 1, 0, 0), + "syxy": (1, 1, 1, 0), + "szxy": (2, 0, 0, 0), + "szxz": (2, 0, 1, 0), + "szyx": (2, 1, 0, 0), + "szyz": (2, 1, 1, 0), + "rzyx": (0, 0, 0, 1), + "rxyx": (0, 0, 1, 1), + "ryzx": (0, 1, 0, 1), + "rxzx": (0, 1, 1, 1), + "rxzy": (1, 0, 0, 1), + "ryzy": (1, 0, 1, 1), + "rzxy": (1, 1, 0, 1), + "ryxy": (1, 1, 1, 1), + "ryxz": (2, 0, 0, 1), + "rzxz": (2, 0, 1, 1), + "rxyz": (2, 1, 0, 1), + "rzyz": (2, 1, 1, 1), +} + +_TUPLE2AXES = {v: k for k, v in _AXES2TUPLE.items()} + + +def vector_norm(data, axis=None, out=None): + """Return length, i.e. Euclidean norm, of ndarray along axis. + + >>> v = np.random.random(3) + >>> n = vector_norm(v) + >>> np.allclose(n, np.linalg.norm(v)) + True + >>> v = np.random.rand(6, 5, 3) + >>> n = vector_norm(v, axis=-1) + >>> np.allclose(n, np.sqrt(np.sum(v*v, axis=2))) + True + >>> n = vector_norm(v, axis=1) + >>> np.allclose(n, np.sqrt(np.sum(v*v, axis=1))) + True + >>> v = np.random.rand(5, 4, 3) + >>> n = np.zeros((5, 3)) + >>> vector_norm(v, axis=1, out=n) + >>> np.allclose(n, np.sqrt(np.sum(v*v, axis=1))) + True + >>> float(vector_norm([])) + 0.0 + >>> float(vector_norm([1])) + 1.0 + + """ + data = np.array(data, dtype=np.float64) + if out is None: + if data.ndim == 1: + return np.sqrt(np.dot(data, data)) + data *= data + out = np.atleast_1d(np.sum(data, axis=axis)) + np.sqrt(out, out) + return out + else: + data *= data + np.sum(data, axis=axis, out=out) + np.sqrt(out, out) + + +def unit_vector(data, axis=None, out=None): + """Return ndarray normalized by length, i.e. Euclidean norm, along axis. + + >>> v0 = np.random.random(3) + >>> v1 = unit_vector(v0) + >>> np.allclose(v1, v0 / np.linalg.norm(v0)) + True + >>> v0 = np.random.rand(5, 4, 3) + >>> v1 = unit_vector(v0, axis=-1) + >>> v2 = v0 / np.expand_dims(np.sqrt(np.sum(v0*v0, axis=2)), 2) + >>> np.allclose(v1, v2) + True + >>> v1 = unit_vector(v0, axis=1) + >>> v2 = v0 / np.expand_dims(np.sqrt(np.sum(v0*v0, axis=1)), 1) + >>> np.allclose(v1, v2) + True + >>> v1 = np.zeros((5, 4, 3)) + >>> unit_vector(v0, axis=1, out=v1) + >>> np.allclose(v1, v2) + True + >>> list(unit_vector([])) + [] + >>> [float(i) for i in unit_vector([1])] + [1.0] + + """ + if out is None: + data = np.array(data, dtype=np.float64) + if data.ndim == 1: + data /= np.sqrt(np.dot(data, data)) + return data + else: + if out is not data: + out[:] = np.asarray(data) + data = out + length = np.atleast_1d(np.sum(data * data, axis)) + np.sqrt(length, length) + if axis is not None: + length = np.expand_dims(length, axis) + data /= length + if out is None: + return data + + +def random_vector(size, seed: Seed = None): + """Return array of random doubles in the half-open interval [0.0, 1.0). + + >>> v = random_vector(10000) + >>> bool(np.all(v >= 0) and np.all(v < 1)) + True + >>> v0 = random_vector(10) + >>> v1 = random_vector(10) + >>> bool(np.any(v0 == v1)) + False + >>> bool(np.allclose(random_vector(10, seed=0), random_vector(10, seed=0))) + True + + """ + return random_generator(seed).random(size) + + +def vector_product(v0, v1, axis=0): + """Return vector perpendicular to vectors. + + >>> v = vector_product([2, 0, 0], [0, 3, 0]) + >>> np.allclose(v, [0, 0, 6]) + True + >>> v0 = [[2, 0, 0, 2], [0, 2, 0, 2], [0, 0, 2, 2]] + >>> v1 = [[3], [0], [0]] + >>> v = vector_product(v0, v1) + >>> np.allclose(v, [[0, 0, 0, 0], [0, 0, 6, 6], [0, -6, 0, -6]]) + True + >>> v0 = [[2, 0, 0], [2, 0, 0], [0, 2, 0], [2, 0, 0]] + >>> v1 = [[0, 3, 0], [0, 0, 3], [0, 0, 3], [3, 3, 3]] + >>> v = vector_product(v0, v1, axis=1) + >>> np.allclose(v, [[0, 0, 6], [0, -6, 0], [6, 0, 0], [0, -6, 6]]) + True + + """ + return np.cross(v0, v1, axis=axis) + + +def angle_between_vectors(v0, v1, directed=True, axis=0): + """Return angle between vectors. + + If directed is False, the input vectors are interpreted as undirected axes, + i.e. the maximum angle is pi/2. + + >>> a = angle_between_vectors([1, -2, 3], [-1, 2, -3]) + >>> np.allclose(a, np.pi) + True + >>> a = angle_between_vectors([1, -2, 3], [-1, 2, -3], directed=False) + >>> np.allclose(a, 0) + True + >>> v0 = [[2, 0, 0, 2], [0, 2, 0, 2], [0, 0, 2, 2]] + >>> v1 = [[3], [0], [0]] + >>> a = angle_between_vectors(v0, v1) + >>> np.allclose(a, [0, 1.5708, 1.5708, 0.95532]) + True + >>> v0 = [[2, 0, 0], [2, 0, 0], [0, 2, 0], [2, 0, 0]] + >>> v1 = [[0, 3, 0], [0, 0, 3], [0, 0, 3], [3, 3, 3]] + >>> a = angle_between_vectors(v0, v1, axis=1) + >>> np.allclose(a, [1.5708, 1.5708, 1.5708, 0.95532]) + True + + """ + v0 = np.asarray(v0, dtype=np.float64) + v1 = np.asarray(v1, dtype=np.float64) + dot = np.sum(v0 * v1, axis=axis) + dot /= vector_norm(v0, axis=axis) * vector_norm(v1, axis=axis) + + # clip off floating point error to avoid `nan` in the arccos` + dot = np.clip(dot, -1.0, 1.0) + return np.arccos(dot if directed else np.fabs(dot)) + + +def inverse_matrix(matrix): + """Return inverse of square transformation matrix. + + >>> M0 = random_rotation_matrix() + >>> M1 = inverse_matrix(M0.T) + >>> np.allclose(M1, np.linalg.inv(M0.T)) + True + >>> for size in range(1, 7): + ... M0 = np.random.rand(size, size) + ... M1 = inverse_matrix(M0) + ... if not np.allclose(M1, np.linalg.inv(M0)): print(size) + + """ + return np.linalg.inv(matrix) + + +def concatenate_matrices(*matrices): + """Return concatenation of series of transformation matrices. + + >>> M = np.random.rand(16).reshape((4, 4)) - 0.5 + >>> np.allclose(M, concatenate_matrices(M)) + True + >>> np.allclose(np.dot(M, M.T), concatenate_matrices(M, M.T)) + True + + """ + M = np.identity(4) + for i in matrices: + M = np.dot(M, i) + return M + + +def is_same_transform(matrix0, matrix1): + """Return True if two matrices perform same transformation. + + >>> is_same_transform(np.identity(4), np.identity(4)) + True + >>> is_same_transform(np.identity(4), random_rotation_matrix()) + False + + """ + matrix0 = np.array(matrix0, dtype=np.float64) + matrix0 /= matrix0[3, 3] + matrix1 = np.array(matrix1, dtype=np.float64) + matrix1 /= matrix1[3, 3] + return np.allclose(matrix0, matrix1) + + +def is_same_quaternion(q0, q1): + """Return True if two quaternions are equal.""" + q0 = np.array(q0) + q1 = np.array(q1) + return np.allclose(q0, q1) or np.allclose(q0, -q1) + + +def transform_around(matrix, point): + """ + Given a transformation matrix, apply its rotation + around a point in space. + + Parameters + ---------- + matrix: (4,4) or (3, 3) float, transformation matrix + point: (3,) or (2,) float, point in space + + Returns + --------- + result: (4,4) transformation matrix + """ + point = np.asanyarray(point) + matrix = np.asanyarray(matrix) + dim = len(point) + if matrix.shape != (dim + 1, dim + 1): + raise ValueError("matrix must be (d+1, d+1)") + + translate = np.eye(dim + 1) + translate[:dim, dim] = -point + result = np.dot(matrix, translate) + translate[:dim, dim] = point + result = np.dot(translate, result) + + return result + + +def planar_matrix(offset=None, theta=None, point=None, scale=None): + """ + 2D homogeonous transformation matrix. + + Parameters + ---------- + offset : (2,) float + XY offset + theta : float + Rotation around Z in radians + point : (2, ) float + Point to rotate around + scale : (2,) float or None + Scale to apply + + Returns + ---------- + matrix : (3, 3) flat + Homogeneous 2D transformation matrix + """ + if offset is None: + offset = [0.0, 0.0] + if theta is None: + theta = 0.0 + offset = np.asanyarray(offset, dtype=np.float64) + theta = float(theta) + if not np.isfinite(theta): + raise ValueError("theta must be finite angle!") + if offset.shape != (2,): + raise ValueError("offset must be length 2!") + + T = np.eye(3, dtype=np.float64) + s = np.sin(theta) + c = np.cos(theta) + + T[0, :2] = [c, s] + T[1, :2] = [-s, c] + T[:2, 2] = offset + + if point is not None: + T = transform_around(matrix=T, point=point) + + if scale is not None: + S = np.eye(3) + S[:2, :2] *= scale + T = np.dot(S, T) + + return T + + +def planar_matrix_to_3D(matrix_2D): + """ + Given a 2D homogeneous rotation matrix convert it to a 3D rotation + matrix that is rotating around the Z axis + + Parameters + ---------- + matrix_2D: (3,3) float, homogeneous 2D rotation matrix + + Returns + ---------- + matrix_3D: (4,4) float, homogeneous 3D rotation matrix + """ + + matrix_2D = np.asanyarray(matrix_2D, dtype=np.float64) + if matrix_2D.shape != (3, 3): + raise ValueError("Homogeneous 2D transformation matrix required!") + + matrix_3D = np.eye(4) + # translation + matrix_3D[:2, 3] = matrix_2D[:2, 2] + # rotation from 2D to around Z + matrix_3D[:2, :2] = matrix_2D[:2, :2] + + return matrix_3D + + +def spherical_matrix(theta, phi, axes="sxyz"): + """ + Give a spherical coordinate vector, find the rotation that will + transform a [0,0,1] vector to those coordinates + + Parameters + ----------- + theta: float, rotation angle in radians + phi: float, rotation angle in radians + + Returns + ---------- + matrix: (4,4) rotation matrix where the following will + be a cartesian vector in the direction of the + input spherical coordinates: + np.dot(matrix, [0,0,1,0]) + + """ + result = euler_matrix(0.0, phi, theta, axes=axes) + return result + + +def transform_points( + points: ArrayLike, matrix: ArrayLike, translate: bool = True +) -> NDArray[np.float64]: + """ + Returns points rotated by a homogeneous + transformation matrix. + + If points are (n, 2) matrix must be (3, 3) + If points are (n, 3) matrix must be (4, 4) + + Parameters + ---------- + points : (n, dim) float + Points where `dim` is 2 or 3. + matrix : (3, 3) or (4, 4) float + Homogeneous rotation matrix. + translate : bool + Apply translation from matrix or not. + + Returns + ---------- + transformed : (n, dim) float + Transformed points. + """ + points = np.asanyarray(points, dtype=np.float64) + if len(points) == 0 or matrix is None: + return points.copy() + + # check the matrix against the points + matrix = np.asanyarray(matrix, dtype=np.float64) + # shorthand the shape + count, dim = points.shape + + # quickly check to see if we've been passed an identity matrix + if np.abs(matrix - _IDENTITY[: dim + 1, : dim + 1]).max() < 1e-8: + return np.ascontiguousarray(points.copy()) + + if translate: + # apply translation and rotation + stack = np.column_stack((points, np.ones(count))) + return np.dot(matrix, stack.T).T[:, :dim] + + # only apply the rotation + return np.dot(matrix[:dim, :dim], points.T).T + + +def fix_rigid(matrix, max_deviance=1e-5): + """ + If a homogeneous transformation matrix is *almost* a rigid + transform but many matrix-multiplies have accumulated some + floating point error try to restore the matrix using SVD. + + Parameters + ----------- + matrix : (4, 4) or (3, 3) float + Homogeneous transformation matrix. + max_deviance : float + Do not alter the matrix if it is not rigid by more + than this amount. + + Returns + ---------- + repaired : (4, 4) or (3, 3) float + Repaired homogeneous transformation matrix + """ + dim = matrix.shape[0] - 1 + check = np.abs( + np.dot(matrix[:dim, :dim], matrix[:dim, :dim].T) - _IDENTITY[:dim, :dim] + ).max() + # if the matrix differs by more than float-zero and less + # than the threshold try to repair the matrix with SVD + if check > 1e-13 and check < max_deviance: + # reconstruct the rotation from the SVD + U, _, V = np.linalg.svd(matrix[:dim, :dim]) + repaired = np.eye(dim + 1) + repaired[:dim, :dim] = np.dot(U, V) + # copy in the translation + repaired[:dim, dim] = matrix[:dim, dim] + # should be within tolerance of the original matrix + assert np.allclose(repaired, matrix, atol=max_deviance) + return repaired + + return matrix + + +def is_rigid(matrix, epsilon=1e-8): + """ + Check to make sure a homogeonous transformation + matrix is a rigid transform. + + Parameters + ----------- + matrix : (4, 4) float + A transformation matrix + + Returns + ----------- + check : bool + True if matrix is a a transform with + only translation, scale, and rotation + """ + + matrix = np.asanyarray(matrix, dtype=np.float64) + + if matrix.shape != (4, 4): + return False + + # make sure last row has no scaling + if np.ptp(matrix[-1] - [0, 0, 0, 1]) > epsilon: + return False + + # check dot product of rotation against transpose + check = np.dot(matrix[:3, :3], matrix[:3, :3].T) - _IDENTITY[:3, :3] + + return np.ptp(check) < epsilon + + +def scale_and_translate(scale=None, translate=None): + """ + Optimized version of `compose_matrix` for just + scaling then translating. + + Scalar args are broadcast to arrays of shape (3,) + + Parameters + -------------- + scale : float or (3,) float + Scale factor + translate : float or (3,) float + Translation + """ + M = np.eye(4) + if np.any(scale != 1): + M[:3, :3] *= scale + if translate is not None: + M[:3, 3] = translate + return M + + +def flips_winding(matrix): + """ + Check to see if a matrix will invert triangles. + + Parameters + ------------- + matrix : (4, 4) float + Homogeneous transformation matrix + + Returns + -------------- + flip : bool + True if matrix will flip winding of triangles. + """ + # get input as numpy array + matrix = np.asanyarray(matrix, dtype=np.float64) + if matrix.shape not in ((3, 3), (4, 4)): + raise ValueError(f"matrix must be (3, 3) or (4, 4), not {matrix.shape!s}") + # a transform flips winding exactly when its determinant is negative + return bool(np.linalg.det(matrix[:3, :3]) < 0.0) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/triangles.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/triangles.py new file mode 100644 index 0000000000000000000000000000000000000000..a6d93c303bd0b0eae2579f8d6ded3316ed52210e --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/triangles.py @@ -0,0 +1,745 @@ +""" +triangles.py +------------- + +Functions for dealing with triangle soups in (n, 3, 3) float form. +""" + +from dataclasses import dataclass +from logging import getLogger + +import numpy as np + +from . import util +from .constants import tol +from .points import point_plane_distance +from .typed import NDArray, float64 +from .util import diagonal_dot, unitize + +log = getLogger(__name__) + + +def cross(triangles: NDArray) -> NDArray: + """ + Returns the cross product of two edges from input triangles + + Parameters + -------------- + triangles: (n, 3, 3) float + Vertices of triangles + + Returns + -------------- + crosses : (n, 3) float + Cross product of two edge vectors + """ + vectors = triangles[:, 1:, :] - triangles[:, :2, :] + if triangles.shape[2] == 3: + return np.cross(vectors[:, 0], vectors[:, 1]) + elif triangles.shape[2] == 2: + a = vectors[:, 0] + b = vectors[:, 1] + # numpy 2.0 deprecated 2D cross productes + return a[:, 0] * b[:, 1] - a[:, 1] * b[:, 0] + + raise ValueError(triangles.shape) + + +def area(triangles=None, crosses=None): + """ + Calculates the sum area of input triangles + + Parameters + ---------- + triangles : (n, 3, 3) float + Vertices of triangles + crosses : (n, 3) float or None + As a speedup don't re- compute cross products + sum : bool + Return summed area or individual triangle area + + Returns + ---------- + area : (n,) float or float + Individual or summed area depending on `sum` argument + """ + if crosses is None: + crosses = cross(np.asanyarray(triangles, dtype=np.float64)) + if len(crosses.shape) == 1: + # support 2D triangles + return np.abs(crosses) / 2.0 + return np.sqrt((crosses**2).sum(axis=1)) / 2.0 + + +def normals(triangles=None, crosses=None): + """ + Calculates the normals of input triangles + + Parameters + ------------ + triangles : (n, 3, 3) float + Vertex positions + crosses : (n, 3) float + Cross products of edge vectors + + Returns + ------------ + normals : (m, 3) float + Normal vectors + valid : (n,) bool + Was the face nonzero area or not + """ + if triangles is not None: + triangles = np.asanyarray(triangles, dtype=np.float64) + if triangles.shape[-1] == 2: + # 2D triangles return unit normal along Z + unit = np.tile([0.0, 0.0, 1.0], (triangles.shape[0], 1)) + valid = np.ones(len(triangles), dtype=bool) + return unit, valid + if crosses is None: + crosses = cross(triangles) + # unitize the cross product vectors + unit, valid = unitize(crosses, check_valid=True) + return unit, valid + + +def angles(triangles): + """ + Calculates the angles of input triangles. + + Parameters + ------------ + triangles : (n, 3, 3) float + Vertex positions + + Returns + ------------ + angles : (n, 3) float + Angles at vertex positions in radians + Degenerate angles will be returned as zero + """ + # don't copy triangles + triangles = np.asanyarray(triangles, dtype=np.float64) + + # get a unit vector for each edge of the triangle + u = unitize(triangles[:, 1] - triangles[:, 0]) + v = unitize(triangles[:, 2] - triangles[:, 0]) + w = unitize(triangles[:, 2] - triangles[:, 1]) + + # run the cosine and per-row dot product + result = np.zeros((len(triangles), 3), dtype=np.float64) + # clip to make sure we don't float error past 1.0 + result[:, 0] = np.arccos(np.clip(diagonal_dot(u, v), -1, 1)) + result[:, 1] = np.arccos(np.clip(diagonal_dot(-u, w), -1, 1)) + # the third angle is just the remaining + result[:, 2] = np.pi - result[:, 0] - result[:, 1] + + # a triangle with any zero angles is degenerate + # so set all of the angles to zero in that case + result[(result < tol.merge).any(axis=1), :] = 0.0 + + return result + + +def all_coplanar(triangles): + """ + Check to see if a list of triangles are all coplanar + + Parameters + ---------------- + triangles: (n, 3, 3) float + Vertices of triangles + + Returns + --------------- + all_coplanar : bool + True if all triangles are coplanar + """ + triangles = np.asanyarray(triangles, dtype=np.float64) + if not util.is_shape(triangles, (-1, 3, 3)): + raise ValueError("Triangles must be (n, 3, 3)!") + + test_normal = normals(triangles)[0] + test_vertex = triangles[0][0] + distances = point_plane_distance( + points=triangles[1:].reshape((-1, 3)), + plane_normal=test_normal, + plane_origin=test_vertex, + ) + all_coplanar = np.all(np.abs(distances) < tol.zero) + return all_coplanar + + +def any_coplanar(triangles): + """ + For a list of triangles if the FIRST triangle is coplanar + with ANY of the following triangles, return True. + Otherwise, return False. + """ + triangles = np.asanyarray(triangles, dtype=np.float64) + if not util.is_shape(triangles, (-1, 3, 3)): + raise ValueError("Triangles must be (n, 3, 3)!") + + test_normal = normals(triangles)[0] + test_vertex = triangles[0][0] + distances = point_plane_distance( + points=triangles[1:].reshape((-1, 3)), + plane_normal=test_normal, + plane_origin=test_vertex, + ) + any_coplanar = np.any(np.all(np.abs(distances.reshape((-1, 3)) < tol.zero), axis=1)) + return any_coplanar + + +@dataclass +class MassProperties: + # the density value these mass properties were calculated with + # this alters `mass` and `inertia` + density: float + + # the volume multiplied by the density + mass: float + + # the volume produced + volume: float + + # the (3,) center of mass + center_mass: NDArray[float64] + + # the (3, 3) inertia tensor + inertia: NDArray[float64] | None = None + + def __getitem__(self, item: str): + # add for backwards compatibility + return getattr(self, item) + + +def mass_properties( + triangles, crosses=None, density=None, center_mass=None, skip_inertia=False +) -> MassProperties: + """ + Calculate the mass properties of a group of triangles. + + Implemented from: + http://www.geometrictools.com/Documentation/PolyhedralMassProperties.pdf + + Parameters + ---------- + triangles : (n, 3, 3) float + Triangle vertices in space + crosses : (n,) float + Optional cross products of triangles + density : float + Optional override for density + center_mass : (3,) float + Optional override for center mass + skip_inertia : bool + if True will not return moments matrix + + Returns + --------- + info : dict + Mass properties + """ + triangles = np.asanyarray(triangles, dtype=np.float64) + if not util.is_shape(triangles, (-1, 3, 3)): + raise ValueError("Triangles must be (n, 3, 3)!") + + if crosses is None: + crosses = cross(triangles) + if density is None: + density = 1.0 + + # these are the subexpressions of the integral + # this is equvilant but 7x faster than triangles.sum(axis=1) + f1 = triangles[:, 0, :] + triangles[:, 1, :] + triangles[:, 2, :] + + # for the the first vertex of every triangle: + # triangles[:,0,:] will give rows like [[x0, y0, z0], ...] + + # for the x coordinates of every triangle + # triangles[:,:,0] will give rows like [[x0, x1, x2], ...] + f2 = ( + triangles[:, 0, :] ** 2 + + triangles[:, 1, :] ** 2 + + triangles[:, 0, :] * triangles[:, 1, :] + + triangles[:, 2, :] * f1 + ) + f3 = ( + (triangles[:, 0, :] ** 3) + + (triangles[:, 0, :] ** 2) * (triangles[:, 1, :]) + + (triangles[:, 0, :]) * (triangles[:, 1, :] ** 2) + + (triangles[:, 1, :] ** 3) + + (triangles[:, 2, :] * f2) + ) + g0 = f2 + (triangles[:, 0, :] + f1) * triangles[:, 0, :] + g1 = f2 + (triangles[:, 1, :] + f1) * triangles[:, 1, :] + g2 = f2 + (triangles[:, 2, :] + f1) * triangles[:, 2, :] + integral = np.zeros((10, len(f1))) + integral[0] = crosses[:, 0] * f1[:, 0] + integral[1:4] = (crosses * f2).T + integral[4:7] = (crosses * f3).T + for i in range(3): + triangle_i = np.mod(i + 1, 3) + integral[i + 7] = crosses[:, i] * ( + (triangles[:, 0, triangle_i] * g0[:, i]) + + (triangles[:, 1, triangle_i] * g1[:, i]) + + (triangles[:, 2, triangle_i] * g2[:, i]) + ) + + integrated = integral.sum(axis=1) / np.array( + [6, 24, 24, 24, 60, 60, 60, 120, 120, 120], dtype=np.float64 + ) + + volume = integrated[0] + + # we allow center of mass to be overridden + if center_mass is None: + if np.abs(volume) < tol.zero: + # if there is no volume set center of mass to the centroid + log.debug("volume is negative center of mass is almost certain to be wrong!") + # otherwise get it from the integration + center_mass = integrated[1:4] / volume + + result = MassProperties( + density=density, + mass=density * volume, + volume=volume, + center_mass=center_mass, + ) + + if skip_inertia: + return result + + inertia = np.zeros((3, 3)) + inertia[0, 0] = ( + integrated[5] + integrated[6] - (volume * (center_mass[[1, 2]] ** 2).sum()) + ) + inertia[1, 1] = ( + integrated[4] + integrated[6] - (volume * (center_mass[[0, 2]] ** 2).sum()) + ) + inertia[2, 2] = ( + integrated[4] + integrated[5] - (volume * (center_mass[[0, 1]] ** 2).sum()) + ) + inertia[0, 1] = -(integrated[7] - (volume * np.prod(center_mass[[0, 1]]))) + inertia[1, 2] = -(integrated[8] - (volume * np.prod(center_mass[[1, 2]]))) + inertia[0, 2] = -(integrated[9] - (volume * np.prod(center_mass[[0, 2]]))) + inertia[2, 0] = inertia[0, 2] + inertia[2, 1] = inertia[1, 2] + inertia[1, 0] = inertia[0, 1] + result.inertia = inertia * density + + return result + + +def windings_aligned(triangles, normals_compare): + """ + Given a list of triangles and a list of normals determine if the + two are aligned + + Parameters + ---------- + triangles : (n, 3, 3) float + Vertex locations in space + normals_compare : (n, 3) float + List of normals to compare + + Returns + ---------- + aligned : (n,) bool + Are normals aligned with triangles + """ + triangles = np.asanyarray(triangles, dtype=np.float64) + if not util.is_shape(triangles, (-1, 3, 3), allow_zeros=True): + raise ValueError(f"triangles must have shape (n, 3, 3), got {triangles.shape!s}") + normals_compare = np.asanyarray(normals_compare, dtype=np.float64) + + calculated, valid = normals(triangles) + if normals_compare.shape == (3,): + # single comparison vector case + difference = np.dot(calculated, normals_compare) + else: + # multiple comparison case + difference = diagonal_dot(calculated, normals_compare[valid]) + + aligned = np.zeros(len(triangles), dtype=bool) + aligned[valid] = difference > 0.0 + + return aligned + + +def bounds_tree(triangles): + """ + Given a list of triangles, create an r-tree for broad- phase + collision detection + + Parameters + --------- + triangles : (n, 3, 3) float + Triangles in space + + Returns + --------- + tree : rtree.Rtree + One node per triangle + """ + triangles = np.asanyarray(triangles, dtype=np.float64) + if not util.is_shape(triangles, (-1, 3, (2, 3))): + raise ValueError("Triangles must be (n, 3, 3)!") + + # the (n,6) interleaved bounding box for every triangle + triangle_bounds = np.column_stack((triangles.min(axis=1), triangles.max(axis=1))) + tree = util.bounds_tree(triangle_bounds) + return tree + + +def nondegenerate(triangles, areas=None, height=None): + """ + Find all triangles which have an oriented bounding box + where both of the two sides is larger than a specified height. + + Degenerate triangles can be when: + 1) Two of the three vertices are colocated + 2) All three vertices are unique but colinear + + + Parameters + ---------- + triangles : (n, 3, 3) float + Triangles in space + height : float + Minimum edge length of a triangle to keep + + Returns + ---------- + nondegenerate : (n,) bool + True if a triangle meets required minimum height + """ + triangles = np.asanyarray(triangles, dtype=np.float64) + if not util.is_shape(triangles, (-1, 3, 3)): + raise ValueError("Triangles must be (n, 3, 3)!") + + if height is None: + height = tol.merge + + # if both edges of the triangles OBB are longer than tol.merge + # we declare them to be nondegenerate + ok = (extents(triangles=triangles, areas=areas) > height).all(axis=1) + + return ok + + +def extents(triangles, areas=None): + """ + Return the 2D bounding box size of each triangle. + + Parameters + ---------- + triangles : (n, 3, 3) float + Triangles in space + areas : (n,) float + Optional area of input triangles + + Returns + ---------- + box : (n, 2) float + The size of each triangle's 2D oriented bounding box + """ + triangles = np.asanyarray(triangles, dtype=np.float64) + if not util.is_shape(triangles, (-1, 3, 3)): + raise ValueError("Triangles must be (n, 3, 3)!") + + if areas is None: + areas = area(triangles=triangles) + + # the edge vectors which define the triangle + a = triangles[:, 1] - triangles[:, 0] + b = triangles[:, 2] - triangles[:, 0] + + # length of the edge vectors + length_a = (a**2).sum(axis=1) ** 0.5 + length_b = (b**2).sum(axis=1) ** 0.5 + + # which edges are acceptable length + nonzero_a = length_a > tol.merge + nonzero_b = length_b > tol.merge + + # find the two heights of the triangle + # essentially this is the side length of an + # oriented bounding box, per triangle + box = np.zeros((len(triangles), 2), dtype=np.float64) + box[:, 0][nonzero_a] = (areas[nonzero_a] * 2) / length_a[nonzero_a] + box[:, 1][nonzero_b] = (areas[nonzero_b] * 2) / length_b[nonzero_b] + + return box + + +def barycentric_to_points(triangles, barycentric): + """ + Convert a list of barycentric coordinates on a list of triangles + to cartesian points. + + Parameters + ------------ + triangles : (n, 3, 3) float + Triangles in space + barycentric : (n, 2) float + Barycentric coordinates + + Returns + ----------- + points : (m, 3) float + Points in space + """ + barycentric = np.array(barycentric, dtype=np.float64) + triangles = np.asanyarray(triangles, dtype=np.float64) + + # normalize in-place + barycentric /= barycentric.sum(axis=1).reshape((-1, 1)) + points = (triangles * barycentric.reshape((-1, 3, 1))).sum(axis=1) + + return points + + +def points_to_barycentric(triangles, points, method="cramer"): + """ + Find the barycentric coordinates of points relative to triangles. + + The Cramer's rule solution implements: + http://blackpawn.com/texts/pointinpoly + + The cross product solution implements: + https://www.cs.ubc.ca/~heidrich/Papers/JGT.05.pdf + + + Parameters + ----------- + triangles : (n, 3, 2 | 3) float + Triangles vertices in space + points : (n, 2 | 3) float + Point in space associated with a triangle + method : str + Which method to compute the barycentric coordinates with: + - 'cross': uses a method using cross products, roughly 2x slower but + different numerical robustness properties + - anything else: uses a cramer's rule solution + + Returns + ----------- + barycentric : (n, 3) float + Barycentric coordinates of each point + """ + + def method_cross(): + n = np.cross(edge_vectors[:, 0], edge_vectors[:, 1]) + denominator = diagonal_dot(n, n) + + barycentric = np.zeros((len(triangles), 3), dtype=np.float64) + barycentric[:, 2] = diagonal_dot(np.cross(edge_vectors[:, 0], w), n) / denominator + barycentric[:, 1] = diagonal_dot(np.cross(w, edge_vectors[:, 1]), n) / denominator + barycentric[:, 0] = 1 - barycentric[:, 1] - barycentric[:, 2] + return barycentric + + def method_cramer(): + dot00 = diagonal_dot(edge_vectors[:, 0], edge_vectors[:, 0]) + dot01 = diagonal_dot(edge_vectors[:, 0], edge_vectors[:, 1]) + dot02 = diagonal_dot(edge_vectors[:, 0], w) + dot11 = diagonal_dot(edge_vectors[:, 1], edge_vectors[:, 1]) + dot12 = diagonal_dot(edge_vectors[:, 1], w) + + inverse_denominator = 1.0 / (dot00 * dot11 - dot01 * dot01) + + barycentric = np.zeros((len(triangles), 3), dtype=np.float64) + barycentric[:, 2] = (dot00 * dot12 - dot01 * dot02) * inverse_denominator + barycentric[:, 1] = (dot11 * dot02 - dot01 * dot12) * inverse_denominator + barycentric[:, 0] = 1 - barycentric[:, 1] - barycentric[:, 2] + return barycentric + + # establish that input triangles and points are sane + triangles = np.asanyarray(triangles, dtype=np.float64) + points = np.asanyarray(points, dtype=np.float64) + + # triangles should be (n, 3, dimension) + if len(triangles.shape) != 3: + raise ValueError("triangles shape incorrect") + + # this should work for 2D and 3D triangles + dim = triangles.shape[2] + if ( + len(points.shape) != 2 + or points.shape[1] != dim + or points.shape[0] != triangles.shape[0] + ): + raise ValueError("triangles and points must correspond") + + edge_vectors = triangles[:, 1:] - triangles[:, :1] + w = points - triangles[:, 0].reshape((-1, dim)) + + if method == "cross": + return method_cross() + return method_cramer() + + +def closest_point(triangles, points): + """ + Return the closest point on the surface of each triangle for a + list of corresponding points. + + Implements the method from "Real Time Collision Detection" and + use the same variable names as "ClosestPtPointTriangle" to avoid + being any more confusing. + + + Parameters + ---------- + triangles : (n, 3, 3) float + Triangle vertices in space + points : (n, 3) float + Points in space + + Returns + ---------- + closest : (n, 3) float + Point on each triangle closest to each point + """ + + # check input triangles and points + triangles = np.asanyarray(triangles, dtype=np.float64) + points = np.asanyarray(points, dtype=np.float64) + if not util.is_shape(triangles, (-1, 3, 3)): + raise ValueError("triangles shape incorrect") + if not util.is_shape(points, (len(triangles), 3)): + raise ValueError("need same number of triangles and points!") + + # store the location of the closest point + result = np.zeros_like(points) + # which points still need to be handled + remain = np.ones(len(points), dtype=bool) + + # if we dot product this against a (n, 3) + # it is equivalent but faster than array.sum(axis=1) + ones = [1.0, 1.0, 1.0] + + # get the three points of each triangle + # use the same notation as RTCD to avoid confusion + a = triangles[:, 0, :] + b = triangles[:, 1, :] + c = triangles[:, 2, :] + + # check if P is in vertex region outside A + ab = b - a + ac = c - a + ap = points - a + # this is a faster equivalent of: + # diagonal_dot(ab, ap) + d1 = np.dot(ab * ap, ones) + d2 = np.dot(ac * ap, ones) + + # is the point at A + is_a = np.logical_and(d1 < tol.zero, d2 < tol.zero) + if any(is_a): + result[is_a] = a[is_a] + remain[is_a] = False + + # When A and B coincide the triangle is the segment AC (or a point). + # Handle these before the AB projection, whose denominator is |AB|**2. + collapsed_ab = np.all(ab == 0.0, axis=1) + if collapsed_ab.any(): + segment = ac[collapsed_ab] + length_squared = np.sum(segment**2, axis=1) + factor = np.zeros(len(segment), dtype=np.float64) + np.divide( + np.sum(ap[collapsed_ab] * segment, axis=1), + length_squared, + out=factor, + where=length_squared > 0, + ) + result[collapsed_ab] = a[collapsed_ab] + np.clip(factor, 0, 1)[:, None] * segment + remain[collapsed_ab] = False + + # check if P in vertex region outside B + bp = points - b + d3 = np.dot(ab * bp, ones) + d4 = np.dot(ac * bp, ones) + + # do the logic check + is_b = (d3 > -tol.zero) & (d4 <= d3) & remain + if any(is_b): + result[is_b] = b[is_b] + remain[is_b] = False + + # check if P in edge region of AB, if so return projection of P onto A + vc = (d1 * d4) - (d3 * d2) + is_ab = (vc < tol.zero) & (d1 > -tol.zero) & (d3 < tol.zero) & remain + if any(is_ab): + v = (d1[is_ab] / (d1[is_ab] - d3[is_ab])).reshape((-1, 1)) + result[is_ab] = a[is_ab] + (v * ab[is_ab]) + remain[is_ab] = False + + # check if P in vertex region outside C + cp = points - c + d5 = np.dot(ab * cp, ones) + d6 = np.dot(ac * cp, ones) + is_c = (d6 > -tol.zero) & (d5 <= d6) & remain + if any(is_c): + result[is_c] = c[is_c] + remain[is_c] = False + + # check if P in edge region of AC, if so return projection of P onto AC + vb = (d5 * d2) - (d1 * d6) + is_ac = (vb < tol.zero) & (d2 > -tol.zero) & (d6 < tol.zero) & remain + if any(is_ac): + w = (d2[is_ac] / (d2[is_ac] - d6[is_ac])).reshape((-1, 1)) + result[is_ac] = a[is_ac] + w * ac[is_ac] + remain[is_ac] = False + + # check if P in edge region of BC, if so return projection of P onto BC + va = (d3 * d6) - (d5 * d4) + is_bc = (va < tol.zero) & ((d4 - d3) > -tol.zero) & ((d5 - d6) > -tol.zero) & remain + if any(is_bc): + d43 = d4[is_bc] - d3[is_bc] + w = (d43 / (d43 + (d5[is_bc] - d6[is_bc]))).reshape((-1, 1)) + result[is_bc] = b[is_bc] + w * (c[is_bc] - b[is_bc]) + remain[is_bc] = False + + # any remaining points must be inside face region + if any(remain): + # point is inside face region + denom = 1.0 / (va[remain] + vb[remain] + vc[remain]) + v = (vb[remain] * denom).reshape((-1, 1)) + w = (vc[remain] * denom).reshape((-1, 1)) + # compute Q through its barycentric coordinates + result[remain] = a[remain] + (ab[remain] * v) + (ac[remain] * w) + + return result + + +def to_kwargs(triangles): + """ + Convert a list of triangles to the kwargs for the Trimesh + constructor. + + Parameters + --------- + triangles : (n, 3, 3) float + Triangles in space + + Returns + --------- + kwargs : dict + Keyword arguments for the trimesh.Trimesh constructor + Includes keys 'vertices' and 'faces' + + Examples + --------- + >>> mesh = trimesh.Trimesh(**trimesh.triangles.to_kwargs(triangles)) + """ + triangles = np.asanyarray(triangles, dtype=np.float64) + if not util.is_shape(triangles, (-1, 3, 3)): + raise ValueError("Triangles must be (n, 3, 3)!") + + vertices = triangles.reshape((-1, 3)) + faces = np.arange(len(vertices)).reshape((-1, 3)) + kwargs = {"vertices": vertices, "faces": faces} + + return kwargs diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/typed.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/typed.py new file mode 100644 index 0000000000000000000000000000000000000000..ad7d769c3a0c8f87813f861172c4c7fa1f508dd8 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/typed.py @@ -0,0 +1,146 @@ +import io +import typing +from collections.abc import Callable, Hashable, Iterable, Mapping, Sequence +from io import IOBase +from pathlib import Path +from sys import version_info +from typing import ( + IO, + Any, + BinaryIO, + Literal, + Protocol, + TypeAlias, + TypeGuard, + TypeVar, + runtime_checkable, +) + +import numpy +from numpy import dtype, float64, floating, generic, int64, integer, ndarray +from numpy.random import BitGenerator, Generator, SeedSequence +from numpy.typing import ArrayLike, DTypeLike, NDArray + +if version_info >= (3, 11): + from typing import Self +else: + Self = Any + +# most loader routes take `file_obj` which can either be +# a file-like object or a file path, or sometimes a dict +# `IOBase` is the base of every stdlib stream and is included because +# concrete streams like `io.BytesIO` don't satisfy the `IO` protocol +# under beartype — https://github.com/beartype/beartype/issues/643 +Stream: TypeAlias = IO[str] | IO[bytes] | IOBase +Loadable: TypeAlias = str | Path | Stream | dict | None + +# for a function that returns "is this a file or not" +# but with typeguard-narrowing if the answer is yes +BoolIsFile: TypeAlias = TypeGuard[IO[Any]] + +# numpy integers do not inherit from python integers, i.e. +# if you type a function argument as an `int` and then pass +# a value from a numpy array like `np.ones(10, dtype=np.int64)[0]` +# you may have a type error. +# these wrappers union numpy integers and python integers +Integer: TypeAlias = int | integer + +# Numbers which can only be floats and will not accept integers +# > isinstance(np.ones(1, dtype=np.float32)[0], floating) # True +# > isinstance(np.ones(1, dtype=np.float32)[0], float) # False +Floating: TypeAlias = float | floating + +# Many arguments take "any valid number" and don't care if it +# is an integer or a floating point input. +Number: TypeAlias = Floating | Integer + +# the literals for specifying what viewer to use +ViewerType: TypeAlias = Callable | Literal["gl", "jupyter", "marimo"] | None + +# literal for color maps we include in the library +ColorMapType: TypeAlias = Literal["viridis", "magma", "inferno", "plasma"] + +# the literal for what graph backend engines are available +GraphEngineType: TypeAlias = Literal["networkx", "scipy"] | None + +# what 3D boolean engines are available +BooleanEngineType: TypeAlias = Literal["manifold", "blender"] | None +# what 3D boolean operations can be passed to boolean functions +BooleanOperationType: TypeAlias = Literal["difference", "union", "intersection"] + +# what are the supported methods for converting a mesh into voxels. +VoxelizationMethodsType: TypeAlias = Literal["subdivide", "ray", "binvox"] + + +@runtime_checkable +class HttpSessionLike(Protocol): + """ + Structural type for an HTTP session. + + Matches `httpx.Client` and `requests.Session` so a resolver + can take either without trimesh importing them directly. + other duck-typed sessions are called as `get(url)` with no + additional kwargs. async sessions like `aiohttp.ClientSession` + can't be driven synchronously and are rejected at runtime. + """ + + def get(self, url: str, *args, **kwargs) -> Any: ... + + +# add numpy types like their `numpy.typing.NDArray` +# but with specific dimensionality, i.e. `NDArray2D[np.float64]` +DType = TypeVar("DType", bound=generic) +NDArray1D: TypeAlias = ndarray[tuple[int], dtype[DType]] +NDArray2D: TypeAlias = ndarray[tuple[int, int], dtype[DType]] +NDArray3D: TypeAlias = ndarray[tuple[int, int, int], dtype[DType]] + +# anything `numpy.random.default_rng` can normalize into a `Generator` +# passing a `Generator` lets a caller thread one stream through nested +# calls -- `default_rng` hands it back rather than re-seeding it +Seed: TypeAlias = Integer | Sequence[int] | SeedSequence | Generator | BitGenerator | None + + +# DEPRECATED : these aliases will be removed after July 2028 +# import them from `typing`, `io`, or `numpy` instead +List = list +Dict = dict +Tuple = tuple +Set = set +Optional = typing.Optional +Union = typing.Union +TextIO = typing.TextIO +BytesIO = io.BytesIO +StringIO = io.StringIO +BufferedRandom = io.BufferedRandom +unsignedinteger = numpy.unsignedinteger + + +__all__ = [ + "IO", + "Any", + "ArrayLike", + "BinaryIO", + "BoolIsFile", + "Callable", + "DTypeLike", + "Floating", + "Hashable", + "HttpSessionLike", + "Integer", + "Iterable", + "Literal", + "Loadable", + "Mapping", + "NDArray", + "NDArray1D", + "NDArray2D", + "NDArray3D", + "Number", + "Seed", + "Self", + "Sequence", + "Stream", + "ViewerType", + "float64", + "int64", +] diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/units.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/units.py new file mode 100644 index 0000000000000000000000000000000000000000..a12d38a04dfaf1e874538cc6b65d84e6825d897d --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/units.py @@ -0,0 +1,164 @@ +""" +units.py +-------------- +Deal with physical unit systems (i.e. inches, mm) + +Very basic conversions, and no requirement for +sympy.physics.units or pint. +""" + +from . import resources +from .constants import log +from .parent import Geometry + +# scaling factors from various unit systems to inches +_lookup = resources.get_json("units_to_inches.json") + + +def unit_conversion(current: str, desired: str) -> float: + """ + Calculate the conversion from one set of units to another. + + Parameters + --------- + current : str + Unit system values are in now (eg 'millimeters') + desired : str + Unit system we'd like values in (eg 'inches') + + Returns + --------- + conversion : float + Number to multiply by to put values into desired units + """ + # convert to common system then return ratio between current and desired + return to_inch(current.strip().lower()) / to_inch(desired.strip().lower()) + + +def keys() -> set: + """ + Return a set containing all currently valid units. + + Returns + -------- + keys + All units with conversions i.e. {'in', 'm', ...} + """ + return set(_lookup.keys()) + + +def to_inch(unit: str) -> float: + """ + Calculate the conversion to an arbitrary common unit. + + Parameters + ------------ + unit + Either a key in `units_to_inches.json` or in the simple + `{float} * {str}` form, i.e. "1.2 * meters". We don't + support arbitrary `eval` of any math string + + Returns + ---------- + conversion + Factor to multiply by to get to an `inch` system. + """ + # see if the units are just in our lookup table + lookup = _lookup.get(unit.strip().lower(), None) + + if lookup is not None: + return lookup + try: + # otherwise check to see if they are in the factor * unit form + value, key = unit.split("*") + return _lookup[key.strip()] * float(value) + except BaseException as E: + # add a helpful error message + message = ( + f'arbitrary units must be in the form "1.21 * meters", not "{unit}" ({E})' + ) + + raise ValueError(message) + + +def units_from_metadata(obj: Geometry, guess: bool = True) -> str: + """ + Try to extract hints from metadata and if that fails + guess based on the object scale. + + + Parameters + ------------ + obj + A geometry object. + guess + If metadata doesn't have units make a "best guess" + + Returns + ------------ + units + A guess of what the units might be + """ + + hints = [obj.metadata.get("name", None)] + if obj.source is not None: + hints.append(obj.source.file_name) + + # try to guess from metadata + for hint in hints: + if hint is None: + continue + hint = hint.lower().replace("units", " ").replace("unit", " ") + # replace all delimiter options with white space + for delim in "_-.": + hint = hint.replace(delim, " ") + hint = "".join(c for c in hint if c not in "0123456789") + # loop through each hint + for h in hint.strip().split(): + # if the hint is a valid unit return it + if h in _lookup: + return h + + if not guess: + raise ValueError("No units and not allowed to guess!") + + # we made it to the wild ass guess section + # if the scale is larger than 100 mystery units + # declare the model to be millimeters, otherwise inches + log.debug("no units: guessing from scale") + if float(obj.scale) > 100.0: + return "millimeters" + else: + return "inches" + + +def _convert_units(obj: Geometry, desired: str, guess=False) -> None: + """ + Given an object with scale and units try to scale + to different units via the object's `apply_scale`. + + Parameters + --------- + obj : object + With apply_scale method (i.e. Trimesh, Path2D, etc) + desired : str + Units desired (eg 'inches') + guess: bool + Whether we are allowed to guess the units + if they are not specified. + """ + if obj.units is None: + # try to extract units from metadata + # if nothing specified in metadata and not allowed + # to guess will raise a ValueError + obj.units = units_from_metadata(obj, guess=guess) + + log.debug("converting units from %s to %s", obj.units, desired) + # float, conversion factor + conversion = unit_conversion(obj.units, desired) + + # apply scale uses transforms which preserve + # cached properties rather than just multiplying vertices + obj.apply_scale(conversion) + # units are now desired units + obj.units = desired diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/util.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/util.py new file mode 100644 index 0000000000000000000000000000000000000000..ef343411bd2d997b919c73400f1481d4bd553d80 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/util.py @@ -0,0 +1,2656 @@ +""" +Grab bag of utility functions. +""" + +import abc +import base64 +import collections +import json +import logging +import random +import shutil +import time +import uuid +import warnings +import zipfile +from collections.abc import ( + Callable, + Collection, + Hashable, + Iterator, + Mapping, + MutableMapping, + MutableSet, + Sequence, +) +from copy import deepcopy +from dataclasses import asdict as dataclass_to_dict +from io import BytesIO, StringIO +from typing import TYPE_CHECKING + +import numpy as np + +from .iteration import chain + +# use our wrapped types for wider version compatibility +from .typed import ( + Any, + ArrayLike, + BoolIsFile, + Floating, + Integer, + Iterable, + NDArray, + NDArray1D, + NDArray2D, + Number, + Seed, + Stream, +) + +# imported only so type checkers can resolve the dotted forward-ref +# string return below — never imported at runtime, and beartype +# re-imports the dotted path itself when the function is first called +if TYPE_CHECKING: + import trimesh.parent + +# create a default logger +log: logging.Logger = logging.getLogger(__name__) + +ABC = abc.ABC +now = time.time +which = shutil.which + +# include constants here so we don't have to import +# a floating point threshold for 0.0 +# we are setting it to 100x the resolution of a float64 +# which works out to be 1e-13 +TOL_ZERO: float = float(np.finfo(np.float64).resolution * 100) +# how close to merge vertices +TOL_MERGE: float = 1e-8 +# enable additional potentially slow checks +_STRICT: bool = False + +# beartype is unable to resolve `NDArray[float64]` for globals +_IDENTITY: np.ndarray = np.eye(4, dtype=np.float64) +_IDENTITY.flags["WRITEABLE"] = False + +# one process-wide generator for the unseeded case: constructing one +# collects OS entropy which costs ~200x more than the draw it feeds +_RANDOM_DEFAULT = np.random.default_rng() + + +def random_generator(seed: Seed = None) -> np.random.Generator: + """ + Get a random generator, optionally seeded for deterministic results. + + Parameters + ---------- + seed + If None use a shared generator seeded from OS entropy. An integer + seeds a fresh generator. A `Generator` is returned unaltered which + lets a caller thread one stream through nested calls rather than + re-seeding each of them to identical values. + + Returns + ------- + generator + Draw random values from this. + """ + if seed is None: + # numpy locks the bit generator on every draw so sharing + # this between threads is as safe as `numpy.random.random` + return _RANDOM_DEFAULT + return np.random.default_rng(seed) + + +def has_module(name: str) -> bool: + """ + Check to see if a module is installed by name without + actually importing the module. + + Parameters + ------------ + name : str + The name of the module to check + + Returns + ------------ + installed : bool + True if module is installed + """ + from importlib.util import find_spec + + return find_spec(name) is not None + + +def unitize( + vectors: ArrayLike, + check_valid: bool = False, + threshold: float | None = None, +): + """ + Unitize a vector or an array or row-vectors. + + Parameters + ------------ + vectors : (n,m) or (j) float + Vector or vectors to be unitized + check_valid : bool + If set, will return mask of nonzero vectors + threshold : float + Cutoff for a value to be considered zero. + + Returns + --------- + unit : (n,m) or (j) float + Input vectors but unitized + valid : (n,) bool or bool + Mask of nonzero vectors returned if `check_valid` + """ + # make sure we have a numpy array + vectors = np.asanyarray(vectors) + + # allow user to set zero threshold + if threshold is None: + threshold = TOL_ZERO + + if len(vectors.shape) == 2: + # for (m, d) arrays take the per-row unit vector + # using sqrt and avoiding exponents is slightly faster + # also dot with ones is faser than .sum(axis=1) + norm = np.sqrt(np.dot(vectors * vectors, [1.0] * vectors.shape[1])) + # non-zero norms + valid = norm > threshold + # in-place reciprocal of nonzero norms + norm[valid] **= -1 + # multiply by reciprocal of norm + unit = vectors * norm.reshape((-1, 1)) + + elif len(vectors.shape) == 1: + # treat 1D arrays as a single vector + norm = np.sqrt(np.dot(vectors, vectors)) + valid = norm > threshold + if valid: + unit = vectors / norm + else: + unit = vectors.copy() + else: + raise ValueError("vectors must be (n, ) or (n, d)!") + + if check_valid: + return unit[valid], valid + return unit + + +def euclidean(a: ArrayLike, b: ArrayLike) -> np.float64: + """ + DEPRECATED: use `np.linalg.norm(a - b)` instead of this. + """ + warnings.warn( + "`trimesh.util.euclidean` is deprecated " + + "and will be removed in January 2025. " + + "replace with `np.linalg.norm(a - b)`", + category=DeprecationWarning, + stacklevel=2, + ) + + a = np.asanyarray(a, dtype=np.float64) + b = np.asanyarray(b, dtype=np.float64) + return np.sqrt(((a - b) ** 2).sum()) + + +def is_file(obj: Any) -> BoolIsFile: + """ + Check if an object is file-like + + Parameters + ------------ + obj : object + Any object type to be checked + + Returns + ----------- + is_file : bool + True if object is a file + """ + return hasattr(obj, "read") or hasattr(obj, "write") + + +def is_pathlib(obj: object) -> bool: + """ + Check if the object is a `pathlib.Path` or subclass. + + Parameters + ------------ + obj : object + Object to be checked + + Returns + ------------ + is_pathlib : bool + Is the input object a pathlib path + """ + # check class name rather than a pathlib import + name = obj.__class__.__name__ + return hasattr(obj, "absolute") and name.endswith("Path") + + +def is_string(obj: object) -> bool: + """ + DEPRECATED : this is not necessary since we dropped Python 2. + + Replace with `isinstance(obj, str)` + """ + warnings.warn( + "`trimesh.util.is_string` is deprecated " + + "and will be removed in January 2025. " + + "replace with `isinstance(obj, str)`", + category=DeprecationWarning, + stacklevel=2, + ) + + return isinstance(obj, str) + + +def is_sequence(obj: Any) -> bool: + """ + Check if an object is a sequence or not. + + Parameters + ------------- + obj : object + Any object type to be checked + + Returns + ------------- + is_sequence : bool + True if object is sequence + """ + seq = (not hasattr(obj, "strip") and hasattr(obj, "__getitem__")) or hasattr( + obj, "__iter__" + ) + + # check to make sure it is not a set, string, or dictionary + seq = seq and all(not isinstance(obj, i) for i in (dict, set, str)) + + # PointCloud objects can look like an array but are not + seq = seq and type(obj).__name__ not in ["PointCloud"] + + # numpy sometimes returns objects that are single float64 values + # but sure look like sequences, so we check the shape + if hasattr(obj, "shape"): + seq = seq and obj.shape != () + + return seq + + +def is_shape( + obj: NDArray | Any, + shape: Sequence[int | tuple[int, ...]], + allow_zeros: bool = False, +) -> bool: + """ + Compare the shape of a numpy.ndarray to a target shape, + with any value less than zero being considered a wildcard + + Note that if a list-like object is passed that is not a numpy + array, this function will not convert it and will return False. + + Parameters + ------------ + obj : np.ndarray + Array to check the shape on + shape : list or tuple + Any negative term will be considered a wildcard + Any tuple term will be evaluated as an OR + allow_zeros: bool + if False, zeros do not match negatives in shape + + Returns + --------- + shape_ok : bool + True if shape of obj matches query shape + + Examples + ------------------------ + In [1]: a = np.random.random((100, 3)) + + In [2]: a.shape + Out[2]: (100, 3) + + In [3]: trimesh.util.is_shape(a, (-1, 3)) + Out[3]: True + + In [4]: trimesh.util.is_shape(a, (-1, 3, 5)) + Out[4]: False + + In [5]: trimesh.util.is_shape(a, (100, -1)) + Out[5]: True + + In [6]: trimesh.util.is_shape(a, (-1, (3, 4))) + Out[6]: True + + In [7]: trimesh.util.is_shape(a, (-1, (4, 5))) + Out[7]: False + """ + + # if the obj.shape is different length than + # the goal shape it means they have different number + # of dimensions and thus the obj is not the query shape + if not hasattr(obj, "shape") or len(obj.shape) != len(shape): + return False + + # empty lists with any flexible dimensions match + if len(obj) == 0 and -1 in shape: + return True + + # loop through each integer of the two shapes + # multiple values are sequences + # wildcards are less than zero (i.e. -1) + for i, target in zip(obj.shape, shape): + # check if current field has multiple acceptable values + # an explicit tuple/list check narrows `target` for type + # checkers — `is_sequence` is not a type guard + if isinstance(target, (list, tuple)): + if i in target: + # obj shape is in the accepted values + continue + else: + return False + + # check if current field is a wildcard + if int(target) < 0: + if i == 0 and not allow_zeros: + # if a dimension is 0, we don't allow + # that to match to a wildcard + # it would have to be explicitly called out as 0 + return False + else: + continue + # since we have a single target and a single value, + # if they are not equal we have an answer + if target != i: + return False + + # since none of the checks failed the obj.shape + # matches the pattern + return True + + +def make_sequence(obj: Any) -> list: + """ + Given an object, if it is a sequence return, otherwise + add it to a length 1 sequence and return. + + Useful for wrapping functions which sometimes return single + objects and other times return lists of objects. + + Parameters + ------------- + obj : object + An object to be made a sequence + + Returns + -------------- + as_sequence : (n,) sequence + Contains input value + """ + if is_sequence(obj): + return list(obj) + else: + return [obj] + + +def vector_hemisphere( + vectors: ArrayLike, + return_sign: bool = False, +): + """ + For a set of 3D vectors alter the sign so they are all in the + upper hemisphere. + + If the vector lies on the plane all vectors with negative Y + will be reversed. + + If the vector has a zero Z and Y value vectors with a + negative X value will be reversed. + + Parameters + ------------ + vectors : (n, 3) float + Input vectors + return_sign : bool + Return the sign mask or not + + Returns + ---------- + oriented: (n, 3) float + Vectors with same magnitude as source + but possibly reversed to ensure all vectors + are in the same hemisphere. + sign : (n,) float + [OPTIONAL] sign of original vectors + """ + # vectors as numpy array + vectors = np.asanyarray(vectors, dtype=np.float64) + + if is_shape(vectors, (-1, 2)): + # 2D vector case + # check the Y value and reverse vector + # direction if negative. + negative = vectors < -TOL_ZERO + zero = np.logical_not(np.logical_or(negative, vectors > TOL_ZERO)) + + signs = np.ones(len(vectors), dtype=np.float64) + # negative Y values are reversed + signs[negative[:, 1]] = -1.0 + + # zero Y and negative X are reversed + signs[np.logical_and(zero[:, 1], negative[:, 0])] = -1.0 + + elif is_shape(vectors, (-1, 3)): + # 3D vector case + negative = vectors < -TOL_ZERO + zero = np.logical_not(np.logical_or(negative, vectors > TOL_ZERO)) + # move all negative Z to positive + # then for zero Z vectors, move all negative Y to positive + # then for zero Y vectors, move all negative X to positive + signs = np.ones(len(vectors), dtype=np.float64) + # all vectors with negative Z values + signs[negative[:, 2]] = -1.0 + # all on-plane vectors with negative Y values + signs[np.logical_and(zero[:, 2], negative[:, 1])] = -1.0 + # all on-plane vectors with zero Y values + # and negative X values + signs[ + np.logical_and(np.logical_and(zero[:, 2], zero[:, 1]), negative[:, 0]) + ] = -1.0 + + else: + raise ValueError("vectors must be (n, 3)!") + + # apply the signs to the vectors + oriented = vectors * signs.reshape((-1, 1)) + + if return_sign: + return oriented, signs + + return oriented + + +def vector_to_spherical(cartesian: ArrayLike) -> NDArray2D[np.float64]: + """ + Convert a set of cartesian points to (n, 2) spherical unit + vectors. + + Parameters + ------------ + cartesian : (n, 3) float + Points in space + + Returns + ------------ + spherical : (n, 2) float + Angles, in radians + """ + cartesian = np.asanyarray(cartesian, dtype=np.float64) + if not is_shape(cartesian, (-1, 3)): + raise ValueError("Cartesian points must be (n, 3)!") + + unit, valid = unitize(cartesian, check_valid=True) + unit[np.abs(unit) < TOL_MERGE] = 0.0 + + x, y, z = unit.T + spherical = np.zeros((len(cartesian), 2), dtype=np.float64) + spherical[valid] = np.column_stack((np.arctan2(y, x), np.arccos(z))) + return spherical + + +def spherical_to_vector(spherical: ArrayLike) -> NDArray2D[np.float64]: + """ + Convert an array of `(n, 2)` spherical angles to `(n, 3)` unit vectors. + + Parameters + ------------ + spherical : (n , 2) float + Angles, in radians + + Returns + ----------- + vectors : (n, 3) float + Unit vectors + """ + spherical = np.asanyarray(spherical, dtype=np.float64) + if not is_shape(spherical, (-1, 2)): + raise ValueError("spherical coordinates must be (n, 2)!") + + theta, phi = spherical.T + st, ct = np.sin(theta), np.cos(theta) + sp, cp = np.sin(phi), np.cos(phi) + return np.column_stack((ct * sp, st * sp, cp)) + + +def pairwise(iterable: Iterable[Any]): + """ + For an iterable, group values into pairs. + + Parameters + ------------ + iterable : (m, ) list + A sequence of values + + Returns + ----------- + pairs: (n, 2) + Pairs of sequential values + + Example + ----------- + In [1]: data + Out[1]: [0, 1, 2, 3, 4, 5, 6] + + In [2]: list(trimesh.util.pairwise(data)) + Out[2]: [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6)] + + """ + # looping through a giant numpy array would be dumb + # so special case ndarrays and use numpy operations + if isinstance(iterable, np.ndarray): + iterable = iterable.reshape(-1) + stacked = np.column_stack((iterable, iterable)) + pairs = stacked.reshape(-1)[1:-1].reshape((-1, 2)) + return pairs + + # if we have a normal iterable use itertools + import itertools + + a, b = itertools.tee(iterable) + # pop the first element of the second item + next(b) + + return zip(a, b) + + +multi_dot = np.linalg.multi_dot + + +def diagonal_dot(a: ArrayLike, b: ArrayLike) -> np.ndarray[tuple[int], np.dtype[Any]]: + """ + Dot product by row of a and b. + + There are a lot of ways to do this though + performance varies very widely. This method + uses a dot product to sum the row and avoids + function calls if at all possible. + + Comparing performance of some equivalent versions: + ``` + In [1]: import numpy as np; import trimesh + + In [2]: a = np.random.random((10000, 3)) + + In [3]: b = np.random.random((10000, 3)) + + In [4]: %timeit (a * b).sum(axis=1) + 1000 loops, best of 3: 181 us per loop + + In [5]: %timeit np.einsum('ij,ij->i', a, b) + 10000 loops, best of 3: 62.7 us per loop + + In [6]: %timeit np.diag(np.dot(a, b.T)) + 1 loop, best of 3: 429 ms per loop + + In [7]: %timeit np.dot(a * b, np.ones(a.shape[1])) + 10000 loops, best of 3: 61.3 us per loop + + In [8]: %timeit trimesh.util.diagonal_dot(a, b) + 10000 loops, best of 3: 55.2 us per loop + ``` + + Parameters + ------------ + a : (m, d) float + First array + b : (m, d) float + Second array + + Returns + ------------- + result : (m,) float + Dot product of each row + """ + # make sure `a` is numpy array + # doing it for `a` will force the multiplication to + # convert `b` if necessary and avoid function call otherwise + a = np.asanyarray(a) + # 3x faster than (a * b).sum(axis=1) + # avoiding np.ones saves 5-10% sometimes + return np.dot(a * b, [1.0] * a.shape[1]) + + +def row_norm(data: NDArray2D[Any]) -> NDArray1D[np.float64]: + """ + Compute the norm per-row of a numpy array. + + This is identical to np.linalg.norm(data, axis=1) but roughly + three times faster due to being less general. + + In [3]: %timeit trimesh.util.row_norm(a) + 76.3 us +/- 651 ns per loop + + In [4]: %timeit np.linalg.norm(a, axis=1) + 220 us +/- 5.41 us per loop + + Parameters + ------------- + data : (n, d) float + Input 2D data to calculate per-row norm of + + Returns + ------------- + norm : (n,) float + Norm of each row of input array + """ + return np.sqrt(np.dot(data**2, [1] * data.shape[1])) + + +def stack_3D( + points: ArrayLike, + return_2D: bool = False, +) -> NDArray2D[np.float64] | tuple[NDArray2D[np.float64], bool]: + """ + For a list of (n, 2) or (n, 3) points return them + as (n, 3) 3D points, 2D points on the XY plane. + + Parameters + ------------ + points : (n, 2) or (n, 3) float + Points in either 2D or 3D space + return_2D : bool + Were the original points 2D? + + Returns + ---------- + points : (n, 3) float + Points in space + is_2D : bool + [OPTIONAL] if source points were (n, 2) + """ + points = np.asanyarray(points, dtype=np.float64) + shape = points.shape + + if shape == (0,): + is_2D = False + elif len(shape) != 2: + raise ValueError("Points must be 2D array!") + elif shape[1] == 2: + points = np.column_stack((points, np.zeros(len(points)))) + is_2D = True + elif shape[1] == 3: + is_2D = False + else: + raise ValueError("Points must be (n, 2) or (n, 3)!") + + if return_2D: + return points, is_2D + + return points + + +def grid_arange(bounds: ArrayLike, step: Number | ArrayLike) -> NDArray2D[np.float64]: + """ + Return a grid from an (2,dimension) bounds with samples step distance apart. + + Parameters + ------------ + bounds: (2,dimension) list of [[min x, min y, etc], [max x, max y, etc]] + step: float, or (dimension) floats, separation between points + + Returns + --------- + grid: (n, dimension), points inside the specified bounds + """ + bounds = np.asanyarray(bounds, dtype=np.float64) + if len(bounds) != 2: + raise ValueError("bounds must be (2, dimension!") + + # allow single float or per-dimension spacing + step = np.asanyarray(step, dtype=np.float64) + if step.shape == (): + step = np.tile(step, bounds.shape[1]) + + grid_elements = [np.arange(*b, step=s) for b, s in zip(bounds.T, step)] + grid = ( + np.vstack(np.meshgrid(*grid_elements, indexing="ij")) + .reshape(bounds.shape[1], -1) + .T + ) + return grid + + +def grid_linspace(bounds: ArrayLike, count: Integer | ArrayLike) -> NDArray2D[np.float64]: + """ + Return a grid spaced inside a bounding box with edges spaced using np.linspace. + + Parameters + ------------ + bounds: (2,dimension) list of [[min x, min y, etc], [max x, max y, etc]] + count: int, or (dimension,) int, number of samples per side + + Returns + --------- + grid: (n, dimension) float, points in the specified bounds + """ + bounds = np.asanyarray(bounds, dtype=np.float64) + if len(bounds) != 2: + raise ValueError("bounds must be (2, dimension!") + + count = np.asanyarray(count, dtype=np.int64) + if count.shape == (): + count = np.tile(count, bounds.shape[1]) + + grid_elements = [np.linspace(*b, num=c) for b, c in zip(bounds.T, count)] + grid = ( + np.vstack(np.meshgrid(*grid_elements, indexing="ij")) + .reshape(bounds.shape[1], -1) + .T + ) + return grid + + +def multi_dict( + pairs: ArrayLike | Iterable[tuple[Hashable, Any]], +) -> collections.defaultdict[Hashable, list]: + """ + Given a set of key value pairs, create a dictionary. + If a key occurs multiple times, stack the values into an array. + + Can be called like the regular dict(pairs) constructor + + Parameters + ------------ + pairs: (n, 2) array of key, value pairs + + Returns + ---------- + result: dict, with all values stored (rather than last with regular dict) + + """ + result = collections.defaultdict(list) + for k, v in pairs: + result[k].append(v) + return result + + +def tolist(data: object) -> Any: + """ + Ensure that any arrays or dicts passed containing + numpy arrays are properly converted to lists + + Parameters + ------------- + data : any + Usually a dict with some numpy arrays as values + + Returns + ---------- + result : any + JSON-serializable version of data + """ + result = json.loads(jsonify(data)) + return result + + +def is_binary_file(file_obj: Stream) -> bool: + """ + Returns True if file has non-ASCII characters (> 0x7F, or 127) + """ + start = file_obj.tell() + fbytes = file_obj.read(1024) + file_obj.seek(start) + is_str = isinstance(fbytes, str) + for fbyte in fbytes: + if is_str: + code = ord(fbyte) + else: + code = fbyte + if code > 127: + return True + return False + + +def distance_to_end(file_obj: Stream) -> int: + """ + For an open file object how far is it to the end + + Parameters + ------------ + file_obj: open file-like object + + Returns + ---------- + distance: int, bytes to end of file + """ + position_current = file_obj.tell() + file_obj.seek(0, 2) + position_end = file_obj.tell() + file_obj.seek(position_current) + distance = position_end - position_current + return distance + + +def decimal_to_digits(decimal: Floating, min_digits: Integer | None = None) -> int: + """ + Return the number of digits to the first nonzero decimal. + + Parameters + ----------- + decimal: float + min_digits: int, minimum number of digits to return + + Returns + ----------- + + digits: int, number of digits to the first nonzero decimal + """ + digits = abs(int(np.log10(decimal))) + if min_digits is not None: + digits = np.clip(digits, min_digits, 20) + return int(digits) + + +def attach_to_log( + level: Integer = logging.DEBUG, + handler: logging.Handler | None = None, + loggers: MutableSet[logging.Logger] | None = None, + colors: bool = True, + capture_warnings: bool = True, + blacklist: Iterable[str] | None = None, + only_parent: bool = True, +) -> None: + """ + Attach a stream handler to all loggers. + + Parameters + ------------ + level : enum + Logging level, like logging.INFO + handler : None or logging.Handler + Handler to attach + loggers : None or (n,) logging.Logger + If None, will try to attach to all available + colors : bool + If True try to use colorlog formatter + blacklist : (n,) str + Names of loggers NOT to attach to + only_parent + Only attach to parent loggers, i.e. `trimesh`, `trimesh.sub1`, `trimesh.sub2` + will only attach to `trimesh` and not the sub-loggers + """ + + # default blacklist includes ipython debugging stuff + if blacklist is None: + blacklist = [ + "TerminalIPythonApp", + "PYREADLINE", + "pyembree", + "shapely", + "matplotlib", + "parso.cache", + "parso", + "parso.python.diff", + "asyncio", + "prompt_toolkit.buffer", + ] + + # make sure we log warnings from the warnings module + logging.captureWarnings(capture_warnings) + + # create a basic formatter + formatter = logging.Formatter( + "[%(asctime)s] %(levelname)-7s (%(filename)s:%(lineno)3s) %(message)s", + "%Y-%m-%d %H:%M:%S", + ) + if colors: + try: + from colorlog import ColoredFormatter + + formatter = ColoredFormatter( + ( + "%(log_color)s%(levelname)-8s%(reset)s " + + "%(filename)17s:%(lineno)-4s %(blue)4s%(message)s" + ), + datefmt=None, + reset=True, + log_colors={ + "DEBUG": "cyan", + "INFO": "green", + "WARNING": "yellow", + "ERROR": "red", + "CRITICAL": "red", + }, + ) + except ImportError: + pass + + # if no handler was passed use a StreamHandler + if handler is None: + handler = logging.StreamHandler() + + # add the formatters and set the level + handler.setFormatter(formatter) + # numpy integers aren't `int` subclasses — coerce for the stdlib stubs + handler.setLevel(int(level)) + + # if nothing passed use all available loggers + if loggers is None: + # de-duplicate loggers using a set + loggers = set(logging.Logger.manager.loggerDict.values()) + + # add the warnings logging + loggers.add(logging.getLogger("py.warnings")) + + # disable pyembree warnings + logging.getLogger("pyembree").disabled = True + + # cull loggers that are not actually loggers or are on the blacklist + loggers_dict = { + L.name: L + for L in loggers + if hasattr(L, "name") + and isinstance(L, logging.Logger) + and L.name not in blacklist + } + + if only_parent: + # create a new dict to store only parent loggers + parent_loggers = {} + # sort logger names to process in hierarchical order + for name in sorted(loggers_dict.keys()): + # if it's not a child of any existing parent, add it as a parent + if not any(name.startswith(f"{p}.") for p in parent_loggers.keys()): + parent_loggers[name] = loggers_dict[name] + # replace loggers dict with only parent loggers + loggers_dict = parent_loggers + + # loop through all available loggers + for logger in loggers_dict.values(): + logger.addHandler(handler) + logger.setLevel(int(level)) + + # set nicer numpy print options + np.set_printoptions(precision=5, suppress=True) + + +def stack_lines(indices: ArrayLike) -> NDArray: + """ + Stack a list of values that represent a polyline into + individual line segments with duplicated consecutive values. + + Parameters + ------------ + indices : (m,) any + List of items to be stacked + + Returns + --------- + stacked : (n, 2) any + Stacked items + + Examples + ---------- + In [1]: trimesh.util.stack_lines([0, 1, 2]) + Out[1]: + array([[0, 1], + [1, 2]]) + + In [2]: trimesh.util.stack_lines([0, 1, 2, 4, 5]) + Out[2]: + array([[0, 1], + [1, 2], + [2, 4], + [4, 5]]) + + In [3]: trimesh.util.stack_lines([[0, 0], [1, 1], [2, 2], [3, 3]]) + Out[3]: + array([[0, 0], + [1, 1], + [1, 1], + [2, 2], + [2, 2], + [3, 3]]) + + """ + indices = np.asanyarray(indices) + if len(indices) == 0: + return np.array([]) + elif is_sequence(indices[0]): + shape = (-1, len(indices[0])) + else: + shape = (-1, 2) + return np.column_stack((indices[:-1], indices[1:])).reshape(shape) + + +def append_faces( + vertices_seq: Iterable[ArrayLike], + faces_seq: Iterable[ArrayLike], +) -> tuple[NDArray2D[np.floating], NDArray2D[np.integer]]: + """ + Given a sequence of zero-indexed faces and vertices + combine them into a single array of faces and + a single array of vertices. + + Parameters + ----------- + vertices_seq : (n, ) sequence of (m, d) float + Multiple arrays of verticesvertex arrays + faces_seq : (n, ) sequence of (p, j) int + Zero indexed faces for matching vertices + + Returns + ---------- + vertices : (i, d) float + Points in space + faces : (j, 3) int + Reference vertex indices + """ + # the length of each vertex array + vertices_len = np.array([len(i) for i in vertices_seq], dtype=np.int64) + # how much each group of faces needs to be offset + face_offset = np.append(0, np.cumsum(vertices_len)[:-1]) + + new_faces = [] + for offset, faces in zip(face_offset, faces_seq): + if len(faces) == 0: + continue + # apply the index offset + new_faces.append(faces + offset) + # stack to clean (n, 3) float + vertices = vstack_empty(vertices_seq) + # stack to clean (n, 3) int + faces = vstack_empty(new_faces) + + # an all-empty stack collapses to a 1d float array — restore the + # documented 2d shape and integer face dtype + if len(vertices) == 0: + vertices = vertices.reshape((0, 3)) + if len(faces) == 0: + faces = faces.reshape((0, 3)).astype(np.int64) + + return vertices, faces + + +def array_to_string( + array: ArrayLike, + col_delim: str = " ", + row_delim: str = "\n", + digits: Integer = 8, + value_format: str = "{}", +) -> str: + """ + Convert a 1 or 2D array into a string with a specified number + of digits and delimiter. The reason this exists is that the + basic numpy array to string conversions are surprisingly slow. + + Parameters + ------------ + array : (n,) or (n, d) float or int + Data to be converted + If shape is (n,) only column delimiter will be used + col_delim : str + What string should separate values in a column + row_delim : str + What string should separate values in a row + digits : int + How many digits should floating point numbers include + value_format : str + Format string for each value or sequence of values + If multiple values per value_format it must divide + into array evenly. + + Returns + ---------- + formatted : str + String representation of original array + """ + # convert inputs to correct types + array = np.asanyarray(array) + digits = int(digits) + row_delim = str(row_delim) + col_delim = str(col_delim) + value_format = str(value_format) + + # abort for non-flat arrays + if len(array.shape) > 2: + raise ValueError( + "conversion only works on 1D/2D arrays not %s!", str(array.shape) + ) + + # abort for structured arrays + if array.dtype.names is not None: + raise ValueError("array is structured, use structured_array_to_string instead") + + # allow a value to be repeated in a value format + repeats = value_format.count("{") + + if array.dtype.kind in ["i", "u"]: + # integer types don't need a specified precision + format_str = value_format + col_delim + elif array.dtype.kind == "f": + # add the digits formatting to floats + format_str = value_format.replace("{}", "{:." + str(digits) + "f}") + col_delim + else: + raise ValueError("dtype %s not convertible!", array.dtype.name) + + # length of extra delimiters at the end + end_junk = len(col_delim) + # if we have a 2D array add a row delimiter + if len(array.shape) == 2: + format_str *= array.shape[1] + # cut off the last column delimiter and add a row delimiter + format_str = format_str[: -len(col_delim)] + row_delim + end_junk = len(row_delim) + + # expand format string to whole array + format_str *= len(array) + + # if an array is repeated in the value format + # do the shaping here so we don't need to specify indexes + shaped = np.tile(array.reshape((-1, 1)), (1, repeats)).reshape(-1) + + # run the format operation and remove the extra delimiters + formatted = format_str.format(*shaped)[:-end_junk] + + return formatted + + +def structured_array_to_string( + array: ArrayLike, + col_delim: str = " ", + row_delim: str = "\n", + digits: Integer = 8, + value_format: str = "{}", +) -> str: + """ + Convert an unstructured array into a string with a specified + number of digits and delimiter. The reason thisexists is + that the basic numpy array to string conversions are + surprisingly slow. + + Parameters + ------------ + array : (n,) or (n, d) float or int + Data to be converted + If shape is (n,) only column delimiter will be used + col_delim : str + What string should separate values in a column + row_delim : str + What string should separate values in a row + digits : int + How many digits should floating point numbers include + value_format : str + Format string for each value or sequence of values + If multiple values per value_format it must divide + into array evenly. + + Returns + ---------- + formatted : str + String representation of original array + """ + # convert inputs to correct types + array = np.asanyarray(array) + digits = int(digits) + row_delim = str(row_delim) + col_delim = str(col_delim) + value_format = str(value_format) + + # abort for non-flat arrays + if len(array.shape) > 1: + raise ValueError( + "conversion only works on 1D/2D arrays not %s!", str(array.shape) + ) + + # abort for unstructured arrays + if array.dtype.names is None: + raise ValueError("array is not structured, use array_to_string instead") + + # do not allow a value to be repeated in a value format + if value_format.count("{") > 1: + raise ValueError( + "value_format %s is invalid, repeating unstructured array " + + "values is unsupported", + value_format, + ) + + format_str = "" + for name in array.dtype.names: + kind = array[name].dtype.kind + element_row_length = array[name].shape[1] if len(array[name].shape) == 2 else 1 + if kind in ["i", "u"]: + # integer types need a no-decimal formatting + element_format_str = value_format.replace("{}", "{:0.0f}") + col_delim + elif kind == "f": + # add the digits formatting to floats + element_format_str = ( + value_format.replace("{}", "{:." + str(digits) + "f}") + col_delim + ) + else: + raise ValueError("dtype %s not convertible!", array.dtype) + format_str += element_row_length * element_format_str + + # length of extra delimiters at the end + format_str = format_str[: -len(col_delim)] + row_delim + # expand format string to whole array + format_str *= len(array) + + # loop through flat fields and flatten to single array + count = len(array) + # will upgrade everything to a float + flattened = np.hstack( + [array[k].reshape((count, -1)) for k in array.dtype.names] + ).reshape(-1) + + # run the format operation and remove the extra delimiters + formatted = format_str.format(*flattened)[: -len(row_delim)] + + return formatted + + +def array_to_encoded( + array: ArrayLike, + dtype: np.typing.DTypeLike | None = None, + encoding: str = "base64", +) -> Mapping[str, Any]: + """ + Export a numpy array to a compact serializable dictionary. + + Parameters + ------------ + array : array + Any numpy array + dtype : str or None + Optional dtype to encode array + encoding : str + 'base64' or 'binary' + + Returns + --------- + encoded : dict + Has keys: + 'dtype': str, of dtype + 'shape': tuple of shape + 'base64': str, base64 encoded string + """ + array = np.asanyarray(array) + shape = array.shape + # ravel also forces contiguous + flat = np.ravel(array) + if dtype is None: + dtype = array.dtype + + encoded: dict[str, Any] = {"dtype": np.dtype(dtype).str, "shape": shape} + if encoding in ["base64", "dict64"]: + packed = base64.b64encode(flat.astype(dtype).tobytes()) + if hasattr(packed, "decode"): + packed = packed.decode("utf-8") + encoded["base64"] = packed + elif encoding == "binary": + encoded["binary"] = array.tobytes(order="C") + else: + raise ValueError(f"encoding {encoding} is not available!") + return encoded + + +# the store key type must be `Any` because the key type changes from `bytes` to `str` +def decode_keys(store: dict[Any, Any], encoding: str = "utf-8") -> dict[str, Any]: + """ + If a dictionary has keys that are bytes decode them to a str. + + Parameters + ------------ + store : dict + Dictionary with data + + Returns + --------- + result : dict + Values are untouched but keys that were bytes + are converted to ASCII strings. + + Example + ----------- + In [1]: d + Out[1]: {1020: 'nah', b'hi': 'stuff'} + + In [2]: trimesh.util.decode_keys(d) + Out[2]: {1020: 'nah', 'hi': 'stuff'} + """ + keys = store.keys() + for key in keys: + if hasattr(key, "decode"): + decoded = key.decode(encoding) + if key != decoded: + store[key.decode(encoding)] = store[key] + store.pop(key) + return store + + +def comment_strip(text: str, starts_with: str = "#", new_line: str = "\n") -> str: + """ + Strip comments from a text block. + + Parameters + ----------- + text : str + Text to remove comments from + starts_with : str + Character or substring that starts a comment + new_line : str + Character or substring that ends a comment + + Returns + ----------- + stripped : str + Text with comments stripped + """ + # if not contained exit immediately + if starts_with not in text: + return text + + # start by splitting into chunks by the comment indicator + split = (text + new_line).split(starts_with) + + # special case files that start with a comment + if text.startswith(starts_with): + lead = "" + else: + lead = split[0] + + # take each comment up until the newline + removed = [i.split(new_line, 1) for i in split] + # add the leading string back on + result = ( + lead + + new_line + + new_line.join(i[1] for i in removed if len(i) > 1 and len(i[1]) > 0) + ) + # strip leading and trailing whitespace + result = result.strip() + + return result + + +def encoded_to_array(encoded: ArrayLike | dict[Any, Any]) -> NDArray: + """ + Turn a dictionary with base64 encoded strings back into a numpy array. + + Parameters + ------------ + encoded + Has keys: + dtype: string of dtype + shape: int tuple of shape + base64: base64 encoded string of flat array + binary: decode result coming from numpy.tobytes + + Returns + ---------- + array + """ + + if not isinstance(encoded, dict): + if is_sequence(encoded): + as_array = np.asanyarray(encoded) + return as_array + else: + raise ValueError("Unable to extract numpy array from input") + + encoded_dict = decode_keys(encoded) + + dtype = np.dtype(encoded_dict["dtype"]) + if "base64" in encoded_dict: + array = np.frombuffer(base64.b64decode(encoded_dict["base64"]), dtype) + elif "binary" in encoded_dict: + array = np.frombuffer(encoded_dict["binary"], dtype=dtype) + else: + raise ValueError("Invalid encoded array, no 'base64' or 'binary' key found") + if "shape" in encoded_dict: + array = array.reshape(encoded_dict["shape"]) + return array + + +def is_instance_named(obj: object, name: str | list[str]) -> bool: + """ + Given an object, if it is a member of the class 'name', + or a subclass of 'name', return True. + + Parameters + ------------ + obj : instance + Some object of some class + name: str + The name of the class we want to check for + + Returns + --------- + is_instance : bool + Whether the object is a member of the named class + """ + try: + if isinstance(name, list): + return any(is_instance_named(obj, i) for i in name) + else: + type_named(obj, name) + return True + except ValueError: + return False + + +def type_bases(obj: object, depth: Integer = 4) -> list[type]: + """ + Return the bases of the object passed. + """ + bases: collections.deque[list] = collections.deque([list(obj.__class__.__bases__)]) + for i in range(depth): + bases.append([i.__base__ for i in bases[-1] if i is not None]) + try: + bases_flat = np.hstack(bases) + except IndexError: + return [] + return [i for i in bases_flat if hasattr(i, "__name__")] + + +def type_named(obj: object, name: str) -> type: + """ + Similar to the type() builtin, but looks in class bases + for named instance. + + Parameters + ------------ + obj : any + Object to look for class of + name : str + Name of class + + Returns + ---------- + class : type + Named class, raises ValueError if not found + """ + # if obj is a member of the named class, return True + name = str(name) + if obj.__class__.__name__ == name: + return obj.__class__ + for base in type_bases(obj): + if base.__name__ == name: + return base + raise ValueError("Unable to extract class of name " + name) + + +def concatenate(a, b=None) -> "trimesh.parent.Geometry": + """ + Concatenate two or more meshes. + + Parameters + ------------ + a : trimesh.Trimesh + Mesh or list of meshes to be concatenated + object, or list of such + b : trimesh.Trimesh + Mesh or list of meshes to be concatenated + + Returns + ---------- + result + Concatenated mesh + """ + dump = [] + for i in chain(a, b): + if is_instance_named(i, "Scene"): + # get every mesh in the final frame. + dump.extend(i.dump()) + else: + # just append to our flat list + dump.append(i) + + if len(dump) == 1: + # if there is only one geometry just return the first + return dump[0].copy() + elif len(dump) == 0: + # if there are no meshes return an empty mesh + from .base import Trimesh + + return Trimesh() + + is_mesh = [f for f in dump if is_instance_named(f, "Trimesh")] + is_path = [f for f in dump if is_instance_named(f, "Path")] + + # if we have more + if len(is_path) > len(is_mesh): + from .path.util import concatenate as concatenate_path + + return concatenate_path(is_path) + + if len(is_mesh) == 0: + # nothing concatenable was passed — match the empty-input + # branch above and hand back an empty mesh + from .base import Trimesh + + return Trimesh() + + # extract the trimesh type to avoid a circular import + # and assert that all inputs are Trimesh objects + trimesh_type = type_named(is_mesh[0], "Trimesh") + + # append faces and vertices of meshes + vertices, faces = append_faces( + [m.vertices.copy() for m in is_mesh], [m.faces.copy() for m in is_mesh] + ) + + # save face normals if already calculated + face_normals = None + if any("face_normals" in m._cache for m in is_mesh): + face_normals = vstack_empty([m.face_normals for m in is_mesh]) + assert face_normals.shape == faces.shape + + # save vertex normals if any mesh has them + vertex_normals = None + if any("vertex_normals" in m._cache for m in is_mesh): + vertex_normals = vstack_empty([m.vertex_normals for m in is_mesh]) + assert vertex_normals.shape == vertices.shape + + try: + # concatenate visuals + visual = is_mesh[0].visual.concatenate([m.visual for m in is_mesh[1:]]) + except BaseException as E: + log.debug(f"failed to combine visuals {_STRICT}", exc_info=True) + visual = None + if _STRICT: + raise E + + metadata = {} + try: + _ = [metadata.update(deepcopy(m.metadata) for m in is_mesh)] + except BaseException: + pass + + # concatenate vertex attributes that are valid for every mesh + vertex_attributes = {} + for key in is_mesh[0].vertex_attributes.keys(): + # make sure every mesh has a valid attribute + if all(len(m.vertex_attributes.get(key, [])) == len(m.vertices) for m in is_mesh): + try: + vertex_attributes[key] = np.concatenate( + [mesh.vertex_attributes.get(key, []) for mesh in is_mesh], axis=0 + ) + except BaseException: + log.warning( + f"Failed to concatenate `vertex_attribute['{key}']`", exc_info=True + ) + + # concatenate face attributes that are valid for every mesh + face_attributes = {} + for key in is_mesh[0].face_attributes.keys(): + # an attribute can only be concatenated if it's valid for every mesh + if all(len(m.face_attributes.get(key, [])) == len(m.faces) for m in is_mesh): + try: + # stack along axis 0 + face_attributes[key] = np.concatenate( + [mesh.face_attributes.get(key, []) for mesh in is_mesh], axis=0 + ) + except BaseException: + # could have failed because attribute had different shapes + log.warning( + f"Failed to concatenate `face_attribute['{key}']`", exc_info=True + ) + + # create the mesh object + result = trimesh_type( + vertices=vertices, + faces=faces, + face_normals=face_normals, + vertex_normals=vertex_normals, + visual=visual, + vertex_attributes=vertex_attributes, + face_attributes=face_attributes, + metadata=metadata, + process=False, + ) + + try: + result._source = deepcopy(is_mesh[0].source) + except BaseException: + pass + + return result + + +def submesh( + mesh, + faces_sequence: Iterable[ArrayLike], + repair: bool = True, + only_watertight: bool = False, + min_faces: Integer | None = None, + append: bool = False, +): + """ + Return a subset of a mesh. + + Parameters + ------------ + mesh : Trimesh + Source mesh to take geometry from + faces_sequence : sequence (p,) int + Indexes of mesh.faces + repair + Try to make submeshes watertight + only_watertight + Only return submeshes which are watertight + min_faces + Minimum number of faces allowed in a submesh. + append : bool + Return a single mesh which has the faces appended, + if this flag is set, only_watertight is ignored + + Returns + --------- + result : Trimesh | list[Trimesh] + Depending on if `append` is true or not. + """ + # evaluate generators so we can escape early + faces_sequence = list(faces_sequence) + + if len(faces_sequence) == 0: + return [] + + # avoid nuking the cache on the original mesh + original_faces = mesh.faces.view(np.ndarray) + original_vertices = mesh.vertices.view(np.ndarray) + + faces = [] + vertices = [] + normals = [] + visuals = [] + + # for reindexing faces + mask = np.arange(len(original_vertices)) + + for index in faces_sequence: + # sanitize indices in case they are coming in as a set or tuple + index = np.asanyarray(index) + if len(index) == 0: + # regardless of type empty arrays are useless + continue + if index.dtype.kind == "b": + # if passed a bool with no true continue + if not index.any(): + continue + # if fewer faces than minimum + if min_faces is not None and index.sum() < min_faces: + continue + elif min_faces is not None and len(index) < min_faces: + continue + + current = original_faces[index] + unique = np.unique(current.reshape(-1)) + + # redefine face indices from zero + mask[unique] = np.arange(len(unique)) + normals.append(mesh.face_normals[index]) + faces.append(mask[current]) + vertices.append(original_vertices[unique]) + + visuals.append(mesh.visual.face_subset(index)) + + if len(vertices) == 0: + return [] + + # we use type(mesh) rather than importing Trimesh from base + # to avoid a circular import + trimesh_type = type_named(mesh, "Trimesh") + + if append: + visual = None + try: + visuals = np.array(visuals) + visual = visuals[0].concatenate(visuals[1:]) + except Exception: + log.debug("failed to combine visuals", exc_info=True) + # re-index faces and stack + vertices, faces = append_faces(vertices, faces) + appended = trimesh_type( + vertices=vertices, + faces=faces, + face_normals=np.vstack(normals), + visual=visual, + metadata=deepcopy(mesh.metadata), + process=False, + ) + appended._source = deepcopy(mesh.source) + + return appended + + if visuals is None: + visuals = [None] * len(vertices) + + # generate a list of Trimesh objects + result = [ + trimesh_type( + vertices=v, + faces=f, + face_normals=n, + visual=c, + metadata=deepcopy(mesh.metadata), + process=False, + ) + for v, f, n, c in zip(vertices, faces, normals, visuals) + ] + + # assign the "source" information summarizing where a mesh was + # loaded from (i.e. file name) to each submesh of the result + [setattr(r, "_source", deepcopy(mesh.source)) for r in result] + + if repair: + # fill_holes will attempt a repair and returns the + # watertight status at the end of the repair attempt + watertight = [len(i.faces) >= 4 and i.fill_holes() for i in result] + elif only_watertight: + # calculate watertightness without repairing + watertight = [i.is_watertight for i in result] + + if only_watertight: + # return only the watertight meshes + return [i for i, w in zip(result, watertight) if w] + + return result + + +def zero_pad(data: NDArray, count: Integer, right: bool = True) -> NDArray: + """ + Parameters + ------------ + data : (n,) + 1D array + count : int + Minimum length of result array + + Returns + --------- + padded : (m,) + 1D array where m >= count + """ + if len(data) == 0: + return np.zeros(count) + elif len(data) < count: + padded = np.zeros(count) + if right: + padded[-len(data) :] = data + else: + padded[: len(data)] = data + return padded + else: + return np.asanyarray(data) + + +def jsonify(obj: object, **kwargs: Any) -> str: + """ + A version of json.dumps that can handle numpy arrays + by creating a custom encoder for numpy dtypes. + + Parameters + -------------- + obj : list, dict + A JSON-serializable blob + kwargs : dict + Passed to json.dumps + + Returns + -------------- + dumped : str + JSON dump of obj + """ + + class EdgeEncoder(json.JSONEncoder): + def default(self, obj: Any): + # will work for numpy.ndarrays + # as well as their int64/etc objects + if hasattr(obj, "tolist"): + # this works on numpy arrays + return obj.tolist() + elif hasattr(obj, "timestamp"): + # serialize datetime as the float stamp + return obj.timestamp() + elif hasattr(obj, "__dataclass_fields__"): + # serialize dataclasses as dict + return dataclass_to_dict(obj) + return json.JSONEncoder.default(self, obj) + + # run the dumps using our encoder + return json.dumps(obj, cls=EdgeEncoder, **kwargs) + + +def convert_like(item, like): + """ + Convert an item to have the dtype of another item + + Parameters + ------------ + item : any + Item to be converted + like : any + Object with target dtype + If None, item is returned unmodified + + Returns + ---------- + result: item, but in dtype of like + """ + # if it's a numpy array + if isinstance(like, np.ndarray): + return np.asanyarray(item, dtype=like.dtype) + + # if it's already the desired type just return it + if isinstance(item, like.__class__) or like is None: + return item + + # if it's an array with one item return it + if is_sequence(item) and len(item) == 1 and isinstance(item[0], like.__class__): + return item[0] + + if ( + isinstance(item, str) + and like.__class__.__name__ == "Polygon" + and item.startswith("POLYGON") + ): + # break our rule on imports but only a little bit + # the import was a WKT serialized polygon + from shapely import wkt + + return wkt.loads(item) + + # otherwise just run the conversion + item = like.__class__(item) + + return item + + +def bounds_tree(bounds: ArrayLike) -> Any: + """ + Given a set of axis aligned bounds create an r-tree for + broad-phase collision detection. + + Parameters + ------------ + bounds : (n, 2D) or (n, 2, D) float + Non-interleaved bounds where D=dimension + E.G a 2D bounds tree: + [(minx, miny, maxx, maxy), ...] + + Returns + --------- + tree : Rtree + Tree containing bounds by index + """ + import rtree + + # make sure we've copied bounds + bounds = np.array(bounds, dtype=np.float64, copy=True) + if len(bounds.shape) == 3: + # should be min-max per bound + if bounds.shape[1] != 2: + raise ValueError("bounds not (n, 2, dimension)!") + # reshape to one-row-per-hyperrectangle + bounds = bounds.reshape((len(bounds), -1)) + elif len(bounds.shape) != 2 or bounds.size == 0: + raise ValueError("Bounds must be (n, dimension * 2)!") + + # check to make sure we have correct shape + dimension = bounds.shape[1] + if (dimension % 2) != 0: + raise ValueError("Bounds must be (n,dimension*2)!") + dimension = int(dimension / 2) + + properties = rtree.index.Property(dimension=dimension) + # stream load was verified working on import above + return rtree.index.Index( + zip(np.arange(len(bounds)), bounds, [None] * len(bounds)), properties=properties + ) + + +def wrap_as_stream(item: str | bytes) -> StringIO | BytesIO: + """ + Wrap a string or bytes object as a file object. + + Parameters + ------------ + item: str or bytes + Item to be wrapped + + Returns + --------- + wrapped : file-like object + Contains data from item + """ + if isinstance(item, str): + return StringIO(item) + elif isinstance(item, bytes): + return BytesIO(item) + raise ValueError(f"{type(item).__name__} is not wrappable!") + + +def sigfig_round(values: ArrayLike, sigfig: ArrayLike = 1) -> NDArray1D[np.float64]: + """ + Round a single value to a specified number of significant figures. + + Parameters + ------------ + values : float + Value to be rounded + sigfig : int + Number of significant figures to reduce to + + Returns + ---------- + rounded : float + Value rounded to the specified number of significant figures + + + Examples + ---------- + In [1]: trimesh.util.round_sigfig(-232453.00014045456, 1) + Out[1]: -200000.0 + + In [2]: trimesh.util.round_sigfig(.00014045456, 1) + Out[2]: 0.0001 + + In [3]: trimesh.util.round_sigfig(.00014045456, 4) + Out[3]: 0.0001405 + """ + as_int, multiplier = sigfig_int(values, sigfig) + rounded = as_int * (10**multiplier) + + return rounded + + +def sigfig_int( + values: ArrayLike, sigfig: ArrayLike +) -> tuple[NDArray1D[np.int64], NDArray1D[np.float64]]: + """ + Convert a set of floating point values into integers + with a specified number of significant figures and an + exponent. + + Parameters + ------------ + values : (n,) float or int + Array of values + sigfig : (n,) int + Number of significant figures to keep + + Returns + ------------ + as_int : (n,) int + Every value[i] has sigfig[i] digits + multiplier : (n,) float + Exponent, so as_int * 10 ** multiplier is + the same order of magnitude as the input + """ + values = np.asanyarray(values).reshape(-1) + sigfig = np.asanyarray(sigfig, dtype=np.int64).reshape(-1) + + if sigfig.shape != values.shape: + raise ValueError("sigfig must match identifier") + + exponent = np.zeros(len(values)) + nonzero = np.abs(values) > TOL_ZERO + exponent[nonzero] = np.floor(np.log10(np.abs(values[nonzero]))) + + multiplier = exponent - sigfig + 1 + as_int = (values / (10**multiplier)).round().astype(np.int64) + + return as_int, multiplier + + +# skip ZIP members once declared uncompressed sizes exceed this +_ARCHIVE_SKIP_SIZE = 32 * 1024**3 # 32 GiB + + +def decompress( + file_obj: bytes | Stream, + file_type: str, +) -> dict[str, Stream | None]: + """ + Given an open file object and a file type, return all components + of the archive as open file objects in a dict. + + ZIP members are skipped once the total uncompressed size declared by + the archive exceeds `_ARCHIVE_SKIP_SIZE`. Other formats don't store a + per-member compressed size so there is nothing to check before reading. + + Parameters + ------------ + file_obj : file-like + Containing compressed data. + file_type : str + File extension, 'zip', 'tar.gz', etc. + + Returns + --------- + decompressed : dict + Data from archive in format {file name : file-like}. + """ + file_type = str(file_type).lower() + if isinstance(file_obj, bytes): + file_obj = BytesIO(file_obj) + + if file_type.endswith("zip"): + archive = zipfile.ZipFile(file_obj) + result = {} + # running total of the sizes the central directory declared: this is + # an upper bound on what we can actually read as `ZipExtFile` stops + # at the declared size and then fails the CRC check + total = 0 + for info in archive.infolist(): + if total + info.file_size > _ARCHIVE_SKIP_SIZE: + log.warning( + "skipping `%s`: declared %d bytes exceeds archive budget", + info.filename, + info.file_size, + ) + continue + total += info.file_size + with archive.open(info, mode="r") as src: + data = src.read() + result[info.filename] = wrap_as_stream(data) + return result + if file_type.endswith("bz2"): + import bz2 + + # get the file name if we have one otherwise default to "archive" + name = getattr(file_obj, "name", "archive1234")[:-4] + return {name: wrap_as_stream(bz2.open(file_obj, mode="r").read())} + if "tar" in file_type[-6:]: + import tarfile + + archive = tarfile.open(fileobj=file_obj, mode="r") + result = {} + for info in archive.getmembers(): + if not info.isfile(): + continue + src = archive.extractfile(info) + if src is None: + continue + result[info.name] = wrap_as_stream(src.read()) + return result + raise ValueError("Unsupported type passed!") + + +def compress( + info: Mapping[str, str | bytes | Stream], + **kwargs: Any, +) -> bytes: + """ + Compress data stored in a dict. + + Parameters + ----------- + info : dict + Data to compress in form: + {file name in archive: bytes or file-like object} + kwargs : dict + Passed to zipfile.ZipFile + Returns + ----------- + compressed : bytes + Compressed file data + """ + file_obj = BytesIO() + with zipfile.ZipFile( + file_obj, mode="w", compression=zipfile.ZIP_DEFLATED, **kwargs + ) as zipper: + for name, data_or_file in info.items(): + if isinstance(data_or_file, (str, bytes)): + data = data_or_file + else: + # a file-like object — read its contents + data = data_or_file.read() + zipper.writestr(name, data) + file_obj.seek(0) + compressed = file_obj.read() + return compressed + + +def split_extension(file_name: str, special: Iterable[str] | None = None) -> str: + """ + Find the file extension of a file name, including support for + special case multipart file extensions (like .tar.gz) + + Parameters + ------------ + file_name : str + File name + special : list of str + Multipart extensions + eg: ['tar.bz2', 'tar.gz'] + + Returns + ---------- + extension : str + Last characters after a period, or + a value from 'special' + """ + file_name = str(file_name) + + if special is None: + special = ["tar.bz2", "tar.gz"] + if file_name.endswith(tuple(special)): + for end in special: + if file_name.endswith(end): + return end + return file_name.split(".")[-1] + + +def triangle_strips_to_faces( + strips: ArrayLike | Sequence[ArrayLike], +) -> NDArray2D[np.int64]: + """ + Convert a sequence of triangle strips to (n, 3) faces. + + Processes all strips at once using np.concatenate and is significantly + faster than loop-based methods. + + From the OpenGL programming guide describing a single triangle + strip [v0, v1, v2, v3, v4]: + + Draws a series of triangles (three-sided polygons) using vertices + v0, v1, v2, then v2, v1, v3 (note the order), then v2, v3, v4, + and so on. The ordering is to ensure that the triangles are all + drawn with the same orientation so that the strip can correctly form + part of a surface. + + Parameters + ------------ + strips: (n,) list of (m,) int + Vertex indices + + Returns + ------------ + faces : (m, 3) int + Vertex indices representing triangles + """ + + # save the length of each list in the list of lists + lengths = np.array([len(i) for i in strips], dtype=np.int64) + # looping through a list of lists is extremely slow + # combine all the sequences into a blob we can manipulate + blob = np.concatenate(strips, dtype=np.int64) + + # slice the blob into rough triangles + tri = np.array([blob[:-2], blob[1:-1], blob[2:]], dtype=np.int64).T + + # if we only have one strip we can do a *lot* less work + # as we keep every triangle and flip every other one + if len(strips) == 1: + # flip in-place every other triangle + tri[1::2] = np.fliplr(tri[1::2]) + return tri + + # remove the triangles which were implicit but not actually there + # because we combined everything into one big array for speed + length_index = np.cumsum(lengths)[:-1] + keep = np.ones(len(tri), dtype=bool) + keep[length_index - 2] = False + keep[length_index - 1] = False + tri = tri[keep] + + # flip every other triangle so they generate correct normals/winding + length_index = np.append(0, np.cumsum(lengths - 2)) + flip = np.zeros(length_index[-1], dtype=bool) + for i in range(len(length_index) - 1): + flip[length_index[i] + 1 : length_index[i + 1]][::2] = True + tri[flip] = np.fliplr(tri[flip]) + + return tri + + +def triangle_fans_to_faces( + fans: Iterable[ArrayLike], +) -> NDArray2D[np.int64]: + """ + Convert fans of m + 2 vertex indices in fan format to m triangles + + Parameters + ---------- + fans: (n,) list of (m + 2,) int + Vertex indices + + Returns + ------- + faces: (m, 3) int + Vertex indices representing triangles + """ + + faces = [ + np.transpose([fan[0] * np.ones(len(fan) - 2, dtype=int), fan[1:-1], fan[2:]]) + for fan in fans + ] + return np.concatenate(faces, dtype=int) + + +def vstack_empty(tup: Iterable[ArrayLike]) -> NDArray: + """ + A thin wrapper for numpy.vstack that ignores empty lists. + + Parameters + ------------ + tup : tuple or list of arrays + With the same number of columns + + Returns + ------------ + stacked : (n, d) array + With same number of columns as + constituent arrays. + """ + # filter out empty arrays + stackable = [i for i in tup if len(i) > 0] + # if we only have one array just return it + if len(stackable) == 1: + return np.asanyarray(stackable[0]) + # if we have nothing return an empty numpy array + elif len(stackable) == 0: + return np.array([]) + # otherwise just use vstack as normal + return np.vstack(stackable) + + +def write_encoded( + file_obj: Stream, + stuff: str | bytes, + encoding: str = "utf-8", +) -> str | bytes: + """ + If a file is open in binary mode and a + string is passed, encode and write. + + If a file is open in text mode and bytes are + passed decode bytes to str and write. + + Assumes binary mode if file_obj does not have + a 'mode' attribute (e.g. io.BufferedRandom). + + Parameters + ----------- + file_obj : file object + With 'write' and 'mode' + stuff : str or bytes + Stuff to be written + encoding : str + Encoding of text + """ + binary_file = "b" in getattr(file_obj, "mode", "b") + string_stuff = isinstance(stuff, str) + binary_stuff = isinstance(stuff, bytes) + + if binary_file and string_stuff: + file_obj.write(stuff.encode(encoding)) + elif not binary_file and binary_stuff: + file_obj.write(stuff.decode(encoding)) + else: + file_obj.write(stuff) + file_obj.flush() + return stuff + + +def unique_id(length: Integer = 12) -> str: + """ + Generate a random alphaNumber unique identifier + using UUID logic. + + Parameters + ------------ + length : int + Length of desired identifier + + Returns + ------------ + unique : str + Unique alphaNumber identifier + """ + return uuid.UUID(int=random.getrandbits(128), version=4).hex[:length] + + +def generate_basis(z: ArrayLike, epsilon: float = 1e-12) -> NDArray2D[np.float64]: + """ + Generate an arbitrary basis (also known as a coordinate frame) + from a given z-axis vector. + + Parameters + ------------ + z : (3,) float + A vector along the positive z-axis. + epsilon : float + Numbers smaller than this considered zero. + + Returns + --------- + x : (3,) float + Vector along x axis. + y : (3,) float + Vector along y axis. + z : (3,) float + Vector along z axis. + """ + # get a copy of input vector + z = np.array(z, dtype=np.float64, copy=True) + # must be a 3D vector + if z.shape != (3,): + raise ValueError("z must be (3,) float!") + + z_norm = np.linalg.norm(z) + if z_norm < epsilon: + return np.eye(3) + + # normalize vector in-place + z /= z_norm + # X as arbitrary perpendicular vector + x = np.array([-z[1], z[0], 0.0]) + # avoid degenerate case + x_norm = np.linalg.norm(x) + if x_norm < epsilon: + # this means that + # so a perpendicular X is just X + x = np.array([-z[2], z[1], 0.0]) + x /= np.linalg.norm(x) + else: + # otherwise normalize X in-place + x /= x_norm + # get perpendicular Y with cross product + y = np.cross(z, x) + # append result values into (3, 3) vector + result = np.array([x, y, z], dtype=np.float64) + + if _STRICT: + # run checks to make sure axis are perpendicular + assert np.abs(np.dot(x, z)) < 1e-8 + assert np.abs(np.dot(y, z)) < 1e-8 + assert np.abs(np.dot(x, y)) < 1e-8 + # all vectors should be unit vector + assert np.allclose(np.linalg.norm(result, axis=1), 1.0) + + return result + + +def isclose( + a: Number | NDArray, + b: Number | NDArray, + atol: Floating = 1e-8, +) -> np.bool_ | NDArray[np.bool_]: + """ + A replacement for np.isclose that does fewer checks + and validation and as a result is roughly 4x faster. + + Note that this is used in tight loops, and as such + a and b MUST be np.ndarray, not list or "array-like" + + Parameters + ------------ + a : np.ndarray + To be compared + b : np.ndarray + To be compared + atol : float + Acceptable distance between `a` and `b` to be "close" + + Returns + ----------- + close : np.ndarray, bool + Per-element closeness + """ + diff = a - b + return np.logical_and(diff > -atol, diff < atol) + + +def allclose(a: Number | NDArray, b: Number | NDArray, atol: Floating = 1e-8) -> bool: + """ + A replacement for np.allclose that does few checks + and validation and as a result is faster. + + Parameters + ------------ + a : np.ndarray + To be compared + b : np.ndarray + To be compared + atol : float + Acceptable distance between `a` and `b` to be "close" + + Returns + ----------- + bool indicating if all elements are within `atol`. + """ + # + return bool(float(np.ptp(a - b)) < atol) + + +class FunctionRegistry(Mapping[str, Callable[..., Any]]): + """ + Non-overwritable mapping of string keys to functions. + + This allows external packages to register additional implementations + of common functionality without risk of breaking implementations provided + by trimesh. + + See trimesh.voxel.morphology for example usage. + """ + + def __init__(self, **kwargs: Callable[..., Any]) -> None: + self._dict = {} + for k, v in kwargs.items(): + self[k] = v + + def __getitem__(self, key: str) -> Callable[..., Any]: + return self._dict[key] + + def __setitem__(self, key: str, value: Callable[..., object]) -> None: + if not isinstance(key, str): + raise ValueError(f"key must be a string, got {key!s}") + if key in self: + raise KeyError(f"Cannot set new value to existing key {key}") + if not callable(value): + raise ValueError("Cannot set value which is not callable.") + self._dict[key] = value + + def __iter__(self) -> Iterator[str]: + return iter(self._dict) + + def __len__(self) -> int: + return len(self._dict) + + def __contains__(self, key: object) -> bool: + return key in self._dict + + def __call__(self, key: str, *args: object, **kwargs: object) -> Any: + return self[key](*args, **kwargs) + + +def decode_text(text: str | bytes, initial: str = "utf-8") -> str: + """ + Try to decode byte input as a string. + + Tries initial guess (UTF-8) then if that fails it + uses charset_normalizer to try another guess before failing. + + Parameters + ------------ + text : bytes + Data that might be a string + initial : str + Initial guess for text encoding. + + Returns + ------------ + decoded : str + Data as a string + """ + # if it's already a string there is nothing to decode + if isinstance(text, str): + return text + + try: + # initially guess file is UTF-8 or specified encoding + return text.decode(initial) + except UnicodeDecodeError: + # detect different file encodings + from charset_normalizer import detect as charset_normalizer_detect + + # try to detect the encoding of the file + # only look at the first 1000 characters for speed + detect = charset_normalizer_detect(text[:1000]) + # warn on files that aren't UTF-8 + log.debug( + "Data not {}! Trying {} (confidence {})".format( + initial, detect["encoding"], detect["confidence"] + ) + ) + # try to decode again ignoring errors + # if detect returned nothing just use the initial guess + return text.decode(detect["encoding"] or initial, errors="ignore") + + +def to_ascii(text: Any) -> str: + """ + Force a string or other to ASCII text ignoring errors. + + Parameters + ----------- + text : any + Input to be converted to ASCII string + + Returns + ----------- + ascii : str + Input as an ASCII string + """ + if hasattr(text, "encode"): + # case for existing strings + return text.encode("ascii", errors="ignore").decode("ascii") + elif hasattr(text, "decode"): + # case for bytes + return text.decode("ascii", errors="ignore") + # otherwise just wrap as a string + return str(text) + + +def is_ccw(points: ArrayLike, return_all: bool = False): + """ + Check if connected 2D points are counterclockwise. + + Parameters + ----------- + points : (n, 2) float + Connected points on a plane + return_all : bool + Return polygon area and centroid or just counter-clockwise. + + Returns + ---------- + ccw : bool + True if points are counter-clockwise + area : float + Only returned if `return_centroid` + centroid : (2,) float + Centroid of the polygon. + """ + points = np.array(points, dtype=np.float64) + + if len(points.shape) != 2 or points.shape[1] != 2: + raise ValueError("only defined for `(n, 2)` points") + + # the "shoelace formula" + product = np.subtract(*(points[:-1, [1, 0]] * points[1:]).T) + # the area of the polygon + area = product.sum() / 2.0 + # check the sign of the area + ccw = area < 0.0 + + if not return_all: + return ccw + + # the centroid of the polygon uses the same formula + centroid = ((points[:-1] + points[1:]) * product.reshape((-1, 1))).sum(axis=0) / ( + 6.0 * area + ) + + return ccw, area, centroid + + +def unique_name( + start: str | None, + contains: Collection[str], + counts: MutableMapping[str | None, int] | None = None, +) -> str: + """ + Deterministically generate a unique name not + contained in a dict, set or other grouping with + `__includes__` defined. Will create names of the + form "start_10" and increment accordingly. + + Parameters + ----------- + start : str + Initial guess for name. + contains : dict, set, or list + Bundle of existing names we can *not* use. + counts : None or dict + Maps name starts encountered before to increments in + order to speed up finding a unique name as otherwise + it potentially has to iterate through all of contains. + Should map to "how many times has this `start` + been attempted, i.e. `counts[start]: int`. + Note that this *will be mutated* in-place by this function! + + Returns + --------- + unique : str + A name that is not contained in `contains` + """ + # exit early if name is not in bundle + if start is not None and len(start) > 0 and start not in contains: + return start + + # start checking with zero index unless found + if counts is None: + increment = 0 + else: + increment = counts.get(start, 0) + if start is not None and len(start) > 0: + formatter = start + "_{}" + # split by our delimiter once + split = start.rsplit("_", 1) + if len(split) == 2 and increment == 0: + try: + # start incrementing from the existing + # trailing value + # if it is not an integer this will fail + increment = int(split[1]) + # include the first split value + formatter = split[0] + "_{}" + except BaseException: + pass + else: + formatter = "geometry_{}" + + # if contains is empty we will only need to check once + for i in range(increment + 1, 2 + increment + len(contains)): + check = formatter.format(i) + if check not in contains: + if counts is not None: + counts[start] = i + return check + + # this should really never happen since we looped + # through the full length of contains + raise ValueError("Unable to establish unique name!") diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/version.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/version.py new file mode 100644 index 0000000000000000000000000000000000000000..f5f3b984147706695d09b43c9f617fd9a097e4f7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/version.py @@ -0,0 +1,51 @@ +""" +# version.py + +Get the current version from package metadata or pyproject.toml +if everything else fails. +""" + +import json +import os + + +def _get_version() -> str | None: + """ + Try all our methods to get the version. + """ + + try: + # Get the version string using package metadata + from importlib.metadata import version + + return version("trimesh") + except Exception: + pass + + try: + # Get the version string from the pyproject.toml file using + # relative paths. This will be the only option if the library + # has not been installed (i.e. in a CI or container environment) + pyproject = os.path.abspath( + os.path.join( + os.path.dirname(os.path.abspath(os.path.expanduser(__file__))), + "..", + "pyproject.toml", + ) + ) + with open(pyproject) as f: + # json.loads cleans up the string and removes the quotes + # this logic requires the first use of "version" be the actual version + return next(json.loads(L.split("=")[1]) for L in f if "version" in L) + except Exception: + pass + + return None + + +# try all our tricks +__version__ = _get_version() + +if __name__ == "__main__": + # print version if run directly i.e. in a CI script + print(__version__) # noqa: T201 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ac44177f44e638176e27f2a79ee675d900d837b4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/__init__.py @@ -0,0 +1,38 @@ +""" +viewer +------------- + +View meshes and scenes via pyglet or inline HTML. +""" + +from .. import exceptions +from .notebook import ( + in_notebook, + scene_to_html, + scene_to_mo_notebook, + scene_to_notebook, +) + +try: + # try importing windowed which will fail + # if we can't create an openGL context + from .windowed import SceneViewer, render_scene +except BaseException as E: + # if windowed failed to import only raise + # the exception if someone tries to use them + SceneViewer = exceptions.ExceptionWrapper(E) + render_scene = exceptions.ExceptionWrapper(E) + + +# this is only standard library imports + +# explicitly list imports in __all__ +# as otherwise flake8 gets mad +__all__ = [ + "SceneViewer", + "in_notebook", + "render_scene", + "scene_to_html", + "scene_to_mo_notebook", + "scene_to_notebook", +] diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0f0a5e5e5a0acd0068474ec59e63a02802412999 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/__pycache__/notebook.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/__pycache__/notebook.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..47d6de3359f2df5c9572db9f8560533901106050 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/__pycache__/notebook.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/__pycache__/trackball.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/__pycache__/trackball.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7d76100eeb5ffce7670e5520088869735bb12350 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/__pycache__/trackball.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/__pycache__/windowed.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/__pycache__/windowed.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..824b2eb4504776cc3b4e5e4528b077e8397fd566 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/__pycache__/windowed.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/notebook.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/notebook.py new file mode 100644 index 0000000000000000000000000000000000000000..2006bc81832b7424789eb471fb07a82bc0992e97 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/notebook.py @@ -0,0 +1,174 @@ +""" +notebook.py +------------- + +Render trimesh.Scene objects in HTML +and jupyter and marimo notebooks using three.js +""" + +import base64 +import os +from typing import Literal + +# for our template +from .. import resources, util + + +def scene_to_html(scene, escape_quotes: bool = False) -> str: + """ + Return HTML that will render the scene using + GLTF/GLB encoded to base64 loaded by three.js + + Parameters + -------------- + scene : trimesh.Scene + Source geometry + escape_quotes + If true, replaces quotes '"' with '"' so that the + HTML is valid inside a `srcdoc` property. + + Returns + -------------- + html : str + HTML containing embedded geometry + """ + # fetch HTML template from ZIP archive + # it is bundling all of three.js so compression is nice + base = ( + util.decompress(resources.get_bytes("templates/viewer.zip"), file_type="zip")[ + "viewer.html.template" + ] + .read() + .decode("utf-8") + ) + # make sure scene has camera populated before export + _ = scene.camera + # get export as bytes + data = scene.export(file_type="glb") + # encode as base64 string + encoded = base64.b64encode(data).decode("utf-8") + # replace keyword with our scene data + html = base.replace("$B64GLTF", encoded) + + if escape_quotes: + return html.replace('"', """) + + return html + + +def scene_to_notebook(scene, height=500, **kwargs): + """ + Convert a scene to HTML containing embedded geometry + and a three.js viewer that will display nicely in + an IPython/Jupyter notebook. + + Parameters + ------------- + scene : trimesh.Scene + Source geometry + + Returns + ------------- + html : IPython.display.HTML + Object containing rendered scene + """ + # keep as soft dependency + from IPython import display + + # convert scene to a full HTML page + as_html = scene_to_html(scene=scene, escape_quotes=True) + + # escape the quotes in the HTML + srcdoc = as_html + # embed this puppy as the srcdoc attr of an IFframe + # I tried this a dozen ways and this is the only one that works + # display.IFrame/display.Javascript really, really don't work + # div is to avoid IPython's pointless hardcoded warning + embedded = display.HTML( + " ".join( + [ + '
', + ] + ).format(srcdoc=srcdoc, height=height) + ) + return embedded + + +def scene_to_mo_notebook(scene, height=500, **kwargs): + """ + Convert a scene to HTML containing embedded geometry + and a three.js viewer that will display nicely in + an Marimo notebook. + + Parameters + ------------- + scene : trimesh.Scene + Source geometry + + Returns + ------------- + html : mo.Html + Object containing rendered scene + """ + # keep as soft dependency + import marimo as mo + + # convert scene to a full HTML page + srcdoc = scene_to_html(scene=scene, escape_quotes=True) + + # Embed as srcdoc attr of IFrame, using mo.iframe + # turns out displaying an empty image. Likely + # similar to display.IFrame + embedded = mo.Html( + " ".join( + [ + '
', + ] + ).format(srcdoc=srcdoc, height=height) + ) + + return embedded + + +def in_notebook() -> Literal["jupyter", "marimo", False]: + """ + Check to see if we are in a Jypyter or Marimo notebook. + + Returns + ----------- + in_notebook + Returns the type of notebook we're in or False if it + is running as terminal application. + """ + try: + # function returns IPython context, but only in IPython + ipy = get_ipython() # NOQA + # we only want to render rich output in notebooks + # in terminals we definitely do not want to output HTML + name = str(ipy.__class__).lower() + terminal = "terminal" in name + + # spyder uses ZMQshell, and can appear to be a notebook + spyder = "_" in os.environ and "spyder" in os.environ["_"] + + # assume we are in a notebook if we are not in + # a terminal and we haven't been run by spyder + if (not terminal) and (not spyder): + return "jupyter" + except BaseException: + pass + + try: + import marimo as mo + + if mo.running_in_notebook(): + return "marimo" + + except BaseException: + pass + + return False diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/trackball.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/trackball.py new file mode 100644 index 0000000000000000000000000000000000000000..2b6a78ba46ff8c17d1de21f11bcbe056a89f6e17 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/trackball.py @@ -0,0 +1,240 @@ +# Copied from +# https://github.com/mmatl/pyrender/blob/master/pyrender/trackball.py + +# MIT License +# +# Copyright (c) 2019 Matthew Matl +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +"""Trackball class for 3D manipulation of viewpoints.""" + +import numpy as np + +from .. import transformations + + +class Trackball: + """A trackball class for creating camera transforms from mouse movements.""" + + STATE_ROTATE = 0 + STATE_PAN = 1 + STATE_ROLL = 2 + STATE_ZOOM = 3 + + def __init__(self, pose, size, scale, target=None): + """Initialize a trackball with an initial camera-to-world pose + and the given parameters. + + Parameters + ---------- + pose : [4,4] + An initial camera-to-world pose for the trackball. + + size : (float, float) + The width and height of the camera image in pixels. + + scale : float + The diagonal of the scene's bounding box -- + used for ensuring translation motions are sufficiently + fast for differently-sized scenes. + + target : (3,) float + The center of the scene in world coordinates. + The trackball will revolve around this point. + """ + self._size = np.array(size) + self._scale = float(scale) + + self._pose = pose + self._n_pose = pose + + if target is None: + self._target = np.array([0.0, 0.0, 0.0]) + self._n_target = np.array([0.0, 0.0, 0.0]) + else: + self._target = target + self._n_target = target + + self._state = Trackball.STATE_ROTATE + + @property + def pose(self): + """autolab_core.RigidTransform : The current camera-to-world pose.""" + return self._n_pose + + def set_state(self, state): + """Set the state of the trackball in order to change the effect of + dragging motions. + + Parameters + ---------- + state : int + One of Trackball.STATE_ROTATE, Trackball.STATE_PAN, + Trackball.STATE_ROLL, and Trackball.STATE_ZOOM. + """ + self._state = state + + def resize(self, size): + """Resize the window. + + Parameters + ---------- + size : (float, float) + The new width and height of the camera image in pixels. + """ + self._size = np.array(size) + + def down(self, point): + """Record an initial mouse press at a given point. + + Parameters + ---------- + point : (2,) int + The x and y pixel coordinates of the mouse press. + """ + self._pdown = np.array(point, dtype=np.float32) + self._pose = self._n_pose + self._target = self._n_target + + def drag(self, point): + """Update the tracball during a drag. + + Parameters + ---------- + point : (2,) int + The current x and y pixel coordinates of the mouse during a drag. + This will compute a movement for the trackball with the relative + motion between this point and the one marked by down(). + """ + point = np.array(point, dtype=np.float32) + # get the "down" point defaulting to current point making + # this a no-op if the "down" event didn't trigger for some reason + dx, dy = point - getattr(self, "_pdown", point) + mindim = 0.3 * np.min(self._size) + + target = self._target + x_axis = self._pose[:3, 0].flatten() + y_axis = self._pose[:3, 1].flatten() + z_axis = self._pose[:3, 2].flatten() + eye = self._pose[:3, 3].flatten() + + # Interpret drag as a rotation + if self._state == Trackball.STATE_ROTATE: + x_angle = -dx / mindim + x_rot_mat = transformations.rotation_matrix(x_angle, y_axis, target) + + y_angle = dy / mindim + y_rot_mat = transformations.rotation_matrix(y_angle, x_axis, target) + + self._n_pose = y_rot_mat.dot(x_rot_mat.dot(self._pose)) + + # Interpret drag as a roll about the camera axis + elif self._state == Trackball.STATE_ROLL: + center = self._size / 2.0 + v_init = self._pdown - center + v_curr = point - center + v_init = v_init / np.linalg.norm(v_init) + v_curr = v_curr / np.linalg.norm(v_curr) + + theta = -np.arctan2(v_curr[1], v_curr[0]) + np.arctan2(v_init[1], v_init[0]) + + rot_mat = transformations.rotation_matrix(theta, z_axis, target) + + self._n_pose = rot_mat.dot(self._pose) + + # Interpret drag as a camera pan in view plane + elif self._state == Trackball.STATE_PAN: + dx = -dx / (5.0 * mindim) * self._scale + dy = -dy / (5.0 * mindim) * self._scale + + translation = dx * x_axis + dy * y_axis + self._n_target = self._target + translation + t_tf = np.eye(4) + t_tf[:3, 3] = translation + self._n_pose = t_tf.dot(self._pose) + + # Interpret drag as a zoom motion + elif self._state == Trackball.STATE_ZOOM: + radius = np.linalg.norm(eye - target) + ratio = 0.0 + if dy > 0: + ratio = np.exp(abs(dy) / (0.5 * self._size[1])) - 1.0 + elif dy < 0: + ratio = 1.0 - np.exp(dy / (0.5 * (self._size[1]))) + translation = -np.sign(dy) * ratio * radius * z_axis + t_tf = np.eye(4) + t_tf[:3, 3] = translation + self._n_pose = t_tf.dot(self._pose) + + def scroll(self, clicks): + """Zoom using a mouse scroll wheel motion. + + Parameters + ---------- + clicks : int + The number of clicks. Positive numbers indicate forward wheel + movement. + """ + target = self._target + ratio = 0.90 + + mult = 1.0 + if clicks > 0: + mult = ratio**clicks + elif clicks < 0: + mult = (1.0 / ratio) ** abs(clicks) + + z_axis = self._n_pose[:3, 2].flatten() + eye = self._n_pose[:3, 3].flatten() + radius = np.linalg.norm(eye - target) + translation = (mult * radius - radius) * z_axis + t_tf = np.eye(4) + t_tf[:3, 3] = translation + self._n_pose = t_tf.dot(self._n_pose) + + z_axis = self._pose[:3, 2].flatten() + eye = self._pose[:3, 3].flatten() + radius = np.linalg.norm(eye - target) + translation = (mult * radius - radius) * z_axis + t_tf = np.eye(4) + t_tf[:3, 3] = translation + self._pose = t_tf.dot(self._pose) + + def rotate(self, azimuth, axis=None): + """Rotate the trackball about the "Up" axis by azimuth radians. + + Parameters + ---------- + azimuth : float + The number of radians to rotate. + """ + target = self._target + + y_axis = self._n_pose[:3, 1].flatten() + if axis is not None: + y_axis = axis + x_rot_mat = transformations.rotation_matrix(azimuth, y_axis, target) + self._n_pose = x_rot_mat.dot(self._n_pose) + + y_axis = self._pose[:3, 1].flatten() + if axis is not None: + y_axis = axis + x_rot_mat = transformations.rotation_matrix(azimuth, y_axis, target) + self._pose = x_rot_mat.dot(self._pose) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/windowed.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/windowed.py new file mode 100644 index 0000000000000000000000000000000000000000..0cb2533ef72b4748d43ed08f06c9094496df16b1 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/viewer/windowed.py @@ -0,0 +1,972 @@ +""" +windowed.py +--------------- + +Provides a pyglet- based windowed viewer to preview +Trimesh, Scene, PointCloud, and Path objects. + +Works on all major platforms: Windows, Linux, and OSX. +""" + +import collections + +import numpy as np +import pyglet + +# pyglet 2.0 is close to a re-write moving from fixed-function +# to shaders and we will likely support it by forking an entirely +# new viewer `trimesh.viewer.shaders` and then basically keeping +# `windowed` around for backwards-compatibility with no changes +if int(pyglet.version.split(".")[0]) >= 2: + raise ImportError('`trimesh.viewer.windowed` requires `pip install "pyglet<2"`') + +from .. import rendering, util +from ..transformations import translation_matrix +from ..typed import ArrayLike, Callable, Iterable, Number +from ..visual import to_rgba +from .trackball import Trackball + +pyglet.options["shadow_window"] = False + +import pyglet.gl as gl # NOQA + +# help message for the viewer +_HELP_MESSAGE = """ +# SceneViewer Controls + +| Input | Action | +|----------------------------|-----------------------------------------------| +| `mouse click + drag` | Rotates the view | +| `ctl + mouse click + drag` | Pans the view | +| `mouse wheel` | Zooms the view | +| `z` | Resets to the initial view | +| `w` | Toggles wireframe mode | +| `c` | Toggles backface culling | +| `g` | Toggles an XY grid with Z set to lowest point | +| `a` | Toggles an XYZ-RGB axis marker between: off, | +| | at world frame, or at every frame and world, | +| | and at every frame | +| `f` | Toggles between fullscreen and windowed mode | +| `h` | Prints this help message | +| `m` | Maximizes the window | +| `q` | Closes the window | +|----------------------------|-----------------------------------------------| +""" + + +class SceneViewer(pyglet.window.Window): + def __init__( + self, + scene, + smooth: bool = True, + flags: dict | None = None, + visible: bool = True, + resolution: ArrayLike | None = None, + fullscreen: bool = False, + resizable: bool = True, + start_loop: bool = True, + callback: Callable | None = None, + callback_period: Number | None = None, + caption: str | None = None, + fixed: Iterable | None = None, + offset_lines: bool = True, + line_settings: dict | None = None, + background=None, + window_conf=None, + profile: bool = False, + record: bool = False, + **kwargs, + ): + """ + Create a window that will display a trimesh.Scene object + in an OpenGL context via pyglet. + + Parameters + --------------- + scene : trimesh.scene.Scene + Scene with geometry and transforms + smooth + If True try to smooth shade things + flags + If passed apply keys to self.view: + ['cull', 'wireframe', etc] + visible + Display window or not + resolution + Initial resolution of window + fullscreen + Determines whether the window is rendered in fullscreen mode. + resizable + Determines whether the rendered window can be resized by the user. + start_loop + Call pyglet.app.run() at the end of init + callback + A function which can be called periodically to + update things in the scene + callback_period + How often to call the callback, in seconds + caption + Caption for the window title + fixed + List of keys in scene.geometry to skip view + transform on to keep fixed relative to camera + offset_lines + If True, will offset lines slightly so if drawn + coplanar with mesh geometry they will be visible + line_settings + Override default line width and point size with keys + 'line_width' and 'point_size' in pixels + background + Color for background + window_conf + Passed to window init + profile + If set will run a `pyinstrument` profile for + every call to `on_draw` and print the output. + record + If True, will save a list of `png` bytes to + a list located in `scene.metadata['recording']` + kwargs + Additional arguments to pass, including + 'background' for to set background color + """ + self.scene = self._scene = scene + + self.callback = callback + self.callback_period = callback_period + self.scene._redraw = self._redraw + self.offset_lines = bool(offset_lines) + self.background = background + # save initial camera transform + self._initial_camera_transform = scene.camera_transform.copy() + + # a transform to offset lines slightly to avoid Z-fighting + self._line_offset = translation_matrix( + [0, 0, scene.scale / 1000 if self.offset_lines else 0] + ) + + self.reset_view() + self.batch = pyglet.graphics.Batch() + self._smooth = smooth + + self._profile = bool(profile) + if self._profile: + from pyinstrument import Profiler + + self.Profiler = Profiler + + self._record = bool(record) + if self._record: + # will save bytes here + self.scene.metadata["recording"] = [] + + # store kwargs + self.kwargs = kwargs + + # store a vertexlist for an axis marker + self._axis = None + # store a vertexlist for a grid display + self._grid = None + # store scene geometry as vertex lists + self.vertex_list = {} + # store geometry hashes + self.vertex_list_hash = {} + # store geometry rendering mode + self.vertex_list_mode = {} + # store meshes that don't rotate relative to viewer + self.fixed = fixed + # store a hidden (don't not display) node. + self._nodes_hidden = set() + # name : texture + self.textures = {} + + # if resolution isn't defined set a default value + if resolution is None: + resolution = scene.camera.resolution + else: + scene.camera.resolution = resolution + + if caption is None: + caption = "Trimesh SceneViewer (`h` for help)" + + # set the default line settings to a fraction + # of our resolution so the points aren't tiny + scale = max(resolution) + self.line_settings = {"point_size": scale / 200, "line_width": scale / 400} + # if we've been passed line settings override the default + if line_settings is not None: + self.line_settings.update(line_settings) + + # no window conf was passed so try to get the best looking one + if window_conf is None: + try: + # try enabling antialiasing + # if you have a graphics card this will probably work + conf = gl.Config( + sample_buffers=1, samples=4, depth_size=24, double_buffer=True + ) + super().__init__( + config=conf, + visible=visible, + fullscreen=fullscreen, + resizable=resizable, + width=resolution[0], + height=resolution[1], + caption=caption, + ) + except pyglet.window.NoSuchConfigException: + conf = gl.Config(double_buffer=True) + super().__init__( + config=conf, + fullscreen=fullscreen, + resizable=resizable, + visible=visible, + width=resolution[0], + height=resolution[1], + caption=caption, + ) + else: + # window config was manually passed + super().__init__( + config=window_conf, + fullscreen=fullscreen, + resizable=resizable, + visible=visible, + width=resolution[0], + height=resolution[1], + caption=caption, + ) + + # add scene geometry to viewer geometry + self._update_vertex_list() + + # call after geometry is added + self.init_gl() + self.set_size(*resolution) + if flags is not None: + self.reset_view(flags=flags) + self.update_flags() + + # someone has passed a callback to be called periodically + if self.callback is not None: + # if no callback period is specified set it to default + if callback_period is None: + # 30 times per second + callback_period = 1.0 / 30.0 + # set up a do-nothing periodic task which will + # trigger `self.on_draw` every `callback_period` + # seconds if someone has passed a callback + pyglet.clock.schedule_interval(lambda x: x, callback_period) + if start_loop: + pyglet.app.run() + + def _redraw(self): + self.on_draw() + + def _update_vertex_list(self): + # update vertex_list if needed + for name, geom in self.scene.geometry.items(): + if geom.is_empty: + continue + if _geometry_hash(geom) == self.vertex_list_hash.get(name): + continue + self.add_geometry(name=name, geometry=geom, smooth=bool(self._smooth)) + + def _update_meshes(self): + # call the callback if specified + if self.callback is not None: + self.callback(self.scene) + self._update_vertex_list() + self._update_perspective(self.width, self.height) + + def add_geometry(self, name, geometry, **kwargs): + """ + Add a geometry to the viewer. + + Parameters + -------------- + name : hashable + Name that references geometry + geometry : Trimesh, Path2D, Path3D, PointCloud + Geometry to display in the viewer window + kwargs ** + Passed to rendering.convert_to_vertexlist + """ + try: + # convert geometry to constructor args + args = rendering.convert_to_vertexlist(geometry, **kwargs) + except BaseException: + util.log.warning(f"failed to add geometry `{name}`", exc_info=True) + return + + # delete old vertex list with the same name + if name in self.vertex_list: + self.vertex_list[name].delete() + + # create the indexed vertex list + self.vertex_list[name] = self.batch.add_indexed(*args) + # save the hash of the geometry + self.vertex_list_hash[name] = _geometry_hash(geometry) + # save the rendering mode from the constructor args + self.vertex_list_mode[name] = args[1] + + # get the visual if the element has it + visual = getattr(geometry, "visual", None) + if hasattr(visual, "uv") and hasattr(visual, "material"): + try: + tex = rendering.material_to_texture(visual.material) + if tex is not None: + self.textures[name] = tex + except BaseException: + util.log.warning("failed to load texture", exc_info=True) + + def cleanup_geometries(self): + """ + Remove any stored vertex lists that no longer + exist in the scene. + """ + # shorthand to scene graph + graph = self.scene.graph + # which parts of the graph still have geometry + geom_keep = {graph[node][1] for node in graph.nodes_geometry} + # which geometries no longer need to be kept + geom_delete = [geom for geom in self.vertex_list if geom not in geom_keep] + for geom in geom_delete: + # delete the vertex list + if geom in self.vertex_list: + self.vertex_list[geom].delete() + # remove stored vertex references + self.vertex_list.pop(geom, None) + self.vertex_list_hash.pop(geom, None) + self.vertex_list_mode.pop(geom, None) + self.textures.pop(geom, None) + + def unhide_geometry(self, node): + """ + If a node is hidden remove the flag and show the + geometry on the next draw. + + Parameters + ------------- + node : str + Node to display + """ + self._nodes_hidden.discard(node) + + def hide_geometry(self, node): + """ + Don't display the geometry contained at a node on + the next draw. + + Parameters + ------------- + node : str + Node to not display + """ + self._nodes_hidden.add(node) + + def reset_view(self, flags=None): + """ + Set view to the default view. + + Parameters + -------------- + flags : None or dict + If any view key passed override the default + e.g. {'cull': False} + """ + self.view = { + "cull": True, + "axis": False, + "grid": False, + "fullscreen": False, + "wireframe": False, + "ball": Trackball( + pose=self._initial_camera_transform, + size=self.scene.camera.resolution, + scale=self.scene.scale, + target=self.scene.centroid, + ), + } + try: + # if any flags are passed override defaults + if isinstance(flags, dict): + for k, v in flags.items(): + if k in self.view: + self.view[k] = v + self.update_flags() + except BaseException: + pass + self.scene.camera_transform = self.view["ball"].pose + + def init_gl(self): + """ + Perform the magic incantations to create an + OpenGL scene using pyglet. + """ + + # if user passed a background color use it + if self.background is None: + # default background color is white + background = np.ones(4) + else: + # convert to (4,) uint8 RGBA + background = to_rgba(self.background) + # convert to 0.0-1.0 float + background = background.astype(np.float64) / 255.0 + + self._gl_set_background(background) + # use camera setting for depth + self._gl_enable_depth(self.scene.camera) + self._gl_enable_color_material() + self._gl_enable_blending() + self._gl_enable_smooth_lines(**self.line_settings) + self._gl_enable_lighting(self.scene) + + @staticmethod + def _gl_set_background(background): + gl.glClearColor(*background) + + @staticmethod + def _gl_unset_background(): + gl.glClearColor(*[0, 0, 0, 0]) + + @staticmethod + def _gl_enable_depth(camera): + """ + Enable depth test in OpenGL using distances + from `scene.camera`. + """ + gl.glClearDepth(1.0) + gl.glEnable(gl.GL_DEPTH_TEST) + gl.glDepthFunc(gl.GL_LEQUAL) + + gl.glEnable(gl.GL_DEPTH_TEST) + gl.glEnable(gl.GL_CULL_FACE) + + @staticmethod + def _gl_enable_color_material(): + # do some openGL things + gl.glColorMaterial(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE) + gl.glEnable(gl.GL_COLOR_MATERIAL) + gl.glShadeModel(gl.GL_SMOOTH) + + gl.glMaterialfv( + gl.GL_FRONT, + gl.GL_AMBIENT, + rendering.vector_to_gl(0.192250, 0.192250, 0.192250), + ) + gl.glMaterialfv( + gl.GL_FRONT, + gl.GL_DIFFUSE, + rendering.vector_to_gl(0.507540, 0.507540, 0.507540), + ) + gl.glMaterialfv( + gl.GL_FRONT, + gl.GL_SPECULAR, + rendering.vector_to_gl(0.5082730, 0.5082730, 0.5082730), + ) + + gl.glMaterialf(gl.GL_FRONT, gl.GL_SHININESS, 0.4 * 128.0) + + @staticmethod + def _gl_enable_blending(): + # enable blending for transparency + gl.glEnable(gl.GL_BLEND) + gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) + + @staticmethod + def _gl_enable_smooth_lines(line_width=4, point_size=4): + # make the lines from Path3D objects less ugly + gl.glEnable(gl.GL_LINE_SMOOTH) + gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) + # set the width of lines to 4 pixels + gl.glLineWidth(line_width) + # set PointCloud markers to 4 pixels in size + gl.glPointSize(point_size) + + @staticmethod + def _gl_enable_lighting(scene): + """ + Take the lights defined in scene.lights and + apply them as openGL lights. + """ + gl.glEnable(gl.GL_LIGHTING) + # opengl only supports 7 lights? + for i, light in enumerate(scene.lights[:7]): + # the index of which light we have + lightN = getattr(gl, f"GL_LIGHT{i}") + + # get the transform for the light by name + matrix = scene.graph.get(light.name)[0] + + # convert light object to glLightfv calls + multiargs = rendering.light_to_gl( + light=light, transform=matrix, lightN=lightN + ) + + # enable the light in question + gl.glEnable(lightN) + # run the glLightfv calls + for args in multiargs: + gl.glLightfv(*args) + + def toggle_culling(self): + """ + Toggle back face culling. + + It is on by default but if you are dealing with + non- watertight meshes you probably want to be able + to see the back sides. + """ + self.view["cull"] = not self.view["cull"] + self.update_flags() + + def toggle_wireframe(self): + """ + Toggle wireframe mode + + Good for looking inside meshes, off by default. + """ + self.view["wireframe"] = not self.view["wireframe"] + self.update_flags() + + def toggle_fullscreen(self): + """ + Toggle between fullscreen and windowed mode. + """ + self.view["fullscreen"] = not self.view["fullscreen"] + self.update_flags() + + def toggle_axis(self): + """ + Toggle a rendered XYZ/RGB axis marker: + off, world frame, every frame + """ + # cycle through three axis states + states = [False, "world", "all", "without_world"] + # the state after toggling + index = (states.index(self.view["axis"]) + 1) % len(states) + # update state to next index + self.view["axis"] = states[index] + # perform gl actions + self.update_flags() + + def toggle_grid(self): + """ + Toggle a rendered grid. + """ + # update state to next index + self.view["grid"] = not self.view["grid"] + # perform gl actions + self.update_flags() + + def update_flags(self): + """ + Check the view flags, and call required GL functions. + """ + # view mode, filled vs wirefrom + if self.view["wireframe"]: + gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_LINE) + else: + gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_FILL) + + # set fullscreen or windowed + self.set_fullscreen(fullscreen=self.view["fullscreen"]) + + # backface culling on or off + if self.view["cull"]: + gl.glEnable(gl.GL_CULL_FACE) + else: + gl.glDisable(gl.GL_CULL_FACE) + + # case where we WANT an axis and NO vertexlist + # is stored internally + if self.view["axis"] and self._axis is None: + from .. import creation + + # create an axis marker sized relative to the scene + axis = creation.axis(origin_size=self.scene.scale / 100) + # create ordered args for a vertex list + args = rendering.mesh_to_vertexlist(axis) + # store the axis as a reference + self._axis = self.batch.add_indexed(*args) + # case where we DON'T want an axis but a vertexlist + # IS stored internally + elif not self.view["axis"] and self._axis is not None: + # remove the axis from the rendering batch + self._axis.delete() + # set the reference to None + self._axis = None + + if self.view["grid"] and self._grid is None: + try: + # create a grid marker + from ..path.creation import grid + + bounds = self.scene.bounds + center = bounds.mean(axis=0) + # set the grid to the lowest Z position + # also offset by the scale to avoid interference + center[2] = bounds[0][2] - (np.ptp(bounds[:, 2]) / 100) + # choose the side length by maximum XY length + side = np.ptp(bounds, axis=0)[:2].max() + # create an axis marker sized relative to the scene + grid_mesh = grid(side=side, count=4, transform=translation_matrix(center)) + # convert the path to vertexlist args + args = rendering.convert_to_vertexlist(grid_mesh) + # create ordered args for a vertex list + self._grid = self.batch.add_indexed(*args) + except BaseException: + util.log.warning("failed to create grid!", exc_info=True) + elif not self.view["grid"] and self._grid is not None: + self._grid.delete() + self._grid = None + + def _update_perspective(self, width, height): + try: + # for high DPI screens viewport size + # will be different then the passed size + width, height = self.get_viewport_size() + except BaseException: + # older versions of pyglet may not have this + pass + + # set the new viewport size + gl.glViewport(0, 0, width, height) + gl.glMatrixMode(gl.GL_PROJECTION) + gl.glLoadIdentity() + + # get field of view and Z range from camera + camera = self.scene.camera + + # set perspective from camera data + gl.gluPerspective( + camera.fov[1], width / float(height), camera.z_near, camera.z_far + ) + gl.glMatrixMode(gl.GL_MODELVIEW) + + return width, height + + def on_resize(self, width, height): + """ + Handle resized windows. + """ + width, height = self._update_perspective(width, height) + self.scene.camera.resolution = (width, height) + self.view["ball"].resize(self.scene.camera.resolution) + self.scene.camera_transform = self.view["ball"].pose + + def on_mouse_press(self, x, y, buttons, modifiers): + """ + Set the start point of the drag. + """ + self.view["ball"].set_state(Trackball.STATE_ROTATE) + if buttons == pyglet.window.mouse.LEFT: + ctrl = modifiers & pyglet.window.key.MOD_CTRL + shift = modifiers & pyglet.window.key.MOD_SHIFT + if ctrl and shift: + self.view["ball"].set_state(Trackball.STATE_ZOOM) + elif shift: + self.view["ball"].set_state(Trackball.STATE_ROLL) + elif ctrl: + self.view["ball"].set_state(Trackball.STATE_PAN) + elif buttons == pyglet.window.mouse.MIDDLE: + self.view["ball"].set_state(Trackball.STATE_PAN) + elif buttons == pyglet.window.mouse.RIGHT: + self.view["ball"].set_state(Trackball.STATE_ZOOM) + + self.view["ball"].down(np.array([x, y])) + self.scene.camera_transform = self.view["ball"].pose + + def on_mouse_drag(self, x, y, dx, dy, buttons, modifiers): + """ + Pan or rotate the view. + """ + self.view["ball"].drag(np.array([x, y])) + self.scene.camera_transform = self.view["ball"].pose + + def on_mouse_scroll(self, x, y, dx, dy): + """ + Zoom the view. + """ + self.view["ball"].scroll(dy) + self.scene.camera_transform = self.view["ball"].pose + + def on_key_press(self, symbol, modifiers): + """ + Call appropriate functions given key presses. + """ + magnitude = 10 + if symbol == pyglet.window.key.W: + self.toggle_wireframe() + elif symbol == pyglet.window.key.Z: + self.reset_view() + elif symbol == pyglet.window.key.C: + self.toggle_culling() + elif symbol == pyglet.window.key.A: + self.toggle_axis() + elif symbol == pyglet.window.key.G: + self.toggle_grid() + elif symbol == pyglet.window.key.Q: + self.on_close() + elif symbol == pyglet.window.key.M: + self.maximize() + elif symbol == pyglet.window.key.F: + self.toggle_fullscreen() + elif symbol == pyglet.window.key.H: + print(_HELP_MESSAGE) # noqa: T201 + + if symbol in [ + pyglet.window.key.LEFT, + pyglet.window.key.RIGHT, + pyglet.window.key.DOWN, + pyglet.window.key.UP, + ]: + self.view["ball"].down([0, 0]) + if symbol == pyglet.window.key.LEFT: + self.view["ball"].drag([-magnitude, 0]) + elif symbol == pyglet.window.key.RIGHT: + self.view["ball"].drag([magnitude, 0]) + elif symbol == pyglet.window.key.DOWN: + self.view["ball"].drag([0, -magnitude]) + elif symbol == pyglet.window.key.UP: + self.view["ball"].drag([0, magnitude]) + self.scene.camera_transform = self.view["ball"].pose + + def on_draw(self): + """ + Run the actual draw calls. + """ + + if self._profile: + profiler = self.Profiler() + profiler.start() + + self._update_meshes() + gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) + gl.glLoadIdentity() + + # pull the new camera transform from the scene + transform_camera = np.linalg.inv(self.scene.camera_transform) + + # apply the camera transform to the matrix stack + gl.glMultMatrixf(rendering.matrix_to_gl(transform_camera)) + + # we want to render fully opaque objects first, + # followed by objects which have transparency + node_names = collections.deque(self.scene.graph.nodes_geometry) + # how many nodes did we start with + count_original = len(node_names) + count = -1 + + # if we are rendering an axis marker at the world + if self._axis and not self.view["axis"] == "without_world": + # we stored it as a vertex list + self._axis.draw(mode=gl.GL_TRIANGLES) + if self._grid: + self._grid.draw(mode=gl.GL_LINES) + + # save a reference outside of the loop + geometry = self.scene.geometry + graph = self.scene.graph + + while len(node_names) > 0: + count += 1 + current_node = node_names.popleft() + + if current_node in self._nodes_hidden: + continue + + # get the transform from world to geometry and mesh name + transform, geometry_name = graph.get(current_node) + # if no geometry at this frame continue without rendering + if geometry_name is None or geometry_name not in self.vertex_list_mode: + continue + + # if a geometry is marked as fixed apply the inverse view transform + if self.fixed is not None and geometry_name in self.fixed: + # remove altered camera transform from fixed geometry + transform_fix = np.linalg.inv( + np.dot(self._initial_camera_transform, transform_camera) + ) + # apply the transform so the fixed geometry doesn't move + transform = np.dot(transform, transform_fix) + + # get a reference to the mesh so we can check transparency + mesh = geometry[geometry_name] + if mesh.is_empty: + continue + # get the GL mode of the current geometry + mode = self.vertex_list_mode[geometry_name] + + # if you draw a coplanar line with a triangle it will z-fight + # the best way to do this is probably a shader but this works fine + if mode == gl.GL_LINES: + # apply the offset in camera space + transform = util.multi_dot( + [ + transform, + np.linalg.inv(transform_camera), + self._line_offset, + transform_camera, + ] + ) + + # add a new matrix to the model stack + gl.glPushMatrix() + # transform by the nodes transform + gl.glMultMatrixf(rendering.matrix_to_gl(transform)) + + # draw an axis marker for each mesh frame + if self.view["axis"] == "all": + self._axis.draw(mode=gl.GL_TRIANGLES) + elif self.view["axis"] == "without_world": + if not util.allclose(transform, np.eye(4), atol=1e-5): + self._axis.draw(mode=gl.GL_TRIANGLES) + + # transparent things must be drawn last + if ( + hasattr(mesh, "visual") + and hasattr(mesh.visual, "transparency") + and mesh.visual.transparency + ): + # put the current item onto the back of the queue + if count < count_original: + # add the node to be drawn last + node_names.append(current_node) + # pop the matrix stack for now + gl.glPopMatrix() + # come back to this mesh later + continue + + # if we have texture enable the target texture + texture = None + if geometry_name in self.textures: + texture = self.textures[geometry_name] + gl.glEnable(texture.target) + gl.glBindTexture(texture.target, texture.id) + + # draw the mesh with its transform applied + self.vertex_list[geometry_name].draw(mode=mode) + # pop the matrix stack as we drew what we needed to draw + gl.glPopMatrix() + + # disable texture after using + if texture is not None: + gl.glDisable(texture.target) + + if self._profile: + profiler.stop() + util.log.debug(profiler.output_text(unicode=True, color=True)) + + def flip(self): + super().flip() + if self._record: + # will save a PNG-encoded bytes + img = self.save_image(util.BytesIO()) + # seek start of file-like object + img.seek(0) + # save the bytes from the file object + self.scene.metadata["recording"].append(img.read()) + + def save_image(self, file_obj): + """ + Save the current color buffer to a file object + in PNG format. + + Parameters + ------------- + file_obj: file name, or file- like object + """ + manager = pyglet.image.get_buffer_manager() + colorbuffer = manager.get_color_buffer() + # if passed a string save by name + if hasattr(file_obj, "write"): + colorbuffer.save(file=file_obj) + else: + colorbuffer.save(filename=file_obj) + return file_obj + + +def _geometry_hash(geometry): + """ + Get a hash for a geometry object + + Parameters + ------------ + geometry : object + + Returns + ------------ + hash : str + """ + h = str(hash(geometry)) + if hasattr(geometry, "visual"): + # if visual properties are defined + h += str(hash(geometry.visual)) + + return h + + +def render_scene( + scene, resolution=None, visible=True, fullscreen=False, resizable=True, **kwargs +): + """ + Render a preview of a scene to a PNG. Note that + whether this works or not highly variable based on + platform and graphics driver. + + Parameters + ------------ + scene : trimesh.Scene + Geometry to be rendered + resolution : (2,) int or None + Resolution in pixels or set from scene.camera + visible : bool + Show a window during rendering. Note that MANY + platforms refuse to render with hidden windows + and will likely return a blank image; this is a + platform issue and cannot be fixed in Python. + fullscreen : bool + Determines whether the window is rendered in fullscreen mode. + Defaults to False (windowed). + resizable : bool + Determines whether the rendered window can be resized by the user. + Defaults to True (resizable). + kwargs : ** + Passed to SceneViewer + + Returns + --------- + render : bytes + Image in PNG format + """ + window = SceneViewer( + scene, + start_loop=False, + visible=visible, + resolution=resolution, + fullscreen=fullscreen, + resizable=resizable, + **kwargs, + ) + + from ..util import BytesIO + + # need to run loop twice to display anything + for save in [False, False, True]: + pyglet.clock.tick() + window.switch_to() + window.dispatch_events() + window.dispatch_event("on_draw") + window.flip() + if save: + # save the color buffer data to memory + file_obj = BytesIO() + window.save_image(file_obj) + file_obj.seek(0) + render = file_obj.read() + window.close() + + return render diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..63a7f25aa28d4737700ae7cd8de05e199847781a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__init__.py @@ -0,0 +1,46 @@ +# flake8: NOQA +""" +visual +------------- + +Handle visual properties for meshes, including color and texture +""" + +from .color import ( + ColorVisuals, + random_color, + to_rgba, + DEFAULT_COLOR, + interpolate, + uv_to_color, + uv_to_interpolated_color, + linear_color_map, +) + +from .texture import TextureVisuals +from .objects import create_visual, concatenate + +from . import color +from . import texture +from . import objects +from . import material +from .. import resolvers + + +# explicitly list imports in __all__ +# as otherwise flake8 gets mad +__all__ = [ + "color", + "texture", + "resolvers", + "TextureVisuals", + "ColorVisuals", + "random_color", + "to_rgba", + "create_visual", + "DEFAULT_COLOR", + "interpolate", + "linear_color_map", + "uv_to_color", + "uv_to_interpolated_color", +] diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1bbf3ccd01d23f95f2dfbf208e9f23323372a7a8 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/base.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/base.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..43833ad597d7194043d9db7e8394f0dee2b28e26 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/base.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/color.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/color.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4f8e7ae3ba89cc61635d0cb38e07b667501712f1 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/color.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/gloss.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/gloss.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e9b7b4569714d32ed9e626cfedd81c045e9e9687 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/gloss.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/material.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/material.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2e3f47cb943332107a540aa1a1ba56667308742f Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/material.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/objects.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/objects.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b84996ce3405e92811bbc4e6c9de245033e920cf Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/objects.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/texture.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/texture.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ebda76ea011c71839fdb99b52e4697cefada198d Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/__pycache__/texture.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/base.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/base.py new file mode 100644 index 0000000000000000000000000000000000000000..5810a67341a505fa559bbe4d00db9ae3ad71e8f2 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/base.py @@ -0,0 +1,58 @@ +""" +base.py +------------- + +The base class for `Visual` objects +""" + +import abc + +from ..util import ABC + + +class Visuals(ABC): + """ + Parent of Visual classes. + """ + + @property + @abc.abstractmethod + def kind(self): + pass + + @abc.abstractmethod + def update_vertices(self, mask): + pass + + @abc.abstractmethod + def update_faces(self, mask): + pass + + @abc.abstractmethod + def concatenate(self, other): + pass + + @abc.abstractmethod + def __hash__(self): + pass + + @abc.abstractmethod + def copy(self): + pass + + def __add__(self, other): + """ + Concatenate two ColorVisuals objects into a single object. + + Parameters + ----------- + other : Visuals + Other visual to concatenate + + Returns + ----------- + result : Visuals + Object containing information from current + object and other in the order (self, other) + """ + return self.concatenate(other) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/color.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/color.py new file mode 100644 index 0000000000000000000000000000000000000000..8c8f53eff6436fb037c837afc1d88a0fdd3b2a0f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/color.py @@ -0,0 +1,1224 @@ +""" +color.py +------------- + +Hold and deal with visual information about meshes. + +There are lots of ways to encode visual information, and the goal of this +architecture is to make it possible to define one, and then transparently +get the others. The two general categories are: + +1) colors, defined for a face, vertex, or material +2) textures, defined as an image and UV coordinates for each vertex + +This module only implements diffuse colors at the moment. + +Goals +---------- +1) If nothing is defined sane defaults should be returned +2) If a user alters or sets a value, that is considered user data + and should be saved and treated as such. +3) Only one 'mode' of visual (vertex or face) is allowed at a time + and setting or altering a value should automatically change the mode. +""" + +import copy +from typing import Any + +import numpy as np + +from .. import caching, util +from ..constants import tol +from ..grouping import unique_rows +from ..resources import get_json +from ..typed import ( + ArrayLike, + Callable, + ColorMapType, + DTypeLike, + Integer, + Iterable, + NDArray, + Seed, +) +from .base import Visuals + +# Save a lookup table for an integer to match the +# cases for HSV conversion specified on the wikipedia article +# Where indexes 0=C, 1=X, 2=0.0 +_HSV_LOOKUP = np.array( + [[0, 1, 2], [1, 0, 2], [2, 0, 1], [2, 1, 0], [1, 2, 0], [0, 2, 1]], dtype=np.int64 +) +_HSV_LOOKUP.flags.writeable = False + + +class ColorVisuals(Visuals): + """ + Store color information about a mesh. + """ + + def __init__( + self, + mesh=None, + face_colors: ArrayLike | None = None, + vertex_colors: ArrayLike | None = None, + ): + """ + Store color information about a mesh. + + Parameters + ---------- + mesh : Trimesh + Object that these visual properties + are associated with + face_ colors : (n,3|4) or (3,) or (4,) uint8 + Colors per-face + vertex_colors : (n,3|4) or (3,) or (4,) uint8 + Colors per-vertex + """ + self.mesh = mesh + self._data = caching.DataStore() + self._cache = caching.Cache(id_function=self._data.__hash__) + + try: + if face_colors is not None: + self.face_colors = face_colors + if vertex_colors is not None: + self.vertex_colors = vertex_colors + except ValueError: + util.log.warning("unable to convert colors!") + + @caching.cache_decorator + def transparency(self) -> bool: + """ + Does the current object contain any transparency. + + Returns + ---------- + transparency: bool, does the current visual contain transparency + """ + if "vertex_colors" in self._data: + a_min = self._data["vertex_colors"][:, 3].min() + elif "face_colors" in self._data: + a_min = self._data["face_colors"][:, 3].min() + else: + return False + + return bool(a_min < 255) + + @property + def defined(self) -> bool: + """ + Are any colors defined for the current mesh. + + Returns + --------- + defined : bool + Are colors defined or not. + """ + return self.kind is not None + + @property + def kind(self) -> str | None: + """ + What color mode has been set. + + Returns + ---------- + mode : str or None + One of ('face', 'vertex', None) + """ + # if nothing is stored anywhere it's a safe bet mode is None + if not (len(self._cache.cache) > 0 or len(self._data.data) > 0): + return None + + self._verify_hash() + + # check modes in data + if "vertex_colors" in self._data: + return "vertex" + elif "face_colors" in self._data: + return "face" + + return None + + def __hash__(self): + return self._data.__hash__() + + def copy(self) -> "ColorVisuals": + """ + Return a copy of the current ColorVisuals object. + + + Returns + ---------- + copied : ColorVisuals + Contains the same information as self + """ + copied = ColorVisuals() + # call the literally insane generators to validate + self.face_colors # noqa + self.vertex_colors # noqa + # copy anything that's actually data + copied._data.data = copy.deepcopy(self._data.data) + + return copied + + @property + def face_colors(self) -> NDArray[np.uint8]: + """ + Colors defined for each face of a mesh. + + If no colors are defined, defaults are returned. + + Returns + ---------- + colors : (len(mesh.faces), 4) uint8 + RGBA color for each face + """ + return self._get_colors(name="face") + + @face_colors.setter + def face_colors(self, values: ArrayLike): + """ + Set the colors for each face of a mesh. + + This will apply these colors and delete any previously specified + color information. + + Parameters + ------------ + colors : (len(mesh.faces), 3), set each face to the specified color + (len(mesh.faces), 4), set each face to the specified color + (3,) int, set the whole mesh this color + (4,) int, set the whole mesh this color + """ + if values is None: + if "face_colors" in self._data: + self._data.data.pop("face_colors") + return + + colors = to_rgba(values) + + if self.mesh is not None and colors.shape == (4,): + count = len(self.mesh.faces) + colors = np.tile(colors, (count, 1)) + + # if we set any color information, clear the others + self._data.clear() + self._data["face_colors"] = colors + self._cache.verify() + + @property + def vertex_colors(self) -> NDArray[np.uint8]: + """ + Return the colors for each vertex of a mesh + + Returns + ------------ + colors: (len(mesh.vertices), 4) uint8, color for each vertex + """ + return self._get_colors(name="vertex") + + @vertex_colors.setter + def vertex_colors(self, values: ArrayLike): + """ + Set the colors for each vertex of a mesh + + This will apply these colors and delete any previously specified + color information. + + Parameters + ------------ + colors : (len(mesh.vertices), 3), set each face to the color + (len(mesh.vertices), 4), set each face to the color + (3,) int, set the whole mesh this color + (4,) int, set the whole mesh this color + """ + if values is None: + if "vertex_colors" in self._data: + self._data.data.pop("vertex_colors") + return + + # make sure passed values are numpy array + values = np.asanyarray(values) + # Ensure the color shape is sane + if self.mesh is not None and not ( + values.shape == (len(self.mesh.vertices), 3) + or values.shape == (len(self.mesh.vertices), 4) + or values.shape == (3,) + or values.shape == (4,) + ): + return + + colors = to_rgba(values) + if self.mesh is not None and colors.shape == (4,): + count = len(self.mesh.vertices) + colors = np.tile(colors, (count, 1)) + + # if we set any color information, clear the others + self._data.clear() + self._data["vertex_colors"] = colors + self._cache.verify() + + def _get_colors(self, name): + """ + A magical function which maintains the sanity of vertex and face colors. + + * If colors have been explicitly stored or changed, they are considered + user data, stored in self._data (DataStore), and are returned immediately + when requested. + * If colors have never been set, a (count,4) tiled copy of the default diffuse + color will be stored in the cache + ** the hash on creation for these cached default colors will also be stored + ** if the cached color array is altered (different hash than when it was + created) we consider that now to be user data and the array is moved from + the cache to the DataStore. + + Parameters + ----------- + name : str + Values 'face' or 'vertex' + + Returns + ----------- + colors : (count, 4) uint8 + RGBA colors + """ + + count = None + try: + if name == "face": + count = len(self.mesh.faces) + elif name == "vertex": + count = len(self.mesh.vertices) + except BaseException: + pass + + # the face or vertex colors + key_colors = str(name) + "_colors" + # the initial hash of the colors + key_hash = key_colors + "_hash" + + if key_colors in self._data: + # if a user has explicitly stored or changed the color it + # will be in data + return self._data[key_colors] + + elif key_colors in self._cache: + # if the colors have been autogenerated already they + # will be in the cache + colors = self._cache[key_colors] + # if the cached colors have been changed since creation we move + # them to data + if hash(colors) != self._cache[key_hash]: + # cached colors were mutated — promote to user data via + # the appropriate property setter + if name == "face": + self.face_colors = colors + elif name == "vertex": + self.vertex_colors = colors + else: + raise ValueError("unsupported name!!!") + self._cache.verify() + # return the stored copy of the colors + return self._data[key_colors] + # hashes match: colors are unmodified, return the cached object directly + return colors + else: + # colors have never been accessed + if self.kind is None: + # no colors are defined, so create a (count, 4) tiled + # copy of the default color + colors = np.tile(DEFAULT_MAT["material_diffuse"], (count, 1)) + elif self.kind == "vertex" and name == "face": + colors = vertex_to_face_color( + vertex_colors=self.vertex_colors, faces=self.mesh.faces + ) + elif self.kind == "face" and name == "vertex": + colors = face_to_vertex_color( + mesh=self.mesh, face_colors=self.face_colors + ) + else: + raise ValueError("self.kind not accepted values!!") + + if count is not None and colors.shape != (count, 4): + raise ValueError("face colors incorrect shape!") + + # subclass the array to track for changes using a hash + colors = caching.tracked_array(colors) + # put the generated colors and their initial checksum into cache + self._cache[key_colors] = colors + self._cache[key_hash] = hash(colors) + + return colors + + def _verify_hash(self): + """ + Verify the checksums of cached face and vertex color, to verify + that a user hasn't altered them since they were generated from + defaults. + + If the colors have been altered since creation, move them into + the DataStore at self._data since the user action has made them + user data. + """ + if not hasattr(self, "_cache") or len(self._cache) == 0: + return + + for name in ["face", "vertex"]: + # the face or vertex colors + key_colors = str(name) + "_colors" + # the initial hash of the colors + key_hash = key_colors + "_hash" + + if key_colors not in self._cache: + continue + + colors = self._cache[key_colors] + # if the cached colors have been changed since creation + # move them to data + if hash(colors) != self._cache[key_hash]: + if name == "face": + self.face_colors = colors + elif name == "vertex": + self.vertex_colors = colors + else: + raise ValueError("unsupported name!!!") + self._cache.verify() + + def update_vertices(self, mask: ArrayLike): + """ + Apply a mask to remove or duplicate vertex properties. + """ + self._update_key(mask, "vertex_colors") + + def update_faces(self, mask: ArrayLike): + """ + Apply a mask to remove or duplicate face properties + """ + self._update_key(mask, "face_colors") + + def face_subset(self, face_index: ArrayLike): + """ + Given a mask of face indices, return a sliced version. + + Parameters + ---------- + face_index: (n,) int, mask for faces + (n,) bool, mask for faces + + Returns + ---------- + visual: ColorVisuals object containing a subset of faces. + """ + kwargs = {} + if self.defined: + if self.face_colors is not None: + kwargs.update(face_colors=self.face_colors[face_index]) + + if self.vertex_colors is not None: + indices = np.unique(self.mesh.faces[face_index].flatten()) + vertex_colors = self.vertex_colors[indices] + kwargs.update(vertex_colors=vertex_colors) + + result = ColorVisuals(**kwargs) + + return result + + @property + def main_color(self) -> NDArray[np.uint8]: + """ + What is the most commonly occurring color. + + Returns + ------------ + color: (4,) uint8, most common color + """ + if self.kind is None: + return DEFAULT_COLOR + elif self.kind == "face": + colors = self.face_colors + elif self.kind == "vertex": + colors = self.vertex_colors + else: + raise ValueError("color kind incorrect!") + + # find the unique colors + unique, inverse = unique_rows(colors) + # the most commonly occurring color, or mode + # this will be an index of inverse, not colors + mode_index = np.bincount(inverse).argmax() + color = colors[unique[mode_index]] + + return color + + def to_texture(self): + """ + Convert the current ColorVisuals object to a texture + with a `SimpleMaterial` defined. + + Returns + ------------ + visual : trimesh.visual.TextureVisuals + Copy of the current visuals as a texture. + """ + from .texture import TextureVisuals + + mat, uv = color_to_uv(vertex_colors=self.vertex_colors) + return TextureVisuals(material=mat, uv=uv) + + def concatenate(self, other: Iterable[Visuals] | Visuals | ArrayLike, *args): + """ + Concatenate two or more ColorVisuals objects + into a single object. + + Parameters + ----------- + other : ColorVisuals + Object to append + *args: ColorVisuals objects + + Returns + ----------- + result : ColorVisuals + Containing information from current + object and others in the order it was passed. + """ + # avoid a circular import + from . import objects + + result = objects.concatenate(self, other, *args) + return result + + def _update_key(self, mask, key): + """ + Mask the value contained in the DataStore at a specified key. + + Parameters + ----------- + mask: (n,) int + (n,) bool + key: hashable object, in self._data + """ + mask = np.asanyarray(mask) + if key in self._data: + self._data[key] = self._data[key][mask] + + +class VertexColor(Visuals): + """ + Create a simple visual object to hold just vertex colors + for objects such as PointClouds. + """ + + def __init__(self, colors=None, obj=None): + """ + Create a vertex color visual + """ + self.obj = obj + self.vertex_colors = colors + + @property + def kind(self): + return "vertex" + + def update_vertices(self, mask): + if self._colors is not None: + self._colors = self._colors[mask] + + def update_faces(self, mask): + pass + + @property + def vertex_colors(self): + return self._colors + + @vertex_colors.setter + def vertex_colors(self, data): + if data is None: + self._colors = caching.tracked_array(None) + else: + # tile single color into color array + data = np.asanyarray(data) + if data.shape in [(3,), (4,)]: + data = np.tile(data, (len(self.obj.vertices), 1)) + # track changes in colors and convert to RGBA + self._colors = caching.tracked_array(to_rgba(data)) + + def copy(self): + """ + Return a copy of the current visuals + """ + return copy.deepcopy(self) + + def concatenate(self, other): + """ + Concatenate this visual object with another + VertexVisuals. + + Parameters + ----------- + other : VertexColors or ColorVisuals + Other object to concatenate + + Returns + ------------ + concate : VertexColor + Object with both colors + """ + return VertexColor(colors=np.vstack(self.vertex_colors, other.vertex_colors)) + + def __hash__(self): + return self._colors.__hash__() + + +def to_rgba(colors: Any, dtype: DTypeLike = np.uint8) -> NDArray: + """ + Convert a single or multiple RGB colors to RGBA colors. + + Parameters + ---------- + colors : (n, 3) or (n, 4) array + RGB or RGBA colors or None + + Returns + ---------- + colors : (n, 4) list of RGBA colors + (4,) single RGBA color + """ + if colors is None: + return DEFAULT_COLOR + # if MTL uses 0 as None + if isinstance(colors, (int, float)) and colors == 0: + return DEFAULT_COLOR + + # colors as numpy array + colors = np.asanyarray(colors) + dtype = np.dtype(dtype) + + # what is the output dtype opaque value + if dtype.kind in "iu": + opaque = np.iinfo(dtype).max + elif dtype.kind == "f": + opaque = 1.0 + else: + raise ValueError(f"Unknown dtype: `{dtype}`") + + if colors.dtype.kind == "f": + # replace any `nan` or `inf` values with zero + colors[~np.isfinite(colors)] = 0.0 + + # multiple the 0.0 - 1.0 colors by the opaque value + # to scale them to the output data type's proper range + colors = np.clip(colors * opaque, 0.0, opaque) + + # if the requested output type is integer-like + # make sure to round the multiplied floats + # before the `astype` on the return + if dtype.kind in "iu": + colors = colors.round() + + if util.is_shape(colors, (-1, 3)): + # add an opaque alpha for RGB colors + colors = np.column_stack((colors, opaque * np.ones(len(colors)))) + elif util.is_shape(colors, (3,)): + # if passed a single RGB color add an alpha + colors = np.append(colors, opaque) + if not (util.is_shape(colors, (4,)) or util.is_shape(colors, (-1, 4))): + raise ValueError("Colors not of appropriate shape!") + + return colors.astype(dtype) + + +def to_float(colors: ArrayLike) -> NDArray[np.float64]: + """ + Convert integer colors to 0.0-1.0 floating point colors + + Parameters + ------------- + colors : (n, d) int + Integer colors + + Returns + ------------- + as_float : (n, d) float + Float colors 0.0 - 1.0 + """ + + # colors as numpy array + colors = np.asanyarray(colors) + if colors.dtype.kind == "f": + return colors.astype(np.float64) + elif colors.dtype.kind in "iu": + # integer value for opaque alpha given our datatype + opaque = np.iinfo(colors.dtype).max + return colors.astype(np.float64) / opaque + else: + raise ValueError("only works on int or float colors!") + + +def hex_to_rgba(color: str) -> NDArray[np.uint8]: + """ + Turn a string hex color to a (4,) RGBA color. + + Parameters + ----------- + color: str, hex color + + Returns + ----------- + rgba: (4,) np.uint8, RGBA color + """ + value = str(color).lstrip("#").strip() + if len(value) == 6: + rgb = [int(value[i : i + 2], 16) for i in (0, 2, 4)] + rgba = np.append(rgb, 255).astype(np.uint8) + else: + raise ValueError("Only RGB supported") + + return rgba + + +def hsv_to_rgba(hsv: ArrayLike, dtype: DTypeLike = np.uint8) -> NDArray: + """ + Convert an (n, 3) array of 0.0-1.0 HSV colors into an + array of RGBA colors. + + A vectorized implementation that matches `colorsys.hsv_to_rgb`. + + Parameters + ----------- + hsv + Should be `(n, 3)` array of 0.0-1.0 values. + + Returns + ------------ + rgba + An (n, 4) array of RGBA colors. + """ + + hsv = np.asanyarray(hsv, dtype=np.float64) + if len(hsv.shape) != 2 or hsv.shape[1] != 3: + raise ValueError("(n, 3) values of HSV are required") + # clip values in-place to 0.0-1.0 range + np.clip(hsv, a_min=0.0, a_max=1.0, out=hsv) + + # expand into flat arrays for each of + # hue, saturation, and value + H, S, V = hsv.T + + # chroma and other values for the equation + C = S * V + Hi = H * 6.0 + X = C * (1.0 - np.abs((Hi % 2.0) - 1.0)) + + # stack values we need so we can access them with the lookup table + stacked = np.column_stack((C, X, np.zeros_like(X))) + # get the indexes per-row and then increment them so we can use them on the stack + indexes = _HSV_LOOKUP[Hi.astype(np.int64)] + (np.arange(len(H)) * 3).reshape((-1, 1)) + + # get the intermediate value, described by wikipedia as + # the point along the bottom three faces of the RGB cube + RGBi = stacked.ravel()[indexes] + + # stack it into the final RGBA array + RGBA = np.column_stack((RGBi + (V - C).reshape((-1, 1)), np.ones(len(H)))) + + # now return the correct type of color + dtype = np.dtype(dtype) + if dtype.kind == "f": + return RGBA.astype(dtype) + elif dtype.kind in "iu": + return (RGBA * np.iinfo(dtype).max).round().astype(dtype) + + raise ValueError(f"dtype `{dtype}` not supported") + + +def linear_to_srgb(linear: ArrayLike) -> NDArray[np.float64]: + """ + Converts linear color values to sRGB color values. + + See: https://entropymine.com/imageworsener/srgbformula/ + + Parameters + ---------- + linear + Linear color values of any shape since this + is a per-element transformation + + Returns + --------- + srgb + Values scaled to an sRGB scale. + """ + linear = to_float(linear) + + mask = linear > 0.00313066844250063 + srgb = np.zeros(linear.shape, dtype=np.float64) + srgb[mask] = 1.055 * np.power(linear[mask], (1.0 / 2.4)) - 0.055 + srgb[~mask] = 12.92 * linear[~mask] + + return srgb + + +def srgb_to_linear(srgb: ArrayLike) -> NDArray[np.float64]: + """ + Converts sRGB color values to linear color values. + See: https://entropymine.com/imageworsener/srgbformula/ + """ + + # make sure the color values are floating point scaled + srgb = to_float(srgb) + + mask = srgb <= 0.0404482362771082 + linear = np.zeros(srgb.shape, dtype=np.float64) + linear[mask] = srgb[mask] / 12.92 + linear[~mask] = np.power(((srgb[~mask] + 0.055) / 1.055), 2.4) + + return linear + + +def random_color( + dtype: DTypeLike = np.uint8, + count: Integer | None = None, + seed: Seed = None, +) -> NDArray: + """ + Return a random RGB color using datatype specified. + + Parameters + ---------- + dtype + Color type of result. + count + If passed return (count, 4) colors instead of + a single (4,) color. + seed + Seed for deterministic results, otherwise OS entropy. + + Returns + ---------- + color : (4,) or (count, 4) + Random color or colors that look "OK" + """ + # generate a random hue + hue = (util.random_generator(seed).random(count or 1) + 0.61803) % 1.0 + + # saturation and "value" as constant + sv = np.ones_like(hue) * 0.99 + # convert our random hue to RGBA + colors = hsv_to_rgba(np.column_stack((hue, sv, sv)), dtype=dtype) + + # unspecified count is a single color + if count is None: + return colors[0] + return colors + + +def vertex_to_face_color(vertex_colors: ArrayLike, faces: ArrayLike) -> NDArray[np.uint8]: + """ + Convert a list of vertex colors to face colors. + + Parameters + ---------- + vertex_colors: (n,(3,4)), colors + faces: (m,3) int, face indexes + + Returns + ----------- + face_colors: (m,4) colors + """ + vertex_colors = to_rgba(vertex_colors) + face_colors = vertex_colors[faces].mean(axis=1) + return face_colors.astype(np.uint8) + + +def face_to_vertex_color( + mesh, face_colors: ArrayLike, dtype: DTypeLike = np.uint8 +) -> NDArray: + """ + Convert face colors into vertex colors. + + Parameters + ----------- + mesh : trimesh.Trimesh + Mesh to convert colors for + face_colors : `(len(mesh.faces), (3 | 4))` int + The colors for each face of the mesh + dtype + What should colors be returned in. + + Returns + ----------- + vertex_colors : `(len(mesh.vertices), 4)` + Color for each vertex + """ + rgba = to_rgba(face_colors) + vertex = mesh.faces_sparse.dot(rgba.astype(np.float64)) + degree = mesh.vertex_degree + + # normalize color by the number of faces including + # the vertex (i.e. the vertex degree) + nonzero = degree > 0 + vertex[nonzero] /= degree[nonzero].reshape((-1, 1)) + + assert vertex.shape == (len(mesh.vertices), 4) + + return vertex.astype(dtype) + + +def colors_to_materials(colors: ArrayLike, count: Integer | None = None): + """ + Convert a list of colors into a list of unique materials + and material indexes. + + Parameters + ----------- + colors : (n, 3) or (n, 4) float + RGB or RGBA colors + count : int + Number of entities to apply color to + + Returns + ----------- + diffuse : (m, 4) int + Colors + index : (count,) int + Index of each color + """ + + # convert RGB to RGBA + rgba = to_rgba(colors) + + # if we were only passed a single color + if util.is_shape(rgba, (4,)) and count is not None: + diffuse = rgba.reshape((-1, 4)) + index = np.zeros(count, dtype=np.int64) + elif util.is_shape(rgba, (-1, 4)): + # we were passed multiple colors + # find the unique colors in the list to save as materials + unique, index = unique_rows(rgba) + diffuse = rgba[unique] + else: + raise ValueError("Colors not convertible!") + + return diffuse, index + + +def linear_color_map(values: ArrayLike, color_range: ArrayLike | None = None) -> NDArray: + """ + Linearly interpolate a color lookup table from normalized + values. + + For example if `color_range` has two values [`a`, `b`] + `values` is `[0.0, 0.5, 1.0]`, this function will return + [`a`, `(a+b)/2`, `b`]. + + The default value for `color_range` is red-green, or you + can pass in a full lookup table for a color map, i.e. a + `(256, 3) float64` array of RGB colors such as our defaults: + `trimesh.resources.get_json('color_map.json.gzip')['viridis']` + + Parameters + -------------- + values : (n, ) float + Normalized to 0.0-1.0 values to interpolate + color_range : None or (n, 3|4) + Evenly spaced colors to interpolate through + where `n >= 2`. + + Returns + --------------- + colors : (n, 4) color_range.dtype + RGBA colors for interpolated values + """ + + if color_range is None: + # do a very unimaginative "red to green" linear scale + color_range = np.array([[255, 0, 0, 255], [0, 255, 0, 255]], dtype=np.uint8) + else: + # make sure we have a numpy array + color_range = np.asanyarray(color_range) + + # do simple checks on the color range shape + if color_range.shape[0] < 2 or color_range.shape[1] < 3: + raise ValueError( + "color_range must be RGBA convertible and have more than 2 values!" + ) + + # float 1D array clamped to 0.0 - 1.0 + values = np.clip(np.asanyarray(values, dtype=np.float64).ravel(), 0.0, 1.0).reshape( + (-1, 1) + ) + + # what is the maximum index of our colors + max_index = len(color_range) - 1 + # convert our normalized values into a fractional index + index = values.ravel() * max_index + + # get the left and right indexes + # clipping should be a no-op based on above normalization but + # be extra sure ceil isn't pushing us out of our array range + bounds = np.clip( + np.column_stack((np.floor(index), np.ceil(index))), 0.0, max_index + ).astype(np.int64) + + # get the factor of how far each point is between `bounds` pair + factor = index - bounds[:, 0] + + # reshape the factor into an interpolation + multiplier = np.column_stack((1.0 - factor, factor)).reshape((-1, 2, 1)) + + # get both colors, multiply them by the interpolation multiplier, and sum + interpolated = (color_range.astype(np.float64)[bounds] * multiplier).sum(axis=1) + + # if we're returning integers make sure to round first + if color_range.dtype.kind in "iu": + return interpolated.round().astype(color_range.dtype) + + return interpolated.astype(color_range.dtype) + + +def interpolate( + values: ArrayLike, + color_map: ColorMapType | Callable | None = None, + dtype: DTypeLike = np.uint8, +) -> NDArray: + """ + Given a 1D list of values, return interpolated colors + for the range. + + Parameters + --------------- + values : (n, ) float + Values to be interpolated over + color_map + One of the four included color maps: + ("viridis", "inferno", "plasma", "magma") + Or a function, `matplotlib.pyplot.get_cmap + + + Returns + ------------- + interpolated : (n, 4) dtype + Interpolated RGBA colors + """ + + # make `viridis` the default just like everyone else + if color_map is None: + color_map = "viridis" + + if callable(color_map): + # should be a `matplotlib.pyplot.get_cmap` callable + cmap = color_map + elif isinstance(color_map, str): + # color map is a named key in our packaged color maps + available = get_json("color_map.json.gzip") + if color_map not in available: + # we could have added a fallback to matplotlib: + # `from matplotlib.pyplot import get_cmap; cmap = get_cmap(name)` + # but we don't want trimesh to depend on matplotlib as it is quite heavy + raise ValueError( + f"Included color maps are: {available.keys()}.\n\n" + + "If you want to use a `matplotlib` color map you can " + + "pass it as `color_map=matplotlib.pyplot.get_cmap(name)`" + ) + + # pass in the retrieved color map values to linear_color_map + def cmap(x): + return linear_color_map(x, np.array(available[color_map])) + else: + raise TypeError(f"Unknown color map: `{type(color_map)}`") + + # make input always float + values = np.asanyarray(values, dtype=np.float64).ravel() + + # get both minumium and maximum values for range normalization + v_min, v_max = values.min(), values.max() + # offset to zero + values -= v_min + # normalize to the 0.0 - 1.0 range + if v_min != v_max: + values /= v_max - v_min + + # scale values to 0.0 - 1.0 and get colors + colors = cmap(values) + + # convert to 0-255 RGBA + rgba = to_rgba(colors, dtype=dtype) + + return rgba + + +def uv_to_color(uv, image) -> NDArray[np.uint8]: + """ + Get the color in a texture image. + + Parameters + ------------- + uv : (n, 2) float + UV coordinates on texture image + image : PIL.Image + Texture image + + Returns + ---------- + colors : (n, 4) uint4 + RGBA color at each of the UV coordinates + """ + if image is None or uv is None: + return None + + # UV coordinates should be (n, 2) float + uv = np.asanyarray(uv, dtype=np.float64) + + # get texture image pixel positions of UV coordinates + x = (uv[:, 0] * (image.width - 1)) % image.width + y = ((1 - uv[:, 1]) * (image.height - 1)) % image.height + + # access colors from pixel locations + # make sure image is RGBA before getting values + colors = np.asanyarray(image.convert("RGBA"))[ + y.round().astype(np.int64) % image.height, + x.round().astype(np.int64) % image.width, + ] + + # conversion to RGBA should have corrected shape + assert colors.ndim == 2 and colors.shape[1] == 4 + assert colors.dtype == np.uint8 + + return colors + + +def uv_to_interpolated_color(uv: ArrayLike, image) -> NDArray[np.uint8]: + """ + Get the color from texture image using bilinear sampling. + + Parameters + ------------- + uv : (n, 2) float + UV coordinates on texture image + image : PIL.Image + Texture image + + Returns + ---------- + colors : (n, 4) uint8 + RGBA color at each of the UV coordinates. + """ + if image is None or uv is None: + return None + + # UV coordinates should be (n, 2) float + uv = np.asanyarray(uv, dtype=np.float64) + + # get texture image pixel positions of UV coordinates + x = uv[:, 0] * (image.width - 1) + y = (1 - uv[:, 1]) * (image.height - 1) + + x_floor = np.floor(x).astype(np.int64) % image.width + y_floor = np.floor(y).astype(np.int64) % image.height + + x_ceil = np.ceil(x).astype(np.int64) % image.width + y_ceil = np.ceil(y).astype(np.int64) % image.height + + dx = x % image.width - x_floor + dy = y % image.height - y_floor + + img = np.asanyarray(image.convert("RGBA")) + + colors00 = img[y_floor, x_floor] + colors01 = img[y_floor, x_ceil] + colors10 = img[y_ceil, x_floor] + colors11 = img[y_ceil, x_ceil] + + a00 = (1 - dx) * (1 - dy) + a01 = dx * (1 - dy) + a10 = (1 - dx) * dy + a11 = dx * dy + + a00 = np.repeat(a00[:, None], 4, axis=1) + a01 = np.repeat(a01[:, None], 4, axis=1) + a10 = np.repeat(a10[:, None], 4, axis=1) + a11 = np.repeat(a11[:, None], 4, axis=1) + + # interpolated colors as floating point then convert back to uint8 + colors = ( + (a00 * colors00 + a01 * colors01 + a10 * colors10 + a11 * colors11) + .round() + .astype(np.uint8) + ) + + # conversion to RGBA should have corrected shape + assert colors.ndim == 2 and colors.shape[1] == 4 + assert colors.dtype == np.uint8 + + return colors + + +def color_to_uv(vertex_colors: ArrayLike): + """ + Pack vertex colors into UV coordinates and a simple image material + + Parameters + ------------ + vertex_colors : (n, 4) float + Array of vertex colors. + + Returns + ------------ + material : SimpleMaterial + Material containing color information. + uv : (n, 2) float + Normalized UV coordinates + """ + from .material import SimpleMaterial, empty_material + + # deduplicate the vertex colors + unique, inverse = unique_rows(vertex_colors) + + # if there is only one color return a + if len(unique) == 1: + # return a simple single-pixel material + material = empty_material(color=vertex_colors[unique[0]]) + uvs = np.zeros((len(vertex_colors), 2)) + 0.5 + return material, uvs + + from PIL import Image + + # return a square image of (size, size) + size = int(np.ceil(np.sqrt(len(unique)))) + ctype = vertex_colors.shape[1] + + colors = np.zeros((size**2, ctype), dtype=vertex_colors.dtype) + colors[: len(unique)] = vertex_colors[unique] + + # PIL has reversed x-y coordinates + image = Image.fromarray(colors.reshape((size, size, ctype))[::-1]) + + pos = np.arange(len(unique)) + # create tiled coordinates for the color pixels + coords = np.column_stack((pos % size, np.floor(pos / size))) + + # normalize the index coords into 0.0 - 1.0 + # and offset them to be centered on the pixel + coords = (coords / size) + (1.0 / (size * 2.0)) + uvs = coords[inverse] + + if tol.strict: + # check the packed colors against the image + check = uv_to_color(image=image, uv=uvs) + assert np.all(check == vertex_colors) + + return SimpleMaterial(image=image), uvs + + +# set an arbitrary grey as the default color +DEFAULT_COLOR = np.array([102, 102, 102, 255], dtype=np.uint8) +DEFAULT_MAT = { + "material_diffuse": np.array([102, 102, 102, 255], dtype=np.uint8), + "material_ambient": np.array([64, 64, 64, 255], dtype=np.uint8), + "material_specular": np.array([197, 197, 197, 255], dtype=np.uint8), + "material_shine": 77.0, +} diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/gloss.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/gloss.py new file mode 100644 index 0000000000000000000000000000000000000000..36d86939156a56d76722c46109eb5a587019e6f2 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/gloss.py @@ -0,0 +1,351 @@ +import numpy as np + +from ..constants import log +from ..exceptions import ExceptionWrapper +from ..typed import ArrayLike, Number +from .color import linear_to_srgb, srgb_to_linear + +try: + from PIL.Image import Image, fromarray +except BaseException as E: + Image = ExceptionWrapper(E) + fromarray = ExceptionWrapper(E) + + +def specular_to_pbr( + specularFactor: ArrayLike | None = None, + glossinessFactor: Number | None = None, + specularGlossinessTexture: "Image | None" = None, + diffuseTexture: "Image | None" = None, + diffuseFactor: ArrayLike | None = None, + **kwargs, +) -> dict: + """ + Convert the KHR_materials_pbrSpecularGlossiness to a + metallicRoughness visual. + + Parameters + ----------- + specularFactor : list[float] + Specular color values. Ignored if specularGlossinessTexture + is present and defaults to [1.0, 1.0, 1.0]. + glossinessFactor : float + glossiness factor in range [0, 1], scaled + specularGlossinessTexture if present. + Defaults to 1.0. + specularGlossinessTexture : PIL.Image + Texture with 4 color channels. With [0,1,2] representing + specular RGB and 3 glossiness. + diffuseTexture : PIL.Image + Texture with 4 color channels. With [0,1,2] representing diffuse + RGB and 3 opacity. + diffuseFactor: float + Diffuse RGBA color. scales diffuseTexture if present. + Defaults to [1.0, 1.0, 1.0, 1.0]. + + Returns + ---------- + kwargs : dict + Constructor args for a PBRMaterial object. + Containing: + - either baseColorTexture or baseColorFactor + - either metallicRoughnessTexture or metallicFactor and roughnessFactor + """ + # based on: + # https://github.com/KhronosGroup/glTF/blob/89427b26fcac884385a2e6d5803d917ab5d1b04f/extensions/2.0/Archived/KHR_materials_pbrSpecularGlossiness/examples/convert-between-workflows-bjs/js/babylon.pbrUtilities.js#L33-L64 + + if isinstance(Image, ExceptionWrapper): + log.debug("unable to convert specular-glossy material without pillow!") + result = {} + if isinstance(diffuseTexture, dict): + result["baseColorTexture"] = diffuseTexture + if diffuseFactor is not None: + result["baseColorFactor"] = diffuseFactor + return result + + dielectric_specular = np.array([0.04, 0.04, 0.04], dtype=np.float32) + epsilon = 1e-6 + + def solve_metallic(diffuse, specular, one_minus_specular_strength): + if isinstance(specular, float) and specular < dielectric_specular[0]: + return 0.0 + + if len(diffuse.shape) == 2: + diffuse = diffuse[..., None] + if len(specular.shape) == 2: + specular = specular[..., None] + + a = dielectric_specular[0] + b = ( + diffuse * one_minus_specular_strength / (1.0 - dielectric_specular[0]) + + specular + - 2.0 * dielectric_specular[0] + ) + c = dielectric_specular[0] - specular + D = b * b - 4.0 * a * c + D = np.clip(D, epsilon, None) + metallic = np.clip((-b + np.sqrt(D)) / (2.0 * a), 0.0, 1.0) + if isinstance(metallic, np.ndarray): + metallic[specular < dielectric_specular[0]] = 0.0 + return metallic + + def get_perceived_brightness(rgb): + return np.sqrt(np.dot(rgb[..., :3] ** 2, [0.299, 0.587, 0.114])) + + def toPIL(img, mode=None): + if isinstance(img, Image): + return img + if img.dtype == np.float32 or img.dtype == np.float64: + img = (np.clip(img, 0.0, 1.0) * 255.0).astype(np.uint8) + return fromarray(img) + + def get_float(val): + if isinstance(val, float): + return val + if isinstance(val, np.ndarray) and len(val.shape) == 1: + return val[0] + return val.tolist() + + def get_diffuse(diffuseFactor, diffuseTexture): + diffuseFactor = ( + diffuseFactor if diffuseFactor is not None else [1.0, 1.0, 1.0, 1.0] + ) + diffuseFactor = np.array(diffuseFactor, dtype=np.float32) + + if diffuseTexture is not None: + if diffuseTexture.mode == "BGR": + diffuseTexture = diffuseTexture.convert("RGB") + elif diffuseTexture.mode == "BGRA": + diffuseTexture = diffuseTexture.convert("RGBA") + + diffuse = np.array(diffuseTexture) / 255.0 + # diffuseFactor must be applied to linear scaled colors . + # Sometimes, diffuse texture is only 2 channels, how do we know + # if they are encoded sRGB or linear? + diffuse = convert_texture_srgb2lin(diffuse) + + if len(diffuse.shape) == 2: + diffuse = diffuse[..., None] + if diffuse.shape[-1] == 1: + diffuse = diffuse * diffuseFactor + elif diffuse.shape[-1] == 2: + alpha = diffuse[..., 1:2] + diffuse = diffuse[..., :1] * diffuseFactor + if diffuseFactor.shape[-1] == 3: + # this should actually not happen, but it seems like many materials are not complying with the spec + diffuse = np.concatenate([diffuse, alpha], axis=-1) + else: + diffuse[..., -1:] *= alpha + elif diffuse.shape[-1] == diffuseFactor.shape[-1]: + diffuse = diffuse * diffuseFactor + elif diffuse.shape[-1] == 3 and diffuseFactor.shape[-1] == 4: + diffuse = ( + np.concatenate([diffuse, np.ones_like(diffuse[..., :1])], axis=-1) + * diffuseFactor + ) + else: + log.warning( + "`diffuseFactor` and `diffuseTexture` have incompatible shapes: " + + f"{diffuseFactor.shape} and {diffuse.shape}" + ) + else: + diffuse = diffuseFactor if diffuseFactor is not None else [1, 1, 1, 1] + diffuse = np.array(diffuse, dtype=np.float32) + return diffuse + + def get_specular_glossiness( + specularFactor, glossinessFactor, specularGlossinessTexture + ): + if specularFactor is None: + specularFactor = [1.0, 1.0, 1.0] + specularFactor = np.array(specularFactor, dtype=np.float32) + if glossinessFactor is None: + glossinessFactor = 1.0 + glossinessFactor = np.array([glossinessFactor], dtype=np.float32) + + # specularGlossinessTexture should be a texture with 4 channels, + # 3 sRGB channels for specular and 1 linear channel for glossiness. + # in practice, it can also have just 1, 2, or 3 channels which are then to + # be multiplied with the provided factors + + if specularGlossinessTexture is not None: + if specularGlossinessTexture.mode == "BGR": + specularGlossinessTexture = specularGlossinessTexture.convert("RGB") + elif specularGlossinessTexture.mode == "BGRA": + specularGlossinessTexture = specularGlossinessTexture.convert("RGBA") + + specularGlossinessTexture = np.array(specularGlossinessTexture) / 255.0 + specularTexture, glossinessTexture = None, None + + if len(specularGlossinessTexture.shape) == 2: + # use the one channel as a multiplier for specular and glossiness + specularTexture = glossinessTexture = specularGlossinessTexture.reshape( + specularGlossinessTexture.shape[0], + specularGlossinessTexture.shape[1], + 1, + ) + elif specularGlossinessTexture.shape[-1] == 1: + # use the one channel as a multiplier for specular and glossiness + specularTexture = glossinessTexture = specularGlossinessTexture[ + ..., np.newaxis + ] + elif specularGlossinessTexture.shape[-1] == 3: + # all channels are specular, glossiness is only a factor + specularTexture = specularGlossinessTexture[..., :3] + elif specularGlossinessTexture.shape[-1] == 2: + # first channel is specular, last channel is glossiness + specularTexture = specularGlossinessTexture[..., :1] + glossinessTexture = specularGlossinessTexture[..., 1:2] + elif specularGlossinessTexture.shape[-1] == 4: + # first 3 channels are specular, last channel is glossiness + specularTexture = specularGlossinessTexture[..., :3] + glossinessTexture = specularGlossinessTexture[..., 3:] + + if specularTexture is not None: + # specular texture channels are sRGB + specularTexture = convert_texture_srgb2lin(specularTexture) + specular = specularTexture * specularFactor + else: + specular = specularFactor + + if glossinessTexture is not None: + # glossiness texture channel is linear + glossiness = glossinessTexture * glossinessFactor + else: + glossiness = glossinessFactor + + one_minus_specular_strength = 1.0 - np.max(specular, axis=-1, keepdims=True) + else: + specular = specularFactor if specularFactor is not None else [1.0, 1.0, 1.0] + specular = np.array(specular, dtype=np.float32) + glossiness = glossinessFactor if glossinessFactor is not None else 1.0 + glossiness = np.array(glossiness, dtype=np.float32) + one_minus_specular_strength = 1.0 - max(specular[:3]) + + return specular, glossiness, one_minus_specular_strength + + if diffuseTexture is not None and specularGlossinessTexture is not None: + # reshape to the size of the largest texture + max_shape = tuple( + max(diffuseTexture.size[i], specularGlossinessTexture.size[i]) + for i in range(2) + ) + if ( + diffuseTexture.size[0] != max_shape[0] + or diffuseTexture.size[1] != max_shape[1] + ): + diffuseTexture = diffuseTexture.resize(max_shape) + if ( + specularGlossinessTexture.size[0] != max_shape[0] + or specularGlossinessTexture.size[1] != max_shape[1] + ): + specularGlossinessTexture = specularGlossinessTexture.resize(max_shape) + + def convert_texture_srgb2lin(texture): + """ + Wrapper for srgb2lin that converts color values from sRGB to linear. + If texture has 2 or 4 channels, the last channel (alpha) is left unchanged. + """ + result = texture.copy() + color_channels = result.shape[-1] + # only scale the color channels, not the alpha channel + if color_channels == 4 or color_channels == 2: + color_channels -= 1 + result[..., :color_channels] = srgb_to_linear(result[..., :color_channels]) + return result + + def convert_texture_lin2srgb(texture): + """ + Wrapper for lin2srgb that converts color values from linear to sRGB. + If texture has 2 or 4 channels, the last channel (alpha) is left unchanged. + """ + + result = texture.copy() + color_channels = result.shape[-1] + # only scale the color channels, not the alpha channel + if color_channels == 4 or color_channels == 2: + color_channels -= 1 + result[..., :color_channels] = linear_to_srgb(result[..., :color_channels]) + return result + + diffuse = get_diffuse(diffuseFactor, diffuseTexture) + specular, glossiness, one_minus_specular_strength = get_specular_glossiness( + specularFactor, glossinessFactor, specularGlossinessTexture + ) + + metallic = solve_metallic( + get_perceived_brightness(diffuse), + get_perceived_brightness(specular), + one_minus_specular_strength, + ) + if not isinstance(metallic, np.ndarray): + metallic = np.array(metallic, dtype=np.float32) + + diffuse_rgb = diffuse[..., :3] + + base_color_from_diffuse = diffuse_rgb * ( + one_minus_specular_strength + / (1.0 - dielectric_specular[0]) + / np.clip((1.0 - metallic), epsilon, None) + ) + base_color_from_specular = (specular - dielectric_specular * (1.0 - metallic)) * ( + 1.0 / np.clip(metallic, epsilon, None) + ) + mm = metallic * metallic + base_color = mm * base_color_from_specular + (1.0 - mm) * base_color_from_diffuse + base_color = np.clip(base_color, 0.0, 1.0) + + # get opacity + try: + if diffuse.shape == (4,): + # opacity is a single scalar value + opacity = diffuse[-1] + if base_color.shape == (3,): + # simple case with one color and diffuse with opacity + # add on the opacity from the diffuse color + base_color = np.append(base_color, opacity) + elif len(base_color.shape) == 3: + # stack opacity to match the base color array + dim = base_color.shape + base_color = np.dstack( + ( + base_color, + np.full(np.prod(dim[:2]), opacity).reshape((dim[0], dim[1], 1)), + ) + ) + elif diffuse.shape[-1] == 4: + opacity = diffuse[..., -1] + base_color = np.concatenate([base_color, opacity[..., None]], axis=-1) + except BaseException: + log.error("unable to get opacity", exc_info=True) + + result = {} + if len(base_color.shape) > 1: + # convert back to sRGB + result["baseColorTexture"] = toPIL( + convert_texture_lin2srgb(base_color), + mode=("RGB" if base_color.shape[-1] == 3 else "RGBA"), + ) + else: + result["baseColorFactor"] = base_color.tolist() + + if len(metallic.shape) > 1 or len(glossiness.shape) > 1: + if len(glossiness.shape) == 1: + glossiness = np.tile(glossiness, (metallic.shape[0], metallic.shape[1], 1)) + if len(metallic.shape) == 1: + metallic = np.tile(metallic, (glossiness.shape[0], glossiness.shape[1], 1)) + + # we need to use RGB textures, because 2 channel textures can cause problems + result["metallicRoughnessTexture"] = toPIL( + np.concatenate( + [np.zeros_like(metallic), 1.0 - glossiness, metallic], axis=-1 + ), + mode="RGB", + ) + result["metallicFactor"] = 1.0 + result["roughnessFactor"] = 1.0 + else: + result["metallicFactor"] = get_float(metallic) + result["roughnessFactor"] = get_float(1.0 - glossiness) + + return result diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/material.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/material.py new file mode 100644 index 0000000000000000000000000000000000000000..3a94dd739bbaf13641e7f3a07a2a6489786fea5b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/material.py @@ -0,0 +1,1144 @@ +""" +material.py +------------- + +Store visual materials as objects. +""" + +import abc +import copy + +import numpy as np + +from .. import exceptions, util +from ..constants import tol +from ..typed import NDArray +from . import color + +try: + from PIL import Image +except BaseException as E: + Image = exceptions.ExceptionWrapper(E) + +# epsilon for comparing floating point +_eps = 1e-5 + + +class Material(util.ABC): + def __init__(self, *args, **kwargs): + raise NotImplementedError("must be subclassed!") + + @abc.abstractmethod + def __hash__(self): + raise NotImplementedError("must be subclassed!") + + @property + @abc.abstractmethod + def main_color(self): + """ + The "average" color of this material. + + Returns + --------- + color : (4,) uint8 + Average color of this material. + """ + + @property + def name(self): + if hasattr(self, "_name"): + return self._name + return "material_0" + + @name.setter + def name(self, value): + if value is not None: + self._name = value + + def copy(self): + return copy.deepcopy(self) + + +class SimpleMaterial(Material): + """ + Hold a single image texture. + """ + + def __init__( + self, + image=None, + diffuse=None, + ambient=None, + specular=None, + glossiness=None, + name=None, + **kwargs, + ): + # save image + self.image = image + self.name = name + # save material colors as RGBA + self.ambient = color.to_rgba(ambient) + self.diffuse = color.to_rgba(diffuse) + self.specular = color.to_rgba(specular) + + # save Ns + self.glossiness = glossiness + + # save other keyword arguments + self.kwargs = kwargs + + def to_color(self, uv): + return color.uv_to_color(uv, self.image) + + def to_obj(self, name=None): + """ + Convert the current material to an OBJ format + material. + + Parameters + ----------- + name : str or None + Name to apply to the material + + Returns + ----------- + tex_name : str + Name of material + mtl_name : str + Name of mtl file in files + files : dict + Data as {file name : bytes} + """ + # material parameters as 0.0-1.0 RGB + Ka = color.to_float(self.ambient)[:3] + Kd = color.to_float(self.diffuse)[:3] + Ks = color.to_float(self.specular)[:3] + + if name is None: + name = self.name + + # create an MTL file + mtl = [ + f"newmtl {name}", + "Ka {:0.8f} {:0.8f} {:0.8f}".format(*Ka), + "Kd {:0.8f} {:0.8f} {:0.8f}".format(*Kd), + "Ks {:0.8f} {:0.8f} {:0.8f}".format(*Ks), + f"Ns {self.glossiness:0.8f}", + ] + + # collect the OBJ data into files + data = {} + + if self.image is not None: + image_type = self.image.format + # what is the name of the export image to save + if image_type is None: + image_type = "png" + image_name = f"{name}.{image_type.lower()}" + # save the reference to the image + mtl.append(f"map_Kd {image_name}") + + # save the image texture as bytes in the original format + f_obj = util.BytesIO() + self.image.save(fp=f_obj, format=image_type) + f_obj.seek(0) + data[image_name] = f_obj.read() + + data[f"{name}.mtl"] = "\n".join(mtl).encode("utf-8") + + return data, name + + def __hash__(self): + """ + Provide a hash of the material so we can detect + duplicates. + + Returns + ------------ + hash : int + Hash of image and parameters + """ + if hasattr(self.image, "tobytes"): + # start with hash of raw image bytes + hashed = hash(self.image.tobytes()) + else: + # otherwise start with zero + hashed = 0 + # we will add additional parameters with + # an in-place xor of the additional value + # if stored as numpy arrays add parameters + if hasattr(self.ambient, "tobytes"): + hashed ^= hash(self.ambient.tobytes()) + if hasattr(self.diffuse, "tobytes"): + hashed ^= hash(self.diffuse.tobytes()) + if hasattr(self.specular, "tobytes"): + hashed ^= hash(self.specular.tobytes()) + if isinstance(self.glossiness, float): + hashed ^= hash(int(self.glossiness * 1000)) + return hashed + + @property + def main_color(self): + """ + Return the most prominent color. + """ + return self.diffuse + + @property + def glossiness(self): + if hasattr(self, "_glossiness"): + return self._glossiness + return 1.0 + + @glossiness.setter + def glossiness(self, value): + if value is None: + return + self._glossiness = float(value) + + def to_pbr(self): + """ + Convert the current simple material to a + PBR material. + + Returns + ------------ + pbr : PBRMaterial + Contains material information in PBR format. + """ + # convert specular exponent to roughness + roughness = (2 / (self.glossiness + 2)) ** (1.0 / 4.0) + + return PBRMaterial( + roughnessFactor=roughness, + baseColorTexture=self.image, + baseColorFactor=self.diffuse, + ) + + +class MultiMaterial(Material): + def __init__(self, materials=None, **kwargs): + """ + Wrapper for a list of Materials. + + Parameters + ---------- + materials : list[Material] | None + List of materials with which the container to be initialized. + """ + if materials is None: + self.materials = [] + else: + self.materials = materials + + def to_pbr(self): + """ + TODO : IMPLEMENT + """ + pbr = [m for m in self.materials if isinstance(m, PBRMaterial)] + if len(pbr) == 0: + return PBRMaterial() + return pbr[0] + + def __hash__(self): + """ + Provide a hash of the multi material so we can detect + duplicates. + + Returns + ------------ + hash : int + Xor hash of the contained materials. + """ + return int(np.bitwise_xor.reduce([hash(m) for m in self.materials])) + + def __iter__(self): + return iter(self.materials) + + def __next__(self): + return next(self.materials) + + def __len__(self): + return len(self.materials) + + @property + def main_color(self): + """ + The "average" color of this material. + + Returns + --------- + color : (4,) uint8 + Average color of this material. + """ + + def add(self, material): + """ + Adds new material to the container. + + Parameters + ---------- + material : Material + The material to be added. + """ + self.materials.append(material) + + def get(self, idx): + """ + Get material by index. + + Parameters + ---------- + idx : int + Index of the material to be retrieved. + + Returns + ------- + The material on the given index. + """ + return self.materials[idx] + + +class PBRMaterial(Material): + """ + Create a material for physically based rendering as + specified by GLTF 2.0: + https://git.io/fhkPZ + + Parameters with `Texture` in them must be PIL.Image objects + """ + + def __init__( + self, + name=None, + emissiveFactor=None, + emissiveTexture=None, + baseColorFactor=None, + metallicFactor=None, + roughnessFactor=None, + normalTexture=None, + occlusionTexture=None, + baseColorTexture=None, + metallicRoughnessTexture=None, + doubleSided=False, + alphaMode=None, + alphaCutoff=None, + **kwargs, + ): + # store values in an internal dict + self._data = {} + + # (3,) float + self.emissiveFactor = emissiveFactor + # (3,) or (4,) float with RGBA colors + self.baseColorFactor = baseColorFactor + + # float + self.metallicFactor = metallicFactor + self.roughnessFactor = roughnessFactor + self.alphaCutoff = alphaCutoff + + # PIL image + self.normalTexture = normalTexture + self.emissiveTexture = emissiveTexture + self.occlusionTexture = occlusionTexture + self.baseColorTexture = baseColorTexture + self.metallicRoughnessTexture = metallicRoughnessTexture + + # bool + self.doubleSided = doubleSided + + # str + self.name = name + self.alphaMode = alphaMode + + if len(kwargs) > 0: + util.log.debug( + "unsupported material keys: {}".format(", ".join(kwargs.keys())) + ) + + @property + def emissiveFactor(self): + """ + The factors for the emissive color of the material. + This value defines linear multipliers for the sampled + texels of the emissive texture. + + Returns + ----------- + emissiveFactor : (3,) float + Ech element in the array MUST be greater than + or equal to 0 and less than or equal to 1. + """ + return self._data.get("emissiveFactor") + + @emissiveFactor.setter + def emissiveFactor(self, value): + if value is None: + # passing none effectively removes value + self._data.pop("emissiveFactor", None) + else: + # non-None values must be a floating point + emissive = np.array(value, dtype=np.float64).reshape(3) + if emissive.min() < -_eps: + raise ValueError("all factors must be greater than 0.0") + self._data["emissiveFactor"] = emissive + + @property + def alphaMode(self): + """ + The material alpha rendering mode enumeration + specifying the interpretation of the alpha value of + the base color. + + Returns + ----------- + alphaMode : str + One of 'OPAQUE', 'MASK', 'BLEND' + """ + return self._data.get("alphaMode") + + @alphaMode.setter + def alphaMode(self, value): + if value is None: + # passing none effectively removes value + self._data.pop("alphaMode", None) + else: + # non-None values must be one of three values + value = str(value).upper().strip() + if value not in ["OPAQUE", "MASK", "BLEND"]: + raise ValueError("incorrect alphaMode: %s", value) + self._data["alphaMode"] = value + + @property + def alphaCutoff(self): + """ + Specifies the cutoff threshold when in MASK alpha mode. + If the alpha value is greater than or equal to this value + then it is rendered as fully opaque, otherwise, it is rendered + as fully transparent. A value greater than 1.0 will render + the entire material as fully transparent. This value MUST be + ignored for other alpha modes. When alphaMode is not defined, + this value MUST NOT be defined. + + Returns + ----------- + alphaCutoff : float + Value of cutoff. + """ + return self._data.get("alphaCutoff") + + @alphaCutoff.setter + def alphaCutoff(self, value): + if value is None: + # passing none effectively removes value + self._data.pop("alphaCutoff", None) + else: + self._data["alphaCutoff"] = float(value) + + @property + def doubleSided(self): + """ + Specifies whether the material is double sided. + + Returns + ----------- + doubleSided : bool + Specifies whether the material is double sided. + """ + return self._data.get("doubleSided") + + @doubleSided.setter + def doubleSided(self, value): + if value is None: + # passing none effectively removes value + self._data.pop("doubleSided", None) + else: + self._data["doubleSided"] = bool(value) + + @property + def metallicFactor(self): + """ + The factor for the metalness of the material. This value + defines a linear multiplier for the sampled metalness values + of the metallic-roughness texture. + + + Returns + ----------- + metallicFactor : float + How metally is the material + """ + return self._data.get("metallicFactor") + + @metallicFactor.setter + def metallicFactor(self, value): + if value is None: + # passing none effectively removes value + self._data.pop("metallicFactor", None) + else: + self._data["metallicFactor"] = float(value) + + @property + def roughnessFactor(self): + """ + The factor for the roughness of the material. This value + defines a linear multiplier for the sampled roughness values + of the metallic-roughness texture. + + Returns + ----------- + roughnessFactor : float + Roughness of material. + """ + return self._data.get("roughnessFactor") + + @roughnessFactor.setter + def roughnessFactor(self, value): + if value is None: + # passing none effectively removes value + self._data.pop("roughnessFactor", None) + else: + self._data["roughnessFactor"] = float(value) + + @property + def baseColorFactor(self): + """ + The factors for the base color of the material. This + value defines linear multipliers for the sampled texels + of the base color texture. + + Returns + --------- + color : (4,) uint8 + RGBA color + """ + return self._data.get("baseColorFactor") + + @baseColorFactor.setter + def baseColorFactor(self, value): + if value is None: + # passing none effectively removes value + self._data.pop("baseColorFactor", None) + else: + # non-None values must be RGBA color + self._data["baseColorFactor"] = color.to_rgba(value) + + @property + def normalTexture(self): + """ + The normal map texture. + + Returns + ---------- + image : PIL.Image + Normal texture. + """ + return self._data.get("normalTexture") + + @normalTexture.setter + def normalTexture(self, value): + if value is None: + # passing none effectively removes value + self._data.pop("normalTexture", None) + else: + self._data["normalTexture"] = value + + @property + def emissiveTexture(self): + """ + The emissive texture. + + Returns + ---------- + image : PIL.Image + Emissive texture. + """ + return self._data.get("emissiveTexture") + + @emissiveTexture.setter + def emissiveTexture(self, value): + if value is None: + # passing none effectively removes value + self._data.pop("emissiveTexture", None) + else: + self._data["emissiveTexture"] = value + + @property + def occlusionTexture(self): + """ + The occlusion texture. + + Returns + ---------- + image : PIL.Image + Occlusion texture. + """ + return self._data.get("occlusionTexture") + + @occlusionTexture.setter + def occlusionTexture(self, value): + if value is None: + # passing none effectively removes value + self._data.pop("occlusionTexture", None) + else: + self._data["occlusionTexture"] = value + + @property + def baseColorTexture(self): + """ + The base color texture image. + + Returns + ---------- + image : PIL.Image + Color texture. + """ + return self._data.get("baseColorTexture") + + @baseColorTexture.setter + def baseColorTexture(self, value): + if value is None: + # passing none effectively removes value + self._data.pop("baseColorTexture", None) + else: + # non-None values must be RGBA color + self._data["baseColorTexture"] = value + + @property + def metallicRoughnessTexture(self): + """ + The metallic-roughness texture. + + Returns + ---------- + image : PIL.Image + Metallic-roughness texture. + """ + return self._data.get("metallicRoughnessTexture") + + @metallicRoughnessTexture.setter + def metallicRoughnessTexture(self, value): + if value is None: + # passing none effectively removes value + self._data.pop("metallicRoughnessTexture", None) + else: + self._data["metallicRoughnessTexture"] = value + + @property + def name(self): + return self._data.get("name") + + @name.setter + def name(self, value): + if value is None: + # passing none effectively removes value + self._data.pop("name", None) + else: + self._data["name"] = value + + def copy(self): + # doing a straight deepcopy fails due to PIL images + kwargs = {} + # collect stored values as kwargs + for k, v in self._data.items(): + if v is None: + continue + if hasattr(v, "copy"): + # use an objects explicit copy if available + kwargs[k] = v.copy() + else: + # otherwise just hope deepcopy does something + kwargs[k] = copy.deepcopy(v) + return PBRMaterial(**kwargs) + + def to_color(self, uv): + """ + Get the rough color at a list of specified UV + coordinates. + + Parameters + ------------- + uv : (n, 2) float + UV coordinates on the material + + Returns + ------------- + colors + """ + colors = color.uv_to_color(uv=uv, image=self.baseColorTexture) + if colors is None and self.baseColorFactor is not None: + colors = self.baseColorFactor.copy() + return colors + + def to_simple(self): + """ + Get a copy of the current PBR material as + a simple material. + + Returns + ------------ + simple : SimpleMaterial + Contains material information in a simple manner + """ + # `self.baseColorFactor` is really a linear value + # so the "right" thing to do here would probably be: + # `diffuse = color.to_rgba(color.linear_to_srgb(self.baseColorFactor))` + # however that subtle transformation seems like it would confuse + # the absolute heck out of people looking at this. If someone wants + # this and has opinions happy to accept that change but otherwise + # we'll just keep passing it through as "probably-RGBA-like" + return SimpleMaterial( + image=self.baseColorTexture, + diffuse=self.baseColorFactor, + name=self.name, + ) + + @property + def main_color(self): + # will return default color if None + result = color.to_rgba(self.baseColorFactor) + return result + + def __hash__(self): + """ + Provide a hash of the material so we can detect + duplicate materials. + + Returns + ------------ + hash : int + Hash of image and parameters + """ + return hash( + b"".join( + np.asanyarray(v).tobytes() for v in self._data.values() if v is not None + ) + ) + + +def empty_material(color: NDArray[np.uint8] | None = None) -> SimpleMaterial: + """ + Return an empty material set to a single color + + Parameters + ----------- + color : None or (3,) uint8 + RGB color + + Returns + ------------- + material : SimpleMaterial + Image is a a four pixel RGB + """ + + # create a one pixel RGB image + return SimpleMaterial(image=color_image(color=color)) + + +def color_image(color: NDArray[np.uint8] | None = None): + """ + Generate an image with one color. + + Parameters + ---------- + color + Optional uint8 color + + Returns + ---------- + image + A (2, 2) RGBA image with the specified color. + """ + # only raise an error further down the line + if isinstance(Image, exceptions.ExceptionWrapper): + return Image + # start with a single default RGBA color + single = np.array([100, 100, 100, 255], dtype=np.uint8) + if np.shape(color) in ((3,), (4,)): + single[: len(color)] = color + # tile into a (2, 2) image and return + return Image.fromarray(np.tile(single, 4).reshape((2, 2, 4)).astype(np.uint8)) + + +def pack( + materials, + uvs, + deduplicate=True, + padding: int = 2, + max_tex_size_individual=8192, + max_tex_size_fused=8192, +): + """ + Pack multiple materials with texture into a single material. + + UV coordinates outside of the 0.0-1.0 range will be coerced + into this range using a "wrap" behavior (i.e. modulus). + + Alpha blending and backface culling settings are not supported! + Returns a material with alpha values set, but alpha blending disabled. + + Parameters + ----------- + materials : (n,) Material + List of multiple materials + uvs : (n, m, 2) float + Original UV coordinates + padding : int + Number of pixels to pad each image with. + max_tex_size_individual : int + Maximum size of each individual texture. + max_tex_size_fused : int | None + Maximum size of the combined texture. + Individual texture size will be reduced to fit. + Set to None to allow infinite size. + + Returns + ------------ + material : SimpleMaterial + Combined material. + uv : (p, 2) float + Combined UV coordinates in the 0.0-1.0 range. + """ + + import collections + + from PIL import Image + + from ..path import packing + + def multiply_factor(img, factor, mode): + """ + Multiply an image by a factor. + """ + if factor is None: + return img.convert(mode) + img = ( + (np.array(img.convert(mode), dtype=np.float64) * factor) + .round() + .astype(np.uint8) + ) + return Image.fromarray(img) + + def get_base_color_texture(mat): + """ + Logic for extracting a simple image from each material. + """ + # extract an image for each material + img = None + if isinstance(mat, PBRMaterial): + if mat.baseColorTexture is not None: + img = multiply_factor( + mat.baseColorTexture, factor=mat.baseColorFactor, mode="RGBA" + ) + elif mat.baseColorFactor is not None: + # Per glTF 2.0 spec (https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html): + # - baseColorFactor: "defines linear multipliers for the sampled texels" + # - baseColorTexture: "RGB components MUST be encoded with the sRGB transfer function" + # + # Therefore when creating a texture from baseColorFactor values, + # we need to convert from linear to sRGB space + c_linear = color.to_float(mat.baseColorFactor).reshape(4) + + # Apply proper sRGB gamma correction to RGB channels + c_srgb = np.concatenate( + [color.linear_to_srgb(c_linear[:3]), c_linear[3:4]] + ) + + # Convert to uint8 + c = np.round(c_srgb * 255).astype(np.uint8) + assert c.shape == (4,) + img = color_image(c) + + if img is not None and mat.alphaMode != "BLEND": + # we can't handle alpha blending well, but we can bake alpha cutoff + mode = img.mode + img = np.array(img) + if mat.alphaMode == "MASK": + img[..., 3] = np.where(img[..., 3] > mat.alphaCutoff * 255, 255, 0) + elif mat.alphaMode == "OPAQUE" or mat.alphaMode is None: + if "A" in mode: + img[..., 3] = 255 + img = Image.fromarray(img) + elif getattr(mat, "image", None) is not None: + img = mat.image + elif np.shape(getattr(mat, "diffuse", [])) == (4,): + # return a one pixel image + img = color_image(mat.diffuse) + + if img is None: + # return a one pixel image + img = color_image() + # make sure we're always returning in RGBA mode + return img.convert("RGBA") + + def get_metallic_roughness_texture(mat): + """ + Logic for extracting a simple image from each material. + """ + # extract an image for each material + img = None + if isinstance(mat, PBRMaterial): + if mat.metallicRoughnessTexture is not None: + if mat.metallicRoughnessTexture.format == "BGR": + img = np.array(mat.metallicRoughnessTexture.convert("RGB")) + else: + img = np.array(mat.metallicRoughnessTexture) + + if len(img.shape) == 2 or img.shape[-1] == 1: + img = img.reshape(*img.shape[:2], 1) + img = np.concatenate( + [ + img, + np.ones_like(img[..., :1]) * 255, + np.zeros_like(img[..., :1]), + ], + axis=-1, + ) + elif img.shape[-1] == 2: + img = np.concatenate([img, np.zeros_like(img[..., :1])], axis=-1) + + if mat.metallicFactor is not None: + img[..., 0] = np.round( + img[..., 0].astype(np.float64) * mat.metallicFactor + ).astype(np.uint8) + if mat.roughnessFactor is not None: + img[..., 1] = np.round( + img[..., 1].astype(np.float64) * mat.roughnessFactor + ).astype(np.uint8) + img = Image.fromarray(img) + else: + metallic = 0.0 if mat.metallicFactor is None else mat.metallicFactor + roughness = 1.0 if mat.roughnessFactor is None else mat.roughnessFactor + # glTF expects B=metallic, G=roughness, R=unused + # https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#metallic-roughness-material + metallic_roughnesss = np.round( + np.array([0.0, roughness, metallic], dtype=np.float64) * 255 + ) + img = Image.fromarray(metallic_roughnesss[None, None].astype(np.uint8)) + return img + + def get_emissive_texture(mat): + """ + Logic for extracting a simple image from each material. + """ + # extract an image for each material + img = None + if isinstance(mat, PBRMaterial): + if mat.emissiveTexture is not None: + img = multiply_factor(mat.emissiveTexture, mat.emissiveFactor, "RGB") + elif mat.emissiveFactor is not None: + c = color.to_rgba(mat.emissiveFactor) + img = Image.fromarray(c.reshape((1, 1, -1))) + else: + img = Image.fromarray(np.reshape([0, 0, 0], (1, 1, 3)).astype(np.uint8)) + # make sure we're always returning in RGBA mode + return img.convert("RGB") + + def get_normal_texture(mat): + # there is no default normal texture + return getattr(mat, "normalTexture", None) + + def get_occlusion_texture(mat): + occlusion_texture = getattr(mat, "occlusionTexture", None) + if occlusion_texture is None: + occlusion_texture = Image.fromarray(np.array([[255]], dtype=np.uint8)) + else: + occlusion_texture = occlusion_texture.convert("L") + return occlusion_texture + + def resize_images(images, sizes): + resized = [] + for img, size in zip(images, sizes): + if img is None: + resized.append(None) + else: + img = img.resize(size) + resized.append(img) + return resized + + packed = {} + + def pack_images(images): + # run image packing with our material-specific settings + # Note: deduplication is disabled to ensure consistent packing + # across different texture types (base color, metallic/roughness, etc) + + # see if we've already run this packing image + key = hash(tuple(sorted([id(i) for i in images]))) + assert key not in packed + if key in packed: + return packed[key] + + # otherwise run packing now + result = packing.images( + images, + deduplicate=False, # Disabled to ensure consistent texture layouts + power_resize=True, + seed=42, + iterations=10, + spacing=int(padding), + ) + packed[key] = result + return result + + if deduplicate: + # start by collecting a list of indexes for each material hash + unique_idx = collections.defaultdict(list) + [unique_idx[hash(m)].append(i) for i, m in enumerate(materials)] + # now we only need the indexes and don't care about the hashes + mat_idx = list(unique_idx.values()) + else: + # otherwise just use all the indexes + mat_idx = np.arange(len(materials)).reshape((-1, 1)) + + if len(mat_idx) == 1: + # if there is only one material we can just return it + return materials[0], np.vstack(uvs) + + assert set(np.concatenate(mat_idx).ravel()) == set(range(len(uvs))) + assert len(uvs) == len(materials) + use_pbr = any(isinstance(m, PBRMaterial) for m in materials) + + # in some cases, the fused scene results in huge trimsheets + # we can try to prevent this by downscaling the textures iteratively + down_scale_iterations = 6 + while down_scale_iterations > 0: + # collect the images from the materials + images = [get_base_color_texture(materials[g[0]]) for g in mat_idx] + + if use_pbr: + # if we have PBR materials, collect all possible textures and + # determine the largest size per material + metallic_roughness = [ + get_metallic_roughness_texture(materials[g[0]]) for g in mat_idx + ] + emissive = [get_emissive_texture(materials[g[0]]) for g in mat_idx] + normals = [get_normal_texture(materials[g[0]]) for g in mat_idx] + occlusion = [get_occlusion_texture(materials[g[0]]) for g in mat_idx] + + unpadded_sizes = [] + for textures in zip(images, metallic_roughness, emissive, normals, occlusion): + # remove None textures + textures = [tex for tex in textures if tex is not None] + tex_sizes = np.stack([np.array(tex.size) for tex in textures]) + max_tex_size = tex_sizes.max(axis=0) + if max_tex_size.max() > max_tex_size_individual: + scale = max_tex_size.max() / max_tex_size_individual + max_tex_size = np.round(max_tex_size / scale).astype(np.int64) + + unpadded_sizes.append(tuple(max_tex_size)) + + # use the same size for all of them to ensure + # that texture atlassing is identical + images = resize_images(images, unpadded_sizes) + metallic_roughness = resize_images(metallic_roughness, unpadded_sizes) + emissive = resize_images(emissive, unpadded_sizes) + normals = resize_images(normals, unpadded_sizes) + occlusion = resize_images(occlusion, unpadded_sizes) + else: + # for non-pbr materials, just use the original image size + unpadded_sizes = [] + for img in images: + tex_size = np.array(img.size) + if tex_size.max() > max_tex_size_individual: + scale = tex_size.max() / max_tex_size_individual + tex_size = np.round(tex_size / scale).astype(np.int64) + unpadded_sizes.append(tex_size) + + # pack the multiple images into a single large image + final, offsets = pack_images(images) + + # if the final image is too large, reduce the maximum texture size and repeat + if ( + max_tex_size_fused is not None + and final.size[0] * final.size[1] > max_tex_size_fused**2 + ): + down_scale_iterations -= 1 + max_tex_size_individual //= 2 + else: + break + + if use_pbr: + # even if we only need the first two channels, store RGB, because + # PIL 'LA' mode images are interpreted incorrectly in other 3D software + final_metallic_roughness, _ = pack_images(metallic_roughness) + + if all(np.array(x).max() == 0 for x in emissive): + # if all emissive textures are black, don't use emissive + emissive = None + final_emissive = None + else: + final_emissive, _ = pack_images(emissive) + + if all(n is not None for n in normals): + # only use normal texture if all materials use them + # how else would you handle missing normals? + final_normals, _ = pack_images(normals) + else: + final_normals = None + + if any(np.array(o).min() < 255 for o in occlusion): + # only use occlusion texture if any material actually has an occlusion value + final_occlusion, _ = pack_images(occlusion) + else: + final_occlusion = None + + # the size of the final texture image + final_size = np.array(final.size, dtype=np.float64) + # collect scaled new UV coordinates by material index + new_uv = {} + for group, img, offset in zip(mat_idx, images, offsets): + # how big was the original image + uv_scale = (np.array(img.size) - 1) / final_size + # the units of offset are *pixels of the final image* + # thus to scale them to normalized UV coordinates we + # what is the offset in fractions of final image + uv_offset = offset / (final_size - 1) + # scale and translate each of the new UV coordinates + # also make sure they are in 0.0-1.0 using modulus (i.e. wrap) + half = 0.5 / np.array(img.size) + + for g in group: + # only wrap pixels that are outside of 0.0-1.0. + # use a small leeway of half a pixel for floating point inaccuracies and + # the case of uv==1.0 + uvg = uvs[g].copy() + + # now wrap anything more than half a pixel outside + uvg[np.logical_or(uvg < -half, uvg > (1.0 + half))] %= 1.0 + # clamp to half a pixel + uvg = np.clip(uvg, half, 1.0 - half) + + # apply the scale and offset + moved = (uvg * uv_scale) + uv_offset + + if tol.strict: + # the color from the original coordinates and image + old = color.uv_to_interpolated_color(uvs[g], img) + # the color from the packed image + new = color.uv_to_interpolated_color(moved, final) + assert np.allclose(old, new, atol=6) + + new_uv[g] = moved + + # stack the new UV coordinates in the original order + stacked = np.vstack([new_uv[i] for i in range(len(uvs))]) + + if use_pbr: + return ( + PBRMaterial( + baseColorTexture=final, + metallicRoughnessTexture=final_metallic_roughness, + emissiveTexture=final_emissive, + emissiveFactor=[1.0, 1.0, 1.0] if final_emissive else None, + alphaMode=None, # unfortunately, we can't handle alpha blending well + doubleSided=False, # TODO how to handle this? + normalTexture=final_normals, + occlusionTexture=final_occlusion, + ), + stacked, + ) + else: + return SimpleMaterial(image=final), stacked diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/objects.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/objects.py new file mode 100644 index 0000000000000000000000000000000000000000..44452b11ebe81efb6d50cd9cc72f1f6067cd19db --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/objects.py @@ -0,0 +1,92 @@ +""" +objects.py +-------------- + +Deal with objects which hold visual properties, like +ColorVisuals and TextureVisuals. +""" + +import numpy as np + +from .color import ColorVisuals, color_to_uv +from .material import pack +from .texture import TextureVisuals + + +def create_visual(**kwargs): + """ + Create Visuals object from keyword arguments. + + Parameters + ----------- + face_colors : (n, 3|4) uint8 + Face colors + vertex_colors : (n, 3|4) uint8 + Vertex colors + mesh : trimesh.Trimesh + Mesh object + + Returns + ---------- + visuals : ColorVisuals + Visual object created from arguments + """ + return ColorVisuals(**kwargs) + + +def concatenate(visuals, *args): + """ + Concatenate multiple visual objects. + + Parameters + ---------- + visuals : ColorVisuals or list + Visuals to concatenate + *args : ColorVisuals or list + More visuals to concatenate + + Returns + ---------- + concat : Visuals + If all are color + """ + # get a flat list of Visuals objects + if len(args) > 0: + visuals = np.append(visuals, args) + else: + visuals = np.array(visuals) + + # if there are any texture visuals convert all to texture + if any(v.kind == "texture" for v in visuals): + # first collect materials and UV coordinates + mats = [] + uvs = [] + for v in visuals: + if v.kind == "texture": + mats.append(v.material) + if v.uv is None: + # otherwise use zeros + uvs.append(np.zeros((len(v.mesh.vertices), 2)) + 0.5) + else: + # if uvs are of correct shape use them + uvs.append(v.uv) + + else: + # create a material and UV coordinates from vertex colors + color_mat, color_uv = color_to_uv(vertex_colors=v.vertex_colors) + mats.append(color_mat) + uvs.append(color_uv) + # pack the materials and UV coordinates into one + new_mat, new_uv = pack(materials=mats, uvs=uvs) + return TextureVisuals(material=new_mat, uv=new_uv) + + # convert all visuals to the first valid kind + kind = next((v.kind for v in visuals if v.kind is not None), None) + if kind == "face": + colors = np.vstack([v.face_colors for v in visuals]) + return ColorVisuals(face_colors=colors) + elif kind == "vertex": + colors = np.vstack([v.vertex_colors for v in visuals]) + return ColorVisuals(vertex_colors=colors) + + return ColorVisuals() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/texture.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/texture.py new file mode 100644 index 0000000000000000000000000000000000000000..04f6691205cb25d38ecb1255d4a246818b9a7cbe --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/visual/texture.py @@ -0,0 +1,350 @@ +import copy + +import numpy as np + +from .. import caching, grouping, util +from . import color +from .base import Visuals +from .material import PBRMaterial, SimpleMaterial, empty_material # NOQA + + +class TextureVisuals(Visuals): + def __init__(self, uv=None, material=None, image=None, face_materials=None): + """ + Store a single material and per-vertex UV coordinates + for a mesh. + + If passed UV coordinates and a single image it will + create a SimpleMaterial for the image. + + Parameters + -------------- + uv : (n, 2) float + UV coordinates for the mesh + material : Material + Store images and properties + image : PIL.Image + Can be passed to automatically create material + """ + + # store values we care about enough to hash + self.vertex_attributes = caching.DataStore() + # cache calculated values + self._cache = caching.Cache(self.vertex_attributes.__hash__) + + # should be (n, 2) float + self.uv = uv + + if material is None: + if image is None: + self.material = empty_material() + else: + # if an image is passed create a SimpleMaterial + self.material = SimpleMaterial(image=image) + else: + # if passed assign + self.material = material + + self.face_materials = face_materials + + def _verify_hash(self): + """ + Dump the cache if anything in self.vertex_attributes + has changed. + """ + self._cache.verify() + + @property + def kind(self): + """ + Return the type of visual data stored + + Returns + ---------- + kind : str + What type of visuals are defined + """ + return "texture" + + @property + def defined(self): + """ + Check if any data is stored + + Returns + ---------- + defined : bool + Are UV coordinates and images set? + """ + ok = self.material is not None + return ok + + def __hash__(self): + """ + Get a CRC of the stored data. + + Returns + -------------- + crc : int + Hash of items in self.vertex_attributes + """ + return self.vertex_attributes.__hash__() + + @property + def uv(self): + """ + Get the stored UV coordinates. + + Returns + ------------ + uv : (n, 2) float or None + Pixel position per-vertex. + """ + return self.vertex_attributes.get("uv", None) + + @uv.setter + def uv(self, values): + """ + Set the UV coordinates. + + Parameters + -------------- + values : (n, 2) float or None + Pixel locations on a texture per- vertex + """ + if values is None: + self.vertex_attributes.pop("uv") + else: + self.vertex_attributes["uv"] = np.asanyarray(values, dtype=np.float64) + + def copy(self, uv=None): + """ + Return a copy of the current TextureVisuals object. + + Returns + ---------- + copied : TextureVisuals + Contains the same information in a new object + """ + if uv is None: + uv = self.uv + if uv is not None: + uv = uv.copy() + copied = TextureVisuals( + uv=uv, + material=self.material.copy(), + face_materials=copy.copy(self.face_materials), + ) + + return copied + + def to_color(self): + """ + Convert textured visuals to a ColorVisuals with vertex + color calculated from texture. + + Returns + ----------- + vis : trimesh.visuals.ColorVisuals + Contains vertex color from texture + """ + # find the color at each UV coordinate + colors = self.material.to_color(self.uv) + # create ColorVisuals from result + vis = color.ColorVisuals(vertex_colors=colors) + return vis + + def face_subset(self, face_index): + """ + Get a copy of + """ + if self.uv is not None: + indices = np.unique(self.mesh.faces[face_index].flatten()) + return self.copy(self.uv[indices]) + else: + return self.copy() + + def update_vertices(self, mask): + """ + Apply a mask to remove or duplicate vertex properties. + + Parameters + ------------ + mask : (len(vertices),) bool or (n,) int + Mask which can be used like: `vertex_attribute[mask]` + """ + # collect updated masked values + updates = {} + for key, value in self.vertex_attributes.items(): + # DataStore will convert None to zero-length array + if len(value) == 0: + continue + try: + # store the update + updates[key] = value[mask] + except BaseException: + # usual reason is an incorrect size or index + util.log.warning(f"failed to update visual: `{key}`") + # clear all values from the vertex attributes + self.vertex_attributes.clear() + # apply the updated values + self.vertex_attributes.update(updates) + + def update_faces(self, mask): + """ + Apply a mask to remove or duplicate face properties, + not applicable to texture visuals. + """ + + def concatenate(self, others): + """ + Concatenate this TextureVisuals object with others + and return the result without modifying this visual. + + Parameters + ----------- + others : (n,) Visuals + Other visual objects to concatenate + + Returns + ----------- + concatenated : TextureVisuals + Concatenated visual objects + """ + from .objects import concatenate + + return concatenate(self, others) + + +def unmerge_faces(faces, *args, **kwargs): + """ + Textured meshes can come with faces referencing vertex + indices (`v`) and an array the same shape which references + vertex texture indices (`vt`) and sometimes even normal (`vn`). + + Vertex locations with different values of any of these can't + be considered the "same" vertex, and for our simple data + model we need to not combine these vertices. + + Parameters + ------------- + faces : (n, d) int + References vertex indices + *args : (n, d) int + Various references of corresponding values + This is usually UV coordinates or normal indexes + maintain_faces : bool + Do not alter original faces and return no-op masks. + + Returns + ------------- + new_faces : (m, d) int + New faces for masked vertices + mask_v : (p,) int + A mask to apply to vertices + mask_* : (p,) int + A mask to apply to vt array to get matching UV coordinates + Returns as many of these as args were passed + """ + # unfortunately Python2 doesn't let us put named kwargs + # after an `*args` sequence so we have to do this ugly get + maintain_faces = kwargs.get("maintain_faces", False) + + # don't alter faces + if maintain_faces: + # start with not altering faces at all + result = [faces] + # find the maximum index referenced by faces + max_idx = faces.max() + # add a vertex mask which is just ordered + result.append(np.arange(max_idx + 1)) + + # now given the order is fixed do our best on the rest of the order + for arg in args: + # create a mask of the attribute-vertex mapping + # note that these might conflict since we're not unmerging + masks = np.full((3, max_idx + 1), -1, dtype=np.int64) + # set the mask using the unmodified face indexes + for i, f, a in zip(range(3), faces.T, arg.T): + masks[i][f] = a + # find the most commonly occurring attribute (i.e. UV coordinate) + # and use that index note that this is doing a float conversion + # and then median before converting back to int: could also do this as + # a column diff and sort but this seemed easier and is fast enough + # turn default attribute value of -1 to nan before median computation + # and use nanmedian to compute the median ignoring the nan values + masks_nan = np.where(masks != -1, masks, np.nan) + result.append(np.nanmedian(masks_nan, axis=0).astype(np.int64)) + + return result + + # stack into pairs of (vertex index, texture index) + stackable = [np.asanyarray(faces).reshape(-1)] + # append multiple args to the correlated stack + # this is usually UV coordinates (vt) and normals (vn) + for arg in args: + stackable.append(np.asanyarray(arg).reshape(-1)) + + # unify them into rows of a numpy array + stack = np.column_stack(stackable) + # find unique pairs: we're trying to avoid merging + # vertices that have the same position but different + # texture coordinates + unique, inverse = grouping.unique_rows(stack) + + # only take the unique pairs + pairs = stack[unique] + # try to maintain original vertex order + order = pairs[:, 0].argsort() + # apply the order to the pairs + pairs = pairs[order] + + # we re-ordered the vertices to try to maintain + # the original vertex order as much as possible + # so to reconstruct the faces we need to remap + remap = np.zeros(len(order), dtype=np.int64) + remap[order] = np.arange(len(order)) + + # the faces are just the inverse with the new order + new_faces = remap[inverse].reshape((-1, faces.shape[1])) + + # the mask for vertices and masks for other args + result = [new_faces] + result.extend(pairs.T) + + return result + + +def power_resize(image, resample=1, square=False): + """ + Resize a PIL image so every dimension is a power of two. + + Parameters + ------------ + image : PIL.Image + Input image + resample : int + Passed to Image.resize + square : bool + If True, upsize to a square image + + Returns + ------------- + resized : PIL.Image + Input image resized + """ + # what is the current resolution of the image in pixels + size = np.array(image.size, dtype=np.int64) + # what is the resolution of the image upsized to the nearest + # power of two on each axis: allow rectangular textures + new_size = (2 ** np.ceil(np.log2(size))).astype(np.int64) + + # make every dimension the largest + if square: + new_size = np.ones(2, dtype=np.int64) * new_size.max() + + # if we're not powers of two upsize + if (size != new_size).any(): + return image.resize(tuple(new_size), resample=resample) + + return image.copy() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..112975981800b1137fe5441b7fdfd428e15525ef --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__init__.py @@ -0,0 +1,4 @@ +from . import creation +from .base import VoxelGrid + +__all__ = ["VoxelGrid", "creation"] diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e8a52b37de73614c804f92fe32e50ae1cc5acacf Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/base.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/base.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..26c1846f5d95e397b3c3e0c90d8bd5bb01c6ff88 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/base.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/creation.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/creation.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..391e536395169f0031c354159b2f80d84a157bfc Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/creation.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/encoding.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/encoding.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..704d113d430325c4f13b6bcacb156187833513bf Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/encoding.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/morphology.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/morphology.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f9c6c27ce2effa480e784df67731e5749ae142fb Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/morphology.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/ops.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/ops.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..037d49bd62ae753c5957511713961492b3a716d3 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/ops.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/runlength.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/runlength.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2e25974874cd155117da26a85499a8b5763998c9 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/runlength.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/transforms.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/transforms.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0e1055c09d07870eceffba5e1a3f053a2c00f6e2 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/__pycache__/transforms.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/base.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/base.py new file mode 100644 index 0000000000000000000000000000000000000000..237a10ef51569e3eb3ff17bc1ce26ce750547612 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/base.py @@ -0,0 +1,427 @@ +""" +voxel.py +----------- + +Convert meshes to a simple voxel data structure and back again. +""" + +from hashlib import sha256 + +import numpy as np + +from .. import bounds as bounds_module +from .. import caching, util +from .. import transformations as tr +from ..constants import log +from ..exchange.binvox import export_binvox +from ..parent import Geometry +from . import morphology, ops, transforms +from .encoding import DenseEncoding, Encoding + + +class VoxelGrid(Geometry): + """ + Store 3D voxels. + """ + + def __init__(self, encoding, transform=None, metadata=None): + if transform is None: + transform = np.eye(4) + if isinstance(encoding, np.ndarray): + encoding = DenseEncoding(encoding.astype(bool)) + if encoding.dtype != bool: + raise ValueError("encoding must have dtype bool") + self._data = caching.DataStore() + self.encoding = encoding + self._transform = transforms.Transform(transform, datastore=self._data) + self._cache = caching.Cache(id_function=self._data.__hash__) + + self.metadata = {} + # update the mesh metadata with passed metadata + if isinstance(metadata, dict): + self.metadata.update(metadata) + elif metadata is not None: + raise ValueError(f"metadata should be a dict or None, got {metadata!s}") + + def __hash__(self): + """ + Get the hash of the current transformation matrix. + + Returns + ------------ + hash : str + Hash of transformation matrix + """ + return self._data.__hash__() + + @property + def identifier_hash(self) -> str: + return sha256(hash(self).to_bytes()).hexdigest() + + @property + def encoding(self): + """ + `Encoding` object providing the occupancy grid. + + See `trimesh.voxel.encoding` for implementations. + """ + return self._data["encoding"] + + @encoding.setter + def encoding(self, encoding): + if isinstance(encoding, np.ndarray): + encoding = DenseEncoding(encoding) + elif not isinstance(encoding, Encoding): + raise ValueError(f"encoding must be an Encoding, got {encoding!s}") + if len(encoding.shape) != 3: + raise ValueError(f"encoding must be rank 3, got shape {encoding.shape!s}") + if encoding.dtype != bool: + raise ValueError(f"encoding must be binary, got {encoding.dtype}") + self._data["encoding"] = encoding + + @property + def transform(self): + """4x4 homogeneous transformation matrix.""" + return self._transform.matrix + + @transform.setter + def transform(self, matrix): + """4x4 homogeneous transformation matrix.""" + self._transform.matrix = matrix + + @property + def translation(self): + """Location of voxel at [0, 0, 0].""" + return self._transform.translation + + @property + def scale(self): + """ + 3-element float representing per-axis scale. + + Raises a `RuntimeError` if `self.transform` has rotation or + shear components. + """ + return self._transform.scale + + @property + def pitch(self): + """ + Uniform scaling factor representing the side length of + each voxel. + + Returns + ----------- + pitch : float + Pitch of the voxels. + + Raises + ------------ + `RuntimeError` + If `self.transformation` has rotation or shear + components of has non-uniform scaling. + """ + return self._transform.pitch + + @property + def element_volume(self): + return self._transform.unit_volume + + def apply_transform(self, matrix): + self._transform.apply_transform(matrix) + return self + + def strip(self): + """ + Mutate self by stripping leading/trailing planes of zeros. + + Returns + -------- + self after mutation occurs in-place + """ + encoding, padding = self.encoding.stripped + self.encoding = encoding + self._transform.matrix[:3, 3] = self.indices_to_points(padding[:, 0]) + return self + + @caching.cache_decorator + def bounds(self): + indices = self.sparse_indices + # get all 8 corners of the AABB + corners = bounds_module.corners( + [indices.min(axis=0) - 0.5, indices.max(axis=0) + 0.5] + ) + # transform these corners to a new frame + corners = self._transform.transform_points(corners) + # get the AABB of corners in-frame + bounds = np.array([corners.min(axis=0), corners.max(axis=0)]) + bounds.flags.writeable = False + return bounds + + @caching.cache_decorator + def extents(self): + bounds = self.bounds + extents = bounds[1] - bounds[0] + extents.flags.writeable = False + return extents + + @caching.cache_decorator + def is_empty(self): + return self.encoding.is_empty + + @property + def shape(self): + """3-tuple of ints denoting shape of occupancy grid.""" + return self.encoding.shape + + @caching.cache_decorator + def filled_count(self): + """int, number of occupied voxels in the grid.""" + return self.encoding.sum.item() + + def is_filled(self, point): + """ + Query points to see if the voxel cells they lie in are + filled or not. + + Parameters + ---------- + point : (n, 3) float + Points in space + + Returns + --------- + is_filled : (n,) bool + Is cell occupied or not for each point + """ + point = np.asanyarray(point) + indices = self.points_to_indices(point) + in_range = np.logical_and( + np.all(indices < np.array(self.shape), axis=-1), np.all(indices >= 0, axis=-1) + ) + + is_filled = np.zeros_like(in_range) + is_filled[in_range] = self.encoding.gather_nd(indices[in_range]) + return is_filled + + def fill(self, method="holes", **kwargs): + """ + Mutates self by filling in the encoding according + to `morphology.fill`. + + Parameters + ---------- + method : hashable + Implementation key, one of + `trimesh.voxel.morphology.fill.fillers` keys + **kwargs : dict + Additional kwargs passed through to + the keyed implementation. + + Returns + ---------- + self : VoxelGrid + After replacing encoding with a filled version. + """ + self.encoding = morphology.fill(self.encoding, method=method, **kwargs) + return self + + def hollow(self): + """ + Mutates self by removing internal voxels + leaving only surface elements. + + Surviving elements are those in encoding that are + adjacent to an empty voxel where adjacency is + controlled by `structure`. + + Returns + ---------- + self : VoxelGrid + After replacing encoding with a surface version. + """ + self.encoding = morphology.surface(self.encoding) + return self + + @caching.cache_decorator + def marching_cubes(self): + """ + A marching cubes Trimesh representation of the voxels. + + No effort was made to clean or smooth the result in any way; + it is merely the result of applying the scikit-image + measure.marching_cubes function to self.encoding.dense. + + Returns + --------- + meshed : trimesh.Trimesh + Representing the current voxel + object as returned by marching cubes algorithm. + """ + return ops.matrix_to_marching_cubes(matrix=self.matrix) + + @property + def matrix(self): + """ + Return a DENSE matrix of the current voxel encoding. + + Returns + ------------- + dense : (a, b, c) bool + Numpy array of dense matrix + Shortcut to voxel.encoding.dense + """ + return self.encoding.dense + + @caching.cache_decorator + def volume(self): + """ + What is the volume of the filled cells in the current + voxel object. + + Returns + --------- + volume : float + Volume of filled cells. + """ + return self.filled_count * self.element_volume + + @caching.cache_decorator + def points(self): + """ + The center of each filled cell as a list of points. + + Returns + ---------- + points : (self.filled, 3) float + Points in space. + """ + return self._transform.transform_points(self.sparse_indices.astype(float)) + + @property + def sparse_indices(self): + """(n, 3) int array of sparse indices of occupied voxels.""" + return self.encoding.sparse_indices + + def as_boxes(self, colors=None, **kwargs): + """ + A rough Trimesh representation of the voxels with a box + for each filled voxel. + + Parameters + ---------- + colors : None, (3,) or (4,) float or uint8 + (X, Y, Z, 3) or (X, Y, Z, 4) float or uint8 + Where matrix.shape == (X, Y, Z) + + Returns + --------- + mesh : trimesh.Trimesh + Mesh with one box per filled cell. + """ + + if colors is not None: + colors = np.asanyarray(colors) + if colors.ndim == 4: + encoding = self.encoding + if colors.shape[:3] == encoding.shape: + # TODO jackd: more efficient implementation? + # encoding.as_mask? + colors = colors[encoding.dense] + else: + log.warning("colors incorrect shape!") + colors = None + elif colors.shape not in ((3,), (4,)): + log.warning("colors incorrect shape!") + colors = None + + mesh = ops.multibox(centers=self.sparse_indices.astype(float), colors=colors) + + mesh = mesh.apply_transform(self.transform) + return mesh + + def points_to_indices(self, points): + """ + Convert points to indices in the matrix array. + + Parameters + ---------- + points: (n, 3) float, point in space + + Returns + --------- + indices: (n, 3) int array of indices into self.encoding + """ + points = self._transform.inverse_transform_points(points) + return np.round(points).astype(int) + + def indices_to_points(self, indices): + return self._transform.transform_points(indices.astype(float)) + + def show(self, *args, **kwargs): + """ + Convert the current set of voxels into a trimesh for visualization + and show that via its built- in preview method. + """ + return self.as_boxes(kwargs.pop("colors", None)).show(*args, **kwargs) + + def copy(self): + return VoxelGrid(self.encoding.copy(), self._transform.matrix.copy()) + + def export(self, file_obj=None, file_type=None, **kwargs): + """ + Export the current VoxelGrid. + + Parameters + ------------ + file_obj : file-like or str + File or file-name to export to. + file_type : None or str + Only 'binvox' currently supported. + + Returns + --------- + export : bytes + Value of export. + """ + if isinstance(file_obj, str) and file_type is None: + file_type = util.split_extension(file_obj).lower() + + if file_type != "binvox": + raise ValueError("only binvox exports supported!") + + exported = export_binvox(self, **kwargs) + if hasattr(file_obj, "write"): + file_obj.write(exported) + elif isinstance(file_obj, str): + with open(file_obj, "wb") as f: + f.write(exported) + return exported + + def revoxelized(self, shape): + """ + Create a new VoxelGrid without rotations, reflections + or shearing. + + Parameters + ---------- + shape : (3, int) + The shape of the returned VoxelGrid. + + Returns + ---------- + vox : VoxelGrid + Of the given shape with possibly non-uniform + scale and translation transformation matrix. + """ + shape = tuple(shape) + bounds = self.bounds.copy() + extents = self.extents + points = util.grid_linspace(bounds, shape).reshape(shape + (3,)) + dense = self.is_filled(points) + scale = extents / np.asanyarray(shape) + translate = bounds[0] + return VoxelGrid(dense, transform=tr.scale_and_translate(scale, translate)) + + def __add__(self, other): + raise NotImplementedError("TODO : implement voxel concatenation") diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/creation.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/creation.py new file mode 100644 index 0000000000000000000000000000000000000000..f9b509c0a0b020cbf71f0d638dd79c904548a58e --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/creation.py @@ -0,0 +1,318 @@ +import numpy as np + +from .. import grouping, remesh, util +from .. import transformations as tr +from ..constants import log_time +from ..typed import ArrayLike, Integer, Number, VoxelizationMethodsType +from . import base +from . import encoding as enc + + +@log_time +def voxelize_subdivide( + mesh, pitch: Number, max_iter: Integer | None = 10, edge_factor: Number = 2.0 +) -> base.VoxelGrid: + """ + Voxelize a surface by subdividing a mesh until every edge is + shorter than: (pitch / edge_factor) + + Parameters + ----------- + mesh : trimesh.Trimesh + Source mesh + pitch + Side length of a single voxel cube + max_iter + Cap maximum subdivisions or None for no limit. + edge_factor + Proportion of pitch maximum edge length. + + Returns + ----------- + VoxelGrid instance representing the voxelized mesh. + """ + max_edge = pitch / edge_factor + + if max_iter is None: + longest_edge = np.linalg.norm( + mesh.vertices[mesh.edges[:, 0]] - mesh.vertices[mesh.edges[:, 1]], axis=1 + ).max() + max_iter = max(int(np.ceil(np.log2(longest_edge / max_edge))), 0) + + # get the same mesh sudivided so every edge is shorter + # than a factor of our pitch + v, _f, _idx = remesh.subdivide_to_size( + mesh.vertices, mesh.faces, max_edge=max_edge, max_iter=max_iter, return_index=True + ) + + # convert the vertices to their voxel grid position + # Provided edge_factor > 1 and max_iter is large enough, this is + # sufficient to preserve 6-connectivity at the level of voxels. + hit = np.round(v / pitch).astype(int) + + # remove duplicates + unique, _inverse = grouping.unique_rows(hit) + + # get the voxel centers in model space + occupied_index = hit[unique] + + origin_index = occupied_index.min(axis=0) + origin_position = origin_index * pitch + + return base.VoxelGrid( + enc.SparseBinaryEncoding(occupied_index - origin_index), + transform=tr.scale_and_translate(scale=pitch, translate=origin_position), + ) + + +def local_voxelize( + mesh, + point: ArrayLike, + pitch: Number, + radius: Number, + fill: bool = True, + **kwargs, +) -> base.VoxelGrid | None: + """ + Voxelize a mesh in the region of a cube around a point. When fill=True, + uses proximity.contains to fill the resulting voxels so may be meaningless + for non-watertight meshes. Useful to reduce memory cost for small values of + pitch as opposed to global voxelization. + + Parameters + ----------- + mesh : trimesh.Trimesh + Source geometry + point : (3, ) float + Point in space to voxelize around + pitch + Side length of a single voxel cube + radius + Number of voxel cubes to return in each direction. + kwargs + Parameters to pass to voxelize_subdivide + + Returns + ----------- + voxels : VoxelGrid instance with resolution (m, m, m) where m=2*radius+1 + or None if the volume is empty + """ + from scipy import ndimage + + # make sure point is correct type/shape + point = np.asanyarray(point, dtype=np.float64).reshape(3) + # this is a gotcha- radius sounds a lot like it should be in + # float model space, not int voxel space so check + if not isinstance(radius, int): + raise ValueError("radius needs to be an integer number of cubes!") + + # Bounds of region + bounds = np.concatenate( + (point - (radius + 0.5) * pitch, point + (radius + 0.5) * pitch) + ) + + # faces that intersect axis aligned bounding box + faces = list(mesh.triangles_tree.intersection(bounds)) + + # didn't hit anything so exit + if len(faces) == 0: + return None + + local = mesh.submesh([[f] for f in faces], append=True) + + # Translate mesh so point is at 0,0,0 + local.apply_translation(-point) + + # sparse, origin = voxelize_subdivide(local, pitch, **kwargs) + vox = voxelize_subdivide(local, pitch, **kwargs) + origin = vox.transform[:3, 3] + matrix = vox.encoding.dense + + # Find voxel index for point + center = np.round(-origin / pitch).astype(np.int64) + + # pad matrix if necessary + prepad = np.maximum(radius - center, 0) + postpad = np.maximum(center + radius + 1 - matrix.shape, 0) + + matrix = np.pad(matrix, np.stack((prepad, postpad), axis=-1), mode="constant") + center += prepad + + # Extract voxels within the bounding box + voxels = matrix[ + center[0] - radius : center[0] + radius + 1, + center[1] - radius : center[1] + radius + 1, + center[2] - radius : center[2] + radius + 1, + ] + local_origin = point - radius * pitch # origin of local voxels + + # Fill internal regions + if fill: + regions, n = ndimage.label(~voxels) + distance = ndimage.distance_transform_cdt(~voxels) + representatives = [ + np.unravel_index((distance * (regions == i)).argmax(), distance.shape) + for i in range(1, n + 1) + ] + contains = mesh.contains(np.asarray(representatives) * pitch + local_origin) + where = np.where(contains)[0] + 1 + internal = np.isin(regions.flatten(), where).reshape(regions.shape) + voxels = np.logical_or(voxels, internal) + + return base.VoxelGrid(voxels, tr.translation_matrix(local_origin)) + + +@log_time +def voxelize_ray( + mesh, pitch: Number, per_cell: ArrayLike | None = None +) -> base.VoxelGrid: + """ + Voxelize a mesh using ray queries. + + Parameters + ------------- + mesh + Mesh to be voxelized + pitch + Length of voxel cube + per_cell : (2,) int + How many ray queries to make per cell + + Returns + ------------- + grid + VoxelGrid instance representing the voxelized mesh. + """ + if per_cell is None: + # how many rays per cell + per_cell = np.array([2, 2], dtype=np.int64) + else: + per_cell = np.array(per_cell, dtype=np.int64).reshape(2) + + # edge length of cube voxels + pitch = float(pitch) + + # create the ray origins in a grid + bounds = mesh.bounds[:, :2].copy() + # offset start so we get the requested number per cell + bounds[0] += pitch / (1.0 + per_cell) + # offset end so arange doesn't short us + bounds[1] += pitch + # on X we are doing multiple rays per voxel step + step = pitch / per_cell + # 2D grid + ray_ori = util.grid_arange(bounds, step=step) + # a Z position below the mesh + z = np.ones(len(ray_ori)) * (mesh.bounds[0][2] - pitch) + ray_ori = np.column_stack((ray_ori, z)) + # all rays are along positive Z + ray_dir = np.ones_like(ray_ori) * [0, 0, 1] + + # if you have pyembree this should be decently fast + hits = mesh.ray.intersects_location(ray_ori, ray_dir)[0] + + # just convert hit locations to integer positions + voxels = np.round(hits / pitch).astype(np.int64) + + # offset voxels by min, so matrix isn't huge + origin_index = voxels.min(axis=0) + voxels -= origin_index + encoding = enc.SparseBinaryEncoding(voxels) + origin_position = origin_index * pitch + return base.VoxelGrid( + encoding, tr.scale_and_translate(scale=pitch, translate=origin_position) + ) + + +@log_time +def voxelize_binvox( + mesh, + pitch: Number | None = None, + dimension: Integer | None = None, + bounds: ArrayLike | None = None, + **binvoxer_kwargs, +) -> base.VoxelGrid: + """ + Voxelize via binvox tool. + + Parameters + -------------- + mesh : trimesh.Trimesh + Mesh to voxelize + pitch : float + Side length of each voxel. Ignored if dimension is provided + dimension: int + Number of voxels along each dimension. If not provided, this is + calculated based on pitch and bounds/mesh extents + bounds: (2, 3) float + min/max values of the returned `VoxelGrid` in each instance. Uses + `mesh.bounds` if not provided. + **binvoxer_kwargs: + Passed to `trimesh.exchange.binvox.Binvoxer`. + Should not contain `bounding_box` if bounds is not None. + + Returns + -------------- + grid + `VoxelGrid` instance + + Raises + -------------- + `ValueError` if `bounds is not None and 'bounding_box' in binvoxer_kwargs`. + """ + from trimesh.exchange import binvox + + if dimension is None: + # pitch must be provided + if bounds is None: + extents = mesh.extents + else: + mins, maxs = bounds + extents = maxs - mins + dimension = int(np.ceil(np.max(extents) / pitch)) + if bounds is not None: + if "bounding_box" in binvoxer_kwargs: + raise ValueError("Cannot provide both bounds and bounding_box") + binvoxer_kwargs["bounding_box"] = np.asanyarray(bounds).flatten() + + binvoxer = binvox.Binvoxer(dimension=dimension, **binvoxer_kwargs) + return binvox.voxelize_mesh(mesh, binvoxer) + + +voxelizers = util.FunctionRegistry( + ray=voxelize_ray, subdivide=voxelize_subdivide, binvox=voxelize_binvox +) + + +def voxelize( + mesh, + pitch: Number | None, + method: VoxelizationMethodsType = "subdivide", + **kwargs, +) -> base.VoxelGrid | None: + """ + Voxelize the given mesh using the specified implementation. + + See `voxelizers` for available implementations or to add your own, e.g. via + `voxelizers['custom_key'] = custom_fn`. + + `custom_fn` should have signature `(mesh, pitch, **kwargs) -> VoxelGrid` + and should not modify encoding. + + Parameters + -------------- + mesh + Geometry to voxelize + pitch + Side length of each voxel. + method + Which voxelization method to use. + kwargs + Passed through to the specified implementation. + + Returns + -------------- + grid + A VoxelGrid instance. + """ + return voxelizers(method, mesh=mesh, pitch=pitch, **kwargs) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/encoding.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/encoding.py new file mode 100644 index 0000000000000000000000000000000000000000..4fcb971739a7c5c7f7666579b197b0af6a57cc70 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/encoding.py @@ -0,0 +1,979 @@ +"""OO interfaces to encodings for ND arrays which caching.""" + +import abc + +import numpy as np + +from .. import caching +from ..util import ABC +from . import runlength + +try: + from scipy import sparse as sp +except BaseException as E: + from ..exceptions import ExceptionWrapper + + sp = ExceptionWrapper(E) + + +def _empty_stripped(shape): + num_dims = len(shape) + encoding = DenseEncoding(np.zeros(shape=(0,) * num_dims, dtype=bool)) + padding = np.zeros(shape=(num_dims, 2), dtype=int) + padding[:, 1] = shape + return encoding, padding + + +class Encoding(ABC): + """ + Base class for objects that implement a specific subset of of ndarray ops. + + This presents a unified interface for various different ways of encoding + conceptually dense arrays and to interoperate between them. + + Example implementations are ND sparse arrays, run length encoded arrays + and dense encodings (wrappers around np.ndarrays). + """ + + def __init__(self, data): + self._data = data + self._cache = caching.Cache(id_function=self._data.__hash__) + + @property + @abc.abstractmethod + def dtype(self): + pass + + @property + @abc.abstractmethod + def shape(self): + pass + + @property + @abc.abstractmethod + def sum(self): + pass + + @property + @abc.abstractmethod + def size(self): + pass + + @property + @abc.abstractmethod + def sparse_indices(self): + pass + + @property + @abc.abstractmethod + def sparse_values(self): + pass + + @property + @abc.abstractmethod + def dense(self): + pass + + @abc.abstractmethod + def gather_nd(self, indices): + pass + + @abc.abstractmethod + def mask(self, mask): + pass + + @abc.abstractmethod + def get_value(self, index): + pass + + @abc.abstractmethod + def copy(self): + pass + + @property + def is_empty(self): + return self.sparse_indices[self.sparse_values != 0].size == 0 + + @caching.cache_decorator + def stripped(self): + """ + Get encoding with all zeros stripped from the start and end + of each axis. + + Returns + ------------ + encoding: ? + padding : (n, 2) int + Padding at the start and end that was stripped + """ + if self.is_empty: + return _empty_stripped(self.shape) + dense = self.dense + shape = dense.shape + ndims = len(shape) + padding = [] + slices = [] + for dim, size in enumerate(shape): + axis = tuple(range(dim)) + tuple(range(dim + 1, ndims)) + filled = np.any(dense, axis=axis) + (indices,) = np.nonzero(filled) + lower = indices.min() + upper = indices.max() + 1 + padding.append([lower, size - upper]) + slices.append(slice(lower, upper)) + return DenseEncoding(dense[tuple(slices)]), np.array(padding, int) + + def _flip(self, axes): + return FlippedEncoding(self, axes) + + def __hash__(self): + """ + Get the hash of the current transformation matrix. + + Returns + ------------ + hash : str + Hash of transformation matrix + """ + return self._data.__hash__() + + @property + def ndims(self): + return len(self.shape) + + def reshape(self, shape): + return self.flat if len(shape) == 1 else ShapedEncoding(self, shape) + + @property + def flat(self): + return FlattenedEncoding(self) + + def flip(self, axis=0): + return _flipped(self, axis) + + @property + def sparse_components(self): + return self.sparse_indices, self.sparse_values + + @property + def data(self): + return self._data + + def run_length_data(self, dtype=np.int64): + if self.ndims != 1: + raise ValueError("`run_length_data` only valid for flat encodings") + return runlength.dense_to_rle(self.dense, dtype=dtype) + + def binary_run_length_data(self, dtype=np.int64): + if self.ndims != 1: + raise ValueError("`run_length_data` only valid for flat encodings") + return runlength.dense_to_brle(self.dense, dtype=dtype) + + def transpose(self, perm): + return _transposed(self, perm) + + def _transpose(self, perm): + return TransposedEncoding(self, perm) + + @property + def mutable(self): + return self._data.mutable + + @mutable.setter + def mutable(self, value): + self._data.mutable = value + + +class DenseEncoding(Encoding): + """Simple `Encoding` implementation based on a numpy ndarray.""" + + def __init__(self, data): + if not isinstance(data, caching.TrackedArray): + if not isinstance(data, np.ndarray): + raise ValueError("DenseEncoding data must be a numpy array") + data = caching.tracked_array(data) + super().__init__(data=data) + + @property + def dtype(self): + return self._data.dtype + + @property + def shape(self): + return self._data.shape + + @caching.cache_decorator + def sum(self): + return self._data.sum() + + @caching.cache_decorator + def is_empty(self): + return not np.any(self._data) + + @property + def size(self): + return self._data.size + + @property + def sparse_components(self): + indices = self.sparse_indices + values = self.gather(indices) + return indices, values + + @caching.cache_decorator + def sparse_indices(self): + return np.column_stack(np.where(self._data)) + + @caching.cache_decorator + def sparse_values(self): + return self.sparse_components[1] + + def _flip(self, axes): + dense = self.dense + for a in axes: + dense = np.flip(dense, a) + return DenseEncoding(dense) + + @property + def dense(self): + return self._data + + def gather(self, indices): + return self._data[indices] + + def gather_nd(self, indices): + return self._data[tuple(indices.T)] + + def mask(self, mask): + return self._data[mask if isinstance(mask, np.ndarray) else mask.dense] + + def get_value(self, index): + return self._data[tuple(index)] + + def reshape(self, shape): + return DenseEncoding(self._data.reshape(shape)) + + def _transpose(self, perm): + return DenseEncoding(self._data.transpose(perm)) + + @property + def flat(self): + return DenseEncoding(self._data.reshape((-1,))) + + def copy(self): + return DenseEncoding(self._data.copy()) + + +class SparseEncoding(Encoding): + """ + `Encoding` implementation based on an ND sparse implementation. + + Since the scipy.sparse implementations are for 2D arrays only, this + implementation uses a single-column CSC matrix with index + raveling/unraveling. + """ + + def __init__(self, indices, values, shape=None): + """ + Parameters + ------------ + indices: (m, n)-sized int array of indices + values: (m, n)-sized dtype array of values at the specified indices + shape: (n,) iterable of integers. If None, the maximum value of indices + + 1 is used. + """ + data = caching.DataStore() + super().__init__(data) + data["indices"] = indices + data["values"] = values + indices = data["indices"] + if len(indices.shape) != 2: + raise ValueError(f"indices must be 2D, got shaped {indices.shape!s}") + if data["values"].shape != (indices.shape[0],): + raise ValueError( + "values and indices shapes inconsistent: {} and {}".format( + data["values"], data["indices"] + ) + ) + if shape is None: + self._shape = tuple(data["indices"].max(axis=0) + 1) + else: + self._shape = tuple(shape) + if not np.all(indices < self._shape): + raise ValueError("all indices must be less than shape") + if not np.all(indices >= 0): + raise ValueError("all indices must be non-negative") + + @staticmethod + def from_dense(dense_data): + sparse_indices = np.where(dense_data) + values = dense_data[sparse_indices] + return SparseEncoding( + np.stack(sparse_indices, axis=-1), values, shape=dense_data.shape + ) + + def copy(self): + return SparseEncoding( + indices=self.sparse_indices.copy(), + values=self.sparse_values.copy(), + shape=self.shape, + ) + + @property + def sparse_indices(self): + return self._data["indices"] + + @property + def sparse_values(self): + return self._data["values"] + + @property + def dtype(self): + return self.sparse_values.dtype + + @caching.cache_decorator + def sum(self): + return self.sparse_values.sum() + + @property + def ndims(self): + return self.sparse_indices.shape[-1] + + @property + def shape(self): + return self._shape + + @property + def size(self): + return np.prod(self.shape) + + @property + def sparse_components(self): + return self.sparse_indices, self.sparse_values + + @caching.cache_decorator + def dense(self): + sparse = self._csc + # sparse.todense gives an `np.matrix` which cannot be reshaped + dense = np.zeros(shape=sparse.shape, dtype=sparse.dtype) + sparse.todense(out=dense) + return np.reshape(dense, self.shape) + + @caching.cache_decorator + def _csc(self): + values = self.sparse_values + indices = self._flat_indices(self.sparse_indices) + indptr = [0, len(indices)] + return sp.csc_matrix((values, indices, indptr), shape=(self.size, 1)) + + def _flat_indices(self, indices): + assert indices.shape[1] == 3 and len(indices.shape) == 2 + return np.ravel_multi_index(indices.T, self.shape) + + def _shaped_indices(self, flat_indices): + return np.column_stack(np.unravel_index(flat_indices, self.shape)) + + def gather_nd(self, indices): + mat = self._csc[self._flat_indices(indices)].todense() + # mat is a np matrix, which stays rank 2 after squeeze + # np.asarray changes this to a standard rank 2 array. + return np.asarray(mat).squeeze(axis=-1) + + def mask(self, mask): + i, _ = np.where(self._csc[mask.reshape((-1,))]) + return self._shaped_indices(i) + + def get_value(self, index): + return self._gather_nd(np.expand_dims(index, axis=0))[0] + + @caching.cache_decorator + def stripped(self): + """ + Get encoding with all zeros stripped from the start/end of each axis. + + Returns: + encoding: SparseEncoding with same values but indices shifted down + by padding[:, 0] + padding: (n, 2) array of ints denoting padding at the start/end + that was stripped + """ + if self.is_empty: + return _empty_stripped(self.shape) + indices = self.sparse_indices + pad_left = np.min(indices, axis=0) + pad_right = np.max(indices, axis=0) + pad_right *= -1 + pad_right += self.shape + padding = np.column_stack((pad_left, pad_right)) + return SparseEncoding(indices - pad_left, self.sparse_values), padding + + +def SparseBinaryEncoding(indices, shape=None): + """ + Convenient factory constructor for SparseEncodings with values all ones. + + Parameters + ------------ + indices: (m, n) sparse indices into conceptual rank-n array + shape: length n iterable or None. If None, maximum of indices along first + axis + 1 is used + + Returns + ------------ + rank n bool `SparseEncoding` with True values at each index. + """ + return SparseEncoding(indices, np.ones(shape=(indices.shape[0],), dtype=bool), shape) + + +class RunLengthEncoding(Encoding): + """1D run length encoding. + + See `trimesh.voxel.runlength` documentation for implementation details. + """ + + def __init__(self, data, dtype=None): + """ + Parameters + ------------ + data: run length encoded data. + dtype: dtype of encoded data. Each second value of data is cast will be + cast to this dtype if provided. + """ + super().__init__(data=caching.tracked_array(data)) + if dtype is None: + dtype = self._data.dtype + if len(self._data.shape) != 1: + raise ValueError("data must be 1D numpy array") + self._dtype = dtype + + @caching.cache_decorator + def is_empty(self): + return not np.any(np.logical_and(self._data[::2], self._data[1::2])) + + @property + def ndims(self): + return 1 + + @property + def shape(self): + return (self.size,) + + @property + def dtype(self): + return self._dtype + + def __hash__(self): + """ + Get the hash of the current transformation matrix. + + Returns + ------------ + hash : str + Hash of transformation matrix + """ + return self._data.__hash__() + + @staticmethod + def from_dense(dense_data, dtype=np.int64, encoding_dtype=np.int64): + return RunLengthEncoding( + runlength.dense_to_rle(dense_data, dtype=encoding_dtype), dtype=dtype + ) + + @staticmethod + def from_rle(rle_data, dtype=None): + if dtype != rle_data.dtype: + rle_data = runlength.rle_to_rle(rle_data, dtype=dtype) + return RunLengthEncoding(rle_data) + + @staticmethod + def from_brle(brle_data, dtype=None): + return RunLengthEncoding(runlength.brle_to_rle(brle_data, dtype=dtype)) + + @caching.cache_decorator + def stripped(self): + if self.is_empty: + return _empty_stripped(self.shape) + data, padding = runlength.rle_strip(self._data) + if padding == (0, 0): + encoding = self + else: + encoding = RunLengthEncoding(data, dtype=self._dtype) + padding = np.expand_dims(padding, axis=0) + return encoding, padding + + @caching.cache_decorator + def sum(self): + return (self._data[::2] * self._data[1::2]).sum() + + @caching.cache_decorator + def size(self): + return runlength.rle_length(self._data) + + def _flip(self, axes): + if axes != (0,): + raise ValueError(f"encoding is 1D - cannot flip on axis {axes!s}") + return RunLengthEncoding(runlength.rle_reverse(self._data)) + + @caching.cache_decorator + def sparse_components(self): + return runlength.rle_to_sparse(self._data) + + @caching.cache_decorator + def sparse_indices(self): + return self.sparse_components[0] + + @caching.cache_decorator + def sparse_values(self): + return self.sparse_components[1] + + @caching.cache_decorator + def dense(self): + return runlength.rle_to_dense(self._data, dtype=self._dtype) + + def gather(self, indices): + return runlength.rle_gather_1d(self._data, indices, dtype=self._dtype) + + def gather_nd(self, indices): + indices = np.squeeze(indices, axis=-1) + return self.gather(indices) + + def sorted_gather(self, ordered_indices): + return np.array( + tuple(runlength.sorted_rle_gather_1d(self._data, ordered_indices)), + dtype=self._dtype, + ) + + def mask(self, mask): + return np.array(tuple(runlength.rle_mask(self._data, mask)), dtype=self._dtype) + + def get_value(self, index): + for value in self.sorted_gather((index,)): + return np.asanyarray(value, dtype=self._dtype) + + def copy(self): + return RunLengthEncoding(self._data.copy(), dtype=self.dtype) + + def run_length_data(self, dtype=np.int64): + return runlength.rle_to_rle(self._data, dtype=dtype) + + def binary_run_length_data(self, dtype=np.int64): + return runlength.rle_to_brle(self._data, dtype=dtype) + + +class BinaryRunLengthEncoding(RunLengthEncoding): + """1D binary run length encoding. + + See `trimesh.voxel.runlength` documentation for implementation details. + """ + + def __init__(self, data): + """ + Parameters + ------------ + data: binary run length encoded data. + """ + super().__init__(data=data, dtype=bool) + + @caching.cache_decorator + def is_empty(self): + return not np.any(self._data[1::2]) + + @staticmethod + def from_dense(dense_data, encoding_dtype=np.int64): + return BinaryRunLengthEncoding( + runlength.dense_to_brle(dense_data, dtype=encoding_dtype) + ) + + @staticmethod + def from_rle(rle_data, dtype=None): + return BinaryRunLengthEncoding(runlength.rle_to_brle(rle_data, dtype=dtype)) + + @staticmethod + def from_brle(brle_data, dtype=None): + if dtype != brle_data.dtype: + brle_data = runlength.brle_to_brle(brle_data, dtype=dtype) + return BinaryRunLengthEncoding(brle_data) + + @caching.cache_decorator + def stripped(self): + if self.is_empty: + return _empty_stripped(self.shape) + data, padding = runlength.rle_strip(self._data) + if padding == (0, 0): + encoding = self + else: + encoding = BinaryRunLengthEncoding(data) + padding = np.expand_dims(padding, axis=0) + return encoding, padding + + @caching.cache_decorator + def sum(self): + return self._data[1::2].sum() + + @caching.cache_decorator + def size(self): + return runlength.brle_length(self._data) + + def _flip(self, axes): + if axes != (0,): + raise ValueError(f"encoding is 1D - cannot flip on axis {axes!s}") + return BinaryRunLengthEncoding(runlength.brle_reverse(self._data)) + + @property + def sparse_components(self): + return self.sparse_indices, self.sparse_values + + @caching.cache_decorator + def sparse_values(self): + return np.ones(shape=(self.sum,), dtype=bool) + + @caching.cache_decorator + def sparse_indices(self): + return runlength.brle_to_sparse(self._data) + + @caching.cache_decorator + def dense(self): + return runlength.brle_to_dense(self._data) + + def gather(self, indices): + return runlength.brle_gather_1d(self._data, indices) + + def gather_nd(self, indices): + indices = np.squeeze(indices) + return self.gather(indices) + + def sorted_gather(self, ordered_indices): + gen = runlength.sorted_brle_gather_1d(self._data, ordered_indices) + return np.array(tuple(gen), dtype=bool) + + def mask(self, mask): + gen = runlength.brle_mask(self._data, mask) + return np.array(tuple(gen), dtype=bool) + + def copy(self): + return BinaryRunLengthEncoding(self._data.copy()) + + def run_length_data(self, dtype=np.int64): + return runlength.brle_to_rle(self._data, dtype=dtype) + + def binary_run_length_data(self, dtype=np.int64): + return runlength.brle_to_brle(self._data, dtype=dtype) + + +class LazyIndexMap(Encoding): + """ + Abstract class for implementing lazy index mapping operations. + + Implementations include transpose, flatten/reshaping and flipping + + Derived classes must implement: + * _to_base_indices(indices) + * _from_base_indices(base_indices) + * shape + * dense + * mask(mask) + """ + + @abc.abstractmethod + def _to_base_indices(self, indices): + pass + + @abc.abstractmethod + def _from_base_indices(self, base_indices): + pass + + @property + def is_empty(self): + return self._data.is_empty + + @property + def dtype(self): + return self._data.dtype + + @property + def sum(self): + return self._data.sum + + @property + def size(self): + return self._data.size + + @property + def sparse_indices(self): + return self._from_base_indices(self._data.sparse_indices) + + @property + def sparse_values(self): + return self._data.sparse_values + + def gather_nd(self, indices): + return self._data.gather_nd(self._to_base_indices(indices)) + + def get_value(self, index): + return self._data[tuple(self._to_base_indices(index))] + + +class FlattenedEncoding(LazyIndexMap): + """ + Lazily flattened encoding. + + Dense equivalent is np.reshape(data, (-1,)) (np.flatten creates a copy). + """ + + def _to_base_indices(self, indices): + return np.column_stack(np.unravel_index(indices, self._data.shape)) + + def _from_base_indices(self, base_indices): + return np.expand_dims( + np.ravel_multi_index(base_indices.T, self._data.shape), axis=-1 + ) + + @property + def shape(self): + return (self.size,) + + @property + def dense(self): + return self._data.dense.reshape((-1,)) + + def mask(self, mask): + return self._data.mask(mask.reshape(self._data.shape)) + + @property + def flat(self): + return self + + def copy(self): + return FlattenedEncoding(self._data.copy()) + + +class ShapedEncoding(LazyIndexMap): + """ + Lazily reshaped encoding. + + Numpy equivalent is `np.reshape` + """ + + def __init__(self, encoding, shape): + if isinstance(encoding, Encoding): + if encoding.ndims != 1: + encoding = encoding.flat + else: + raise ValueError("encoding must be an Encoding") + super().__init__(data=encoding) + self._shape = tuple(shape) + nn = self._shape.count(-1) + size = np.prod(self._shape) + if nn == 1: + size = np.abs(size) + if self._data.size % size != 0: + raise ValueError( + "cannot reshape encoding of size %d into shape %s", + self._data.size, + str(self._shape), + ) + + rem = self._data.size // size + self._shape = tuple(rem if s == -1 else s for s in self._shape) + elif nn > 2: + raise ValueError("shape cannot have more than one -1 value") + elif np.prod(self._shape) != self._data.size: + raise ValueError( + "cannot reshape encoding of size %d into shape %s", + self._data.size, + str(self._shape), + ) + + def _from_base_indices(self, base_indices): + return np.column_stack(np.unravel_index(base_indices, self.shape)) + + def _to_base_indices(self, indices): + return np.expand_dims(np.ravel_multi_index(indices.T, self.shape), axis=-1) + + @property + def flat(self): + return self._data + + @property + def shape(self): + return self._shape + + @property + def dense(self): + return self._data.dense.reshape(self.shape) + + def mask(self, mask): + return self._data.mask(mask.flat) + + def copy(self): + return ShapedEncoding(encoding=self._data.copy(), shape=self.shape) + + +class TransposedEncoding(LazyIndexMap): + """ + Lazily transposed encoding + + Dense equivalent is `np.transpose` + """ + + def __init__(self, base_encoding, perm): + if not isinstance(base_encoding, Encoding): + raise ValueError(f"base_encoding must be an Encoding, got {base_encoding!s}") + if len(base_encoding.shape) != len(perm): + raise ValueError( + "base_encoding has %d ndims - cannot transpose with perm %s", + base_encoding.ndims, + str(perm), + ) + + super().__init__(base_encoding) + perm = np.array(perm, dtype=np.int64) + if not all(i in perm for i in range(base_encoding.ndims)): + raise ValueError(f"perm {perm!s} is not a valid permutation") + inv_perm = np.zeros_like(perm) + inv_perm[perm] = np.arange(base_encoding.ndims) + self._perm = perm + self._inv_perm = inv_perm + + def transpose(self, perm): + return _transposed(self._data, [self._perm[p] for p in perm]) + + def _transpose(self, perm): + raise RuntimeError("Should not be here") + + @property + def perm(self): + return self._perm + + @property + def shape(self): + shape = self._data.shape + return tuple(shape[p] for p in self._perm) + + def _to_base_indices(self, indices): + return np.take(indices, self._perm, axis=-1) + + def _from_base_indices(self, base_indices): + try: + return np.take(base_indices, self._inv_perm, axis=-1) + except TypeError: + # windows sometimes tries to use wrong dtypes + return np.take( + base_indices.astype(np.int64), self._inv_perm.astype(np.int64), axis=-1 + ) + + @property + def dense(self): + return self._data.dense.transpose(self._perm) + + def gather(self, indices): + return self._data.gather(self._base_indices(indices)) + + def mask(self, mask): + return self._data.mask(mask.transpose(self._inv_perm)).transpose(self._perm) + + def get_value(self, index): + return self._data[tuple(self._base_indices(index))] + + @property + def data(self): + return self._data + + def copy(self): + return TransposedEncoding(base_encoding=self._data.copy(), perm=self._perm) + + +class FlippedEncoding(LazyIndexMap): + """ + Encoding with entries flipped along one or more axes. + + Dense equivalent is `np.flip` + """ + + def __init__(self, encoding, axes): + ndims = encoding.ndims + if isinstance(axes, np.ndarray) and axes.size == 1: + axes = (axes.item(),) + elif isinstance(axes, int): + axes = (axes,) + axes = tuple(a + ndims if a < 0 else a for a in axes) + self._axes = tuple(sorted(axes)) + if len(set(self._axes)) != len(self._axes): + raise ValueError(f"Axes cannot contain duplicates, got {self._axes!s}") + super().__init__(encoding) + if not all(0 <= a < self._data.ndims for a in axes): + raise ValueError( + "Invalid axes %s for %d-d encoding", str(axes), self._data.ndims + ) + + def _to_base_indices(self, indices): + indices = indices.copy() + shape = self.shape + for a in self._axes: + indices[:, a] *= -1 + indices[:, a] += shape + return indices + + def _from_base_indices(self, base_indices): + return self._to_base_indices(base_indices) + + @property + def shape(self): + return self._data.shape + + @property + def dense(self): + dense = self._data.dense + for a in self._axes: + dense = np.flip(dense, a) + return dense + + def mask(self, mask): + if not isinstance(mask, Encoding): + mask = DenseEncoding(mask) + mask = mask.flip(self._axes) + return self._data.mask(mask).flip(self._axes) + + def copy(self): + return FlippedEncoding(self._data.copy(), self._axes) + + def flip(self, axis=0): + if isinstance(axis, np.ndarray): + if axis.size == 1: + axis = (axis.item(),) + else: + axis = tuple(axis) + elif isinstance(axis, int): + axes = (axis,) + else: + axes = tuple(axis) + return _flipped(self, self._axes + axes) + + def _flip(self, axes): + raise RuntimeError("Should not be here") + + +def _flipped(encoding, axes): + if not hasattr(axes, "__iter__"): + axes = (axes,) + unique_ax = set() + ndims = encoding.ndims + axes = tuple(a + ndims if a < 0 else a for a in axes) + for a in axes: + if a in unique_ax: + unique_ax.remove(a) + else: + unique_ax.add(a) + if len(unique_ax) == 0: + return encoding + else: + return encoding._flip(tuple(sorted(unique_ax))) + + +def _transposed(encoding, perm): + ndims = encoding.ndims + perm = tuple(p + ndims if p < 0 else p for p in perm) + if np.all(np.arange(ndims) == perm): + return encoding + else: + return encoding._transpose(perm) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/morphology.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/morphology.py new file mode 100644 index 0000000000000000000000000000000000000000..38692cca39b95b65b65acb23de39fde62b04fcea --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/morphology.py @@ -0,0 +1,185 @@ +"""Basic morphology operations that create new encodings.""" + +import numpy as np + +from .. import util +from ..constants import log_time +from . import encoding as enc +from . import ops + +try: + from scipy import ndimage +except BaseException as E: + # scipy is a soft dependency + from ..exceptions import ExceptionWrapper + + ndimage = ExceptionWrapper(E) + + +def _dense(encoding, rank=None): + if isinstance(encoding, np.ndarray): + dense = encoding + elif isinstance(encoding, enc.Encoding): + dense = encoding.dense + else: + raise ValueError(f"encoding must be np.ndarray or Encoding, got {encoding!s}") + if rank: + _assert_rank(dense, rank) + return dense + + +def _sparse_indices(encoding, rank=None): + if isinstance(encoding, np.ndarray): + sparse_indices = encoding + elif isinstance(encoding, enc.Encoding): + sparse_indices = encoding.sparse_indices + else: + raise ValueError(f"encoding must be np.ndarray or Encoding, got {encoding!s}") + + _assert_sparse_rank(sparse_indices, 3) + return sparse_indices + + +def _assert_rank(value, rank): + if len(value.shape) != rank: + raise ValueError("Expected rank %d, got shape %s", rank, str(value.shape)) + + +def _assert_sparse_rank(value, rank=None): + if len(value.shape) != 2: + raise ValueError(f"sparse_indices must be rank 2, got shape {value.shape!s}") + if rank is not None: + if value.shape[-1] != rank: + raise ValueError( + "sparse_indices.shape[1] must be %d, got %d", rank, value.shape[-1] + ) + + +@log_time +def fill_base(encoding): + """ + Given a sparse surface voxelization, fill in between columns. + + Parameters + -------------- + encoding: Encoding object or sparse array with shape (?, 3) + + Returns + -------------- + A new filled encoding object. + """ + return enc.SparseBinaryEncoding(ops.fill_base(_sparse_indices(encoding, rank=3))) + + +@log_time +def fill_orthographic(encoding): + """ + Fill the given encoding by orthographic projection method. + + Any voxel in the dense representation with no free ray along the x, y, z + axes in each direction is assigned filled. This is likely faster than fill + holes, and is more stable with regards to small holes. + + Parameters + -------------- + encoding: Encoding object or dense rank-3 array. + + Returns + -------------- + A new filled encoding object. + """ + return enc.DenseEncoding(ops.fill_orthographic(_dense(encoding, rank=3))) + + +@log_time +def fill_holes(encoding, **kwargs): + """ + Encoding wrapper around scipy.ndimage.morphology.binary_fill_holes. + + https://docs.scipy.org/doc/scipy-0.15.1/reference/generated/scipy.ndimage.morphology.binary_fill_holes.html#scipy.ndimage.morphology.binary_fill_holes + + Parameters + -------------- + encoding: Encoding object or dense rank-3 array. + **kwargs: see scipy.ndimage.morphology.binary_fill_holes. + + Returns + -------------- + A new filled in encoding object. + """ + return enc.DenseEncoding( + ndimage.binary_fill_holes(_dense(encoding, rank=3), **kwargs) + ) + + +fillers = util.FunctionRegistry( + base=fill_base, + orthographic=fill_orthographic, + holes=fill_holes, +) + + +def fill(encoding, method="base", **kwargs): + """ + Fill the given encoding using the specified implementation. + + See `fillers` for available implementations or to add your own, e.g. via + `fillers['custom_key'] = custom_fn`. + + `custom_fn` should have signature `(encoding, **kwargs) -> filled_encoding` + and should not modify encoding. + + Parameters + -------------- + encoding: Encoding object (left unchanged). + method: method present in `fillers`. + **kwargs: additional kwargs passed to the specified implementation. + + Returns + -------------- + A new filled Encoding object. + """ + return fillers(method, encoding=encoding, **kwargs) + + +def binary_dilation(encoding, **kwargs): + """ + Encoding wrapper around scipy.ndimage.morphology.binary_dilation. + + https://docs.scipy.org/doc/scipy-0.15.1/reference/generated/scipy.ndimage.morphology.binary_dilation.html#scipy.ndimage.morphology.binary_dilation + """ + return enc.DenseEncoding(ndimage.binary_dilation(_dense(encoding, rank=3), **kwargs)) + + +def binary_closing(encoding, **kwargs): + """ + Encoding wrapper around scipy.ndimage.morphology.binary_closing. + + https://docs.scipy.org/doc/scipy-0.15.1/reference/generated/scipy.ndimage.morphology.binary_closing.html#scipy.ndimage.morphology.binary_closing + """ + return enc.DenseEncoding(ndimage.binary_closing(_dense(encoding, rank=3), **kwargs)) + + +def surface(encoding, structure=None): + """ + Get elements on the surface of encoding. + + A surface element is any one in encoding that is adjacent to an empty + voxel. + + Parameters + -------------- + encoding: Encoding or dense rank-3 array + structure: adjacency structure. If None, square connectivity is used. + + Returns + -------------- + new surface Encoding. + """ + dense = _dense(encoding, rank=3) + # padding/unpadding resolves issues with occupied voxels on the boundary + dense = np.pad(dense, np.ones((3, 2), dtype=int), mode="constant") + empty = np.logical_not(dense) + dilated = ndimage.binary_dilation(empty, structure=structure) + surface = np.logical_and(dense, dilated)[1:-1, 1:-1, 1:-1] + return enc.DenseEncoding(surface) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/ops.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/ops.py new file mode 100644 index 0000000000000000000000000000000000000000..967c661d8c97c078b3ff6bbec1b91b462678bc42 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/ops.py @@ -0,0 +1,454 @@ +import numpy as np + +from .. import util +from ..constants import log +from ..typed import ArrayLike, Number + + +def fill_orthographic(dense): + shape = dense.shape + indices = np.stack( + np.meshgrid(*(np.arange(s) for s in shape), indexing="ij"), axis=-1 + ) + empty = np.logical_not(dense) + + def fill_axis(axis): + base_local_indices = indices[..., axis] + local_indices = base_local_indices.copy() + local_indices[empty] = shape[axis] + mins = np.min(local_indices, axis=axis, keepdims=True) + local_indices = base_local_indices.copy() + local_indices[empty] = -1 + maxs = np.max(local_indices, axis=axis, keepdims=True) + + return np.logical_and( + base_local_indices >= mins, + base_local_indices <= maxs, + ) + + filled = fill_axis(axis=0) + for axis in range(1, len(shape)): + filled = np.logical_and(filled, fill_axis(axis)) + return filled + + +def fill_base(sparse_indices): + """ + Given a sparse surface voxelization, fill in between columns. + + Parameters + -------------- + sparse_indices: (n, 3) int, location of filled cells + + Returns + -------------- + filled: (m, 3) int, location of filled cells + """ + # validate inputs + sparse_indices = np.asanyarray(sparse_indices, dtype=np.int64) + if not util.is_shape(sparse_indices, (-1, 3)): + raise ValueError("incorrect shape") + + # create grid and mark inner voxels + max_value = sparse_indices.max() + 3 + + grid = np.zeros((max_value, max_value, max_value), bool) + voxels_sparse = np.add(sparse_indices, 1) + + grid[tuple(voxels_sparse.T)] = 1 + + for i in range(max_value): + check_dir2 = False + for j in range(0, max_value - 1): + idx = [] + # find transitions first + # transition positions are from 0 to 1 and from 1 to 0 + eq = np.equal(grid[i, j, :-1], grid[i, j, 1:]) + idx = np.where(np.logical_not(eq))[0] + 1 + c = len(idx) + check_dir2 = (c % 4) > 0 and c > 4 + if c < 4: + continue + for s in range(0, c - c % 4, 4): + grid[i, j, idx[s] : idx[s + 3]] = 1 + if not check_dir2: + continue + + # check another direction for robustness + for k in range(0, max_value - 1): + idx = [] + # find transitions first + eq = np.equal(grid[i, :-1, k], grid[i, 1:, k]) + idx = np.where(np.logical_not(eq))[0] + 1 + c = len(idx) + if c < 4: + continue + for s in range(0, c - c % 4, 4): + grid[i, idx[s] : idx[s + 3], k] = 1 + + # generate new voxels + filled = np.column_stack(np.where(grid)) + filled -= 1 + + return filled + + +fill_voxelization = fill_base + + +def matrix_to_marching_cubes( + matrix: ArrayLike, + pitch: Number | ArrayLike = 1.0, + threshold: Number | None = None, +): + """ + Convert an (n, m, p) matrix into a mesh, using marching_cubes. + + Parameters + ----------- + matrix : (n, m, p) bool + Occupancy array + pitch : float or length-3 tuple of floats, optional + Voxel spacing in each dimension + threshold : float or None, optional + If specified, converts the input into a boolean + matrix by considering values above `threshold` as True + + + Returns + ---------- + mesh : trimesh.Trimesh + Mesh generated by meshing voxels using + the marching cubes algorithm in skimage + """ + from skimage import measure + + from ..base import Trimesh + + if threshold is not None: + matrix = np.asanyarray(matrix) > threshold + else: + matrix = np.asanyarray(matrix, dtype=bool) + + rev_matrix = np.logical_not(matrix) # Takes set about 0. + # Add in padding so marching cubes can function properly with + # voxels on edge of AABB + pad_width = 1 + rev_matrix = np.pad( + rev_matrix, pad_width=(pad_width), mode="constant", constant_values=(1) + ) + + # pick between old and new API + if hasattr(measure, "marching_cubes_lewiner"): + func = measure.marching_cubes_lewiner + else: + func = measure.marching_cubes + + # Run marching cubes. + pitch = np.asanyarray(pitch) + if pitch.size == 1: + pitch = (pitch,) * 3 + meshed = func( + volume=rev_matrix, + level=0.5, + spacing=pitch, # it is a boolean voxel grid + ) + + # allow results from either marching cubes function in skimage + # binaries available for python 3.3 and 3.4 appear to use the classic + # method + if len(meshed) == 2: + log.warning("using old marching cubes, may not be watertight!") + vertices, faces = meshed + normals = None + elif len(meshed) == 4: + vertices, faces, normals, _vals = meshed + + # Return to the origin, add in the pad_width + vertices = np.subtract(vertices, pad_width * pitch) + # create the mesh + mesh = Trimesh(vertices=vertices, faces=faces, vertex_normals=normals) + return mesh + + +def sparse_to_matrix(sparse): + """ + Take a sparse (n,3) list of integer indexes of filled cells, + turn it into a dense (m,o,p) matrix. + + Parameters + ----------- + sparse : (n, 3) int + Index of filled cells + + Returns + ------------ + dense : (m, o, p) bool + Matrix of filled cells + """ + + sparse = np.asanyarray(sparse, dtype=np.int64) + if not util.is_shape(sparse, (-1, 3)): + raise ValueError("sparse must be (n,3)!") + + shape = sparse.max(axis=0) + 1 + matrix = np.zeros(np.prod(shape), dtype=bool) + multiplier = np.array([np.prod(shape[1:]), shape[2], 1]) + + index = (sparse * multiplier).sum(axis=1) + matrix[index] = True + + dense = matrix.reshape(shape) + return dense + + +def points_to_marching_cubes(points, pitch=1.0): + """ + Mesh points by assuming they fill a voxel box, and then + running marching cubes on them + + Parameters + ------------ + points : (n, 3) float + Points in 3D space + + Returns + ------------- + mesh : trimesh.Trimesh + Points meshed using marching cubes + """ + # make sure inputs are as expected + points = np.asanyarray(points, dtype=np.float64) + pitch = np.asanyarray(pitch, dtype=float) + + # find the minimum value of points for origin + origin = points.min(axis=0) + # convert points to occupied voxel cells + index = ((points - origin) / pitch).round().astype(np.int64) + + # convert voxel indices to a matrix + matrix = sparse_to_matrix(index) + + # run marching cubes on the matrix to generate a mesh + mesh = matrix_to_marching_cubes(matrix, pitch=pitch) + mesh.vertices += origin + + return mesh + + +def multibox(centers, pitch=1.0, colors=None, remove_internal_faces=False): + """ + Return a Trimesh object with a box at every center. + + Doesn't do anything nice or fancy. + + Parameters + ----------- + centers : (n, 3) float + Center of boxes that are occupied + pitch : float + The edge length of a voxel + colors : (3,) or (4,) or (n,3) or (n, 4) float + Color of boxes + remove_internal_faces : bool + If True, removes internal faces shared between adjacent boxes + + Returns + --------- + rough : Trimesh + Mesh object representing inputs + """ + from .. import primitives + from ..base import Trimesh + + # get centers as numpy array + centers = np.asanyarray(centers, dtype=np.float64) + + # get a basic box + b = primitives.Box() + # apply the pitch + b.apply_scale(float(pitch)) + # tile into one box vertex per center + v = np.tile(centers, (1, len(b.vertices))).reshape((-1, 3)) + # offset to centers + v += np.tile(b.vertices, (len(centers), 1)) + + f = np.tile(b.faces, (len(centers), 1)) + f += np.repeat(np.arange(len(centers)) * len(b.vertices), len(b.faces))[:, None] + + if remove_internal_faces: + # Get 12 unit normals (1 per triangle face) indicating face direction + base_normals = np.round(b.face_normals).astype(int) # (12, 3) + # Expand those directions across all voxel boxes so as to check neighbor presence + face_normals = np.tile(base_normals, (len(centers), 1)) # (len(centers) * 12, 3) + + # Maps each face to the voxel box it came from + face_voxel_idx = np.repeat( + np.arange(len(centers)), len(b.faces) + ) # (len(centers) * 12, ) + # Converts voxel centers to discrete grid coordinates + voxel_coords = np.round(centers / pitch).astype(int) # (len(centers), 3) + # Creates a fast lookup structure for checking voxel neighbors + voxel_set = set(map(tuple, voxel_coords)) + + # Gets the grid coordinate of the voxel that owns each face + voxel_face_coords = voxel_coords[face_voxel_idx] + # Computes the adjacent voxel coordinate in the face direction + neighbor_coords = voxel_face_coords + face_normals + # Keeps only faces whose neighboring voxel does not exist + keep_mask = np.array([tuple(c) not in voxel_set for c in neighbor_coords]) + else: + keep_mask = np.ones(len(f), dtype=bool) + + face_colors = None + if colors is not None: + colors = np.asarray(colors) + if colors.ndim == 1: + colors = colors[None].repeat(len(centers), axis=0) + if colors.ndim == 2 and len(colors) == len(centers): + face_colors = colors.repeat(12, axis=0)[keep_mask] + + mesh = Trimesh(vertices=v, faces=f[keep_mask], face_colors=face_colors) + + return mesh + + +def boolean_sparse(a, b, operation=np.logical_and): + """ + Find common rows between two arrays very quickly + using 3D boolean sparse matrices. + + Parameters + ----------- + a: (n, d) int, coordinates in space + b: (m, d) int, coordinates in space + operation: numpy operation function, ie: + np.logical_and + np.logical_or + + Returns + ----------- + coords: (q, d) int, coordinates in space + """ + # 3D sparse arrays, using wrapped scipy.sparse + # pip install sparse + import sparse + + # find the bounding box of both arrays + extrema = np.array([a.min(axis=0), a.max(axis=0), b.min(axis=0), b.max(axis=0)]) + origin = extrema.min(axis=0) - 1 + size = tuple(np.ptp(extrema, axis=0) + 2) + + # put nearby voxel arrays into same shape sparse array + sp_a = sparse.COO((a - origin).T, data=np.ones(len(a), dtype=bool), shape=size) + sp_b = sparse.COO((b - origin).T, data=np.ones(len(b), dtype=bool), shape=size) + + # apply the logical operation + # get a sparse matrix out + applied = operation(sp_a, sp_b) + # reconstruct the original coordinates + coords = np.column_stack(applied.coords) + origin + + return coords + + +def strip_array(data): + shape = data.shape + ndims = len(shape) + padding = [] + slices = [] + for dim in range(len(shape)): + axis = tuple(range(dim)) + tuple(range(dim + 1, ndims)) + filled = np.any(data, axis=axis) + (indices,) = np.nonzero(filled) + pad_left = indices[0] + pad_right = indices[-1] + padding.append([pad_left, pad_right]) + slices.append(slice(pad_left, pad_right)) + return data[tuple(slices)], np.array(padding, int) + + +def indices_to_points(indices, pitch=None, origin=None): + """ + Convert indices of an (n,m,p) matrix into a set of voxel center points. + + Parameters + ---------- + indices: (q, 3) int, index of voxel matrix (n,m,p) + pitch: float, what pitch was the voxel matrix computed with + origin: (3,) float, what is the origin of the voxel matrix + + Returns + ---------- + points: (q, 3) float, list of points + """ + indices = np.asanyarray(indices) + if indices.shape[1:] != (3,): + raise ValueError("shape of indices must be (q, 3)") + + points = np.array(indices, dtype=np.float64) + if pitch is not None: + points *= float(pitch) + if origin is not None: + origin = np.asanyarray(origin) + if origin.shape != (3,): + raise ValueError("shape of origin must be (3,)") + points += origin + + return points + + +def matrix_to_points(matrix, pitch=None, origin=None): + """ + Convert an (n,m,p) matrix into a set of points for each voxel center. + + Parameters + ----------- + matrix: (n,m,p) bool, voxel matrix + pitch: float, what pitch was the voxel matrix computed with + origin: (3,) float, what is the origin of the voxel matrix + + Returns + ---------- + points: (q, 3) list of points + """ + indices = np.column_stack(np.nonzero(matrix)) + points = indices_to_points(indices=indices, pitch=pitch, origin=origin) + return points + + +def points_to_indices(points, pitch=None, origin=None): + """ + Convert center points of an (n,m,p) matrix into its indices. + + Parameters + ---------- + points : (q, 3) float + Center points of voxel matrix (n,m,p) + pitch : float + What pitch was the voxel matrix computed with + origin : (3,) float + What is the origin of the voxel matrix + + Returns + ---------- + indices : (q, 3) int + List of indices + """ + points = np.array(points, dtype=np.float64) + if points.shape != (points.shape[0], 3): + raise ValueError("shape of points must be (q, 3)") + + if origin is not None: + origin = np.asanyarray(origin) + if origin.shape != (3,): + raise ValueError("shape of origin must be (3,)") + points -= origin + if pitch is not None: + points /= pitch + + origin = np.asanyarray(origin, dtype=np.float64) + pitch = float(pitch) + + indices = np.round(points).astype(int) + return indices diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/runlength.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/runlength.py new file mode 100644 index 0000000000000000000000000000000000000000..3bc3f4105b151ce100826fbf2b1da57896164676 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/runlength.py @@ -0,0 +1,720 @@ +""" +Numpy encode/decode/utility implementations for run length encodings. + +# Run Length Encoded Features + +Encoding/decoding functions for run length encoded data. + +We include code for two variations: + +* run length encoding (RLE) +* binary run length encdoing (BRLE) + +RLE stores sequences of repeated values as the value followed by its count, e.g. + +```python +dense_to_rle([5, 5, 3, 2, 2, 2, 2, 6]) == [5, 2, 3, 1, 2, 4, 6, 1] +``` + +i.e. the value `5` is repeated `2` times, then `3` is repeated `1` time, `2` is +repeated `4` times and `6` is repeated `1` time. + +BRLE is an optimized form for when the stored values can only be `0` or `1`. +This means we only need to save the counts, and assume the values alternate +(starting at `0`). + +```python +dense_to_brle([1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0]) == \ + [0, 2, 4, 7, 2] +``` + +i.e. the value zero occurs `0` times, followed by `2` ones, `4` zeros, `7` ones +and `2` zeros. + +Sequences with counts exceeding the data type's maximum value have to be +handled carefully. For example, the `uint8` encoding of 300 zeros +(`uint8` has a max value of 255) is: + +* RLE: `[0, 255, 0, 45]` (`0` repeated `255` times + `0` repeated `45` times) +* BRLE: `[255, 0, 45, 0]` (`255` zeros + `0` ones + `45` zeros + `0` ones) + +This module contains implementations of various RLE/BRLE operations. +""" + +import functools + +import numpy as np + + +def brle_length(brle): + """Optimized implementation of `len(brle_to_dense(brle))`""" + return np.sum(brle) + + +def rle_length(rle): + """Optimized implementation of `len(rle_to_dense(rle_to_brle(rle)))`""" + return np.sum(rle[1::2]) + + +def rle_to_brle(rle, dtype=None): + """ + Convert run length encoded (RLE) value/counts to BRLE. + + RLE data is stored in a rank 1 array with each pair giving: + (value, count) + + e.g. the RLE encoding of [4, 4, 4, 1, 1, 6] is [4, 3, 1, 2, 6, 1]. + + Parameters + ---------- + rle : (n,) int + Run length encoded data + + Returns + ---------- + equivalent binary run length encoding. a list if dtype is None, + otherwise brle_to_brle is called on that list before returning. + + Raises + ---------- + ValueError + If any of the even counts of `rle` are not zero or 1. + """ + curr_val = 0 + out = [0] + acc = 0 + for value, count in np.reshape(rle, (-1, 2)): + acc += count + if value not in (0, 1): + raise ValueError("Invalid run length encoding for conversion to BRLE") + if value == curr_val: + out[-1] += count + else: + out.append(int(count)) + curr_val = value + if len(out) % 2: + out.append(0) + if dtype is not None: + out = brle_to_brle(out, dtype=dtype) + return out + + +def brle_logical_not(brle): + """ + Get the BRLE encoding of the `logical_not`ed dense form of `brle`. + + Equivalent to `dense_to_brle(np.logical_not(brle_to_dense(brle)))` but + highly optimized - just pads brle with a 0 on each end (or strips is + existing endpoints are both zero). + + Parameters + ---------- + brle: rank 1 int array of binary run length encoded data + + Returns + ---------- + rank 1 int array of binary run length encoded data corresponding to + element-wise not of the input. + """ + if brle[0] or brle[-1]: + return np.pad(brle, [1, 1], mode="constant") + else: + return brle[1:-1] + + +def merge_brle_lengths(lengths): + """Inverse of split_long_brle_lengths.""" + if len(lengths) == 0: + return [] + + out = [int(lengths[0])] + accumulating = False + for length in lengths[1:]: + if accumulating: + out[-1] += length + accumulating = False + else: + if length == 0: + accumulating = True + else: + out.append(int(length)) + return out + + +def split_long_brle_lengths(lengths, dtype=np.int64): + """ + Split lengths that exceed max dtype value. + + Lengths `l` are converted into [max_val, 0] * l // max_val + [l % max_val] + + e.g. for dtype=np.uint8 (max_value == 255) + ``` + split_long_brle_lengths([600, 300, 2, 6], np.uint8) == \ + [255, 0, 255, 0, 90, 255, 0, 45, 2, 6] + ``` + """ + lengths = np.asarray(lengths) + max_val = np.iinfo(dtype).max + bad_length_mask = lengths > max_val + if np.any(bad_length_mask): + # there are some bad lengths + nl = len(lengths) + repeats = np.asarray(lengths) // max_val + remainders = (lengths % max_val).astype(dtype) + + lengths = np.concatenate( + [ + np.array([max_val, 0] * repeat + [remainder], dtype=dtype) + for repeat, remainder in zip(repeats, remainders) + ] + ) + lengths = lengths.reshape((np.sum(repeats) * 2 + nl,)).astype(dtype) + return lengths + elif lengths.dtype != dtype: + return lengths.astype(dtype) + else: + return lengths + + +def dense_to_brle(dense_data, dtype=np.int64): + """ + Get the binary run length encoding of `dense_data`. + + Parameters + ---------- + dense_data: rank 1 bool array of data to encode. + dtype: numpy int type. + + Returns + ---------- + Binary run length encoded rank 1 array of dtype `dtype`. + + Raises + ---------- + ValuError if dense_data is not a rank 1 bool array. + """ + if dense_data.dtype != bool: + raise ValueError("`dense_data` must be bool") + if len(dense_data.shape) != 1: + raise ValueError("`dense_data` must be rank 1.") + n = len(dense_data) + starts = np.r_[0, np.flatnonzero(dense_data[1:] != dense_data[:-1]) + 1] + lengths = np.diff(np.r_[starts, n]) + lengths = split_long_brle_lengths(lengths, dtype=dtype) + if dense_data[0]: + lengths = np.pad(lengths, [1, 0], mode="constant") + return lengths + + +_ft = np.array([False, True], dtype=bool) + + +def brle_to_dense(brle_data, vals=None): + """Decode binary run length encoded data to dense. + + Parameters + ---------- + brle_data: BRLE counts of False/True values + vals: if not `None`, a length 2 array/list/tuple with False/True substitute + values, e.g. brle_to_dense([2, 3, 1, 0], [7, 9]) == [7, 7, 9, 9, 9, 7] + + Returns + ---------- + rank 1 dense data of dtype `bool if vals is None else vals.dtype` + + Raises + ---------- + ValueError if vals it not None and shape is not (2,) + """ + if vals is None: + vals = _ft + else: + vals = np.asarray(vals) + if vals.shape != (2,): + raise ValueError(f"vals.shape must be (2,), got {vals.shape}") + ft = np.repeat(_ft[np.newaxis, :], (len(brle_data) + 1) // 2, axis=0).flatten() + return np.repeat(ft[: len(brle_data)], np.asarray(brle_data, dtype=int)).flatten() + + +def rle_to_dense(rle_data, dtype=np.int64): + """Get the dense decoding of the associated run length encoded data.""" + values, counts = np.split(np.reshape(rle_data, (-1, 2)), 2, axis=-1) + if dtype is not None: + values = np.asanyarray(values, dtype=dtype) + try: + result = np.repeat( + np.squeeze(values, axis=-1), np.squeeze(counts, axis=-1).astype(int) + ) + except TypeError: + # on windows it sometimes fails to cast data type + result = np.repeat( + np.squeeze(values.astype(np.int64), axis=-1), + np.squeeze(counts.astype(int), axis=-1), + ) + return result + + +def dense_to_rle(dense_data, dtype=np.int64): + """Get run length encoding of the provided dense data.""" + n = len(dense_data) + starts = np.r_[0, np.flatnonzero(dense_data[1:] != dense_data[:-1]) + 1] + lengths = np.diff(np.r_[starts, n]) + values = dense_data[starts] + values, lengths = split_long_rle_lengths(values, lengths, dtype=dtype) + out = np.stack((values, lengths), axis=1) + return out.flatten() + + +def split_long_rle_lengths(values, lengths, dtype=np.int64): + """ + Split long lengths in the associated run length encoding. + + e.g. + ```python + split_long_rle_lengths([5, 300, 2, 12], np.uint8) == [5, 255, 5, 45, 2, 12] + ``` + + Parameters + ---------- + values: values column of run length encoding, or `rle[::2]` + lengths: counts in run length encoding, or `rle[1::2]` + dtype: numpy data type indicating the maximum value. + + Returns + ---------- + values, lengths associated with the appropriate splits. `lengths` will be + of type `dtype`, while `values` will be the same as the value passed in. + """ + max_length = np.iinfo(dtype).max + lengths = np.asarray(lengths, dtype=np.int64) + repeats = lengths // max_length + if repeats.any(): + repeats = (repeats + 1).astype(int) + remainder = lengths % max_length + values = np.repeat(values, repeats) + lengths = np.zeros(len(repeats), dtype=dtype) + lengths.fill(max_length) + lengths = np.repeat(lengths, repeats) + lengths[np.cumsum(repeats) - 1] = remainder + elif lengths.dtype != dtype: + lengths = lengths.astype(dtype) + return values, lengths + + +def merge_rle_lengths(values, lengths): + """Inverse of split_long_rle_lengths except returns normal python lists.""" + ret_values = [] + ret_lengths = [] + curr = None + for value, length in zip(values, lengths): + if length == 0: + continue + if value == curr: + ret_lengths[-1] += length + else: + curr = value + ret_lengths.append(int(length)) + ret_values.append(value) + return ret_values, ret_lengths + + +def brle_to_rle(brle, dtype=np.int64): + if len(brle) % 2 == 1: + brle = np.concatenate([brle, [0]]) + lengths = brle + values = np.tile(_ft, len(brle) // 2) + return rle_to_rle(np.stack((values, lengths), axis=1).flatten(), dtype=dtype) + + +def brle_to_brle(brle, dtype=np.int64): + """ + Almost the identity function. + + Checks for possible merges and required splits. + """ + return split_long_brle_lengths(merge_brle_lengths(brle), dtype=dtype) + + +def rle_to_rle(rle, dtype=np.int64): + """ + Almost the identity function. + + Checks for possible merges and required splits. + """ + values, lengths = np.reshape(rle, (-1, 2)).T + values, lengths = merge_rle_lengths(values, lengths) + values, lengths = split_long_rle_lengths(values, lengths, dtype=dtype) + return np.stack((values, lengths), axis=1).flatten() + + +def _unsorted_gatherer(indices, sorted_gather_fn): + if not isinstance(indices, np.ndarray): + indices = np.array(indices, copy=False) + order = np.argsort(indices) + ordered_indices = indices[order] + + def f(data, dtype=None): + result = np.zeros(len(order), dtype=dtype or getattr(data, "dtype", None)) + result[order] = tuple(sorted_gather_fn(data, ordered_indices)) + return result + + return f + + +def sorted_rle_gather_1d(rle_data, ordered_indices): + """ + Gather brle_data at ordered_indices. + + This is equivalent to `rle_to_dense(brle_data)[ordered_indices]` but avoids + the decoding. + + Parameters + ---------- + brle_data: iterable of run-length-encoded data. + ordered_indices: iterable of ints in ascending order. + + Returns + ---------- + `brle_data` iterable of values at the dense indices, same length as + ordered indices. + """ + data_iter = iter(rle_data) + index_iter = iter(ordered_indices) + try: + index = next(index_iter) + except StopIteration: + return + start = 0 + while True: + while start <= index: + try: + value = next(data_iter) + start += next(data_iter) + except StopIteration: + raise IndexError( + "Index %d out of range of raw_values length %d", index, start + ) + + try: + while index < start: + yield value + index = next(index_iter) + except StopIteration: + break + + +def rle_mask(rle_data, mask): + """ + Perform masking of the input run-length data. + + Parameters + ---------- + rle_data: iterable of run length encoded data + mask: iterable of bools corresponding to the dense mask. + + Returns + ---------- + iterable of dense values of rle_data wherever mask is True. + """ + data_iter = iter(rle_data) + mask_iter = iter(mask) + while True: + try: + value = next(data_iter) + count = next(data_iter) + except StopIteration: + break + for _ in range(count): + m = next(mask_iter) + if m: + yield value + + +def brle_mask(rle_data, mask): + """ + Perform masking of the input binary run-length data. + + Parameters + ---------- + brle_data: iterable of binary run length encoded data + mask: iterable of bools corresponding to the dense mask. + + Returns + ---------- + iterable dense values of brle_data wherever mask is True. + """ + data_iter = iter(rle_data) + mask_iter = iter(mask) + value = True + while True: + try: + value = not value + count = next(data_iter) + except StopIteration: + break + for _ in range(count): + m = next(mask_iter) + if m: + yield value + + +def rle_gatherer_1d(indices): + """ + Get a gather function at the given indices. + + Because gathering on RLE data requires sorting, for instances where + gathering at the same indices on different RLE data this can save the + sorting process. + + If only gathering on a single RLE iterable, use `rle_gather_1d`. + + Parameters + ---------- + indices: iterable of integers + + Returns + ---------- + gather function, mapping `(rle_data, dtype=None) -> values`. + `values` will have the same length as `indices` and dtype provided, + or rle_data.dtype if no dtype is provided. + """ + return _unsorted_gatherer(indices, sorted_rle_gather_1d) + + +def rle_gather_1d(rle_data, indices, dtype=None): + """ + Gather RLE data values at the provided dense indices. + + This is equivalent to `rle_to_dense(rle_data)[indices]` but the + implementation does not require the construction of the dense array. + + If indices is known to be in order, use `sorted_gather_1d`. + + Parameters + ---------- + rle_data: run length encoded data + indices: dense indices + dtype: numpy dtype. If not provided, uses rle_data.dtype + + Returns + ---------- + numpy array, dense data at indices, same length as indices and dtype as + rle_data + """ + return rle_gatherer_1d(indices)(rle_data, dtype=dtype) + + +def sorted_brle_gather_1d(brle_data, ordered_indices): + """ + Gather brle_data at ordered_indices. + + This is equivalent to `brle_to_dense(brle_data)[ordered_indices]` but + avoids the decoding. + + Parameters + ---------- + raw_data: iterable of run-length-encoded data. + ordered_indices: iterable of ints in ascending order. + + Returns + ---------- + `raw_data` iterable of values at the dense indices, same length as + ordered indices. + """ + data_iter = iter(brle_data) + index_iter = iter(ordered_indices) + try: + index = next(index_iter) + except StopIteration: + return + start = 0 + value = True + while True: + while start <= index: + try: + value = not value + start += next(data_iter) + except StopIteration: + raise IndexError( + "Index %d out of range of raw_values length %d", index, start + ) + + try: + while index < start: + yield value + index = next(index_iter) + except StopIteration: + break + + +def brle_gatherer_1d(indices): + """ + Get a gather function at the given indices. + + Because gathering on BRLE data requires sorting, for instances where + gathering at the same indices on different RLE data this can save the + sorting process. + + If only gathering on a single RLE iterable, use `brle_gather_1d`. + + Parameters + ---------- + indices: iterable of integers + + Returns + ---------- + gather function, mapping `(rle_data, dtype=None) -> values`. + `values` will have the same length as `indices` and dtype provided, + or rle_data.dtype if no dtype is provided. + """ + return functools.partial( + _unsorted_gatherer(indices, sorted_brle_gather_1d), dtype=bool + ) + + +def brle_gather_1d(brle_data, indices): + """ + Gather BRLE data values at the provided dense indices. + + This is equivalent to `rle_to_dense(rle_data)[indices]` but the + implementation does not require the construction of the dense array. + + If indices is known to be in order, use `sorted_brle_gather_1d`. + + Parameters + ---------- + rle_data: run length encoded data + indices: dense indices + + Returns + ---------- + numpy array, dense data at indices, same length as indices and dtype as + rle_data + """ + return brle_gatherer_1d(indices)(brle_data) + + +def brle_reverse(brle_data): + """Equivalent to dense_to_brle(brle_to_dense(brle_data)[-1::-1]).""" + if len(brle_data) % 2 == 0: + brle_data = np.concatenate([brle_data, [0]], axis=0) + end = -1 if brle_data[-1] == 0 else None + return brle_data[-1:end:-1] + + +def rle_reverse(rle_data): + """Get the rle encoding of the reversed dense array.""" + if not isinstance(rle_data, np.ndarray): + rle_data = np.array(rle_data, copy=False) + rle_data = np.reshape(rle_data, (-1, 2)) + rle_data = rle_data[-1::-1] + return np.reshape(rle_data, (-1,)) + + +def rle_to_sparse(rle_data): + """Get dense indices associated with non-zeros.""" + indices = [] + values = [] + it = iter(rle_data) + index = 0 + try: + while True: + value = next(it) + counts = int(next(it)) + end = index + counts + if value: + indices.append(np.arange(index, end, dtype=np.int64)) + values.append(np.repeat(value, counts)) + index = end + except StopIteration: + pass + if len(indices) == 0: + assert len(values) == 0 + return indices, values + + indices = np.concatenate(indices) + values = np.concatenate(values, dtype=rle_data.dtype) + return indices, values + + +def brle_to_sparse(brle_data, dtype=np.int64): + ends = np.cumsum(brle_data) + indices = [np.arange(s, e, dtype=dtype) for s, e in zip(ends[::2], ends[1::2])] + return np.concatenate(indices) + + +def rle_strip(rle_data): + """ + Remove leading and trailing zeros. + + Parameters + ---------- + rle_data: run length encoded data + + Returns + ---------- + (stripped_rle_data, padding) + stripped_rle_data: rle data without any leading or trailing zeros + padding: 2-element dense padding + """ + rle_data = np.reshape(rle_data, (-1, 2)) + start = 0 + final_i = len(rle_data) + for i, (val, count) in enumerate(rle_data): + if val and count > 0: + final_i = i + break + else: + start += count + + end = 0 + final_j = len(rle_data) + for j, (val, count) in enumerate(rle_data[::-1]): + if val and count > 0: + final_j = j + break + else: + end += count + + rle_data = rle_data[final_i : None if final_j == 0 else -final_j].reshape((-1,)) + return rle_data, (start, end) + + +def brle_strip(brle_data): + """ + Remove leading and trailing zeros. + + Parameters + ---------- + brle_data: binary run length encoded data. + + Returns + ---------- + (stripped_brle_data, padding) + stripped_brle_data: rle data without any leading or trailing zeros + padding: 2-element dense padding + """ + start = 0 + val = True + final_i = len(brle_data) + for i, count in enumerate(brle_data): + val = not val + if val and count > 0: + final_i = i + break + else: + start += count + end = 0 + final_j = len(brle_data) + val = bool(len(brle_data) % 2) + for j, count in enumerate(brle_data[::-1]): + val = not val + if val and count > 0: + final_j = j + break + else: + end += count + + brle_data = brle_data[final_i : None if final_j == 0 else -final_j] + brle_data = np.concatenate([[0], brle_data]) + return brle_data, (start, end) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/transforms.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/transforms.py new file mode 100644 index 0000000000000000000000000000000000000000..8831f638dd582af97237b7dd4e588715bd74fbb7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/voxel/transforms.py @@ -0,0 +1,180 @@ +import numpy as np + +from .. import caching, util +from .. import transformations as tr + + +class Transform: + """ + Class for caching metadata associated with 4x4 transformations. + + The transformation matrix is used to define relevant properties + for the voxels, including pitch and origin. + """ + + def __init__(self, matrix, datastore: caching.DataStore | None = None): + """ + Initialize with a transform. + + Parameters + ----------- + matrix : (4, 4) float + Homogeneous transformation matrix + datastore + If passed store the actual values in a reference to + another datastore. + """ + matrix = np.asanyarray(matrix, dtype=np.float64) + if matrix.shape != (4, 4) or not np.allclose(matrix[3, :], [0, 0, 0, 1]): + raise ValueError("matrix is invalid!") + + # store matrix as data + if datastore is None: + self._data = caching.DataStore() + elif isinstance(datastore, caching.DataStore): + self._data = datastore + else: + raise ValueError(f"{type(datastore)} != caching.DataStore") + + self._data["transform_matrix"] = matrix + # dump cache when matrix changes + self._cache = caching.Cache(id_function=self._data.__hash__) + + def __hash__(self): + """ + Get the hash of the current transformation matrix. + + Returns + ------------ + hash : str + Hash of transformation matrix + """ + return self._data.__hash__() + + @property + def translation(self): + """ + Get the translation component of the matrix + + Returns + ------------ + translation : (3,) float + Cartesian translation + """ + return self._data["transform_matrix"][:3, 3] + + @property + def matrix(self): + """ + Get the homogeneous transformation matrix. + + Returns + ------------- + matrix : (4, 4) float + Transformation matrix + """ + return self._data["transform_matrix"] + + @matrix.setter + def matrix(self, values): + """ + Set the homogeneous transformation matrix. + + Parameters + ------------- + matrix : (4, 4) float + Transformation matrix + """ + values = np.asanyarray(values, dtype=np.float64) + if values.shape != (4, 4): + raise ValueError("matrix must be (4, 4)!") + self._data["transform_matrix"] = values + + @caching.cache_decorator + def scale(self): + """ + Get the scale factor of the current transformation. + + Returns + ------------- + scale : (3,) float + Scale factor from the matrix + """ + # get the current transformation + matrix = self.matrix + # get the (3,) diagonal of the rotation component + scale = np.diag(matrix[:3, :3]) + if not np.allclose(matrix[:3, :3], scale * np.eye(3), scale * 1e-6 + 1e-8): + raise RuntimeError("transform features a shear or rotation") + return scale + + @caching.cache_decorator + def pitch(self): + scale = self.scale + if not util.allclose(scale[0], scale[1:], np.max(np.abs(scale)) * 1e-6 + 1e-8): + raise RuntimeError("transform features non-uniform scaling") + return scale + + @caching.cache_decorator + def unit_volume(self): + """Volume of a transformed unit cube.""" + return np.linalg.det(self._data["transform_matrix"][:3, :3]) + + def apply_transform(self, matrix): + """Mutate the transform in-place and return self.""" + self.matrix = np.matmul(matrix, self.matrix) + return self + + def apply_translation(self, translation): + """Mutate the transform in-place and return self.""" + self.matrix[:3, 3] += translation + return self + + def apply_scale(self, scale): + """Mutate the transform in-place and return self.""" + self.matrix[:3] *= scale + return self + + def transform_points(self, points): + """ + Apply the transformation to points (not in-place). + + Parameters + ---------- + points: (n, 3) float + Points in cartesian space + + Returns + ---------- + transformed : (n, 3) float + Points transformed by matrix + """ + if self.is_identity: + return points.copy() + return tr.transform_points(points.reshape(-1, 3), self.matrix).reshape( + points.shape + ) + + def inverse_transform_points(self, points): + """Apply the inverse transformation to points (not in-place).""" + if self.is_identity: + return points + return tr.transform_points(points.reshape(-1, 3), self.inverse_matrix).reshape( + points.shape + ) + + @caching.cache_decorator + def inverse_matrix(self): + inv = np.linalg.inv(self.matrix) + inv.flags.writeable = False + return inv + + def copy(self): + return Transform(matrix=self.matrix) + + @caching.cache_decorator + def is_identity(self): + """ + Flags this transformation being sufficiently close to eye(4). + """ + return util.allclose(self.matrix, np.eye(4), 1e-8) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore-0.10.5.dist-info/INSTALLER b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore-0.10.5.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore-0.10.5.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore-0.10.5.dist-info/METADATA b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore-0.10.5.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..9bc076af4599bfb71cde3dc14f89b0e60a1cde1a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore-0.10.5.dist-info/METADATA @@ -0,0 +1,110 @@ +Metadata-Version: 2.4 +Name: truststore +Version: 0.10.5 +Summary: Verify certificates using native system trust stores +Author-email: Seth Michael Larson , David Glick +Requires-Python: >= 3.10 +Description-Content-Type: text/markdown +License-Expression: MIT +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Operating System :: MacOS +Classifier: Operating System :: Microsoft +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: 3.14 +Classifier: Programming Language :: Python :: 3.15 +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +License-File: LICENSE +Project-URL: Documentation, https://truststore.readthedocs.io +Project-URL: Source, https://github.com/sethmlarson/truststore + +# Truststore + +[![PyPI](https://img.shields.io/pypi/v/truststore)](https://pypi.org/project/truststore) +[![CI](https://github.com/sethmlarson/truststore/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/sethmlarson/truststore/actions/workflows/ci.yml) + +Truststore is a library which exposes native system certificate stores (ie "trust stores") +through an `ssl.SSLContext`-like API. This means that Python applications no longer need to +rely on certifi as a root certificate store. Native system certificate stores +have many helpful features compared to a static certificate bundle like certifi: + +- Automatically update certificates as new CAs are created and removed +- Fetch missing intermediate certificates +- Check certificates against certificate revocation lists (CRLs) to avoid monster-in-the-middle (MITM) attacks +- Managed per-system rather than per-application by a operations/IT team +- PyPI is no longer a CA distribution channel 🥳 + +Right now truststore is a stand-alone library that can be installed globally in your +application to immediately take advantage of the benefits in Python 3.10+. Truststore +has also been integrated into pip 24.2+ as the default method for verifying HTTPS +certificates (with a fallback to certifi). + +Long-term the hope is to add this functionality into Python itself. Wish us luck! + +## Installation + +Truststore is installed from [PyPI](https://pypi.org/project/truststore) with pip: + +```{code-block} shell +$ python -m pip install truststore +``` + +Truststore **requires Python 3.10 or later** and supports the following platforms: +- macOS 10.8+ via [Security framework](https://developer.apple.com/documentation/security) +- Windows via [CryptoAPI](https://docs.microsoft.com/en-us/windows/win32/seccrypto/cryptography-functions#certificate-verification-functions) +- Linux via OpenSSL + +## User Guide + +> **Warning** +> **PLEASE READ:** `inject_into_ssl()` **must not be used by libraries or packages** as it will cause issues on import time when integrated with other libraries. +> Libraries and packages should instead use `truststore.SSLContext` directly which is detailed below. +> +> The `inject_into_ssl()` function is intended only for use in applications and scripts. + +You can inject `truststore` into the standard library `ssl` module so the functionality is used +by every library by default. To do so use the `truststore.inject_into_ssl()` function: + +```python +import truststore +truststore.inject_into_ssl() + +# Automatically works with urllib3, requests, aiohttp, and more: +import urllib3 +http = urllib3.PoolManager() +resp = http.request("GET", "https://example.com") + +import aiohttp +http = aiohttp.ClientSession() +resp = await http.request("GET", "https://example.com") + +import requests +resp = requests.get("https://example.com") +``` + +If you'd like finer-grained control or you're developing a library or package you can create your own `truststore.SSLContext` instance +and use it anywhere you'd use an `ssl.SSLContext`: + +```python +import ssl +import truststore + +ctx = truststore.SSLContext(ssl.PROTOCOL_TLS_CLIENT) + +import urllib3 +http = urllib3.PoolManager(ssl_context=ctx) +resp = http.request("GET", "https://example.com") +``` + +You can read more in the [user guide in the documentation](https://truststore.readthedocs.io/en/latest/#user-guide). + +## License + +MIT + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore-0.10.5.dist-info/RECORD b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore-0.10.5.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..c7715c24cadd5b63646d1b54a43ab87bdbb4ce65 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore-0.10.5.dist-info/RECORD @@ -0,0 +1,18 @@ +truststore-0.10.5.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +truststore-0.10.5.dist-info/METADATA,sha256=H9SW8pCFMhTmMNlvcWPS3ZFvhOvmNLWKqCfWhT6PhhA,4515 +truststore-0.10.5.dist-info/RECORD,, +truststore-0.10.5.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82 +truststore-0.10.5.dist-info/licenses/LICENSE,sha256=M757fo-k_Rmxdg4ajtimaL2rhSyRtpLdQUJLy3Jan8o,1086 +truststore/__init__.py,sha256=pbihzIROul2l51JSJaFbrxLhRB_9u3Ol_ScM_w4WE64,1307 +truststore/__pycache__/__init__.cpython-311.pyc,, +truststore/__pycache__/_api.cpython-311.pyc,, +truststore/__pycache__/_macos.cpython-311.pyc,, +truststore/__pycache__/_openssl.cpython-311.pyc,, +truststore/__pycache__/_ssl_constants.cpython-311.pyc,, +truststore/__pycache__/_windows.cpython-311.pyc,, +truststore/_api.py,sha256=L9h9Pz1-C2LfUHX-slr_TUGHiHrO11FXezhW6dFGa-o,13160 +truststore/_macos.py,sha256=nZlLkOmszUE0g6ryRwBVGY5COzPyudcsiJtDWarM5LQ,20503 +truststore/_openssl.py,sha256=r42qoqmCdS6kQsG9eNWBedYxgQhzs7_DW-nehrrOlAM,2370 +truststore/_ssl_constants.py,sha256=LaCaVgQG4PNdNSh6Yfg4GxUM4BMa_PisxCAR4IFgYMU,1106 +truststore/_windows.py,sha256=jWeQJoSJKq9hMxk_XUf6RpFViXcDcd9Guip6iMx9GCw,18035 +truststore/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore-0.10.5.dist-info/WHEEL b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore-0.10.5.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..d8b9936dad9ab2513fa6979f411560d3b6b57e37 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore-0.10.5.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: flit 3.12.0 +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore-0.10.5.dist-info/licenses/LICENSE b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore-0.10.5.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..7ec568c1136eb8ec86aa05cf7abacfb54c3e5ead --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore-0.10.5.dist-info/licenses/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2022 Seth Michael Larson + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2358903cf00dd10d13011b04f6ccd37c209de463 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__init__.py @@ -0,0 +1,36 @@ +"""Verify certificates using native system trust stores""" + +import sys as _sys + +if _sys.version_info < (3, 10): # noqa: UP036 + raise ImportError("truststore requires Python 3.10 or later") + +# Detect Python runtimes which don't implement SSLObject.get_unverified_chain() API +# This API only became public in Python 3.13 but was available in CPython and PyPy since 3.10. +if _sys.version_info < (3, 13) and _sys.implementation.name not in ("cpython", "pypy"): + try: + import ssl as _ssl + except ImportError: + raise ImportError("truststore requires the 'ssl' module") + else: + _sslmem = _ssl.MemoryBIO() + _sslobj = _ssl.create_default_context().wrap_bio( + _sslmem, + _sslmem, + ) + try: + while not hasattr(_sslobj, "get_unverified_chain"): + _sslobj = _sslobj._sslobj # type: ignore[attr-defined] + except AttributeError: + raise ImportError( + "truststore requires peer certificate chain APIs to be available" + ) from None + + del _ssl, _sslobj, _sslmem + +from ._api import SSLContext, extract_from_ssl, inject_into_ssl + +del _api, _sys # type: ignore[name-defined] # noqa: F821 + +__all__ = ["SSLContext", "inject_into_ssl", "extract_from_ssl"] +__version__ = "0.10.5" diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3aedece58346248dfa5269c0df34e7a15b5fa301 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/_api.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/_api.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2734836ede2cb2a657976e6abaf5710575a5a48d Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/_api.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/_macos.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/_macos.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..71b92ba2290a61ca10a80e6ffbf4a90e129c1604 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/_macos.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/_openssl.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/_openssl.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..513b28ba871c517e9ea376e3a6e81e90fb0de619 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/_openssl.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/_ssl_constants.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/_ssl_constants.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8e46cc34c9e2704a5870b69cb7c94f14ae44c060 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/_ssl_constants.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/_windows.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/_windows.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..13c62e875147b7ba1fefc33d4cfc056707030872 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/__pycache__/_windows.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/_api.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/_api.py new file mode 100644 index 0000000000000000000000000000000000000000..2aa79a789452fa3dcddfdf26597ca60575d1ea0a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/_api.py @@ -0,0 +1,377 @@ +import _ssl +import os +import platform +import socket +import ssl +import sys +import threading +import typing + +from ._ssl_constants import ( + _original_SSLContext, + _original_super_SSLContext, + _truststore_SSLContext_dunder_class, + _truststore_SSLContext_super_class, +) + +if platform.system() == "Windows": + from ._windows import _configure_context, _verify_peercerts_impl +elif platform.system() == "Darwin": + from ._macos import _configure_context, _verify_peercerts_impl +else: + from ._openssl import _configure_context, _verify_peercerts_impl + +if typing.TYPE_CHECKING: + from typing_extensions import Buffer + +# From typeshed/stdlib/ssl.pyi +_StrOrBytesPath: typing.TypeAlias = str | bytes | os.PathLike[str] | os.PathLike[bytes] +_PasswordType: typing.TypeAlias = str | bytes | typing.Callable[[], str | bytes] + + +def inject_into_ssl() -> None: + """Injects the :class:`truststore.SSLContext` into the ``ssl`` + module by replacing :class:`ssl.SSLContext`. + """ + setattr(ssl, "SSLContext", SSLContext) + # urllib3 holds on to its own reference of ssl.SSLContext + # so we need to replace that reference too. + try: + import urllib3.util.ssl_ as urllib3_ssl + + setattr(urllib3_ssl, "SSLContext", SSLContext) + except ImportError: + pass + + # requests starting with 2.32.0 added a preloaded SSL context to improve concurrent performance; + # this unfortunately leads to a RecursionError, which can be avoided by patching the preloaded SSL context with + # the truststore patched instance + # also see https://github.com/psf/requests/pull/6667 + try: + import requests.adapters + + preloaded_context = getattr(requests.adapters, "_preloaded_ssl_context", None) + if preloaded_context is not None: + setattr( + requests.adapters, + "_preloaded_ssl_context", + SSLContext(ssl.PROTOCOL_TLS_CLIENT), + ) + except ImportError: + pass + + +def extract_from_ssl() -> None: + """Restores the :class:`ssl.SSLContext` class to its original state""" + setattr(ssl, "SSLContext", _original_SSLContext) + try: + import urllib3.util.ssl_ as urllib3_ssl + + urllib3_ssl.SSLContext = _original_SSLContext + except ImportError: + pass + + +class SSLContext(_truststore_SSLContext_super_class): # type: ignore[misc] + """SSLContext API that uses system certificates on all platforms""" + + @property # type: ignore[misc] + def __class__(self) -> type: + # Dirty hack to get around isinstance() checks + # for ssl.SSLContext instances in aiohttp/trustme + # when using non-CPython implementations. + return _truststore_SSLContext_dunder_class or SSLContext + + def __init__(self, protocol: int = None) -> None: # type: ignore[assignment] + self._ctx = _original_SSLContext(protocol) + self._ctx_lock = threading.RLock() + + ctx_lock = self._ctx_lock # Reference used by sslobject/sslsocket classes. + + class TruststoreSSLObject(ssl.SSLObject): + # This object exists because wrap_bio() doesn't + # immediately do the handshake so we need to do + # certificate verifications after SSLObject.do_handshake() + + def do_handshake(self) -> None: + with ctx_lock: + ret = super().do_handshake() + _verify_peercerts(self, server_hostname=self.server_hostname) + return ret + + class TruststoreSSLSocket(ssl.SSLSocket): + # Handles do_handshake_on_connect=False, explicit do_handshake() + # calls, and the handshake that SSLSocket.connect() triggers. + # Must never be called inside _configure_context(). wrap_socket() + # guarantees this by always wrapping with do_handshake_on_connect=False. + def do_handshake(self, block: bool = False) -> None: + with ctx_lock: + ret = super().do_handshake(block) + try: + _verify_peercerts(self, server_hostname=self.server_hostname) + except Exception: + self.close() + raise + return ret + + self._ctx.sslsocket_class = TruststoreSSLSocket + self._ctx.sslobject_class = TruststoreSSLObject + + def wrap_socket( + self, + sock: socket.socket, + server_side: bool = False, + do_handshake_on_connect: bool = True, + suppress_ragged_eofs: bool = True, + server_hostname: str | None = None, + session: ssl.SSLSession | None = None, + ) -> ssl.SSLSocket: + if self.check_hostname and not server_hostname: + raise ValueError("check_hostname requires server_hostname") + + with self._ctx_lock: + with _configure_context(self._ctx): + ssl_sock = self._ctx.wrap_socket( + sock, + server_side=server_side, + server_hostname=server_hostname, + do_handshake_on_connect=do_handshake_on_connect, + suppress_ragged_eofs=suppress_ragged_eofs, + session=session, + ) + + # NOTE: Below is still inside ctx_lock but not + # inside the _configure_context(). + + # Indicates that a handshake completed and + # we can verify now, otherwise verification + # will happen in TruststoreSSLSocket.do_handshake() + if ssl_sock.version() is not None: + try: + _verify_peercerts(ssl_sock, server_hostname=server_hostname) + except Exception: + ssl_sock.close() + raise + + return ssl_sock + + def wrap_bio( + self, + incoming: ssl.MemoryBIO, + outgoing: ssl.MemoryBIO, + server_side: bool = False, + server_hostname: str | None = None, + session: ssl.SSLSession | None = None, + ) -> ssl.SSLObject: + if self.check_hostname and not server_hostname: + raise ValueError("check_hostname requires server_hostname") + + # We need to lock around the .__enter__() + # but we don't need to lock within the + # context manager, so we need to expand the + # syntactic sugar of the `with` statement. + with self._ctx_lock, _configure_context(self._ctx): + ssl_obj = self._ctx.wrap_bio( + incoming, + outgoing, + server_hostname=server_hostname, + server_side=server_side, + session=session, + ) + return ssl_obj + + def load_verify_locations( + self, + cafile: str | bytes | os.PathLike[str] | os.PathLike[bytes] | None = None, + capath: str | bytes | os.PathLike[str] | os.PathLike[bytes] | None = None, + cadata: typing.Union[str, "Buffer", None] = None, + ) -> None: + return self._ctx.load_verify_locations( + cafile=cafile, capath=capath, cadata=cadata + ) + + def load_cert_chain( + self, + certfile: _StrOrBytesPath, + keyfile: _StrOrBytesPath | None = None, + password: _PasswordType | None = None, + ) -> None: + return self._ctx.load_cert_chain( + certfile=certfile, keyfile=keyfile, password=password + ) + + def load_default_certs( + self, purpose: ssl.Purpose = ssl.Purpose.SERVER_AUTH + ) -> None: + return self._ctx.load_default_certs(purpose) + + def set_alpn_protocols(self, alpn_protocols: typing.Iterable[str]) -> None: + return self._ctx.set_alpn_protocols(alpn_protocols) + + def set_npn_protocols(self, npn_protocols: typing.Iterable[str]) -> None: + return self._ctx.set_npn_protocols(npn_protocols) + + def set_ciphers(self, __cipherlist: str) -> None: + return self._ctx.set_ciphers(__cipherlist) + + def get_ciphers(self) -> typing.Any: + return self._ctx.get_ciphers() + + def session_stats(self) -> dict[str, int]: + return self._ctx.session_stats() + + def cert_store_stats(self) -> dict[str, int]: + raise NotImplementedError() + + def set_default_verify_paths(self) -> None: + self._ctx.set_default_verify_paths() + + @typing.overload + def get_ca_certs( + self, binary_form: typing.Literal[False] = ... + ) -> list[typing.Any]: ... + + @typing.overload + def get_ca_certs(self, binary_form: typing.Literal[True] = ...) -> list[bytes]: ... + + @typing.overload + def get_ca_certs(self, binary_form: bool = ...) -> typing.Any: ... + + def get_ca_certs(self, binary_form: bool = False) -> list[typing.Any] | list[bytes]: + raise NotImplementedError() + + @property + def check_hostname(self) -> bool: + with self._ctx_lock: + return self._ctx.check_hostname + + @check_hostname.setter + def check_hostname(self, value: bool) -> None: + with self._ctx_lock: + self._ctx.check_hostname = value + + @property + def hostname_checks_common_name(self) -> bool: + return self._ctx.hostname_checks_common_name + + @hostname_checks_common_name.setter + def hostname_checks_common_name(self, value: bool) -> None: + self._ctx.hostname_checks_common_name = value + + @property + def keylog_filename(self) -> str: + return self._ctx.keylog_filename + + @keylog_filename.setter + def keylog_filename(self, value: str) -> None: + self._ctx.keylog_filename = value + + @property + def maximum_version(self) -> ssl.TLSVersion: + return self._ctx.maximum_version + + @maximum_version.setter + def maximum_version(self, value: ssl.TLSVersion) -> None: + _original_super_SSLContext.maximum_version.__set__( # type: ignore[attr-defined] + self._ctx, value + ) + + @property + def minimum_version(self) -> ssl.TLSVersion: + return self._ctx.minimum_version + + @minimum_version.setter + def minimum_version(self, value: ssl.TLSVersion) -> None: + _original_super_SSLContext.minimum_version.__set__( # type: ignore[attr-defined] + self._ctx, value + ) + + @property + def options(self) -> ssl.Options: + return self._ctx.options + + @options.setter + def options(self, value: ssl.Options) -> None: + _original_super_SSLContext.options.__set__( # type: ignore[attr-defined] + self._ctx, value + ) + + @property + def post_handshake_auth(self) -> bool: + return self._ctx.post_handshake_auth + + @post_handshake_auth.setter + def post_handshake_auth(self, value: bool) -> None: + self._ctx.post_handshake_auth = value + + @property + def protocol(self) -> ssl._SSLMethod: + return self._ctx.protocol + + @property + def security_level(self) -> int: + return self._ctx.security_level + + @property + def verify_flags(self) -> ssl.VerifyFlags: + return self._ctx.verify_flags + + @verify_flags.setter + def verify_flags(self, value: ssl.VerifyFlags) -> None: + _original_super_SSLContext.verify_flags.__set__( # type: ignore[attr-defined] + self._ctx, value + ) + + @property + def verify_mode(self) -> ssl.VerifyMode: + with self._ctx_lock: + return self._ctx.verify_mode + + @verify_mode.setter + def verify_mode(self, value: ssl.VerifyMode) -> None: + with self._ctx_lock: + _original_super_SSLContext.verify_mode.__set__( # type: ignore[attr-defined] + self._ctx, value + ) + + +# Python 3.13+ makes get_unverified_chain() a public API that only returns DER +# encoded certificates. We detect whether we need to call public_bytes() for 3.10->3.12 +# Pre-3.13 returned None instead of an empty list from get_unverified_chain() +if sys.version_info >= (3, 13): + + def _get_unverified_chain_bytes(sslobj: ssl.SSLObject) -> list[bytes]: + unverified_chain = sslobj.get_unverified_chain() or () + return [ + cert if isinstance(cert, bytes) else cert.public_bytes(_ssl.ENCODING_DER) + for cert in unverified_chain + ] + +else: + + def _get_unverified_chain_bytes(sslobj: ssl.SSLObject) -> list[bytes]: + unverified_chain = sslobj.get_unverified_chain() or () # type: ignore[attr-defined] + return [cert.public_bytes(_ssl.ENCODING_DER) for cert in unverified_chain] + + +def _verify_peercerts( + sock_or_sslobj: ssl.SSLSocket | ssl.SSLObject, server_hostname: str | None +) -> None: + """ + Verifies the peer certificates from an SSLSocket or SSLObject + against the certificates in the OS trust store. + """ + if sock_or_sslobj.context.check_hostname and not server_hostname: + raise ValueError("check_hostname requires server_hostname") + + sslobj: ssl.SSLObject = sock_or_sslobj # type: ignore[assignment] + try: + while not hasattr(sslobj, "get_unverified_chain"): + sslobj = sslobj._sslobj # type: ignore[attr-defined] + except AttributeError: + pass + + cert_bytes = _get_unverified_chain_bytes(sslobj) + _verify_peercerts_impl( + sock_or_sslobj.context, cert_bytes, server_hostname=server_hostname + ) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/_macos.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/_macos.py new file mode 100644 index 0000000000000000000000000000000000000000..345030772441102eda1be73661469a5f726d668a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/_macos.py @@ -0,0 +1,571 @@ +import contextlib +import ctypes +import platform +import ssl +import typing +from ctypes import ( + CDLL, + POINTER, + c_bool, + c_char_p, + c_int32, + c_long, + c_uint32, + c_ulong, + c_void_p, +) +from ctypes.util import find_library + +from ._ssl_constants import _set_ssl_context_verify_mode + +_mac_version = platform.mac_ver()[0] +_mac_version_info = tuple(map(int, _mac_version.split("."))) +if _mac_version_info < (10, 8): + raise ImportError( + f"Only OS X 10.8 and newer are supported, not {_mac_version_info[0]}.{_mac_version_info[1]}" + ) + +_is_macos_version_10_14_or_later = _mac_version_info >= (10, 14) + + +def _load_cdll(name: str, macos10_16_path: str) -> CDLL: + """Loads a CDLL by name, falling back to known path on 10.16+""" + try: + # Big Sur is technically 11 but we use 10.16 due to the Big Sur + # beta being labeled as 10.16. + path: str | None + if _mac_version_info >= (10, 16): + path = macos10_16_path + else: + path = find_library(name) + if not path: + raise OSError # Caught and reraised as 'ImportError' + return CDLL(path, use_errno=True) + except OSError: + raise ImportError(f"The library {name} failed to load") from None + + +Security = _load_cdll( + "Security", "/System/Library/Frameworks/Security.framework/Security" +) +CoreFoundation = _load_cdll( + "CoreFoundation", + "/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation", +) + +Boolean = c_bool +CFIndex = c_long +CFStringEncoding = c_uint32 +CFData = c_void_p +CFString = c_void_p +CFArray = c_void_p +CFMutableArray = c_void_p +CFError = c_void_p +CFType = c_void_p +CFTypeID = c_ulong +CFTypeRef = POINTER(CFType) +CFAllocatorRef = c_void_p + +OSStatus = c_int32 + +CFErrorRef = POINTER(CFError) +CFDataRef = POINTER(CFData) +CFStringRef = POINTER(CFString) +CFArrayRef = POINTER(CFArray) +CFMutableArrayRef = POINTER(CFMutableArray) +CFArrayCallBacks = c_void_p +CFOptionFlags = c_uint32 + +SecCertificateRef = POINTER(c_void_p) +SecPolicyRef = POINTER(c_void_p) +SecTrustRef = POINTER(c_void_p) +SecTrustResultType = c_uint32 +SecTrustOptionFlags = c_uint32 + +try: + Security.SecCertificateCreateWithData.argtypes = [CFAllocatorRef, CFDataRef] + Security.SecCertificateCreateWithData.restype = SecCertificateRef + + Security.SecCertificateCopyData.argtypes = [SecCertificateRef] + Security.SecCertificateCopyData.restype = CFDataRef + + Security.SecCopyErrorMessageString.argtypes = [OSStatus, c_void_p] + Security.SecCopyErrorMessageString.restype = CFStringRef + + Security.SecTrustSetAnchorCertificates.argtypes = [SecTrustRef, CFArrayRef] + Security.SecTrustSetAnchorCertificates.restype = OSStatus + + Security.SecTrustSetAnchorCertificatesOnly.argtypes = [SecTrustRef, Boolean] + Security.SecTrustSetAnchorCertificatesOnly.restype = OSStatus + + Security.SecPolicyCreateRevocation.argtypes = [CFOptionFlags] + Security.SecPolicyCreateRevocation.restype = SecPolicyRef + + Security.SecPolicyCreateSSL.argtypes = [Boolean, CFStringRef] + Security.SecPolicyCreateSSL.restype = SecPolicyRef + + Security.SecTrustCreateWithCertificates.argtypes = [ + CFTypeRef, + CFTypeRef, + POINTER(SecTrustRef), + ] + Security.SecTrustCreateWithCertificates.restype = OSStatus + + Security.SecTrustGetTrustResult.argtypes = [ + SecTrustRef, + POINTER(SecTrustResultType), + ] + Security.SecTrustGetTrustResult.restype = OSStatus + + Security.SecTrustEvaluate.argtypes = [ + SecTrustRef, + POINTER(SecTrustResultType), + ] + Security.SecTrustEvaluate.restype = OSStatus + + Security.SecTrustRef = SecTrustRef # type: ignore[attr-defined] + Security.SecTrustResultType = SecTrustResultType # type: ignore[attr-defined] + Security.OSStatus = OSStatus # type: ignore[attr-defined] + + kSecRevocationUseAnyAvailableMethod = 3 + kSecRevocationRequirePositiveResponse = 8 + + CoreFoundation.CFRelease.argtypes = [CFTypeRef] + CoreFoundation.CFRelease.restype = None + + CoreFoundation.CFGetTypeID.argtypes = [CFTypeRef] + CoreFoundation.CFGetTypeID.restype = CFTypeID + + CoreFoundation.CFStringCreateWithCString.argtypes = [ + CFAllocatorRef, + c_char_p, + CFStringEncoding, + ] + CoreFoundation.CFStringCreateWithCString.restype = CFStringRef + + CoreFoundation.CFStringGetCStringPtr.argtypes = [CFStringRef, CFStringEncoding] + CoreFoundation.CFStringGetCStringPtr.restype = c_char_p + + CoreFoundation.CFStringGetCString.argtypes = [ + CFStringRef, + c_char_p, + CFIndex, + CFStringEncoding, + ] + CoreFoundation.CFStringGetCString.restype = c_bool + + CoreFoundation.CFDataCreate.argtypes = [CFAllocatorRef, c_char_p, CFIndex] + CoreFoundation.CFDataCreate.restype = CFDataRef + + CoreFoundation.CFDataGetLength.argtypes = [CFDataRef] + CoreFoundation.CFDataGetLength.restype = CFIndex + + CoreFoundation.CFDataGetBytePtr.argtypes = [CFDataRef] + CoreFoundation.CFDataGetBytePtr.restype = c_void_p + + CoreFoundation.CFArrayCreate.argtypes = [ + CFAllocatorRef, + POINTER(CFTypeRef), + CFIndex, + CFArrayCallBacks, + ] + CoreFoundation.CFArrayCreate.restype = CFArrayRef + + CoreFoundation.CFArrayCreateMutable.argtypes = [ + CFAllocatorRef, + CFIndex, + CFArrayCallBacks, + ] + CoreFoundation.CFArrayCreateMutable.restype = CFMutableArrayRef + + CoreFoundation.CFArrayAppendValue.argtypes = [CFMutableArrayRef, c_void_p] + CoreFoundation.CFArrayAppendValue.restype = None + + CoreFoundation.CFArrayGetCount.argtypes = [CFArrayRef] + CoreFoundation.CFArrayGetCount.restype = CFIndex + + CoreFoundation.CFArrayGetValueAtIndex.argtypes = [CFArrayRef, CFIndex] + CoreFoundation.CFArrayGetValueAtIndex.restype = c_void_p + + CoreFoundation.CFErrorGetCode.argtypes = [CFErrorRef] + CoreFoundation.CFErrorGetCode.restype = CFIndex + + CoreFoundation.CFErrorCopyDescription.argtypes = [CFErrorRef] + CoreFoundation.CFErrorCopyDescription.restype = CFStringRef + + CoreFoundation.kCFAllocatorDefault = CFAllocatorRef.in_dll( # type: ignore[attr-defined] + CoreFoundation, "kCFAllocatorDefault" + ) + CoreFoundation.kCFTypeArrayCallBacks = c_void_p.in_dll( # type: ignore[attr-defined] + CoreFoundation, "kCFTypeArrayCallBacks" + ) + + CoreFoundation.CFTypeRef = CFTypeRef # type: ignore[attr-defined] + CoreFoundation.CFArrayRef = CFArrayRef # type: ignore[attr-defined] + CoreFoundation.CFStringRef = CFStringRef # type: ignore[attr-defined] + CoreFoundation.CFErrorRef = CFErrorRef # type: ignore[attr-defined] + +except AttributeError as e: + raise ImportError(f"Error initializing ctypes: {e}") from None + +# SecTrustEvaluateWithError is macOS 10.14+ +if _is_macos_version_10_14_or_later: + try: + Security.SecTrustEvaluateWithError.argtypes = [ + SecTrustRef, + POINTER(CFErrorRef), + ] + Security.SecTrustEvaluateWithError.restype = c_bool + except AttributeError as e: + raise ImportError(f"Error initializing ctypes: {e}") from None + + +def _handle_osstatus(result: OSStatus, _: typing.Any, args: typing.Any) -> typing.Any: + """ + Raises an error if the OSStatus value is non-zero. + """ + if int(result) == 0: + return args + + # Returns a CFString which we need to transform + # into a UTF-8 Python string. + error_message_cfstring = None + try: + error_message_cfstring = Security.SecCopyErrorMessageString(result, None) + + # First step is convert the CFString into a C string pointer. + # We try the fast no-copy way first. + error_message_cfstring_c_void_p = ctypes.cast( + error_message_cfstring, ctypes.POINTER(ctypes.c_void_p) + ) + message = CoreFoundation.CFStringGetCStringPtr( + error_message_cfstring_c_void_p, CFConst.kCFStringEncodingUTF8 + ) + + # Quoting the Apple dev docs: + # + # "A pointer to a C string or NULL if the internal + # storage of theString does not allow this to be + # returned efficiently." + # + # So we need to get our hands dirty. + if message is None: + buffer = ctypes.create_string_buffer(1024) + result = CoreFoundation.CFStringGetCString( + error_message_cfstring_c_void_p, + buffer, + 1024, + CFConst.kCFStringEncodingUTF8, + ) + if not result: + raise OSError("Error copying C string from CFStringRef") + message = buffer.value + + finally: + if error_message_cfstring is not None: + CoreFoundation.CFRelease(error_message_cfstring) + + # If no message can be found for this status we come + # up with a generic one that forwards the status code. + if message is None or message == "": + message = f"SecureTransport operation returned a non-zero OSStatus: {result}" + + raise ssl.SSLError(message) + + +Security.SecTrustCreateWithCertificates.errcheck = _handle_osstatus # type: ignore[assignment] +Security.SecTrustSetAnchorCertificates.errcheck = _handle_osstatus # type: ignore[assignment] +Security.SecTrustSetAnchorCertificatesOnly.errcheck = _handle_osstatus # type: ignore[assignment] +Security.SecTrustGetTrustResult.errcheck = _handle_osstatus # type: ignore[assignment] +Security.SecTrustEvaluate.errcheck = _handle_osstatus # type: ignore[assignment] + + +class CFConst: + """CoreFoundation constants""" + + kCFStringEncodingUTF8 = CFStringEncoding(0x08000100) + + errSecIncompleteCertRevocationCheck = -67635 + errSecHostNameMismatch = -67602 + errSecCertificateExpired = -67818 + errSecNotTrusted = -67843 + + +def _bytes_to_cf_data_ref(value: bytes) -> CFDataRef: # type: ignore[valid-type] + return CoreFoundation.CFDataCreate( # type: ignore[no-any-return] + CoreFoundation.kCFAllocatorDefault, value, len(value) + ) + + +def _bytes_to_cf_string(value: bytes) -> CFString: + """ + Given a Python binary data, create a CFString. + The string must be CFReleased by the caller. + """ + c_str = ctypes.c_char_p(value) + cf_str = CoreFoundation.CFStringCreateWithCString( + CoreFoundation.kCFAllocatorDefault, + c_str, + CFConst.kCFStringEncodingUTF8, + ) + return cf_str # type: ignore[no-any-return] + + +def _cf_string_ref_to_str(cf_string_ref: CFStringRef) -> str | None: # type: ignore[valid-type] + """ + Creates a Unicode string from a CFString object. Used entirely for error + reporting. + Yes, it annoys me quite a lot that this function is this complex. + """ + + string = CoreFoundation.CFStringGetCStringPtr( + cf_string_ref, CFConst.kCFStringEncodingUTF8 + ) + if string is None: + buffer = ctypes.create_string_buffer(1024) + result = CoreFoundation.CFStringGetCString( + cf_string_ref, buffer, 1024, CFConst.kCFStringEncodingUTF8 + ) + if not result: + raise OSError("Error copying C string from CFStringRef") + string = buffer.value + if string is not None: + string = string.decode("utf-8") + return string # type: ignore[no-any-return] + + +def _der_certs_to_cf_cert_array(certs: list[bytes]) -> CFMutableArrayRef: # type: ignore[valid-type] + """Builds a CFArray of SecCertificateRefs from a list of DER-encoded certificates. + Responsibility of the caller to call CoreFoundation.CFRelease on the CFArray. + """ + cf_array = CoreFoundation.CFArrayCreateMutable( + CoreFoundation.kCFAllocatorDefault, + 0, + ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks), + ) + if not cf_array: + raise MemoryError("Unable to allocate memory!") + + for cert_data in certs: + cf_data = None + sec_cert_ref = None + try: + cf_data = _bytes_to_cf_data_ref(cert_data) + sec_cert_ref = Security.SecCertificateCreateWithData( + CoreFoundation.kCFAllocatorDefault, cf_data + ) + CoreFoundation.CFArrayAppendValue(cf_array, sec_cert_ref) + finally: + if cf_data: + CoreFoundation.CFRelease(cf_data) + if sec_cert_ref: + CoreFoundation.CFRelease(sec_cert_ref) + + return cf_array # type: ignore[no-any-return] + + +@contextlib.contextmanager +def _configure_context(ctx: ssl.SSLContext) -> typing.Iterator[None]: + check_hostname = ctx.check_hostname + verify_mode = ctx.verify_mode + ctx.check_hostname = False + _set_ssl_context_verify_mode(ctx, ssl.CERT_NONE) + try: + yield + finally: + ctx.check_hostname = check_hostname + _set_ssl_context_verify_mode(ctx, verify_mode) + + +def _verify_peercerts_impl( + ssl_context: ssl.SSLContext, + cert_chain: list[bytes], + server_hostname: str | None = None, +) -> None: + certs = None + policies = None + trust = None + try: + # Only set a hostname on the policy if we're verifying the hostname + # on the leaf certificate. + if server_hostname is not None and ssl_context.check_hostname: + cf_str_hostname = None + try: + cf_str_hostname = _bytes_to_cf_string(server_hostname.encode("ascii")) + ssl_policy = Security.SecPolicyCreateSSL(True, cf_str_hostname) + finally: + if cf_str_hostname: + CoreFoundation.CFRelease(cf_str_hostname) + else: + ssl_policy = Security.SecPolicyCreateSSL(True, None) + + policies = ssl_policy + if ssl_context.verify_flags & ssl.VERIFY_CRL_CHECK_CHAIN: + # Add explicit policy requiring positive revocation checks + policies = CoreFoundation.CFArrayCreateMutable( + CoreFoundation.kCFAllocatorDefault, + 0, + ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks), + ) + CoreFoundation.CFArrayAppendValue(policies, ssl_policy) + CoreFoundation.CFRelease(ssl_policy) + revocation_policy = Security.SecPolicyCreateRevocation( + kSecRevocationUseAnyAvailableMethod + | kSecRevocationRequirePositiveResponse + ) + CoreFoundation.CFArrayAppendValue(policies, revocation_policy) + CoreFoundation.CFRelease(revocation_policy) + elif ssl_context.verify_flags & ssl.VERIFY_CRL_CHECK_LEAF: + raise NotImplementedError("VERIFY_CRL_CHECK_LEAF not implemented for macOS") + + certs = None + try: + certs = _der_certs_to_cf_cert_array(cert_chain) + + # Now that we have certificates loaded and a SecPolicy + # we can finally create a SecTrust object! + trust = Security.SecTrustRef() + Security.SecTrustCreateWithCertificates( + certs, policies, ctypes.byref(trust) + ) + + finally: + # The certs are now being held by SecTrust so we can + # release our handles for the array. + if certs: + CoreFoundation.CFRelease(certs) + + # If there are additional trust anchors to load we need to transform + # the list of DER-encoded certificates into a CFArray. + ctx_ca_certs_der: list[bytes] | None = ssl_context.get_ca_certs( + binary_form=True + ) + if ctx_ca_certs_der: + ctx_ca_certs = None + try: + ctx_ca_certs = _der_certs_to_cf_cert_array(ctx_ca_certs_der) + Security.SecTrustSetAnchorCertificates(trust, ctx_ca_certs) + finally: + if ctx_ca_certs: + CoreFoundation.CFRelease(ctx_ca_certs) + + # We always want system certificates. + Security.SecTrustSetAnchorCertificatesOnly(trust, False) + + # macOS 10.13 and earlier don't support SecTrustEvaluateWithError() + # so we use SecTrustEvaluate() which means we need to construct error + # messages ourselves. + if _is_macos_version_10_14_or_later: + _verify_peercerts_impl_macos_10_14(ssl_context, trust) + else: + _verify_peercerts_impl_macos_10_13(ssl_context, trust) + finally: + if policies: + CoreFoundation.CFRelease(policies) + if trust: + CoreFoundation.CFRelease(trust) + + +def _verify_peercerts_impl_macos_10_13( + ssl_context: ssl.SSLContext, sec_trust_ref: typing.Any +) -> None: + """Verify using 'SecTrustEvaluate' API for macOS 10.13 and earlier. + macOS 10.14 added the 'SecTrustEvaluateWithError' API. + """ + sec_trust_result_type = Security.SecTrustResultType() + Security.SecTrustEvaluate(sec_trust_ref, ctypes.byref(sec_trust_result_type)) + + try: + sec_trust_result_type_as_int = int(sec_trust_result_type.value) + except (ValueError, TypeError): + sec_trust_result_type_as_int = -1 + + # Apple doesn't document these values in their own API docs. + # See: https://github.com/xybp888/iOS-SDKs/blob/master/iPhoneOS13.0.sdk/System/Library/Frameworks/Security.framework/Headers/SecTrust.h#L84 + if ( + ssl_context.verify_mode == ssl.CERT_REQUIRED + and sec_trust_result_type_as_int not in (1, 4) + ): + # Note that we're not able to ignore only hostname errors + # for macOS 10.13 and earlier, so check_hostname=False will + # still return an error. + sec_trust_result_type_to_message = { + 0: "Invalid trust result type", + # 1: "Trust evaluation succeeded", + 2: "User confirmation required", + 3: "User specified that certificate is not trusted", + # 4: "Trust result is unspecified", + 5: "Recoverable trust failure occurred", + 6: "Fatal trust failure occurred", + 7: "Other error occurred, certificate may be revoked", + } + error_message = sec_trust_result_type_to_message.get( + sec_trust_result_type_as_int, + f"Unknown trust result: {sec_trust_result_type_as_int}", + ) + + err = ssl.SSLCertVerificationError(error_message) + err.verify_message = error_message + err.verify_code = sec_trust_result_type_as_int + raise err + + +def _verify_peercerts_impl_macos_10_14( + ssl_context: ssl.SSLContext, sec_trust_ref: typing.Any +) -> None: + """Verify using 'SecTrustEvaluateWithError' API for macOS 10.14+.""" + cf_error = CoreFoundation.CFErrorRef() + sec_trust_eval_result = Security.SecTrustEvaluateWithError( + sec_trust_ref, ctypes.byref(cf_error) + ) + # sec_trust_eval_result is a bool (0 or 1) + # where 1 means that the certs are trusted. + if sec_trust_eval_result == 1: + is_trusted = True + elif sec_trust_eval_result == 0: + is_trusted = False + else: + raise ssl.SSLError( + f"Unknown result from Security.SecTrustEvaluateWithError: {sec_trust_eval_result!r}" + ) + + cf_error_code = 0 + if not is_trusted: + cf_error_code = CoreFoundation.CFErrorGetCode(cf_error) + + # If the error is a known failure that we're + # explicitly okay with from SSLContext configuration + # we can set is_trusted accordingly. + if ssl_context.verify_mode != ssl.CERT_REQUIRED and ( + cf_error_code == CFConst.errSecNotTrusted + or cf_error_code == CFConst.errSecCertificateExpired + ): + is_trusted = True + + # If we're still not trusted then we start to + # construct and raise the SSLCertVerificationError. + if not is_trusted: + cf_error_string_ref = None + try: + cf_error_string_ref = CoreFoundation.CFErrorCopyDescription(cf_error) + + # Can this ever return 'None' if there's a CFError? + cf_error_message = ( + _cf_string_ref_to_str(cf_error_string_ref) + or "Certificate verification failed" + ) + + # TODO: Not sure if we need the SecTrustResultType for anything? + # We only care whether or not it's a success or failure for now. + sec_trust_result_type = Security.SecTrustResultType() + Security.SecTrustGetTrustResult( + sec_trust_ref, ctypes.byref(sec_trust_result_type) + ) + + err = ssl.SSLCertVerificationError(cf_error_message) + err.verify_message = cf_error_message + err.verify_code = cf_error_code + raise err + finally: + if cf_error_string_ref: + CoreFoundation.CFRelease(cf_error_string_ref) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/_openssl.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/_openssl.py new file mode 100644 index 0000000000000000000000000000000000000000..8a595dd7f78fef050dd13b4a54a40f0d00b3c9ba --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/_openssl.py @@ -0,0 +1,65 @@ +import contextlib +import os +import re +import ssl +import typing + +# candidates based on https://github.com/tiran/certifi-system-store by Christian Heimes +_CA_FILE_CANDIDATES = [ + # Alpine, Arch, Fedora 34-43, OpenWRT, RHEL 9-10, BSD + "/etc/ssl/cert.pem", + # Fedora 44+, RHEL 11+ + "/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem", + # Fedora <= 34, RHEL <= 9, CentOS <= 9 + "/etc/pki/tls/cert.pem", + # Debian, Ubuntu (requires ca-certificates) + "/etc/ssl/certs/ca-certificates.crt", + # SUSE + "/etc/ssl/ca-bundle.pem", +] + +_HASHED_CERT_FILENAME_RE = re.compile(r"^[0-9a-fA-F]{8}\.[0-9]$") + + +@contextlib.contextmanager +def _configure_context(ctx: ssl.SSLContext) -> typing.Iterator[None]: + # First, check whether the default locations from OpenSSL + # seem like they will give us a usable set of CA certs. + # ssl.get_default_verify_paths already takes care of: + # - getting cafile from either the SSL_CERT_FILE env var + # or the path configured when OpenSSL was compiled, + # and verifying that that path exists + # - getting capath from either the SSL_CERT_DIR env var + # or the path configured when OpenSSL was compiled, + # and verifying that that path exists + # In addition we'll check whether capath appears to contain certs. + defaults = ssl.get_default_verify_paths() + if defaults.cafile or (defaults.capath and _capath_contains_certs(defaults.capath)): + ctx.set_default_verify_paths() + else: + # cafile from OpenSSL doesn't exist + # and capath from OpenSSL doesn't contain certs. + # Let's search other common locations instead. + for cafile in _CA_FILE_CANDIDATES: + if os.path.isfile(cafile): + ctx.load_verify_locations(cafile=cafile) + break + + yield + + +def _capath_contains_certs(capath: str) -> bool: + """Check whether capath exists and contains certs in the expected format.""" + if not os.path.isdir(capath): + return False + return any(_HASHED_CERT_FILENAME_RE.match(name) for name in os.listdir(capath)) + + +def _verify_peercerts_impl( + ssl_context: ssl.SSLContext, + cert_chain: list[bytes], + server_hostname: str | None = None, +) -> None: + # This is a no-op because we've enabled SSLContext's built-in + # verification via verify_mode=CERT_REQUIRED, and don't need to repeat it. + pass diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/_ssl_constants.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/_ssl_constants.py new file mode 100644 index 0000000000000000000000000000000000000000..f164f622c2fb675904484ba0bc3e5c099edcc92a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/_ssl_constants.py @@ -0,0 +1,30 @@ +import ssl +import sys + +# Hold on to the original class so we can create it consistently +# even if we inject our own SSLContext into the ssl module. +_original_SSLContext = ssl.SSLContext +_original_super_SSLContext = super(_original_SSLContext, _original_SSLContext) + +# CPython is known to be good, but non-CPython implementations +# may implement SSLContext differently so to be safe we don't +# subclass the SSLContext. + +# This is returned by truststore.SSLContext.__class__() +_truststore_SSLContext_dunder_class: type | None + +# This value is the superclass of truststore.SSLContext. +_truststore_SSLContext_super_class: type + +if sys.implementation.name == "cpython": + _truststore_SSLContext_super_class = _original_SSLContext + _truststore_SSLContext_dunder_class = None +else: + _truststore_SSLContext_super_class = object + _truststore_SSLContext_dunder_class = _original_SSLContext + + +def _set_ssl_context_verify_mode( + ssl_context: ssl.SSLContext, verify_mode: ssl.VerifyMode +) -> None: + _original_super_SSLContext.verify_mode.__set__(ssl_context, verify_mode) # type: ignore[attr-defined] diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/_windows.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/_windows.py new file mode 100644 index 0000000000000000000000000000000000000000..e0482039fdb874a36651b7c78f3fbf52788cc521 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/_windows.py @@ -0,0 +1,567 @@ +import contextlib # noqa: I001 +import ssl +import typing +from ctypes import WinDLL # type: ignore[attr-defined] +from ctypes import WinError # type: ignore[attr-defined] +from ctypes import ( + POINTER, + Structure, + c_char_p, + c_ulong, + c_void_p, + c_wchar_p, + cast, + create_unicode_buffer, + pointer, + sizeof, +) +from ctypes.wintypes import ( + BOOL, + DWORD, + HANDLE, + LONG, + LPCSTR, + LPCVOID, + LPCWSTR, + LPFILETIME, + LPSTR, + LPWSTR, +) +from typing import TYPE_CHECKING, Any + +from ._ssl_constants import _set_ssl_context_verify_mode + +HCERTCHAINENGINE = HANDLE +HCERTSTORE = HANDLE +HCRYPTPROV_LEGACY = HANDLE + + +class CERT_CONTEXT(Structure): + _fields_ = ( + ("dwCertEncodingType", DWORD), + ("pbCertEncoded", c_void_p), + ("cbCertEncoded", DWORD), + ("pCertInfo", c_void_p), + ("hCertStore", HCERTSTORE), + ) + + +PCERT_CONTEXT = POINTER(CERT_CONTEXT) +PCCERT_CONTEXT = POINTER(PCERT_CONTEXT) + + +class CERT_ENHKEY_USAGE(Structure): + _fields_ = ( + ("cUsageIdentifier", DWORD), + ("rgpszUsageIdentifier", POINTER(LPSTR)), + ) + + +PCERT_ENHKEY_USAGE = POINTER(CERT_ENHKEY_USAGE) + + +class CERT_USAGE_MATCH(Structure): + _fields_ = ( + ("dwType", DWORD), + ("Usage", CERT_ENHKEY_USAGE), + ) + + +class CERT_CHAIN_PARA(Structure): + _fields_ = ( + ("cbSize", DWORD), + ("RequestedUsage", CERT_USAGE_MATCH), + ("RequestedIssuancePolicy", CERT_USAGE_MATCH), + ("dwUrlRetrievalTimeout", DWORD), + ("fCheckRevocationFreshnessTime", BOOL), + ("dwRevocationFreshnessTime", DWORD), + ("pftCacheResync", LPFILETIME), + ("pStrongSignPara", c_void_p), + ("dwStrongSignFlags", DWORD), + ) + + +if TYPE_CHECKING: + PCERT_CHAIN_PARA = pointer[CERT_CHAIN_PARA] # type: ignore[misc] +else: + PCERT_CHAIN_PARA = POINTER(CERT_CHAIN_PARA) + + +class CERT_TRUST_STATUS(Structure): + _fields_ = ( + ("dwErrorStatus", DWORD), + ("dwInfoStatus", DWORD), + ) + + +class CERT_CHAIN_ELEMENT(Structure): + _fields_ = ( + ("cbSize", DWORD), + ("pCertContext", PCERT_CONTEXT), + ("TrustStatus", CERT_TRUST_STATUS), + ("pRevocationInfo", c_void_p), + ("pIssuanceUsage", PCERT_ENHKEY_USAGE), + ("pApplicationUsage", PCERT_ENHKEY_USAGE), + ("pwszExtendedErrorInfo", LPCWSTR), + ) + + +PCERT_CHAIN_ELEMENT = POINTER(CERT_CHAIN_ELEMENT) + + +class CERT_SIMPLE_CHAIN(Structure): + _fields_ = ( + ("cbSize", DWORD), + ("TrustStatus", CERT_TRUST_STATUS), + ("cElement", DWORD), + ("rgpElement", POINTER(PCERT_CHAIN_ELEMENT)), + ("pTrustListInfo", c_void_p), + ("fHasRevocationFreshnessTime", BOOL), + ("dwRevocationFreshnessTime", DWORD), + ) + + +PCERT_SIMPLE_CHAIN = POINTER(CERT_SIMPLE_CHAIN) + + +class CERT_CHAIN_CONTEXT(Structure): + _fields_ = ( + ("cbSize", DWORD), + ("TrustStatus", CERT_TRUST_STATUS), + ("cChain", DWORD), + ("rgpChain", POINTER(PCERT_SIMPLE_CHAIN)), + ("cLowerQualityChainContext", DWORD), + ("rgpLowerQualityChainContext", c_void_p), + ("fHasRevocationFreshnessTime", BOOL), + ("dwRevocationFreshnessTime", DWORD), + ) + + +PCERT_CHAIN_CONTEXT = POINTER(CERT_CHAIN_CONTEXT) +PCCERT_CHAIN_CONTEXT = POINTER(PCERT_CHAIN_CONTEXT) + + +class SSL_EXTRA_CERT_CHAIN_POLICY_PARA(Structure): + _fields_ = ( + ("cbSize", DWORD), + ("dwAuthType", DWORD), + ("fdwChecks", DWORD), + ("pwszServerName", LPCWSTR), + ) + + +class CERT_CHAIN_POLICY_PARA(Structure): + _fields_ = ( + ("cbSize", DWORD), + ("dwFlags", DWORD), + ("pvExtraPolicyPara", c_void_p), + ) + + +PCERT_CHAIN_POLICY_PARA = POINTER(CERT_CHAIN_POLICY_PARA) + + +class CERT_CHAIN_POLICY_STATUS(Structure): + _fields_ = ( + ("cbSize", DWORD), + ("dwError", DWORD), + ("lChainIndex", LONG), + ("lElementIndex", LONG), + ("pvExtraPolicyStatus", c_void_p), + ) + + +PCERT_CHAIN_POLICY_STATUS = POINTER(CERT_CHAIN_POLICY_STATUS) + + +class CERT_CHAIN_ENGINE_CONFIG(Structure): + _fields_ = ( + ("cbSize", DWORD), + ("hRestrictedRoot", HCERTSTORE), + ("hRestrictedTrust", HCERTSTORE), + ("hRestrictedOther", HCERTSTORE), + ("cAdditionalStore", DWORD), + ("rghAdditionalStore", c_void_p), + ("dwFlags", DWORD), + ("dwUrlRetrievalTimeout", DWORD), + ("MaximumCachedCertificates", DWORD), + ("CycleDetectionModulus", DWORD), + ("hExclusiveRoot", HCERTSTORE), + ("hExclusiveTrustedPeople", HCERTSTORE), + ("dwExclusiveFlags", DWORD), + ) + + +PCERT_CHAIN_ENGINE_CONFIG = POINTER(CERT_CHAIN_ENGINE_CONFIG) +PHCERTCHAINENGINE = POINTER(HCERTCHAINENGINE) + +X509_ASN_ENCODING = 0x00000001 +PKCS_7_ASN_ENCODING = 0x00010000 +CERT_STORE_PROV_MEMORY = b"Memory" +CERT_STORE_ADD_USE_EXISTING = 2 +USAGE_MATCH_TYPE_OR = 1 +OID_PKIX_KP_SERVER_AUTH = c_char_p(b"1.3.6.1.5.5.7.3.1") +CERT_CHAIN_REVOCATION_CHECK_END_CERT = 0x10000000 +CERT_CHAIN_REVOCATION_CHECK_CHAIN = 0x20000000 +CERT_CHAIN_POLICY_IGNORE_ALL_NOT_TIME_VALID_FLAGS = 0x00000007 +CERT_CHAIN_POLICY_IGNORE_INVALID_BASIC_CONSTRAINTS_FLAG = 0x00000008 +CERT_CHAIN_POLICY_ALLOW_UNKNOWN_CA_FLAG = 0x00000010 +CERT_CHAIN_POLICY_IGNORE_INVALID_NAME_FLAG = 0x00000040 +CERT_CHAIN_POLICY_IGNORE_WRONG_USAGE_FLAG = 0x00000020 +CERT_CHAIN_POLICY_IGNORE_INVALID_POLICY_FLAG = 0x00000080 +CERT_CHAIN_POLICY_IGNORE_ALL_REV_UNKNOWN_FLAGS = 0x00000F00 +CERT_CHAIN_POLICY_ALLOW_TESTROOT_FLAG = 0x00008000 +CERT_CHAIN_POLICY_TRUST_TESTROOT_FLAG = 0x00004000 +SECURITY_FLAG_IGNORE_CERT_CN_INVALID = 0x00001000 +AUTHTYPE_SERVER = 2 +CERT_CHAIN_POLICY_SSL = 4 +FORMAT_MESSAGE_FROM_SYSTEM = 0x00001000 +FORMAT_MESSAGE_IGNORE_INSERTS = 0x00000200 + +# Flags to set for SSLContext.verify_mode=CERT_NONE +CERT_CHAIN_POLICY_VERIFY_MODE_NONE_FLAGS = ( + CERT_CHAIN_POLICY_IGNORE_ALL_NOT_TIME_VALID_FLAGS + | CERT_CHAIN_POLICY_IGNORE_INVALID_BASIC_CONSTRAINTS_FLAG + | CERT_CHAIN_POLICY_ALLOW_UNKNOWN_CA_FLAG + | CERT_CHAIN_POLICY_IGNORE_INVALID_NAME_FLAG + | CERT_CHAIN_POLICY_IGNORE_WRONG_USAGE_FLAG + | CERT_CHAIN_POLICY_IGNORE_INVALID_POLICY_FLAG + | CERT_CHAIN_POLICY_IGNORE_ALL_REV_UNKNOWN_FLAGS + | CERT_CHAIN_POLICY_ALLOW_TESTROOT_FLAG + | CERT_CHAIN_POLICY_TRUST_TESTROOT_FLAG +) + +wincrypt = WinDLL("crypt32.dll") +kernel32 = WinDLL("kernel32.dll") + + +def _handle_win_error(result: bool, _: Any, args: Any) -> Any: + if not result: + # Note, actually raises OSError after calling GetLastError and FormatMessage + raise WinError() + return args + + +CertCreateCertificateChainEngine = wincrypt.CertCreateCertificateChainEngine +CertCreateCertificateChainEngine.argtypes = ( + PCERT_CHAIN_ENGINE_CONFIG, + PHCERTCHAINENGINE, +) +CertCreateCertificateChainEngine.errcheck = _handle_win_error + +CertOpenStore = wincrypt.CertOpenStore +CertOpenStore.argtypes = (LPCSTR, DWORD, HCRYPTPROV_LEGACY, DWORD, c_void_p) +CertOpenStore.restype = HCERTSTORE +CertOpenStore.errcheck = _handle_win_error + +CertAddEncodedCertificateToStore = wincrypt.CertAddEncodedCertificateToStore +CertAddEncodedCertificateToStore.argtypes = ( + HCERTSTORE, + DWORD, + c_char_p, + DWORD, + DWORD, + PCCERT_CONTEXT, +) +CertAddEncodedCertificateToStore.restype = BOOL + +CertCreateCertificateContext = wincrypt.CertCreateCertificateContext +CertCreateCertificateContext.argtypes = (DWORD, c_char_p, DWORD) +CertCreateCertificateContext.restype = PCERT_CONTEXT +CertCreateCertificateContext.errcheck = _handle_win_error + +CertGetCertificateChain = wincrypt.CertGetCertificateChain +CertGetCertificateChain.argtypes = ( + HCERTCHAINENGINE, + PCERT_CONTEXT, + LPFILETIME, + HCERTSTORE, + PCERT_CHAIN_PARA, + DWORD, + c_void_p, + PCCERT_CHAIN_CONTEXT, +) +CertGetCertificateChain.restype = BOOL +CertGetCertificateChain.errcheck = _handle_win_error + +CertVerifyCertificateChainPolicy = wincrypt.CertVerifyCertificateChainPolicy +CertVerifyCertificateChainPolicy.argtypes = ( + c_ulong, + PCERT_CHAIN_CONTEXT, + PCERT_CHAIN_POLICY_PARA, + PCERT_CHAIN_POLICY_STATUS, +) +CertVerifyCertificateChainPolicy.restype = BOOL + +CertCloseStore = wincrypt.CertCloseStore +CertCloseStore.argtypes = (HCERTSTORE, DWORD) +CertCloseStore.restype = BOOL +CertCloseStore.errcheck = _handle_win_error + +CertFreeCertificateChain = wincrypt.CertFreeCertificateChain +CertFreeCertificateChain.argtypes = (PCERT_CHAIN_CONTEXT,) + +CertFreeCertificateContext = wincrypt.CertFreeCertificateContext +CertFreeCertificateContext.argtypes = (PCERT_CONTEXT,) + +CertFreeCertificateChainEngine = wincrypt.CertFreeCertificateChainEngine +CertFreeCertificateChainEngine.argtypes = (HCERTCHAINENGINE,) + +FormatMessageW = kernel32.FormatMessageW +FormatMessageW.argtypes = ( + DWORD, + LPCVOID, + DWORD, + DWORD, + LPWSTR, + DWORD, + c_void_p, +) +FormatMessageW.restype = DWORD + + +def _verify_peercerts_impl( + ssl_context: ssl.SSLContext, + cert_chain: list[bytes], + server_hostname: str | None = None, +) -> None: + """Verify the cert_chain from the server using Windows APIs.""" + + # If the peer didn't send any certificates then + # we can't do verification. Raise an error. + if not cert_chain: + raise ssl.SSLCertVerificationError("Peer sent no certificates to verify") + + pCertContext = None + hIntermediateCertStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, None, 0, None) + try: + # Add intermediate certs to an in-memory cert store + for cert_bytes in cert_chain[1:]: + CertAddEncodedCertificateToStore( + hIntermediateCertStore, + X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, + cert_bytes, + len(cert_bytes), + CERT_STORE_ADD_USE_EXISTING, + None, + ) + + # Cert context for leaf cert + leaf_cert = cert_chain[0] + pCertContext = CertCreateCertificateContext( + X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, leaf_cert, len(leaf_cert) + ) + + # Chain params to match certs for serverAuth extended usage + cert_enhkey_usage = CERT_ENHKEY_USAGE() + cert_enhkey_usage.cUsageIdentifier = 1 + cert_enhkey_usage.rgpszUsageIdentifier = (c_char_p * 1)(OID_PKIX_KP_SERVER_AUTH) + cert_usage_match = CERT_USAGE_MATCH() + cert_usage_match.Usage = cert_enhkey_usage + chain_params = CERT_CHAIN_PARA() + chain_params.RequestedUsage = cert_usage_match + chain_params.cbSize = sizeof(chain_params) + pChainPara = pointer(chain_params) + + if ssl_context.verify_flags & ssl.VERIFY_CRL_CHECK_CHAIN: + chain_flags = CERT_CHAIN_REVOCATION_CHECK_CHAIN + elif ssl_context.verify_flags & ssl.VERIFY_CRL_CHECK_LEAF: + chain_flags = CERT_CHAIN_REVOCATION_CHECK_END_CERT + else: + chain_flags = 0 + + try: + # First attempt to verify using the default Windows system trust roots + # (default chain engine). + _get_and_verify_cert_chain( + ssl_context, + None, + hIntermediateCertStore, + pCertContext, + pChainPara, + server_hostname, + chain_flags=chain_flags, + ) + except ssl.SSLCertVerificationError as e: + # If that fails but custom CA certs have been added + # to the SSLContext using load_verify_locations, + # try verifying using a custom chain engine + # that trusts the custom CA certs. + custom_ca_certs: list[bytes] | None = ssl_context.get_ca_certs( + binary_form=True + ) + if custom_ca_certs: + try: + _verify_using_custom_ca_certs( + ssl_context, + custom_ca_certs, + hIntermediateCertStore, + pCertContext, + pChainPara, + server_hostname, + chain_flags=chain_flags, + ) + # Raise the original error, not the new error. + except ssl.SSLCertVerificationError: + raise e from None + else: + raise + finally: + CertCloseStore(hIntermediateCertStore, 0) + if pCertContext: + CertFreeCertificateContext(pCertContext) + + +def _get_and_verify_cert_chain( + ssl_context: ssl.SSLContext, + hChainEngine: HCERTCHAINENGINE | None, + hIntermediateCertStore: HCERTSTORE, + pPeerCertContext: c_void_p, + pChainPara: PCERT_CHAIN_PARA, # type: ignore[valid-type] + server_hostname: str | None, + chain_flags: int, +) -> None: + ppChainContext = None + try: + # Get cert chain + ppChainContext = pointer(PCERT_CHAIN_CONTEXT()) + CertGetCertificateChain( + hChainEngine, # chain engine + pPeerCertContext, # leaf cert context + None, # current system time + hIntermediateCertStore, # additional in-memory cert store + pChainPara, # chain-building parameters + chain_flags, + None, # reserved + ppChainContext, # the resulting chain context + ) + pChainContext = ppChainContext.contents + + # Verify cert chain + ssl_extra_cert_chain_policy_para = SSL_EXTRA_CERT_CHAIN_POLICY_PARA() + ssl_extra_cert_chain_policy_para.cbSize = sizeof( + ssl_extra_cert_chain_policy_para + ) + ssl_extra_cert_chain_policy_para.dwAuthType = AUTHTYPE_SERVER + ssl_extra_cert_chain_policy_para.fdwChecks = 0 + if ssl_context.check_hostname is False: + ssl_extra_cert_chain_policy_para.fdwChecks = ( + SECURITY_FLAG_IGNORE_CERT_CN_INVALID + ) + if server_hostname: + ssl_extra_cert_chain_policy_para.pwszServerName = c_wchar_p(server_hostname) + + chain_policy = CERT_CHAIN_POLICY_PARA() + chain_policy.pvExtraPolicyPara = cast( + pointer(ssl_extra_cert_chain_policy_para), c_void_p + ) + if ssl_context.verify_mode == ssl.CERT_NONE: + chain_policy.dwFlags |= CERT_CHAIN_POLICY_VERIFY_MODE_NONE_FLAGS + chain_policy.cbSize = sizeof(chain_policy) + + pPolicyPara = pointer(chain_policy) + policy_status = CERT_CHAIN_POLICY_STATUS() + policy_status.cbSize = sizeof(policy_status) + pPolicyStatus = pointer(policy_status) + CertVerifyCertificateChainPolicy( + CERT_CHAIN_POLICY_SSL, + pChainContext, + pPolicyPara, + pPolicyStatus, + ) + + # Check status + error_code = policy_status.dwError + if error_code: + # Try getting a human readable message for an error code. + error_message_buf = create_unicode_buffer(1024) + error_message_chars = FormatMessageW( + FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, + None, + error_code, + 0, + error_message_buf, + sizeof(error_message_buf), + None, + ) + + # See if we received a message for the error, + # otherwise we use a generic error with the + # error code and hope that it's search-able. + if error_message_chars <= 0: + error_message = f"Certificate chain policy error {error_code:#x} [{policy_status.lElementIndex}]" + else: + error_message = error_message_buf.value.strip() + + err = ssl.SSLCertVerificationError(error_message) + err.verify_message = error_message + err.verify_code = error_code + raise err from None + finally: + if ppChainContext: + CertFreeCertificateChain(ppChainContext.contents) + + +def _verify_using_custom_ca_certs( + ssl_context: ssl.SSLContext, + custom_ca_certs: list[bytes], + hIntermediateCertStore: HCERTSTORE, + pPeerCertContext: c_void_p, + pChainPara: PCERT_CHAIN_PARA, # type: ignore[valid-type] + server_hostname: str | None, + chain_flags: int, +) -> None: + hChainEngine = None + hRootCertStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, None, 0, None) + try: + # Add custom CA certs to an in-memory cert store + for cert_bytes in custom_ca_certs: + CertAddEncodedCertificateToStore( + hRootCertStore, + X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, + cert_bytes, + len(cert_bytes), + CERT_STORE_ADD_USE_EXISTING, + None, + ) + + # Create a custom cert chain engine which exclusively trusts + # certs from our hRootCertStore + cert_chain_engine_config = CERT_CHAIN_ENGINE_CONFIG() + cert_chain_engine_config.cbSize = sizeof(cert_chain_engine_config) + cert_chain_engine_config.hExclusiveRoot = hRootCertStore + pConfig = pointer(cert_chain_engine_config) + phChainEngine = pointer(HCERTCHAINENGINE()) + CertCreateCertificateChainEngine( + pConfig, + phChainEngine, + ) + hChainEngine = phChainEngine.contents + + # Get and verify a cert chain using the custom chain engine + _get_and_verify_cert_chain( + ssl_context, + hChainEngine, + hIntermediateCertStore, + pPeerCertContext, + pChainPara, + server_hostname, + chain_flags, + ) + finally: + if hChainEngine: + CertFreeCertificateChainEngine(hChainEngine) + CertCloseStore(hRootCertStore, 0) + + +@contextlib.contextmanager +def _configure_context(ctx: ssl.SSLContext) -> typing.Iterator[None]: + check_hostname = ctx.check_hostname + verify_mode = ctx.verify_mode + ctx.check_hostname = False + _set_ssl_context_verify_mode(ctx, ssl.CERT_NONE) + try: + yield + finally: + ctx.check_hostname = check_hostname + _set_ssl_context_verify_mode(ctx, verify_mode) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/py.typed b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/truststore/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions-4.16.0.dist-info/INSTALLER b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions-4.16.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions-4.16.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions-4.16.0.dist-info/METADATA b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions-4.16.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..97fd818b909551186a659e13240c49c2187d0cdc --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions-4.16.0.dist-info/METADATA @@ -0,0 +1,73 @@ +Metadata-Version: 2.4 +Name: typing_extensions +Version: 4.16.0 +Summary: Backported and Experimental Type Hints for Python 3.9+ +Keywords: annotations,backport,checker,checking,function,hinting,hints,type,typechecking,typehinting,typehints,typing +Author-email: "Guido van Rossum, Jukka Lehtosalo, Łukasz Langa, Michael Lee" +Requires-Python: >=3.9 +Description-Content-Type: text/markdown +License-Expression: PSF-2.0 +Classifier: Development Status :: 5 - Production/Stable +Classifier: Environment :: Console +Classifier: Intended Audience :: Developers +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: 3.14 +Classifier: Programming Language :: Python :: 3.15 +Classifier: Topic :: Software Development +License-File: LICENSE +Project-URL: Bug Tracker, https://github.com/python/typing_extensions/issues +Project-URL: Changes, https://github.com/python/typing_extensions/blob/main/CHANGELOG.md +Project-URL: Documentation, https://typing-extensions.readthedocs.io/ +Project-URL: Home, https://github.com/python/typing_extensions +Project-URL: Q & A, https://github.com/python/typing/discussions +Project-URL: Repository, https://github.com/python/typing_extensions + +# Typing Extensions + +[![Chat at https://gitter.im/python/typing](https://badges.gitter.im/python/typing.svg)](https://gitter.im/python/typing) + +[Documentation](https://typing-extensions.readthedocs.io/en/latest/#) – +[PyPI](https://pypi.org/project/typing-extensions/) + +## Overview + +The `typing_extensions` module serves two related purposes: + +- Enable use of new type system features on older Python versions. For example, + `typing.TypeGuard` is new in Python 3.10, but `typing_extensions` allows + users on previous Python versions to use it too. +- Enable experimentation with new type system PEPs before they are accepted and + added to the `typing` module. + +`typing_extensions` is treated specially by static type checkers such as +mypy and pyright. Objects defined in `typing_extensions` are treated the same +way as equivalent forms in `typing`. + +`typing_extensions` uses +[Semantic Versioning](https://semver.org/). The +major version will be incremented only for backwards-incompatible changes. +Therefore, it's safe to depend +on `typing_extensions` like this: `typing_extensions ~=x.y`, +where `x.y` is the first version that includes all features you need. +[This](https://packaging.python.org/en/latest/specifications/version-specifiers/#compatible-release) +is equivalent to `typing_extensions >=x.y, <(x+1)`. Do not depend on `~= x.y.z` +unless you really know what you're doing; that defeats the purpose of +semantic versioning. + +## Included items + +See [the documentation](https://typing-extensions.readthedocs.io/en/latest/#) for a +complete listing of module contents. + +## Contributing + +See [CONTRIBUTING.md](https://github.com/python/typing_extensions/blob/main/CONTRIBUTING.md) +for how to contribute to `typing_extensions`. + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions-4.16.0.dist-info/RECORD b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions-4.16.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..4b531ef5e0c1c2b45a0c0daf40e1b4cd169127e7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions-4.16.0.dist-info/RECORD @@ -0,0 +1,7 @@ +__pycache__/typing_extensions.cpython-311.pyc,, +typing_extensions-4.16.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +typing_extensions-4.16.0.dist-info/METADATA,sha256=sFCEyh1Qh5hlF42f_5-r6rYb37HzYb-96VQh_8j5vkY,3310 +typing_extensions-4.16.0.dist-info/RECORD,, +typing_extensions-4.16.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82 +typing_extensions-4.16.0.dist-info/licenses/LICENSE,sha256=Oy-B_iHRgcSZxZolbI4ZaEVdZonSaaqFNzv7avQdo78,13936 +typing_extensions.py,sha256=QEDKGh7L7gDROFwSqTCE0cW9RvC3dPB-WufpHE9V5pY,165012 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions-4.16.0.dist-info/WHEEL b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions-4.16.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..d8b9936dad9ab2513fa6979f411560d3b6b57e37 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions-4.16.0.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: flit 3.12.0 +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions-4.16.0.dist-info/licenses/LICENSE b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions-4.16.0.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..f26bcf4d2de6eb136e31006ca3ab447d5e488adf --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions-4.16.0.dist-info/licenses/LICENSE @@ -0,0 +1,279 @@ +A. HISTORY OF THE SOFTWARE +========================== + +Python was created in the early 1990s by Guido van Rossum at Stichting +Mathematisch Centrum (CWI, see https://www.cwi.nl) in the Netherlands +as a successor of a language called ABC. Guido remains Python's +principal author, although it includes many contributions from others. + +In 1995, Guido continued his work on Python at the Corporation for +National Research Initiatives (CNRI, see https://www.cnri.reston.va.us) +in Reston, Virginia where he released several versions of the +software. + +In May 2000, Guido and the Python core development team moved to +BeOpen.com to form the BeOpen PythonLabs team. In October of the same +year, the PythonLabs team moved to Digital Creations, which became +Zope Corporation. In 2001, the Python Software Foundation (PSF, see +https://www.python.org/psf/) was formed, a non-profit organization +created specifically to own Python-related Intellectual Property. +Zope Corporation was a sponsoring member of the PSF. + +All Python releases are Open Source (see https://opensource.org for +the Open Source Definition). Historically, most, but not all, Python +releases have also been GPL-compatible; the table below summarizes +the various releases. + + Release Derived Year Owner GPL- + from compatible? (1) + + 0.9.0 thru 1.2 1991-1995 CWI yes + 1.3 thru 1.5.2 1.2 1995-1999 CNRI yes + 1.6 1.5.2 2000 CNRI no + 2.0 1.6 2000 BeOpen.com no + 1.6.1 1.6 2001 CNRI yes (2) + 2.1 2.0+1.6.1 2001 PSF no + 2.0.1 2.0+1.6.1 2001 PSF yes + 2.1.1 2.1+2.0.1 2001 PSF yes + 2.1.2 2.1.1 2002 PSF yes + 2.1.3 2.1.2 2002 PSF yes + 2.2 and above 2.1.1 2001-now PSF yes + +Footnotes: + +(1) GPL-compatible doesn't mean that we're distributing Python under + the GPL. All Python licenses, unlike the GPL, let you distribute + a modified version without making your changes open source. The + GPL-compatible licenses make it possible to combine Python with + other software that is released under the GPL; the others don't. + +(2) According to Richard Stallman, 1.6.1 is not GPL-compatible, + because its license has a choice of law clause. According to + CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1 + is "not incompatible" with the GPL. + +Thanks to the many outside volunteers who have worked under Guido's +direction to make these releases possible. + + +B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON +=============================================================== + +Python software and documentation are licensed under the +Python Software Foundation License Version 2. + +Starting with Python 3.8.6, examples, recipes, and other code in +the documentation are dual licensed under the PSF License Version 2 +and the Zero-Clause BSD license. + +Some software incorporated into Python is under different licenses. +The licenses are listed with code falling under that license. + + +PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 +-------------------------------------------- + +1. This LICENSE AGREEMENT is between the Python Software Foundation +("PSF"), and the Individual or Organization ("Licensee") accessing and +otherwise using this software ("Python") in source or binary form and +its associated documentation. + +2. Subject to the terms and conditions of this License Agreement, PSF hereby +grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, +analyze, test, perform and/or display publicly, prepare derivative works, +distribute, and otherwise use Python alone or in any derivative version, +provided, however, that PSF's License Agreement and PSF's notice of copyright, +i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, +2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Python Software Foundation; +All Rights Reserved" are retained in Python alone or in any derivative version +prepared by Licensee. + +3. In the event Licensee prepares a derivative work that is based on +or incorporates Python or any part thereof, and wants to make +the derivative work available to others as provided herein, then +Licensee hereby agrees to include in any such work a brief summary of +the changes made to Python. + +4. PSF is making Python available to Licensee on an "AS IS" +basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON +FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +6. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +7. Nothing in this License Agreement shall be deemed to create any +relationship of agency, partnership, or joint venture between PSF and +Licensee. This License Agreement does not grant permission to use PSF +trademarks or trade name in a trademark sense to endorse or promote +products or services of Licensee, or any third party. + +8. By copying, installing or otherwise using Python, Licensee +agrees to be bound by the terms and conditions of this License +Agreement. + + +BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0 +------------------------------------------- + +BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1 + +1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an +office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the +Individual or Organization ("Licensee") accessing and otherwise using +this software in source or binary form and its associated +documentation ("the Software"). + +2. Subject to the terms and conditions of this BeOpen Python License +Agreement, BeOpen hereby grants Licensee a non-exclusive, +royalty-free, world-wide license to reproduce, analyze, test, perform +and/or display publicly, prepare derivative works, distribute, and +otherwise use the Software alone or in any derivative version, +provided, however, that the BeOpen Python License is retained in the +Software, alone or in any derivative version prepared by Licensee. + +3. BeOpen is making the Software available to Licensee on an "AS IS" +basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE +SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS +AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY +DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +5. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +6. This License Agreement shall be governed by and interpreted in all +respects by the law of the State of California, excluding conflict of +law provisions. Nothing in this License Agreement shall be deemed to +create any relationship of agency, partnership, or joint venture +between BeOpen and Licensee. This License Agreement does not grant +permission to use BeOpen trademarks or trade names in a trademark +sense to endorse or promote products or services of Licensee, or any +third party. As an exception, the "BeOpen Python" logos available at +http://www.pythonlabs.com/logos.html may be used according to the +permissions granted on that web page. + +7. By copying, installing or otherwise using the software, Licensee +agrees to be bound by the terms and conditions of this License +Agreement. + + +CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1 +--------------------------------------- + +1. This LICENSE AGREEMENT is between the Corporation for National +Research Initiatives, having an office at 1895 Preston White Drive, +Reston, VA 20191 ("CNRI"), and the Individual or Organization +("Licensee") accessing and otherwise using Python 1.6.1 software in +source or binary form and its associated documentation. + +2. Subject to the terms and conditions of this License Agreement, CNRI +hereby grants Licensee a nonexclusive, royalty-free, world-wide +license to reproduce, analyze, test, perform and/or display publicly, +prepare derivative works, distribute, and otherwise use Python 1.6.1 +alone or in any derivative version, provided, however, that CNRI's +License Agreement and CNRI's notice of copyright, i.e., "Copyright (c) +1995-2001 Corporation for National Research Initiatives; All Rights +Reserved" are retained in Python 1.6.1 alone or in any derivative +version prepared by Licensee. Alternately, in lieu of CNRI's License +Agreement, Licensee may substitute the following text (omitting the +quotes): "Python 1.6.1 is made available subject to the terms and +conditions in CNRI's License Agreement. This Agreement together with +Python 1.6.1 may be located on the internet using the following +unique, persistent identifier (known as a handle): 1895.22/1013. This +Agreement may also be obtained from a proxy server on the internet +using the following URL: http://hdl.handle.net/1895.22/1013". + +3. In the event Licensee prepares a derivative work that is based on +or incorporates Python 1.6.1 or any part thereof, and wants to make +the derivative work available to others as provided herein, then +Licensee hereby agrees to include in any such work a brief summary of +the changes made to Python 1.6.1. + +4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS" +basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON +1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +6. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +7. This License Agreement shall be governed by the federal +intellectual property law of the United States, including without +limitation the federal copyright law, and, to the extent such +U.S. federal law does not apply, by the law of the Commonwealth of +Virginia, excluding Virginia's conflict of law provisions. +Notwithstanding the foregoing, with regard to derivative works based +on Python 1.6.1 that incorporate non-separable material that was +previously distributed under the GNU General Public License (GPL), the +law of the Commonwealth of Virginia shall govern this License +Agreement only as to issues arising under or with respect to +Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this +License Agreement shall be deemed to create any relationship of +agency, partnership, or joint venture between CNRI and Licensee. This +License Agreement does not grant permission to use CNRI trademarks or +trade name in a trademark sense to endorse or promote products or +services of Licensee, or any third party. + +8. By clicking on the "ACCEPT" button where indicated, or by copying, +installing or otherwise using Python 1.6.1, Licensee agrees to be +bound by the terms and conditions of this License Agreement. + + ACCEPT + + +CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2 +-------------------------------------------------- + +Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, +The Netherlands. All rights reserved. + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Stichting Mathematisch +Centrum or CWI not be used in advertising or publicity pertaining to +distribution of the software without specific, written prior +permission. + +STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO +THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE +FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION +---------------------------------------------------------------------- + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions.py new file mode 100644 index 0000000000000000000000000000000000000000..ced78373258ef307c9a94ef15286e6da359e7a80 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/typing_extensions.py @@ -0,0 +1,4422 @@ +import abc +import builtins +import collections +import collections.abc +import contextlib +import enum +import functools +import inspect +import io +import keyword +import operator +import sys +import types as _types +import typing +import warnings + +# Breakpoint: https://github.com/python/cpython/pull/119891 +if sys.version_info >= (3, 14): + import annotationlib + +__all__ = [ + # Super-special typing primitives. + 'Any', + 'ClassVar', + 'Concatenate', + 'Final', + 'LiteralString', + 'ParamSpec', + 'ParamSpecArgs', + 'ParamSpecKwargs', + 'Self', + 'Type', + 'TypeVar', + 'TypeVarTuple', + 'Unpack', + + # ABCs (from collections.abc). + 'Awaitable', + 'AsyncIterator', + 'AsyncIterable', + 'Coroutine', + 'AsyncGenerator', + 'AsyncContextManager', + 'Buffer', + 'ChainMap', + + # Concrete collection types. + 'ContextManager', + 'Counter', + 'Deque', + 'DefaultDict', + 'NamedTuple', + 'OrderedDict', + 'TypedDict', + + # Structural checks, a.k.a. protocols. + 'SupportsAbs', + 'SupportsBytes', + 'SupportsComplex', + 'SupportsFloat', + 'SupportsIndex', + 'SupportsInt', + 'SupportsRound', + 'Reader', + 'Writer', + + # One-off things. + 'Annotated', + 'assert_never', + 'assert_type', + 'clear_overloads', + 'dataclass_transform', + 'deprecated', + 'disjoint_base', + 'Doc', + 'evaluate_forward_ref', + 'get_overloads', + 'final', + 'Format', + 'get_annotations', + 'get_args', + 'get_origin', + 'get_original_bases', + 'get_protocol_members', + 'get_type_hints', + 'IntVar', + 'is_protocol', + 'is_typeddict', + 'Literal', + 'NewType', + 'overload', + 'override', + 'Protocol', + 'sentinel', + 'Sentinel', + 'reveal_type', + 'runtime', + 'runtime_checkable', + 'Text', + 'TypeAlias', + 'TypeAliasType', + 'TypeForm', + 'TypeGuard', + 'TypeIs', + 'TYPE_CHECKING', + 'type_repr', + 'Never', + 'NoReturn', + 'ReadOnly', + 'Required', + 'NotRequired', + 'NoDefault', + 'NoExtraItems', + + # Pure aliases, have always been in typing + 'AbstractSet', + 'AnyStr', + 'BinaryIO', + 'Callable', + 'Collection', + 'Container', + 'Dict', + 'ForwardRef', + 'FrozenSet', + 'Generator', + 'Generic', + 'Hashable', + 'IO', + 'ItemsView', + 'Iterable', + 'Iterator', + 'KeysView', + 'List', + 'Mapping', + 'MappingView', + 'Match', + 'MutableMapping', + 'MutableSequence', + 'MutableSet', + 'Optional', + 'Pattern', + 'Reversible', + 'Sequence', + 'Set', + 'Sized', + 'TextIO', + 'Tuple', + 'Union', + 'ValuesView', + 'cast', + 'no_type_check', +] + +# for backward compatibility +PEP_560 = True +GenericMeta = type +# Breakpoint: https://github.com/python/cpython/pull/116129 +_PEP_696_IMPLEMENTED = sys.version_info >= (3, 13, 0, "beta") + +# Added with bpo-45166 to 3.10.1+ and some 3.9 versions +_FORWARD_REF_HAS_CLASS = "__forward_is_class__" in typing.ForwardRef.__slots__ + + +def _caller(depth=1, default='__main__'): + try: + return sys._getframemodulename(depth + 1) or default + except AttributeError: # For platforms without _getframemodulename() + pass + try: + return sys._getframe(depth + 1).f_globals.get('__name__', default) + except (AttributeError, ValueError): # For platforms without _getframe() + pass + return None + + +# Placeholder for sentinel methods, because sentinels can not have their own sentinels +_sentinel_placeholder = object() + +if hasattr(builtins, "sentinel"): # 3.15+ + sentinel = builtins.sentinel +else: + class sentinel: + """Create a unique sentinel object. + + *name* should be the name of the variable to which the return value + shall be assigned. + """ + + def __init__( + self, + __name: str = _sentinel_placeholder, + __repr: typing.Optional[str] = _sentinel_placeholder, + /, + *, + repr: typing.Optional[str] = None, + name: str = _sentinel_placeholder, + ) -> None: + if name is not _sentinel_placeholder: + warnings.warn( + "Passing 'name' as a keyword argument is deprecated; " + "pass it positionally instead.", + DeprecationWarning, + stacklevel=2, + ) + __name = name + if __name is _sentinel_placeholder: + raise TypeError("First parameter 'name' is required") + if __repr is not _sentinel_placeholder: + warnings.warn( + "Passing 'repr' as a positional argument is deprecated; " + "pass it by keyword instead.", + DeprecationWarning, + stacklevel=2, + ) + repr = __repr + + self._name = __name + self._repr = repr if repr is not None else __name + + # For pickling as a singleton: + self.__module__ = _caller() + + def __init_subclass__(cls): + warnings.warn( + "Subclassing sentinel is deprecated " + "and will be disallowed in Python 3.15", + DeprecationWarning, + stacklevel=2, + ) + super().__init_subclass__() + + def __setattr__(self, attr: str, value: object) -> None: + if attr not in {"_name", "_repr", "__module__"}: + warnings.warn( + f"Setting attribute {attr!r} on sentinel objects is deprecated " + "and will be disallowed in Python 3.15.", + DeprecationWarning, + stacklevel=2, + ) + super().__setattr__(attr, value) + + @property + def __name__(self) -> str: + return self._name + + @__name__.setter + def __name__(self, value: str) -> None: + self._name = value + + def __repr__(self) -> str: + return self._repr + + if sys.version_info < (3, 11): + # The presence of this method convinces typing._type_check + # that Sentinels are types. + def __call__(self, *args, **kwargs): + raise TypeError(f"{type(self).__name__!r} object is not callable") + + # Breakpoint: https://github.com/python/cpython/pull/21515 + if sys.version_info >= (3, 10): + def __or__(self, other): + return typing.Union[self, other] + + def __ror__(self, other): + return typing.Union[other, self] + + def __reduce__(self) -> str: + """Reduce this sentinel to a singleton.""" + return self.__name__ # Module is taken from the __module__ attribute + +Sentinel = sentinel + +_marker = sentinel("sentinel") + + +# The functions below are modified copies of typing internal helpers. +# They are needed by _ProtocolMeta and they provide support for PEP 646. + +# Breakpoint: https://github.com/python/cpython/pull/27342 +if sys.version_info >= (3, 10): + def _should_collect_from_parameters(t): + return isinstance( + t, (typing._GenericAlias, _types.GenericAlias, _types.UnionType) + ) +else: + def _should_collect_from_parameters(t): + return isinstance(t, (typing._GenericAlias, _types.GenericAlias)) + + +NoReturn = typing.NoReturn + +# Some unconstrained type variables. These are used by the container types. +# (These are not for export.) +T = typing.TypeVar('T') # Any type. +KT = typing.TypeVar('KT') # Key type. +VT = typing.TypeVar('VT') # Value type. +T_co = typing.TypeVar('T_co', covariant=True) # Any type covariant containers. +T_contra = typing.TypeVar('T_contra', contravariant=True) # Ditto contravariant. + + +# Breakpoint: https://github.com/python/cpython/pull/31841 +if sys.version_info >= (3, 11): + from typing import Any +else: + + class _AnyMeta(type): + def __instancecheck__(self, obj): + if self is Any: + raise TypeError("typing_extensions.Any cannot be used with isinstance()") + return super().__instancecheck__(obj) + + def __repr__(self): + if self is Any: + return "typing_extensions.Any" + return super().__repr__() + + class Any(metaclass=_AnyMeta): + """Special type indicating an unconstrained type. + - Any is compatible with every type. + - Any assumed to have all methods. + - All values assumed to be instances of Any. + Note that all the above statements are true from the point of view of + static type checkers. At runtime, Any should not be used with instance + checks. + """ + def __new__(cls, *args, **kwargs): + if cls is Any: + raise TypeError("Any cannot be instantiated") + return super().__new__(cls, *args, **kwargs) + + +ClassVar = typing.ClassVar + +# Vendored from cpython typing._SpecialFrom +# Having a separate class means that instances will not be rejected by +# typing._type_check. +class _SpecialForm(typing._Final, _root=True): + __slots__ = ('_name', '__doc__', '_getitem') + + def __init__(self, getitem): + self._getitem = getitem + self._name = getitem.__name__ + self.__doc__ = getitem.__doc__ + + def __getattr__(self, item): + if item in {'__name__', '__qualname__'}: + return self._name + + raise AttributeError(item) + + def __mro_entries__(self, bases): + raise TypeError(f"Cannot subclass {self!r}") + + def __repr__(self): + return f'typing_extensions.{self._name}' + + def __reduce__(self): + return self._name + + def __call__(self, *args, **kwds): + raise TypeError(f"Cannot instantiate {self!r}") + + def __or__(self, other): + return typing.Union[self, other] + + def __ror__(self, other): + return typing.Union[other, self] + + def __instancecheck__(self, obj): + raise TypeError(f"{self} cannot be used with isinstance()") + + def __subclasscheck__(self, cls): + raise TypeError(f"{self} cannot be used with issubclass()") + + @typing._tp_cache + def __getitem__(self, parameters): + return self._getitem(self, parameters) + + +# Note that inheriting from this class means that the object will be +# rejected by typing._type_check, so do not use it if the special form +# is arguably valid as a type by itself. +class _ExtensionsSpecialForm(typing._SpecialForm, _root=True): + def __repr__(self): + return 'typing_extensions.' + self._name + + +Final = typing.Final + +# Breakpoint: https://github.com/python/cpython/pull/30530 +if sys.version_info >= (3, 11): + final = typing.final +else: + # @final exists in 3.8+, but we backport it for all versions + # before 3.11 to keep support for the __final__ attribute. + # See https://bugs.python.org/issue46342 + def final(f): + """This decorator can be used to indicate to type checkers that + the decorated method cannot be overridden, and decorated class + cannot be subclassed. For example: + + class Base: + @final + def done(self) -> None: + ... + class Sub(Base): + def done(self) -> None: # Error reported by type checker + ... + @final + class Leaf: + ... + class Other(Leaf): # Error reported by type checker + ... + + There is no runtime checking of these properties. The decorator + sets the ``__final__`` attribute to ``True`` on the decorated object + to allow runtime introspection. + """ + try: + f.__final__ = True + except (AttributeError, TypeError): + # Skip the attribute silently if it is not writable. + # AttributeError happens if the object has __slots__ or a + # read-only property, TypeError if it's a builtin class. + pass + return f + + +if hasattr(typing, "disjoint_base"): # 3.15 + disjoint_base = typing.disjoint_base +else: + def disjoint_base(cls): + """This decorator marks a class as a disjoint base. + + Child classes of a disjoint base cannot inherit from other disjoint bases that are + not parent classes of the disjoint base. + + For example: + + @disjoint_base + class Disjoint1: pass + + @disjoint_base + class Disjoint2: pass + + class Disjoint3(Disjoint1, Disjoint2): pass # Type checker error + + Type checkers can use knowledge of disjoint bases to detect unreachable code + and determine when two types can overlap. + + See PEP 800.""" + cls.__disjoint_base__ = True + return cls + + +def IntVar(name): + return typing.TypeVar(name) + + +# A Literal bug was fixed in 3.11.0, 3.10.1 and 3.9.8 +# Breakpoint: https://github.com/python/cpython/pull/29334 +if sys.version_info >= (3, 10, 1): + Literal = typing.Literal +else: + def _flatten_literal_params(parameters): + """An internal helper for Literal creation: flatten Literals among parameters""" + params = [] + for p in parameters: + if isinstance(p, _LiteralGenericAlias): + params.extend(p.__args__) + else: + params.append(p) + return tuple(params) + + def _value_and_type_iter(params): + for p in params: + yield p, type(p) + + class _LiteralGenericAlias(typing._GenericAlias, _root=True): + def __eq__(self, other): + if not isinstance(other, _LiteralGenericAlias): + return NotImplemented + these_args_deduped = set(_value_and_type_iter(self.__args__)) + other_args_deduped = set(_value_and_type_iter(other.__args__)) + return these_args_deduped == other_args_deduped + + def __hash__(self): + return hash(frozenset(_value_and_type_iter(self.__args__))) + + class _LiteralForm(_ExtensionsSpecialForm, _root=True): + def __init__(self, doc: str): + self._name = 'Literal' + self._doc = self.__doc__ = doc + + def __getitem__(self, parameters): + if not isinstance(parameters, tuple): + parameters = (parameters,) + + parameters = _flatten_literal_params(parameters) + + val_type_pairs = list(_value_and_type_iter(parameters)) + try: + deduped_pairs = set(val_type_pairs) + except TypeError: + # unhashable parameters + pass + else: + # similar logic to typing._deduplicate on Python 3.9+ + if len(deduped_pairs) < len(val_type_pairs): + new_parameters = [] + for pair in val_type_pairs: + if pair in deduped_pairs: + new_parameters.append(pair[0]) + deduped_pairs.remove(pair) + assert not deduped_pairs, deduped_pairs + parameters = tuple(new_parameters) + + return _LiteralGenericAlias(self, parameters) + + Literal = _LiteralForm(doc="""\ + A type that can be used to indicate to type checkers + that the corresponding value has a value literally equivalent + to the provided parameter. For example: + + var: Literal[4] = 4 + + The type checker understands that 'var' is literally equal to + the value 4 and no other value. + + Literal[...] cannot be subclassed. There is no runtime + checking verifying that the parameter is actually a value + instead of a type.""") + + +_overload_dummy = typing._overload_dummy + + +if hasattr(typing, "get_overloads"): # 3.11+ + overload = typing.overload + get_overloads = typing.get_overloads + clear_overloads = typing.clear_overloads +else: + # {module: {qualname: {firstlineno: func}}} + _overload_registry = collections.defaultdict( + functools.partial(collections.defaultdict, dict) + ) + + def overload(func): + """Decorator for overloaded functions/methods. + + In a stub file, place two or more stub definitions for the same + function in a row, each decorated with @overload. For example: + + @overload + def utf8(value: None) -> None: ... + @overload + def utf8(value: bytes) -> bytes: ... + @overload + def utf8(value: str) -> bytes: ... + + In a non-stub file (i.e. a regular .py file), do the same but + follow it with an implementation. The implementation should *not* + be decorated with @overload. For example: + + @overload + def utf8(value: None) -> None: ... + @overload + def utf8(value: bytes) -> bytes: ... + @overload + def utf8(value: str) -> bytes: ... + def utf8(value): + # implementation goes here + + The overloads for a function can be retrieved at runtime using the + get_overloads() function. + """ + # classmethod and staticmethod + f = getattr(func, "__func__", func) + try: + _overload_registry[f.__module__][f.__qualname__][ + f.__code__.co_firstlineno + ] = func + except AttributeError: + # Not a normal function; ignore. + pass + return _overload_dummy + + def get_overloads(func): + """Return all defined overloads for *func* as a sequence.""" + # classmethod and staticmethod + f = getattr(func, "__func__", func) + if f.__module__ not in _overload_registry: + return [] + mod_dict = _overload_registry[f.__module__] + if f.__qualname__ not in mod_dict: + return [] + return list(mod_dict[f.__qualname__].values()) + + def clear_overloads(): + """Clear all overloads in the registry.""" + _overload_registry.clear() + + +# This is not a real generic class. Don't use outside annotations. +Type = typing.Type + +# Various ABCs mimicking those in collections.abc. +# A few are simply re-exported for completeness. +Awaitable = typing.Awaitable +Coroutine = typing.Coroutine +AsyncIterable = typing.AsyncIterable +AsyncIterator = typing.AsyncIterator +Deque = typing.Deque +DefaultDict = typing.DefaultDict +OrderedDict = typing.OrderedDict +Counter = typing.Counter +ChainMap = typing.ChainMap +Text = typing.Text +TYPE_CHECKING = typing.TYPE_CHECKING + + +# Breakpoint: https://github.com/python/cpython/pull/118681 +if sys.version_info >= (3, 13, 0, "beta"): + from typing import AsyncContextManager, AsyncGenerator, ContextManager, Generator +else: + def _is_dunder(attr): + return attr.startswith('__') and attr.endswith('__') + + + class _SpecialGenericAlias(typing._SpecialGenericAlias, _root=True): + def __init__(self, origin, nparams, *, defaults, inst=True, name=None): + assert nparams > 0, "`nparams` must be a positive integer" + assert defaults, "Must always specify a non-empty sequence for `defaults`" + super().__init__(origin, nparams, inst=inst, name=name) + self._defaults = defaults + + def __setattr__(self, attr, val): + allowed_attrs = {'_name', '_inst', '_nparams', '_defaults'} + if _is_dunder(attr) or attr in allowed_attrs: + object.__setattr__(self, attr, val) + else: + setattr(self.__origin__, attr, val) + + @typing._tp_cache + def __getitem__(self, params): + if not isinstance(params, tuple): + params = (params,) + msg = "Parameters to generic types must be types." + params = tuple(typing._type_check(p, msg) for p in params) + if ( + len(params) < self._nparams + and len(params) + len(self._defaults) >= self._nparams + ): + params = (*params, *self._defaults[len(params) - self._nparams:]) + actual_len = len(params) + + if actual_len != self._nparams: + expected = f"at least {self._nparams - len(self._defaults)}" + raise TypeError( + f"Too {'many' if actual_len > self._nparams else 'few'}" + f" arguments for {self};" + f" actual {actual_len}, expected {expected}" + ) + return self.copy_with(params) + + _NoneType = type(None) + Generator = _SpecialGenericAlias( + collections.abc.Generator, 3, defaults=(_NoneType, _NoneType) + ) + AsyncGenerator = _SpecialGenericAlias( + collections.abc.AsyncGenerator, 2, defaults=(_NoneType,) + ) + ContextManager = _SpecialGenericAlias( + contextlib.AbstractContextManager, + 2, + name="ContextManager", + defaults=(typing.Optional[bool],) + ) + AsyncContextManager = _SpecialGenericAlias( + contextlib.AbstractAsyncContextManager, + 2, + name="AsyncContextManager", + defaults=(typing.Optional[bool],) + ) + + +_PROTO_ALLOWLIST = { + 'collections.abc': [ + 'Callable', 'Awaitable', 'Iterable', 'Iterator', 'AsyncIterable', + 'AsyncIterator', 'Hashable', 'Sized', 'Container', 'Collection', + 'Reversible', 'Buffer', + ], + 'contextlib': ['AbstractContextManager', 'AbstractAsyncContextManager'], + 'io': ['Reader', 'Writer'], + 'typing_extensions': ['Buffer'], + 'os': ['PathLike'], +} + + +_EXCLUDED_ATTRS = frozenset(typing.EXCLUDED_ATTRIBUTES) | { + "__match_args__", "__protocol_attrs__", "__non_callable_proto_members__", + "__final__", +} + + +def _get_protocol_attrs(cls): + attrs = set() + for base in cls.__mro__[:-1]: # without object + if base.__name__ in {'Protocol', 'Generic'}: + continue + annotations = getattr(base, '__annotations__', {}) + for attr in (*base.__dict__, *annotations): + if (not attr.startswith('_abc_') and attr not in _EXCLUDED_ATTRS): + attrs.add(attr) + return attrs + + +# `__match_args__` attribute was removed from protocol members in 3.13, +# we want to backport this change to older Python versions. +# 3.14 additionally added `io.Reader`, `io.Writer` and `os.PathLike` to +# the list of allowed protocol allowlist. +# https://github.com/python/cpython/issues/127647 +if sys.version_info >= (3, 14): + Protocol = typing.Protocol +else: + def _allow_reckless_class_checks(depth=2): + """Allow instance and class checks for special stdlib modules. + The abc and functools modules indiscriminately call isinstance() and + issubclass() on the whole MRO of a user class, which may contain protocols. + """ + return _caller(depth) in {'abc', 'functools', None} + + def _no_init(self, *args, **kwargs): + if type(self)._is_protocol: + raise TypeError('Protocols cannot be instantiated') + + def _type_check_issubclass_arg_1(arg): + """Raise TypeError if `arg` is not an instance of `type` + in `issubclass(arg, )`. + + In most cases, this is verified by type.__subclasscheck__. + Checking it again unnecessarily would slow down issubclass() checks, + so, we don't perform this check unless we absolutely have to. + + For various error paths, however, + we want to ensure that *this* error message is shown to the user + where relevant, rather than a typing.py-specific error message. + """ + if not isinstance(arg, type): + # Same error message as for issubclass(1, int). + raise TypeError('issubclass() arg 1 must be a class') + + # Inheriting from typing._ProtocolMeta isn't actually desirable, + # but is necessary to allow typing.Protocol and typing_extensions.Protocol + # to mix without getting TypeErrors about "metaclass conflict" + class _ProtocolMeta(type(typing.Protocol)): + # This metaclass is somewhat unfortunate, + # but is necessary for several reasons... + # + # NOTE: DO NOT call super() in any methods in this class + # That would call the methods on typing._ProtocolMeta on Python <=3.11 + # and those are slow + def __new__(mcls, name, bases, namespace, **kwargs): + if name == "Protocol" and len(bases) < 2: + pass + elif {Protocol, typing.Protocol} & set(bases): + for base in bases: + if not ( + base in {object, typing.Generic, Protocol, typing.Protocol} + or base.__name__ in _PROTO_ALLOWLIST.get(base.__module__, []) + or is_protocol(base) + ): + raise TypeError( + f"Protocols can only inherit from other protocols, " + f"got {base!r}" + ) + return abc.ABCMeta.__new__(mcls, name, bases, namespace, **kwargs) + + def __init__(cls, *args, **kwargs): + abc.ABCMeta.__init__(cls, *args, **kwargs) + if getattr(cls, "_is_protocol", False): + cls.__protocol_attrs__ = _get_protocol_attrs(cls) + + def __subclasscheck__(cls, other): + if cls is Protocol: + return type.__subclasscheck__(cls, other) + if ( + getattr(cls, '_is_protocol', False) + and not _allow_reckless_class_checks() + ): + if not getattr(cls, '_is_runtime_protocol', False): + _type_check_issubclass_arg_1(other) + raise TypeError( + "Instance and class checks can only be used with " + "@runtime_checkable protocols" + ) + if ( + # this attribute is set by @runtime_checkable: + cls.__non_callable_proto_members__ + and cls.__dict__.get("__subclasshook__") is _proto_hook + ): + _type_check_issubclass_arg_1(other) + non_method_attrs = sorted(cls.__non_callable_proto_members__) + raise TypeError( + "Protocols with non-method members don't support issubclass()." + f" Non-method members: {str(non_method_attrs)[1:-1]}." + ) + return abc.ABCMeta.__subclasscheck__(cls, other) + + def __instancecheck__(cls, instance): + # We need this method for situations where attributes are + # assigned in __init__. + if cls is Protocol: + return type.__instancecheck__(cls, instance) + if not getattr(cls, "_is_protocol", False): + # i.e., it's a concrete subclass of a protocol + return abc.ABCMeta.__instancecheck__(cls, instance) + + if ( + not getattr(cls, '_is_runtime_protocol', False) and + not _allow_reckless_class_checks() + ): + raise TypeError("Instance and class checks can only be used with" + " @runtime_checkable protocols") + + if abc.ABCMeta.__instancecheck__(cls, instance): + return True + + for attr in cls.__protocol_attrs__: + try: + val = inspect.getattr_static(instance, attr) + except AttributeError: + break + # this attribute is set by @runtime_checkable: + if val is None and attr not in cls.__non_callable_proto_members__: + break + else: + return True + + return False + + def __eq__(cls, other): + # Hack so that typing.Generic.__class_getitem__ + # treats typing_extensions.Protocol + # as equivalent to typing.Protocol + if abc.ABCMeta.__eq__(cls, other) is True: + return True + return cls is Protocol and other is typing.Protocol + + # This has to be defined, or the abc-module cache + # complains about classes with this metaclass being unhashable, + # if we define only __eq__! + def __hash__(cls) -> int: + return type.__hash__(cls) + + @classmethod + def _proto_hook(cls, other): + if not cls.__dict__.get('_is_protocol', False): + return NotImplemented + + for attr in cls.__protocol_attrs__: + for base in other.__mro__: + # Check if the members appears in the class dictionary... + if attr in base.__dict__: + if base.__dict__[attr] is None: + return NotImplemented + break + + # ...or in annotations, if it is a sub-protocol. + annotations = getattr(base, '__annotations__', {}) + if ( + isinstance(annotations, collections.abc.Mapping) + and attr in annotations + and is_protocol(other) + ): + break + else: + return NotImplemented + return True + + class Protocol(typing.Generic, metaclass=_ProtocolMeta): + __doc__ = typing.Protocol.__doc__ + __slots__ = () + _is_protocol = True + _is_runtime_protocol = False + + def __init_subclass__(cls, *args, **kwargs): + super().__init_subclass__(*args, **kwargs) + + # Determine if this is a protocol or a concrete subclass. + if not cls.__dict__.get('_is_protocol', False): + cls._is_protocol = any(b is Protocol for b in cls.__bases__) + + # Set (or override) the protocol subclass hook. + if '__subclasshook__' not in cls.__dict__: + cls.__subclasshook__ = _proto_hook + + # Prohibit instantiation for protocol classes + if cls._is_protocol and cls.__init__ is Protocol.__init__: + cls.__init__ = _no_init + + +# Breakpoint: https://github.com/python/cpython/pull/113401 +if sys.version_info >= (3, 13): + runtime_checkable = typing.runtime_checkable +else: + def runtime_checkable(cls): + """Mark a protocol class as a runtime protocol. + + Such protocol can be used with isinstance() and issubclass(). + Raise TypeError if applied to a non-protocol class. + This allows a simple-minded structural check very similar to + one trick ponies in collections.abc such as Iterable. + + For example:: + + @runtime_checkable + class Closable(Protocol): + def close(self): ... + + assert isinstance(open('/some/file'), Closable) + + Warning: this will check only the presence of the required methods, + not their type signatures! + """ + if not issubclass(cls, typing.Generic) or not getattr(cls, '_is_protocol', False): + raise TypeError(f'@runtime_checkable can be only applied to protocol classes,' + f' got {cls!r}') + cls._is_runtime_protocol = True + + # typing.Protocol classes on <=3.11 break if we execute this block, + # because typing.Protocol classes on <=3.11 don't have a + # `__protocol_attrs__` attribute, and this block relies on the + # `__protocol_attrs__` attribute. Meanwhile, typing.Protocol classes on 3.12.2+ + # break if we *don't* execute this block, because *they* assume that all + # protocol classes have a `__non_callable_proto_members__` attribute + # (which this block sets) + if isinstance(cls, _ProtocolMeta) or sys.version_info >= (3, 12, 2): + # PEP 544 prohibits using issubclass() + # with protocols that have non-method members. + # See gh-113320 for why we compute this attribute here, + # rather than in `_ProtocolMeta.__init__` + cls.__non_callable_proto_members__ = set() + for attr in cls.__protocol_attrs__: + try: + is_callable = callable(getattr(cls, attr, None)) + except Exception as e: + raise TypeError( + f"Failed to determine whether protocol member {attr!r} " + "is a method member" + ) from e + else: + if not is_callable: + cls.__non_callable_proto_members__.add(attr) + + return cls + + +# The "runtime" alias exists for backwards compatibility. +runtime = runtime_checkable + + +# Our version of runtime-checkable protocols is faster on Python <=3.11 +# Breakpoint: https://github.com/python/cpython/pull/112717 +if sys.version_info >= (3, 12): + SupportsInt = typing.SupportsInt + SupportsFloat = typing.SupportsFloat + SupportsComplex = typing.SupportsComplex + SupportsBytes = typing.SupportsBytes + SupportsIndex = typing.SupportsIndex + SupportsAbs = typing.SupportsAbs + SupportsRound = typing.SupportsRound +else: + @runtime_checkable + class SupportsInt(Protocol): + """An ABC with one abstract method __int__.""" + __slots__ = () + + @abc.abstractmethod + def __int__(self) -> int: + pass + + @runtime_checkable + class SupportsFloat(Protocol): + """An ABC with one abstract method __float__.""" + __slots__ = () + + @abc.abstractmethod + def __float__(self) -> float: + pass + + @runtime_checkable + class SupportsComplex(Protocol): + """An ABC with one abstract method __complex__.""" + __slots__ = () + + @abc.abstractmethod + def __complex__(self) -> complex: + pass + + @runtime_checkable + class SupportsBytes(Protocol): + """An ABC with one abstract method __bytes__.""" + __slots__ = () + + @abc.abstractmethod + def __bytes__(self) -> bytes: + pass + + @runtime_checkable + class SupportsIndex(Protocol): + __slots__ = () + + @abc.abstractmethod + def __index__(self) -> int: + pass + + @runtime_checkable + class SupportsAbs(Protocol[T_co]): + """ + An ABC with one abstract method __abs__ that is covariant in its return type. + """ + __slots__ = () + + @abc.abstractmethod + def __abs__(self) -> T_co: + pass + + @runtime_checkable + class SupportsRound(Protocol[T_co]): + """ + An ABC with one abstract method __round__ that is covariant in its return type. + """ + __slots__ = () + + @abc.abstractmethod + def __round__(self, ndigits: int = 0) -> T_co: + pass + + +if hasattr(io, "Reader") and hasattr(io, "Writer"): + Reader = io.Reader + Writer = io.Writer +else: + @runtime_checkable + class Reader(Protocol[T_co]): + """Protocol for simple I/O reader instances. + + This protocol only supports blocking I/O. + """ + + __slots__ = () + + @abc.abstractmethod + def read(self, size: int = ..., /) -> T_co: + """Read data from the input stream and return it. + + If *size* is specified, at most *size* items (bytes/characters) will be + read. + """ + + @runtime_checkable + class Writer(Protocol[T_contra]): + """Protocol for simple I/O writer instances. + + This protocol only supports blocking I/O. + """ + + __slots__ = () + + @abc.abstractmethod + def write(self, data: T_contra, /) -> int: + """Write *data* to the output stream and return the number of items written.""" # noqa: E501 + + +_NEEDS_SINGLETONMETA = ( + not hasattr(typing, "NoDefault") or not hasattr(typing, "NoExtraItems") +) + +if _NEEDS_SINGLETONMETA: + class SingletonMeta(type): + def __setattr__(cls, attr, value): + # TypeError is consistent with the behavior of NoneType + raise TypeError( + f"cannot set {attr!r} attribute of immutable type {cls.__name__!r}" + ) + + +if hasattr(typing, "NoDefault"): + NoDefault = typing.NoDefault +else: + class NoDefaultType(metaclass=SingletonMeta): + """The type of the NoDefault singleton.""" + + __slots__ = () + + def __new__(cls): + return globals().get("NoDefault") or object.__new__(cls) + + def __repr__(self): + return "typing_extensions.NoDefault" + + def __reduce__(self): + return "NoDefault" + + NoDefault = NoDefaultType() + del NoDefaultType + +if hasattr(typing, "NoExtraItems"): + NoExtraItems = typing.NoExtraItems +else: + class NoExtraItemsType(metaclass=SingletonMeta): + """The type of the NoExtraItems singleton.""" + + __slots__ = () + + def __new__(cls): + return globals().get("NoExtraItems") or object.__new__(cls) + + def __repr__(self): + return "typing_extensions.NoExtraItems" + + def __reduce__(self): + return "NoExtraItems" + + NoExtraItems = NoExtraItemsType() + del NoExtraItemsType + +if _NEEDS_SINGLETONMETA: + del SingletonMeta + + +# Update this to something like >=3.13.0b1 if and when +# PEP 764 is implemented in CPython +_PEP_764_IMPLEMENTED = False + +if _PEP_764_IMPLEMENTED: + # The standard library TypedDict in Python 3.9.0/1 does not honour the "total" + # keyword with old-style TypedDict(). See https://bugs.python.org/issue42059 + # The standard library TypedDict below Python 3.11 does not store runtime + # information about optional and required keys when using Required or NotRequired. + # Generic TypedDicts are also impossible using typing.TypedDict on Python <3.11. + # Aaaand on 3.12 we add __orig_bases__ to TypedDict + # to enable better runtime introspection. + # On 3.13 we deprecate some odd ways of creating TypedDicts. + # Also on 3.13, PEP 705 adds the ReadOnly[] qualifier. + # PEP 728 (Python 3.15+) adds the `extra_items` and `closed` keywords. + # PEP 764 (still pending) allows the `TypedDict` special form to be subscripted. + TypedDict = typing.TypedDict + _TypedDictMeta = typing._TypedDictMeta + is_typeddict = typing.is_typeddict +else: + # 3.10.0 and later + _TAKES_MODULE = "module" in inspect.signature(typing._type_check).parameters + + def _get_typeddict_qualifiers(annotation_type): + while True: + annotation_origin = get_origin(annotation_type) + if annotation_origin is Annotated: + annotation_args = get_args(annotation_type) + if annotation_args: + annotation_type = annotation_args[0] + else: + break + elif annotation_origin is Required: + yield Required + annotation_type, = get_args(annotation_type) + elif annotation_origin is NotRequired: + yield NotRequired + annotation_type, = get_args(annotation_type) + elif annotation_origin is ReadOnly: + yield ReadOnly + annotation_type, = get_args(annotation_type) + else: + break + + class _TypedDictMeta(type): + + def __new__(cls, name, bases, ns, *, total=True, closed=None, + extra_items=NoExtraItems): + """Create new typed dict class object. + + This method is called when TypedDict is subclassed, + or when TypedDict is instantiated. This way + TypedDict supports all three syntax forms described in its docstring. + Subclasses and instances of TypedDict return actual dictionaries. + """ + for base in bases: + if type(base) is not _TypedDictMeta and base is not typing.Generic: + raise TypeError('cannot inherit from both a TypedDict type ' + 'and a non-TypedDict base class') + if closed is not None and extra_items is not NoExtraItems: + raise TypeError(f"Cannot combine closed={closed!r} and extra_items") + + if any(issubclass(b, typing.Generic) for b in bases): + generic_base = (typing.Generic,) + else: + generic_base = () + + ns_annotations = ns.pop('__annotations__', None) + + # typing.py generally doesn't let you inherit from plain Generic, unless + # the name of the class happens to be "Protocol" + tp_dict = type.__new__(_TypedDictMeta, "Protocol", (*generic_base, dict), ns) + tp_dict.__name__ = name + if tp_dict.__qualname__ == "Protocol": + tp_dict.__qualname__ = name + + if not hasattr(tp_dict, '__orig_bases__'): + tp_dict.__orig_bases__ = bases + + annotations = {} + own_annotate = None + if ns_annotations is not None: + own_annotations = ns_annotations + elif sys.version_info >= (3, 14): + if hasattr(annotationlib, "get_annotate_from_class_namespace"): + own_annotate = annotationlib.get_annotate_from_class_namespace(ns) + else: + # 3.14.0a7 and earlier + own_annotate = ns.get("__annotate__") + if own_annotate is not None: + own_annotations = annotationlib.call_annotate_function( + own_annotate, Format.FORWARDREF, owner=tp_dict + ) + else: + own_annotations = {} + else: + own_annotations = {} + msg = "TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type" + if _TAKES_MODULE: + own_checked_annotations = { + n: typing._type_check(tp, msg, module=tp_dict.__module__) + for n, tp in own_annotations.items() + } + else: + own_checked_annotations = { + n: typing._type_check(tp, msg) + for n, tp in own_annotations.items() + } + required_keys = set() + optional_keys = set() + readonly_keys = set() + mutable_keys = set() + extra_items_type = extra_items + + for base in bases: + base_dict = base.__dict__ + + if sys.version_info <= (3, 14): + annotations.update(base_dict.get('__annotations__', {})) + base_required = base_dict.get('__required_keys__', set()) + required_keys |= base_required + optional_keys -= base_required + + base_optional = base_dict.get('__optional_keys__', set()) + required_keys -= base_optional + optional_keys |= base_optional + + readonly_keys.update(base_dict.get('__readonly_keys__', ())) + mutable_keys.update(base_dict.get('__mutable_keys__', ())) + + # This was specified in an earlier version of PEP 728. Support + # is retained for backwards compatibility, but only for Python + # 3.13 and lower. + if (closed and sys.version_info < (3, 14) + and "__extra_items__" in own_checked_annotations): + annotation_type = own_checked_annotations.pop("__extra_items__") + qualifiers = set(_get_typeddict_qualifiers(annotation_type)) + if Required in qualifiers: + raise TypeError( + "Special key __extra_items__ does not support " + "Required" + ) + if NotRequired in qualifiers: + raise TypeError( + "Special key __extra_items__ does not support " + "NotRequired" + ) + extra_items_type = annotation_type + + annotations.update(own_checked_annotations) + for annotation_key, annotation_type in own_checked_annotations.items(): + qualifiers = set(_get_typeddict_qualifiers(annotation_type)) + + if Required in qualifiers: + is_required = True + elif NotRequired in qualifiers: + is_required = False + else: + is_required = total + + if is_required: + required_keys.add(annotation_key) + optional_keys.discard(annotation_key) + else: + optional_keys.add(annotation_key) + required_keys.discard(annotation_key) + + if ReadOnly in qualifiers: + mutable_keys.discard(annotation_key) + readonly_keys.add(annotation_key) + else: + mutable_keys.add(annotation_key) + readonly_keys.discard(annotation_key) + + # Breakpoint: https://github.com/python/cpython/pull/119891 + if sys.version_info >= (3, 14): + def __annotate__(format): + annos = {} + for base in bases: + if base is Generic: + continue + base_annotate = base.__annotate__ + if base_annotate is None: + continue + base_annos = annotationlib.call_annotate_function( + base_annotate, format, owner=base) + annos.update(base_annos) + if own_annotate is not None: + own = annotationlib.call_annotate_function( + own_annotate, format, owner=tp_dict) + if format != Format.STRING: + own = { + n: typing._type_check(tp, msg, module=tp_dict.__module__) + for n, tp in own.items() + } + elif format == Format.STRING: + own = annotationlib.annotations_to_string(own_annotations) + elif format in (Format.FORWARDREF, Format.VALUE): + own = own_checked_annotations + else: + raise NotImplementedError(format) + annos.update(own) + return annos + + tp_dict.__annotate__ = __annotate__ + else: + tp_dict.__annotations__ = annotations + tp_dict.__required_keys__ = frozenset(required_keys) + tp_dict.__optional_keys__ = frozenset(optional_keys) + tp_dict.__readonly_keys__ = frozenset(readonly_keys) + tp_dict.__mutable_keys__ = frozenset(mutable_keys) + tp_dict.__total__ = total + tp_dict.__closed__ = closed + tp_dict.__extra_items__ = extra_items_type + return tp_dict + + __call__ = dict # static method + + def __subclasscheck__(cls, other): + # Typed dicts are only for static structural subtyping. + raise TypeError('TypedDict does not support instance and class checks') + + __instancecheck__ = __subclasscheck__ + + _TypedDict = type.__new__(_TypedDictMeta, 'TypedDict', (), {}) + + def _create_typeddict( + typename, + fields, + /, + *, + typing_is_inline, + total, + closed, + extra_items, + **kwargs, + ): + if fields is _marker or fields is None: + if fields is _marker: + deprecated_thing = ( + "Failing to pass a value for the 'fields' parameter" + ) + else: + deprecated_thing = "Passing `None` as the 'fields' parameter" + + example = f"`{typename} = TypedDict({typename!r}, {{}})`" + deprecation_msg = ( + f"{deprecated_thing} is deprecated and will be disallowed in " + "Python 3.15. To create a TypedDict class with 0 fields " + "using the functional syntax, pass an empty dictionary, e.g. " + ) + example + "." + warnings.warn(deprecation_msg, DeprecationWarning, stacklevel=2) + # Support a field called "closed" + if closed is not False and closed is not True and closed is not None: + kwargs["closed"] = closed + closed = None + # Or "extra_items" + if extra_items is not NoExtraItems: + kwargs["extra_items"] = extra_items + extra_items = NoExtraItems + fields = kwargs + elif kwargs: + raise TypeError("TypedDict takes either a dict or keyword arguments," + " but not both") + if kwargs: + # Breakpoint: https://github.com/python/cpython/pull/104891 + if sys.version_info >= (3, 13): + raise TypeError("TypedDict takes no keyword arguments") + warnings.warn( + "The kwargs-based syntax for TypedDict definitions is deprecated " + "in Python 3.11, will be removed in Python 3.13, and may not be " + "understood by third-party type checkers.", + DeprecationWarning, + stacklevel=2, + ) + + ns = {'__annotations__': dict(fields)} + module = _caller(depth=4 if typing_is_inline else 2) + if module is not None: + # Setting correct module is necessary to make typed dict classes + # pickleable. + ns['__module__'] = module + + td = _TypedDictMeta(typename, (), ns, total=total, closed=closed, + extra_items=extra_items) + td.__orig_bases__ = (TypedDict,) + return td + + class _TypedDictSpecialForm(_SpecialForm, _root=True): + def __call__( + self, + typename, + fields=_marker, + /, + *, + total=True, + closed=None, + extra_items=NoExtraItems, + **kwargs + ): + return _create_typeddict( + typename, + fields, + typing_is_inline=False, + total=total, + closed=closed, + extra_items=extra_items, + **kwargs, + ) + + def __mro_entries__(self, bases): + return (_TypedDict,) + + @_TypedDictSpecialForm + def TypedDict(self, args): + """A simple typed namespace. At runtime it is equivalent to a plain dict. + + TypedDict creates a dictionary type such that a type checker will expect all + instances to have a certain set of keys, where each key is + associated with a value of a consistent type. This expectation + is not checked at runtime. + + Usage:: + + class Point2D(TypedDict): + x: int + y: int + label: str + + a: Point2D = {'x': 1, 'y': 2, 'label': 'good'} # OK + b: Point2D = {'z': 3, 'label': 'bad'} # Fails type check + + assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first') + + The type info can be accessed via the Point2D.__annotations__ dict, and + the Point2D.__required_keys__ and Point2D.__optional_keys__ frozensets. + TypedDict supports an additional equivalent form:: + + Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str}) + + By default, all keys must be present in a TypedDict. It is possible + to override this by specifying totality:: + + class Point2D(TypedDict, total=False): + x: int + y: int + + This means that a Point2D TypedDict can have any of the keys omitted. A type + checker is only expected to support a literal False or True as the value of + the total argument. True is the default, and makes all items defined in the + class body be required. + + The Required and NotRequired special forms can also be used to mark + individual keys as being required or not required:: + + class Point2D(TypedDict): + x: int # the "x" key must always be present (Required is the default) + y: NotRequired[int] # the "y" key can be omitted + + See PEP 655 for more details on Required and NotRequired. + """ + # This runs when creating inline TypedDicts: + if not isinstance(args, dict): + raise TypeError( + "TypedDict[...] should be used with a single dict argument" + ) + + return _create_typeddict( + "", + args, + typing_is_inline=True, + total=True, + closed=True, + extra_items=NoExtraItems, + ) + + _TYPEDDICT_TYPES = (typing._TypedDictMeta, _TypedDictMeta) + + def is_typeddict(tp): + """Check if an annotation is a TypedDict class + + For example:: + class Film(TypedDict): + title: str + year: int + + is_typeddict(Film) # => True + is_typeddict(Union[list, str]) # => False + """ + return isinstance(tp, _TYPEDDICT_TYPES) + + +if hasattr(typing, "assert_type"): + assert_type = typing.assert_type + +else: + def assert_type(val, typ, /): + """Assert (to the type checker) that the value is of the given type. + + When the type checker encounters a call to assert_type(), it + emits an error if the value is not of the specified type:: + + def greet(name: str) -> None: + assert_type(name, str) # ok + assert_type(name, int) # type checker error + + At runtime this returns the first argument unchanged and otherwise + does nothing. + """ + return val + + +if hasattr(typing, "ReadOnly"): # 3.13+ + get_type_hints = typing.get_type_hints +else: # <=3.13 + # replaces _strip_annotations() + def _strip_extras(t): + """Strips Annotated, Required and NotRequired from a given type.""" + if isinstance(t, typing._AnnotatedAlias): + return _strip_extras(t.__origin__) + if hasattr(t, "__origin__") and t.__origin__ in (Required, NotRequired, ReadOnly): + return _strip_extras(t.__args__[0]) + if isinstance(t, typing._GenericAlias): + stripped_args = tuple(_strip_extras(a) for a in t.__args__) + if stripped_args == t.__args__: + return t + return t.copy_with(stripped_args) + if hasattr(_types, "GenericAlias") and isinstance(t, _types.GenericAlias): + stripped_args = tuple(_strip_extras(a) for a in t.__args__) + if stripped_args == t.__args__: + return t + return _types.GenericAlias(t.__origin__, stripped_args) + if hasattr(_types, "UnionType") and isinstance(t, _types.UnionType): + stripped_args = tuple(_strip_extras(a) for a in t.__args__) + if stripped_args == t.__args__: + return t + return functools.reduce(operator.or_, stripped_args) + + return t + + def get_type_hints(obj, globalns=None, localns=None, include_extras=False): + """Return type hints for an object. + + This is often the same as obj.__annotations__, but it handles + forward references encoded as string literals, adds Optional[t] if a + default value equal to None is set and recursively replaces all + 'Annotated[T, ...]', 'Required[T]' or 'NotRequired[T]' with 'T' + (unless 'include_extras=True'). + + The argument may be a module, class, method, or function. The annotations + are returned as a dictionary. For classes, annotations include also + inherited members. + + TypeError is raised if the argument is not of a type that can contain + annotations, and an empty dictionary is returned if no annotations are + present. + + BEWARE -- the behavior of globalns and localns is counterintuitive + (unless you are familiar with how eval() and exec() work). The + search order is locals first, then globals. + + - If no dict arguments are passed, an attempt is made to use the + globals from obj (or the respective module's globals for classes), + and these are also used as the locals. If the object does not appear + to have globals, an empty dictionary is used. + + - If one dict argument is passed, it is used for both globals and + locals. + + - If two dict arguments are passed, they specify globals and + locals, respectively. + """ + hint = typing.get_type_hints( + obj, globalns=globalns, localns=localns, include_extras=True + ) + # Breakpoint: https://github.com/python/cpython/pull/30304 + if sys.version_info < (3, 11): + _clean_optional(obj, hint, globalns, localns) + if include_extras: + return hint + return {k: _strip_extras(t) for k, t in hint.items()} + + _NoneType = type(None) + + def _could_be_inserted_optional(t): + """detects Union[..., None] pattern""" + if not isinstance(t, typing._UnionGenericAlias): + return False + # Assume if last argument is not None they are user defined + if t.__args__[-1] is not _NoneType: + return False + return True + + # < 3.11 + def _clean_optional(obj, hints, globalns=None, localns=None): + # reverts injected Union[..., None] cases from typing.get_type_hints + # when a None default value is used. + # see https://github.com/python/typing_extensions/issues/310 + if not hints or isinstance(obj, type): + return + defaults = typing._get_defaults(obj) # avoid accessing __annotations___ + if not defaults: + return + original_hints = obj.__annotations__ + for name, value in hints.items(): + # Not a Union[..., None] or replacement conditions not fullfilled + if (not _could_be_inserted_optional(value) + or name not in defaults + or defaults[name] is not None + ): + continue + original_value = original_hints[name] + # value=NoneType should have caused a skip above but check for safety + if original_value is None: + original_value = _NoneType + # Forward reference + if isinstance(original_value, str): + if globalns is None: + if isinstance(obj, _types.ModuleType): + globalns = obj.__dict__ + else: + nsobj = obj + # Find globalns for the unwrapped object. + while hasattr(nsobj, '__wrapped__'): + nsobj = nsobj.__wrapped__ + globalns = getattr(nsobj, '__globals__', {}) + if localns is None: + localns = globalns + elif localns is None: + localns = globalns + + original_value = ForwardRef( + original_value, + is_argument=not isinstance(obj, _types.ModuleType) + ) + original_evaluated = typing._eval_type(original_value, globalns, localns) + # Compare if values differ. Note that even if equal + # value might be cached by typing._tp_cache contrary to original_evaluated + if original_evaluated != value or ( + # 3.10: ForwardRefs of UnionType might be turned into _UnionGenericAlias + hasattr(_types, "UnionType") + and isinstance(original_evaluated, _types.UnionType) + and not isinstance(value, _types.UnionType) + ): + hints[name] = original_evaluated + +# Python 3.9 has get_origin() and get_args() but those implementations don't support +# ParamSpecArgs and ParamSpecKwargs, so only Python 3.10's versions will do. +# Breakpoint: https://github.com/python/cpython/pull/25298 +if sys.version_info >= (3, 10): + get_origin = typing.get_origin + get_args = typing.get_args +# 3.9 +else: + def get_origin(tp): + """Get the unsubscripted version of a type. + + This supports generic types, Callable, Tuple, Union, Literal, Final, ClassVar + and Annotated. Return None for unsupported types. Examples:: + + get_origin(Literal[42]) is Literal + get_origin(int) is None + get_origin(ClassVar[int]) is ClassVar + get_origin(Generic) is Generic + get_origin(Generic[T]) is Generic + get_origin(Union[T, int]) is Union + get_origin(List[Tuple[T, T]][int]) == list + get_origin(P.args) is P + """ + if isinstance(tp, typing._AnnotatedAlias): + return Annotated + if isinstance(tp, (typing._BaseGenericAlias, _types.GenericAlias, + ParamSpecArgs, ParamSpecKwargs)): + return tp.__origin__ + if tp is typing.Generic: + return typing.Generic + return None + + def get_args(tp): + """Get type arguments with all substitutions performed. + + For unions, basic simplifications used by Union constructor are performed. + Examples:: + get_args(Dict[str, int]) == (str, int) + get_args(int) == () + get_args(Union[int, Union[T, int], str][int]) == (int, str) + get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int]) + get_args(Callable[[], T][int]) == ([], int) + """ + if isinstance(tp, typing._AnnotatedAlias): + return (tp.__origin__, *tp.__metadata__) + if isinstance(tp, (typing._GenericAlias, _types.GenericAlias)): + res = tp.__args__ + if get_origin(tp) is collections.abc.Callable and res[0] is not Ellipsis: + res = (list(res[:-1]), res[-1]) + return res + return () + + +# 3.10+ +if hasattr(typing, 'TypeAlias'): + TypeAlias = typing.TypeAlias +# 3.9 +else: + @_ExtensionsSpecialForm + def TypeAlias(self, parameters): + """Special marker indicating that an assignment should + be recognized as a proper type alias definition by type + checkers. + + For example:: + + Predicate: TypeAlias = Callable[..., bool] + + It's invalid when used anywhere except as in the example above. + """ + raise TypeError(f"{self} is not subscriptable") + + +def _set_default(type_param, default): + type_param.has_default = lambda: default is not NoDefault + type_param.__default__ = default + + +def _set_module(typevarlike): + # for pickling: + def_mod = _caller(depth=2) + if def_mod != 'typing_extensions': + typevarlike.__module__ = def_mod + + +class _DefaultMixin: + """Mixin for TypeVarLike defaults.""" + + __slots__ = () + __init__ = _set_default + + +# Classes using this metaclass must provide a _backported_typevarlike ClassVar +class _TypeVarLikeMeta(type): + def __instancecheck__(cls, __instance: Any) -> bool: + return isinstance(__instance, cls._backported_typevarlike) + + +if _PEP_696_IMPLEMENTED: + from typing import TypeVar +else: + # Add default and infer_variance parameters from PEP 696 and 695 + class TypeVar(metaclass=_TypeVarLikeMeta): + """Type variable.""" + + _backported_typevarlike = typing.TypeVar + + def __new__(cls, name, *constraints, bound=None, + covariant=False, contravariant=False, + default=NoDefault, infer_variance=False): + if hasattr(typing, "TypeAliasType"): + # PEP 695 implemented (3.12+), can pass infer_variance to typing.TypeVar + typevar = typing.TypeVar(name, *constraints, bound=bound, + covariant=covariant, contravariant=contravariant, + infer_variance=infer_variance) + else: + typevar = typing.TypeVar(name, *constraints, bound=bound, + covariant=covariant, contravariant=contravariant) + if infer_variance and (covariant or contravariant): + raise ValueError("Variance cannot be specified with infer_variance.") + typevar.__infer_variance__ = infer_variance + + _set_default(typevar, default) + _set_module(typevar) + + def _tvar_prepare_subst(alias, args): + if ( + typevar.has_default() + and alias.__parameters__.index(typevar) == len(args) + ): + args += (typevar.__default__,) + return args + + typevar.__typing_prepare_subst__ = _tvar_prepare_subst + return typevar + + def __init_subclass__(cls) -> None: + raise TypeError(f"type '{__name__}.TypeVar' is not an acceptable base type") + + +# Python 3.10+ has PEP 612 +if hasattr(typing, 'ParamSpecArgs'): + ParamSpecArgs = typing.ParamSpecArgs + ParamSpecKwargs = typing.ParamSpecKwargs +# 3.9 +else: + class _Immutable: + """Mixin to indicate that object should not be copied.""" + __slots__ = () + + def __copy__(self): + return self + + def __deepcopy__(self, memo): + return self + + class ParamSpecArgs(_Immutable): + """The args for a ParamSpec object. + + Given a ParamSpec object P, P.args is an instance of ParamSpecArgs. + + ParamSpecArgs objects have a reference back to their ParamSpec: + + P.args.__origin__ is P + + This type is meant for runtime introspection and has no special meaning to + static type checkers. + """ + def __init__(self, origin): + self.__origin__ = origin + + def __repr__(self): + return f"{self.__origin__.__name__}.args" + + def __eq__(self, other): + if not isinstance(other, ParamSpecArgs): + return NotImplemented + return self.__origin__ == other.__origin__ + + class ParamSpecKwargs(_Immutable): + """The kwargs for a ParamSpec object. + + Given a ParamSpec object P, P.kwargs is an instance of ParamSpecKwargs. + + ParamSpecKwargs objects have a reference back to their ParamSpec: + + P.kwargs.__origin__ is P + + This type is meant for runtime introspection and has no special meaning to + static type checkers. + """ + def __init__(self, origin): + self.__origin__ = origin + + def __repr__(self): + return f"{self.__origin__.__name__}.kwargs" + + def __eq__(self, other): + if not isinstance(other, ParamSpecKwargs): + return NotImplemented + return self.__origin__ == other.__origin__ + + +if _PEP_696_IMPLEMENTED: + from typing import ParamSpec + +# 3.10+ +elif hasattr(typing, 'ParamSpec'): + + # Add default parameter - PEP 696 + class ParamSpec(metaclass=_TypeVarLikeMeta): + """Parameter specification.""" + + _backported_typevarlike = typing.ParamSpec + + def __new__(cls, name, *, bound=None, + covariant=False, contravariant=False, + infer_variance=False, default=NoDefault): + if hasattr(typing, "TypeAliasType"): + # PEP 695 implemented, can pass infer_variance to typing.TypeVar + paramspec = typing.ParamSpec(name, bound=bound, + covariant=covariant, + contravariant=contravariant, + infer_variance=infer_variance) + else: + paramspec = typing.ParamSpec(name, bound=bound, + covariant=covariant, + contravariant=contravariant) + paramspec.__infer_variance__ = bool(infer_variance) + + _set_default(paramspec, default) + _set_module(paramspec) + + def _paramspec_prepare_subst(alias, args): + params = alias.__parameters__ + i = params.index(paramspec) + if i == len(args) and paramspec.has_default(): + args = [*args, paramspec.__default__] + if i >= len(args): + raise TypeError(f"Too few arguments for {alias}") + # Special case where Z[[int, str, bool]] == Z[int, str, bool] in PEP 612. + if len(params) == 1 and not typing._is_param_expr(args[0]): + assert i == 0 + args = (args,) + # Convert lists to tuples to help other libraries cache the results. + elif isinstance(args[i], list): + args = (*args[:i], tuple(args[i]), *args[i + 1:]) + return args + + paramspec.__typing_prepare_subst__ = _paramspec_prepare_subst + return paramspec + + def __init_subclass__(cls) -> None: + raise TypeError(f"type '{__name__}.ParamSpec' is not an acceptable base type") + +# 3.9 +else: + + # Inherits from list as a workaround for Callable checks in Python < 3.9.2. + class ParamSpec(list, _DefaultMixin): + """Parameter specification variable. + + Usage:: + + P = ParamSpec('P') + + Parameter specification variables exist primarily for the benefit of static + type checkers. They are used to forward the parameter types of one + callable to another callable, a pattern commonly found in higher order + functions and decorators. They are only valid when used in ``Concatenate``, + or s the first argument to ``Callable``. In Python 3.10 and higher, + they are also supported in user-defined Generics at runtime. + See class Generic for more information on generic types. An + example for annotating a decorator:: + + T = TypeVar('T') + P = ParamSpec('P') + + def add_logging(f: Callable[P, T]) -> Callable[P, T]: + '''A type-safe decorator to add logging to a function.''' + def inner(*args: P.args, **kwargs: P.kwargs) -> T: + logging.info(f'{f.__name__} was called') + return f(*args, **kwargs) + return inner + + @add_logging + def add_two(x: float, y: float) -> float: + '''Add two numbers together.''' + return x + y + + Parameter specification variables defined with covariant=True or + contravariant=True can be used to declare covariant or contravariant + generic types. These keyword arguments are valid, but their actual semantics + are yet to be decided. See PEP 612 for details. + + Parameter specification variables can be introspected. e.g.: + + P.__name__ == 'T' + P.__bound__ == None + P.__covariant__ == False + P.__contravariant__ == False + + Note that only parameter specification variables defined in global scope can + be pickled. + """ + + # Trick Generic __parameters__. + __class__ = typing.TypeVar + + @property + def args(self): + return ParamSpecArgs(self) + + @property + def kwargs(self): + return ParamSpecKwargs(self) + + def __init__(self, name, *, bound=None, covariant=False, contravariant=False, + infer_variance=False, default=NoDefault): + list.__init__(self, [self]) + self.__name__ = name + self.__covariant__ = bool(covariant) + self.__contravariant__ = bool(contravariant) + self.__infer_variance__ = bool(infer_variance) + self.__bound__ = bound + _DefaultMixin.__init__(self, default) + + # for pickling: + def_mod = _caller() + if def_mod != 'typing_extensions': + self.__module__ = def_mod + + def __repr__(self): + if self.__infer_variance__: + prefix = '' + elif self.__covariant__: + prefix = '+' + elif self.__contravariant__: + prefix = '-' + else: + prefix = '~' + return prefix + self.__name__ + + def __hash__(self): + return object.__hash__(self) + + def __eq__(self, other): + return self is other + + def __reduce__(self): + return self.__name__ + + # Hack to get typing._type_check to pass. + def __call__(self, *args, **kwargs): + pass + + def __init_subclass__(cls) -> None: + raise TypeError(f"type '{__name__}.ParamSpec' is not an acceptable base type") + + +# 3.9 +if not hasattr(typing, 'Concatenate'): + # Inherits from list as a workaround for Callable checks in Python < 3.9.2. + + # 3.9.0-1 + if not hasattr(typing, '_type_convert'): + def _type_convert(arg, module=None, *, allow_special_forms=False): + """For converting None to type(None), and strings to ForwardRef.""" + if arg is None: + return type(None) + if isinstance(arg, str): + if sys.version_info <= (3, 9, 6): + return ForwardRef(arg) + if sys.version_info <= (3, 9, 7): + return ForwardRef(arg, module=module) + return ForwardRef(arg, module=module, is_class=allow_special_forms) + return arg + else: + _type_convert = typing._type_convert + + class _ConcatenateGenericAlias(list): + + # Trick Generic into looking into this for __parameters__. + __class__ = typing._GenericAlias + + def __init__(self, origin, args): + # Cannot use `super().__init__` here because of the `__class__` assignment + # in the class body (https://github.com/python/typing_extensions/issues/661) + list.__init__(self, args) + self.__origin__ = origin + self.__args__ = args + + def __repr__(self): + _type_repr = typing._type_repr + return (f'{_type_repr(self.__origin__)}' + f'[{", ".join(_type_repr(arg) for arg in self.__args__)}]') + + def __hash__(self): + return hash((self.__origin__, self.__args__)) + + # Hack to get typing._type_check to pass in Generic. + def __call__(self, *args, **kwargs): + pass + + @property + def __parameters__(self): + return tuple( + tp for tp in self.__args__ if isinstance(tp, (typing.TypeVar, ParamSpec)) + ) + + # 3.9 used by __getitem__ below + def copy_with(self, params): + if isinstance(params[-1], _ConcatenateGenericAlias): + params = (*params[:-1], *params[-1].__args__) + elif isinstance(params[-1], (list, tuple)): + return (*params[:-1], *params[-1]) + elif (not (params[-1] is ... or isinstance(params[-1], ParamSpec))): + raise TypeError("The last parameter to Concatenate should be a " + "ParamSpec variable or ellipsis.") + return self.__class__(self.__origin__, params) + + # 3.9; accessed during GenericAlias.__getitem__ when substituting + def __getitem__(self, args): + if self.__origin__ in (Generic, Protocol): + # Can't subscript Generic[...] or Protocol[...]. + raise TypeError(f"Cannot subscript already-subscripted {self}") + if not self.__parameters__: + raise TypeError(f"{self} is not a generic class") + + if not isinstance(args, tuple): + args = (args,) + args = _unpack_args(*(_type_convert(p) for p in args)) + params = self.__parameters__ + for param in params: + prepare = getattr(param, "__typing_prepare_subst__", None) + if prepare is not None: + args = prepare(self, args) + # 3.9 & typing.ParamSpec + elif isinstance(param, ParamSpec): + i = params.index(param) + if ( + i == len(args) + and getattr(param, '__default__', NoDefault) is not NoDefault + ): + args = [*args, param.__default__] + if i >= len(args): + raise TypeError(f"Too few arguments for {self}") + # Special case for Z[[int, str, bool]] == Z[int, str, bool] + if len(params) == 1 and not _is_param_expr(args[0]): + assert i == 0 + args = (args,) + elif ( + isinstance(args[i], list) + # 3.9 + # This class inherits from list do not convert + and not isinstance(args[i], _ConcatenateGenericAlias) + ): + args = (*args[:i], tuple(args[i]), *args[i + 1:]) + + alen = len(args) + plen = len(params) + if alen != plen: + raise TypeError( + f"Too {'many' if alen > plen else 'few'} arguments for {self};" + f" actual {alen}, expected {plen}" + ) + + subst = dict(zip(self.__parameters__, args)) + # determine new args + new_args = [] + for arg in self.__args__: + if isinstance(arg, type): + new_args.append(arg) + continue + if isinstance(arg, TypeVar): + arg = subst[arg] + if ( + (isinstance(arg, typing._GenericAlias) and _is_unpack(arg)) + or ( + hasattr(_types, "GenericAlias") + and isinstance(arg, _types.GenericAlias) + and getattr(arg, "__unpacked__", False) + ) + ): + raise TypeError(f"{arg} is not valid as type argument") + + elif isinstance(arg, + typing._GenericAlias + if not hasattr(_types, "GenericAlias") else + (typing._GenericAlias, _types.GenericAlias) + ): + subparams = arg.__parameters__ + if subparams: + subargs = tuple(subst[x] for x in subparams) + arg = arg[subargs] + new_args.append(arg) + return self.copy_with(tuple(new_args)) + +# 3.10+ +else: + _ConcatenateGenericAlias = typing._ConcatenateGenericAlias + + # 3.10 + if sys.version_info < (3, 11): + + class _ConcatenateGenericAlias(typing._ConcatenateGenericAlias, _root=True): + # needed for checks in collections.abc.Callable to accept this class + __module__ = "typing" + + def copy_with(self, params): + if isinstance(params[-1], (list, tuple)): + return (*params[:-1], *params[-1]) + if isinstance(params[-1], typing._ConcatenateGenericAlias): + params = (*params[:-1], *params[-1].__args__) + elif not (params[-1] is ... or isinstance(params[-1], ParamSpec)): + raise TypeError("The last parameter to Concatenate should be a " + "ParamSpec variable or ellipsis.") + return super(typing._ConcatenateGenericAlias, self).copy_with(params) + + def __getitem__(self, args): + value = super().__getitem__(args) + if isinstance(value, tuple) and any(_is_unpack(t) for t in value): + return tuple(_unpack_args(*(n for n in value))) + return value + + +# 3.9.2 +class _EllipsisDummy: ... + + +# <=3.10 +def _create_concatenate_alias(origin, parameters): + if parameters[-1] is ... and sys.version_info < (3, 9, 2): + # Hack: Arguments must be types, replace it with one. + parameters = (*parameters[:-1], _EllipsisDummy) + if sys.version_info >= (3, 10, 3): + concatenate = _ConcatenateGenericAlias(origin, parameters, + _typevar_types=(TypeVar, ParamSpec), + _paramspec_tvars=True) + else: + concatenate = _ConcatenateGenericAlias(origin, parameters) + if parameters[-1] is not _EllipsisDummy: + return concatenate + # Remove dummy again + concatenate.__args__ = tuple(p if p is not _EllipsisDummy else ... + for p in concatenate.__args__) + if sys.version_info < (3, 10): + # backport needs __args__ adjustment only + return concatenate + concatenate.__parameters__ = tuple(p for p in concatenate.__parameters__ + if p is not _EllipsisDummy) + return concatenate + + +# <=3.10 +@typing._tp_cache +def _concatenate_getitem(self, parameters): + if parameters == (): + raise TypeError("Cannot take a Concatenate of no types.") + if not isinstance(parameters, tuple): + parameters = (parameters,) + if not (parameters[-1] is ... or isinstance(parameters[-1], ParamSpec)): + raise TypeError("The last parameter to Concatenate should be a " + "ParamSpec variable or ellipsis.") + msg = "Concatenate[arg, ...]: each arg must be a type." + parameters = (*(typing._type_check(p, msg) for p in parameters[:-1]), + parameters[-1]) + return _create_concatenate_alias(self, parameters) + + +# 3.11+; Concatenate does not accept ellipsis in 3.10 +# Breakpoint: https://github.com/python/cpython/pull/30969 +if sys.version_info >= (3, 11): + Concatenate = typing.Concatenate +# <=3.10 +else: + @_ExtensionsSpecialForm + def Concatenate(self, parameters): + """Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a + higher order function which adds, removes or transforms parameters of a + callable. + + For example:: + + Callable[Concatenate[int, P], int] + + See PEP 612 for detailed information. + """ + return _concatenate_getitem(self, parameters) + + +# 3.10+ +if hasattr(typing, 'TypeGuard'): + TypeGuard = typing.TypeGuard +# 3.9 +else: + @_ExtensionsSpecialForm + def TypeGuard(self, parameters): + """Special typing form used to annotate the return type of a user-defined + type guard function. ``TypeGuard`` only accepts a single type argument. + At runtime, functions marked this way should return a boolean. + + ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static + type checkers to determine a more precise type of an expression within a + program's code flow. Usually type narrowing is done by analyzing + conditional code flow and applying the narrowing to a block of code. The + conditional expression here is sometimes referred to as a "type guard". + + Sometimes it would be convenient to use a user-defined boolean function + as a type guard. Such a function should use ``TypeGuard[...]`` as its + return type to alert static type checkers to this intention. + + Using ``-> TypeGuard`` tells the static type checker that for a given + function: + + 1. The return value is a boolean. + 2. If the return value is ``True``, the type of its argument + is the type inside ``TypeGuard``. + + For example:: + + def is_str(val: Union[str, float]): + # "isinstance" type guard + if isinstance(val, str): + # Type of ``val`` is narrowed to ``str`` + ... + else: + # Else, type of ``val`` is narrowed to ``float``. + ... + + Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower + form of ``TypeA`` (it can even be a wider form) and this may lead to + type-unsafe results. The main reason is to allow for things like + narrowing ``List[object]`` to ``List[str]`` even though the latter is not + a subtype of the former, since ``List`` is invariant. The responsibility of + writing type-safe type guards is left to the user. + + ``TypeGuard`` also works with type variables. For more information, see + PEP 647 (User-Defined Type Guards). + """ + item = typing._type_check(parameters, f'{self} accepts only a single type.') + return typing._GenericAlias(self, (item,)) + + +# 3.13+ +if hasattr(typing, 'TypeIs'): + TypeIs = typing.TypeIs +# <=3.12 +else: + @_ExtensionsSpecialForm + def TypeIs(self, parameters): + """Special typing form used to annotate the return type of a user-defined + type narrower function. ``TypeIs`` only accepts a single type argument. + At runtime, functions marked this way should return a boolean. + + ``TypeIs`` aims to benefit *type narrowing* -- a technique used by static + type checkers to determine a more precise type of an expression within a + program's code flow. Usually type narrowing is done by analyzing + conditional code flow and applying the narrowing to a block of code. The + conditional expression here is sometimes referred to as a "type guard". + + Sometimes it would be convenient to use a user-defined boolean function + as a type guard. Such a function should use ``TypeIs[...]`` as its + return type to alert static type checkers to this intention. + + Using ``-> TypeIs`` tells the static type checker that for a given + function: + + 1. The return value is a boolean. + 2. If the return value is ``True``, the type of its argument + is the intersection of the type inside ``TypeIs`` and the argument's + previously known type. + + For example:: + + def is_awaitable(val: object) -> TypeIs[Awaitable[Any]]: + return hasattr(val, '__await__') + + def f(val: Union[int, Awaitable[int]]) -> int: + if is_awaitable(val): + assert_type(val, Awaitable[int]) + else: + assert_type(val, int) + + ``TypeIs`` also works with type variables. For more information, see + PEP 742 (Narrowing types with TypeIs). + """ + item = typing._type_check(parameters, f'{self} accepts only a single type.') + return typing._GenericAlias(self, (item,)) + + +# 3.15+? +if hasattr(typing, 'TypeForm'): + TypeForm = typing.TypeForm +# <=3.14 +else: + class _TypeFormForm(_ExtensionsSpecialForm, _root=True): + # TypeForm(X) is equivalent to X but indicates to the type checker + # that the object is a TypeForm. + def __call__(self, obj, /): + return obj + + @_TypeFormForm + def TypeForm(self, parameters): + """A special form representing the value that results from the evaluation + of a type expression. This value encodes the information supplied in the + type expression, and it represents the type described by that type expression. + + When used in a type expression, TypeForm describes a set of type form objects. + It accepts a single type argument, which must be a valid type expression. + ``TypeForm[T]`` describes the set of all type form objects that represent + the type T or types that are assignable to T. + + Usage: + + def cast[T](typ: TypeForm[T], value: Any) -> T: ... + + reveal_type(cast(int, "x")) # int + + See PEP 747 for more information. + """ + item = typing._type_check(parameters, f'{self} accepts only a single type.') + return typing._GenericAlias(self, (item,)) + + + + +if hasattr(typing, "LiteralString"): # 3.11+ + LiteralString = typing.LiteralString +else: + @_SpecialForm + def LiteralString(self, params): + """Represents an arbitrary literal string. + + Example:: + + from typing_extensions import LiteralString + + def query(sql: LiteralString) -> ...: + ... + + query("SELECT * FROM table") # ok + query(f"SELECT * FROM {input()}") # not ok + + See PEP 675 for details. + + """ + raise TypeError(f"{self} is not subscriptable") + + +if hasattr(typing, "Self"): # 3.11+ + Self = typing.Self +else: + @_SpecialForm + def Self(self, params): + """Used to spell the type of "self" in classes. + + Example:: + + from typing import Self + + class ReturnsSelf: + def parse(self, data: bytes) -> Self: + ... + return self + + """ + + raise TypeError(f"{self} is not subscriptable") + + +if hasattr(typing, "Never"): # 3.11+ + Never = typing.Never +else: + @_SpecialForm + def Never(self, params): + """The bottom type, a type that has no members. + + This can be used to define a function that should never be + called, or a function that never returns:: + + from typing_extensions import Never + + def never_call_me(arg: Never) -> None: + pass + + def int_or_str(arg: int | str) -> None: + never_call_me(arg) # type checker error + match arg: + case int(): + print("It's an int") + case str(): + print("It's a str") + case _: + never_call_me(arg) # ok, arg is of type Never + + """ + + raise TypeError(f"{self} is not subscriptable") + + +if hasattr(typing, 'Required'): # 3.11+ + Required = typing.Required + NotRequired = typing.NotRequired +else: # <=3.10 + @_ExtensionsSpecialForm + def Required(self, parameters): + """A special typing construct to mark a key of a total=False TypedDict + as required. For example: + + class Movie(TypedDict, total=False): + title: Required[str] + year: int + + m = Movie( + title='The Matrix', # typechecker error if key is omitted + year=1999, + ) + + There is no runtime checking that a required key is actually provided + when instantiating a related TypedDict. + """ + item = typing._type_check(parameters, f'{self._name} accepts only a single type.') + return typing._GenericAlias(self, (item,)) + + @_ExtensionsSpecialForm + def NotRequired(self, parameters): + """A special typing construct to mark a key of a TypedDict as + potentially missing. For example: + + class Movie(TypedDict): + title: str + year: NotRequired[int] + + m = Movie( + title='The Matrix', # typechecker error if key is omitted + year=1999, + ) + """ + item = typing._type_check(parameters, f'{self._name} accepts only a single type.') + return typing._GenericAlias(self, (item,)) + + +if hasattr(typing, 'ReadOnly'): + ReadOnly = typing.ReadOnly +else: # <=3.12 + @_ExtensionsSpecialForm + def ReadOnly(self, parameters): + """A special typing construct to mark an item of a TypedDict as read-only. + + For example: + + class Movie(TypedDict): + title: ReadOnly[str] + year: int + + def mutate_movie(m: Movie) -> None: + m["year"] = 1992 # allowed + m["title"] = "The Matrix" # typechecker error + + There is no runtime checking for this property. + """ + item = typing._type_check(parameters, f'{self._name} accepts only a single type.') + return typing._GenericAlias(self, (item,)) + + +_UNPACK_DOC = """\ +Type unpack operator. + +The type unpack operator takes the child types from some container type, +such as `tuple[int, str]` or a `TypeVarTuple`, and 'pulls them out'. For +example: + + # For some generic class `Foo`: + Foo[Unpack[tuple[int, str]]] # Equivalent to Foo[int, str] + + Ts = TypeVarTuple('Ts') + # Specifies that `Bar` is generic in an arbitrary number of types. + # (Think of `Ts` as a tuple of an arbitrary number of individual + # `TypeVar`s, which the `Unpack` is 'pulling out' directly into the + # `Generic[]`.) + class Bar(Generic[Unpack[Ts]]): ... + Bar[int] # Valid + Bar[int, str] # Also valid + +From Python 3.11, this can also be done using the `*` operator: + + Foo[*tuple[int, str]] + class Bar(Generic[*Ts]): ... + +The operator can also be used along with a `TypedDict` to annotate +`**kwargs` in a function signature. For instance: + + class Movie(TypedDict): + name: str + year: int + + # This function expects two keyword arguments - *name* of type `str` and + # *year* of type `int`. + def foo(**kwargs: Unpack[Movie]): ... + +Note that there is only some runtime checking of this operator. Not +everything the runtime allows may be accepted by static type checkers. + +For more information, see PEP 646 and PEP 692. +""" + + +# PEP 692 changed the repr of Unpack[] +# Breakpoint: https://github.com/python/cpython/pull/104048 +if sys.version_info >= (3, 12): + Unpack = typing.Unpack + + def _is_unpack(obj): + return get_origin(obj) is Unpack + +else: # <=3.11 + class _UnpackSpecialForm(_ExtensionsSpecialForm, _root=True): + def __init__(self, getitem): + super().__init__(getitem) + self.__doc__ = _UNPACK_DOC + + class _UnpackAlias(typing._GenericAlias, _root=True): + if sys.version_info < (3, 11): + # needed for compatibility with Generic[Unpack[Ts]] + __class__ = typing.TypeVar + + @property + def __typing_unpacked_tuple_args__(self): + assert self.__origin__ is Unpack + assert len(self.__args__) == 1 + arg, = self.__args__ + if isinstance(arg, (typing._GenericAlias, _types.GenericAlias)): + if arg.__origin__ is not tuple: + raise TypeError("Unpack[...] must be used with a tuple type") + return arg.__args__ + return None + + @property + def __typing_is_unpacked_typevartuple__(self): + assert self.__origin__ is Unpack + assert len(self.__args__) == 1 + return isinstance(self.__args__[0], TypeVarTuple) + + def __getitem__(self, args): + if self.__typing_is_unpacked_typevartuple__: + return args + # Cannot use `super().__getitem__` here because of the `__class__` assignment + # in the class body on Python <=3.11 + # (https://github.com/python/typing_extensions/issues/661) + return typing._GenericAlias.__getitem__(self, args) + + @_UnpackSpecialForm + def Unpack(self, parameters): + item = typing._type_check(parameters, f'{self._name} accepts only a single type.') + return _UnpackAlias(self, (item,)) + + def _is_unpack(obj): + return isinstance(obj, _UnpackAlias) + + +def _unpack_args(*args): + newargs = [] + for arg in args: + subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) + if subargs is not None and (not (subargs and subargs[-1] is ...)): + newargs.extend(subargs) + else: + newargs.append(arg) + return newargs + + +if sys.version_info >= (3, 15): + from typing import TypeVarTuple + +elif hasattr(typing, "TypeVarTuple"): # 3.11+ + + # Add default parameter - PEP 696 and bound/variance parameters + class TypeVarTuple(metaclass=_TypeVarLikeMeta): + """Type variable tuple.""" + + _backported_typevarlike = typing.TypeVarTuple + + def __new__(cls, name, *, bound=None, + covariant=False, contravariant=False, + infer_variance=False, default=NoDefault): + + if _PEP_696_IMPLEMENTED: + # can pass default argument + tvt = typing.TypeVarTuple(name, default=default) + else: + tvt = typing.TypeVarTuple(name) + _set_default(tvt, default) + + tvt.__bound__ = bound + tvt.__covariant__ = bool(covariant) + tvt.__contravariant__ = bool(contravariant) + tvt.__infer_variance__ = bool(infer_variance) + + _set_module(tvt) + + def _typevartuple_prepare_subst(alias, args): + params = alias.__parameters__ + typevartuple_index = params.index(tvt) + for param in params[typevartuple_index + 1:]: + if isinstance(param, TypeVarTuple): + raise TypeError( + f"More than one TypeVarTuple parameter in {alias}" + ) + + alen = len(args) + plen = len(params) + left = typevartuple_index + right = plen - typevartuple_index - 1 + var_tuple_index = None + fillarg = None + for k, arg in enumerate(args): + if not isinstance(arg, type): + subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) + if subargs and len(subargs) == 2 and subargs[-1] is ...: + if var_tuple_index is not None: + raise TypeError( + "More than one unpacked " + "arbitrary-length tuple argument" + ) + var_tuple_index = k + fillarg = subargs[0] + if var_tuple_index is not None: + left = min(left, var_tuple_index) + right = min(right, alen - var_tuple_index - 1) + elif left + right > alen: + raise TypeError(f"Too few arguments for {alias};" + f" actual {alen}, expected at least {plen - 1}") + if left == alen - right and tvt.has_default(): + replacement = _unpack_args(tvt.__default__) + else: + replacement = args[left: alen - right] + + return ( + *args[:left], + *([fillarg] * (typevartuple_index - left)), + replacement, + *([fillarg] * (plen - right - left - typevartuple_index - 1)), + *args[alen - right:], + ) + + tvt.__typing_prepare_subst__ = _typevartuple_prepare_subst + return tvt + + def __init_subclass__(self, *args, **kwds): + raise TypeError("Cannot subclass special typing classes") + +else: # <=3.10 + class TypeVarTuple(_DefaultMixin): + """Type variable tuple. + + Usage:: + + Ts = TypeVarTuple('Ts') + + In the same way that a normal type variable is a stand-in for a single + type such as ``int``, a type variable *tuple* is a stand-in for a *tuple* + type such as ``Tuple[int, str]``. + + Type variable tuples can be used in ``Generic`` declarations. + Consider the following example:: + + class Array(Generic[*Ts]): ... + + The ``Ts`` type variable tuple here behaves like ``tuple[T1, T2]``, + where ``T1`` and ``T2`` are type variables. To use these type variables + as type parameters of ``Array``, we must *unpack* the type variable tuple using + the star operator: ``*Ts``. The signature of ``Array`` then behaves + as if we had simply written ``class Array(Generic[T1, T2]): ...``. + In contrast to ``Generic[T1, T2]``, however, ``Generic[*Shape]`` allows + us to parameterise the class with an *arbitrary* number of type parameters. + + Type variable tuples can be used anywhere a normal ``TypeVar`` can. + This includes class definitions, as shown above, as well as function + signatures and variable annotations:: + + class Array(Generic[*Ts]): + + def __init__(self, shape: Tuple[*Ts]): + self._shape: Tuple[*Ts] = shape + + def get_shape(self) -> Tuple[*Ts]: + return self._shape + + shape = (Height(480), Width(640)) + x: Array[Height, Width] = Array(shape) + y = abs(x) # Inferred type is Array[Height, Width] + z = x + x # ... is Array[Height, Width] + x.get_shape() # ... is tuple[Height, Width] + + """ + + # Trick Generic __parameters__. + __class__ = typing.TypeVar + + def __iter__(self): + yield self.__unpacked__ + + def __init__(self, name, *, bound=None, covariant=False, contravariant=False, + infer_variance=False, default=NoDefault): + self.__name__ = name + self.__covariant__ = bool(covariant) + self.__contravariant__ = bool(contravariant) + self.__infer_variance__ = bool(infer_variance) + self.__bound__ = bound + _DefaultMixin.__init__(self, default) + + # for pickling: + def_mod = _caller() + if def_mod != 'typing_extensions': + self.__module__ = def_mod + + self.__unpacked__ = Unpack[self] + + def __repr__(self): + if self.__infer_variance__: + prefix = '' + elif self.__covariant__: + prefix = '+' + elif self.__contravariant__: + prefix = '-' + else: + prefix = '~' + return prefix + self.__name__ + + def __hash__(self): + return object.__hash__(self) + + def __eq__(self, other): + return self is other + + def __reduce__(self): + return self.__name__ + + def __init_subclass__(self, *args, **kwds): + if '_root' not in kwds: + raise TypeError("Cannot subclass special typing classes") + + +if hasattr(typing, "reveal_type"): # 3.11+ + reveal_type = typing.reveal_type +else: # <=3.10 + def reveal_type(obj: T, /) -> T: + """Reveal the inferred type of a variable. + + When a static type checker encounters a call to ``reveal_type()``, + it will emit the inferred type of the argument:: + + x: int = 1 + reveal_type(x) + + Running a static type checker (e.g., ``mypy``) on this example + will produce output similar to 'Revealed type is "builtins.int"'. + + At runtime, the function prints the runtime type of the + argument and returns it unchanged. + + """ + print(f"Runtime type is {type(obj).__name__!r}", file=sys.stderr) + return obj + + +if hasattr(typing, "_ASSERT_NEVER_REPR_MAX_LENGTH"): # 3.11+ + _ASSERT_NEVER_REPR_MAX_LENGTH = typing._ASSERT_NEVER_REPR_MAX_LENGTH +else: # <=3.10 + _ASSERT_NEVER_REPR_MAX_LENGTH = 100 + + +if hasattr(typing, "assert_never"): # 3.11+ + assert_never = typing.assert_never +else: # <=3.10 + def assert_never(arg: Never, /) -> Never: + """Assert to the type checker that a line of code is unreachable. + + Example:: + + def int_or_str(arg: int | str) -> None: + match arg: + case int(): + print("It's an int") + case str(): + print("It's a str") + case _: + assert_never(arg) + + If a type checker finds that a call to assert_never() is + reachable, it will emit an error. + + At runtime, this throws an exception when called. + + """ + value = repr(arg) + if len(value) > _ASSERT_NEVER_REPR_MAX_LENGTH: + value = value[:_ASSERT_NEVER_REPR_MAX_LENGTH] + '...' + raise AssertionError(f"Expected code to be unreachable, but got: {value}") + + +# dataclass_transform exists in 3.11 but lacks the frozen_default parameter +# Breakpoint: https://github.com/python/cpython/pull/99958 +if sys.version_info >= (3, 12): # 3.12+ + dataclass_transform = typing.dataclass_transform +else: # <=3.11 + def dataclass_transform( + *, + eq_default: bool = True, + order_default: bool = False, + kw_only_default: bool = False, + frozen_default: bool = False, + field_specifiers: typing.Tuple[ + typing.Union[typing.Type[typing.Any], typing.Callable[..., typing.Any]], + ... + ] = (), + **kwargs: typing.Any, + ) -> typing.Callable[[T], T]: + """Decorator that marks a function, class, or metaclass as providing + dataclass-like behavior. + + Example: + + from typing_extensions import dataclass_transform + + _T = TypeVar("_T") + + # Used on a decorator function + @dataclass_transform() + def create_model(cls: type[_T]) -> type[_T]: + ... + return cls + + @create_model + class CustomerModel: + id: int + name: str + + # Used on a base class + @dataclass_transform() + class ModelBase: ... + + class CustomerModel(ModelBase): + id: int + name: str + + # Used on a metaclass + @dataclass_transform() + class ModelMeta(type): ... + + class ModelBase(metaclass=ModelMeta): ... + + class CustomerModel(ModelBase): + id: int + name: str + + Each of the ``CustomerModel`` classes defined in this example will now + behave similarly to a dataclass created with the ``@dataclasses.dataclass`` + decorator. For example, the type checker will synthesize an ``__init__`` + method. + + The arguments to this decorator can be used to customize this behavior: + - ``eq_default`` indicates whether the ``eq`` parameter is assumed to be + True or False if it is omitted by the caller. + - ``order_default`` indicates whether the ``order`` parameter is + assumed to be True or False if it is omitted by the caller. + - ``kw_only_default`` indicates whether the ``kw_only`` parameter is + assumed to be True or False if it is omitted by the caller. + - ``frozen_default`` indicates whether the ``frozen`` parameter is + assumed to be True or False if it is omitted by the caller. + - ``field_specifiers`` specifies a static list of supported classes + or functions that describe fields, similar to ``dataclasses.field()``. + + At runtime, this decorator records its arguments in the + ``__dataclass_transform__`` attribute on the decorated object. + + See PEP 681 for details. + + """ + def decorator(cls_or_fn): + cls_or_fn.__dataclass_transform__ = { + "eq_default": eq_default, + "order_default": order_default, + "kw_only_default": kw_only_default, + "frozen_default": frozen_default, + "field_specifiers": field_specifiers, + "kwargs": kwargs, + } + return cls_or_fn + return decorator + + +if hasattr(typing, "override"): # 3.12+ + override = typing.override +else: # <=3.11 + _F = typing.TypeVar("_F", bound=typing.Callable[..., typing.Any]) + + def override(arg: _F, /) -> _F: + """Indicate that a method is intended to override a method in a base class. + + Usage: + + class Base: + def method(self) -> None: + pass + + class Child(Base): + @override + def method(self) -> None: + super().method() + + When this decorator is applied to a method, the type checker will + validate that it overrides a method with the same name on a base class. + This helps prevent bugs that may occur when a base class is changed + without an equivalent change to a child class. + + There is no runtime checking of these properties. The decorator + sets the ``__override__`` attribute to ``True`` on the decorated object + to allow runtime introspection. + + See PEP 698 for details. + + """ + try: + arg.__override__ = True + except (AttributeError, TypeError): + # Skip the attribute silently if it is not writable. + # AttributeError happens if the object has __slots__ or a + # read-only property, TypeError if it's a builtin class. + pass + return arg + + +# Python 3.13.8+ and 3.14.1+ contain a fix for the wrapped __init_subclass__ +# Breakpoint: https://github.com/python/cpython/pull/138210 +if ((3, 13, 8) <= sys.version_info < (3, 14)) or sys.version_info >= (3, 14, 1): + deprecated = warnings.deprecated +else: + _T = typing.TypeVar("_T") + + class deprecated: + """Indicate that a class, function or overload is deprecated. + + When this decorator is applied to an object, the type checker + will generate a diagnostic on usage of the deprecated object. + + Usage: + + @deprecated("Use B instead") + class A: + pass + + @deprecated("Use g instead") + def f(): + pass + + @overload + @deprecated("int support is deprecated") + def g(x: int) -> int: ... + @overload + def g(x: str) -> int: ... + + The warning specified by *category* will be emitted at runtime + on use of deprecated objects. For functions, that happens on calls; + for classes, on instantiation and on creation of subclasses. + If the *category* is ``None``, no warning is emitted at runtime. + The *stacklevel* determines where the + warning is emitted. If it is ``1`` (the default), the warning + is emitted at the direct caller of the deprecated object; if it + is higher, it is emitted further up the stack. + Static type checker behavior is not affected by the *category* + and *stacklevel* arguments. + + The deprecation message passed to the decorator is saved in the + ``__deprecated__`` attribute on the decorated object. + If applied to an overload, the decorator + must be after the ``@overload`` decorator for the attribute to + exist on the overload as returned by ``get_overloads()``. + + See PEP 702 for details. + + """ + def __init__( + self, + message: str, + /, + *, + category: typing.Optional[typing.Type[Warning]] = DeprecationWarning, + stacklevel: int = 1, + ) -> None: + if not isinstance(message, str): + raise TypeError( + "Expected an object of type str for 'message', not " + f"{type(message).__name__!r}" + ) + self.message = message + self.category = category + self.stacklevel = stacklevel + + def __call__(self, arg: _T, /) -> _T: + # Make sure the inner functions created below don't + # retain a reference to self. + msg = self.message + category = self.category + stacklevel = self.stacklevel + if category is None: + arg.__deprecated__ = msg + return arg + elif isinstance(arg, type): + import functools + from types import MethodType + + original_new = arg.__new__ + + @functools.wraps(original_new) + def __new__(cls, /, *args, **kwargs): + if cls is arg: + warnings.warn(msg, category=category, stacklevel=stacklevel + 1) + if original_new is not object.__new__: + return original_new(cls, *args, **kwargs) + # Mirrors a similar check in object.__new__. + elif cls.__init__ is object.__init__ and (args or kwargs): + raise TypeError(f"{cls.__name__}() takes no arguments") + else: + return original_new(cls) + + arg.__new__ = staticmethod(__new__) + + if "__init_subclass__" in arg.__dict__: + # __init_subclass__ is directly present on the decorated class. + # Synthesize a wrapper that calls this method directly. + original_init_subclass = arg.__init_subclass__ + # We need slightly different behavior if __init_subclass__ + # is a bound method (likely if it was implemented in Python). + # Otherwise, it likely means it's a builtin such as + # object's implementation of __init_subclass__. + if isinstance(original_init_subclass, MethodType): + original_init_subclass = original_init_subclass.__func__ + + @functools.wraps(original_init_subclass) + def __init_subclass__(*args, **kwargs): + warnings.warn(msg, category=category, stacklevel=stacklevel + 1) + return original_init_subclass(*args, **kwargs) + else: + def __init_subclass__(cls, *args, **kwargs): + warnings.warn(msg, category=category, stacklevel=stacklevel + 1) + return super(arg, cls).__init_subclass__(*args, **kwargs) + + arg.__init_subclass__ = classmethod(__init_subclass__) + + arg.__deprecated__ = __new__.__deprecated__ = msg + __init_subclass__.__deprecated__ = msg + return arg + elif callable(arg): + import functools + import inspect + + @functools.wraps(arg) + def wrapper(*args, **kwargs): + warnings.warn(msg, category=category, stacklevel=stacklevel + 1) + return arg(*args, **kwargs) + + if inspect.iscoroutinefunction(arg): + # Breakpoint: https://github.com/python/cpython/pull/99247 + if sys.version_info >= (3, 12): + wrapper = inspect.markcoroutinefunction(wrapper) + else: + import asyncio.coroutines + + wrapper._is_coroutine = asyncio.coroutines._is_coroutine + + arg.__deprecated__ = wrapper.__deprecated__ = msg + return wrapper + else: + raise TypeError( + "@deprecated decorator with non-None category must be applied to " + f"a class or callable, not {arg!r}" + ) + +# Breakpoint: https://github.com/python/cpython/pull/23702 +if sys.version_info < (3, 10): + def _is_param_expr(arg): + return arg is ... or isinstance( + arg, (tuple, list, ParamSpec, _ConcatenateGenericAlias) + ) +else: + def _is_param_expr(arg): + return arg is ... or isinstance( + arg, + ( + tuple, + list, + ParamSpec, + _ConcatenateGenericAlias, + typing._ConcatenateGenericAlias, + ), + ) + + +# We have to do some monkey patching to deal with the dual nature of +# Unpack/TypeVarTuple: +# - We want Unpack to be a kind of TypeVar so it gets accepted in +# Generic[Unpack[Ts]] +# - We want it to *not* be treated as a TypeVar for the purposes of +# counting generic parameters, so that when we subscript a generic, +# the runtime doesn't try to substitute the Unpack with the subscripted type. +if not hasattr(typing, "TypeVarTuple"): + def _check_generic(cls, parameters, elen=_marker): + """Check correct count for parameters of a generic cls (internal helper). + + This gives a nice error message in case of count mismatch. + """ + # If substituting a single ParamSpec with multiple arguments + # we do not check the count + if (inspect.isclass(cls) and issubclass(cls, typing.Generic) + and len(cls.__parameters__) == 1 + and isinstance(cls.__parameters__[0], ParamSpec) + and parameters + and not _is_param_expr(parameters[0]) + ): + # Generic modifies parameters variable, but here we cannot do this + return + + if not elen: + raise TypeError(f"{cls} is not a generic class") + if elen is _marker: + if not hasattr(cls, "__parameters__") or not cls.__parameters__: + raise TypeError(f"{cls} is not a generic class") + elen = len(cls.__parameters__) + alen = len(parameters) + if alen != elen: + expect_val = elen + if hasattr(cls, "__parameters__"): + parameters = [p for p in cls.__parameters__ if not _is_unpack(p)] + num_tv_tuples = sum(isinstance(p, TypeVarTuple) for p in parameters) + if (num_tv_tuples > 0) and (alen >= elen - num_tv_tuples): + return + + # deal with TypeVarLike defaults + # required TypeVarLikes cannot appear after a defaulted one. + if alen < elen: + # since we validate TypeVarLike default in _collect_type_vars + # or _collect_parameters we can safely check parameters[alen] + if ( + getattr(parameters[alen], '__default__', NoDefault) + is not NoDefault + ): + return + + num_default_tv = sum(getattr(p, '__default__', NoDefault) + is not NoDefault for p in parameters) + + elen -= num_default_tv + + expect_val = f"at least {elen}" + + # Breakpoint: https://github.com/python/cpython/pull/27515 + things = "arguments" if sys.version_info >= (3, 10) else "parameters" + raise TypeError(f"Too {'many' if alen > elen else 'few'} {things}" + f" for {cls}; actual {alen}, expected {expect_val}") +else: + # Python 3.11+ + + def _check_generic(cls, parameters, elen): + """Check correct count for parameters of a generic cls (internal helper). + + This gives a nice error message in case of count mismatch. + """ + if not elen: + raise TypeError(f"{cls} is not a generic class") + alen = len(parameters) + if alen != elen: + expect_val = elen + if hasattr(cls, "__parameters__"): + parameters = [p for p in cls.__parameters__ if not _is_unpack(p)] + + # deal with TypeVarLike defaults + # required TypeVarLikes cannot appear after a defaulted one. + if alen < elen: + # since we validate TypeVarLike default in _collect_type_vars + # or _collect_parameters we can safely check parameters[alen] + if ( + getattr(parameters[alen], '__default__', NoDefault) + is not NoDefault + ): + return + + num_default_tv = sum(getattr(p, '__default__', NoDefault) + is not NoDefault for p in parameters) + + elen -= num_default_tv + + expect_val = f"at least {elen}" + + raise TypeError(f"Too {'many' if alen > elen else 'few'} arguments" + f" for {cls}; actual {alen}, expected {expect_val}") + +if not _PEP_696_IMPLEMENTED: + typing._check_generic = _check_generic + + +def _has_generic_or_protocol_as_origin() -> bool: + try: + frame = sys._getframe(2) + # - Catch AttributeError: not all Python implementations have sys._getframe() + # - Catch ValueError: maybe we're called from an unexpected module + # and the call stack isn't deep enough + except (AttributeError, ValueError): + return False # err on the side of leniency + else: + # If we somehow get invoked from outside typing.py, + # also err on the side of leniency + if frame.f_globals.get("__name__") != "typing": + return False + origin = frame.f_locals.get("origin") + # Cannot use "in" because origin may be an object with a buggy __eq__ that + # throws an error. + return origin is typing.Generic or origin is Protocol or origin is typing.Protocol + + +_TYPEVARTUPLE_TYPES = {TypeVarTuple, getattr(typing, "TypeVarTuple", None)} + + +def _is_unpacked_typevartuple(x) -> bool: + if get_origin(x) is not Unpack: + return False + args = get_args(x) + return ( + bool(args) + and len(args) == 1 + and type(args[0]) in _TYPEVARTUPLE_TYPES + ) + + +# Python 3.11+ _collect_type_vars was renamed to _collect_parameters +if hasattr(typing, '_collect_type_vars'): + def _collect_type_vars(types, typevar_types=None): + """Collect all type variable contained in types in order of + first appearance (lexicographic order). For example:: + + _collect_type_vars((T, List[S, T])) == (T, S) + """ + if typevar_types is None: + typevar_types = typing.TypeVar + tvars = [] + + # A required TypeVarLike cannot appear after a TypeVarLike with a default + # if it was a direct call to `Generic[]` or `Protocol[]` + enforce_default_ordering = _has_generic_or_protocol_as_origin() + default_encountered = False + + # Also, a TypeVarLike with a default cannot appear after a TypeVarTuple + type_var_tuple_encountered = False + + for t in types: + if _is_unpacked_typevartuple(t): + type_var_tuple_encountered = True + elif ( + isinstance(t, typevar_types) and not isinstance(t, _UnpackAlias) + and t not in tvars + ): + if enforce_default_ordering: + has_default = getattr(t, '__default__', NoDefault) is not NoDefault + if has_default: + if type_var_tuple_encountered: + raise TypeError('Type parameter with a default' + ' follows TypeVarTuple') + default_encountered = True + elif default_encountered: + raise TypeError(f'Type parameter {t!r} without a default' + ' follows type parameter with a default') + + tvars.append(t) + if _should_collect_from_parameters(t): + tvars.extend([t for t in t.__parameters__ if t not in tvars]) + elif isinstance(t, tuple): + # Collect nested type_vars + # tuple wrapped by _prepare_paramspec_params(cls, params) + for x in t: + for collected in _collect_type_vars([x]): + if collected not in tvars: + tvars.append(collected) + return tuple(tvars) + + typing._collect_type_vars = _collect_type_vars +else: + def _collect_parameters(args): + """Collect all type variables and parameter specifications in args + in order of first appearance (lexicographic order). + + For example:: + + assert _collect_parameters((T, Callable[P, T])) == (T, P) + """ + parameters = [] + + # A required TypeVarLike cannot appear after a TypeVarLike with default + # if it was a direct call to `Generic[]` or `Protocol[]` + enforce_default_ordering = _has_generic_or_protocol_as_origin() + default_encountered = False + + # Also, a TypeVarLike with a default cannot appear after a TypeVarTuple + type_var_tuple_encountered = False + + for t in args: + if isinstance(t, type): + # We don't want __parameters__ descriptor of a bare Python class. + pass + elif isinstance(t, tuple): + # `t` might be a tuple, when `ParamSpec` is substituted with + # `[T, int]`, or `[int, *Ts]`, etc. + for x in t: + for collected in _collect_parameters([x]): + if collected not in parameters: + parameters.append(collected) + elif hasattr(t, '__typing_subst__'): + if t not in parameters: + if enforce_default_ordering: + has_default = ( + getattr(t, '__default__', NoDefault) is not NoDefault + ) + + if type_var_tuple_encountered and has_default: + raise TypeError('Type parameter with a default' + ' follows TypeVarTuple') + + if has_default: + default_encountered = True + elif default_encountered: + raise TypeError(f'Type parameter {t!r} without a default' + ' follows type parameter with a default') + + parameters.append(t) + else: + if _is_unpacked_typevartuple(t): + type_var_tuple_encountered = True + for x in getattr(t, '__parameters__', ()): + if x not in parameters: + parameters.append(x) + + return tuple(parameters) + + if not _PEP_696_IMPLEMENTED: + typing._collect_parameters = _collect_parameters + +# Backport typing.NamedTuple as it exists in Python 3.13. +# In 3.11, the ability to define generic `NamedTuple`s was supported. +# This was explicitly disallowed in 3.9-3.10, and only half-worked in <=3.8. +# On 3.12, we added __orig_bases__ to call-based NamedTuples +# On 3.13, we deprecated kwargs-based NamedTuples +# Breakpoint: https://github.com/python/cpython/pull/105609 +if sys.version_info >= (3, 13): + NamedTuple = typing.NamedTuple +else: + def _make_nmtuple(name, types, module, defaults=()): + fields = [n for n, t in types] + annotations = {n: typing._type_check(t, f"field {n} annotation must be a type") + for n, t in types} + nm_tpl = collections.namedtuple(name, fields, + defaults=defaults, module=module) + nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = annotations + return nm_tpl + + _prohibited_namedtuple_fields = typing._prohibited + _special_namedtuple_fields = frozenset({'__module__', '__name__', '__annotations__'}) + + class _NamedTupleMeta(type): + def __new__(cls, typename, bases, ns): + assert _NamedTuple in bases + for base in bases: + if base is not _NamedTuple and base is not typing.Generic: + raise TypeError( + 'can only inherit from a NamedTuple type and Generic') + bases = tuple(tuple if base is _NamedTuple else base for base in bases) + if "__annotations__" in ns: + types = ns["__annotations__"] + elif "__annotate__" in ns: + # TODO: Use inspect.VALUE here, and make the annotations lazily evaluated + types = ns["__annotate__"](1) + else: + types = {} + default_names = [] + for field_name in types: + if field_name in ns: + default_names.append(field_name) + elif default_names: + raise TypeError(f"Non-default namedtuple field {field_name} " + f"cannot follow default field" + f"{'s' if len(default_names) > 1 else ''} " + f"{', '.join(default_names)}") + nm_tpl = _make_nmtuple( + typename, types.items(), + defaults=[ns[n] for n in default_names], + module=ns['__module__'] + ) + nm_tpl.__bases__ = bases + if typing.Generic in bases: + if hasattr(typing, '_generic_class_getitem'): # 3.12+ + nm_tpl.__class_getitem__ = classmethod(typing._generic_class_getitem) + else: + class_getitem = typing.Generic.__class_getitem__.__func__ + nm_tpl.__class_getitem__ = classmethod(class_getitem) + # update from user namespace without overriding special namedtuple attributes + for key, val in ns.items(): + if key in _prohibited_namedtuple_fields: + raise AttributeError("Cannot overwrite NamedTuple attribute " + key) + elif key not in _special_namedtuple_fields: + if key not in nm_tpl._fields: + setattr(nm_tpl, key, ns[key]) + try: + set_name = type(val).__set_name__ + except AttributeError: + pass + else: + try: + set_name(val, nm_tpl, key) + except BaseException as e: + msg = ( + f"Error calling __set_name__ on {type(val).__name__!r} " + f"instance {key!r} in {typename!r}" + ) + # BaseException.add_note() existed on py311, + # but the __set_name__ machinery didn't start + # using add_note() until py312. + # Making sure exceptions are raised in the same way + # as in "normal" classes seems most important here. + # Breakpoint: https://github.com/python/cpython/pull/95915 + if sys.version_info >= (3, 12): + e.add_note(msg) + raise + else: + raise RuntimeError(msg) from e + + if typing.Generic in bases: + nm_tpl.__init_subclass__() + return nm_tpl + + _NamedTuple = type.__new__(_NamedTupleMeta, 'NamedTuple', (), {}) + + def _namedtuple_mro_entries(bases): + assert NamedTuple in bases + return (_NamedTuple,) + + def NamedTuple(typename, fields=_marker, /, **kwargs): + """Typed version of namedtuple. + + Usage:: + + class Employee(NamedTuple): + name: str + id: int + + This is equivalent to:: + + Employee = collections.namedtuple('Employee', ['name', 'id']) + + The resulting class has an extra __annotations__ attribute, giving a + dict that maps field names to types. (The field names are also in + the _fields attribute, which is part of the namedtuple API.) + An alternative equivalent functional syntax is also accepted:: + + Employee = NamedTuple('Employee', [('name', str), ('id', int)]) + """ + if fields is _marker: + if kwargs: + deprecated_thing = "Creating NamedTuple classes using keyword arguments" + deprecation_msg = ( + "{name} is deprecated and will be disallowed in Python {remove}. " + "Use the class-based or functional syntax instead." + ) + else: + deprecated_thing = "Failing to pass a value for the 'fields' parameter" + example = f"`{typename} = NamedTuple({typename!r}, [])`" + deprecation_msg = ( + "{name} is deprecated and will be disallowed in Python {remove}. " + "To create a NamedTuple class with 0 fields " + "using the functional syntax, " + "pass an empty list, e.g. " + ) + example + "." + elif fields is None: + if kwargs: + raise TypeError( + "Cannot pass `None` as the 'fields' parameter " + "and also specify fields using keyword arguments" + ) + else: + deprecated_thing = "Passing `None` as the 'fields' parameter" + example = f"`{typename} = NamedTuple({typename!r}, [])`" + deprecation_msg = ( + "{name} is deprecated and will be disallowed in Python {remove}. " + "To create a NamedTuple class with 0 fields " + "using the functional syntax, " + "pass an empty list, e.g. " + ) + example + "." + elif kwargs: + raise TypeError("Either list of fields or keywords" + " can be provided to NamedTuple, not both") + if fields is _marker or fields is None: + warnings.warn( + deprecation_msg.format(name=deprecated_thing, remove="3.15"), + DeprecationWarning, + stacklevel=2, + ) + fields = kwargs.items() + nt = _make_nmtuple(typename, fields, module=_caller()) + nt.__orig_bases__ = (NamedTuple,) + return nt + + NamedTuple.__mro_entries__ = _namedtuple_mro_entries + + +if hasattr(collections.abc, "Buffer"): + Buffer = collections.abc.Buffer +else: + class Buffer(abc.ABC): # noqa: B024 + """Base class for classes that implement the buffer protocol. + + The buffer protocol allows Python objects to expose a low-level + memory buffer interface. Before Python 3.12, it is not possible + to implement the buffer protocol in pure Python code, or even + to check whether a class implements the buffer protocol. In + Python 3.12 and higher, the ``__buffer__`` method allows access + to the buffer protocol from Python code, and the + ``collections.abc.Buffer`` ABC allows checking whether a class + implements the buffer protocol. + + To indicate support for the buffer protocol in earlier versions, + inherit from this ABC, either in a stub file or at runtime, + or use ABC registration. This ABC provides no methods, because + there is no Python-accessible methods shared by pre-3.12 buffer + classes. It is useful primarily for static checks. + + """ + + # As a courtesy, register the most common stdlib buffer classes. + Buffer.register(memoryview) + Buffer.register(bytearray) + Buffer.register(bytes) + + +# Backport of types.get_original_bases, available on 3.12+ in CPython +if hasattr(_types, "get_original_bases"): + get_original_bases = _types.get_original_bases +else: + def get_original_bases(cls, /): + """Return the class's "original" bases prior to modification by `__mro_entries__`. + + Examples:: + + from typing import TypeVar, Generic + from typing_extensions import NamedTuple, TypedDict + + T = TypeVar("T") + class Foo(Generic[T]): ... + class Bar(Foo[int], float): ... + class Baz(list[str]): ... + Eggs = NamedTuple("Eggs", [("a", int), ("b", str)]) + Spam = TypedDict("Spam", {"a": int, "b": str}) + + assert get_original_bases(Bar) == (Foo[int], float) + assert get_original_bases(Baz) == (list[str],) + assert get_original_bases(Eggs) == (NamedTuple,) + assert get_original_bases(Spam) == (TypedDict,) + assert get_original_bases(int) == (object,) + """ + try: + return cls.__dict__.get("__orig_bases__", cls.__bases__) + except AttributeError: + raise TypeError( + f'Expected an instance of type, not {type(cls).__name__!r}' + ) from None + + +# NewType is a class on Python 3.10+, making it pickleable +# The error message for subclassing instances of NewType was improved on 3.11+ +# Breakpoint: https://github.com/python/cpython/pull/30268 +if sys.version_info >= (3, 11): + NewType = typing.NewType +else: + class NewType: + """NewType creates simple unique types with almost zero + runtime overhead. NewType(name, tp) is considered a subtype of tp + by static type checkers. At runtime, NewType(name, tp) returns + a dummy callable that simply returns its argument. Usage:: + UserId = NewType('UserId', int) + def name_by_id(user_id: UserId) -> str: + ... + UserId('user') # Fails type check + name_by_id(42) # Fails type check + name_by_id(UserId(42)) # OK + num = UserId(5) + 1 # type: int + """ + + def __call__(self, obj, /): + return obj + + def __init__(self, name, tp): + self.__qualname__ = name + if '.' in name: + name = name.rpartition('.')[-1] + self.__name__ = name + self.__supertype__ = tp + def_mod = _caller() + if def_mod != 'typing_extensions': + self.__module__ = def_mod + + def __mro_entries__(self, bases): + # We defined __mro_entries__ to get a better error message + # if a user attempts to subclass a NewType instance. bpo-46170 + supercls_name = self.__name__ + + class Dummy: + def __init_subclass__(cls): + subcls_name = cls.__name__ + raise TypeError( + f"Cannot subclass an instance of NewType. " + f"Perhaps you were looking for: " + f"`{subcls_name} = NewType({subcls_name!r}, {supercls_name})`" + ) + + return (Dummy,) + + def __repr__(self): + return f'{self.__module__}.{self.__qualname__}' + + def __reduce__(self): + return self.__qualname__ + + # Breakpoint: https://github.com/python/cpython/pull/21515 + if sys.version_info >= (3, 10): + # PEP 604 methods + # It doesn't make sense to have these methods on Python <3.10 + + def __or__(self, other): + return typing.Union[self, other] + + def __ror__(self, other): + return typing.Union[other, self] + + +# Breakpoint: https://github.com/python/cpython/pull/149172 +if sys.version_info >= (3, 15): + TypeAliasType = typing.TypeAliasType +# <=3.14 +else: + # Breakpoint: https://github.com/python/cpython/pull/103764 + if sys.version_info >= (3, 12): + # 3.12-3.14 + def _is_unionable(obj): + """Corresponds to is_unionable() in unionobject.c in CPython.""" + return obj is None or isinstance(obj, ( + type, + _types.GenericAlias, + _types.UnionType, + typing.TypeAliasType, + TypeAliasType, + )) + else: + # <=3.11 + def _is_unionable(obj): + """Corresponds to is_unionable() in unionobject.c in CPython.""" + return obj is None or isinstance(obj, ( + type, + _types.GenericAlias, + _types.UnionType, + TypeAliasType, + )) + + if sys.version_info < (3, 10): + # Copied and pasted from https://github.com/python/cpython/blob/986a4e1b6fcae7fe7a1d0a26aea446107dd58dd2/Objects/genericaliasobject.c#L568-L582, + # so that we emulate the behaviour of `types.GenericAlias` + # on the latest versions of CPython + _ATTRIBUTE_DELEGATION_EXCLUSIONS = frozenset({ + "__class__", + "__bases__", + "__origin__", + "__args__", + "__unpacked__", + "__parameters__", + "__typing_unpacked_tuple_args__", + "__mro_entries__", + "__reduce_ex__", + "__reduce__", + "__copy__", + "__deepcopy__", + }) + + class _TypeAliasGenericAlias(typing._GenericAlias, _root=True): + def __getattr__(self, attr): + if attr in _ATTRIBUTE_DELEGATION_EXCLUSIONS: + return object.__getattr__(self, attr) + return getattr(self.__origin__, attr) + + + class TypeAliasType: + """Create named, parameterized type aliases. + + This provides a backport of the new `type` statement in Python 3.12: + + type ListOrSet[T] = list[T] | set[T] + + is equivalent to: + + T = TypeVar("T") + ListOrSet = TypeAliasType("ListOrSet", list[T] | set[T], type_params=(T,)) + + The name ListOrSet can then be used as an alias for the type it refers to. + + The type_params argument should contain all the type parameters used + in the value of the type alias. If the alias is not generic, this + argument is omitted. + + Static type checkers should only support type aliases declared using + TypeAliasType that follow these rules: + + - The first argument (the name) must be a string literal. + - The TypeAliasType instance must be immediately assigned to a variable + of the same name. (For example, 'X = TypeAliasType("Y", int)' is invalid, + as is 'X, Y = TypeAliasType("X", int), TypeAliasType("Y", int)'). + + """ + + def __init__(self, name: str, value, *, type_params=()): + if not isinstance(name, str): + raise TypeError("TypeAliasType name must be a string") + if not isinstance(type_params, tuple): + raise TypeError("type_params must be a tuple") + self.__value__ = value + self.__type_params__ = type_params + + default_value_encountered = False + parameters = [] + for type_param in type_params: + if ( + not isinstance(type_param, (TypeVar, TypeVarTuple, ParamSpec)) + # <=3.11 + # Unpack Backport passes isinstance(type_param, TypeVar) + or _is_unpack(type_param) + ): + raise TypeError(f"Expected a type param, got {type_param!r}") + has_default = ( + getattr(type_param, '__default__', NoDefault) is not NoDefault + ) + if default_value_encountered and not has_default: + raise TypeError(f"non-default type parameter '{type_param!r}'" + " follows default type parameter") + if has_default: + default_value_encountered = True + if isinstance(type_param, TypeVarTuple): + parameters.extend(type_param) + else: + parameters.append(type_param) + self.__parameters__ = tuple(parameters) + def_mod = _caller() + if def_mod != 'typing_extensions': + self.__module__ = def_mod + # Setting this attribute closes the TypeAliasType from further modification + self.__name__ = name + + def __setattr__(self, name: str, value: object, /) -> None: + if hasattr(self, "__name__") and name != "__module__": + self._raise_attribute_error(name) + super().__setattr__(name, value) + + def __delattr__(self, name: str, /) -> Never: + self._raise_attribute_error(name) + + def _raise_attribute_error(self, name: str) -> Never: + # Match the Python 3.12 error messages exactly + if name == "__name__": + raise AttributeError("readonly attribute") + elif name in {"__value__", "__type_params__", "__parameters__"}: + raise AttributeError( + f"attribute '{name}' of 'typing.TypeAliasType' objects " + "is not writable" + ) + else: + raise AttributeError( + f"'typing.TypeAliasType' object has no attribute '{name}'" + ) + + def __repr__(self) -> str: + return self.__name__ + + if sys.version_info < (3, 11): + def _check_single_param(self, param, recursion=0): + # Allow [], [int], [int, str], [int, ...], [int, T] + if param is ...: + return ... + if param is None: + return None + # Note in <= 3.9 _ConcatenateGenericAlias inherits from list + if isinstance(param, list) and recursion == 0: + return [self._check_single_param(arg, recursion+1) + for arg in param] + return typing._type_check( + param, f'Subscripting {self.__name__} requires a type.' + ) + + def _check_parameters(self, parameters): + if sys.version_info < (3, 11): + return tuple( + self._check_single_param(item) + for item in parameters + ) + return tuple(typing._type_check( + item, f'Subscripting {self.__name__} requires a type.' + ) + for item in parameters + ) + + def __getitem__(self, parameters): + if not self.__type_params__: + raise TypeError("Only generic type aliases are subscriptable") + if not isinstance(parameters, tuple): + parameters = (parameters,) + # Using 3.9 here will create problems with Concatenate + if sys.version_info >= (3, 10): + return _types.GenericAlias(self, parameters) + type_vars = _collect_type_vars(parameters) + parameters = self._check_parameters(parameters) + alias = _TypeAliasGenericAlias(self, parameters) + # alias.__parameters__ is not complete if Concatenate is present + # as it is converted to a list from which no parameters are extracted. + if alias.__parameters__ != type_vars: + alias.__parameters__ = type_vars + return alias + + def __reduce__(self): + return self.__name__ + + def __init_subclass__(cls, *args, **kwargs): + raise TypeError( + "type 'typing_extensions.TypeAliasType' is not an acceptable base type" + ) + + # The presence of this method convinces typing._type_check + # that TypeAliasTypes are types. + def __call__(self): + raise TypeError("Type alias is not callable") + + # Breakpoint: https://github.com/python/cpython/pull/21515 + if sys.version_info >= (3, 10): + def __or__(self, right): + # For forward compatibility with 3.12, reject Unions + # that are not accepted by the built-in Union. + if not _is_unionable(right): + return NotImplemented + return typing.Union[self, right] + + def __ror__(self, left): + if not _is_unionable(left): + return NotImplemented + return typing.Union[left, self] + + +if hasattr(typing, "is_protocol"): + is_protocol = typing.is_protocol + get_protocol_members = typing.get_protocol_members +else: + def is_protocol(tp: type, /) -> bool: + """Return True if the given type is a Protocol. + + Example:: + + >>> from typing_extensions import Protocol, is_protocol + >>> class P(Protocol): + ... def a(self) -> str: ... + ... b: int + >>> is_protocol(P) + True + >>> is_protocol(int) + False + """ + return ( + isinstance(tp, type) + and getattr(tp, '_is_protocol', False) + and tp is not Protocol + and tp is not typing.Protocol + ) + + def get_protocol_members(tp: type, /) -> typing.FrozenSet[str]: + """Return the set of members defined in a Protocol. + + Example:: + + >>> from typing_extensions import Protocol, get_protocol_members + >>> class P(Protocol): + ... def a(self) -> str: ... + ... b: int + >>> get_protocol_members(P) == frozenset({'a', 'b'}) + True + + Raise a TypeError for arguments that are not Protocols. + """ + if not is_protocol(tp): + raise TypeError(f'{tp!r} is not a Protocol') + if hasattr(tp, '__protocol_attrs__'): + return frozenset(tp.__protocol_attrs__) + return frozenset(_get_protocol_attrs(tp)) + + +if hasattr(typing, "Doc"): + Doc = typing.Doc +else: + class Doc: + """Define the documentation of a type annotation using ``Annotated``, to be + used in class attributes, function and method parameters, return values, + and variables. + + The value should be a positional-only string literal to allow static tools + like editors and documentation generators to use it. + + This complements docstrings. + + The string value passed is available in the attribute ``documentation``. + + Example:: + + >>> from typing_extensions import Annotated, Doc + >>> def hi(to: Annotated[str, Doc("Who to say hi to")]) -> None: ... + """ + def __init__(self, documentation: str, /) -> None: + self.documentation = documentation + + def __repr__(self) -> str: + return f"Doc({self.documentation!r})" + + def __hash__(self) -> int: + return hash(self.documentation) + + def __eq__(self, other: object) -> bool: + if not isinstance(other, Doc): + return NotImplemented + return self.documentation == other.documentation + + +_CapsuleType = getattr(_types, "CapsuleType", None) + +if _CapsuleType is None: + try: + import _socket + except ImportError: + pass + else: + _CAPI = getattr(_socket, "CAPI", None) + if _CAPI is not None: + _CapsuleType = type(_CAPI) + +if _CapsuleType is not None: + CapsuleType = _CapsuleType + __all__.append("CapsuleType") + + +if sys.version_info >= (3, 14): + from annotationlib import Format, get_annotations +else: + # Available since Python 3.14.0a3 + # PR: https://github.com/python/cpython/pull/124415 + class Format(enum.IntEnum): + VALUE = 1 + VALUE_WITH_FAKE_GLOBALS = 2 + FORWARDREF = 3 + STRING = 4 + + # Available since Python 3.14.0a1 + # PR: https://github.com/python/cpython/pull/119891 + def get_annotations(obj, *, globals=None, locals=None, eval_str=False, + format=Format.VALUE): + """Compute the annotations dict for an object. + + obj may be a callable, class, or module. + Passing in an object of any other type raises TypeError. + + Returns a dict. get_annotations() returns a new dict every time + it's called; calling it twice on the same object will return two + different but equivalent dicts. + + This is a backport of `inspect.get_annotations`, which has been + in the standard library since Python 3.10. See the standard library + documentation for more: + + https://docs.python.org/3/library/inspect.html#inspect.get_annotations + + This backport adds the *format* argument introduced by PEP 649. The + three formats supported are: + * VALUE: the annotations are returned as-is. This is the default and + it is compatible with the behavior on previous Python versions. + * FORWARDREF: return annotations as-is if possible, but replace any + undefined names with ForwardRef objects. The implementation proposed by + PEP 649 relies on language changes that cannot be backported; the + typing-extensions implementation simply returns the same result as VALUE. + * STRING: return annotations as strings, in a format close to the original + source. Again, this behavior cannot be replicated directly in a backport. + As an approximation, typing-extensions retrieves the annotations under + VALUE semantics and then stringifies them. + + The purpose of this backport is to allow users who would like to use + FORWARDREF or STRING semantics once PEP 649 is implemented, but who also + want to support earlier Python versions, to simply write: + + typing_extensions.get_annotations(obj, format=Format.FORWARDREF) + + """ + format = Format(format) + if format is Format.VALUE_WITH_FAKE_GLOBALS: + raise ValueError( + "The VALUE_WITH_FAKE_GLOBALS format is for internal use only" + ) + + if eval_str and format is not Format.VALUE: + raise ValueError("eval_str=True is only supported with format=Format.VALUE") + + if isinstance(obj, type): + # class + obj_dict = getattr(obj, '__dict__', None) + if obj_dict and hasattr(obj_dict, 'get'): + ann = obj_dict.get('__annotations__', None) + if isinstance(ann, _types.GetSetDescriptorType): + ann = None + else: + ann = None + + obj_globals = None + module_name = getattr(obj, '__module__', None) + if module_name: + module = sys.modules.get(module_name, None) + if module: + obj_globals = getattr(module, '__dict__', None) + obj_locals = dict(vars(obj)) + unwrap = obj + elif isinstance(obj, _types.ModuleType): + # module + ann = getattr(obj, '__annotations__', None) + obj_globals = obj.__dict__ + obj_locals = None + unwrap = None + elif callable(obj): + # this includes types.Function, types.BuiltinFunctionType, + # types.BuiltinMethodType, functools.partial, functools.singledispatch, + # "class funclike" from Lib/test/test_inspect... on and on it goes. + ann = getattr(obj, '__annotations__', None) + obj_globals = getattr(obj, '__globals__', None) + obj_locals = None + unwrap = obj + elif hasattr(obj, '__annotations__'): + ann = obj.__annotations__ + obj_globals = obj_locals = unwrap = None + else: + raise TypeError(f"{obj!r} is not a module, class, or callable.") + + if ann is None: + return {} + + if not isinstance(ann, dict): + raise ValueError(f"{obj!r}.__annotations__ is neither a dict nor None") + + if not ann: + return {} + + if not eval_str: + if format is Format.STRING: + return { + key: value if isinstance(value, str) else typing._type_repr(value) + for key, value in ann.items() + } + return dict(ann) + + if unwrap is not None: + while True: + if hasattr(unwrap, '__wrapped__'): + unwrap = unwrap.__wrapped__ + continue + if isinstance(unwrap, functools.partial): + unwrap = unwrap.func + continue + break + if hasattr(unwrap, "__globals__"): + obj_globals = unwrap.__globals__ + + if globals is None: + globals = obj_globals + if locals is None: + locals = obj_locals or {} + + # "Inject" type parameters into the local namespace + # (unless they are shadowed by assignments *in* the local namespace), + # as a way of emulating annotation scopes when calling `eval()` + if type_params := getattr(obj, "__type_params__", ()): + locals = {param.__name__: param for param in type_params} | locals + + return_value = {key: + value if not isinstance(value, str) else eval(value, globals, locals) + for key, value in ann.items() } + return return_value + + +if hasattr(typing, "evaluate_forward_ref"): + evaluate_forward_ref = typing.evaluate_forward_ref +else: + # Implements annotationlib.ForwardRef.evaluate + def _eval_with_owner( + forward_ref, *, owner=None, globals=None, locals=None, type_params=None + ): + if forward_ref.__forward_evaluated__: + return forward_ref.__forward_value__ + if getattr(forward_ref, "__cell__", None) is not None: + try: + value = forward_ref.__cell__.cell_contents + except ValueError: + pass + else: + forward_ref.__forward_evaluated__ = True + forward_ref.__forward_value__ = value + return value + if owner is None: + owner = getattr(forward_ref, "__owner__", None) + + if ( + globals is None + and getattr(forward_ref, "__forward_module__", None) is not None + ): + globals = getattr( + sys.modules.get(forward_ref.__forward_module__, None), "__dict__", None + ) + if globals is None: + globals = getattr(forward_ref, "__globals__", None) + if globals is None: + if isinstance(owner, type): + module_name = getattr(owner, "__module__", None) + if module_name: + module = sys.modules.get(module_name, None) + if module: + globals = getattr(module, "__dict__", None) + elif isinstance(owner, _types.ModuleType): + globals = getattr(owner, "__dict__", None) + elif callable(owner): + globals = getattr(owner, "__globals__", None) + + # If we pass None to eval() below, the globals of this module are used. + if globals is None: + globals = {} + + if locals is None: + locals = {} + if isinstance(owner, type): + locals.update(vars(owner)) + + if type_params is None and owner is not None: + # "Inject" type parameters into the local namespace + # (unless they are shadowed by assignments *in* the local namespace), + # as a way of emulating annotation scopes when calling `eval()` + type_params = getattr(owner, "__type_params__", None) + + # Type parameters exist in their own scope, which is logically + # between the locals and the globals. We simulate this by adding + # them to the globals. + if type_params is not None: + globals = dict(globals) + for param in type_params: + globals[param.__name__] = param + + arg = forward_ref.__forward_arg__ + if arg.isidentifier() and not keyword.iskeyword(arg): + if arg in locals: + value = locals[arg] + elif arg in globals: + value = globals[arg] + elif hasattr(builtins, arg): + return getattr(builtins, arg) + else: + raise NameError(arg) + else: + code = forward_ref.__forward_code__ + value = eval(code, globals, locals) + forward_ref.__forward_evaluated__ = True + forward_ref.__forward_value__ = value + return value + + def evaluate_forward_ref( + forward_ref, + *, + owner=None, + globals=None, + locals=None, + type_params=None, + format=None, + _recursive_guard=frozenset(), + ): + """Evaluate a forward reference as a type hint. + + This is similar to calling the ForwardRef.evaluate() method, + but unlike that method, evaluate_forward_ref() also: + + * Recursively evaluates forward references nested within the type hint. + * Rejects certain objects that are not valid type hints. + * Replaces type hints that evaluate to None with types.NoneType. + * Supports the *FORWARDREF* and *STRING* formats. + + *forward_ref* must be an instance of ForwardRef. *owner*, if given, + should be the object that holds the annotations that the forward reference + derived from, such as a module, class object, or function. It is used to + infer the namespaces to use for looking up names. *globals* and *locals* + can also be explicitly given to provide the global and local namespaces. + *type_params* is a tuple of type parameters that are in scope when + evaluating the forward reference. This parameter must be provided (though + it may be an empty tuple) if *owner* is not given and the forward reference + does not already have an owner set. *format* specifies the format of the + annotation and is a member of the annotationlib.Format enum. + + """ + if format == Format.STRING: + return forward_ref.__forward_arg__ + if forward_ref.__forward_arg__ in _recursive_guard: + return forward_ref + + # Evaluate the forward reference + try: + value = _eval_with_owner( + forward_ref, + owner=owner, + globals=globals, + locals=locals, + type_params=type_params, + ) + except NameError: + if format == Format.FORWARDREF: + return forward_ref + else: + raise + + if isinstance(value, str): + value = ForwardRef(value) + + # Recursively evaluate the type + if isinstance(value, ForwardRef): + if getattr(value, "__forward_module__", True) is not None: + globals = None + return evaluate_forward_ref( + value, + globals=globals, + locals=locals, + type_params=type_params, owner=owner, + _recursive_guard=_recursive_guard, format=format + ) + if sys.version_info < (3, 12, 5) and type_params: + # Make use of type_params + locals = dict(locals) if locals else {} + for tvar in type_params: + if tvar.__name__ not in locals: # lets not overwrite something present + locals[tvar.__name__] = tvar + if sys.version_info < (3, 12, 5): + return typing._eval_type( + value, + globals, + locals, + recursive_guard=_recursive_guard | {forward_ref.__forward_arg__}, + ) + else: + return typing._eval_type( + value, + globals, + locals, + type_params, + recursive_guard=_recursive_guard | {forward_ref.__forward_arg__}, + ) + + +if sys.version_info >= (3, 14, 0, "beta"): + type_repr = annotationlib.type_repr +else: + def type_repr(value): + """Convert a Python value to a format suitable for use with the STRING format. + + This is intended as a helper for tools that support the STRING format but do + not have access to the code that originally produced the annotations. It uses + repr() for most objects. + + """ + if isinstance(value, (type, _types.FunctionType, _types.BuiltinFunctionType)): + if value.__module__ == "builtins": + return value.__qualname__ + return f"{value.__module__}.{value.__qualname__}" + if value is ...: + return "..." + return repr(value) + + +# Aliases for items that are in typing in all supported versions. +# We use hasattr() checks so this library will continue to import on +# future versions of Python that may remove these names. +_typing_names = [ + "AbstractSet", + "AnyStr", + "BinaryIO", + "Callable", + "Collection", + "Container", + "Dict", + "FrozenSet", + "Hashable", + "IO", + "ItemsView", + "Iterable", + "Iterator", + "KeysView", + "List", + "Mapping", + "MappingView", + "Match", + "MutableMapping", + "MutableSequence", + "MutableSet", + "Optional", + "Pattern", + "Reversible", + "Sequence", + "Set", + "Sized", + "TextIO", + "Tuple", + "Union", + "ValuesView", + "cast", + "no_type_check", + # This is private, but it was defined by typing_extensions for a long time + # and some users rely on it. + "_AnnotatedAlias", +] + +# Breakpoint: https://github.com/python/cpython/pull/133602 +if sys.version_info < (3, 15, 0): + _typing_names.append("no_type_check_decorator") + __all__.append("no_type_check_decorator") + +globals().update( + {name: getattr(typing, name) for name in _typing_names if hasattr(typing, name)} +) +# These are defined unconditionally because they are used in +# typing-extensions itself. +Generic = typing.Generic +ForwardRef = typing.ForwardRef +Annotated = typing.Annotated diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/INSTALLER b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/METADATA b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..33514f59e135ae2a2c59b35922e0de14cac000f4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/METADATA @@ -0,0 +1,29 @@ +Metadata-Version: 2.4 +Name: vhacdx +Version: 0.1.0 +Summary: Python bindings for VHACD +Author-email: Thomas Wolf +Project-URL: Homepage, https://github.com/trimesh/vhacdx +Requires-Python: >=3.7 +Description-Content-Type: text/markdown +License-File: LICENSE +Requires-Dist: numpy +Provides-Extra: test +Requires-Dist: pytest; extra == "test" +Dynamic: license-file + +# vhacdx +Python bindings for V-HACD + +A very simple and raw python binding for [V-HACD](https://github.com/kmammou/v-hacd) that is forked from [thomwolf/pyVHACD](https://github.com/thomwolf/pyVHACD) which generates an approximate convex decomposition of a triangle mesh. + +Contains a single method: `output = compute_vhacd(points, faces)` which take as inputs: +- points: a (N, 3) Numpy array of double containing the coordinates of the N vertex of the mesh +- face: a (M,) Numpy array of uint32 containing the face vertxe indices were M is 3 times the number of faces + +Gives as output a list (number of convex hulls) of pairs of points-faces for each convex hull. + +# To install +``` +pip install vhacdx +``` diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/RECORD b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..7e7abb8820bb3784d4e9da057054ca0a74f9d3f3 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/RECORD @@ -0,0 +1,10 @@ +vhacdx-0.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +vhacdx-0.1.0.dist-info/METADATA,sha256=GZznouksJ7b5hTlJ7MbND1rR6Q5TkFYQeCs8KEswq_U,1083 +vhacdx-0.1.0.dist-info/RECORD,, +vhacdx-0.1.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +vhacdx-0.1.0.dist-info/WHEEL,sha256=G4tz_EN0PGnsGTeBSpgRT59OSP4cVFKWMTwFGMlfeXg,152 +vhacdx-0.1.0.dist-info/licenses/LICENSE,sha256=DO84E1YuzqlWMXAYpa1BuuqE5DF7xXkk_036L_XFF3U,2625 +vhacdx-0.1.0.dist-info/top_level.txt,sha256=kRJmlK_xeBU5kk3I_2hGUPfh7RAGxEUNSNHitrvCUSI,7 +vhacdx.cpython-311-x86_64-linux-gnu.so,sha256=PuAECZ-L-IW52B2kKlmUKda0rmVLDdZ1xLFo3F6CWqI,501432 +vhacdx/VHACD.h,sha256=AjFMV1kJ1lbcZ9bjw4zvxJxEA-jKHcsKtLBYAM7mHhw,259743 +vhacdx/main.cpp,sha256=74pDBh_fKBUiTDe0pOWkY3lNwnvsESFldwdghwH2xcI,5596 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/REQUESTED b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/WHEEL b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..4ee6b3c06c3f7144da8bc99d6b992499e2575836 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: setuptools (84.0.0) +Root-Is-Purelib: false +Tag: cp311-cp311-manylinux_2_27_x86_64 +Tag: cp311-cp311-manylinux_2_28_x86_64 + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/licenses/LICENSE b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..6a234c9d1de249808232cc71e56d2acd4555fff9 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/licenses/LICENSE @@ -0,0 +1,52 @@ +MIT License + +Copyright (c) 2022 Thomas Wolf + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + + +Additionally, the V-HACD header-only C++ library (src/vhacdx/VHACD.h) is: + + +Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com) +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. The names of the contributors may not be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/top_level.txt b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..c27936c916a64898bbbad961bd45979da9eb6b71 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx-0.1.0.dist-info/top_level.txt @@ -0,0 +1 @@ +vhacdx diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx.cpython-311-x86_64-linux-gnu.so b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx.cpython-311-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..34502bd09bcda8623498cb8e953782760e4c1d96 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx.cpython-311-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3ee004099f8bf885b9d81da42a599429d6b4ae654b0dd675c4b168dc5e825aa2 +size 501432 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx/VHACD.h b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx/VHACD.h new file mode 100644 index 0000000000000000000000000000000000000000..6c8b8691e1cb1460d3cf5f72218176f933c468cd --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx/VHACD.h @@ -0,0 +1,8367 @@ +/* Copyright (c) 2011 Khaled Mamou (kmamou at gmail dot com) + All rights reserved. + + + Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. + + 3. The names of the contributors may not be used to endorse or promote products derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#pragma once +#ifndef VHACD_H +# define VHACD_H + +// Please view this slide deck which describes usage and how the algorithm works. +// https://docs.google.com/presentation/d/1OZ4mtZYrGEC8qffqb8F7Le2xzufiqvaPpRbLHKKgTIM/edit?usp=sharing + +// VHACD is now a header only library. +// In just *one* of your CPP files *before* you include 'VHACD.h' you must declare +// #define ENABLE_VHACD_IMPLEMENTATION 1 +// This will compile the implementation code into your project. If you don't +// have this define, you will get link errors since the implementation code will +// not be present. If you define it more than once in your code base, you will get +// link errors due to a duplicate implementation. This is the same pattern used by +// ImGui and StbLib and other popular open source libraries. + +# define VHACD_VERSION_MAJOR 4 +# define VHACD_VERSION_MINOR 1 + +// Changes for version 4.1 +// +// Various minor tweaks mostly to the test application and some default values. + +// Changes for version 4.0 +// +// * The code has been significantly refactored to be cleaner and easier to maintain +// * All OpenCL related code removed +// * All Bullet code removed +// * All SIMD code removed +// * Old plane splitting code removed +// +// * The code is now delivered as a single header file 'VHACD.h' which has both the API +// * declaration as well as the implementation. Simply add '#define ENABLE_VHACD_IMPLEMENTATION 1' +// * to any CPP in your application prior to including 'VHACD.h'. Only do this in one CPP though. +// * If you do not have this define once, you will get link errors since the implementation code +// * will not be compiled in. If you have this define more than once, you are likely to get +// * duplicate symbol link errors. +// +// * Since the library is now delivered as a single header file, we do not provide binaries +// * or build scripts as these are not needed. +// +// * The old DebugView and test code has all been removed and replaced with a much smaller and +// * simpler test console application with some test meshes to work with. +// +// * The convex hull generation code has changed. The previous version came from Bullet. +// * However, the new version is courtesy of Julio Jerez, the author of the Newton +// * physics engine. His new version is faster and more numerically stable. +// +// * The code can now detect if the input mesh is, itself, already a convex object and +// * can early out. +// +// * Significant performance improvements have been made to the code and it is now much +// * faster, stable, and is easier to tune than previous versions. +// +// * A bug was fixed with the shrink wrapping code (project hull vertices) that could +// * sometime produce artifacts in the results. The new version uses a 'closest point' +// * algorithm that is more reliable. +// +// * You can now select which 'fill mode' to use. For perfectly closed meshes, the default +// * behavior using a flood fill generally works fine. However, some meshes have small +// * holes in them and therefore the flood fill will fail, treating the mesh as being +// * hollow. In these cases, you can use the 'raycast' fill option to determine which +// * parts of the voxelized mesh are 'inside' versus being 'outside'. Finally, there +// * are some rare instances where a user might actually want the mesh to be treated as +// * hollow, in which case you can pass in 'surface' only. +// * +// * A new optional virtual interface called 'IUserProfiler' was provided. +// * This allows the user to provide an optional profiling callback interface to assist in +// * diagnosing performance issues. This change was made by Danny Couture at Epic for the UE4 integration. +// * Some profiling macros were also declared in support of this feature. +// * +// * Another new optional virtual interface called 'IUserTaskRunner' was provided. +// * This interface is used to run logical 'tasks' in a background thread. If none is provided +// * then a default implementation using std::thread will be executed. +// * This change was made by Danny Couture at Epic to speed up the voxelization step. +// * + + + +// The history of V-HACD: +// +// The initial version was written by John W. Ratcliff and was called 'ACD' +// This version did not perform CSG operations on the source mesh, so if you +// recursed too deeply it would produce hollow results. +// +// The next version was written by Khaled Mamou and was called 'HACD' +// In this version Khaled tried to perform a CSG operation on the source +// mesh to produce more robust results. However, Khaled learned that the +// CSG library he was using had licensing issues so he started work on the +// next version. +// +// The next version was called 'V-HACD' because Khaled made the observation +// that plane splitting would be far easier to implement working in voxel space. +// +// V-HACD has been integrated into UE4, Blender, and a number of other projects. +// This new release, version4, is a significant refactor of the code to fix +// some bugs, improve performance, and to make the codebase easier to maintain +// going forward. + +#include +#include + +#include +#include +#include +#include + +namespace VHACD { + +struct Vertex +{ + double mX; + double mY; + double mZ; + + Vertex() = default; + Vertex(double x, double y, double z) : mX(x), mY(y), mZ(z) {} + + const double& operator[](size_t idx) const + { + switch(idx) + { + case 0: return mX; + case 1: return mY; + case 2: return mZ; + }; + return mX; + } +}; + +struct Triangle +{ + uint32_t mI0; + uint32_t mI1; + uint32_t mI2; + + Triangle() = default; + Triangle(uint32_t i0, uint32_t i1, uint32_t i2) : mI0(i0), mI1(i1), mI2(i2) {} +}; + +template +class Vector3 +{ +public: + /* + * Getters + */ + T& operator[](size_t i); + const T& operator[](size_t i) const; + T& GetX(); + T& GetY(); + T& GetZ(); + const T& GetX() const; + const T& GetY() const; + const T& GetZ() const; + + /* + * Normalize and norming + */ + T Normalize(); + Vector3 Normalized(); + T GetNorm() const; + T GetNormSquared() const; + int LongestAxis() const; + + /* + * Vector-vector operations + */ + Vector3& operator=(const Vector3& rhs); + Vector3& operator+=(const Vector3& rhs); + Vector3& operator-=(const Vector3& rhs); + + Vector3 CWiseMul(const Vector3& rhs) const; + Vector3 Cross(const Vector3& rhs) const; + T Dot(const Vector3& rhs) const; + Vector3 operator+(const Vector3& rhs) const; + Vector3 operator-(const Vector3& rhs) const; + + /* + * Vector-scalar operations + */ + Vector3& operator-=(T a); + Vector3& operator+=(T a); + Vector3& operator/=(T a); + Vector3& operator*=(T a); + + Vector3 operator*(T rhs) const; + Vector3 operator/(T rhs) const; + + /* + * Unary operations + */ + Vector3 operator-() const; + + /* + * Comparison operators + */ + bool operator<(const Vector3& rhs) const; + bool operator>(const Vector3& rhs) const; + + /* + * Returns true if all elements of *this are greater than or equal to all elements of rhs, coefficient wise + * LE is less than or equal + */ + bool CWiseAllGE(const Vector3& rhs) const; + bool CWiseAllLE(const Vector3& rhs) const; + + Vector3 CWiseMin(const Vector3& rhs) const; + Vector3 CWiseMax(const Vector3& rhs) const; + T MinCoeff() const; + T MaxCoeff() const; + + T MinCoeff(uint32_t& idx) const; + T MaxCoeff(uint32_t& idx) const; + + /* + * Constructors + */ + Vector3() = default; + Vector3(T a); + Vector3(T x, T y, T z); + Vector3(const Vector3& rhs); + ~Vector3() = default; + + template + Vector3(const Vector3& rhs); + + Vector3(const VHACD::Vertex&); + Vector3(const VHACD::Triangle&); + + operator VHACD::Vertex() const; + +private: + std::array m_data{ T(0.0) }; +}; + +typedef VHACD::Vector3 Vect3; + +struct BoundsAABB +{ + BoundsAABB() = default; + BoundsAABB(const std::vector& points); + BoundsAABB(const Vect3& min, + const Vect3& max); + + BoundsAABB Union(const BoundsAABB& b); + + bool Intersects(const BoundsAABB& b) const; + + double SurfaceArea() const; + double Volume() const; + + BoundsAABB Inflate(double ratio) const; + + VHACD::Vect3 ClosestPoint(const VHACD::Vect3& p) const; + + VHACD::Vect3& GetMin(); + VHACD::Vect3& GetMax(); + const VHACD::Vect3& GetMin() const; + const VHACD::Vect3& GetMax() const; + + VHACD::Vect3 GetSize() const; + VHACD::Vect3 GetCenter() const; + + VHACD::Vect3 m_min{ double(0.0) }; + VHACD::Vect3 m_max{ double(0.0) }; +}; + +/** +* This enumeration determines how the voxels as filled to create a solid +* object. The default should be 'FLOOD_FILL' which generally works fine +* for closed meshes. However, if the mesh is not watertight, then using +* RAYCAST_FILL may be preferable as it will determine if a voxel is part +* of the interior of the source mesh by raycasting around it. +* +* Finally, there are some cases where you might actually want a convex +* decomposition to treat the source mesh as being hollow. If that is the +* case you can pass in 'SURFACE_ONLY' and then the convex decomposition +* will converge only onto the 'skin' of the surface mesh. +*/ +enum class FillMode +{ + FLOOD_FILL, // This is the default behavior, after the voxelization step it uses a flood fill to determine 'inside' + // from 'outside'. However, meshes with holes can fail and create hollow results. + SURFACE_ONLY, // Only consider the 'surface', will create 'skins' with hollow centers. + RAYCAST_FILL, // Uses raycasting to determine inside from outside. +}; + +class IVHACD +{ +public: + /** + * This optional pure virtual interface is used to notify the caller of the progress + * of convex decomposition as well as a signal when it is complete when running in + * a background thread + */ + class IUserCallback + { + public: + virtual ~IUserCallback(){}; + + /** + * Notifies the application of the current state of the convex decomposition operation + * + * @param overallProgress : Total progress from 0-100% + * @param stageProgress : Progress of the current stage 0-100% + * @param stage : A text description of the current stage we are in + * @param operation : A text description of what operation is currently being performed. + */ + virtual void Update(const double overallProgress, + const double stageProgress, + const char* const stage, + const char* operation) = 0; + + // This is an optional user callback which is only called when running V-HACD asynchronously. + // This is a callback performed to notify the user that the + // convex decomposition background process is completed. This call back will occur from + // a different thread so the user should take that into account. + virtual void NotifyVHACDComplete() + { + } + }; + + /** + * Optional user provided pure virtual interface to be notified of warning or informational messages + */ + class IUserLogger + { + public: + virtual ~IUserLogger(){}; + virtual void Log(const char* const msg) = 0; + }; + + /** + * An optional user provided pure virtual interface to perform a background task. + * This was added by Danny Couture at Epic as they wanted to use their own + * threading system instead of the standard library version which is the default. + */ + class IUserTaskRunner + { + public: + virtual ~IUserTaskRunner(){}; + virtual void* StartTask(std::function func) = 0; + virtual void JoinTask(void* Task) = 0; + }; + + /** + * A simple class that represents a convex hull as a triangle mesh with + * double precision vertices. Polygons are not currently provided. + */ + class ConvexHull + { + public: + std::vector m_points; + std::vector m_triangles; + + double m_volume{ 0 }; // The volume of the convex hull + VHACD::Vect3 m_center{ 0, 0, 0 }; // The centroid of the convex hull + uint32_t m_meshId{ 0 }; // A unique id for this convex hull + VHACD::Vect3 mBmin; // Bounding box minimum of the AABB + VHACD::Vect3 mBmax; // Bounding box maximum of the AABB + }; + + /** + * This class provides the parameters controlling the convex decomposition operation + */ + class Parameters + { + public: + IUserCallback* m_callback{nullptr}; // Optional user provided callback interface for progress + IUserLogger* m_logger{nullptr}; // Optional user provided callback interface for log messages + IUserTaskRunner* m_taskRunner{nullptr}; // Optional user provided interface for creating tasks + uint32_t m_maxConvexHulls{ 64 }; // The maximum number of convex hulls to produce + uint32_t m_resolution{ 400000 }; // The voxel resolution to use + double m_minimumVolumePercentErrorAllowed{ 1 }; // if the voxels are within 1% of the volume of the hull, we consider this a close enough approximation + uint32_t m_maxRecursionDepth{ 10 }; // The maximum recursion depth + bool m_shrinkWrap{true}; // Whether or not to shrinkwrap the voxel positions to the source mesh on output + FillMode m_fillMode{ FillMode::FLOOD_FILL }; // How to fill the interior of the voxelized mesh + uint32_t m_maxNumVerticesPerCH{ 64 }; // The maximum number of vertices allowed in any output convex hull + bool m_asyncACD{ true }; // Whether or not to run asynchronously, taking advantage of additional cores + uint32_t m_minEdgeLength{ 2 }; // Once a voxel patch has an edge length of less than 4 on all 3 sides, we don't keep recursing + bool m_findBestPlane{ false }; // Whether or not to attempt to split planes along the best location. Experimental feature. False by default. + }; + + /** + * Will cause the convex decomposition operation to be canceled early. No results will be produced but the background operation will end as soon as it can. + */ + virtual void Cancel() = 0; + + /** + * Compute a convex decomposition of a triangle mesh using float vertices and the provided user parameters. + * + * @param points : The vertices of the source mesh as floats in the form of X1,Y1,Z1, X2,Y2,Z2,.. etc. + * @param countPoints : The number of vertices in the source mesh. + * @param triangles : The indices of triangles in the source mesh in the form of I1,I2,I3, .... + * @param countTriangles : The number of triangles in the source mesh + * @param params : The convex decomposition parameters to apply + * @return : Returns true if the convex decomposition operation can be started + */ + virtual bool Compute(const float* const points, + const uint32_t countPoints, + const uint32_t* const triangles, + const uint32_t countTriangles, + const Parameters& params) = 0; + + /** + * Compute a convex decomposition of a triangle mesh using double vertices and the provided user parameters. + * + * @param points : The vertices of the source mesh as floats in the form of X1,Y1,Z1, X2,Y2,Z2,.. etc. + * @param countPoints : The number of vertices in the source mesh. + * @param triangles : The indices of triangles in the source mesh in the form of I1,I2,I3, .... + * @param countTriangles : The number of triangles in the source mesh + * @param params : The convex decomposition parameters to apply + * @return : Returns true if the convex decomposition operation can be started + */ + virtual bool Compute(const double* const points, + const uint32_t countPoints, + const uint32_t* const triangles, + const uint32_t countTriangles, + const Parameters& params) = 0; + + /** + * Returns the number of convex hulls that were produced. + * + * @return : Returns the number of convex hulls produced, or zero if it failed or was canceled + */ + virtual uint32_t GetNConvexHulls() const = 0; + + /** + * Retrieves one of the convex hulls in the solution set + * + * @param index : Which convex hull to retrieve + * @param ch : The convex hull descriptor to return + * @return : Returns true if the convex hull exists and could be retrieved + */ + virtual bool GetConvexHull(const uint32_t index, + ConvexHull& ch) const = 0; + + /** + * Releases any memory allocated by the V-HACD class + */ + virtual void Clean() = 0; // release internally allocated memory + + /** + * Releases this instance of the V-HACD class + */ + virtual void Release() = 0; // release IVHACD + + // Will compute the center of mass of the convex hull decomposition results and return it + // in 'centerOfMass'. Returns false if the center of mass could not be computed. + virtual bool ComputeCenterOfMass(double centerOfMass[3]) const = 0; + + // In synchronous mode (non-multi-threaded) the state is always 'ready' + // In asynchronous mode, this returns true if the background thread is not still actively computing + // a new solution. In an asynchronous config the 'IsReady' call will report any update or log + // messages in the caller's current thread. + virtual bool IsReady() const + { + return true; + } + + /** + * At the request of LegionFu : out_look@foxmail.com + * This method will return which convex hull is closest to the source position. + * You can use this method to figure out, for example, which vertices in the original + * source mesh are best associated with which convex hull. + * + * @param pos : The input 3d position to test against + * + * @return : Returns which convex hull this position is closest to. + */ + virtual uint32_t findNearestConvexHull(const double pos[3], + double& distanceToHull) = 0; + +protected: + virtual ~IVHACD() + { + } +}; +/* + * Out of line definitions + */ + + template + T clamp(const T& v, const T& lo, const T& hi) + { + if (v < lo) + { + return lo; + } + if (v > hi) + { + return hi; + } + return v ; + } + +/* + * Getters + */ + template + inline T& Vector3::operator[](size_t i) + { + return m_data[i]; + } + + template + inline const T& Vector3::operator[](size_t i) const + { + return m_data[i]; + } + + template + inline T& Vector3::GetX() + { + return m_data[0]; + } + + template + inline T& Vector3::GetY() + { + return m_data[1]; + } + + template + inline T& Vector3::GetZ() + { + return m_data[2]; + } + + template + inline const T& Vector3::GetX() const + { + return m_data[0]; + } + + template + inline const T& Vector3::GetY() const + { + return m_data[1]; + } + + template + inline const T& Vector3::GetZ() const + { + return m_data[2]; + } + +/* + * Normalize and norming + */ + template + inline T Vector3::Normalize() + { + T n = GetNorm(); + if (n != T(0.0)) (*this) /= n; + return n; + } + + template + inline Vector3 Vector3::Normalized() + { + Vector3 ret = *this; + T n = GetNorm(); + if (n != T(0.0)) ret /= n; + return ret; + } + + template + inline T Vector3::GetNorm() const + { + return std::sqrt(GetNormSquared()); + } + + template + inline T Vector3::GetNormSquared() const + { + return this->Dot(*this); + } + + template + inline int Vector3::LongestAxis() const + { + auto it = std::max_element(m_data.begin(), m_data.end()); + return int(std::distance(m_data.begin(), it)); + } + +/* + * Vector-vector operations + */ + template + inline Vector3& Vector3::operator=(const Vector3& rhs) + { + GetX() = rhs.GetX(); + GetY() = rhs.GetY(); + GetZ() = rhs.GetZ(); + return *this; + } + + template + inline Vector3& Vector3::operator+=(const Vector3& rhs) + { + GetX() += rhs.GetX(); + GetY() += rhs.GetY(); + GetZ() += rhs.GetZ(); + return *this; + } + + template + inline Vector3& Vector3::operator-=(const Vector3& rhs) + { + GetX() -= rhs.GetX(); + GetY() -= rhs.GetY(); + GetZ() -= rhs.GetZ(); + return *this; + } + + template + inline Vector3 Vector3::CWiseMul(const Vector3& rhs) const + { + return Vector3(GetX() * rhs.GetX(), + GetY() * rhs.GetY(), + GetZ() * rhs.GetZ()); + } + + template + inline Vector3 Vector3::Cross(const Vector3& rhs) const + { + return Vector3(GetY() * rhs.GetZ() - GetZ() * rhs.GetY(), + GetZ() * rhs.GetX() - GetX() * rhs.GetZ(), + GetX() * rhs.GetY() - GetY() * rhs.GetX()); + } + + template + inline T Vector3::Dot(const Vector3& rhs) const + { + return GetX() * rhs.GetX() + + GetY() * rhs.GetY() + + GetZ() * rhs.GetZ(); + } + + template + inline Vector3 Vector3::operator+(const Vector3& rhs) const + { + return Vector3(GetX() + rhs.GetX(), + GetY() + rhs.GetY(), + GetZ() + rhs.GetZ()); + } + + template + inline Vector3 Vector3::operator-(const Vector3& rhs) const + { + return Vector3(GetX() - rhs.GetX(), + GetY() - rhs.GetY(), + GetZ() - rhs.GetZ()); + } + + template + inline Vector3 operator*(T lhs, const Vector3& rhs) + { + return Vector3(lhs * rhs.GetX(), + lhs * rhs.GetY(), + lhs * rhs.GetZ()); + } + +/* + * Vector-scalar operations + */ + template + inline Vector3& Vector3::operator-=(T a) + { + GetX() -= a; + GetY() -= a; + GetZ() -= a; + return *this; + } + + template + inline Vector3& Vector3::operator+=(T a) + { + GetX() += a; + GetY() += a; + GetZ() += a; + return *this; + } + + template + inline Vector3& Vector3::operator/=(T a) + { + GetX() /= a; + GetY() /= a; + GetZ() /= a; + return *this; + } + + template + inline Vector3& Vector3::operator*=(T a) + { + GetX() *= a; + GetY() *= a; + GetZ() *= a; + return *this; + } + + template + inline Vector3 Vector3::operator*(T rhs) const + { + return Vector3(GetX() * rhs, + GetY() * rhs, + GetZ() * rhs); + } + + template + inline Vector3 Vector3::operator/(T rhs) const + { + return Vector3(GetX() / rhs, + GetY() / rhs, + GetZ() / rhs); + } + +/* + * Unary operations + */ + template + inline Vector3 Vector3::operator-() const + { + return Vector3(-GetX(), + -GetY(), + -GetZ()); + } + +/* + * Comparison operators + */ + template + inline bool Vector3::operator<(const Vector3& rhs) const + { + if (GetX() == rhs.GetX()) + { + if (GetY() == rhs.GetY()) + { + return (GetZ() < rhs.GetZ()); + } + return (GetY() < rhs.GetY()); + } + return (GetX() < rhs.GetX()); + } + + template + inline bool Vector3::operator>(const Vector3& rhs) const + { + if (GetX() == rhs.GetX()) + { + if (GetY() == rhs.GetY()) + { + return (GetZ() > rhs.GetZ()); + } + return (GetY() > rhs.GetY()); + } + return (GetX() > rhs.GetZ()); + } + + template + inline bool Vector3::CWiseAllGE(const Vector3& rhs) const + { + return GetX() >= rhs.GetX() + && GetY() >= rhs.GetY() + && GetZ() >= rhs.GetZ(); + } + + template + inline bool Vector3::CWiseAllLE(const Vector3& rhs) const + { + return GetX() <= rhs.GetX() + && GetY() <= rhs.GetY() + && GetZ() <= rhs.GetZ(); + } + + template + inline Vector3 Vector3::CWiseMin(const Vector3& rhs) const + { + return Vector3(std::min(GetX(), rhs.GetX()), + std::min(GetY(), rhs.GetY()), + std::min(GetZ(), rhs.GetZ())); + } + + template + inline Vector3 Vector3::CWiseMax(const Vector3& rhs) const + { + return Vector3(std::max(GetX(), rhs.GetX()), + std::max(GetY(), rhs.GetY()), + std::max(GetZ(), rhs.GetZ())); + } + + template + inline T Vector3::MinCoeff() const + { + return *std::min_element(m_data.begin(), m_data.end()); + } + + template + inline T Vector3::MaxCoeff() const + { + return *std::max_element(m_data.begin(), m_data.end()); + } + + template + inline T Vector3::MinCoeff(uint32_t& idx) const + { + auto it = std::min_element(m_data.begin(), m_data.end()); + idx = uint32_t(std::distance(m_data.begin(), it)); + return *it; + } + + template + inline T Vector3::MaxCoeff(uint32_t& idx) const + { + auto it = std::max_element(m_data.begin(), m_data.end()); + idx = uint32_t(std::distance(m_data.begin(), it)); + return *it; + } + +/* + * Constructors + */ + template + inline Vector3::Vector3(T a) + : m_data{a, a, a} + { + } + + template + inline Vector3::Vector3(T x, T y, T z) + : m_data{x, y, z} + { + } + + template + inline Vector3::Vector3(const Vector3& rhs) + : m_data{rhs.m_data} + { + } + + template + template + inline Vector3::Vector3(const Vector3& rhs) + : m_data{T(rhs.GetX()), T(rhs.GetY()), T(rhs.GetZ())} + { + } + + template + inline Vector3::Vector3(const VHACD::Vertex& rhs) + : Vector3(rhs.mX, rhs.mY, rhs.mZ) + { + static_assert(std::is_same::value, "Vertex to Vector3 constructor only enabled for double"); + } + + template + inline Vector3::Vector3(const VHACD::Triangle& rhs) + : Vector3(rhs.mI0, rhs.mI1, rhs.mI2) + { + static_assert(std::is_same::value, "Triangle to Vector3 constructor only enabled for uint32_t"); + } + + template + inline Vector3::operator VHACD::Vertex() const + { + static_assert(std::is_same::value, "Vector3 to Vertex conversion only enable for double"); + return ::VHACD::Vertex( GetX(), GetY(), GetZ()); + } + +IVHACD* CreateVHACD(); // Create a synchronous (blocking) implementation of V-HACD +IVHACD* CreateVHACD_ASYNC(); // Create an asynchronous (non-blocking) implementation of V-HACD + +} // namespace VHACD + +#if ENABLE_VHACD_IMPLEMENTATION +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable:4100 4127 4189 4244 4456 4701 4702 4996) +#endif // _MSC_VER + +#ifdef __GNUC__ +#pragma GCC diagnostic push +// Minimum set of warnings used for cleanup +// #pragma GCC diagnostic warning "-Wall" +// #pragma GCC diagnostic warning "-Wextra" +// #pragma GCC diagnostic warning "-Wpedantic" +// #pragma GCC diagnostic warning "-Wold-style-cast" +// #pragma GCC diagnostic warning "-Wnon-virtual-dtor" +// #pragma GCC diagnostic warning "-Wshadow" +#endif // __GNUC__ + +// Scoped Timer +namespace VHACD { + +class Timer +{ +public: + Timer() + : m_startTime(std::chrono::high_resolution_clock::now()) + { + } + + void Reset() + { + m_startTime = std::chrono::high_resolution_clock::now(); + } + + double GetElapsedSeconds() + { + auto s = PeekElapsedSeconds(); + Reset(); + return s; + } + + double PeekElapsedSeconds() + { + auto now = std::chrono::high_resolution_clock::now(); + std::chrono::duration diff = now - m_startTime; + return diff.count(); + } + +private: + std::chrono::time_point m_startTime; +}; + +class ScopedTime +{ +public: + ScopedTime(const char* action, + VHACD::IVHACD::IUserLogger* logger) + : m_action(action) + , m_logger(logger) + { + m_timer.Reset(); + } + + ~ScopedTime() + { + double dtime = m_timer.GetElapsedSeconds(); + if( m_logger ) + { + char scratch[512]; + snprintf(scratch, + sizeof(scratch),"%s took %0.5f seconds", + m_action, + dtime); + m_logger->Log(scratch); + } + } + + const char* m_action{ nullptr }; + Timer m_timer; + VHACD::IVHACD::IUserLogger* m_logger{ nullptr }; +}; +BoundsAABB::BoundsAABB(const std::vector& points) + : m_min(points[0]) + , m_max(points[0]) +{ + for (uint32_t i = 1; i < points.size(); ++i) + { + const VHACD::Vertex& p = points[i]; + m_min = m_min.CWiseMin(p); + m_max = m_max.CWiseMax(p); + } +} + +BoundsAABB::BoundsAABB(const VHACD::Vect3& min, + const VHACD::Vect3& max) + : m_min(min) + , m_max(max) +{ +} + +BoundsAABB BoundsAABB::Union(const BoundsAABB& b) +{ + return BoundsAABB(GetMin().CWiseMin(b.GetMin()), + GetMax().CWiseMax(b.GetMax())); +} + +bool VHACD::BoundsAABB::Intersects(const VHACD::BoundsAABB& b) const +{ + if ( ( GetMin().GetX() > b.GetMax().GetX()) + || (b.GetMin().GetX() > GetMax().GetX())) + return false; + if ( ( GetMin().GetY() > b.GetMax().GetY()) + || (b.GetMin().GetY() > GetMax().GetY())) + return false; + if ( ( GetMin().GetZ() > b.GetMax().GetZ()) + || (b.GetMin().GetZ() > GetMax().GetZ())) + return false; + return true; +} + +double BoundsAABB::SurfaceArea() const +{ + VHACD::Vect3 d = GetMax() - GetMin(); + return double(2.0) * (d.GetX() * d.GetY() + d.GetX() * d.GetZ() + d.GetY() * d.GetZ()); +} + +double VHACD::BoundsAABB::Volume() const +{ + VHACD::Vect3 d = GetMax() - GetMin(); + return d.GetX() * d.GetY() * d.GetZ(); +} + +BoundsAABB VHACD::BoundsAABB::Inflate(double ratio) const +{ + double inflate = (GetMin() - GetMax()).GetNorm() * double(0.5) * ratio; + return BoundsAABB(GetMin() - inflate, + GetMax() + inflate); +} + +VHACD::Vect3 VHACD::BoundsAABB::ClosestPoint(const VHACD::Vect3& p) const +{ + return p.CWiseMax(GetMin()).CWiseMin(GetMax()); +} + +VHACD::Vect3& VHACD::BoundsAABB::GetMin() +{ + return m_min; +} + +VHACD::Vect3& VHACD::BoundsAABB::GetMax() +{ + return m_max; +} + +inline const VHACD::Vect3& VHACD::BoundsAABB::GetMin() const +{ + return m_min; +} + +const VHACD::Vect3& VHACD::BoundsAABB::GetMax() const +{ + return m_max; +} + +VHACD::Vect3 VHACD::BoundsAABB::GetSize() const +{ + return GetMax() - GetMin(); +} + +VHACD::Vect3 VHACD::BoundsAABB::GetCenter() const +{ + return (GetMin() + GetMax()) * double(0.5); +} + +/* + * Relies on three way comparison, which std::sort doesn't use + */ +template +void Sort(T* const array, int elements) +{ + const int batchSize = 8; + int stack[1024][2]; + + stack[0][0] = 0; + stack[0][1] = elements - 1; + int stackIndex = 1; + const dCompareKey comparator; + while (stackIndex) + { + stackIndex--; + int lo = stack[stackIndex][0]; + int hi = stack[stackIndex][1]; + if ((hi - lo) > batchSize) + { + int mid = (lo + hi) >> 1; + if (comparator.Compare(array[lo], array[mid]) > 0) + { + std::swap(array[lo], + array[mid]); + } + if (comparator.Compare(array[mid], array[hi]) > 0) + { + std::swap(array[mid], + array[hi]); + } + if (comparator.Compare(array[lo], array[mid]) > 0) + { + std::swap(array[lo], + array[mid]); + } + int i = lo + 1; + int j = hi - 1; + const T pivot(array[mid]); + do + { + while (comparator.Compare(array[i], pivot) < 0) + { + i++; + } + while (comparator.Compare(array[j], pivot) > 0) + { + j--; + } + + if (i <= j) + { + std::swap(array[i], + array[j]); + i++; + j--; + } + } while (i <= j); + + if (i < hi) + { + stack[stackIndex][0] = i; + stack[stackIndex][1] = hi; + stackIndex++; + } + if (lo < j) + { + stack[stackIndex][0] = lo; + stack[stackIndex][1] = j; + stackIndex++; + } + assert(stackIndex < int(sizeof(stack) / (2 * sizeof(stack[0][0])))); + } + } + + int stride = batchSize + 1; + if (elements < stride) + { + stride = elements; + } + for (int i = 1; i < stride; ++i) + { + if (comparator.Compare(array[0], array[i]) > 0) + { + std::swap(array[0], + array[i]); + } + } + + for (int i = 1; i < elements; ++i) + { + int j = i; + const T tmp(array[i]); + for (; comparator.Compare(array[j - 1], tmp) > 0; --j) + { + assert(j > 0); + array[j] = array[j - 1]; + } + array[j] = tmp; + } +} + +/* +Maintaining comment due to attribution +Purpose: + +TRIANGLE_AREA_3D computes the area of a triangle in 3D. + +Modified: + +22 April 1999 + +Author: + +John Burkardt + +Parameters: + +Input, double X1, Y1, Z1, X2, Y2, Z2, X3, Y3, Z3, the (getX,getY,getZ) +coordinates of the corners of the triangle. + +Output, double TRIANGLE_AREA_3D, the area of the triangle. +*/ +double ComputeArea(const VHACD::Vect3& p1, + const VHACD::Vect3& p2, + const VHACD::Vect3& p3) +{ + /* + Find the projection of (P3-P1) onto (P2-P1). + */ + double base = (p2 - p1).GetNorm(); + /* + The height of the triangle is the length of (P3-P1) after its + projection onto (P2-P1) has been subtracted. + */ + double height; + if (base == double(0.0)) + { + height = double(0.0); + } + else + { + double dot = (p3 - p1).Dot(p2 - p1); + double alpha = dot / (base * base); + + VHACD::Vect3 a = p3 - p1 - alpha * (p2 - p1); + height = a.GetNorm(); + } + + return double(0.5) * base * height; +} + +bool ComputeCentroid(const std::vector& points, + const std::vector& indices, + VHACD::Vect3& center) + +{ + bool ret = false; + if (points.size()) + { + center = VHACD::Vect3(0); + + VHACD::Vect3 numerator(0); + double denominator = 0; + + for (uint32_t i = 0; i < indices.size(); i++) + { + uint32_t i1 = indices[i].mI0; + uint32_t i2 = indices[i].mI1; + uint32_t i3 = indices[i].mI2; + + const VHACD::Vect3& p1 = points[i1]; + const VHACD::Vect3& p2 = points[i2]; + const VHACD::Vect3& p3 = points[i3]; + + // Compute the average of the sum of the three positions + VHACD::Vect3 sum = (p1 + p2 + p3) / 3; + + // Compute the area of this triangle + double area = ComputeArea(p1, + p2, + p3); + + numerator += (sum * area); + + denominator += area; + } + double recip = 1 / denominator; + center = numerator * recip; + ret = true; + } + return ret; +} + +double Determinant3x3(const std::array& matrix, + double& error) +{ + double det = double(0.0); + error = double(0.0); + + double a01xa12 = matrix[0].GetY() * matrix[1].GetZ(); + double a02xa11 = matrix[0].GetZ() * matrix[1].GetY(); + error += (std::abs(a01xa12) + std::abs(a02xa11)) * std::abs(matrix[2].GetX()); + det += (a01xa12 - a02xa11) * matrix[2].GetX(); + + double a00xa12 = matrix[0].GetX() * matrix[1].GetZ(); + double a02xa10 = matrix[0].GetZ() * matrix[1].GetX(); + error += (std::abs(a00xa12) + std::abs(a02xa10)) * std::abs(matrix[2].GetY()); + det -= (a00xa12 - a02xa10) * matrix[2].GetY(); + + double a00xa11 = matrix[0].GetX() * matrix[1].GetY(); + double a01xa10 = matrix[0].GetY() * matrix[1].GetX(); + error += (std::abs(a00xa11) + std::abs(a01xa10)) * std::abs(matrix[2].GetZ()); + det += (a00xa11 - a01xa10) * matrix[2].GetZ(); + + return det; +} + +double ComputeMeshVolume(const std::vector& vertices, + const std::vector& indices) +{ + double volume = 0; + for (uint32_t i = 0; i < indices.size(); i++) + { + const std::array m = { + vertices[indices[i].mI0], + vertices[indices[i].mI1], + vertices[indices[i].mI2] + }; + double placeholder; + volume += Determinant3x3(m, + placeholder); + } + + volume *= (double(1.0) / double(6.0)); + if (volume < 0) + volume *= -1; + return volume; +} + +/* + * To minimize memory allocations while maintaining pointer stability. + * Used in KdTreeNode and ConvexHull, as both use tree data structures that rely on pointer stability + * Neither rely on random access or iteration + * They just dump elements into a memory pool, then refer to pointers to the elements + * All elements are default constructed in NodeStorage's m_nodes array + */ +template +class NodeBundle +{ + struct NodeStorage { + bool IsFull() const; + + T& GetNextNode(); + + std::size_t m_index; + std::array m_nodes; + }; + + std::list m_list; + typename std::list::iterator m_head{ m_list.end() }; + +public: + T& GetNextNode(); + + T& GetFirstNode(); + + void Clear(); +}; + +template +bool NodeBundle::NodeStorage::IsFull() const +{ + return m_index == MaxBundleSize; +} + +template +T& NodeBundle::NodeStorage::GetNextNode() +{ + assert(m_index < MaxBundleSize); + T& ret = m_nodes[m_index]; + m_index++; + return ret; +} + +template +T& NodeBundle::GetNextNode() +{ + /* + * || short circuits, so doesn't dereference if m_bundle == m_bundleHead.end() + */ + if ( m_head == m_list.end() + || m_head->IsFull()) + { + m_head = m_list.emplace(m_list.end()); + } + + return m_head->GetNextNode(); +} + +template +T& NodeBundle::GetFirstNode() +{ + assert(m_head != m_list.end()); + return m_list.front().m_nodes[0]; +} + +template +void NodeBundle::Clear() +{ + m_list.clear(); +} + +/* + * Returns index of highest set bit in x + */ +inline int dExp2(int x) +{ + int exp; + for (exp = -1; x; x >>= 1) + { + exp++; + } + return exp; +} + +/* + * Reverses the order of the bits in v and returns the result + * Does not put fill any of the bits higher than the highest bit in v + * Only used to calculate index of ndNormalMap::m_normal when tessellating a triangle + */ +inline int dBitReversal(int v, + int base) +{ + int x = 0; + int power = dExp2(base) - 1; + do + { + x += (v & 1) << power; + v >>= 1; + power--; + } while (v); + return x; +} + +class Googol +{ + #define VHACD_GOOGOL_SIZE 4 +public: + Googol() = default; + Googol(double value); + + operator double() const; + Googol operator+(const Googol &A) const; + Googol operator-(const Googol &A) const; + Googol operator*(const Googol &A) const; + Googol operator/ (const Googol &A) const; + + Googol& operator+= (const Googol &A); + Googol& operator-= (const Googol &A); + + bool operator>(const Googol &A) const; + bool operator>=(const Googol &A) const; + bool operator<(const Googol &A) const; + bool operator<=(const Googol &A) const; + bool operator==(const Googol &A) const; + bool operator!=(const Googol &A) const; + + Googol Abs() const; + Googol Floor() const; + Googol InvSqrt() const; + Googol Sqrt() const; + + void ToString(char* const string) const; + +private: + void NegateMantissa(std::array& mantissa) const; + void CopySignedMantissa(std::array& mantissa) const; + int NormalizeMantissa(std::array& mantissa) const; + void ShiftRightMantissa(std::array& mantissa, + int bits) const; + uint64_t CheckCarrier(uint64_t a, uint64_t b) const; + + int LeadingZeros(uint64_t a) const; + void ExtendedMultiply(uint64_t a, + uint64_t b, + uint64_t& high, + uint64_t& low) const; + void ScaleMantissa(uint64_t* out, + uint64_t scale) const; + + int m_sign{ 0 }; + int m_exponent{ 0 }; + std::array m_mantissa{ 0 }; + +public: + static Googol m_zero; + static Googol m_one; + static Googol m_two; + static Googol m_three; + static Googol m_half; +}; + +Googol Googol::m_zero(double(0.0)); +Googol Googol::m_one(double(1.0)); +Googol Googol::m_two(double(2.0)); +Googol Googol::m_three(double(3.0)); +Googol Googol::m_half(double(0.5)); + +Googol::Googol(double value) +{ + int exp; + double mantissa = fabs(frexp(value, &exp)); + + m_exponent = exp; + m_sign = (value >= 0) ? 0 : 1; + + m_mantissa[0] = uint64_t(double(uint64_t(1) << 62) * mantissa); +} + +Googol::operator double() const +{ + double mantissa = (double(1.0) / double(uint64_t(1) << 62)) * double(m_mantissa[0]); + mantissa = ldexp(mantissa, m_exponent) * (m_sign ? double(-1.0) : double(1.0)); + return mantissa; +} + +Googol Googol::operator+(const Googol &A) const +{ + Googol tmp; + if (m_mantissa[0] && A.m_mantissa[0]) + { + std::array mantissa0; + std::array mantissa1; + std::array mantissa; + + CopySignedMantissa(mantissa0); + A.CopySignedMantissa(mantissa1); + + int exponentDiff = m_exponent - A.m_exponent; + int exponent = m_exponent; + if (exponentDiff > 0) + { + ShiftRightMantissa(mantissa1, + exponentDiff); + } + else if (exponentDiff < 0) + { + exponent = A.m_exponent; + ShiftRightMantissa(mantissa0, + -exponentDiff); + } + + uint64_t carrier = 0; + for (int i = VHACD_GOOGOL_SIZE - 1; i >= 0; i--) + { + uint64_t m0 = mantissa0[i]; + uint64_t m1 = mantissa1[i]; + mantissa[i] = m0 + m1 + carrier; + carrier = CheckCarrier(m0, m1) | CheckCarrier(m0 + m1, carrier); + } + + int sign = 0; + if (int64_t(mantissa[0]) < 0) + { + sign = 1; + NegateMantissa(mantissa); + } + + int bits = NormalizeMantissa(mantissa); + if (bits <= (-64 * VHACD_GOOGOL_SIZE)) + { + tmp.m_sign = 0; + tmp.m_exponent = 0; + } + else + { + tmp.m_sign = sign; + tmp.m_exponent = int(exponent + bits); + } + + tmp.m_mantissa = mantissa; + } + else if (A.m_mantissa[0]) + { + tmp = A; + } + else + { + tmp = *this; + } + + return tmp; +} + +Googol Googol::operator-(const Googol &A) const +{ + Googol tmp(A); + tmp.m_sign = !tmp.m_sign; + return *this + tmp; +} + +Googol Googol::operator*(const Googol &A) const +{ + if (m_mantissa[0] && A.m_mantissa[0]) + { + std::array mantissaAcc{ 0 }; + for (int i = VHACD_GOOGOL_SIZE - 1; i >= 0; i--) + { + uint64_t a = m_mantissa[i]; + if (a) + { + uint64_t mantissaScale[2 * VHACD_GOOGOL_SIZE] = { 0 }; + A.ScaleMantissa(&mantissaScale[i], a); + + uint64_t carrier = 0; + for (int j = 0; j < 2 * VHACD_GOOGOL_SIZE; j++) + { + const int k = 2 * VHACD_GOOGOL_SIZE - 1 - j; + uint64_t m0 = mantissaAcc[k]; + uint64_t m1 = mantissaScale[k]; + mantissaAcc[k] = m0 + m1 + carrier; + carrier = CheckCarrier(m0, m1) | CheckCarrier(m0 + m1, carrier); + } + } + } + + uint64_t carrier = 0; + int bits = LeadingZeros(mantissaAcc[0]) - 2; + for (int i = 0; i < 2 * VHACD_GOOGOL_SIZE; i++) + { + const int k = 2 * VHACD_GOOGOL_SIZE - 1 - i; + uint64_t a = mantissaAcc[k]; + mantissaAcc[k] = (a << uint64_t(bits)) | carrier; + carrier = a >> uint64_t(64 - bits); + } + + int exp = m_exponent + A.m_exponent - (bits - 2); + + Googol tmp; + tmp.m_sign = m_sign ^ A.m_sign; + tmp.m_exponent = exp; + for (std::size_t i = 0; i < tmp.m_mantissa.size(); ++i) + { + tmp.m_mantissa[i] = mantissaAcc[i]; + } + + return tmp; + } + return Googol(double(0.0)); +} + +Googol Googol::operator/(const Googol &A) const +{ + Googol tmp(double(1.0) / A); + tmp = tmp * (m_two - A * tmp); + tmp = tmp * (m_two - A * tmp); + bool test = false; + int passes = 0; + do + { + passes++; + Googol tmp0(tmp); + tmp = tmp * (m_two - A * tmp); + test = tmp0 == tmp; + } while (test && (passes < (2 * VHACD_GOOGOL_SIZE))); + return (*this) * tmp; +} + +Googol& Googol::operator+=(const Googol &A) +{ + *this = *this + A; + return *this; +} + +Googol& Googol::operator-=(const Googol &A) +{ + *this = *this - A; + return *this; +} + +bool Googol::operator>(const Googol &A) const +{ + Googol tmp(*this - A); + return double(tmp) > double(0.0); +} + +bool Googol::operator>=(const Googol &A) const +{ + Googol tmp(*this - A); + return double(tmp) >= double(0.0); +} + +bool Googol::operator<(const Googol &A) const +{ + Googol tmp(*this - A); + return double(tmp) < double(0.0); +} + +bool Googol::operator<=(const Googol &A) const +{ + Googol tmp(*this - A); + return double(tmp) <= double(0.0); +} + +bool Googol::operator==(const Googol &A) const +{ + return m_sign == A.m_sign + && m_exponent == A.m_exponent + && m_mantissa == A.m_mantissa; +} + +bool Googol::operator!=(const Googol &A) const +{ + return !(*this == A); +} + +Googol Googol::Abs() const +{ + Googol tmp(*this); + tmp.m_sign = 0; + return tmp; +} + +Googol Googol::Floor() const +{ + if (m_exponent < 1) + { + return Googol(double(0.0)); + } + int bits = m_exponent + 2; + int start = 0; + while (bits >= 64) + { + bits -= 64; + start++; + } + + Googol tmp(*this); + for (int i = VHACD_GOOGOL_SIZE - 1; i > start; i--) + { + tmp.m_mantissa[i] = 0; + } + // some compilers do no like this and I do not know why is that + //uint64_t mask = (-1LL) << (64 - bits); + uint64_t mask(~0ULL); + mask <<= (64 - bits); + tmp.m_mantissa[start] &= mask; + return tmp; +} + +Googol Googol::InvSqrt() const +{ + const Googol& me = *this; + Googol x(double(1.0) / sqrt(me)); + + int test = 0; + int passes = 0; + do + { + passes++; + Googol tmp(x); + x = m_half * x * (m_three - me * x * x); + test = (x != tmp); + } while (test && (passes < (2 * VHACD_GOOGOL_SIZE))); + return x; +} + +Googol Googol::Sqrt() const +{ + return *this * InvSqrt(); +} + +void Googol::ToString(char* const string) const +{ + Googol tmp(*this); + Googol base(double(10.0)); + while (double(tmp) > double(1.0)) + { + tmp = tmp / base; + } + + int index = 0; + while (tmp.m_mantissa[0]) + { + tmp = tmp * base; + Googol digit(tmp.Floor()); + tmp -= digit; + double val = digit; + string[index] = char(val) + '0'; + index++; + } + string[index] = 0; +} + +void Googol::NegateMantissa(std::array& mantissa) const +{ + uint64_t carrier = 1; + for (size_t i = mantissa.size() - 1; i >= 0 && i < mantissa.size(); i--) + { + uint64_t a = ~mantissa[i] + carrier; + if (a) + { + carrier = 0; + } + mantissa[i] = a; + } +} + +void Googol::CopySignedMantissa(std::array& mantissa) const +{ + mantissa = m_mantissa; + if (m_sign) + { + NegateMantissa(mantissa); + } +} + +int Googol::NormalizeMantissa(std::array& mantissa) const +{ + int bits = 0; + if (int64_t(mantissa[0] * 2) < 0) + { + bits = 1; + ShiftRightMantissa(mantissa, 1); + } + else + { + while (!mantissa[0] && bits > (-64 * VHACD_GOOGOL_SIZE)) + { + bits -= 64; + for (int i = 1; i < VHACD_GOOGOL_SIZE; i++) { + mantissa[i - 1] = mantissa[i]; + } + mantissa[VHACD_GOOGOL_SIZE - 1] = 0; + } + + if (bits > (-64 * VHACD_GOOGOL_SIZE)) + { + int n = LeadingZeros(mantissa[0]) - 2; + if (n > 0) + { + uint64_t carrier = 0; + for (int i = VHACD_GOOGOL_SIZE - 1; i >= 0; i--) + { + uint64_t a = mantissa[i]; + mantissa[i] = (a << n) | carrier; + carrier = a >> (64 - n); + } + bits -= n; + } + else if (n < 0) + { + // this is very rare but it does happens, whee the leading zeros of the mantissa is an exact multiple of 64 + uint64_t carrier = 0; + int shift = -n; + for (int i = 0; i < VHACD_GOOGOL_SIZE; i++) + { + uint64_t a = mantissa[i]; + mantissa[i] = (a >> shift) | carrier; + carrier = a << (64 - shift); + } + bits -= n; + } + } + } + return bits; +} + +void Googol::ShiftRightMantissa(std::array& mantissa, + int bits) const +{ + uint64_t carrier = 0; + if (int64_t(mantissa[0]) < int64_t(0)) + { + carrier = uint64_t(-1); + } + + while (bits >= 64) + { + for (int i = VHACD_GOOGOL_SIZE - 2; i >= 0; i--) + { + mantissa[i + 1] = mantissa[i]; + } + mantissa[0] = carrier; + bits -= 64; + } + + if (bits > 0) + { + carrier <<= (64 - bits); + for (int i = 0; i < VHACD_GOOGOL_SIZE; i++) + { + uint64_t a = mantissa[i]; + mantissa[i] = (a >> bits) | carrier; + carrier = a << (64 - bits); + } + } +} + +uint64_t Googol::CheckCarrier(uint64_t a, uint64_t b) const +{ + return ((uint64_t(-1) - b) < a) ? uint64_t(1) : 0; +} + +int Googol::LeadingZeros(uint64_t a) const +{ + #define VHACD_COUNTBIT(mask, add) \ + do { \ + uint64_t test = a & mask; \ + n += test ? 0 : add; \ + a = test ? test : (a & ~mask); \ + } while (false) + + int n = 0; + VHACD_COUNTBIT(0xffffffff00000000LL, 32); + VHACD_COUNTBIT(0xffff0000ffff0000LL, 16); + VHACD_COUNTBIT(0xff00ff00ff00ff00LL, 8); + VHACD_COUNTBIT(0xf0f0f0f0f0f0f0f0LL, 4); + VHACD_COUNTBIT(0xccccccccccccccccLL, 2); + VHACD_COUNTBIT(0xaaaaaaaaaaaaaaaaLL, 1); + + return n; +} + +void Googol::ExtendedMultiply(uint64_t a, + uint64_t b, + uint64_t& high, + uint64_t& low) const +{ + uint64_t bLow = b & 0xffffffff; + uint64_t bHigh = b >> 32; + uint64_t aLow = a & 0xffffffff; + uint64_t aHigh = a >> 32; + + uint64_t l = bLow * aLow; + + uint64_t c1 = bHigh * aLow; + uint64_t c2 = bLow * aHigh; + uint64_t m = c1 + c2; + uint64_t carrier = CheckCarrier(c1, c2) << 32; + + uint64_t h = bHigh * aHigh + carrier; + + uint64_t ml = m << 32; + uint64_t ll = l + ml; + uint64_t mh = (m >> 32) + CheckCarrier(l, ml); + uint64_t hh = h + mh; + + low = ll; + high = hh; +} + +void Googol::ScaleMantissa(uint64_t* dst, + uint64_t scale) const +{ + uint64_t carrier = 0; + for (int i = VHACD_GOOGOL_SIZE - 1; i >= 0; i--) + { + if (m_mantissa[i]) + { + uint64_t low; + uint64_t high; + ExtendedMultiply(scale, + m_mantissa[i], + high, + low); + uint64_t acc = low + carrier; + carrier = CheckCarrier(low, + carrier); + carrier += high; + dst[i + 1] = acc; + } + else + { + dst[i + 1] = carrier; + carrier = 0; + } + + } + dst[0] = carrier; +} + +Googol Determinant3x3(const std::array, 3>& matrix) +{ + Googol det = double(0.0); + + Googol a01xa12 = matrix[0].GetY() * matrix[1].GetZ(); + Googol a02xa11 = matrix[0].GetZ() * matrix[1].GetY(); + det += (a01xa12 - a02xa11) * matrix[2].GetX(); + + Googol a00xa12 = matrix[0].GetX() * matrix[1].GetZ(); + Googol a02xa10 = matrix[0].GetZ() * matrix[1].GetX(); + det -= (a00xa12 - a02xa10) * matrix[2].GetY(); + + Googol a00xa11 = matrix[0].GetX() * matrix[1].GetY(); + Googol a01xa10 = matrix[0].GetY() * matrix[1].GetX(); + det += (a00xa11 - a01xa10) * matrix[2].GetZ(); + return det; +} + +class HullPlane : public VHACD::Vect3 +{ +public: + HullPlane(const HullPlane&) = default; + HullPlane(double x, + double y, + double z, + double w); + + HullPlane(const VHACD::Vect3& p, + double w); + + HullPlane(const VHACD::Vect3& p0, + const VHACD::Vect3& p1, + const VHACD::Vect3& p2); + + HullPlane Scale(double s) const; + + HullPlane& operator=(const HullPlane& rhs); + + double Evalue(const VHACD::Vect3 &point) const; + + double& GetW(); + const double& GetW() const; + +private: + double m_w; +}; + +HullPlane::HullPlane(double x, + double y, + double z, + double w) + : VHACD::Vect3(x, y, z) + , m_w(w) +{ +} + +HullPlane::HullPlane(const VHACD::Vect3& p, + double w) + : VHACD::Vect3(p) + , m_w(w) +{ +} + +HullPlane::HullPlane(const VHACD::Vect3& p0, + const VHACD::Vect3& p1, + const VHACD::Vect3& p2) + : VHACD::Vect3((p1 - p0).Cross(p2 - p0)) + , m_w(-Dot(p0)) +{ +} + +HullPlane HullPlane::Scale(double s) const +{ + return HullPlane(*this * s, + m_w * s); +} + +HullPlane& HullPlane::operator=(const HullPlane& rhs) +{ + GetX() = rhs.GetX(); + GetY() = rhs.GetY(); + GetZ() = rhs.GetZ(); + m_w = rhs.m_w; + return *this; +} + +double HullPlane::Evalue(const VHACD::Vect3& point) const +{ + return Dot(point) + m_w; +} + +double& HullPlane::GetW() +{ + return m_w; +} + +const double& HullPlane::GetW() const +{ + return m_w; +} + +class ConvexHullFace +{ +public: + ConvexHullFace() = default; + double Evalue(const std::vector& pointArray, + const VHACD::Vect3& point) const; + HullPlane GetPlaneEquation(const std::vector& pointArray, + bool& isValid) const; + + std::array m_index; +private: + int m_mark{ 0 }; + std::array::iterator, 3> m_twin; + + friend class ConvexHull; +}; + +double ConvexHullFace::Evalue(const std::vector& pointArray, + const VHACD::Vect3& point) const +{ + const VHACD::Vect3& p0 = pointArray[m_index[0]]; + const VHACD::Vect3& p1 = pointArray[m_index[1]]; + const VHACD::Vect3& p2 = pointArray[m_index[2]]; + + std::array matrix = { p2 - p0, p1 - p0, point - p0 }; + double error; + double det = Determinant3x3(matrix, + error); + + // the code use double, however the threshold for accuracy test is the machine precision of a float. + // by changing this to a smaller number, the code should run faster since many small test will be considered valid + // the precision must be a power of two no smaller than the machine precision of a double, (1<<48) + // float64(1<<30) can be a good value + + // double precision = double (1.0f) / double (1<<30); + double precision = double(1.0) / double(1 << 24); + double errbound = error * precision; + if (fabs(det) > errbound) + { + return det; + } + + const VHACD::Vector3 p0g = pointArray[m_index[0]]; + const VHACD::Vector3 p1g = pointArray[m_index[1]]; + const VHACD::Vector3 p2g = pointArray[m_index[2]]; + const VHACD::Vector3 pointg = point; + std::array, 3> exactMatrix = { p2g - p0g, p1g - p0g, pointg - p0g }; + return Determinant3x3(exactMatrix); +} + +HullPlane ConvexHullFace::GetPlaneEquation(const std::vector& pointArray, + bool& isvalid) const +{ + const VHACD::Vect3& p0 = pointArray[m_index[0]]; + const VHACD::Vect3& p1 = pointArray[m_index[1]]; + const VHACD::Vect3& p2 = pointArray[m_index[2]]; + HullPlane plane(p0, p1, p2); + + isvalid = false; + double mag2 = plane.Dot(plane); + if (mag2 > double(1.0e-16)) + { + isvalid = true; + plane = plane.Scale(double(1.0) / sqrt(mag2)); + } + return plane; +} + +class ConvexHullVertex : public VHACD::Vect3 +{ +public: + ConvexHullVertex() = default; + ConvexHullVertex(const ConvexHullVertex&) = default; + ConvexHullVertex& operator=(const ConvexHullVertex& rhs) = default; + using VHACD::Vect3::operator=; + + int m_mark{ 0 }; +}; + + +class ConvexHullAABBTreeNode +{ + #define VHACD_CONVEXHULL_3D_VERTEX_CLUSTER_SIZE 8 +public: + ConvexHullAABBTreeNode() = default; + ConvexHullAABBTreeNode(ConvexHullAABBTreeNode* parent); + + VHACD::Vect3 m_box[2]; + ConvexHullAABBTreeNode* m_left{ nullptr }; + ConvexHullAABBTreeNode* m_right{ nullptr }; + ConvexHullAABBTreeNode* m_parent{ nullptr }; + + size_t m_count; + std::array m_indices; +}; + +ConvexHullAABBTreeNode::ConvexHullAABBTreeNode(ConvexHullAABBTreeNode* parent) + : m_parent(parent) +{ +} + +class ConvexHull +{ + class ndNormalMap; + +public: + ConvexHull(const ConvexHull& source); + ConvexHull(const std::vector<::VHACD::Vertex>& vertexCloud, + double distTol, + int maxVertexCount = 0x7fffffff); + ~ConvexHull() = default; + + const std::vector& GetVertexPool() const; + + const std::list& GetList() const { return m_list; } + +private: + void BuildHull(const std::vector<::VHACD::Vertex>& vertexCloud, + double distTol, + int maxVertexCount); + + void GetUniquePoints(std::vector& points); + int InitVertexArray(std::vector& points, + NodeBundle& memoryPool); + + ConvexHullAABBTreeNode* BuildTreeNew(std::vector& points, + std::vector& memoryPool) const; + ConvexHullAABBTreeNode* BuildTreeOld(std::vector& points, + NodeBundle& memoryPool); + ConvexHullAABBTreeNode* BuildTreeRecurse(ConvexHullAABBTreeNode* const parent, + ConvexHullVertex* const points, + int count, + int baseIndex, + NodeBundle& memoryPool) const; + + std::list::iterator AddFace(int i0, + int i1, + int i2); + + void CalculateConvexHull3D(ConvexHullAABBTreeNode* vertexTree, + std::vector& points, + int count, + double distTol, + int maxVertexCount); + + int SupportVertex(ConvexHullAABBTreeNode** const tree, + const std::vector& points, + const VHACD::Vect3& dir, + const bool removeEntry = true) const; + double TetrahedrumVolume(const VHACD::Vect3& p0, + const VHACD::Vect3& p1, + const VHACD::Vect3& p2, + const VHACD::Vect3& p3) const; + + std::list m_list; + VHACD::Vect3 m_aabbP0{ 0 }; + VHACD::Vect3 m_aabbP1{ 0 }; + double m_diag{ 0.0 }; + std::vector m_points; +}; + +class ConvexHull::ndNormalMap +{ +public: + ndNormalMap(); + + static const ndNormalMap& GetNormalMap(); + + void TessellateTriangle(int level, + const VHACD::Vect3& p0, + const VHACD::Vect3& p1, + const VHACD::Vect3& p2, + int& count); + + std::array m_normal; + int m_count{ 128 }; +}; + +const ConvexHull::ndNormalMap& ConvexHull::ndNormalMap::GetNormalMap() +{ + static ndNormalMap normalMap; + return normalMap; +} + +void ConvexHull::ndNormalMap::TessellateTriangle(int level, + const VHACD::Vect3& p0, + const VHACD::Vect3& p1, + const VHACD::Vect3& p2, + int& count) +{ + if (level) + { + assert(fabs(p0.Dot(p0) - double(1.0)) < double(1.0e-4)); + assert(fabs(p1.Dot(p1) - double(1.0)) < double(1.0e-4)); + assert(fabs(p2.Dot(p2) - double(1.0)) < double(1.0e-4)); + VHACD::Vect3 p01(p0 + p1); + VHACD::Vect3 p12(p1 + p2); + VHACD::Vect3 p20(p2 + p0); + + p01 = p01 * (double(1.0) / p01.GetNorm()); + p12 = p12 * (double(1.0) / p12.GetNorm()); + p20 = p20 * (double(1.0) / p20.GetNorm()); + + assert(fabs(p01.GetNormSquared() - double(1.0)) < double(1.0e-4)); + assert(fabs(p12.GetNormSquared() - double(1.0)) < double(1.0e-4)); + assert(fabs(p20.GetNormSquared() - double(1.0)) < double(1.0e-4)); + + TessellateTriangle(level - 1, p0, p01, p20, count); + TessellateTriangle(level - 1, p1, p12, p01, count); + TessellateTriangle(level - 1, p2, p20, p12, count); + TessellateTriangle(level - 1, p01, p12, p20, count); + } + else + { + /* + * This is just m_normal[index] = n.Normalized(), but due to tiny floating point errors, causes + * different outputs, so I'm leaving it + */ + HullPlane n(p0, p1, p2); + n = n.Scale(double(1.0) / n.GetNorm()); + n.GetW() = double(0.0); + int index = dBitReversal(count, + int(m_normal.size())); + m_normal[index] = n; + count++; + assert(count <= int(m_normal.size())); + } +} + +ConvexHull::ndNormalMap::ndNormalMap() +{ + VHACD::Vect3 p0(double( 1.0), double( 0.0), double( 0.0)); + VHACD::Vect3 p1(double(-1.0), double( 0.0), double( 0.0)); + VHACD::Vect3 p2(double( 0.0), double( 1.0), double( 0.0)); + VHACD::Vect3 p3(double( 0.0), double(-1.0), double( 0.0)); + VHACD::Vect3 p4(double( 0.0), double( 0.0), double( 1.0)); + VHACD::Vect3 p5(double( 0.0), double( 0.0), double(-1.0)); + + int count = 0; + int subdivisions = 2; + TessellateTriangle(subdivisions, p4, p0, p2, count); + TessellateTriangle(subdivisions, p0, p5, p2, count); + TessellateTriangle(subdivisions, p5, p1, p2, count); + TessellateTriangle(subdivisions, p1, p4, p2, count); + TessellateTriangle(subdivisions, p0, p4, p3, count); + TessellateTriangle(subdivisions, p5, p0, p3, count); + TessellateTriangle(subdivisions, p1, p5, p3, count); + TessellateTriangle(subdivisions, p4, p1, p3, count); +} + +ConvexHull::ConvexHull(const std::vector<::VHACD::Vertex>& vertexCloud, + double distTol, + int maxVertexCount) +{ + if (vertexCloud.size() >= 4) + { + BuildHull(vertexCloud, + distTol, + maxVertexCount); + } +} + +const std::vector& ConvexHull::GetVertexPool() const +{ + return m_points; +} + +void ConvexHull::BuildHull(const std::vector<::VHACD::Vertex>& vertexCloud, + double distTol, + int maxVertexCount) +{ + size_t treeCount = vertexCloud.size() / (VHACD_CONVEXHULL_3D_VERTEX_CLUSTER_SIZE >> 1); + treeCount = std::max(treeCount, size_t(4)) * 2; + + std::vector points(vertexCloud.size()); + /* + * treePool provides a memory pool for the AABB tree + * Each node is either a leaf or non-leaf node + * Non-leaf nodes have up to 8 vertices + * Vertices are specified by the m_indices array and are accessed via the points array + * + * Later on in ConvexHull::SupportVertex, the tree is used directly + * It differentiates between ConvexHullAABBTreeNode and ConvexHull3DPointCluster by whether the m_left and m_right + * pointers are null or not + * + * Pointers have to be stable + */ + NodeBundle treePool; + for (size_t i = 0; i < vertexCloud.size(); ++i) + { + points[i] = VHACD::Vect3(vertexCloud[i]); + } + int count = InitVertexArray(points, + treePool); + + if (m_points.size() >= 4) + { + CalculateConvexHull3D(&treePool.GetFirstNode(), + points, + count, + distTol, + maxVertexCount); + } +} + +void ConvexHull::GetUniquePoints(std::vector& points) +{ + class CompareVertex + { + public: + int Compare(const ConvexHullVertex& elementA, const ConvexHullVertex& elementB) const + { + for (int i = 0; i < 3; i++) + { + if (elementA[i] < elementB[i]) + { + return -1; + } + else if (elementA[i] > elementB[i]) + { + return 1; + } + } + return 0; + } + }; + + int count = int(points.size()); + Sort(points.data(), + count); + + int indexCount = 0; + CompareVertex compareVertex; + for (int i = 1; i < count; ++i) + { + for (; i < count; ++i) + { + if (compareVertex.Compare(points[indexCount], points[i])) + { + indexCount++; + points[indexCount] = points[i]; + break; + } + } + } + points.resize(indexCount + 1); +} + +ConvexHullAABBTreeNode* ConvexHull::BuildTreeRecurse(ConvexHullAABBTreeNode* const parent, + ConvexHullVertex* const points, + int count, + int baseIndex, + NodeBundle& memoryPool) const +{ + ConvexHullAABBTreeNode* tree = nullptr; + + assert(count); + VHACD::Vect3 minP( double(1.0e15)); + VHACD::Vect3 maxP(-double(1.0e15)); + if (count <= VHACD_CONVEXHULL_3D_VERTEX_CLUSTER_SIZE) + { + ConvexHullAABBTreeNode& clump = memoryPool.GetNextNode(); + + clump.m_count = count; + for (int i = 0; i < count; ++i) + { + clump.m_indices[i] = i + baseIndex; + + const VHACD::Vect3& p = points[i]; + minP = minP.CWiseMin(p); + maxP = maxP.CWiseMax(p); + } + + clump.m_left = nullptr; + clump.m_right = nullptr; + tree = &clump; + } + else + { + VHACD::Vect3 median(0); + VHACD::Vect3 varian(0); + for (int i = 0; i < count; ++i) + { + const VHACD::Vect3& p = points[i]; + minP = minP.CWiseMin(p); + maxP = maxP.CWiseMax(p); + median += p; + varian += p.CWiseMul(p); + } + + varian = varian * double(count) - median.CWiseMul(median); + int index = 0; + double maxVarian = double(-1.0e10); + for (int i = 0; i < 3; ++i) + { + if (varian[i] > maxVarian) + { + index = i; + maxVarian = varian[i]; + } + } + VHACD::Vect3 center(median * (double(1.0) / double(count))); + + double test = center[index]; + + int i0 = 0; + int i1 = count - 1; + do + { + for (; i0 <= i1; i0++) + { + double val = points[i0][index]; + if (val > test) + { + break; + } + } + + for (; i1 >= i0; i1--) + { + double val = points[i1][index]; + if (val < test) + { + break; + } + } + + if (i0 < i1) + { + std::swap(points[i0], + points[i1]); + i0++; + i1--; + } + } while (i0 <= i1); + + if (i0 == 0) + { + i0 = count / 2; + } + if (i0 >= (count - 1)) + { + i0 = count / 2; + } + + tree = &memoryPool.GetNextNode(); + + assert(i0); + assert(count - i0); + + tree->m_left = BuildTreeRecurse(tree, + points, + i0, + baseIndex, + memoryPool); + tree->m_right = BuildTreeRecurse(tree, + &points[i0], + count - i0, + i0 + baseIndex, + memoryPool); + } + + assert(tree); + tree->m_parent = parent; + /* + * WARNING: Changing the compiler conversion of 1.0e-3f changes the results of the convex decomposition + * Inflate the tree's bounding box slightly + */ + tree->m_box[0] = minP - VHACD::Vect3(double(1.0e-3f)); + tree->m_box[1] = maxP + VHACD::Vect3(double(1.0e-3f)); + return tree; +} + +ConvexHullAABBTreeNode* ConvexHull::BuildTreeOld(std::vector& points, + NodeBundle& memoryPool) +{ + GetUniquePoints(points); + int count = int(points.size()); + if (count < 4) + { + return nullptr; + } + return BuildTreeRecurse(nullptr, + points.data(), + count, + 0, + memoryPool); +} + +ConvexHullAABBTreeNode* ConvexHull::BuildTreeNew(std::vector& points, + std::vector& memoryPool) const +{ + class dCluster + { + public: + VHACD::Vect3 m_sum{ double(0.0) }; + VHACD::Vect3 m_sum2{ double(0.0) }; + int m_start{ 0 }; + int m_count{ 0 }; + }; + + dCluster firstCluster; + firstCluster.m_count = int(points.size()); + + for (int i = 0; i < firstCluster.m_count; ++i) + { + const VHACD::Vect3& p = points[i]; + firstCluster.m_sum += p; + firstCluster.m_sum2 += p.CWiseMul(p); + } + + int baseCount = 0; + const int clusterSize = 16; + + if (firstCluster.m_count > clusterSize) + { + dCluster spliteStack[128]; + spliteStack[0] = firstCluster; + size_t stack = 1; + + while (stack) + { + stack--; + dCluster cluster (spliteStack[stack]); + + const VHACD::Vect3 origin(cluster.m_sum * (double(1.0) / cluster.m_count)); + const VHACD::Vect3 variance2(cluster.m_sum2 * (double(1.0) / cluster.m_count) - origin.CWiseMul(origin)); + double maxVariance2 = variance2.MaxCoeff(); + + if ( (cluster.m_count <= clusterSize) + || (stack > (sizeof(spliteStack) / sizeof(spliteStack[0]) - 4)) + || (maxVariance2 < 1.e-4f)) + { + // no sure if this is beneficial, + // the array is so small that seem too much overhead + //int maxIndex = 0; + //double min_x = 1.0e20f; + //for (int i = 0; i < cluster.m_count; ++i) + //{ + // if (points[cluster.m_start + i].getX() < min_x) + // { + // maxIndex = i; + // min_x = points[cluster.m_start + i].getX(); + // } + //} + //Swap(points[cluster.m_start], points[cluster.m_start + maxIndex]); + // + //for (int i = 2; i < cluster.m_count; ++i) + //{ + // int j = i; + // ConvexHullVertex tmp(points[cluster.m_start + i]); + // for (; points[cluster.m_start + j - 1].getX() > tmp.getX(); --j) + // { + // assert(j > 0); + // points[cluster.m_start + j] = points[cluster.m_start + j - 1]; + // } + // points[cluster.m_start + j] = tmp; + //} + + int count = cluster.m_count; + for (int i = cluster.m_count - 1; i > 0; --i) + { + for (int j = i - 1; j >= 0; --j) + { + VHACD::Vect3 error(points[cluster.m_start + j] - points[cluster.m_start + i]); + double mag2 = error.Dot(error); + if (mag2 < double(1.0e-6)) + { + points[cluster.m_start + j] = points[cluster.m_start + i]; + count--; + break; + } + } + } + + assert(baseCount <= cluster.m_start); + for (int i = 0; i < count; ++i) + { + points[baseCount] = points[cluster.m_start + i]; + baseCount++; + } + } + else + { + const int firstSortAxis = variance2.LongestAxis(); + double axisVal = origin[firstSortAxis]; + + int i0 = 0; + int i1 = cluster.m_count - 1; + + const int start = cluster.m_start; + while (i0 < i1) + { + while ( (points[start + i0][firstSortAxis] <= axisVal) + && (i0 < i1)) + { + ++i0; + }; + + while ( (points[start + i1][firstSortAxis] > axisVal) + && (i0 < i1)) + { + --i1; + } + + assert(i0 <= i1); + if (i0 < i1) + { + std::swap(points[start + i0], + points[start + i1]); + ++i0; + --i1; + } + } + + while ( (points[start + i0][firstSortAxis] <= axisVal) + && (i0 < cluster.m_count)) + { + ++i0; + }; + + #ifdef _DEBUG + for (int i = 0; i < i0; ++i) + { + assert(points[start + i][firstSortAxis] <= axisVal); + } + + for (int i = i0; i < cluster.m_count; ++i) + { + assert(points[start + i][firstSortAxis] > axisVal); + } + #endif + + VHACD::Vect3 xc(0); + VHACD::Vect3 x2c(0); + for (int i = 0; i < i0; ++i) + { + const VHACD::Vect3& x = points[start + i]; + xc += x; + x2c += x.CWiseMul(x); + } + + dCluster cluster_i1(cluster); + cluster_i1.m_start = start + i0; + cluster_i1.m_count = cluster.m_count - i0; + cluster_i1.m_sum -= xc; + cluster_i1.m_sum2 -= x2c; + spliteStack[stack] = cluster_i1; + assert(cluster_i1.m_count > 0); + stack++; + + dCluster cluster_i0(cluster); + cluster_i0.m_start = start; + cluster_i0.m_count = i0; + cluster_i0.m_sum = xc; + cluster_i0.m_sum2 = x2c; + assert(cluster_i0.m_count > 0); + spliteStack[stack] = cluster_i0; + stack++; + } + } + } + + points.resize(baseCount); + if (baseCount < 4) + { + return nullptr; + } + + VHACD::Vect3 sum(0); + VHACD::Vect3 sum2(0); + VHACD::Vect3 minP(double( 1.0e15)); + VHACD::Vect3 maxP(double(-1.0e15)); + class dTreeBox + { + public: + VHACD::Vect3 m_min; + VHACD::Vect3 m_max; + VHACD::Vect3 m_sum; + VHACD::Vect3 m_sum2; + ConvexHullAABBTreeNode* m_parent; + ConvexHullAABBTreeNode** m_child; + int m_start; + int m_count; + }; + + for (int i = 0; i < baseCount; ++i) + { + const VHACD::Vect3& p = points[i]; + sum += p; + sum2 += p.CWiseMul(p); + minP = minP.CWiseMin(p); + maxP = maxP.CWiseMax(p); + } + + dTreeBox treeBoxStack[128]; + treeBoxStack[0].m_start = 0; + treeBoxStack[0].m_count = baseCount; + treeBoxStack[0].m_sum = sum; + treeBoxStack[0].m_sum2 = sum2; + treeBoxStack[0].m_min = minP; + treeBoxStack[0].m_max = maxP; + treeBoxStack[0].m_child = nullptr; + treeBoxStack[0].m_parent = nullptr; + + int stack = 1; + ConvexHullAABBTreeNode* root = nullptr; + while (stack) + { + stack--; + dTreeBox box(treeBoxStack[stack]); + if (box.m_count <= VHACD_CONVEXHULL_3D_VERTEX_CLUSTER_SIZE) + { + assert(memoryPool.size() != memoryPool.capacity() + && "memoryPool is going to be reallocated, pointers will be invalid"); + memoryPool.emplace_back(); + ConvexHullAABBTreeNode& clump = memoryPool.back(); + + clump.m_count = box.m_count; + for (int i = 0; i < box.m_count; ++i) + { + clump.m_indices[i] = i + box.m_start; + } + clump.m_box[0] = box.m_min; + clump.m_box[1] = box.m_max; + + if (box.m_child) + { + *box.m_child = &clump; + } + + if (!root) + { + root = &clump; + } + } + else + { + const VHACD::Vect3 origin(box.m_sum * (double(1.0) / box.m_count)); + const VHACD::Vect3 variance2(box.m_sum2 * (double(1.0) / box.m_count) - origin.CWiseMul(origin)); + + int firstSortAxis = 0; + if ((variance2.GetY() >= variance2.GetX()) && (variance2.GetY() >= variance2.GetZ())) + { + firstSortAxis = 1; + } + else if ((variance2.GetZ() >= variance2.GetX()) && (variance2.GetZ() >= variance2.GetY())) + { + firstSortAxis = 2; + } + double axisVal = origin[firstSortAxis]; + + int i0 = 0; + int i1 = box.m_count - 1; + + const int start = box.m_start; + while (i0 < i1) + { + while ((points[start + i0][firstSortAxis] <= axisVal) && (i0 < i1)) + { + ++i0; + }; + + while ((points[start + i1][firstSortAxis] > axisVal) && (i0 < i1)) + { + --i1; + } + + assert(i0 <= i1); + if (i0 < i1) + { + std::swap(points[start + i0], + points[start + i1]); + ++i0; + --i1; + } + } + + while ((points[start + i0][firstSortAxis] <= axisVal) && (i0 < box.m_count)) + { + ++i0; + }; + + #ifdef _DEBUG + for (int i = 0; i < i0; ++i) + { + assert(points[start + i][firstSortAxis] <= axisVal); + } + + for (int i = i0; i < box.m_count; ++i) + { + assert(points[start + i][firstSortAxis] > axisVal); + } + #endif + + assert(memoryPool.size() != memoryPool.capacity() + && "memoryPool is going to be reallocated, pointers will be invalid"); + memoryPool.emplace_back(); + ConvexHullAABBTreeNode& node = memoryPool.back(); + + node.m_box[0] = box.m_min; + node.m_box[1] = box.m_max; + if (box.m_child) + { + *box.m_child = &node; + } + + if (!root) + { + root = &node; + } + + { + VHACD::Vect3 xc(0); + VHACD::Vect3 x2c(0); + VHACD::Vect3 p0(double( 1.0e15)); + VHACD::Vect3 p1(double(-1.0e15)); + for (int i = i0; i < box.m_count; ++i) + { + const VHACD::Vect3& p = points[start + i]; + xc += p; + x2c += p.CWiseMul(p); + p0 = p0.CWiseMin(p); + p1 = p1.CWiseMax(p); + } + + dTreeBox cluster_i1(box); + cluster_i1.m_start = start + i0; + cluster_i1.m_count = box.m_count - i0; + cluster_i1.m_sum = xc; + cluster_i1.m_sum2 = x2c; + cluster_i1.m_min = p0; + cluster_i1.m_max = p1; + cluster_i1.m_parent = &node; + cluster_i1.m_child = &node.m_right; + treeBoxStack[stack] = cluster_i1; + assert(cluster_i1.m_count > 0); + stack++; + } + + { + VHACD::Vect3 xc(0); + VHACD::Vect3 x2c(0); + VHACD::Vect3 p0(double( 1.0e15)); + VHACD::Vect3 p1(double(-1.0e15)); + for (int i = 0; i < i0; ++i) + { + const VHACD::Vect3& p = points[start + i]; + xc += p; + x2c += p.CWiseMul(p); + p0 = p0.CWiseMin(p); + p1 = p1.CWiseMax(p); + } + + dTreeBox cluster_i0(box); + cluster_i0.m_start = start; + cluster_i0.m_count = i0; + cluster_i0.m_min = p0; + cluster_i0.m_max = p1; + cluster_i0.m_sum = xc; + cluster_i0.m_sum2 = x2c; + cluster_i0.m_parent = &node; + cluster_i0.m_child = &node.m_left; + assert(cluster_i0.m_count > 0); + treeBoxStack[stack] = cluster_i0; + stack++; + } + } + } + + return root; +} + +int ConvexHull::SupportVertex(ConvexHullAABBTreeNode** const treePointer, + const std::vector& points, + const VHACD::Vect3& dirPlane, + const bool removeEntry) const +{ +#define VHACD_STACK_DEPTH_3D 64 + double aabbProjection[VHACD_STACK_DEPTH_3D]; + ConvexHullAABBTreeNode* stackPool[VHACD_STACK_DEPTH_3D]; + + VHACD::Vect3 dir(dirPlane); + + int index = -1; + int stack = 1; + stackPool[0] = *treePointer; + aabbProjection[0] = double(1.0e20); + double maxProj = double(-1.0e20); + int ix = (dir[0] > double(0.0)) ? 1 : 0; + int iy = (dir[1] > double(0.0)) ? 1 : 0; + int iz = (dir[2] > double(0.0)) ? 1 : 0; + while (stack) + { + stack--; + double boxSupportValue = aabbProjection[stack]; + if (boxSupportValue > maxProj) + { + ConvexHullAABBTreeNode* me = stackPool[stack]; + + /* + * If the node is not a leaf node... + */ + if (me->m_left && me->m_right) + { + const VHACD::Vect3 leftSupportPoint(me->m_left->m_box[ix].GetX(), + me->m_left->m_box[iy].GetY(), + me->m_left->m_box[iz].GetZ()); + double leftSupportDist = leftSupportPoint.Dot(dir); + + const VHACD::Vect3 rightSupportPoint(me->m_right->m_box[ix].GetX(), + me->m_right->m_box[iy].GetY(), + me->m_right->m_box[iz].GetZ()); + double rightSupportDist = rightSupportPoint.Dot(dir); + + /* + * ...push the shorter side first + * So we can explore the tree in the larger side first + */ + if (rightSupportDist >= leftSupportDist) + { + aabbProjection[stack] = leftSupportDist; + stackPool[stack] = me->m_left; + stack++; + assert(stack < VHACD_STACK_DEPTH_3D); + aabbProjection[stack] = rightSupportDist; + stackPool[stack] = me->m_right; + stack++; + assert(stack < VHACD_STACK_DEPTH_3D); + } + else + { + aabbProjection[stack] = rightSupportDist; + stackPool[stack] = me->m_right; + stack++; + assert(stack < VHACD_STACK_DEPTH_3D); + aabbProjection[stack] = leftSupportDist; + stackPool[stack] = me->m_left; + stack++; + assert(stack < VHACD_STACK_DEPTH_3D); + } + } + /* + * If it is a node... + */ + else + { + ConvexHullAABBTreeNode* cluster = me; + for (size_t i = 0; i < cluster->m_count; ++i) + { + const ConvexHullVertex& p = points[cluster->m_indices[i]]; + assert(p.GetX() >= cluster->m_box[0].GetX()); + assert(p.GetX() <= cluster->m_box[1].GetX()); + assert(p.GetY() >= cluster->m_box[0].GetY()); + assert(p.GetY() <= cluster->m_box[1].GetY()); + assert(p.GetZ() >= cluster->m_box[0].GetZ()); + assert(p.GetZ() <= cluster->m_box[1].GetZ()); + if (!p.m_mark) + { + //assert(p.m_w == double(0.0f)); + double dist = p.Dot(dir); + if (dist > maxProj) + { + maxProj = dist; + index = cluster->m_indices[i]; + } + } + else if (removeEntry) + { + cluster->m_indices[i] = cluster->m_indices[cluster->m_count - 1]; + cluster->m_count = cluster->m_count - 1; + i--; + } + } + + if (cluster->m_count == 0) + { + ConvexHullAABBTreeNode* const parent = cluster->m_parent; + if (parent) + { + ConvexHullAABBTreeNode* const sibling = (parent->m_left != cluster) ? parent->m_left : parent->m_right; + assert(sibling != cluster); + ConvexHullAABBTreeNode* const grandParent = parent->m_parent; + if (grandParent) + { + sibling->m_parent = grandParent; + if (grandParent->m_right == parent) + { + grandParent->m_right = sibling; + } + else + { + grandParent->m_left = sibling; + } + } + else + { + sibling->m_parent = nullptr; + *treePointer = sibling; + } + } + } + } + } + } + + assert(index != -1); + return index; +} + +double ConvexHull::TetrahedrumVolume(const VHACD::Vect3& p0, + const VHACD::Vect3& p1, + const VHACD::Vect3& p2, + const VHACD::Vect3& p3) const +{ + const VHACD::Vect3 p1p0(p1 - p0); + const VHACD::Vect3 p2p0(p2 - p0); + const VHACD::Vect3 p3p0(p3 - p0); + return p3p0.Dot(p1p0.Cross(p2p0)); +} + +int ConvexHull::InitVertexArray(std::vector& points, + NodeBundle& memoryPool) +// std::vector& memoryPool) +{ +#if 1 + ConvexHullAABBTreeNode* tree = BuildTreeOld(points, + memoryPool); +#else + ConvexHullAABBTreeNode* tree = BuildTreeNew(points, (char**)&memoryPool, maxMemSize); +#endif + int count = int(points.size()); + if (count < 4) + { + m_points.resize(0); + return 0; + } + + m_points.resize(count); + m_aabbP0 = tree->m_box[0]; + m_aabbP1 = tree->m_box[1]; + + VHACD::Vect3 boxSize(tree->m_box[1] - tree->m_box[0]); + m_diag = boxSize.GetNorm(); + const ndNormalMap& normalMap = ndNormalMap::GetNormalMap(); + + int index0 = SupportVertex(&tree, + points, + normalMap.m_normal[0]); + m_points[0] = points[index0]; + points[index0].m_mark = 1; + + bool validTetrahedrum = false; + VHACD::Vect3 e1(double(0.0)); + for (int i = 1; i < normalMap.m_count; ++i) + { + int index = SupportVertex(&tree, + points, + normalMap.m_normal[i]); + assert(index >= 0); + + e1 = points[index] - m_points[0]; + double error2 = e1.GetNormSquared(); + if (error2 > (double(1.0e-4) * m_diag * m_diag)) + { + m_points[1] = points[index]; + points[index].m_mark = 1; + validTetrahedrum = true; + break; + } + } + if (!validTetrahedrum) + { + m_points.resize(0); + assert(0); + return count; + } + + validTetrahedrum = false; + VHACD::Vect3 e2(double(0.0)); + VHACD::Vect3 normal(double(0.0)); + for (int i = 2; i < normalMap.m_count; ++i) + { + int index = SupportVertex(&tree, + points, + normalMap.m_normal[i]); + assert(index >= 0); + e2 = points[index] - m_points[0]; + normal = e1.Cross(e2); + double error2 = normal.GetNorm(); + if (error2 > (double(1.0e-4) * m_diag * m_diag)) + { + m_points[2] = points[index]; + points[index].m_mark = 1; + validTetrahedrum = true; + break; + } + } + + if (!validTetrahedrum) + { + m_points.resize(0); + assert(0); + return count; + } + + // find the largest possible tetrahedron + validTetrahedrum = false; + VHACD::Vect3 e3(double(0.0)); + + index0 = SupportVertex(&tree, + points, + normal); + e3 = points[index0] - m_points[0]; + double err2 = normal.Dot(e3); + if (fabs(err2) > (double(1.0e-6) * m_diag * m_diag)) + { + // we found a valid tetrahedral, about and start build the hull by adding the rest of the points + m_points[3] = points[index0]; + points[index0].m_mark = 1; + validTetrahedrum = true; + } + if (!validTetrahedrum) + { + VHACD::Vect3 n(-normal); + int index = SupportVertex(&tree, + points, + n); + e3 = points[index] - m_points[0]; + double error2 = normal.Dot(e3); + if (fabs(error2) > (double(1.0e-6) * m_diag * m_diag)) + { + // we found a valid tetrahedral, about and start build the hull by adding the rest of the points + m_points[3] = points[index]; + points[index].m_mark = 1; + validTetrahedrum = true; + } + } + if (!validTetrahedrum) + { + for (int i = 3; i < normalMap.m_count; ++i) + { + int index = SupportVertex(&tree, + points, + normalMap.m_normal[i]); + assert(index >= 0); + + //make sure the volume of the fist tetrahedral is no negative + e3 = points[index] - m_points[0]; + double error2 = normal.Dot(e3); + if (fabs(error2) > (double(1.0e-6) * m_diag * m_diag)) + { + // we found a valid tetrahedral, about and start build the hull by adding the rest of the points + m_points[3] = points[index]; + points[index].m_mark = 1; + validTetrahedrum = true; + break; + } + } + } + if (!validTetrahedrum) + { + // the points do not form a convex hull + m_points.resize(0); + return count; + } + + m_points.resize(4); + double volume = TetrahedrumVolume(m_points[0], + m_points[1], + m_points[2], + m_points[3]); + if (volume > double(0.0)) + { + std::swap(m_points[2], + m_points[3]); + } + assert(TetrahedrumVolume(m_points[0], m_points[1], m_points[2], m_points[3]) < double(0.0)); + return count; +} + +std::list::iterator ConvexHull::AddFace(int i0, + int i1, + int i2) +{ + ConvexHullFace face; + face.m_index[0] = i0; + face.m_index[1] = i1; + face.m_index[2] = i2; + + std::list::iterator node = m_list.emplace(m_list.end(), face); + return node; +} + +void ConvexHull::CalculateConvexHull3D(ConvexHullAABBTreeNode* vertexTree, + std::vector& points, + int count, + double distTol, + int maxVertexCount) +{ + distTol = fabs(distTol) * m_diag; + std::list::iterator f0Node = AddFace(0, 1, 2); + std::list::iterator f1Node = AddFace(0, 2, 3); + std::list::iterator f2Node = AddFace(2, 1, 3); + std::list::iterator f3Node = AddFace(1, 0, 3); + + ConvexHullFace& f0 = *f0Node; + ConvexHullFace& f1 = *f1Node; + ConvexHullFace& f2 = *f2Node; + ConvexHullFace& f3 = *f3Node; + + f0.m_twin[0] = f3Node; + f0.m_twin[1] = f2Node; + f0.m_twin[2] = f1Node; + + f1.m_twin[0] = f0Node; + f1.m_twin[1] = f2Node; + f1.m_twin[2] = f3Node; + + f2.m_twin[0] = f0Node; + f2.m_twin[1] = f3Node; + f2.m_twin[2] = f1Node; + + f3.m_twin[0] = f0Node; + f3.m_twin[1] = f1Node; + f3.m_twin[2] = f2Node; + + std::list::iterator> boundaryFaces; + boundaryFaces.push_back(f0Node); + boundaryFaces.push_back(f1Node); + boundaryFaces.push_back(f2Node); + boundaryFaces.push_back(f3Node); + + m_points.resize(count); + + count -= 4; + maxVertexCount -= 4; + int currentIndex = 4; + + /* + * Some are iterators into boundaryFaces, others into m_list + */ + std::vector::iterator> stack; + std::vector::iterator> coneList; + std::vector::iterator> deleteList; + + stack.reserve(1024 + count); + coneList.reserve(1024 + count); + deleteList.reserve(1024 + count); + + while (boundaryFaces.size() && count && (maxVertexCount > 0)) + { + // my definition of the optimal convex hull of a given vertex count, + // is the convex hull formed by a subset of the input vertex that minimizes the volume difference + // between the perfect hull formed from all input vertex and the hull of the sub set of vertex. + // When using a priority heap this algorithms will generate the an optimal of a fix vertex count. + // Since all Newton's tools do not have a limit on the point count of a convex hull, I can use either a stack or a queue. + // a stack maximize construction speed, a Queue tend to maximize the volume of the generated Hull approaching a perfect Hull. + // For now we use a queue. + // For general hulls it does not make a difference if we use a stack, queue, or a priority heap. + // perfect optimal hull only apply for when build hull of a limited vertex count. + // + // Also when building Hulls of a limited vertex count, this function runs in constant time. + // yes that is correct, it does not makes a difference if you build a N point hull from 100 vertex + // or from 100000 vertex input array. + + // using a queue (some what slower by better hull when reduced vertex count is desired) + bool isvalid; + std::list::iterator faceNode = boundaryFaces.back(); + ConvexHullFace& face = *faceNode; + HullPlane planeEquation(face.GetPlaneEquation(m_points, isvalid)); + + int index = 0; + double dist = 0; + VHACD::Vect3 p; + if (isvalid) + { + index = SupportVertex(&vertexTree, + points, + planeEquation); + p = points[index]; + dist = planeEquation.Evalue(p); + } + + if ( isvalid + && (dist >= distTol) + && (face.Evalue(m_points, p) < double(0.0))) + { + stack.push_back(faceNode); + + deleteList.clear(); + while (stack.size()) + { + std::list::iterator node1 = stack.back(); + ConvexHullFace& face1 = *node1; + + stack.pop_back(); + + if (!face1.m_mark && (face1.Evalue(m_points, p) < double(0.0))) + { + #ifdef _DEBUG + for (const auto node : deleteList) + { + assert(node != node1); + } + #endif + + deleteList.push_back(node1); + face1.m_mark = 1; + for (std::list::iterator& twinNode : face1.m_twin) + { + ConvexHullFace& twinFace = *twinNode; + if (!twinFace.m_mark) + { + stack.push_back(twinNode); + } + } + } + } + + m_points[currentIndex] = points[index]; + points[index].m_mark = 1; + + coneList.clear(); + for (std::list::iterator node1 : deleteList) + { + ConvexHullFace& face1 = *node1; + assert(face1.m_mark == 1); + for (std::size_t j0 = 0; j0 < face1.m_twin.size(); ++j0) + { + std::list::iterator twinNode = face1.m_twin[j0]; + ConvexHullFace& twinFace = *twinNode; + if (!twinFace.m_mark) + { + std::size_t j1 = (j0 == 2) ? 0 : j0 + 1; + std::list::iterator newNode = AddFace(currentIndex, + face1.m_index[j0], + face1.m_index[j1]); + boundaryFaces.push_front(newNode); + ConvexHullFace& newFace = *newNode; + + newFace.m_twin[1] = twinNode; + for (std::size_t k = 0; k < twinFace.m_twin.size(); ++k) + { + if (twinFace.m_twin[k] == node1) + { + twinFace.m_twin[k] = newNode; + } + } + coneList.push_back(newNode); + } + } + } + + for (std::size_t i = 0; i < coneList.size() - 1; ++i) + { + std::list::iterator nodeA = coneList[i]; + ConvexHullFace& faceA = *nodeA; + assert(faceA.m_mark == 0); + for (std::size_t j = i + 1; j < coneList.size(); j++) + { + std::list::iterator nodeB = coneList[j]; + ConvexHullFace& faceB = *nodeB; + assert(faceB.m_mark == 0); + if (faceA.m_index[2] == faceB.m_index[1]) + { + faceA.m_twin[2] = nodeB; + faceB.m_twin[0] = nodeA; + break; + } + } + + for (std::size_t j = i + 1; j < coneList.size(); j++) + { + std::list::iterator nodeB = coneList[j]; + ConvexHullFace& faceB = *nodeB; + assert(faceB.m_mark == 0); + if (faceA.m_index[1] == faceB.m_index[2]) + { + faceA.m_twin[0] = nodeB; + faceB.m_twin[2] = nodeA; + break; + } + } + } + + for (std::list::iterator node : deleteList) + { + auto it = std::find(boundaryFaces.begin(), + boundaryFaces.end(), + node); + if (it != boundaryFaces.end()) + { + boundaryFaces.erase(it); + } + m_list.erase(node); + } + + maxVertexCount--; + currentIndex++; + count--; + } + else + { + auto it = std::find(boundaryFaces.begin(), + boundaryFaces.end(), + faceNode); + if (it != boundaryFaces.end()) + { + boundaryFaces.erase(it); + } + } + } + m_points.resize(currentIndex); +} + +//*********************************************************************************************** +// End of ConvexHull generation code by Julio Jerez +//*********************************************************************************************** + +class KdTreeNode; + +enum Axes +{ + X_AXIS = 0, + Y_AXIS = 1, + Z_AXIS = 2 +}; + +class KdTreeFindNode +{ +public: + KdTreeFindNode() = default; + + KdTreeNode* m_node{ nullptr }; + double m_distance{ 0.0 }; +}; + +class KdTree +{ +public: + KdTree() = default; + + const VHACD::Vertex& GetPosition(uint32_t index) const; + + uint32_t Search(const VHACD::Vect3& pos, + double radius, + uint32_t maxObjects, + KdTreeFindNode* found) const; + + uint32_t Add(const VHACD::Vertex& v); + + KdTreeNode& GetNewNode(uint32_t index); + + uint32_t GetNearest(const VHACD::Vect3& pos, + double radius, + bool& _found) const; // returns the nearest possible neighbor's index. + + const std::vector& GetVertices() const; + std::vector&& TakeVertices(); + + uint32_t GetVCount() const; + +private: + KdTreeNode* m_root{ nullptr }; + NodeBundle m_bundle; + + std::vector m_vertices; +}; + +class KdTreeNode +{ +public: + KdTreeNode() = default; + KdTreeNode(uint32_t index); + + void Add(KdTreeNode& node, + Axes dim, + const KdTree& iface); + + uint32_t GetIndex() const; + + void Search(Axes axis, + const VHACD::Vect3& pos, + double radius, + uint32_t& count, + uint32_t maxObjects, + KdTreeFindNode* found, + const KdTree& iface); + +private: + uint32_t m_index = 0; + KdTreeNode* m_left = nullptr; + KdTreeNode* m_right = nullptr; +}; + +const VHACD::Vertex& KdTree::GetPosition(uint32_t index) const +{ + assert(index < m_vertices.size()); + return m_vertices[index]; +} + +uint32_t KdTree::Search(const VHACD::Vect3& pos, + double radius, + uint32_t maxObjects, + KdTreeFindNode* found) const +{ + if (!m_root) + return 0; + uint32_t count = 0; + m_root->Search(X_AXIS, pos, radius, count, maxObjects, found, *this); + return count; +} + +uint32_t KdTree::Add(const VHACD::Vertex& v) +{ + uint32_t ret = uint32_t(m_vertices.size()); + m_vertices.emplace_back(v); + KdTreeNode& node = GetNewNode(ret); + if (m_root) + { + m_root->Add(node, + X_AXIS, + *this); + } + else + { + m_root = &node; + } + return ret; +} + +KdTreeNode& KdTree::GetNewNode(uint32_t index) +{ + KdTreeNode& node = m_bundle.GetNextNode(); + node = KdTreeNode(index); + return node; +} + +uint32_t KdTree::GetNearest(const VHACD::Vect3& pos, + double radius, + bool& _found) const // returns the nearest possible neighbor's index. +{ + uint32_t ret = 0; + + _found = false; + KdTreeFindNode found; + uint32_t count = Search(pos, radius, 1, &found); + if (count) + { + KdTreeNode* node = found.m_node; + ret = node->GetIndex(); + _found = true; + } + return ret; +} + +const std::vector& KdTree::GetVertices() const +{ + return m_vertices; +} + +std::vector&& KdTree::TakeVertices() +{ + return std::move(m_vertices); +} + +uint32_t KdTree::GetVCount() const +{ + return uint32_t(m_vertices.size()); +} + +KdTreeNode::KdTreeNode(uint32_t index) + : m_index(index) +{ +} + +void KdTreeNode::Add(KdTreeNode& node, + Axes dim, + const KdTree& tree) +{ + Axes axis = X_AXIS; + uint32_t idx = 0; + switch (dim) + { + case X_AXIS: + idx = 0; + axis = Y_AXIS; + break; + case Y_AXIS: + idx = 1; + axis = Z_AXIS; + break; + case Z_AXIS: + idx = 2; + axis = X_AXIS; + break; + } + + const VHACD::Vertex& nodePosition = tree.GetPosition(node.m_index); + const VHACD::Vertex& position = tree.GetPosition(m_index); + if (nodePosition[idx] <= position[idx]) + { + if (m_left) + m_left->Add(node, axis, tree); + else + m_left = &node; + } + else + { + if (m_right) + m_right->Add(node, axis, tree); + else + m_right = &node; + } +} + +uint32_t KdTreeNode::GetIndex() const +{ + return m_index; +} + +void KdTreeNode::Search(Axes axis, + const VHACD::Vect3& pos, + double radius, + uint32_t& count, + uint32_t maxObjects, + KdTreeFindNode* found, + const KdTree& iface) +{ + const VHACD::Vect3 position = iface.GetPosition(m_index); + + const VHACD::Vect3 d = pos - position; + + KdTreeNode* search1 = 0; + KdTreeNode* search2 = 0; + + uint32_t idx = 0; + switch (axis) + { + case X_AXIS: + idx = 0; + axis = Y_AXIS; + break; + case Y_AXIS: + idx = 1; + axis = Z_AXIS; + break; + case Z_AXIS: + idx = 2; + axis = X_AXIS; + break; + } + + if (d[idx] <= 0) // JWR if we are to the left + { + search1 = m_left; // JWR then search to the left + if (-d[idx] < radius) // JWR if distance to the right is less than our search radius, continue on the right + // as well. + search2 = m_right; + } + else + { + search1 = m_right; // JWR ok, we go down the left tree + if (d[idx] < radius) // JWR if the distance from the right is less than our search radius + search2 = m_left; + } + + double r2 = radius * radius; + double m = d.GetNormSquared(); + + if (m < r2) + { + switch (count) + { + case 0: + { + found[count].m_node = this; + found[count].m_distance = m; + break; + } + case 1: + { + if (m < found[0].m_distance) + { + if (maxObjects == 1) + { + found[0].m_node = this; + found[0].m_distance = m; + } + else + { + found[1] = found[0]; + found[0].m_node = this; + found[0].m_distance = m; + } + } + else if (maxObjects > 1) + { + found[1].m_node = this; + found[1].m_distance = m; + } + break; + } + default: + { + bool inserted = false; + + for (uint32_t i = 0; i < count; i++) + { + if (m < found[i].m_distance) // if this one is closer than a pre-existing one... + { + // insertion sort... + uint32_t scan = count; + if (scan >= maxObjects) + scan = maxObjects - 1; + for (uint32_t j = scan; j > i; j--) + { + found[j] = found[j - 1]; + } + found[i].m_node = this; + found[i].m_distance = m; + inserted = true; + break; + } + } + + if (!inserted && count < maxObjects) + { + found[count].m_node = this; + found[count].m_distance = m; + } + } + break; + } + + count++; + + if (count > maxObjects) + { + count = maxObjects; + } + } + + + if (search1) + search1->Search(axis, pos, radius, count, maxObjects, found, iface); + + if (search2) + search2->Search(axis, pos, radius, count, maxObjects, found, iface); +} + +class VertexIndex +{ +public: + VertexIndex(double granularity, + bool snapToGrid); + + VHACD::Vect3 SnapToGrid(VHACD::Vect3 p); + + uint32_t GetIndex(VHACD::Vect3 p, + bool& newPos); + + const std::vector& GetVertices() const; + + std::vector&& TakeVertices(); + + uint32_t GetVCount() const; + + bool SaveAsObj(const char* fname, + uint32_t tcount, + uint32_t* indices) + { + bool ret = false; + + FILE* fph = fopen(fname, "wb"); + if (fph) + { + ret = true; + + const std::vector& v = GetVertices(); + for (uint32_t i = 0; i < v.size(); ++i) + { + fprintf(fph, "v %0.9f %0.9f %0.9f\r\n", + v[i].mX, + v[i].mY, + v[i].mZ); + } + + for (uint32_t i = 0; i < tcount; i++) + { + uint32_t i1 = *indices++; + uint32_t i2 = *indices++; + uint32_t i3 = *indices++; + fprintf(fph, "f %d %d %d\r\n", + i1 + 1, + i2 + 1, + i3 + 1); + } + fclose(fph); + } + + return ret; + } + +private: + bool m_snapToGrid : 1; + double m_granularity; + KdTree m_KdTree; +}; + +VertexIndex::VertexIndex(double granularity, + bool snapToGrid) + : m_snapToGrid(snapToGrid) + , m_granularity(granularity) +{ +} + +VHACD::Vect3 VertexIndex::SnapToGrid(VHACD::Vect3 p) +{ + for (int i = 0; i < 3; ++i) + { + double m = fmod(p[i], m_granularity); + p[i] -= m; + } + return p; +} + +uint32_t VertexIndex::GetIndex(VHACD::Vect3 p, + bool& newPos) +{ + uint32_t ret; + + newPos = false; + + if (m_snapToGrid) + { + p = SnapToGrid(p); + } + + bool found; + ret = m_KdTree.GetNearest(p, m_granularity, found); + if (!found) + { + newPos = true; + ret = m_KdTree.Add(VHACD::Vertex(p.GetX(), p.GetY(), p.GetZ())); + } + + return ret; +} + +const std::vector& VertexIndex::GetVertices() const +{ + return m_KdTree.GetVertices(); +} + +std::vector&& VertexIndex::TakeVertices() +{ + return std::move(m_KdTree.TakeVertices()); +} + +uint32_t VertexIndex::GetVCount() const +{ + return m_KdTree.GetVCount(); +} + +/* + * A wrapper class for 3 10 bit integers packed into a 32 bit integer + * Layout is [PAD][X][Y][Z] + * Pad is bits 31-30, X is 29-20, Y is 19-10, and Z is 9-0 + */ +class Voxel +{ + /* + * Specify all of them for consistency + */ + static constexpr int VoxelBitsZStart = 0; + static constexpr int VoxelBitsYStart = 10; + static constexpr int VoxelBitsXStart = 20; + static constexpr int VoxelBitMask = 0x03FF; // bits 0 through 9 inclusive +public: + Voxel() = default; + + Voxel(uint32_t index); + + Voxel(uint32_t x, + uint32_t y, + uint32_t z); + + bool operator==(const Voxel &v) const; + + VHACD::Vector3 GetVoxel() const; + + uint32_t GetX() const; + uint32_t GetY() const; + uint32_t GetZ() const; + + uint32_t GetVoxelAddress() const; + +private: + uint32_t m_voxel{ 0 }; +}; + +Voxel::Voxel(uint32_t index) + : m_voxel(index) +{ +} + +Voxel::Voxel(uint32_t x, + uint32_t y, + uint32_t z) + : m_voxel((x << VoxelBitsXStart) | (y << VoxelBitsYStart) | (z << VoxelBitsZStart)) +{ + assert(x < 1024 && "Voxel constructed with X outside of range"); + assert(y < 1024 && "Voxel constructed with Y outside of range"); + assert(z < 1024 && "Voxel constructed with Z outside of range"); +} + +bool Voxel::operator==(const Voxel& v) const +{ + return m_voxel == v.m_voxel; +} + +VHACD::Vector3 Voxel::GetVoxel() const +{ + return VHACD::Vector3(GetX(), GetY(), GetZ()); +} + +uint32_t Voxel::GetX() const +{ + return (m_voxel >> VoxelBitsXStart) & VoxelBitMask; +} + +uint32_t Voxel::GetY() const +{ + return (m_voxel >> VoxelBitsYStart) & VoxelBitMask; +} + +uint32_t Voxel::GetZ() const +{ + return (m_voxel >> VoxelBitsZStart) & VoxelBitMask; +} + +uint32_t Voxel::GetVoxelAddress() const +{ + return m_voxel; +} + +struct SimpleMesh +{ + std::vector m_vertices; + std::vector m_indices; +}; + +/*======================== 0-tests ========================*/ +inline bool IntersectRayAABB(const VHACD::Vect3& start, + const VHACD::Vect3& dir, + const VHACD::BoundsAABB& bounds, + double& t) +{ + //! calculate candidate plane on each axis + bool inside = true; + VHACD::Vect3 ta(double(-1.0)); + + //! use unrolled loops + for (uint32_t i = 0; i < 3; ++i) + { + if (start[i] < bounds.GetMin()[i]) + { + if (dir[i] != double(0.0)) + ta[i] = (bounds.GetMin()[i] - start[i]) / dir[i]; + inside = false; + } + else if (start[i] > bounds.GetMax()[i]) + { + if (dir[i] != double(0.0)) + ta[i] = (bounds.GetMax()[i] - start[i]) / dir[i]; + inside = false; + } + } + + //! if point inside all planes + if (inside) + { + t = double(0.0); + return true; + } + + //! we now have t values for each of possible intersection planes + //! find the maximum to get the intersection point + uint32_t taxis; + double tmax = ta.MaxCoeff(taxis); + + if (tmax < double(0.0)) + return false; + + //! check that the intersection point lies on the plane we picked + //! we don't test the axis of closest intersection for precision reasons + + //! no eps for now + double eps = double(0.0); + + VHACD::Vect3 hit = start + dir * tmax; + + if (( hit.GetX() < bounds.GetMin().GetX() - eps + || hit.GetX() > bounds.GetMax().GetX() + eps) + && taxis != 0) + return false; + if (( hit.GetY() < bounds.GetMin().GetY() - eps + || hit.GetY() > bounds.GetMax().GetY() + eps) + && taxis != 1) + return false; + if (( hit.GetZ() < bounds.GetMin().GetZ() - eps + || hit.GetZ() > bounds.GetMax().GetZ() + eps) + && taxis != 2) + return false; + + //! output results + t = tmax; + + return true; +} + +// Moller and Trumbore's method +inline bool IntersectRayTriTwoSided(const VHACD::Vect3& p, + const VHACD::Vect3& dir, + const VHACD::Vect3& a, + const VHACD::Vect3& b, + const VHACD::Vect3& c, + double& t, + double& u, + double& v, + double& w, + double& sign, + VHACD::Vect3* normal) +{ + VHACD::Vect3 ab = b - a; + VHACD::Vect3 ac = c - a; + VHACD::Vect3 n = ab.Cross(ac); + + double d = -dir.Dot(n); + double ood = double(1.0) / d; // No need to check for division by zero here as infinity arithmetic will save us... + VHACD::Vect3 ap = p - a; + + t = ap.Dot(n) * ood; + if (t < double(0.0)) + { + return false; + } + + VHACD::Vect3 e = -dir.Cross(ap); + v = ac.Dot(e) * ood; + if (v < double(0.0) || v > double(1.0)) // ...here... + { + return false; + } + w = -ab.Dot(e) * ood; + if (w < double(0.0) || v + w > double(1.0)) // ...and here + { + return false; + } + + u = double(1.0) - v - w; + if (normal) + { + *normal = n; + } + + sign = d; + + return true; +} + +// RTCD 5.1.5, page 142 +inline VHACD::Vect3 ClosestPointOnTriangle(const VHACD::Vect3& a, + const VHACD::Vect3& b, + const VHACD::Vect3& c, + const VHACD::Vect3& p, + double& v, + double& w) +{ + VHACD::Vect3 ab = b - a; + VHACD::Vect3 ac = c - a; + VHACD::Vect3 ap = p - a; + + double d1 = ab.Dot(ap); + double d2 = ac.Dot(ap); + if ( d1 <= double(0.0) + && d2 <= double(0.0)) + { + v = double(0.0); + w = double(0.0); + return a; + } + + VHACD::Vect3 bp = p - b; + double d3 = ab.Dot(bp); + double d4 = ac.Dot(bp); + if ( d3 >= double(0.0) + && d4 <= d3) + { + v = double(1.0); + w = double(0.0); + return b; + } + + double vc = d1 * d4 - d3 * d2; + if ( vc <= double(0.0) + && d1 >= double(0.0) + && d3 <= double(0.0)) + { + v = d1 / (d1 - d3); + w = double(0.0); + return a + v * ab; + } + + VHACD::Vect3 cp = p - c; + double d5 = ab.Dot(cp); + double d6 = ac.Dot(cp); + if (d6 >= double(0.0) && d5 <= d6) + { + v = double(0.0); + w = double(1.0); + return c; + } + + double vb = d5 * d2 - d1 * d6; + if ( vb <= double(0.0) + && d2 >= double(0.0) + && d6 <= double(0.0)) + { + v = double(0.0); + w = d2 / (d2 - d6); + return a + w * ac; + } + + double va = d3 * d6 - d5 * d4; + if ( va <= double(0.0) + && (d4 - d3) >= double(0.0) + && (d5 - d6) >= double(0.0)) + { + w = (d4 - d3) / ((d4 - d3) + (d5 - d6)); + v = double(1.0) - w; + return b + w * (c - b); + } + + double denom = double(1.0) / (va + vb + vc); + v = vb * denom; + w = vc * denom; + return a + ab * v + ac * w; +} + +class AABBTree +{ +public: + AABBTree() = default; + AABBTree(AABBTree&&) = default; + AABBTree& operator=(AABBTree&&) = default; + + AABBTree(const std::vector& vertices, + const std::vector& indices); + + bool TraceRay(const VHACD::Vect3& start, + const VHACD::Vect3& to, + double& outT, + double& faceSign, + VHACD::Vect3& hitLocation) const; + + bool TraceRay(const VHACD::Vect3& start, + const VHACD::Vect3& dir, + uint32_t& insideCount, + uint32_t& outsideCount) const; + + bool TraceRay(const VHACD::Vect3& start, + const VHACD::Vect3& dir, + double& outT, + double& u, + double& v, + double& w, + double& faceSign, + uint32_t& faceIndex) const; + + VHACD::Vect3 GetCenter() const; + VHACD::Vect3 GetMinExtents() const; + VHACD::Vect3 GetMaxExtents() const; + + bool GetClosestPointWithinDistance(const VHACD::Vect3& point, + double maxDistance, + VHACD::Vect3& closestPoint) const; + +private: + struct Node + { + union + { + uint32_t m_children; + uint32_t m_numFaces{ 0 }; + }; + + uint32_t* m_faces{ nullptr }; + VHACD::BoundsAABB m_extents; + }; + + struct FaceSorter + { + FaceSorter(const std::vector& positions, + const std::vector& indices, + uint32_t axis); + + bool operator()(uint32_t lhs, uint32_t rhs) const; + + double GetCentroid(uint32_t face) const; + + const std::vector& m_vertices; + const std::vector& m_indices; + uint32_t m_axis; + }; + + // partition the objects and return the number of objects in the lower partition + uint32_t PartitionMedian(Node& n, + uint32_t* faces, + uint32_t numFaces); + uint32_t PartitionSAH(Node& n, + uint32_t* faces, + uint32_t numFaces); + + void Build(); + + void BuildRecursive(uint32_t nodeIndex, + uint32_t* faces, + uint32_t numFaces); + + void TraceRecursive(uint32_t nodeIndex, + const VHACD::Vect3& start, + const VHACD::Vect3& dir, + double& outT, + double& u, + double& v, + double& w, + double& faceSign, + uint32_t& faceIndex) const; + + + bool GetClosestPointWithinDistance(const VHACD::Vect3& point, + const double maxDis, + double& dis, + double& v, + double& w, + uint32_t& faceIndex, + VHACD::Vect3& closest) const; + + void GetClosestPointWithinDistanceSqRecursive(uint32_t nodeIndex, + const VHACD::Vect3& point, + double& outDisSq, + double& outV, + double& outW, + uint32_t& outFaceIndex, + VHACD::Vect3& closest) const; + + VHACD::BoundsAABB CalculateFaceBounds(uint32_t* faces, + uint32_t numFaces); + + // track the next free node + uint32_t m_freeNode; + + const std::vector* m_vertices{ nullptr }; + const std::vector* m_indices{ nullptr }; + + std::vector m_faces; + std::vector m_nodes; + std::vector m_faceBounds; + + // stats + uint32_t m_treeDepth{ 0 }; + uint32_t m_innerNodes{ 0 }; + uint32_t m_leafNodes{ 0 }; + + uint32_t s_depth{ 0 }; +}; + +AABBTree::FaceSorter::FaceSorter(const std::vector& positions, + const std::vector& indices, + uint32_t axis) + : m_vertices(positions) + , m_indices(indices) + , m_axis(axis) +{ +} + +inline bool AABBTree::FaceSorter::operator()(uint32_t lhs, + uint32_t rhs) const +{ + double a = GetCentroid(lhs); + double b = GetCentroid(rhs); + + if (a == b) + { + return lhs < rhs; + } + else + { + return a < b; + } +} + +inline double AABBTree::FaceSorter::GetCentroid(uint32_t face) const +{ + const VHACD::Vect3& a = m_vertices[m_indices[face].mI0]; + const VHACD::Vect3& b = m_vertices[m_indices[face].mI1]; + const VHACD::Vect3& c = m_vertices[m_indices[face].mI2]; + + return (a[m_axis] + b[m_axis] + c[m_axis]) / double(3.0); +} + +AABBTree::AABBTree(const std::vector& vertices, + const std::vector& indices) + : m_vertices(&vertices) + , m_indices(&indices) +{ + Build(); +} + +bool AABBTree::TraceRay(const VHACD::Vect3& start, + const VHACD::Vect3& to, + double& outT, + double& faceSign, + VHACD::Vect3& hitLocation) const +{ + VHACD::Vect3 dir = to - start; + double distance = dir.Normalize(); + double u, v, w; + uint32_t faceIndex; + bool hit = TraceRay(start, + dir, + outT, + u, + v, + w, + faceSign, + faceIndex); + if (hit) + { + hitLocation = start + dir * outT; + } + + if (hit && outT > distance) + { + hit = false; + } + return hit; +} + +bool AABBTree::TraceRay(const VHACD::Vect3& start, + const VHACD::Vect3& dir, + uint32_t& insideCount, + uint32_t& outsideCount) const +{ + double outT, u, v, w, faceSign; + uint32_t faceIndex; + bool hit = TraceRay(start, + dir, + outT, + u, + v, + w, + faceSign, + faceIndex); + if (hit) + { + if (faceSign >= 0) + { + insideCount++; + } + else + { + outsideCount++; + } + } + return hit; +} + +bool AABBTree::TraceRay(const VHACD::Vect3& start, + const VHACD::Vect3& dir, + double& outT, + double& u, + double& v, + double& w, + double& faceSign, + uint32_t& faceIndex) const +{ + outT = FLT_MAX; + TraceRecursive(0, + start, + dir, + outT, + u, + v, + w, + faceSign, + faceIndex); + return (outT != FLT_MAX); +} + +VHACD::Vect3 AABBTree::GetCenter() const +{ + return m_nodes[0].m_extents.GetCenter(); +} + +VHACD::Vect3 AABBTree::GetMinExtents() const +{ + return m_nodes[0].m_extents.GetMin(); +} + +VHACD::Vect3 AABBTree::GetMaxExtents() const +{ + return m_nodes[0].m_extents.GetMax(); +} + +bool AABBTree::GetClosestPointWithinDistance(const VHACD::Vect3& point, + double maxDistance, + VHACD::Vect3& closestPoint) const +{ + double dis, v, w; + uint32_t faceIndex; + bool hit = GetClosestPointWithinDistance(point, + maxDistance, + dis, + v, + w, + faceIndex, + closestPoint); + return hit; +} + +// partition faces around the median face +uint32_t AABBTree::PartitionMedian(Node& n, + uint32_t* faces, + uint32_t numFaces) +{ + FaceSorter predicate(*m_vertices, + *m_indices, + n.m_extents.GetSize().LongestAxis()); + std::nth_element(faces, + faces + numFaces / 2, + faces + numFaces, + predicate); + + return numFaces / 2; +} + +// partition faces based on the surface area heuristic +uint32_t AABBTree::PartitionSAH(Node&, + uint32_t* faces, + uint32_t numFaces) +{ + uint32_t bestAxis = 0; + uint32_t bestIndex = 0; + double bestCost = FLT_MAX; + + for (uint32_t a = 0; a < 3; ++a) + { + // sort faces by centroids + FaceSorter predicate(*m_vertices, + *m_indices, + a); + std::sort(faces, + faces + numFaces, + predicate); + + // two passes over data to calculate upper and lower bounds + std::vector cumulativeLower(numFaces); + std::vector cumulativeUpper(numFaces); + + VHACD::BoundsAABB lower; + VHACD::BoundsAABB upper; + + for (uint32_t i = 0; i < numFaces; ++i) + { + lower.Union(m_faceBounds[faces[i]]); + upper.Union(m_faceBounds[faces[numFaces - i - 1]]); + + cumulativeLower[i] = lower.SurfaceArea(); + cumulativeUpper[numFaces - i - 1] = upper.SurfaceArea(); + } + + double invTotalSA = double(1.0) / cumulativeUpper[0]; + + // test all split positions + for (uint32_t i = 0; i < numFaces - 1; ++i) + { + double pBelow = cumulativeLower[i] * invTotalSA; + double pAbove = cumulativeUpper[i] * invTotalSA; + + double cost = double(0.125) + (pBelow * i + pAbove * (numFaces - i)); + if (cost <= bestCost) + { + bestCost = cost; + bestIndex = i; + bestAxis = a; + } + } + } + + // re-sort by best axis + FaceSorter predicate(*m_vertices, + *m_indices, + bestAxis); + std::sort(faces, + faces + numFaces, + predicate); + + return bestIndex + 1; +} + +void AABBTree::Build() +{ + const uint32_t numFaces = uint32_t(m_indices->size()); + + // build initial list of faces + m_faces.reserve(numFaces); + + // calculate bounds of each face and store + m_faceBounds.reserve(numFaces); + + std::vector stack; + for (uint32_t i = 0; i < numFaces; ++i) + { + VHACD::BoundsAABB top = CalculateFaceBounds(&i, + 1); + + m_faces.push_back(i); + m_faceBounds.push_back(top); + } + + m_nodes.reserve(uint32_t(numFaces * double(1.5))); + + // allocate space for all the nodes + m_freeNode = 1; + + // start building + BuildRecursive(0, + m_faces.data(), + numFaces); + + assert(s_depth == 0); +} + +void AABBTree::BuildRecursive(uint32_t nodeIndex, + uint32_t* faces, + uint32_t numFaces) +{ + const uint32_t kMaxFacesPerLeaf = 6; + + // if we've run out of nodes allocate some more + if (nodeIndex >= m_nodes.size()) + { + uint32_t s = std::max(uint32_t(double(1.5) * m_nodes.size()), 512U); + m_nodes.resize(s); + } + + // a reference to the current node, need to be careful here as this reference may become invalid if array is resized + Node& n = m_nodes[nodeIndex]; + + // track max tree depth + ++s_depth; + m_treeDepth = std::max(m_treeDepth, s_depth); + + n.m_extents = CalculateFaceBounds(faces, + numFaces); + + // calculate bounds of faces and add node + if (numFaces <= kMaxFacesPerLeaf) + { + n.m_faces = faces; + n.m_numFaces = numFaces; + + ++m_leafNodes; + } + else + { + ++m_innerNodes; + + // face counts for each branch + const uint32_t leftCount = PartitionMedian(n, faces, numFaces); + // const uint32_t leftCount = PartitionSAH(n, faces, numFaces); + const uint32_t rightCount = numFaces - leftCount; + + // alloc 2 nodes + m_nodes[nodeIndex].m_children = m_freeNode; + + // allocate two nodes + m_freeNode += 2; + + // split faces in half and build each side recursively + BuildRecursive(m_nodes[nodeIndex].m_children + 0, faces, leftCount); + BuildRecursive(m_nodes[nodeIndex].m_children + 1, faces + leftCount, rightCount); + } + + --s_depth; +} + +void AABBTree::TraceRecursive(uint32_t nodeIndex, + const VHACD::Vect3& start, + const VHACD::Vect3& dir, + double& outT, + double& outU, + double& outV, + double& outW, + double& faceSign, + uint32_t& faceIndex) const +{ + const Node& node = m_nodes[nodeIndex]; + + if (node.m_faces == NULL) + { + // find closest node + const Node& leftChild = m_nodes[node.m_children + 0]; + const Node& rightChild = m_nodes[node.m_children + 1]; + + double dist[2] = { FLT_MAX, FLT_MAX }; + + IntersectRayAABB(start, + dir, + leftChild.m_extents, + dist[0]); + IntersectRayAABB(start, + dir, + rightChild.m_extents, + dist[1]); + + uint32_t closest = 0; + uint32_t furthest = 1; + + if (dist[1] < dist[0]) + { + closest = 1; + furthest = 0; + } + + if (dist[closest] < outT) + { + TraceRecursive(node.m_children + closest, + start, + dir, + outT, + outU, + outV, + outW, + faceSign, + faceIndex); + } + + if (dist[furthest] < outT) + { + TraceRecursive(node.m_children + furthest, + start, + dir, + outT, + outU, + outV, + outW, + faceSign, + faceIndex); + } + } + else + { + double t, u, v, w, s; + + for (uint32_t i = 0; i < node.m_numFaces; ++i) + { + uint32_t indexStart = node.m_faces[i]; + + const VHACD::Vect3& a = (*m_vertices)[(*m_indices)[indexStart].mI0]; + const VHACD::Vect3& b = (*m_vertices)[(*m_indices)[indexStart].mI1]; + const VHACD::Vect3& c = (*m_vertices)[(*m_indices)[indexStart].mI2]; + if (IntersectRayTriTwoSided(start, dir, a, b, c, t, u, v, w, s, NULL)) + { + if (t < outT) + { + outT = t; + outU = u; + outV = v; + outW = w; + faceSign = s; + faceIndex = node.m_faces[i]; + } + } + } + } +} + +bool AABBTree::GetClosestPointWithinDistance(const VHACD::Vect3& point, + const double maxDis, + double& dis, + double& v, + double& w, + uint32_t& faceIndex, + VHACD::Vect3& closest) const +{ + dis = maxDis; + faceIndex = uint32_t(~0); + double disSq = dis * dis; + + GetClosestPointWithinDistanceSqRecursive(0, + point, + disSq, + v, + w, + faceIndex, + closest); + dis = sqrt(disSq); + + return (faceIndex < (~(static_cast(0)))); +} + +void AABBTree::GetClosestPointWithinDistanceSqRecursive(uint32_t nodeIndex, + const VHACD::Vect3& point, + double& outDisSq, + double& outV, + double& outW, + uint32_t& outFaceIndex, + VHACD::Vect3& closestPoint) const +{ + const Node& node = m_nodes[nodeIndex]; + + if (node.m_faces == nullptr) + { + // find closest node + const Node& leftChild = m_nodes[node.m_children + 0]; + const Node& rightChild = m_nodes[node.m_children + 1]; + + // double dist[2] = { FLT_MAX, FLT_MAX }; + VHACD::Vect3 lp = leftChild.m_extents.ClosestPoint(point); + VHACD::Vect3 rp = rightChild.m_extents.ClosestPoint(point); + + + uint32_t closest = 0; + uint32_t furthest = 1; + double dcSq = (point - lp).GetNormSquared(); + double dfSq = (point - rp).GetNormSquared(); + if (dfSq < dcSq) + { + closest = 1; + furthest = 0; + std::swap(dfSq, dcSq); + } + + if (dcSq < outDisSq) + { + GetClosestPointWithinDistanceSqRecursive(node.m_children + closest, + point, + outDisSq, + outV, + outW, + outFaceIndex, + closestPoint); + } + + if (dfSq < outDisSq) + { + GetClosestPointWithinDistanceSqRecursive(node.m_children + furthest, + point, + outDisSq, + outV, + outW, + outFaceIndex, + closestPoint); + } + } + else + { + + double v, w; + for (uint32_t i = 0; i < node.m_numFaces; ++i) + { + uint32_t indexStart = node.m_faces[i]; + + const VHACD::Vect3& a = (*m_vertices)[(*m_indices)[indexStart].mI0]; + const VHACD::Vect3& b = (*m_vertices)[(*m_indices)[indexStart].mI1]; + const VHACD::Vect3& c = (*m_vertices)[(*m_indices)[indexStart].mI2]; + + VHACD::Vect3 cp = ClosestPointOnTriangle(a, b, c, point, v, w); + double disSq = (cp - point).GetNormSquared(); + + if (disSq < outDisSq) + { + closestPoint = cp; + outDisSq = disSq; + outV = v; + outW = w; + outFaceIndex = node.m_faces[i]; + } + } + } +} + +VHACD::BoundsAABB AABBTree::CalculateFaceBounds(uint32_t* faces, + uint32_t numFaces) +{ + VHACD::Vect3 minExtents( FLT_MAX); + VHACD::Vect3 maxExtents(-FLT_MAX); + + // calculate face bounds + for (uint32_t i = 0; i < numFaces; ++i) + { + VHACD::Vect3 a = (*m_vertices)[(*m_indices)[faces[i]].mI0]; + VHACD::Vect3 b = (*m_vertices)[(*m_indices)[faces[i]].mI1]; + VHACD::Vect3 c = (*m_vertices)[(*m_indices)[faces[i]].mI2]; + + minExtents = a.CWiseMin(minExtents); + maxExtents = a.CWiseMax(maxExtents); + + minExtents = b.CWiseMin(minExtents); + maxExtents = b.CWiseMax(maxExtents); + + minExtents = c.CWiseMin(minExtents); + maxExtents = c.CWiseMax(maxExtents); + } + + return VHACD::BoundsAABB(minExtents, + maxExtents); +} + +enum class VoxelValue : uint8_t +{ + PRIMITIVE_UNDEFINED = 0, + PRIMITIVE_OUTSIDE_SURFACE_TOWALK = 1, + PRIMITIVE_OUTSIDE_SURFACE = 2, + PRIMITIVE_INSIDE_SURFACE = 3, + PRIMITIVE_ON_SURFACE = 4 +}; + +class Volume +{ +public: + void Voxelize(const std::vector& points, + const std::vector& triangles, + const size_t dim, + FillMode fillMode, + const AABBTree& aabbTree); + + void RaycastFill(const AABBTree& aabbTree); + + void SetVoxel(const size_t i, + const size_t j, + const size_t k, + VoxelValue value); + + VoxelValue& GetVoxel(const size_t i, + const size_t j, + const size_t k); + + const VoxelValue& GetVoxel(const size_t i, + const size_t j, + const size_t k) const; + + const std::vector& GetSurfaceVoxels() const; + const std::vector& GetInteriorVoxels() const; + + double GetScale() const; + const VHACD::BoundsAABB& GetBounds() const; + const VHACD::Vector3& GetDimensions() const; + + VHACD::BoundsAABB m_bounds; + double m_scale{ 1.0 }; + VHACD::Vector3 m_dim{ 0 }; + size_t m_numVoxelsOnSurface{ 0 }; + size_t m_numVoxelsInsideSurface{ 0 }; + size_t m_numVoxelsOutsideSurface{ 0 }; + std::vector m_data; +private: + + void MarkOutsideSurface(const size_t i0, + const size_t j0, + const size_t k0, + const size_t i1, + const size_t j1, + const size_t k1); + void FillOutsideSurface(); + + void FillInsideSurface(); + + std::vector m_surfaceVoxels; + std::vector m_interiorVoxels; +}; + +bool PlaneBoxOverlap(const VHACD::Vect3& normal, + const VHACD::Vect3& vert, + const VHACD::Vect3& maxbox) +{ + int32_t q; + VHACD::Vect3 vmin; + VHACD::Vect3 vmax; + double v; + for (q = 0; q < 3; q++) + { + v = vert[q]; + if (normal[q] > double(0.0)) + { + vmin[q] = -maxbox[q] - v; + vmax[q] = maxbox[q] - v; + } + else + { + vmin[q] = maxbox[q] - v; + vmax[q] = -maxbox[q] - v; + } + } + if (normal.Dot(vmin) > double(0.0)) + return false; + if (normal.Dot(vmax) >= double(0.0)) + return true; + return false; +} + +bool AxisTest(double a, double b, double fa, double fb, + double v0, double v1, double v2, double v3, + double boxHalfSize1, double boxHalfSize2) +{ + double p0 = a * v0 + b * v1; + double p1 = a * v2 + b * v3; + + double min = std::min(p0, p1); + double max = std::max(p0, p1); + + double rad = fa * boxHalfSize1 + fb * boxHalfSize2; + if (min > rad || max < -rad) + { + return false; + } + + return true; +} + +bool TriBoxOverlap(const VHACD::Vect3& boxCenter, + const VHACD::Vect3& boxHalfSize, + const VHACD::Vect3& triVer0, + const VHACD::Vect3& triVer1, + const VHACD::Vect3& triVer2) +{ + /* use separating axis theorem to test overlap between triangle and box */ + /* need to test for overlap in these directions: */ + /* 1) the {x,y,z}-directions (actually, since we use the AABB of the triangle */ + /* we do not even need to test these) */ + /* 2) normal of the triangle */ + /* 3) crossproduct(edge from tri, {x,y,z}-direction) */ + /* this gives 3x3=9 more tests */ + + VHACD::Vect3 v0 = triVer0 - boxCenter; + VHACD::Vect3 v1 = triVer1 - boxCenter; + VHACD::Vect3 v2 = triVer2 - boxCenter; + VHACD::Vect3 e0 = v1 - v0; + VHACD::Vect3 e1 = v2 - v1; + VHACD::Vect3 e2 = v0 - v2; + + /* This is the fastest branch on Sun */ + /* move everything so that the boxcenter is in (0,0,0) */ + + /* Bullet 3: */ + /* test the 9 tests first (this was faster) */ + double fex = fabs(e0[0]); + double fey = fabs(e0[1]); + double fez = fabs(e0[2]); + + /* + * These should use Get*() instead of subscript for consistency, but the function calls are long enough already + */ + if (!AxisTest( e0[2], -e0[1], fez, fey, v0[1], v0[2], v2[1], v2[2], boxHalfSize[1], boxHalfSize[2])) return 0; // X01 + if (!AxisTest(-e0[2], e0[0], fez, fex, v0[0], v0[2], v2[0], v2[2], boxHalfSize[0], boxHalfSize[2])) return 0; // Y02 + if (!AxisTest( e0[1], -e0[0], fey, fex, v1[0], v1[1], v2[0], v2[1], boxHalfSize[0], boxHalfSize[1])) return 0; // Z12 + + fex = fabs(e1[0]); + fey = fabs(e1[1]); + fez = fabs(e1[2]); + + if (!AxisTest( e1[2], -e1[1], fez, fey, v0[1], v0[2], v2[1], v2[2], boxHalfSize[1], boxHalfSize[2])) return 0; // X01 + if (!AxisTest(-e1[2], e1[0], fez, fex, v0[0], v0[2], v2[0], v2[2], boxHalfSize[0], boxHalfSize[2])) return 0; // Y02 + if (!AxisTest( e1[1], -e1[0], fey, fex, v0[0], v0[1], v1[0], v1[1], boxHalfSize[0], boxHalfSize[2])) return 0; // Z0 + + fex = fabs(e2[0]); + fey = fabs(e2[1]); + fez = fabs(e2[2]); + + if (!AxisTest( e2[2], -e2[1], fez, fey, v0[1], v0[2], v1[1], v1[2], boxHalfSize[1], boxHalfSize[2])) return 0; // X2 + if (!AxisTest(-e2[2], e2[0], fez, fex, v0[0], v0[2], v1[0], v1[2], boxHalfSize[0], boxHalfSize[2])) return 0; // Y1 + if (!AxisTest( e2[1], -e2[0], fey, fex, v1[0], v1[1], v2[0], v2[1], boxHalfSize[0], boxHalfSize[1])) return 0; // Z12 + + /* Bullet 1: */ + /* first test overlap in the {x,y,z}-directions */ + /* find min, max of the triangle each direction, and test for overlap in */ + /* that direction -- this is equivalent to testing a minimal AABB around */ + /* the triangle against the AABB */ + + /* test in 0-direction */ + double min = std::min({v0.GetX(), v1.GetX(), v2.GetX()}); + double max = std::max({v0.GetX(), v1.GetX(), v2.GetX()}); + if (min > boxHalfSize[0] || max < -boxHalfSize[0]) + return false; + + /* test in 1-direction */ + min = std::min({v0.GetY(), v1.GetY(), v2.GetY()}); + max = std::max({v0.GetY(), v1.GetY(), v2.GetY()}); + if (min > boxHalfSize[1] || max < -boxHalfSize[1]) + return false; + + /* test in getZ-direction */ + min = std::min({v0.GetZ(), v1.GetZ(), v2.GetZ()}); + max = std::max({v0.GetZ(), v1.GetZ(), v2.GetZ()}); + if (min > boxHalfSize[2] || max < -boxHalfSize[2]) + return false; + + /* Bullet 2: */ + /* test if the box intersects the plane of the triangle */ + /* compute plane equation of triangle: normal*x+d=0 */ + VHACD::Vect3 normal = e0.Cross(e1); + + if (!PlaneBoxOverlap(normal, v0, boxHalfSize)) + return false; + return true; /* box and triangle overlaps */ +} + +void Volume::Voxelize(const std::vector& points, + const std::vector& indices, + const size_t dimensions, + FillMode fillMode, + const AABBTree& aabbTree) +{ + double a = std::pow(dimensions, 0.33); + size_t dim = a * double(1.5); + dim = std::max(dim, size_t(32)); + + if (points.size() == 0) + { + return; + } + + m_bounds = BoundsAABB(points); + + VHACD::Vect3 d = m_bounds.GetSize(); + double r; + // Equal comparison is important here to avoid taking the last branch when d[0] == d[1] with d[2] being the smallest + // dimension. That would lead to dimensions in i and j to be a lot bigger than expected and make the amount of + // voxels in the volume totally unmanageable. + if (d[0] >= d[1] && d[0] >= d[2]) + { + r = d[0]; + m_dim[0] = uint32_t(dim); + m_dim[1] = uint32_t(2 + static_cast(dim * d[1] / d[0])); + m_dim[2] = uint32_t(2 + static_cast(dim * d[2] / d[0])); + } + else if (d[1] >= d[0] && d[1] >= d[2]) + { + r = d[1]; + m_dim[1] = uint32_t(dim); + m_dim[0] = uint32_t(2 + static_cast(dim * d[0] / d[1])); + m_dim[2] = uint32_t(2 + static_cast(dim * d[2] / d[1])); + } + else + { + r = d[2]; + m_dim[2] = uint32_t(dim); + m_dim[0] = uint32_t(2 + static_cast(dim * d[0] / d[2])); + m_dim[1] = uint32_t(2 + static_cast(dim * d[1] / d[2])); + } + + m_scale = r / (dim - 1); + double invScale = (dim - 1) / r; + + m_data = std::vector(m_dim[0] * m_dim[1] * m_dim[2], + VoxelValue::PRIMITIVE_UNDEFINED); + m_numVoxelsOnSurface = 0; + m_numVoxelsInsideSurface = 0; + m_numVoxelsOutsideSurface = 0; + + VHACD::Vect3 p[3]; + VHACD::Vect3 boxcenter; + VHACD::Vect3 pt; + const VHACD::Vect3 boxhalfsize(double(0.5)); + for (size_t t = 0; t < indices.size(); ++t) + { + size_t i0, j0, k0; + size_t i1, j1, k1; + VHACD::Vector3 tri = indices[t]; + for (int32_t c = 0; c < 3; ++c) + { + pt = points[tri[c]]; + + p[c] = (pt - m_bounds.GetMin()) * invScale; + + size_t i = static_cast(p[c][0] + double(0.5)); + size_t j = static_cast(p[c][1] + double(0.5)); + size_t k = static_cast(p[c][2] + double(0.5)); + + assert(i < m_dim[0] && i >= 0 && j < m_dim[1] && j >= 0 && k < m_dim[2] && k >= 0); + + if (c == 0) + { + i0 = i1 = i; + j0 = j1 = j; + k0 = k1 = k; + } + else + { + i0 = std::min(i0, i); + j0 = std::min(j0, j); + k0 = std::min(k0, k); + + i1 = std::max(i1, i); + j1 = std::max(j1, j); + k1 = std::max(k1, k); + } + } + if (i0 > 0) + --i0; + if (j0 > 0) + --j0; + if (k0 > 0) + --k0; + if (i1 < m_dim[0]) + ++i1; + if (j1 < m_dim[1]) + ++j1; + if (k1 < m_dim[2]) + ++k1; + for (size_t i_id = i0; i_id < i1; ++i_id) + { + boxcenter[0] = uint32_t(i_id); + for (size_t j_id = j0; j_id < j1; ++j_id) + { + boxcenter[1] = uint32_t(j_id); + for (size_t k_id = k0; k_id < k1; ++k_id) + { + boxcenter[2] = uint32_t(k_id); + bool res = TriBoxOverlap(boxcenter, + boxhalfsize, + p[0], + p[1], + p[2]); + VoxelValue& value = GetVoxel(i_id, + j_id, + k_id); + if ( res + && value == VoxelValue::PRIMITIVE_UNDEFINED) + { + value = VoxelValue::PRIMITIVE_ON_SURFACE; + ++m_numVoxelsOnSurface; + m_surfaceVoxels.emplace_back(uint32_t(i_id), + uint32_t(j_id), + uint32_t(k_id)); + } + } + } + } + } + + if (fillMode == FillMode::SURFACE_ONLY) + { + const size_t i0_local = m_dim[0]; + const size_t j0_local = m_dim[1]; + const size_t k0_local = m_dim[2]; + for (size_t i_id = 0; i_id < i0_local; ++i_id) + { + for (size_t j_id = 0; j_id < j0_local; ++j_id) + { + for (size_t k_id = 0; k_id < k0_local; ++k_id) + { + const VoxelValue& voxel = GetVoxel(i_id, + j_id, + k_id); + if (voxel != VoxelValue::PRIMITIVE_ON_SURFACE) + { + SetVoxel(i_id, + j_id, + k_id, + VoxelValue::PRIMITIVE_OUTSIDE_SURFACE); + } + } + } + } + } + else if (fillMode == FillMode::FLOOD_FILL) + { + /* + * Marking the outside edges of the voxel cube to be outside surfaces to walk + */ + MarkOutsideSurface(0, 0, 0, m_dim[0], m_dim[1], 1); + MarkOutsideSurface(0, 0, m_dim[2] - 1, m_dim[0], m_dim[1], m_dim[2]); + MarkOutsideSurface(0, 0, 0, m_dim[0], 1, m_dim[2]); + MarkOutsideSurface(0, m_dim[1] - 1, 0, m_dim[0], m_dim[1], m_dim[2]); + MarkOutsideSurface(0, 0, 0, 1, m_dim[1], m_dim[2]); + MarkOutsideSurface(m_dim[0] - 1, 0, 0, m_dim[0], m_dim[1], m_dim[2]); + FillOutsideSurface(); + FillInsideSurface(); + } + else if (fillMode == FillMode::RAYCAST_FILL) + { + RaycastFill(aabbTree); + } +} + +void Volume::RaycastFill(const AABBTree& aabbTree) +{ + const uint32_t i0 = m_dim[0]; + const uint32_t j0 = m_dim[1]; + const uint32_t k0 = m_dim[2]; + + size_t maxSize = i0 * j0 * k0; + + std::vector temp; + temp.reserve(maxSize); + uint32_t count{ 0 }; + m_numVoxelsInsideSurface = 0; + for (uint32_t i = 0; i < i0; ++i) + { + for (uint32_t j = 0; j < j0; ++j) + { + for (uint32_t k = 0; k < k0; ++k) + { + VoxelValue& voxel = GetVoxel(i, j, k); + if (voxel != VoxelValue::PRIMITIVE_ON_SURFACE) + { + VHACD::Vect3 start = VHACD::Vect3(i, j, k) * m_scale + m_bounds.GetMin(); + + uint32_t insideCount = 0; + uint32_t outsideCount = 0; + + VHACD::Vect3 directions[6] = { + VHACD::Vect3( 1, 0, 0), + VHACD::Vect3(-1, 0, 0), // this was 1, 0, 0 in the original code, but looks wrong + VHACD::Vect3( 0, 1, 0), + VHACD::Vect3( 0, -1, 0), + VHACD::Vect3( 0, 0, 1), + VHACD::Vect3( 0, 0, -1) + }; + + for (uint32_t r = 0; r < 6; r++) + { + aabbTree.TraceRay(start, + directions[r], + insideCount, + outsideCount); + // Early out if we hit the outside of the mesh + if (outsideCount) + { + break; + } + // Early out if we accumulated 3 inside hits + if (insideCount >= 3) + { + break; + } + } + + if (outsideCount == 0 && insideCount >= 3) + { + voxel = VoxelValue::PRIMITIVE_INSIDE_SURFACE; + temp.emplace_back(i, j, k); + count++; + m_numVoxelsInsideSurface++; + } + else + { + voxel = VoxelValue::PRIMITIVE_OUTSIDE_SURFACE; + } + } + } + } + } + + if (count) + { + m_interiorVoxels = std::move(temp); + } +} + +void Volume::SetVoxel(const size_t i, + const size_t j, + const size_t k, + VoxelValue value) +{ + assert(i < m_dim[0] || i >= 0); + assert(j < m_dim[1] || j >= 0); + assert(k < m_dim[2] || k >= 0); + + m_data[k + j * m_dim[2] + i * m_dim[1] * m_dim[2]] = value; +} + +VoxelValue& Volume::GetVoxel(const size_t i, + const size_t j, + const size_t k) +{ + assert(i < m_dim[0] || i >= 0); + assert(j < m_dim[1] || j >= 0); + assert(k < m_dim[2] || k >= 0); + return m_data[k + j * m_dim[2] + i * m_dim[1] * m_dim[2]]; +} + +const VoxelValue& Volume::GetVoxel(const size_t i, + const size_t j, + const size_t k) const +{ + assert(i < m_dim[0] || i >= 0); + assert(j < m_dim[1] || j >= 0); + assert(k < m_dim[2] || k >= 0); + return m_data[k + j * m_dim[2] + i * m_dim[1] * m_dim[2]]; +} + +const std::vector& Volume::GetSurfaceVoxels() const +{ + return m_surfaceVoxels; +} + +const std::vector& Volume::GetInteriorVoxels() const +{ + return m_interiorVoxels; +} + +double Volume::GetScale() const +{ + return m_scale; +} + +const VHACD::BoundsAABB& Volume::GetBounds() const +{ + return m_bounds; +} + +const VHACD::Vector3& Volume::GetDimensions() const +{ + return m_dim; +} + +void Volume::MarkOutsideSurface(const size_t i0, + const size_t j0, + const size_t k0, + const size_t i1, + const size_t j1, + const size_t k1) +{ + for (size_t i = i0; i < i1; ++i) + { + for (size_t j = j0; j < j1; ++j) + { + for (size_t k = k0; k < k1; ++k) + { + VoxelValue& v = GetVoxel(i, j, k); + if (v == VoxelValue::PRIMITIVE_UNDEFINED) + { + v = VoxelValue::PRIMITIVE_OUTSIDE_SURFACE_TOWALK; + } + } + } + } +} + +inline void WalkForward(int64_t start, + int64_t end, + VoxelValue* ptr, + int64_t stride, + int64_t maxDistance) +{ + for (int64_t i = start, count = 0; + count < maxDistance && i < end && *ptr == VoxelValue::PRIMITIVE_UNDEFINED; + ++i, ptr += stride, ++count) + { + *ptr = VoxelValue::PRIMITIVE_OUTSIDE_SURFACE_TOWALK; + } +} + +inline void WalkBackward(int64_t start, + int64_t end, + VoxelValue* ptr, + int64_t stride, + int64_t maxDistance) +{ + for (int64_t i = start, count = 0; + count < maxDistance && i >= end && *ptr == VoxelValue::PRIMITIVE_UNDEFINED; + --i, ptr -= stride, ++count) + { + *ptr = VoxelValue::PRIMITIVE_OUTSIDE_SURFACE_TOWALK; + } +} + +void Volume::FillOutsideSurface() +{ + size_t voxelsWalked = 0; + const int64_t i0 = m_dim[0]; + const int64_t j0 = m_dim[1]; + const int64_t k0 = m_dim[2]; + + // Avoid striding too far in each direction to stay in L1 cache as much as possible. + // The cache size required for the walk is roughly (4 * walkDistance * 64) since + // the k direction doesn't count as it's walking byte per byte directly in a cache lines. + // ~16k is required for a walk distance of 64 in each directions. + const size_t walkDistance = 64; + + // using the stride directly instead of calling GetVoxel for each iterations saves + // a lot of multiplications and pipeline stalls due to data dependencies on imul. + const size_t istride = &GetVoxel(1, 0, 0) - &GetVoxel(0, 0, 0); + const size_t jstride = &GetVoxel(0, 1, 0) - &GetVoxel(0, 0, 0); + const size_t kstride = &GetVoxel(0, 0, 1) - &GetVoxel(0, 0, 0); + + // It might seem counter intuitive to go over the whole voxel range multiple times + // but since we do the run in memory order, it leaves us with far fewer cache misses + // than a BFS algorithm and it has the additional benefit of not requiring us to + // store and manipulate a fifo for recursion that might become huge when the number + // of voxels is large. + // This will outperform the BFS algorithm by several orders of magnitude in practice. + do + { + voxelsWalked = 0; + for (int64_t i = 0; i < i0; ++i) + { + for (int64_t j = 0; j < j0; ++j) + { + for (int64_t k = 0; k < k0; ++k) + { + VoxelValue& voxel = GetVoxel(i, j, k); + if (voxel == VoxelValue::PRIMITIVE_OUTSIDE_SURFACE_TOWALK) + { + voxelsWalked++; + voxel = VoxelValue::PRIMITIVE_OUTSIDE_SURFACE; + + // walk in each direction to mark other voxel that should be walked. + // this will generate a 3d pattern that will help the overall + // algorithm converge faster while remaining cache friendly. + WalkForward(k + 1, k0, &voxel + kstride, kstride, walkDistance); + WalkBackward(k - 1, 0, &voxel - kstride, kstride, walkDistance); + + WalkForward(j + 1, j0, &voxel + jstride, jstride, walkDistance); + WalkBackward(j - 1, 0, &voxel - jstride, jstride, walkDistance); + + WalkForward(i + 1, i0, &voxel + istride, istride, walkDistance); + WalkBackward(i - 1, 0, &voxel - istride, istride, walkDistance); + } + } + } + } + + m_numVoxelsOutsideSurface += voxelsWalked; + } while (voxelsWalked != 0); +} + +void Volume::FillInsideSurface() +{ + const uint32_t i0 = uint32_t(m_dim[0]); + const uint32_t j0 = uint32_t(m_dim[1]); + const uint32_t k0 = uint32_t(m_dim[2]); + + size_t maxSize = i0 * j0 * k0; + + std::vector temp; + temp.reserve(maxSize); + uint32_t count{ 0 }; + + for (uint32_t i = 0; i < i0; ++i) + { + for (uint32_t j = 0; j < j0; ++j) + { + for (uint32_t k = 0; k < k0; ++k) + { + VoxelValue& v = GetVoxel(i, j, k); + if (v == VoxelValue::PRIMITIVE_UNDEFINED) + { + v = VoxelValue::PRIMITIVE_INSIDE_SURFACE; + temp.emplace_back(i, j, k); + count++; + ++m_numVoxelsInsideSurface; + } + } + } + } + + if ( count ) + { + m_interiorVoxels = std::move(temp); + } +} + +//****************************************************************************************** +// ShrinkWrap helper class +//****************************************************************************************** +// This is a code snippet which 'shrinkwraps' a convex hull +// to a source mesh. +// +// It is a somewhat complicated algorithm. It works as follows: +// +// * Step #1 : Compute the mean unit normal vector for each vertex in the convex hull +// * Step #2 : For each vertex in the conex hull we project is slightly outwards along the mean normal vector +// * Step #3 : We then raycast from this slightly extruded point back into the opposite direction of the mean normal vector +// resulting in a raycast from slightly beyond the vertex in the hull into the source mesh we are trying +// to 'shrink wrap' against +// * Step #4 : If the raycast fails we leave the original vertex alone +// * Step #5 : If the raycast hits a backface we leave the original vertex alone +// * Step #6 : If the raycast hits too far away (no more than a certain threshold distance) we live it alone +// * Step #7 : If the point we hit on the source mesh is not still within the convex hull, we reject it. +// * Step #8 : If all of the previous conditions are met, then we take the raycast hit location as the 'new position' +// * Step #9 : Once all points have been projected, if possible, we need to recompute the convex hull again based on these shrinkwrapped points +// * Step #10 : In theory that should work.. let's see... + +//*********************************************************************************************** +// QuickHull implementation +//*********************************************************************************************** + +////////////////////////////////////////////////////////////////////////// +// Quickhull base class holding the hull during construction +////////////////////////////////////////////////////////////////////////// +class QuickHull +{ +public: + uint32_t ComputeConvexHull(const std::vector& vertices, + uint32_t maxHullVertices); + + const std::vector& GetVertices() const; + const std::vector& GetIndices() const; + +private: + std::vector m_vertices; + std::vector m_indices; +}; + +uint32_t QuickHull::ComputeConvexHull(const std::vector& vertices, + uint32_t maxHullVertices) +{ + m_indices.clear(); + + VHACD::ConvexHull ch(vertices, + double(0.0001), + maxHullVertices); + + auto& vlist = ch.GetVertexPool(); + if ( !vlist.empty() ) + { + size_t vcount = vlist.size(); + m_vertices.resize(vcount); + std::copy(vlist.begin(), + vlist.end(), + m_vertices.begin()); + } + + for (std::list::const_iterator node = ch.GetList().begin(); node != ch.GetList().end(); ++node) + { + const VHACD::ConvexHullFace& face = *node; + m_indices.emplace_back(face.m_index[0], + face.m_index[1], + face.m_index[2]); + } + + return uint32_t(m_indices.size()); +} + +const std::vector& QuickHull::GetVertices() const +{ + return m_vertices; +} + +const std::vector& QuickHull::GetIndices() const +{ + return m_indices; +} + +//****************************************************************************************** +// Implementation of the ShrinkWrap function +//****************************************************************************************** + +void ShrinkWrap(SimpleMesh& sourceConvexHull, + const AABBTree& aabbTree, + uint32_t maxHullVertexCount, + double distanceThreshold, + bool doShrinkWrap) +{ + std::vector verts; // New verts for the new convex hull + verts.reserve(sourceConvexHull.m_vertices.size()); + // Examine each vertex and see if it is within the voxel distance. + // If it is, then replace the point with the shrinkwrapped / projected point + for (uint32_t j = 0; j < sourceConvexHull.m_vertices.size(); j++) + { + VHACD::Vertex& p = sourceConvexHull.m_vertices[j]; + if (doShrinkWrap) + { + VHACD::Vect3 closest; + if (aabbTree.GetClosestPointWithinDistance(p, distanceThreshold, closest)) + { + p = closest; + } + } + verts.emplace_back(p); + } + // Final step is to recompute the convex hull + VHACD::QuickHull qh; + uint32_t tcount = qh.ComputeConvexHull(verts, + maxHullVertexCount); + if (tcount) + { + sourceConvexHull.m_vertices = qh.GetVertices(); + sourceConvexHull.m_indices = qh.GetIndices(); + } +} + +//******************************************************************************************************************** + +#if !VHACD_DISABLE_THREADING + +//******************************************************************************************************************** +// Definition of the ThreadPool +//******************************************************************************************************************** + +class ThreadPool { + public: + ThreadPool(); + ThreadPool(int worker); + ~ThreadPool(); + template + auto enqueue(F&& f, Args&& ... args) +#ifndef __cpp_lib_is_invocable + -> std::future< typename std::result_of< F( Args... ) >::type>; +#else + -> std::future< typename std::invoke_result_t>; +#endif + private: + std::vector workers; + std::deque> tasks; + std::mutex task_mutex; + std::condition_variable cv; + bool closed; + int count; +}; + +ThreadPool::ThreadPool() + : ThreadPool(1) +{ +} + +ThreadPool::ThreadPool(int worker) + : closed(false) + , count(0) +{ + workers.reserve(worker); + for(int i=0; i lock(this->task_mutex); + while(true) + { + while (this->tasks.empty()) + { + if (this->closed) + { + return; + } + this->cv.wait(lock); + } + auto task = this->tasks.front(); + this->tasks.pop_front(); + lock.unlock(); + task(); + lock.lock(); + } + } + ); + } +} + +template +auto ThreadPool::enqueue(F&& f, Args&& ... args) +#ifndef __cpp_lib_is_invocable + -> std::future< typename std::result_of< F( Args... ) >::type> +#else + -> std::future< typename std::invoke_result_t> +#endif +{ + +#ifndef __cpp_lib_is_invocable + using return_type = typename std::result_of< F( Args... ) >::type; +#else + using return_type = typename std::invoke_result_t< F, Args... >; +#endif + auto task = std::make_shared > ( + std::bind(std::forward(f), std::forward(args)...) + ); + auto result = task->get_future(); + + { + std::unique_lock lock(task_mutex); + if (!closed) + { + tasks.emplace_back([task] + { + (*task)(); + }); + cv.notify_one(); + } + } + + return result; +} + +ThreadPool::~ThreadPool() { + { + std::unique_lock lock(task_mutex); + closed = true; + } + cv.notify_all(); + for (auto && worker : workers) + { + worker.join(); + } +} +#endif + +enum class Stages +{ + COMPUTE_BOUNDS_OF_INPUT_MESH, + REINDEXING_INPUT_MESH, + CREATE_RAYCAST_MESH, + VOXELIZING_INPUT_MESH, + BUILD_INITIAL_CONVEX_HULL, + PERFORMING_DECOMPOSITION, + INITIALIZING_CONVEX_HULLS_FOR_MERGING, + COMPUTING_COST_MATRIX, + MERGING_CONVEX_HULLS, + FINALIZING_RESULTS, + NUM_STAGES +}; + +class VHACDCallbacks +{ +public: + virtual void ProgressUpdate(Stages stage, + double stageProgress, + const char *operation) = 0; + virtual bool IsCanceled() const = 0; + + virtual ~VHACDCallbacks() = default; +}; + +enum class SplitAxis +{ + X_AXIS_NEGATIVE, + X_AXIS_POSITIVE, + Y_AXIS_NEGATIVE, + Y_AXIS_POSITIVE, + Z_AXIS_NEGATIVE, + Z_AXIS_POSITIVE, +}; + +// This class represents a collection of voxels, the convex hull +// which surrounds them, and a triangle mesh representation of those voxels +class VoxelHull +{ +public: + + // This method constructs a new VoxelHull based on a plane split of the parent + // convex hull + VoxelHull(const VoxelHull& parent, + SplitAxis axis, + uint32_t splitLoc); + + // Here we construct the initial convex hull around the + // entire voxel set + VoxelHull(Volume& voxels, + const IVHACD::Parameters ¶ms, + VHACDCallbacks *callbacks); + + ~VoxelHull() = default; + + // Helper method to refresh the min/max voxel bounding region + void MinMaxVoxelRegion(const Voxel &v); + + void BuildRaycastMesh(); + + // We now compute the convex hull relative to a triangle mesh generated + // from the voxels + void ComputeConvexHull(); + + // Returns true if this convex hull should be considered done + bool IsComplete(); + + + // Convert a voxel position into it's correct double precision location + VHACD::Vect3 GetPoint(const int32_t x, + const int32_t y, + const int32_t z, + const double scale, + const VHACD::Vect3& bmin) const; + + // Sees if we have already got an index for this voxel position. + // If the voxel position has already been indexed, we just return + // that index value. + // If not, then we convert it into the floating point position and + // add it to the index map + uint32_t GetVertexIndex(const VHACD::Vector3& p); + + // This method will convert the voxels into an actual indexed triangle mesh of boxes + // This serves two purposes. + // The primary purpose is so that when we compute a convex hull it considered all of the points + // for each voxel, not just the center point. If you don't do this, then the hulls don't fit the + // mesh accurately enough. + // The second reason we convert it into a triangle mesh is so that we can do raycasting against it + // to search for the best splitting plane fairly quickly. That algorithm will be discussed in the + // method which computes the best splitting plane. + void BuildVoxelMesh(); + + // Convert a single voxel position into an actual 3d box mesh comprised + // of 12 triangles + void AddVoxelBox(const Voxel &v); + + // Add the triangle represented by these 3 indices into the 'box' set of vertices + // to the output mesh + void AddTri(const std::array, 8>& box, + uint32_t i1, + uint32_t i2, + uint32_t i3); + + // Here we convert from voxel space to a 3d position, index it, and add + // the triangle positions and indices for the output mesh + void AddTriangle(const VHACD::Vector3& p1, + const VHACD::Vector3& p2, + const VHACD::Vector3& p3); + + // When computing the split plane, we start by simply + // taking the midpoint of the longest side. However, + // we can also search the surface and look for the greatest + // spot of concavity and use that as the split location. + // This will make the convex decomposition more efficient + // as it will tend to cut across the greatest point of + // concavity on the surface. + SplitAxis ComputeSplitPlane(uint32_t& location); + + VHACD::Vect3 GetPosition(const VHACD::Vector3& ip) const; + + double Raycast(const VHACD::Vector3& p1, + const VHACD::Vector3& p2) const; + + bool FindConcavity(uint32_t idx, + uint32_t& splitLoc); + + // Finding the greatest area of concavity.. + bool FindConcavityX(uint32_t& splitLoc); + + // Finding the greatest area of concavity.. + bool FindConcavityY(uint32_t& splitLoc); + + // Finding the greatest area of concavity.. + bool FindConcavityZ(uint32_t& splitLoc); + + // This operation is performed in a background thread. + // It splits the voxels by a plane + void PerformPlaneSplit(); + + // Used only for debugging. Saves the voxelized mesh to disk + // Optionally saves the original source mesh as well for comparison + void SaveVoxelMesh(const SimpleMesh& inputMesh, + bool saveVoxelMesh, + bool saveSourceMesh); + + void SaveOBJ(const char* fname, + const VoxelHull* h); + + void SaveOBJ(const char* fname); + +private: + void WriteOBJ(FILE* fph, + const std::vector& vertices, + const std::vector& indices, + uint32_t baseIndex); +public: + + SplitAxis m_axis{ SplitAxis::X_AXIS_NEGATIVE }; + Volume* m_voxels{ nullptr }; // The voxelized data set + double m_voxelScale{ 0 }; // Size of a single voxel + double m_voxelScaleHalf{ 0 }; // 1/2 of the size of a single voxel + VHACD::BoundsAABB m_voxelBounds; + VHACD::Vect3 m_voxelAdjust; // Minimum coordinates of the voxel space, with adjustment + uint32_t m_depth{ 0 }; // How deep in the recursion of the binary tree this hull is + uint32_t m_index{ 0 }; // Each convex hull is given a unique id to distinguish it from the others + double m_volumeError{ 0 }; // The percentage error from the convex hull volume vs. the voxel volume + double m_voxelVolume{ 0 }; // The volume of the voxels + double m_hullVolume{ 0 }; // The volume of the enclosing convex hull + + std::unique_ptr m_convexHull{ nullptr }; // The convex hull which encloses this set of voxels. + std::vector m_surfaceVoxels; // The voxels which are on the surface of the source mesh. + std::vector m_newSurfaceVoxels; // Voxels which are on the surface as a result of a plane split + std::vector m_interiorVoxels; // Voxels which are part of the interior of the hull + + std::unique_ptr m_hullA{ nullptr }; // hull resulting from one side of the plane split + std::unique_ptr m_hullB{ nullptr }; // hull resulting from the other side of the plane split + + // Defines the coordinates this convex hull comprises within the voxel volume + // of the entire source + VHACD::Vector3 m_1{ 0 }; + VHACD::Vector3 m_2{ 0 }; + AABBTree m_AABBTree; + std::unordered_map m_voxelIndexMap; // Maps from a voxel coordinate space into a vertex index space + std::vector m_vertices; + std::vector m_indices; + static uint32_t m_voxelHullCount; + IVHACD::Parameters m_params; + VHACDCallbacks* m_callbacks{ nullptr }; +}; + +uint32_t VoxelHull::m_voxelHullCount = 0; + +VoxelHull::VoxelHull(const VoxelHull& parent, + SplitAxis axis, + uint32_t splitLoc) + : m_axis(axis) + , m_voxels(parent.m_voxels) + , m_voxelScale(m_voxels->GetScale()) + , m_voxelScaleHalf(m_voxelScale * double(0.5)) + , m_voxelBounds(m_voxels->GetBounds()) + , m_voxelAdjust(m_voxelBounds.GetMin() - m_voxelScaleHalf) + , m_depth(parent.m_depth + 1) + , m_index(++m_voxelHullCount) + , m_1(parent.m_1) + , m_2(parent.m_2) + , m_params(parent.m_params) +{ + // Default copy the voxel region from the parent, but values will + // be adjusted next based on the split axis and location + switch ( m_axis ) + { + case SplitAxis::X_AXIS_NEGATIVE: + m_2.GetX() = splitLoc; + break; + case SplitAxis::X_AXIS_POSITIVE: + m_1.GetX() = splitLoc + 1; + break; + case SplitAxis::Y_AXIS_NEGATIVE: + m_2.GetY() = splitLoc; + break; + case SplitAxis::Y_AXIS_POSITIVE: + m_1.GetY() = splitLoc + 1; + break; + case SplitAxis::Z_AXIS_NEGATIVE: + m_2.GetZ() = splitLoc; + break; + case SplitAxis::Z_AXIS_POSITIVE: + m_1.GetZ() = splitLoc + 1; + break; + } + + // First, we copy all of the interior voxels from our parent + // which intersect our region + for (auto& i : parent.m_interiorVoxels) + { + VHACD::Vector3 v = i.GetVoxel(); + if (v.CWiseAllGE(m_1) && v.CWiseAllLE(m_2)) + { + bool newSurface = false; + switch ( m_axis ) + { + case SplitAxis::X_AXIS_NEGATIVE: + if ( v.GetX() == splitLoc ) + { + newSurface = true; + } + break; + case SplitAxis::X_AXIS_POSITIVE: + if ( v.GetX() == m_1.GetX() ) + { + newSurface = true; + } + break; + case SplitAxis::Y_AXIS_NEGATIVE: + if ( v.GetY() == splitLoc ) + { + newSurface = true; + } + break; + case SplitAxis::Y_AXIS_POSITIVE: + if ( v.GetY() == m_1.GetY() ) + { + newSurface = true; + } + break; + case SplitAxis::Z_AXIS_NEGATIVE: + if ( v.GetZ() == splitLoc ) + { + newSurface = true; + } + break; + case SplitAxis::Z_AXIS_POSITIVE: + if ( v.GetZ() == m_1.GetZ() ) + { + newSurface = true; + } + break; + } + // If his interior voxels lie directly on the split plane then + // these become new surface voxels for our patch + if ( newSurface ) + { + m_newSurfaceVoxels.push_back(i); + } + else + { + m_interiorVoxels.push_back(i); + } + } + } + // Next we copy all of the surface voxels which intersect our region + for (auto& i : parent.m_surfaceVoxels) + { + VHACD::Vector3 v = i.GetVoxel(); + if (v.CWiseAllGE(m_1) && v.CWiseAllLE(m_2)) + { + m_surfaceVoxels.push_back(i); + } + } + // Our parent's new surface voxels become our new surface voxels so long as they intersect our region + for (auto& i : parent.m_newSurfaceVoxels) + { + VHACD::Vector3 v = i.GetVoxel(); + if (v.CWiseAllGE(m_1) && v.CWiseAllLE(m_2)) + { + m_newSurfaceVoxels.push_back(i); + } + } + + // Recompute the min-max bounding box which would be different after the split occurs + m_1 = VHACD::Vector3(0x7FFFFFFF); + m_2 = VHACD::Vector3(0); + for (auto& i : m_surfaceVoxels) + { + MinMaxVoxelRegion(i); + } + for (auto& i : m_newSurfaceVoxels) + { + MinMaxVoxelRegion(i); + } + for (auto& i : m_interiorVoxels) + { + MinMaxVoxelRegion(i); + } + + BuildVoxelMesh(); + BuildRaycastMesh(); // build a raycast mesh of the voxel mesh + ComputeConvexHull(); +} + +VoxelHull::VoxelHull(Volume& voxels, + const IVHACD::Parameters& params, + VHACDCallbacks* callbacks) + : m_voxels(&voxels) + , m_voxelScale(m_voxels->GetScale()) + , m_voxelScaleHalf(m_voxelScale * double(0.5)) + , m_voxelBounds(m_voxels->GetBounds()) + , m_voxelAdjust(m_voxelBounds.GetMin() - m_voxelScaleHalf) + , m_index(++m_voxelHullCount) + // Here we get a copy of all voxels which lie on the surface mesh + , m_surfaceVoxels(m_voxels->GetSurfaceVoxels()) + // Now we get a copy of all voxels which are considered part of the 'interior' of the source mesh + , m_interiorVoxels(m_voxels->GetInteriorVoxels()) + , m_2(m_voxels->GetDimensions() - 1) + , m_params(params) + , m_callbacks(callbacks) +{ + BuildVoxelMesh(); + BuildRaycastMesh(); // build a raycast mesh of the voxel mesh + ComputeConvexHull(); +} + +void VoxelHull::MinMaxVoxelRegion(const Voxel& v) +{ + VHACD::Vector3 x = v.GetVoxel(); + m_1 = m_1.CWiseMin(x); + m_2 = m_2.CWiseMax(x); +} + +void VoxelHull::BuildRaycastMesh() +{ + // Create a raycast mesh representation of the voxelized surface mesh + if ( !m_indices.empty() ) + { + m_AABBTree = AABBTree(m_vertices, + m_indices); + } +} + +void VoxelHull::ComputeConvexHull() +{ + if ( !m_vertices.empty() ) + { + // we compute the convex hull as follows... + VHACD::QuickHull qh; + uint32_t tcount = qh.ComputeConvexHull(m_vertices, + uint32_t(m_vertices.size())); + if ( tcount ) + { + m_convexHull = std::unique_ptr(new IVHACD::ConvexHull); + + m_convexHull->m_points = qh.GetVertices(); + m_convexHull->m_triangles = qh.GetIndices(); + + VHACD::ComputeCentroid(m_convexHull->m_points, + m_convexHull->m_triangles, + m_convexHull->m_center); + m_convexHull->m_volume = VHACD::ComputeMeshVolume(m_convexHull->m_points, + m_convexHull->m_triangles); + } + } + if ( m_convexHull ) + { + m_hullVolume = m_convexHull->m_volume; + } + // This is the volume of a single voxel + double singleVoxelVolume = m_voxelScale * m_voxelScale * m_voxelScale; + size_t voxelCount = m_interiorVoxels.size() + m_newSurfaceVoxels.size() + m_surfaceVoxels.size(); + m_voxelVolume = singleVoxelVolume * double(voxelCount); + double diff = fabs(m_hullVolume - m_voxelVolume); + m_volumeError = (diff * 100) / m_voxelVolume; +} + +bool VoxelHull::IsComplete() +{ + bool ret = false; + if ( m_convexHull == nullptr ) + { + ret = true; + } + else if ( m_volumeError < m_params.m_minimumVolumePercentErrorAllowed ) + { + ret = true; + } + else if ( m_depth > m_params.m_maxRecursionDepth ) + { + ret = true; + } + else + { + // We compute the voxel width on all 3 axes and see if they are below the min threshold size + VHACD::Vector3 d = m_2 - m_1; + if ( d.GetX() <= m_params.m_minEdgeLength && + d.GetY() <= m_params.m_minEdgeLength && + d.GetZ() <= m_params.m_minEdgeLength ) + { + ret = true; + } + } + return ret; +} + +VHACD::Vect3 VoxelHull::GetPoint(const int32_t x, + const int32_t y, + const int32_t z, + const double scale, + const VHACD::Vect3& bmin) const +{ + return VHACD::Vect3(x * scale + bmin.GetX(), + y * scale + bmin.GetY(), + z * scale + bmin.GetZ()); +} + +uint32_t VoxelHull::GetVertexIndex(const VHACD::Vector3& p) +{ + uint32_t ret = 0; + uint32_t address = (p.GetX() << 20) | (p.GetY() << 10) | p.GetZ(); + auto found = m_voxelIndexMap.find(address); + if ( found != m_voxelIndexMap.end() ) + { + ret = found->second; + } + else + { + VHACD::Vect3 vertex = GetPoint(p.GetX(), + p.GetY(), + p.GetZ(), + m_voxelScale, + m_voxelAdjust); + ret = uint32_t(m_voxelIndexMap.size()); + m_voxelIndexMap[address] = ret; + m_vertices.emplace_back(vertex); + } + return ret; +} + +void VoxelHull::BuildVoxelMesh() +{ + // When we build the triangle mesh we do *not* need the interior voxels, only the ones + // which lie upon the logical surface of the mesh. + // Each time we perform a plane split, voxels which are along the splitting plane become + // 'new surface voxels'. + + for (auto& i : m_surfaceVoxels) + { + AddVoxelBox(i); + } + for (auto& i : m_newSurfaceVoxels) + { + AddVoxelBox(i); + } +} + +void VoxelHull::AddVoxelBox(const Voxel &v) +{ + // The voxel position of the upper left corner of the box + VHACD::Vector3 bmin(v.GetX(), + v.GetY(), + v.GetZ()); + // The voxel position of the lower right corner of the box + VHACD::Vector3 bmax(bmin.GetX() + 1, + bmin.GetY() + 1, + bmin.GetZ() + 1); + + // Build the set of 8 voxel positions representing + // the coordinates of the box + std::array, 8> box{{ + { bmin.GetX(), bmin.GetY(), bmin.GetZ() }, + { bmax.GetX(), bmin.GetY(), bmin.GetZ() }, + { bmax.GetX(), bmax.GetY(), bmin.GetZ() }, + { bmin.GetX(), bmax.GetY(), bmin.GetZ() }, + { bmin.GetX(), bmin.GetY(), bmax.GetZ() }, + { bmax.GetX(), bmin.GetY(), bmax.GetZ() }, + { bmax.GetX(), bmax.GetY(), bmax.GetZ() }, + { bmin.GetX(), bmax.GetY(), bmax.GetZ() } + }}; + + // Now add the 12 triangles comprising the 3d box + AddTri(box, 2, 1, 0); + AddTri(box, 3, 2, 0); + + AddTri(box, 7, 2, 3); + AddTri(box, 7, 6, 2); + + AddTri(box, 5, 1, 2); + AddTri(box, 5, 2, 6); + + AddTri(box, 5, 4, 1); + AddTri(box, 4, 0, 1); + + AddTri(box, 4, 6, 7); + AddTri(box, 4, 5, 6); + + AddTri(box, 4, 7, 0); + AddTri(box, 7, 3, 0); +} + +void VoxelHull::AddTri(const std::array, 8>& box, + uint32_t i1, + uint32_t i2, + uint32_t i3) +{ + AddTriangle(box[i1], box[i2], box[i3]); +} + +void VoxelHull::AddTriangle(const VHACD::Vector3& p1, + const VHACD::Vector3& p2, + const VHACD::Vector3& p3) +{ + uint32_t i1 = GetVertexIndex(p1); + uint32_t i2 = GetVertexIndex(p2); + uint32_t i3 = GetVertexIndex(p3); + + m_indices.emplace_back(i1, i2, i3); +} + +SplitAxis VoxelHull::ComputeSplitPlane(uint32_t& location) +{ + SplitAxis ret = SplitAxis::X_AXIS_NEGATIVE; + + VHACD::Vector3 d = m_2 - m_1; + + if ( d.GetX() >= d.GetY() && d.GetX() >= d.GetZ() ) + { + ret = SplitAxis::X_AXIS_NEGATIVE; + location = (m_2.GetX() + 1 + m_1.GetX()) / 2; + uint32_t edgeLoc; + if ( m_params.m_findBestPlane && FindConcavityX(edgeLoc) ) + { + location = edgeLoc; + } + } + else if ( d.GetY() >= d.GetX() && d.GetY() >= d.GetZ() ) + { + ret = SplitAxis::Y_AXIS_NEGATIVE; + location = (m_2.GetY() + 1 + m_1.GetY()) / 2; + uint32_t edgeLoc; + if ( m_params.m_findBestPlane && FindConcavityY(edgeLoc) ) + { + location = edgeLoc; + } + } + else + { + ret = SplitAxis::Z_AXIS_NEGATIVE; + location = (m_2.GetZ() + 1 + m_1.GetZ()) / 2; + uint32_t edgeLoc; + if ( m_params.m_findBestPlane && FindConcavityZ(edgeLoc) ) + { + location = edgeLoc; + } + } + + return ret; +} + +VHACD::Vect3 VoxelHull::GetPosition(const VHACD::Vector3& ip) const +{ + return GetPoint(ip.GetX(), + ip.GetY(), + ip.GetZ(), + m_voxelScale, + m_voxelAdjust); +} + +double VoxelHull::Raycast(const VHACD::Vector3& p1, + const VHACD::Vector3& p2) const +{ + double ret; + VHACD::Vect3 from = GetPosition(p1); + VHACD::Vect3 to = GetPosition(p2); + + double outT; + double faceSign; + VHACD::Vect3 hitLocation; + if (m_AABBTree.TraceRay(from, to, outT, faceSign, hitLocation)) + { + ret = (from - hitLocation).GetNorm(); + } + else + { + ret = 0; // if it doesn't hit anything, just assign it to zero. + } + + return ret; +} + +bool VoxelHull::FindConcavity(uint32_t idx, + uint32_t& splitLoc) +{ + bool ret = false; + + int32_t d = (m_2[idx] - m_1[idx]) + 1; // The length of the getX axis in voxel space + + uint32_t idx1; + uint32_t idx2; + uint32_t idx3; + switch (idx) + { + case 0: // X + idx1 = 0; + idx2 = 1; + idx3 = 2; + break; + case 1: // Y + idx1 = 1; + idx2 = 0; + idx3 = 2; + break; + case 2: + idx1 = 2; + idx2 = 1; + idx3 = 0; + break; + default: + /* + * To silence uninitialized variable warnings + */ + idx1 = 0; + idx2 = 0; + idx3 = 0; + assert(0 && "findConcavity::idx must be 0, 1, or 2"); + break; + } + + // We will compute the edge error on the XY plane and the XZ plane + // searching for the greatest location of concavity + std::vector edgeError1 = std::vector(d); + std::vector edgeError2 = std::vector(d); + + // Counter of number of voxel samples on the XY plane we have accumulated + uint32_t index1 = 0; + + // Compute Edge Error on the XY plane + for (uint32_t i0 = m_1[idx1]; i0 <= m_2[idx1]; i0++) + { + double errorTotal = 0; + // We now perform a raycast from the sides inward on the XY plane to + // determine the total error (distance of the surface from the sides) + // along this getX position. + for (uint32_t i1 = m_1[idx2]; i1 <= m_2[idx2]; i1++) + { + VHACD::Vector3 p1; + VHACD::Vector3 p2; + switch (idx) + { + case 0: + { + p1 = VHACD::Vector3(i0, i1, m_1.GetZ() - 2); + p2 = VHACD::Vector3(i0, i1, m_2.GetZ() + 2); + break; + } + case 1: + { + p1 = VHACD::Vector3(i1, i0, m_1.GetZ() - 2); + p2 = VHACD::Vector3(i1, i0, m_2.GetZ() + 2); + break; + } + case 2: + { + p1 = VHACD::Vector3(m_1.GetX() - 2, i1, i0); + p2 = VHACD::Vector3(m_2.GetX() + 2, i1, i0); + break; + } + } + + double e1 = Raycast(p1, p2); + double e2 = Raycast(p2, p1); + + errorTotal = errorTotal + e1 + e2; + } + // The total amount of edge error along this voxel location + edgeError1[index1] = errorTotal; + index1++; + } + + // Compute edge error along the XZ plane + uint32_t index2 = 0; + + for (uint32_t i0 = m_1[idx1]; i0 <= m_2[idx1]; i0++) + { + double errorTotal = 0; + + for (uint32_t i1 = m_1[idx3]; i1 <= m_2[idx3]; i1++) + { + VHACD::Vector3 p1; + VHACD::Vector3 p2; + switch (idx) + { + case 0: + { + p1 = VHACD::Vector3(i0, m_1.GetY() - 2, i1); + p2 = VHACD::Vector3(i0, m_2.GetY() + 2, i1); + break; + } + case 1: + { + p1 = VHACD::Vector3(m_1.GetX() - 2, i0, i1); + p2 = VHACD::Vector3(m_2.GetX() + 2, i0, i1); + break; + } + case 2: + { + p1 = VHACD::Vector3(i1, m_1.GetY() - 2, i0); + p2 = VHACD::Vector3(i1, m_2.GetY() + 2, i0); + break; + } + } + + double e1 = Raycast(p1, p2); // raycast from one side to the interior + double e2 = Raycast(p2, p1); // raycast from the other side to the interior + + errorTotal = errorTotal + e1 + e2; + } + edgeError2[index2] = errorTotal; + index2++; + } + + + // we now compute the first derivative to find the greatest spot of concavity on the XY plane + double maxDiff = 0; + uint32_t maxC = 0; + for (uint32_t x = 1; x < index1; x++) + { + if ( edgeError1[x] > 0 && edgeError1[x - 1] > 0 ) + { + double diff = abs(edgeError1[x] - edgeError1[x - 1]); + if ( diff > maxDiff ) + { + maxDiff = diff; + maxC = x-1; + } + } + } + + // Now see if there is a greater concavity on the XZ plane + for (uint32_t x = 1; x < index2; x++) + { + if ( edgeError2[x] > 0 && edgeError2[x - 1] > 0 ) + { + double diff = abs(edgeError2[x] - edgeError2[x - 1]); + if ( diff > maxDiff ) + { + maxDiff = diff; + maxC = x - 1; + } + } + } + + splitLoc = maxC + m_1[idx1]; + + // we do not allow an edge split if it is too close to the ends + if ( splitLoc > (m_1[idx1] + 4) + && splitLoc < (m_2[idx1] - 4) ) + { + ret = true; + } + + return ret; +} + +// Finding the greatest area of concavity.. +bool VoxelHull::FindConcavityX(uint32_t& splitLoc) +{ + return FindConcavity(0, splitLoc); +} + +// Finding the greatest area of concavity.. +bool VoxelHull::FindConcavityY(uint32_t& splitLoc) +{ + return FindConcavity(1, splitLoc); +} + +// Finding the greatest area of concavity.. +bool VoxelHull::FindConcavityZ(uint32_t &splitLoc) +{ + return FindConcavity(2, splitLoc); +} + +void VoxelHull::PerformPlaneSplit() +{ + if ( IsComplete() ) + { + } + else + { + uint32_t splitLoc; + SplitAxis axis = ComputeSplitPlane(splitLoc); + switch ( axis ) + { + case SplitAxis::X_AXIS_NEGATIVE: + case SplitAxis::X_AXIS_POSITIVE: + // Split on the getX axis at this split location + m_hullA = std::unique_ptr(new VoxelHull(*this, SplitAxis::X_AXIS_NEGATIVE, splitLoc)); + m_hullB = std::unique_ptr(new VoxelHull(*this, SplitAxis::X_AXIS_POSITIVE, splitLoc)); + break; + case SplitAxis::Y_AXIS_NEGATIVE: + case SplitAxis::Y_AXIS_POSITIVE: + // Split on the 1 axis at this split location + m_hullA = std::unique_ptr(new VoxelHull(*this, SplitAxis::Y_AXIS_NEGATIVE, splitLoc)); + m_hullB = std::unique_ptr(new VoxelHull(*this, SplitAxis::Y_AXIS_POSITIVE, splitLoc)); + break; + case SplitAxis::Z_AXIS_NEGATIVE: + case SplitAxis::Z_AXIS_POSITIVE: + // Split on the getZ axis at this split location + m_hullA = std::unique_ptr(new VoxelHull(*this, SplitAxis::Z_AXIS_NEGATIVE, splitLoc)); + m_hullB = std::unique_ptr(new VoxelHull(*this, SplitAxis::Z_AXIS_POSITIVE, splitLoc)); + break; + } + } +} + +void VoxelHull::SaveVoxelMesh(const SimpleMesh &inputMesh, + bool saveVoxelMesh, + bool saveSourceMesh) +{ + char scratch[512]; + snprintf(scratch, + sizeof(scratch), + "voxel-mesh-%03d.obj", + m_index); + FILE *fph = fopen(scratch, + "wb"); + if ( fph ) + { + uint32_t baseIndex = 1; + if ( saveVoxelMesh ) + { + WriteOBJ(fph, + m_vertices, + m_indices, + baseIndex); + baseIndex += uint32_t(m_vertices.size()); + } + if ( saveSourceMesh ) + { + WriteOBJ(fph, + inputMesh.m_vertices, + inputMesh.m_indices, + baseIndex); + } + fclose(fph); + } +} + +void VoxelHull::SaveOBJ(const char* fname, + const VoxelHull* h) +{ + FILE *fph = fopen(fname,"wb"); + if ( fph ) + { + uint32_t baseIndex = 1; + WriteOBJ(fph, + m_vertices, + m_indices, + baseIndex); + + baseIndex += uint32_t(m_vertices.size()); + + WriteOBJ(fph, + h->m_vertices, + h->m_indices, + baseIndex); + fclose(fph); + } +} + +void VoxelHull::SaveOBJ(const char *fname) +{ + FILE *fph = fopen(fname, "wb"); + if ( fph ) + { + printf("Saving '%s' with %d vertices and %d triangles\n", + fname, + uint32_t(m_vertices.size()), + uint32_t(m_indices.size())); + WriteOBJ(fph, + m_vertices, + m_indices, + 1); + fclose(fph); + } +} + +void VoxelHull::WriteOBJ(FILE* fph, + const std::vector& vertices, + const std::vector& indices, + uint32_t baseIndex) +{ + if (!fph) + { + return; + } + + for (size_t i = 0; i < vertices.size(); ++i) + { + const VHACD::Vertex& v = vertices[i]; + fprintf(fph, "v %0.9f %0.9f %0.9f\n", + v.mX, + v.mY, + v.mZ); + } + + for (size_t i = 0; i < indices.size(); ++i) + { + const VHACD::Triangle& t = indices[i]; + fprintf(fph, "f %d %d %d\n", + t.mI0 + baseIndex, + t.mI1 + baseIndex, + t.mI2 + baseIndex); + } +} + +class VHACDImpl; + +// This class represents a single task to compute the volume error +// of two convex hulls combined +class CostTask +{ +public: + VHACDImpl* m_this{ nullptr }; + IVHACD::ConvexHull* m_hullA{ nullptr }; + IVHACD::ConvexHull* m_hullB{ nullptr }; + double m_concavity{ 0 }; // concavity of the two combined + std::future m_future; +}; + +class HullPair +{ +public: + HullPair() = default; + HullPair(uint32_t hullA, + uint32_t hullB, + double concavity); + + bool operator<(const HullPair &h) const; + + uint32_t m_hullA{ 0 }; + uint32_t m_hullB{ 0 }; + double m_concavity{ 0 }; +}; + +HullPair::HullPair(uint32_t hullA, + uint32_t hullB, + double concavity) + : m_hullA(hullA) + , m_hullB(hullB) + , m_concavity(concavity) +{ +} + +bool HullPair::operator<(const HullPair &h) const +{ + return m_concavity > h.m_concavity ? true : false; +} + +// void jobCallback(void* userPtr); + +class VHACDImpl : public IVHACD, public VHACDCallbacks +{ + // Don't consider more than 100,000 convex hulls. + static constexpr uint32_t MaxConvexHullFragments{ 100000 }; +public: + VHACDImpl() = default; + + /* + * Overrides VHACD::IVHACD + */ + ~VHACDImpl() override + { + Clean(); + } + + void Cancel() override final; + + bool Compute(const float* const points, + const uint32_t countPoints, + const uint32_t* const triangles, + const uint32_t countTriangles, + const Parameters& params) override final; + + bool Compute(const double* const points, + const uint32_t countPoints, + const uint32_t* const triangles, + const uint32_t countTriangles, + const Parameters& params) override final; + + uint32_t GetNConvexHulls() const override final; + + bool GetConvexHull(const uint32_t index, + ConvexHull& ch) const override final; + + void Clean() override final; // release internally allocated memory + + void Release() override final; + + // Will compute the center of mass of the convex hull decomposition results and return it + // in 'centerOfMass'. Returns false if the center of mass could not be computed. + bool ComputeCenterOfMass(double centerOfMass[3]) const override final; + + // In synchronous mode (non-multi-threaded) the state is always 'ready' + // In asynchronous mode, this returns true if the background thread is not still actively computing + // a new solution. In an asynchronous config the 'IsReady' call will report any update or log + // messages in the caller's current thread. + bool IsReady(void) const override final; + + /** + * At the request of LegionFu : out_look@foxmail.com + * This method will return which convex hull is closest to the source position. + * You can use this method to figure out, for example, which vertices in the original + * source mesh are best associated with which convex hull. + * + * @param pos : The input 3d position to test against + * + * @return : Returns which convex hull this position is closest to. + */ + uint32_t findNearestConvexHull(const double pos[3], + double& distanceToHull) override final; + +// private: + bool Compute(const std::vector& points, + const std::vector& triangles, + const Parameters& params); + + // Take the source position, normalize it, and then convert it into an index position + uint32_t GetIndex(VHACD::VertexIndex& vi, + const VHACD::Vertex& p); + + // This copies the input mesh while scaling the input positions + // to fit into a normalized unit cube. It also re-indexes all of the + // vertex positions in case they weren't clean coming in. + void CopyInputMesh(const std::vector& points, + const std::vector& triangles); + + void ScaleOutputConvexHull(ConvexHull &ch); + + void AddCostToPriorityQueue(CostTask& task); + + void ReleaseConvexHull(ConvexHull* ch); + + void PerformConvexDecomposition(); + + double ComputeConvexHullVolume(const ConvexHull& sm); + + double ComputeVolume4(const VHACD::Vect3& a, + const VHACD::Vect3& b, + const VHACD::Vect3& c, + const VHACD::Vect3& d); + + double ComputeConcavity(double volumeSeparate, + double volumeCombined, + double volumeMesh); + + // See if we can compute the cost without having to actually merge convex hulls. + // If the axis aligned bounding boxes (slightly inflated) of the two convex hulls + // do not intersect, then we don't need to actually compute the merged convex hull + // volume. + bool DoFastCost(CostTask& mt); + + void PerformMergeCostTask(CostTask& mt); + + ConvexHull* ComputeReducedConvexHull(const ConvexHull& ch, + uint32_t maxVerts, + bool projectHullVertices); + + // Take the points in convex hull A and the points in convex hull B and generate + // a new convex hull on the combined set of points. + // Once completed, we create a SimpleMesh instance to hold the triangle mesh + // and we compute an inflated AABB for it. + ConvexHull* ComputeCombinedConvexHull(const ConvexHull& sm1, + const ConvexHull& sm2); + + + ConvexHull* GetHull(uint32_t index); + + bool RemoveHull(uint32_t index); + + ConvexHull* CopyConvexHull(const ConvexHull& source); + + const char* GetStageName(Stages stage) const; + + /* + * Overrides VHACD::VHACDCallbacks + */ + void ProgressUpdate(Stages stage, + double stageProgress, + const char* operation) override final; + + bool IsCanceled() const override final; + + std::atomic m_canceled{ false }; + Parameters m_params; // Convex decomposition parameters + + std::vector m_convexHulls; // Finalized convex hulls + std::vector> m_voxelHulls; // completed voxel hulls + std::vector> m_pendingHulls; + + std::vector> m_trees; + VHACD::AABBTree m_AABBTree; + VHACD::Volume m_voxelize; + VHACD::Vect3 m_center; + double m_scale{ double(1.0) }; + double m_recipScale{ double(1.0) }; + SimpleMesh m_inputMesh; // re-indexed and normalized input mesh + std::vector m_vertices; + std::vector m_indices; + + double m_overallHullVolume{ double(0.0) }; + double m_voxelScale{ double(0.0) }; + double m_voxelHalfScale{ double(0.0) }; + VHACD::Vect3 m_voxelBmin; + VHACD::Vect3 m_voxelBmax; + uint32_t m_meshId{ 0 }; + std::priority_queue m_hullPairQueue; +#if !VHACD_DISABLE_THREADING + std::unique_ptr m_threadPool{ nullptr }; +#endif + std::unordered_map m_hulls; + + double m_overallProgress{ double(0.0) }; + double m_stageProgress{ double(0.0) }; + double m_operationProgress{ double(0.0) }; +}; + +void VHACDImpl::Cancel() +{ + m_canceled = true; +} + +bool VHACDImpl::Compute(const float* const points, + const uint32_t countPoints, + const uint32_t* const triangles, + const uint32_t countTriangles, + const Parameters& params) +{ + std::vector v; + v.reserve(countPoints); + for (uint32_t i = 0; i < countPoints; ++i) + { + v.emplace_back(points[i * 3 + 0], + points[i * 3 + 1], + points[i * 3 + 2]); + } + + std::vector t; + t.reserve(countTriangles); + for (uint32_t i = 0; i < countTriangles; ++i) + { + t.emplace_back(triangles[i * 3 + 0], + triangles[i * 3 + 1], + triangles[i * 3 + 2]); + } + + return Compute(v, t, params); +} + +bool VHACDImpl::Compute(const double* const points, + const uint32_t countPoints, + const uint32_t* const triangles, + const uint32_t countTriangles, + const Parameters& params) +{ + std::vector v; + v.reserve(countPoints); + for (uint32_t i = 0; i < countPoints; ++i) + { + v.emplace_back(points[i * 3 + 0], + points[i * 3 + 1], + points[i * 3 + 2]); + } + + std::vector t; + t.reserve(countTriangles); + for (uint32_t i = 0; i < countTriangles; ++i) + { + t.emplace_back(triangles[i * 3 + 0], + triangles[i * 3 + 1], + triangles[i * 3 + 2]); + } + + return Compute(v, t, params); +} + +uint32_t VHACDImpl::GetNConvexHulls() const +{ + return uint32_t(m_convexHulls.size()); +} + +bool VHACDImpl::GetConvexHull(const uint32_t index, + ConvexHull& ch) const +{ + bool ret = false; + + if ( index < uint32_t(m_convexHulls.size() )) + { + ch = *m_convexHulls[index]; + ret = true; + } + + return ret; +} + +void VHACDImpl::Clean() +{ +#if !VHACD_DISABLE_THREADING + m_threadPool = nullptr; +#endif + + m_trees.clear(); + + for (auto& ch : m_convexHulls) + { + ReleaseConvexHull(ch); + } + m_convexHulls.clear(); + + for (auto& ch : m_hulls) + { + ReleaseConvexHull(ch.second); + } + m_hulls.clear(); + + m_voxelHulls.clear(); + + m_pendingHulls.clear(); + + m_vertices.clear(); + m_indices.clear(); +} + +void VHACDImpl::Release() +{ + delete this; +} + +bool VHACDImpl::ComputeCenterOfMass(double centerOfMass[3]) const +{ + bool ret = false; + + return ret; +} + +bool VHACDImpl::IsReady() const +{ + return true; +} + +uint32_t VHACDImpl::findNearestConvexHull(const double pos[3], + double& distanceToHull) +{ + uint32_t ret = 0; // The default return code is zero + + uint32_t hullCount = GetNConvexHulls(); + distanceToHull = 0; + // First, make sure that we have valid and completed results + if ( hullCount ) + { + // See if we already have AABB trees created for each convex hull + if ( m_trees.empty() ) + { + // For each convex hull, we generate an AABB tree for fast closest point queries + for (uint32_t i = 0; i < hullCount; i++) + { + VHACD::IVHACD::ConvexHull ch; + GetConvexHull(i,ch); + // Pass the triangle mesh to create an AABB tree instance based on it. + m_trees.emplace_back(new AABBTree(ch.m_points, + ch.m_triangles)); + } + } + // We now compute the closest point to each convex hull and save the nearest one + double closest = 1e99; + for (uint32_t i = 0; i < hullCount; i++) + { + std::unique_ptr& t = m_trees[i]; + if ( t ) + { + VHACD::Vect3 closestPoint; + VHACD::Vect3 position(pos[0], + pos[1], + pos[2]); + if ( t->GetClosestPointWithinDistance(position, 1e99, closestPoint)) + { + VHACD::Vect3 d = position - closestPoint; + double distanceSquared = d.GetNormSquared(); + if ( distanceSquared < closest ) + { + closest = distanceSquared; + ret = i; + } + } + } + } + distanceToHull = sqrt(closest); // compute the distance to the nearest convex hull + } + + return ret; +} + +bool VHACDImpl::Compute(const std::vector& points, + const std::vector& triangles, + const Parameters& params) +{ + bool ret = false; + + m_params = params; + m_canceled = false; + + Clean(); // release any previous results +#if !VHACD_DISABLE_THREADING + if ( m_params.m_asyncACD ) + { + m_threadPool = std::unique_ptr(new ThreadPool(8)); + } +#endif + CopyInputMesh(points, + triangles); + if ( !m_canceled ) + { + // We now recursively perform convex decomposition until complete + PerformConvexDecomposition(); + } + + if ( m_canceled ) + { + Clean(); + ret = false; + if ( m_params.m_logger ) + { + m_params.m_logger->Log("VHACD operation canceled before it was complete."); + } + } + else + { + ret = true; + } +#if !VHACD_DISABLE_THREADING + m_threadPool = nullptr; +#endif + return ret; +} + +uint32_t VHACDImpl::GetIndex(VHACD::VertexIndex& vi, + const VHACD::Vertex& p) +{ + VHACD::Vect3 pos = (VHACD::Vect3(p) - m_center) * m_recipScale; + bool newPos; + uint32_t ret = vi.GetIndex(pos, + newPos); + return ret; +} + +void VHACDImpl::CopyInputMesh(const std::vector& points, + const std::vector& triangles) +{ + m_vertices.clear(); + m_indices.clear(); + m_indices.reserve(triangles.size()); + + // First we must find the bounding box of this input vertices and normalize them into a unit-cube + VHACD::Vect3 bmin( FLT_MAX); + VHACD::Vect3 bmax(-FLT_MAX); + ProgressUpdate(Stages::COMPUTE_BOUNDS_OF_INPUT_MESH, + 0, + "ComputingBounds"); + for (uint32_t i = 0; i < points.size(); i++) + { + const VHACD::Vertex& p = points[i]; + + bmin = bmin.CWiseMin(p); + bmax = bmax.CWiseMax(p); + } + ProgressUpdate(Stages::COMPUTE_BOUNDS_OF_INPUT_MESH, + 100, + "ComputingBounds"); + + m_center = (bmax + bmin) * double(0.5); + + VHACD::Vect3 scale = bmax - bmin; + m_scale = scale.MaxCoeff(); + + m_recipScale = m_scale > double(0.0) ? double(1.0) / m_scale : double(0.0); + + { + VHACD::VertexIndex vi = VHACD::VertexIndex(double(0.001), false); + + uint32_t dcount = 0; + + for (uint32_t i = 0; i < triangles.size() && !m_canceled; ++i) + { + const VHACD::Triangle& t = triangles[i]; + const VHACD::Vertex& p1 = points[t.mI0]; + const VHACD::Vertex& p2 = points[t.mI1]; + const VHACD::Vertex& p3 = points[t.mI2]; + + uint32_t i1 = GetIndex(vi, p1); + uint32_t i2 = GetIndex(vi, p2); + uint32_t i3 = GetIndex(vi, p3); + + if ( i1 == i2 || i1 == i3 || i2 == i3 ) + { + dcount++; + } + else + { + m_indices.emplace_back(i1, i2, i3); + } + } + + if ( dcount ) + { + if ( m_params.m_logger ) + { + char scratch[512]; + snprintf(scratch, + sizeof(scratch), + "Skipped %d degenerate triangles", dcount); + m_params.m_logger->Log(scratch); + } + } + + m_vertices = vi.TakeVertices(); + } + + // Create the raycast mesh + if ( !m_canceled ) + { + ProgressUpdate(Stages::CREATE_RAYCAST_MESH, + 0, + "Building RaycastMesh"); + m_AABBTree = VHACD::AABBTree(m_vertices, + m_indices); + ProgressUpdate(Stages::CREATE_RAYCAST_MESH, + 100, + "RaycastMesh completed"); + } + if ( !m_canceled ) + { + ProgressUpdate(Stages::VOXELIZING_INPUT_MESH, + 0, + "Voxelizing Input Mesh"); + m_voxelize = VHACD::Volume(); + m_voxelize.Voxelize(m_vertices, + m_indices, + m_params.m_resolution, + m_params.m_fillMode, + m_AABBTree); + m_voxelScale = m_voxelize.GetScale(); + m_voxelHalfScale = m_voxelScale * double(0.5); + m_voxelBmin = m_voxelize.GetBounds().GetMin(); + m_voxelBmax = m_voxelize.GetBounds().GetMax(); + ProgressUpdate(Stages::VOXELIZING_INPUT_MESH, + 100, + "Voxelization complete"); + } + + m_inputMesh.m_vertices = m_vertices; + m_inputMesh.m_indices = m_indices; + if ( !m_canceled ) + { + ProgressUpdate(Stages::BUILD_INITIAL_CONVEX_HULL, + 0, + "Build initial ConvexHull"); + std::unique_ptr vh = std::unique_ptr(new VoxelHull(m_voxelize, + m_params, + this)); + if ( vh->m_convexHull ) + { + m_overallHullVolume = vh->m_convexHull->m_volume; + } + m_pendingHulls.push_back(std::move(vh)); + ProgressUpdate(Stages::BUILD_INITIAL_CONVEX_HULL, + 100, + "Initial ConvexHull complete"); + } +} + +void VHACDImpl::ScaleOutputConvexHull(ConvexHull& ch) +{ + for (uint32_t i = 0; i < ch.m_points.size(); i++) + { + VHACD::Vect3 p = ch.m_points[i]; + p = (p * m_scale) + m_center; + ch.m_points[i] = p; + } + ch.m_volume = ComputeConvexHullVolume(ch); // get the combined volume + VHACD::BoundsAABB b(ch.m_points); + ch.mBmin = b.GetMin(); + ch.mBmax = b.GetMax(); + ComputeCentroid(ch.m_points, + ch.m_triangles, + ch.m_center); +} + +void VHACDImpl::AddCostToPriorityQueue(CostTask& task) +{ + HullPair hp(task.m_hullA->m_meshId, + task.m_hullB->m_meshId, + task.m_concavity); + m_hullPairQueue.push(hp); +} + +void VHACDImpl::ReleaseConvexHull(ConvexHull* ch) +{ + if ( ch ) + { + delete ch; + } +} + +void jobCallback(std::unique_ptr& userPtr) +{ + userPtr->PerformPlaneSplit(); +} + +void computeMergeCostTask(CostTask& ptr) +{ + ptr.m_this->PerformMergeCostTask(ptr); +} + +void VHACDImpl::PerformConvexDecomposition() +{ + { + ScopedTime st("Convex Decomposition", + m_params.m_logger); + double maxHulls = pow(2, m_params.m_maxRecursionDepth); + // We recursively split convex hulls until we can + // no longer recurse further. + Timer t; + + while ( !m_pendingHulls.empty() && !m_canceled ) + { + size_t count = m_pendingHulls.size() + m_voxelHulls.size(); + double e = t.PeekElapsedSeconds(); + if ( e >= double(0.1) ) + { + t.Reset(); + double stageProgress = (double(count) * double(100.0)) / maxHulls; + ProgressUpdate(Stages::PERFORMING_DECOMPOSITION, + stageProgress, + "Performing recursive decomposition of convex hulls"); + } + // First we make a copy of the hulls we are processing + std::vector> oldList = std::move(m_pendingHulls); + // For each hull we want to split, we either + // immediately perform the plane split or we post it as + // a job to be performed in a background thread + std::vector> futures(oldList.size()); + uint32_t futureCount = 0; + for (auto& i : oldList) + { + if ( i->IsComplete() || count > MaxConvexHullFragments ) + { + } + else + { +#if !VHACD_DISABLE_THREADING + if ( m_threadPool ) + { + futures[futureCount] = m_threadPool->enqueue([&i] + { + jobCallback(i); + }); + futureCount++; + } + else +#endif + { + i->PerformPlaneSplit(); + } + } + } + // Wait for any outstanding jobs to complete in the background threads + if ( futureCount ) + { + for (uint32_t i = 0; i < futureCount; i++) + { + futures[i].get(); + } + } + // Now, we rebuild the pending convex hulls list by + // adding the two children to the output list if + // we need to recurse them further + for (auto& vh : oldList) + { + if ( vh->IsComplete() || count > MaxConvexHullFragments ) + { + if ( vh->m_convexHull ) + { + m_voxelHulls.push_back(std::move(vh)); + } + } + else + { + if ( vh->m_hullA ) + { + m_pendingHulls.push_back(std::move(vh->m_hullA)); + } + if ( vh->m_hullB ) + { + m_pendingHulls.push_back(std::move(vh->m_hullB)); + } + } + } + } + } + + if ( !m_canceled ) + { + // Give each convex hull a unique guid + m_meshId = 0; + m_hulls.clear(); + + // Build the convex hull id map + std::vector hulls; + + ProgressUpdate(Stages::INITIALIZING_CONVEX_HULLS_FOR_MERGING, + 0, + "Initializing ConvexHulls"); + for (auto& vh : m_voxelHulls) + { + if ( m_canceled ) + { + break; + } + ConvexHull* ch = CopyConvexHull(*vh->m_convexHull); + m_meshId++; + ch->m_meshId = m_meshId; + m_hulls[m_meshId] = ch; + // Compute the volume of the convex hull + ch->m_volume = ComputeConvexHullVolume(*ch); + // Compute the AABB of the convex hull + VHACD::BoundsAABB b = VHACD::BoundsAABB(ch->m_points).Inflate(double(0.1)); + ch->mBmin = b.GetMin(); + ch->mBmax = b.GetMax(); + + ComputeCentroid(ch->m_points, + ch->m_triangles, + ch->m_center); + + hulls.push_back(ch); + } + ProgressUpdate(Stages::INITIALIZING_CONVEX_HULLS_FOR_MERGING, + 100, + "ConvexHull initialization complete"); + + m_voxelHulls.clear(); + + // here we merge convex hulls as needed until the match the + // desired maximum hull count. + size_t hullCount = hulls.size(); + + if ( hullCount > m_params.m_maxConvexHulls && !m_canceled) + { + size_t costMatrixSize = ((hullCount * hullCount) - hullCount) >> 1; + std::vector tasks; + tasks.reserve(costMatrixSize); + + ScopedTime st("Computing the Cost Matrix", + m_params.m_logger); + // First thing we need to do is compute the cost matrix + // This is computed as the volume error of any two convex hulls + // combined + ProgressUpdate(Stages::COMPUTING_COST_MATRIX, + 0, + "Computing Hull Merge Cost Matrix"); + for (size_t i = 1; i < hullCount && !m_canceled; i++) + { + ConvexHull* chA = hulls[i]; + + for (size_t j = 0; j < i && !m_canceled; j++) + { + ConvexHull* chB = hulls[j]; + + CostTask t; + t.m_hullA = chA; + t.m_hullB = chB; + t.m_this = this; + + if ( DoFastCost(t) ) + { + } + else + { + tasks.push_back(std::move(t)); + CostTask* task = &tasks.back(); +#if !VHACD_DISABLE_THREADING + if ( m_threadPool ) + { + task->m_future = m_threadPool->enqueue([task] + { + computeMergeCostTask(*task); + }); + } +#endif + } + } + } + + if ( !m_canceled ) + { +#if !VHACD_DISABLE_THREADING + if ( m_threadPool ) + { + for (CostTask& task : tasks) + { + task.m_future.get(); + } + + for (CostTask& task : tasks) + { + AddCostToPriorityQueue(task); + } + } + else +#endif + { + for (CostTask& task : tasks) + { + PerformMergeCostTask(task); + AddCostToPriorityQueue(task); + } + } + ProgressUpdate(Stages::COMPUTING_COST_MATRIX, + 100, + "Finished cost matrix"); + } + + if ( !m_canceled ) + { + ScopedTime stMerging("Merging Convex Hulls", + m_params.m_logger); + Timer t; + // Now that we know the cost to merge each hull, we can begin merging them. + bool cancel = false; + + uint32_t maxMergeCount = uint32_t(m_hulls.size()) - m_params.m_maxConvexHulls; + uint32_t startCount = uint32_t(m_hulls.size()); + + while ( !cancel + && m_hulls.size() > m_params.m_maxConvexHulls + && !m_hullPairQueue.empty() + && !m_canceled) + { + double e = t.PeekElapsedSeconds(); + if ( e >= double(0.1) ) + { + t.Reset(); + uint32_t hullsProcessed = startCount - uint32_t(m_hulls.size() ); + double stageProgress = double(hullsProcessed * 100) / double(maxMergeCount); + ProgressUpdate(Stages::MERGING_CONVEX_HULLS, + stageProgress, + "Merging Convex Hulls"); + } + + HullPair hp = m_hullPairQueue.top(); + m_hullPairQueue.pop(); + + // It is entirely possible that the hull pair queue can + // have references to convex hulls that are no longer valid + // because they were previously merged. So we check for this + // and if either hull referenced in this pair no longer + // exists, then we skip it. + + // Look up this pair of hulls by ID + ConvexHull* ch1 = GetHull(hp.m_hullA); + ConvexHull* ch2 = GetHull(hp.m_hullB); + + // If both hulls are still valid, then we merge them, delete the old + // two hulls and recompute the cost matrix for the new combined hull + // we have created + if ( ch1 && ch2 ) + { + // This is the convex hull which results from combining the + // vertices in the two source hulls + ConvexHull* combinedHull = ComputeCombinedConvexHull(*ch1, + *ch2); + // The two old convex hulls are going to get removed + RemoveHull(hp.m_hullA); + RemoveHull(hp.m_hullB); + + m_meshId++; + combinedHull->m_meshId = m_meshId; + tasks.clear(); + tasks.reserve(m_hulls.size()); + + // Compute the cost between this new merged hull + // and all existing convex hulls and then + // add that to the priority queue + for (auto& i : m_hulls) + { + if ( m_canceled ) + { + break; + } + ConvexHull* secondHull = i.second; + CostTask t; + t.m_hullA = combinedHull; + t.m_hullB = secondHull; + t.m_this = this; + if ( DoFastCost(t) ) + { + } + else + { + tasks.push_back(std::move(t)); + } + } + m_hulls[combinedHull->m_meshId] = combinedHull; + // See how many merge cost tasks were posted + // If there are 8 or more and we are running asynchronously, then do them that way. +#if !VHACD_DISABLE_THREADING + if ( m_threadPool && tasks.size() >= 2) + { + for (CostTask& task : tasks) + { + task.m_future = m_threadPool->enqueue([&task] + { + computeMergeCostTask(task); + }); + } + + for (CostTask& task : tasks) + { + task.m_future.get(); + } + } + else +#endif + { + for (CostTask& task : tasks) + { + PerformMergeCostTask(task); + } + } + + for (CostTask& task : tasks) + { + AddCostToPriorityQueue(task); + } + } + } + // Ok...once we are done, we copy the results! + m_meshId -= 0; + ProgressUpdate(Stages::FINALIZING_RESULTS, + 0, + "Finalizing results"); + for (auto& i : m_hulls) + { + if ( m_canceled ) + { + break; + } + ConvexHull* ch = i.second; + // We now must reduce the convex hull + if ( ch->m_points.size() > m_params.m_maxNumVerticesPerCH || m_params.m_shrinkWrap) + { + ConvexHull* reduce = ComputeReducedConvexHull(*ch, + m_params.m_maxNumVerticesPerCH, + m_params.m_shrinkWrap); + ReleaseConvexHull(ch); + ch = reduce; + } + ScaleOutputConvexHull(*ch); + ch->m_meshId = m_meshId; + m_meshId++; + m_convexHulls.push_back(ch); + } + m_hulls.clear(); // since the hulls were moved into the output list, we don't need to delete them from this container + ProgressUpdate(Stages::FINALIZING_RESULTS, + 100, + "Finalized results complete"); + } + } + else + { + ProgressUpdate(Stages::FINALIZING_RESULTS, + 0, + "Finalizing results"); + m_meshId = 0; + for (auto& ch : hulls) + { + // We now must reduce the convex hull + if ( ch->m_points.size() > m_params.m_maxNumVerticesPerCH || m_params.m_shrinkWrap ) + { + ConvexHull* reduce = ComputeReducedConvexHull(*ch, + m_params.m_maxNumVerticesPerCH, + m_params.m_shrinkWrap); + ReleaseConvexHull(ch); + ch = reduce; + } + ScaleOutputConvexHull(*ch); + ch->m_meshId = m_meshId; + m_meshId++; + m_convexHulls.push_back(ch); + } + m_hulls.clear(); + ProgressUpdate(Stages::FINALIZING_RESULTS, + 100, + "Finalized results"); + } + } +} + +double VHACDImpl::ComputeConvexHullVolume(const ConvexHull& sm) +{ + double totalVolume = 0; + VHACD::Vect3 bary(0, 0, 0); + for (uint32_t i = 0; i < sm.m_points.size(); i++) + { + VHACD::Vect3 p(sm.m_points[i]); + bary += p; + } + bary /= double(sm.m_points.size()); + + for (uint32_t i = 0; i < sm.m_triangles.size(); i++) + { + uint32_t i1 = sm.m_triangles[i].mI0; + uint32_t i2 = sm.m_triangles[i].mI1; + uint32_t i3 = sm.m_triangles[i].mI2; + + VHACD::Vect3 ver0(sm.m_points[i1]); + VHACD::Vect3 ver1(sm.m_points[i2]); + VHACD::Vect3 ver2(sm.m_points[i3]); + + totalVolume += ComputeVolume4(ver0, + ver1, + ver2, + bary); + + } + totalVolume = totalVolume / double(6.0); + return totalVolume; +} + +double VHACDImpl::ComputeVolume4(const VHACD::Vect3& a, + const VHACD::Vect3& b, + const VHACD::Vect3& c, + const VHACD::Vect3& d) +{ + VHACD::Vect3 ad = a - d; + VHACD::Vect3 bd = b - d; + VHACD::Vect3 cd = c - d; + VHACD::Vect3 bcd = bd.Cross(cd); + double dot = ad.Dot(bcd); + return dot; +} + +double VHACDImpl::ComputeConcavity(double volumeSeparate, + double volumeCombined, + double volumeMesh) +{ + return fabs(volumeSeparate - volumeCombined) / volumeMesh; +} + +bool VHACDImpl::DoFastCost(CostTask& mt) +{ + bool ret = false; + + ConvexHull* ch1 = mt.m_hullA; + ConvexHull* ch2 = mt.m_hullB; + + VHACD::BoundsAABB ch1b(ch1->mBmin, + ch1->mBmax); + VHACD::BoundsAABB ch2b(ch2->mBmin, + ch2->mBmax); + if (!ch1b.Intersects(ch2b)) + { + VHACD::BoundsAABB b = ch1b.Union(ch2b); + + double combinedVolume = b.Volume(); + double concavity = ComputeConcavity(ch1->m_volume + ch2->m_volume, + combinedVolume, + m_overallHullVolume); + HullPair hp(ch1->m_meshId, + ch2->m_meshId, + concavity); + m_hullPairQueue.push(hp); + ret = true; + } + return ret; +} + +void VHACDImpl::PerformMergeCostTask(CostTask& mt) +{ + ConvexHull* ch1 = mt.m_hullA; + ConvexHull* ch2 = mt.m_hullB; + + double volume1 = ch1->m_volume; + double volume2 = ch2->m_volume; + + ConvexHull* combined = ComputeCombinedConvexHull(*ch1, + *ch2); // Build the combined convex hull + double combinedVolume = ComputeConvexHullVolume(*combined); // get the combined volume + mt.m_concavity = ComputeConcavity(volume1 + volume2, + combinedVolume, + m_overallHullVolume); + ReleaseConvexHull(combined); +} + +IVHACD::ConvexHull* VHACDImpl::ComputeReducedConvexHull(const ConvexHull& ch, + uint32_t maxVerts, + bool projectHullVertices) +{ + SimpleMesh sourceConvexHull; + + sourceConvexHull.m_vertices = ch.m_points; + sourceConvexHull.m_indices = ch.m_triangles; + + ShrinkWrap(sourceConvexHull, + m_AABBTree, + maxVerts, + m_voxelScale * 4, + projectHullVertices); + + ConvexHull *ret = new ConvexHull; + + ret->m_points = sourceConvexHull.m_vertices; + ret->m_triangles = sourceConvexHull.m_indices; + + VHACD::BoundsAABB b = VHACD::BoundsAABB(ret->m_points).Inflate(double(0.1)); + ret->mBmin = b.GetMin(); + ret->mBmax = b.GetMax(); + ComputeCentroid(ret->m_points, + ret->m_triangles, + ret->m_center); + + ret->m_volume = ComputeConvexHullVolume(*ret); + + // Return the convex hull + return ret; +} + +IVHACD::ConvexHull* VHACDImpl::ComputeCombinedConvexHull(const ConvexHull& sm1, + const ConvexHull& sm2) +{ + uint32_t vcount = uint32_t(sm1.m_points.size() + sm2.m_points.size()); // Total vertices from both hulls + std::vector vertices(vcount); + auto it = std::copy(sm1.m_points.begin(), + sm1.m_points.end(), + vertices.begin()); + std::copy(sm2.m_points.begin(), + sm2.m_points.end(), + it); + + VHACD::QuickHull qh; + qh.ComputeConvexHull(vertices, + vcount); + + ConvexHull* ret = new ConvexHull; + ret->m_points = qh.GetVertices(); + ret->m_triangles = qh.GetIndices(); + + ret->m_volume = ComputeConvexHullVolume(*ret); + + VHACD::BoundsAABB b = VHACD::BoundsAABB(qh.GetVertices()).Inflate(double(0.1)); + ret->mBmin = b.GetMin(); + ret->mBmax = b.GetMax(); + ComputeCentroid(ret->m_points, + ret->m_triangles, + ret->m_center); + + // Return the convex hull + return ret; +} + +IVHACD::ConvexHull* VHACDImpl::GetHull(uint32_t index) +{ + ConvexHull* ret = nullptr; + + auto found = m_hulls.find(index); + if ( found != m_hulls.end() ) + { + ret = found->second; + } + + return ret; +} + +bool VHACDImpl::RemoveHull(uint32_t index) +{ + bool ret = false; + auto found = m_hulls.find(index); + if ( found != m_hulls.end() ) + { + ret = true; + ReleaseConvexHull(found->second); + m_hulls.erase(found); + } + return ret; +} + +IVHACD::ConvexHull* VHACDImpl::CopyConvexHull(const ConvexHull& source) +{ + ConvexHull *ch = new ConvexHull; + *ch = source; + + return ch; +} + +const char* VHACDImpl::GetStageName(Stages stage) const +{ + const char *ret = "unknown"; + switch ( stage ) + { + case Stages::COMPUTE_BOUNDS_OF_INPUT_MESH: + ret = "COMPUTE_BOUNDS_OF_INPUT_MESH"; + break; + case Stages::REINDEXING_INPUT_MESH: + ret = "REINDEXING_INPUT_MESH"; + break; + case Stages::CREATE_RAYCAST_MESH: + ret = "CREATE_RAYCAST_MESH"; + break; + case Stages::VOXELIZING_INPUT_MESH: + ret = "VOXELIZING_INPUT_MESH"; + break; + case Stages::BUILD_INITIAL_CONVEX_HULL: + ret = "BUILD_INITIAL_CONVEX_HULL"; + break; + case Stages::PERFORMING_DECOMPOSITION: + ret = "PERFORMING_DECOMPOSITION"; + break; + case Stages::INITIALIZING_CONVEX_HULLS_FOR_MERGING: + ret = "INITIALIZING_CONVEX_HULLS_FOR_MERGING"; + break; + case Stages::COMPUTING_COST_MATRIX: + ret = "COMPUTING_COST_MATRIX"; + break; + case Stages::MERGING_CONVEX_HULLS: + ret = "MERGING_CONVEX_HULLS"; + break; + case Stages::FINALIZING_RESULTS: + ret = "FINALIZING_RESULTS"; + break; + case Stages::NUM_STAGES: + // Should be unreachable, here to silence enumeration value not handled in switch warnings + // GCC/Clang's -Wswitch + break; + } + return ret; +} + +void VHACDImpl::ProgressUpdate(Stages stage, + double stageProgress, + const char* operation) +{ + if ( m_params.m_callback ) + { + double overallProgress = (double(stage) * 100) / double(Stages::NUM_STAGES); + const char *s = GetStageName(stage); + m_params.m_callback->Update(overallProgress, + stageProgress, + s, + operation); + } +} + +bool VHACDImpl::IsCanceled() const +{ + return m_canceled; +} + +IVHACD* CreateVHACD(void) +{ + VHACDImpl *ret = new VHACDImpl; + return static_cast< IVHACD *>(ret); +} + +IVHACD* CreateVHACD(void); + +#if !VHACD_DISABLE_THREADING + +class LogMessage +{ +public: + double m_overallProgress{ double(-1.0) }; + double m_stageProgress{ double(-1.0) }; + std::string m_stage; + std::string m_operation; +}; + +class VHACDAsyncImpl : public VHACD::IVHACD, + public VHACD::IVHACD::IUserCallback, + VHACD::IVHACD::IUserLogger, + VHACD::IVHACD::IUserTaskRunner +{ +public: + VHACDAsyncImpl() = default; + + ~VHACDAsyncImpl() override; + + void Cancel() override final; + + bool Compute(const float* const points, + const uint32_t countPoints, + const uint32_t* const triangles, + const uint32_t countTriangles, + const Parameters& params) override final; + + bool Compute(const double* const points, + const uint32_t countPoints, + const uint32_t* const triangles, + const uint32_t countTriangles, + const Parameters& params) override final; + + bool GetConvexHull(const uint32_t index, + VHACD::IVHACD::ConvexHull& ch) const override final; + + uint32_t GetNConvexHulls() const override final; + + void Clean() override final; // release internally allocated memory + + void Release() override final; // release IVHACD + + // Will compute the center of mass of the convex hull decomposition results and return it + // in 'centerOfMass'. Returns false if the center of mass could not be computed. + bool ComputeCenterOfMass(double centerOfMass[3]) const override; + + bool IsReady() const override final; + + /** + * At the request of LegionFu : out_look@foxmail.com + * This method will return which convex hull is closest to the source position. + * You can use this method to figure out, for example, which vertices in the original + * source mesh are best associated with which convex hull. + * + * @param pos : The input 3d position to test against + * + * @return : Returns which convex hull this position is closest to. + */ + uint32_t findNearestConvexHull(const double pos[3], + double& distanceToHull) override final; + + void Update(const double overallProgress, + const double stageProgress, + const char* const stage, + const char *operation) override final; + + void Log(const char* const msg) override final; + + void* StartTask(std::function func) override; + + void JoinTask(void* Task) override; + + bool Compute(const Parameters params); + + bool ComputeNow(const std::vector& points, + const std::vector& triangles, + const Parameters& _desc); + + // As a convenience for the calling application we only send it update and log messages from it's own main + // thread. This reduces the complexity burden on the caller by making sure it only has to deal with log + // messages in it's main application thread. + void ProcessPendingMessages() const; + +private: + VHACD::VHACDImpl m_VHACD; + std::vector m_vertices; + std::vector m_indices; + VHACD::IVHACD::IUserCallback* m_callback{ nullptr }; + VHACD::IVHACD::IUserLogger* m_logger{ nullptr }; + VHACD::IVHACD::IUserTaskRunner* m_taskRunner{ nullptr }; + void* m_task{ nullptr }; + std::atomic m_running{ false }; + std::atomic m_cancel{ false }; + + // Thread safe caching mechanism for messages and update status. + // This is so that caller always gets messages in his own thread + // Member variables are marked as 'mutable' since the message dispatch function + // is called from const query methods. + mutable std::mutex m_messageMutex; + mutable std::vector m_messages; + mutable std::atomic m_haveMessages{ false }; +}; + +VHACDAsyncImpl::~VHACDAsyncImpl() +{ + Cancel(); +} + +void VHACDAsyncImpl::Cancel() +{ + m_cancel = true; + m_VHACD.Cancel(); + + if (m_task) + { + m_taskRunner->JoinTask(m_task); // Wait for the thread to fully exit before we delete the instance + m_task = nullptr; + } + m_cancel = false; // clear the cancel semaphore +} + +bool VHACDAsyncImpl::Compute(const float* const points, + const uint32_t countPoints, + const uint32_t* const triangles, + const uint32_t countTriangles, + const Parameters& params) +{ + m_vertices.reserve(countPoints); + for (uint32_t i = 0; i < countPoints; ++i) + { + m_vertices.emplace_back(points[i * 3 + 0], + points[i * 3 + 1], + points[i * 3 + 2]); + } + + m_indices.reserve(countTriangles); + for (uint32_t i = 0; i < countTriangles; ++i) + { + m_indices.emplace_back(triangles[i * 3 + 0], + triangles[i * 3 + 1], + triangles[i * 3 + 2]); + } + + return Compute(params); +} + +bool VHACDAsyncImpl::Compute(const double* const points, + const uint32_t countPoints, + const uint32_t* const triangles, + const uint32_t countTriangles, + const Parameters& params) +{ + // We need to copy the input vertices and triangles into our own buffers so we can operate + // on them safely from the background thread. + // Can't be local variables due to being asynchronous + m_vertices.reserve(countPoints); + for (uint32_t i = 0; i < countPoints; ++i) + { + m_vertices.emplace_back(points[i * 3 + 0], + points[i * 3 + 1], + points[i * 3 + 2]); + } + + m_indices.reserve(countTriangles); + for (uint32_t i = 0; i < countTriangles; ++i) + { + m_indices.emplace_back(triangles[i * 3 + 0], + triangles[i * 3 + 1], + triangles[i * 3 + 2]); + } + + return Compute(params); +} + +bool VHACDAsyncImpl::GetConvexHull(const uint32_t index, + VHACD::IVHACD::ConvexHull& ch) const +{ + return m_VHACD.GetConvexHull(index, + ch); +} + +uint32_t VHACDAsyncImpl::GetNConvexHulls() const +{ + ProcessPendingMessages(); + return m_VHACD.GetNConvexHulls(); +} + +void VHACDAsyncImpl::Clean() +{ + Cancel(); + m_VHACD.Clean(); +} + +void VHACDAsyncImpl::Release() +{ + delete this; +} + +bool VHACDAsyncImpl::ComputeCenterOfMass(double centerOfMass[3]) const +{ + bool ret = false; + + centerOfMass[0] = 0; + centerOfMass[1] = 0; + centerOfMass[2] = 0; + + if (IsReady()) + { + ret = m_VHACD.ComputeCenterOfMass(centerOfMass); + } + return ret; +} + +bool VHACDAsyncImpl::IsReady() const +{ + ProcessPendingMessages(); + return !m_running; +} + +uint32_t VHACDAsyncImpl::findNearestConvexHull(const double pos[3], + double& distanceToHull) +{ + uint32_t ret = 0; // The default return code is zero + + distanceToHull = 0; + // First, make sure that we have valid and completed results + if (IsReady() ) + { + ret = m_VHACD.findNearestConvexHull(pos,distanceToHull); + } + + return ret; +} + +void VHACDAsyncImpl::Update(const double overallProgress, + const double stageProgress, + const char* const stage, + const char* operation) +{ + m_messageMutex.lock(); + LogMessage m; + m.m_operation = std::string(operation); + m.m_overallProgress = overallProgress; + m.m_stageProgress = stageProgress; + m.m_stage = std::string(stage); + m_messages.push_back(m); + m_haveMessages = true; + m_messageMutex.unlock(); +} + +void VHACDAsyncImpl::Log(const char* const msg) +{ + m_messageMutex.lock(); + LogMessage m; + m.m_operation = std::string(msg); + m_haveMessages = true; + m_messages.push_back(m); + m_messageMutex.unlock(); +} + +void* VHACDAsyncImpl::StartTask(std::function func) +{ + return new std::thread(func); +} + +void VHACDAsyncImpl::JoinTask(void* Task) +{ + std::thread* t = static_cast(Task); + t->join(); + delete t; +} + +bool VHACDAsyncImpl::Compute(Parameters params) +{ + Cancel(); // if we previously had a solution running; cancel it. + + m_taskRunner = params.m_taskRunner ? params.m_taskRunner : this; + params.m_taskRunner = m_taskRunner; + + m_running = true; + m_task = m_taskRunner->StartTask([this, params]() { + ComputeNow(m_vertices, + m_indices, + params); + // If we have a user provided callback and the user did *not* call 'cancel' we notify him that the + // task is completed. However..if the user selected 'cancel' we do not send a completed notification event. + if (params.m_callback && !m_cancel) + { + params.m_callback->NotifyVHACDComplete(); + } + m_running = false; + }); + return true; +} + +bool VHACDAsyncImpl::ComputeNow(const std::vector& points, + const std::vector& triangles, + const Parameters& _desc) +{ + uint32_t ret = 0; + + Parameters desc; + m_callback = _desc.m_callback; + m_logger = _desc.m_logger; + + desc = _desc; + // Set our intercepting callback interfaces if non-null + desc.m_callback = _desc.m_callback ? this : nullptr; + desc.m_logger = _desc.m_logger ? this : nullptr; + + // If not task runner provided, then use the default one + if (desc.m_taskRunner == nullptr) + { + desc.m_taskRunner = this; + } + + bool ok = m_VHACD.Compute(points, + triangles, + desc); + if (ok) + { + ret = m_VHACD.GetNConvexHulls(); + } + + return ret ? true : false; +} + +void VHACDAsyncImpl::ProcessPendingMessages() const +{ + if (m_cancel) + { + return; + } + if ( m_haveMessages ) + { + m_messageMutex.lock(); + for (auto& i : m_messages) + { + if ( i.m_overallProgress == -1 ) + { + if ( m_logger ) + { + m_logger->Log(i.m_operation.c_str()); + } + } + else if ( m_callback ) + { + m_callback->Update(i.m_overallProgress, + i.m_stageProgress, + i.m_stage.c_str(), + i.m_operation.c_str()); + } + } + m_messages.clear(); + m_haveMessages = false; + m_messageMutex.unlock(); + } +} + +IVHACD* CreateVHACD_ASYNC() +{ + VHACDAsyncImpl* m = new VHACDAsyncImpl; + return static_cast(m); +} +#endif + +} // namespace VHACD + +#ifdef _MSC_VER +#pragma warning(pop) +#endif // _MSC_VER + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +#endif // ENABLE_VHACD_IMPLEMENTATION + +#endif // VHACD_H diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx/main.cpp b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx/main.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ab2869f525558511e31a266425a1e2f7acc77b79 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx/main.cpp @@ -0,0 +1,157 @@ +#include +#include +#include +#include +#define ENABLE_VHACD_IMPLEMENTATION 1 +#define VHACD_DISABLE_THREADING 0 +#include "VHACD.h" + +#define STRINGIFY(x) #x +#define MACRO_STRINGIFY(x) STRINGIFY(x) + +namespace py = pybind11; + +// Return a list of convex hulls +// Each convex hull is a tuple of (vertices, indices) +// vertices is a numpy array of shape (n, 3) +// indices is a numpy array of shape (m,) +std::vector, py::array_t>> +compute_vhacd(py::array_t points, py::array_t faces, + uint32_t maxConvexHulls, uint32_t resolution, + double minimumVolumePercentErrorAllowed, + uint32_t maxRecursionDepth, bool shrinkWrap, std::string fillMode, + uint32_t maxNumVerticesPerCH, bool asyncACD, + uint32_t minEdgeLength, bool findBestPlane) { + + /* read input arrays buffer_info */ + auto buf_points = points.request(); + auto buf_faces = faces.request(); + + /* variables */ + double *ptr_points = (double *)buf_points.ptr; + uint32_t *ptr_faces = (uint32_t *)buf_faces.ptr; + size_t num_points = buf_points.shape[0]; + size_t num_faces = buf_faces.shape[0] / 4; + size_t num_triangle_indices = num_faces * 3; + + // Prepare our input arrays for VHACD + uint32_t *triangles = new uint32_t[num_triangle_indices]; + for (uint32_t i = 0; i < num_faces; i++) { + // We skip the first index of the face array, which is the number of + // vertices in the face + triangles[3 * i] = ptr_faces[4 * i + 1]; + triangles[3 * i + 1] = ptr_faces[4 * i + 2]; + triangles[3 * i + 2] = ptr_faces[4 * i + 3]; + } + + // Create the VHACD parameters + VHACD::IVHACD::Parameters p; + p.m_maxConvexHulls = maxConvexHulls; + p.m_resolution = resolution; + p.m_minimumVolumePercentErrorAllowed = minimumVolumePercentErrorAllowed; + p.m_maxRecursionDepth = maxRecursionDepth; + p.m_shrinkWrap = shrinkWrap; + p.m_maxNumVerticesPerCH = maxNumVerticesPerCH; + p.m_asyncACD = asyncACD; + p.m_minEdgeLength = minEdgeLength; + p.m_findBestPlane = findBestPlane; + if (fillMode == "flood") { + p.m_fillMode = VHACD::FillMode::FLOOD_FILL; + } else if (fillMode == "raycast") { + p.m_fillMode = VHACD::FillMode::RAYCAST_FILL; + } else if (fillMode == "surface") { + p.m_fillMode = VHACD::FillMode::SURFACE_ONLY; + } else { + printf("Invalid fill mode, only valid options are 'flood', 'raycast', and " + "'surface'\n"); + } + +#if VHACD_DISABLE_THREADING + VHACD::IVHACD *iface = VHACD::CreateVHACD(); +#else + VHACD::IVHACD *iface = + p.m_asyncACD ? VHACD::CreateVHACD_ASYNC() : VHACD::CreateVHACD(); +#endif + + /// The main computation /////////////////////////////////////////////// + iface->Compute(ptr_points, num_points, triangles, num_faces, p); + + while (!iface->IsReady()) { + std::this_thread::sleep_for(std::chrono::nanoseconds(10000)); // s + } + + // Build our output arrays from VHACD outputs + std::vector, py::array_t>> res; + const int nConvexHulls = iface->GetNConvexHulls(); + res.reserve(nConvexHulls); + + if (nConvexHulls) { + // Exporting Convex Decomposition results of convex hulls + + for (uint32_t i = 0; i < iface->GetNConvexHulls(); i++) { + VHACD::IVHACD::ConvexHull ch; + iface->GetConvexHull(i, ch); + + /* allocate the output buffers */ + py::array_t res_vertices = + py::array_t(ch.m_points.size() * 3); + py::array_t res_faces = + py::array_t(ch.m_triangles.size() * 3); + + py::buffer_info buf_res_vertices = res_vertices.request(); + py::buffer_info buf_res_faces = res_faces.request(); + + double *ptr_res_vertices = (double *)buf_res_vertices.ptr; + uint32_t *ptr_res_faces = (uint32_t *)buf_res_faces.ptr; + + for (uint32_t j = 0; j < ch.m_points.size(); j++) { + const VHACD::Vertex &pos = ch.m_points[j]; + ptr_res_vertices[3 * j] = pos.mX; + ptr_res_vertices[3 * j + 1] = pos.mY; + ptr_res_vertices[3 * j + 2] = pos.mZ; + } + + for (uint32_t j = 0; j < ch.m_triangles.size(); j++) { + uint32_t i1 = ch.m_triangles[j].mI0; + uint32_t i2 = ch.m_triangles[j].mI1; + uint32_t i3 = ch.m_triangles[j].mI2; + ptr_res_faces[3 * j] = i1; + ptr_res_faces[3 * j + 1] = i2; + ptr_res_faces[3 * j + 2] = i3; + } + + // Reshape the vertices array to be (n, 3) + const long width = 3; + res_vertices.resize({(long)ch.m_points.size(), width}); + // Resize faces to be (m, 3) + res_faces.resize({(long)ch.m_triangles.size(), width}); + + // Push on our list + res.emplace_back(std::move(res_vertices), std::move(res_faces)); + } + } + + iface->Release(); + delete[] triangles; + return res; +} + +/* Wrapping routines with PyBind */ +PYBIND11_MODULE(vhacdx, m) { + m.doc() = + "Python bindings for the V-HACD algorithm"; // optional module docstring + m.def("compute_vhacd", &compute_vhacd, "Compute convex hulls", + py::arg("points"), py::arg("faces"), py::arg("maxConvexHulls") = 64, + py::arg("resolution") = 400000, + py::arg("minimumVolumePercentErrorAllowed") = 1.0, + py::arg("maxRecursionDepth") = 10, py::arg("shrinkWrap") = true, + py::arg("fillMode") = "flood", py::arg("maxNumVerticesPerCH") = 64, + py::arg("asyncACD") = true, py::arg("minEdgeLength") = 2, + py::arg("findBestPlane") = false); + +#ifdef VERSION_INFO + m.attr("__version__") = MACRO_STRINGIFY(VERSION_INFO); +#else + m.attr("__version__") = "dev"; +#endif +} diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel-0.48.0.dist-info/METADATA b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel-0.48.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..cdbbaa3f15969b232706b4b6573f4016d4a60ab0 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel-0.48.0.dist-info/METADATA @@ -0,0 +1,66 @@ +Metadata-Version: 2.4 +Name: wheel +Version: 0.48.0 +Summary: Command line tool for manipulating wheel files +Keywords: wheel,packaging +Author-email: Daniel Holth +Maintainer-email: Alex Grönholm +Requires-Python: >=3.9 +Description-Content-Type: text/x-rst +License-Expression: MIT +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Topic :: System :: Archiving :: Packaging +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: 3.14 +License-File: LICENSE.txt +Requires-Dist: packaging >= 24.0 +Project-URL: Changelog, https://wheel.readthedocs.io/en/stable/news.html +Project-URL: Documentation, https://wheel.readthedocs.io/ +Project-URL: Issue Tracker, https://github.com/pypa/wheel/issues +Project-URL: Source, https://github.com/pypa/wheel + +wheel +===== + +This is a command line tool for manipulating Python wheel files, as defined in +`PEP 427`_. It contains the following functionality: + +* Convert ``.egg`` archives into ``.whl`` +* Unpack wheel archives +* Repack wheel archives +* Add or remove tags in existing wheel archives + +.. _PEP 427: https://peps.python.org/pep-0427/ + +Historical note +--------------- + +This project used to contain the implementation of the setuptools_ ``bdist_wheel`` +command, but as of setuptools v70.1, it no longer needs ``wheel`` installed for that to +work. Thus, you should install this **only** if you intend to use the ``wheel`` command +line tool! + +.. _setuptools: https://pypi.org/project/setuptools/ + +Documentation +------------- + +The documentation_ can be found on Read The Docs. + +.. _documentation: https://wheel.readthedocs.io/ + +Code of Conduct +--------------- + +Everyone interacting in the wheel project's codebases, issue trackers, chat +rooms, and mailing lists is expected to follow the `PSF Code of Conduct`_. + +.. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel-0.48.0.dist-info/RECORD b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel-0.48.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..4526232371fbd701d13c44ac7ad8eb38c7b49dd8 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel-0.48.0.dist-info/RECORD @@ -0,0 +1,21 @@ +../../../bin/wheel,sha256=v-H0LQfwMKZL6kh5Y9LB9C3ESJBV6P3HRXBb4NZ5R40,497 +wheel-0.48.0.dist-info/METADATA,sha256=XYWkW5pBeyDo-QURBrifwuJKo-itYFXw8eQVPwFckeM,2282 +wheel-0.48.0.dist-info/RECORD,, +wheel-0.48.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82 +wheel-0.48.0.dist-info/entry_points.txt,sha256=JJdtSAGTvMLbIkTVZUAMvGKO39FtWfCVF8mp_NH6e4g,110 +wheel-0.48.0.dist-info/licenses/LICENSE.txt,sha256=MMI2GGeRCPPo6h0qZYx8pBe9_IkcmO8aifpP8MmChlQ,1107 +wheel/__init__.py,sha256=SG9JEXYSJFwqLY6fS5aGpuhFHFqovQ16Y8nubQ5Ea9Q,59 +wheel/__main__.py,sha256=2H-pZZw-0uFWPYT46XjFt7wUi7eJ1afPXwocKkDzXXM,516 +wheel/_bdist_wheel.py,sha256=bpmNa7_s-CYFkVgXf9ENAYTiJ01XBhRW4pxH1T8XYsI,21729 +wheel/_commands/__init__.py,sha256=O17zMe6NwPRyioSe_8R0IiPfAt4PJRliFbZ_qMsyutI,5099 +wheel/_commands/convert.py,sha256=Mpgx55EBpwIEYhEoaGESwcywmjyac8dz5EvjYbPlFII,13501 +wheel/_commands/info.py,sha256=GzV4h1sovB3DYsCCNQ5CYzavbA0z2EU2d1e1qqi9mH0,4446 +wheel/_commands/pack.py,sha256=gMogRgR-jUIfV8RdO-WQGR5De2DDbyq5WIP_-NRdLOk,4966 +wheel/_commands/tags.py,sha256=DnDK2wmjas5GpSw7EFwaCjAQO_LTeUK5nXVR4HtMS7I,5620 +wheel/_commands/unpack.py,sha256=AjDSS23XYyCSFfifnMutinrpPv-DK_2wbNHkKAUFwgM,1016 +wheel/_metadata.py,sha256=BP5jC9uC1hyicp7nL4FJ2LYixNFpEJIV_uMDY1KBZBg,6188 +wheel/_setuptools_logging.py,sha256=-5KC-lne0ilOUWIDfOkqapUWGMFZhuKYDIavIZiB5kM,781 +wheel/bdist_wheel.py,sha256=HrzYiSzMkh5ohAAhlQnYBS1p8qbr85X6F59xqxd9kBg,1102 +wheel/macosx_libfile.py,sha256=pL0wm88jRMl_4ASgGlNg_mz69Zmv5xm8JSkjLdwyvIQ,16712 +wheel/metadata.py,sha256=GknOO7JJiZMlcEe_fiD7nqnDTTLd0sX_-IgipM4L3-4,757 +wheel/wheelfile.py,sha256=Lr-hlD6vlagOoXjHkJseN7bKD4qsWQlsPBaB5QnJrVs,9288 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel-0.48.0.dist-info/WHEEL b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel-0.48.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..d8b9936dad9ab2513fa6979f411560d3b6b57e37 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel-0.48.0.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: flit 3.12.0 +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel-0.48.0.dist-info/entry_points.txt b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel-0.48.0.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..dcebd58811da1ee2758dd0f45c575704afdd61bd --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel-0.48.0.dist-info/entry_points.txt @@ -0,0 +1,6 @@ +[console_scripts] +wheel=wheel._commands:main + +[distutils.commands] +bdist_wheel=wheel.bdist_wheel:bdist_wheel + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel-0.48.0.dist-info/licenses/LICENSE.txt b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel-0.48.0.dist-info/licenses/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..a31470f14c5978d5fcc3bc173b8399b6c9a6443f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel-0.48.0.dist-info/licenses/LICENSE.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2012 Daniel Holth and contributors + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a6f1c6e349fc57e9f94990fc64c7e76821ab10d4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__init__.py @@ -0,0 +1,3 @@ +from __future__ import annotations + +__version__ = "0.48.0" diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__main__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..ce9a58d3b945a810109aaa3211f091630c19d72b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__main__.py @@ -0,0 +1,25 @@ +""" +Wheel command line tool (enables the ``python -m wheel`` syntax) +""" + +from __future__ import annotations + +import sys +from typing import NoReturn + + +def main() -> NoReturn: # needed for console script + if __spec__.parent == "": + # To be able to run 'python wheel-0.9.whl/wheel': + import os.path + + path = os.path.dirname(os.path.dirname(__file__)) + sys.path[0:0] = [path] + + from ._commands import main as cli_main + + sys.exit(cli_main()) + + +if __name__ == "__main__": + main() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..81d143a53f281c8c44ee380eea02ec351d98cd4e Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/__main__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/__main__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ce203b996956ca9ac31fa51e77745e678eb014eb Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/__main__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/_bdist_wheel.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/_bdist_wheel.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..268047489f1eeb21515487644c9e5d5c6c594992 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/_bdist_wheel.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/_metadata.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/_metadata.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..df2c458e5754ef4a10cae5a0d27c3aff44b9860e Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/_metadata.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/_setuptools_logging.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/_setuptools_logging.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..353c2ebbd44ad8e8dcc066f42df4e7c79132c588 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/_setuptools_logging.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/bdist_wheel.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/bdist_wheel.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dbca78917259fc83f903f3b8496b25688a80aeae Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/bdist_wheel.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/macosx_libfile.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/macosx_libfile.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..330bf8ffa7806fca6d271ff61db18e66e3bddd88 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/macosx_libfile.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/metadata.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/metadata.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f0584d183d3d8e592c88eaefd4695a2890596c98 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/metadata.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/wheelfile.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/wheelfile.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..84243c3fead73cdecc59c7dd7faac4a2de6f411f Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/__pycache__/wheelfile.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_bdist_wheel.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_bdist_wheel.py new file mode 100644 index 0000000000000000000000000000000000000000..575fbfb35105eb82faee5a368781ecf818379354 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_bdist_wheel.py @@ -0,0 +1,616 @@ +""" +Create a wheel (.whl) distribution. + +A wheel is a built archive format. +""" + +from __future__ import annotations + +import logging +import os +import re +import shutil +import stat +import struct +import sys +import sysconfig +import warnings +from collections.abc import Iterable, Sequence +from email.generator import BytesGenerator, Generator +from email.policy import EmailPolicy +from glob import iglob +from shutil import rmtree +from typing import TYPE_CHECKING, Callable, Literal, cast +from zipfile import ZIP_DEFLATED, ZIP_STORED + +import setuptools +from packaging import tags +from packaging import version as _packaging_version +from setuptools import Command + +from . import __version__ as wheel_version +from ._metadata import pkginfo_to_metadata +from .wheelfile import WheelFile + +if TYPE_CHECKING: + import types + +# ensure Python logging is configured +try: + __import__("setuptools.logging") +except ImportError: + # setuptools < ?? + from . import _setuptools_logging + + _setuptools_logging.configure() + +log = logging.getLogger("wheel") + + +def safe_name(name: str) -> str: + """Convert an arbitrary string to a standard distribution name + Any runs of non-alphanumeric/. characters are replaced with a single '-'. + """ + return re.sub("[^A-Za-z0-9.]+", "-", name) + + +def safe_version(version: str) -> str: + """ + Convert an arbitrary string to a standard version string + """ + try: + # normalize the version + return str(_packaging_version.Version(version)) + except _packaging_version.InvalidVersion: + version = version.replace(" ", ".") + return re.sub("[^A-Za-z0-9.]+", "-", version) + + +setuptools_major_version = int(setuptools.__version__.split(".")[0]) + +PY_LIMITED_API_PATTERN = r"cp3\d" + + +def _is_32bit_interpreter() -> bool: + return struct.calcsize("P") == 4 + + +def python_tag() -> str: + return f"py{sys.version_info[0]}" + + +def get_platform(archive_root: str | None) -> str: + """Return our platform name 'win32', 'linux_x86_64'""" + result = sysconfig.get_platform() + if result.startswith("macosx") and archive_root is not None: + from .macosx_libfile import calculate_macosx_platform_tag + + result = calculate_macosx_platform_tag(archive_root, result) + elif _is_32bit_interpreter(): + if result == "linux-x86_64": + # pip pull request #3497 + result = "linux-i686" + elif result == "linux-aarch64": + # packaging pull request #234 + # TODO armv8l, packaging pull request #690 => this did not land + # in pip/packaging yet + result = "linux-armv7l" + + return result.replace("-", "_") + + +def get_flag( + var: str, fallback: bool, expected: bool = True, warn: bool = True +) -> bool: + """Use a fallback value for determining SOABI flags if the needed config + var is unset or unavailable.""" + val = sysconfig.get_config_var(var) + if val is None: + if warn: + warnings.warn( + f"Config variable '{var}' is unset, Python ABI tag may be incorrect", + RuntimeWarning, + stacklevel=2, + ) + return fallback + return val == expected + + +def get_abi_tag() -> str | None: + """Return the ABI tag based on SOABI (if available) or emulate SOABI (PyPy2).""" + soabi: str = sysconfig.get_config_var("SOABI") + impl = tags.interpreter_name() + if not soabi and impl in ("cp", "pp") and hasattr(sys, "maxunicode"): + d = "" + m = "" + u = "" + if get_flag("Py_DEBUG", hasattr(sys, "gettotalrefcount"), warn=(impl == "cp")): + d = "d" + + if get_flag( + "WITH_PYMALLOC", + impl == "cp", + warn=(impl == "cp" and sys.version_info < (3, 8)), + ) and sys.version_info < (3, 8): + m = "m" + + abi = f"{impl}{tags.interpreter_version()}{d}{m}{u}" + elif soabi and impl == "cp" and soabi.startswith("cpython"): + # non-Windows + abi = "cp" + soabi.split("-")[1] + elif soabi and impl == "cp" and soabi.startswith("cp"): + # Windows + abi = soabi.split("-")[0] + elif soabi and impl == "pp": + # we want something like pypy36-pp73 + abi = "-".join(soabi.split("-")[:2]) + abi = abi.replace(".", "_").replace("-", "_") + elif soabi and impl == "graalpy": + abi = "-".join(soabi.split("-")[:3]) + abi = abi.replace(".", "_").replace("-", "_") + elif soabi: + abi = soabi.replace(".", "_").replace("-", "_") + else: + abi = None + + return abi + + +def safer_name(name: str) -> str: + return safe_name(name).replace("-", "_") + + +def safer_version(version: str) -> str: + return safe_version(version).replace("-", "_") + + +def remove_readonly( + func: Callable[..., object], + path: str, + excinfo: tuple[type[Exception], Exception, types.TracebackType], +) -> None: + remove_readonly_exc(func, path, excinfo[1]) + + +def remove_readonly_exc(func: Callable[..., object], path: str, exc: Exception) -> None: + os.chmod(path, stat.S_IWRITE) + func(path) + + +class bdist_wheel(Command): + description = "create a wheel distribution" + + supported_compressions = { + "stored": ZIP_STORED, + "deflated": ZIP_DEFLATED, + } + + user_options = [ + ("bdist-dir=", "b", "temporary directory for creating the distribution"), + ( + "plat-name=", + "p", + "platform name to embed in generated filenames " + f"(default: {get_platform(None)})", + ), + ( + "keep-temp", + "k", + "keep the pseudo-installation tree around after " + "creating the distribution archive", + ), + ("dist-dir=", "d", "directory to put final built distributions in"), + ("skip-build", None, "skip rebuilding everything (for testing/debugging)"), + ( + "relative", + None, + "build the archive using relative paths (default: false)", + ), + ( + "owner=", + "u", + "Owner name used when creating a tar file [default: current user]", + ), + ( + "group=", + "g", + "Group name used when creating a tar file [default: current group]", + ), + ("universal", None, "make a universal wheel (default: false)"), + ( + "compression=", + None, + "zipfile compression (one of: {}) (default: 'deflated')".format( + ", ".join(supported_compressions) + ), + ), + ( + "python-tag=", + None, + f"Python implementation compatibility tag (default: '{python_tag()}')", + ), + ( + "build-number=", + None, + "Build number for this particular version. " + "As specified in PEP-0427, this must start with a digit. " + "[default: None]", + ), + ( + "py-limited-api=", + None, + "Python tag (cp32|cp33|cpNN) for abi3 wheel tag (default: false)", + ), + ] + + boolean_options = ["keep-temp", "skip-build", "relative", "universal"] + + def initialize_options(self): + self.bdist_dir: str = None + self.data_dir = None + self.plat_name: str | None = None + self.plat_tag = None + self.format = "zip" + self.keep_temp = False + self.dist_dir: str | None = None + self.egginfo_dir = None + self.root_is_pure: bool | None = None + self.skip_build = None + self.relative = False + self.owner = None + self.group = None + self.universal: bool = False + self.compression: str | int = "deflated" + self.python_tag: str = python_tag() + self.build_number: str | None = None + self.py_limited_api: str | Literal[False] = False + self.plat_name_supplied = False + + def finalize_options(self): + if self.bdist_dir is None: + bdist_base = self.get_finalized_command("bdist").bdist_base + self.bdist_dir = os.path.join(bdist_base, "wheel") + + egg_info = self.distribution.get_command_obj("egg_info") + egg_info.ensure_finalized() # needed for correct `wheel_dist_name` + + self.data_dir = self.wheel_dist_name + ".data" + self.plat_name_supplied = self.plat_name is not None + + try: + self.compression = self.supported_compressions[self.compression] + except KeyError: + raise ValueError(f"Unsupported compression: {self.compression}") from None + + need_options = ("dist_dir", "plat_name", "skip_build") + + self.set_undefined_options("bdist", *zip(need_options, need_options)) + + self.root_is_pure = not ( + self.distribution.has_ext_modules() or self.distribution.has_c_libraries() + ) + + if self.py_limited_api and not re.match( + PY_LIMITED_API_PATTERN, self.py_limited_api + ): + raise ValueError(f"py-limited-api must match '{PY_LIMITED_API_PATTERN}'") + + # Support legacy [wheel] section for setting universal + wheel = self.distribution.get_option_dict("wheel") + if "universal" in wheel: + # please don't define this in your global configs + log.warning( + "The [wheel] section is deprecated. Use [bdist_wheel] instead.", + ) + val = wheel["universal"][1].strip() + if val.lower() in ("1", "true", "yes"): + self.universal = True + + if self.build_number is not None and not self.build_number[:1].isdigit(): + raise ValueError("Build tag (build-number) must start with a digit.") + + @property + def wheel_dist_name(self): + """Return distribution full name with - replaced with _""" + components = ( + safer_name(self.distribution.get_name()), + safer_version(self.distribution.get_version()), + ) + if self.build_number: + components += (self.build_number,) + return "-".join(components) + + def get_tag(self) -> tuple[str, str, str]: + # bdist sets self.plat_name if unset, we should only use it for purepy + # wheels if the user supplied it. + if self.plat_name_supplied: + plat_name = cast(str, self.plat_name) + elif self.root_is_pure: + plat_name = "any" + else: + # macosx contains system version in platform name so need special handle + if self.plat_name and not self.plat_name.startswith("macosx"): + plat_name = self.plat_name + else: + # on macosx always limit the platform name to comply with any + # c-extension modules in bdist_dir, since the user can specify + # a higher MACOSX_DEPLOYMENT_TARGET via tools like CMake + + # on other platforms, and on macosx if there are no c-extension + # modules, use the default platform name. + plat_name = get_platform(self.bdist_dir) + + if _is_32bit_interpreter(): + if plat_name in ("linux-x86_64", "linux_x86_64"): + plat_name = "linux_i686" + if plat_name in ("linux-aarch64", "linux_aarch64"): + # TODO armv8l, packaging pull request #690 => this did not land + # in pip/packaging yet + plat_name = "linux_armv7l" + + plat_name = ( + plat_name.lower().replace("-", "_").replace(".", "_").replace(" ", "_") + ) + + if self.root_is_pure: + if self.universal: + impl = "py2.py3" + else: + impl = self.python_tag + tag = (impl, "none", plat_name) + else: + impl_name = tags.interpreter_name() + impl_ver = tags.interpreter_version() + impl = impl_name + impl_ver + # We don't work on CPython 3.1, 3.0. + if self.py_limited_api and (impl_name + impl_ver).startswith("cp3"): + impl = self.py_limited_api + abi_tag = "abi3" + else: + abi_tag = str(get_abi_tag()).lower() + tag = (impl, abi_tag, plat_name) + # issue gh-374: allow overriding plat_name + supported_tags = [ + (t.interpreter, t.abi, plat_name) for t in tags.sys_tags() + ] + assert tag in supported_tags, ( + f"would build wheel with unsupported tag {tag}" + ) + return tag + + def run(self): + build_scripts = self.reinitialize_command("build_scripts") + build_scripts.executable = "python" + build_scripts.force = True + + build_ext = self.reinitialize_command("build_ext") + build_ext.inplace = False + + if not self.skip_build: + self.run_command("build") + + install = self.reinitialize_command("install", reinit_subcommands=True) + install.root = self.bdist_dir + install.compile = False + install.skip_build = self.skip_build + install.warn_dir = False + + # A wheel without setuptools scripts is more cross-platform. + # Use the (undocumented) `no_ep` option to setuptools' + # install_scripts command to avoid creating entry point scripts. + install_scripts = self.reinitialize_command("install_scripts") + install_scripts.no_ep = True + + # Use a custom scheme for the archive, because we have to decide + # at installation time which scheme to use. + for key in ("headers", "scripts", "data", "purelib", "platlib"): + setattr(install, "install_" + key, os.path.join(self.data_dir, key)) + + basedir_observed = "" + + if os.name == "nt": + # win32 barfs if any of these are ''; could be '.'? + # (distutils.command.install:change_roots bug) + basedir_observed = os.path.normpath(os.path.join(self.data_dir, "..")) + self.install_libbase = self.install_lib = basedir_observed + + setattr( + install, + "install_purelib" if self.root_is_pure else "install_platlib", + basedir_observed, + ) + + log.info(f"installing to {self.bdist_dir}") + + self.run_command("install") + + impl_tag, abi_tag, plat_tag = self.get_tag() + archive_basename = f"{self.wheel_dist_name}-{impl_tag}-{abi_tag}-{plat_tag}" + if not self.relative: + archive_root = self.bdist_dir + else: + archive_root = os.path.join( + self.bdist_dir, self._ensure_relative(install.install_base) + ) + + self.set_undefined_options("install_egg_info", ("target", "egginfo_dir")) + distinfo_dirname = ( + f"{safer_name(self.distribution.get_name())}-" + f"{safer_version(self.distribution.get_version())}.dist-info" + ) + distinfo_dir = os.path.join(self.bdist_dir, distinfo_dirname) + self.egg2dist(self.egginfo_dir, distinfo_dir) + + self.write_wheelfile(distinfo_dir) + + # Make the archive + if not os.path.exists(self.dist_dir): + os.makedirs(self.dist_dir) + + wheel_path = os.path.join(self.dist_dir, archive_basename + ".whl") + with WheelFile(wheel_path, "w", self.compression) as wf: + wf.write_files(archive_root) + + # Add to 'Distribution.dist_files' so that the "upload" command works + getattr(self.distribution, "dist_files", []).append( + ( + "bdist_wheel", + "{}.{}".format(*sys.version_info[:2]), # like 3.7 + wheel_path, + ) + ) + + if not self.keep_temp: + log.info(f"removing {self.bdist_dir}") + if not self.dry_run: + if sys.version_info < (3, 12): + rmtree(self.bdist_dir, onerror=remove_readonly) + else: + rmtree(self.bdist_dir, onexc=remove_readonly_exc) + + def write_wheelfile( + self, wheelfile_base: str, generator: str = f"bdist_wheel ({wheel_version})" + ): + from email.message import Message + + msg = Message() + msg["Wheel-Version"] = "1.0" # of the spec + msg["Generator"] = generator + msg["Root-Is-Purelib"] = str(self.root_is_pure).lower() + if self.build_number is not None: + msg["Build"] = self.build_number + + # Doesn't work for bdist_wininst + impl_tag, abi_tag, plat_tag = self.get_tag() + for impl in impl_tag.split("."): + for abi in abi_tag.split("."): + for plat in plat_tag.split("."): + msg["Tag"] = "-".join((impl, abi, plat)) + + wheelfile_path = os.path.join(wheelfile_base, "WHEEL") + log.info(f"creating {wheelfile_path}") + with open(wheelfile_path, "wb") as f: + BytesGenerator(f, maxheaderlen=0).flatten(msg) + + def _ensure_relative(self, path: str) -> str: + # copied from dir_util, deleted + drive, path = os.path.splitdrive(path) + if path[0:1] == os.sep: + path = drive + path[1:] + return path + + @property + def license_paths(self) -> Iterable[str]: + if setuptools_major_version >= 57: + # Setuptools has resolved any patterns to actual file names + return self.distribution.metadata.license_files or () + + files: set[str] = set() + metadata = self.distribution.get_option_dict("metadata") + if setuptools_major_version >= 42: + # Setuptools recognizes the license_files option but does not do globbing + patterns = cast(Sequence[str], self.distribution.metadata.license_files) + else: + # Prior to those, wheel is entirely responsible for handling license files + if "license_files" in metadata: + patterns = metadata["license_files"][1].split() + else: + patterns = () + + if "license_file" in metadata: + warnings.warn( + 'The "license_file" option is deprecated. Use "license_files" instead.', + DeprecationWarning, + stacklevel=2, + ) + files.add(metadata["license_file"][1]) + + if not files and not patterns and not isinstance(patterns, list): + patterns = ("LICEN[CS]E*", "COPYING*", "NOTICE*", "AUTHORS*") + + for pattern in patterns: + for path in iglob(pattern): + if path.endswith("~"): + log.debug( + f'ignoring license file "{path}" as it looks like a backup' + ) + continue + + if path not in files and os.path.isfile(path): + log.info( + f'adding license file "{path}" (matched pattern "{pattern}")' + ) + files.add(path) + + return files + + def egg2dist(self, egginfo_path: str, distinfo_path: str): + """Convert an .egg-info directory into a .dist-info directory""" + + def adios(p: str) -> None: + """Appropriately delete directory, file or link.""" + if os.path.exists(p) and not os.path.islink(p) and os.path.isdir(p): + shutil.rmtree(p) + elif os.path.exists(p): + os.unlink(p) + + adios(distinfo_path) + + if not os.path.exists(egginfo_path): + # There is no egg-info. This is probably because the egg-info + # file/directory is not named matching the distribution name used + # to name the archive file. Check for this case and report + # accordingly. + import glob + + pat = os.path.join(os.path.dirname(egginfo_path), "*.egg-info") + possible = glob.glob(pat) + err = f"Egg metadata expected at {egginfo_path} but not found" + if possible: + alt = os.path.basename(possible[0]) + err += f" ({alt} found - possible misnamed archive file?)" + + raise ValueError(err) + + if os.path.isfile(egginfo_path): + # .egg-info is a single file + pkg_info = pkginfo_to_metadata(egginfo_path, egginfo_path) + os.mkdir(distinfo_path) + else: + # .egg-info is a directory + pkginfo_path = os.path.join(egginfo_path, "PKG-INFO") + pkg_info = pkginfo_to_metadata(egginfo_path, pkginfo_path) + + # ignore common egg metadata that is useless to wheel + shutil.copytree( + egginfo_path, + distinfo_path, + ignore=lambda x, y: { + "PKG-INFO", + "requires.txt", + "SOURCES.txt", + "not-zip-safe", + }, + ) + + # delete dependency_links if it is only whitespace + dependency_links_path = os.path.join(distinfo_path, "dependency_links.txt") + with open(dependency_links_path, encoding="utf-8") as dependency_links_file: + dependency_links = dependency_links_file.read().strip() + if not dependency_links: + adios(dependency_links_path) + + pkg_info_path = os.path.join(distinfo_path, "METADATA") + serialization_policy = EmailPolicy( + utf8=True, + mangle_from_=False, + max_line_length=0, + ) + with open(pkg_info_path, "w", encoding="utf-8") as out: + Generator(out, policy=serialization_policy).flatten(pkg_info) + + for license_path in self.license_paths: + filename = os.path.basename(license_path) + shutil.copy(license_path, os.path.join(distinfo_path, filename)) + + adios(egginfo_path) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7931c786c931df8cb49f3c85e26b9800df77dc55 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__init__.py @@ -0,0 +1,172 @@ +""" +Wheel command-line utility. +""" + +from __future__ import annotations + +import argparse +import os +import sys +from argparse import ArgumentTypeError + +from ..wheelfile import WheelError + + +def unpack_f(args: argparse.Namespace) -> None: + from .unpack import unpack + + unpack(args.wheelfile, args.dest) + + +def pack_f(args: argparse.Namespace) -> None: + from .pack import pack + + pack(args.directory, args.dest_dir, args.build_number, args.local_version) + + +def convert_f(args: argparse.Namespace) -> None: + from .convert import convert + + convert(args.files, args.dest_dir, args.verbose) + + +def tags_f(args: argparse.Namespace) -> None: + from .tags import tags + + names = ( + tags( + wheel, + args.python_tag, + args.abi_tag, + args.platform_tag, + args.build, + args.remove, + ) + for wheel in args.wheel + ) + + for name in names: + print(name) + + +def info_f(args: argparse.Namespace) -> None: + from .info import info + + try: + info(args.wheelfile, args.verbose) + except FileNotFoundError as e: + raise WheelError(str(e)) from e + + +def version_f(args: argparse.Namespace) -> None: + from .. import __version__ + + print(f"wheel {__version__}") + + +def parse_build_tag(build_tag: str) -> str: + if build_tag and not build_tag[0].isdigit(): + raise ArgumentTypeError("build tag must begin with a digit") + elif "-" in build_tag: + raise ArgumentTypeError("invalid character ('-') in build tag") + + return build_tag + + +TAGS_HELP = """\ +Make a new wheel with given tags. Any tags unspecified will remain the same. +Starting the tags with a "+" will append to the existing tags. Starting with a +"-" will remove a tag (use --option=-TAG syntax). Multiple tags can be +separated by ".". The original file will remain unless --remove is given. The +output filename(s) will be displayed on stdout for further processing. +""" + + +def parser() -> argparse.ArgumentParser: + p = argparse.ArgumentParser() + s = p.add_subparsers(help="commands") + + unpack_parser = s.add_parser("unpack", help="Unpack wheel") + unpack_parser.add_argument( + "--dest", "-d", help="Destination directory", default="." + ) + unpack_parser.add_argument("wheelfile", help="Wheel file") + unpack_parser.set_defaults(func=unpack_f) + + repack_parser = s.add_parser("pack", help="Repack wheel") + repack_parser.add_argument("directory", help="Root directory of the unpacked wheel") + repack_parser.add_argument( + "--dest-dir", + "-d", + default=os.path.curdir, + help="Directory to store the wheel (default %(default)s)", + ) + repack_parser.add_argument( + "--build-number", help="Build tag to use in the wheel name" + ) + repack_parser.add_argument( + "--local-version", help="Local version identifier to add or replace" + ) + repack_parser.set_defaults(func=pack_f) + + convert_parser = s.add_parser("convert", help="Convert egg or wininst to wheel") + convert_parser.add_argument("files", nargs="*", help="Files to convert") + convert_parser.add_argument( + "--dest-dir", + "-d", + default=os.path.curdir, + help="Directory to store wheels (default %(default)s)", + ) + convert_parser.add_argument("--verbose", "-v", action="store_true") + convert_parser.set_defaults(func=convert_f) + + tags_parser = s.add_parser( + "tags", help="Add or replace the tags on a wheel", description=TAGS_HELP + ) + tags_parser.add_argument("wheel", nargs="*", help="Existing wheel(s) to retag") + tags_parser.add_argument( + "--remove", + action="store_true", + help="Remove the original files, keeping only the renamed ones", + ) + tags_parser.add_argument( + "--python-tag", metavar="TAG", help="Specify an interpreter tag(s)" + ) + tags_parser.add_argument("--abi-tag", metavar="TAG", help="Specify an ABI tag(s)") + tags_parser.add_argument( + "--platform-tag", metavar="TAG", help="Specify a platform tag(s)" + ) + tags_parser.add_argument( + "--build", type=parse_build_tag, metavar="BUILD", help="Specify a build tag" + ) + tags_parser.set_defaults(func=tags_f) + + info_parser = s.add_parser("info", help="Show information about a wheel file") + info_parser.add_argument("wheelfile", help="Wheel file to show information for") + info_parser.add_argument( + "--verbose", "-v", action="store_true", help="Show detailed file listing" + ) + info_parser.set_defaults(func=info_f) + + version_parser = s.add_parser("version", help="Print version and exit") + version_parser.set_defaults(func=version_f) + + help_parser = s.add_parser("help", help="Show this help") + help_parser.set_defaults(func=lambda args: p.print_help()) + + return p + + +def main() -> int: + p = parser() + args = p.parse_args() + if not hasattr(args, "func"): + p.print_help() + else: + try: + args.func(args) + return 0 + except WheelError as e: + print(e, file=sys.stderr) + + return 1 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..939f3e84a65e87b9d82e1271f4b6a1fcbb83b6e0 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/convert.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/convert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5f654f78ff4e366e9339c5c712c52da0cf37e6cf Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/convert.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/info.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/info.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..00007357630ff192f6bd30fdb962c8f379c082c3 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/info.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/pack.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/pack.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8d82a83d5b6fbb1299bba48d048d7ab7561a4932 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/pack.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/tags.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/tags.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c742555aade9d77d27e14561b751aaead65c08e1 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/tags.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/unpack.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/unpack.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..566ccec2b39369fea92825b1ec1b476274ac7459 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/__pycache__/unpack.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/convert.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/convert.py new file mode 100644 index 0000000000000000000000000000000000000000..394b1dafd5c5f27d63ef7c2e3aa072b5b48618cf --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/convert.py @@ -0,0 +1,359 @@ +from __future__ import annotations + +import os.path +import re +from abc import ABCMeta, abstractmethod +from collections import defaultdict +from collections.abc import Iterator +from email.message import Message +from email.parser import Parser +from email.policy import EmailPolicy +from glob import iglob +from pathlib import Path +from textwrap import dedent +from zipfile import ZipFile + +from packaging.tags import parse_tag + +from .. import __version__ +from .._metadata import generate_requirements +from ..wheelfile import WheelError, WheelFile + +egg_filename_re = re.compile( + r""" + (?P.+?)-(?P.+?) + (-(?Ppy\d\.\d+) + (-(?P.+?))? + )?.egg$""", + re.VERBOSE, +) +egg_info_re = re.compile( + r""" + ^(?P.+?)-(?P.+?) + (-(?Ppy\d\.\d+) + )?.egg-info/""", + re.VERBOSE, +) +wininst_re = re.compile( + r"\.(?Pwin32|win-amd64)(?:-(?Ppy\d\.\d))?\.exe$" +) +pyd_re = re.compile(r"\.(?P[a-z0-9]+)-(?Pwin32|win_amd64)\.pyd$") +serialization_policy = EmailPolicy( + utf8=True, + mangle_from_=False, + max_line_length=0, +) +GENERATOR = f"wheel {__version__}" + + +def convert_requires(requires: str, metadata: Message) -> None: + extra: str | None = None + requirements: dict[str | None, list[str]] = defaultdict(list) + for line in requires.splitlines(): + line = line.strip() + if not line: + continue + + if line.startswith("[") and line.endswith("]"): + extra = line[1:-1] + continue + + requirements[extra].append(line) + + for key, value in generate_requirements(requirements): + metadata.add_header(key, value) + + +def convert_pkg_info(pkginfo: str, metadata: Message) -> None: + parsed_message = Parser().parsestr(pkginfo) + metadata_version = parsed_message.get("Metadata-Version", "1.0") + for key, value in parsed_message.items(): + key_lower = key.lower() + if value == "UNKNOWN": + continue + + if key_lower == "description": + description_lines = value.splitlines() + if description_lines: + value = "\n".join( + ( + description_lines[0].lstrip(), + dedent("\n".join(description_lines[1:])), + "\n", + ) + ) + else: + value = "\n" + + metadata.set_payload(value) + elif key_lower == "home-page": + metadata.add_header("Project-URL", f"Homepage, {value}") + elif key_lower == "download-url": + metadata.add_header("Project-URL", f"Download, {value}") + else: + metadata.add_header(key, value) + + metadata.replace_header( + "Metadata-Version", + _compatible_metadata_version(metadata_version), + ) + + +def _compatible_metadata_version(metadata_version: str) -> str: + try: + major_str, minor_str = metadata_version.split(".", 1) + major_minor = (int(major_str), int(minor_str)) + except ValueError: + return "1.2" + + if major_minor < (1, 2): + return "1.2" + + return metadata_version + + +def normalize(name: str) -> str: + return re.sub(r"[-_.]+", "-", name).lower().replace("-", "_") + + +class ConvertSource(metaclass=ABCMeta): + name: str + version: str + pyver: str = "py2.py3" + abi: str = "none" + platform: str = "any" + metadata: Message + + @property + def dist_info_dir(self) -> str: + return f"{self.name}-{self.version}.dist-info" + + @abstractmethod + def generate_contents(self) -> Iterator[tuple[str, bytes]]: + pass + + +class EggFileSource(ConvertSource): + def __init__(self, path: Path): + if not (match := egg_filename_re.match(path.name)): + raise ValueError(f"Invalid egg file name: {path.name}") + + # Binary wheels are assumed to be for CPython + self.path = path + self.name = normalize(match.group("name")) + self.version = match.group("ver") + if pyver := match.group("pyver"): + self.pyver = pyver.replace(".", "") + if arch := match.group("arch"): + self.abi = self.pyver.replace("py", "cp") + self.platform = normalize(arch) + + self.metadata = Message() + + def generate_contents(self) -> Iterator[tuple[str, bytes]]: + with ZipFile(self.path, "r") as zip_file: + for filename in sorted(zip_file.namelist()): + # Skip pure directory entries + if filename.endswith("/"): + continue + + # Handle files in the egg-info directory specially, selectively moving + # them to the dist-info directory while converting as needed + if filename.startswith("EGG-INFO/"): + if filename == "EGG-INFO/requires.txt": + requires = zip_file.read(filename).decode("utf-8") + convert_requires(requires, self.metadata) + elif filename == "EGG-INFO/PKG-INFO": + pkginfo = zip_file.read(filename).decode("utf-8") + convert_pkg_info(pkginfo, self.metadata) + elif filename == "EGG-INFO/entry_points.txt": + yield ( + f"{self.dist_info_dir}/entry_points.txt", + zip_file.read(filename), + ) + + continue + + # For any other file, just pass it through + yield filename, zip_file.read(filename) + + +class EggDirectorySource(EggFileSource): + def generate_contents(self) -> Iterator[tuple[str, bytes]]: + for dirpath, _, filenames in os.walk(self.path): + for filename in sorted(filenames): + path = Path(dirpath, filename) + if path.parent.name == "EGG-INFO": + if path.name == "requires.txt": + requires = path.read_text("utf-8") + convert_requires(requires, self.metadata) + elif path.name == "PKG-INFO": + pkginfo = path.read_text("utf-8") + convert_pkg_info(pkginfo, self.metadata) + if name := self.metadata.get("Name"): + self.name = normalize(name) + + if version := self.metadata.get("Version"): + self.version = version + elif path.name == "entry_points.txt": + yield ( + f"{self.dist_info_dir}/entry_points.txt", + path.read_bytes(), + ) + + continue + + # For any other file, just pass it through + yield str(path.relative_to(self.path)), path.read_bytes() + + +class WininstFileSource(ConvertSource): + """ + Handles distributions created with ``bdist_wininst``. + + The egginfo filename has the format:: + + name-ver(-pyver)(-arch).egg-info + + The installer filename has the format:: + + name-ver.arch(-pyver).exe + + Some things to note: + + 1. The installer filename is not definitive. An installer can be renamed + and work perfectly well as an installer. So more reliable data should + be used whenever possible. + 2. The egg-info data should be preferred for the name and version, because + these come straight from the distutils metadata, and are mandatory. + 3. The pyver from the egg-info data should be ignored, as it is + constructed from the version of Python used to build the installer, + which is irrelevant - the installer filename is correct here (even to + the point that when it's not there, any version is implied). + 4. The architecture must be taken from the installer filename, as it is + not included in the egg-info data. + 5. Architecture-neutral installers still have an architecture because the + installer format itself (being executable) is architecture-specific. We + should therefore ignore the architecture if the content is pure-python. + """ + + def __init__(self, path: Path): + self.path = path + self.metadata = Message() + + # Determine the initial architecture and Python version from the file name + # (if possible) + if match := wininst_re.search(path.name): + self.platform = normalize(match.group("platform")) + if pyver := match.group("pyver"): + self.pyver = pyver.replace(".", "") + + # Look for an .egg-info directory and any .pyd files for more precise info + egg_info_found = pyd_found = False + with ZipFile(self.path) as zip_file: + for filename in zip_file.namelist(): + prefix, filename = filename.split("/", 1) + if not egg_info_found and (match := egg_info_re.match(filename)): + egg_info_found = True + self.name = normalize(match.group("name")) + self.version = match.group("ver") + if pyver := match.group("pyver"): + self.pyver = pyver.replace(".", "") + elif not pyd_found and (match := pyd_re.search(filename)): + pyd_found = True + self.abi = match.group("abi") + self.platform = match.group("platform") + + if egg_info_found and pyd_found: + break + + def generate_contents(self) -> Iterator[tuple[str, bytes]]: + dist_info_dir = f"{self.name}-{self.version}.dist-info" + data_dir = f"{self.name}-{self.version}.data" + with ZipFile(self.path, "r") as zip_file: + for filename in sorted(zip_file.namelist()): + # Skip pure directory entries + if filename.endswith("/"): + continue + + # Handle files in the egg-info directory specially, selectively moving + # them to the dist-info directory while converting as needed + prefix, target_filename = filename.split("/", 1) + if egg_info_re.search(target_filename): + basename = target_filename.rsplit("/", 1)[-1] + if basename == "requires.txt": + requires = zip_file.read(filename).decode("utf-8") + convert_requires(requires, self.metadata) + elif basename == "PKG-INFO": + pkginfo = zip_file.read(filename).decode("utf-8") + convert_pkg_info(pkginfo, self.metadata) + elif basename == "entry_points.txt": + yield ( + f"{dist_info_dir}/entry_points.txt", + zip_file.read(filename), + ) + + continue + elif prefix == "SCRIPTS": + target_filename = f"{data_dir}/scripts/{target_filename}" + + # For any other file, just pass it through + yield target_filename, zip_file.read(filename) + + +def convert(files: list[str], dest_dir: str, verbose: bool) -> None: + for pat in files: + for archive in iglob(pat): + path = Path(archive) + if path.suffix == ".egg": + if path.is_dir(): + source: ConvertSource = EggDirectorySource(path) + else: + source = EggFileSource(path) + else: + source = WininstFileSource(path) + + if verbose: + print(f"{archive}...", flush=True, end="") + + dest_path = Path(dest_dir) / ( + f"{source.name}-{source.version}-{source.pyver}-{source.abi}" + f"-{source.platform}.whl" + ) + if dest_path.parent != Path(dest_dir): + # name/version come from the input archive and may contain path + # separators; never write outside the destination directory + raise WheelError(f"Invalid distribution name or version in {archive!r}") + + with WheelFile(dest_path, "w") as wheelfile: + for name_or_zinfo, contents in source.generate_contents(): + wheelfile.writestr(name_or_zinfo, contents) + + # Write the METADATA file + wheelfile.writestr( + f"{source.dist_info_dir}/METADATA", + source.metadata.as_string(policy=serialization_policy).encode( + "utf-8" + ), + ) + + # Write the WHEEL file + wheel_message = Message() + wheel_message.add_header("Wheel-Version", "1.0") + wheel_message.add_header("Generator", GENERATOR) + wheel_message.add_header( + "Root-Is-Purelib", str(source.platform == "any").lower() + ) + tags = parse_tag(f"{source.pyver}-{source.abi}-{source.platform}") + for tag in sorted(tags, key=lambda tag: tag.interpreter): + wheel_message.add_header("Tag", str(tag)) + + wheelfile.writestr( + f"{source.dist_info_dir}/WHEEL", + wheel_message.as_string(policy=serialization_policy).encode( + "utf-8" + ), + ) + + if verbose: + print("OK") diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/info.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/info.py new file mode 100644 index 0000000000000000000000000000000000000000..27ad47a28601e939f11714c49c809490d10763c3 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/info.py @@ -0,0 +1,124 @@ +""" +Display information about wheel files. +""" + +from __future__ import annotations + +import email.policy +import sys +from email.parser import BytesParser +from pathlib import Path + +from ..wheelfile import WheelFile + + +def info(path: str, verbose: bool = False) -> None: + """Display information about a wheel file. + + :param path: The path to the wheel file + :param verbose: Show detailed file listing + """ + wheel_path = Path(path) + if not wheel_path.exists(): + raise FileNotFoundError(f"Wheel file not found: {path}") + + with WheelFile(path) as wf: + # Extract basic wheel information from filename + parsed = wf.parsed_filename + name = parsed.group("name") + version = parsed.group("ver") + build_tag = parsed.group("build") + + print(f"Name: {name}") + print(f"Version: {version}") + if build_tag: + print(f"Build: {build_tag}") + + # Read WHEEL metadata + try: + with wf.open(f"{wf.dist_info_path}/WHEEL") as wheel_file: + wheel_metadata = BytesParser(policy=email.policy.compat32).parse( + wheel_file + ) + + print( + f"Wheel-Version: {wheel_metadata.get('Wheel-Version', 'Unknown')}" + ) + print( + f"Root-Is-Purelib: {wheel_metadata.get('Root-Is-Purelib', 'Unknown')}" + ) + + # Get all tags + tags = wheel_metadata.get_all("Tag", []) + if tags: + print("Tags:") + for tag in sorted(tags): # Sort tags for consistent output + print(f" {tag}") + + generators = wheel_metadata.get_all("Generator", []) + for generator in generators: + print(f"Generator: {generator}") + except KeyError: + print("Warning: WHEEL metadata file not found", file=sys.stderr) + + # Read package METADATA + try: + with wf.open(f"{wf.dist_info_path}/METADATA") as metadata_file: + pkg_metadata = BytesParser(policy=email.policy.compat32).parse( + metadata_file + ) + + summary = pkg_metadata.get("Summary", "") + if summary and summary != "UNKNOWN": + print(f"Summary: {summary}") + + author = pkg_metadata.get("Author", "") + if author and author != "UNKNOWN": + print(f"Author: {author}") + + author_email = pkg_metadata.get("Author-email") + if author_email and author_email != "UNKNOWN": + print(f"Author-email: {author_email}") + + homepage = pkg_metadata.get("Home-page") + if homepage and homepage != "UNKNOWN": + print(f"Home-page: {homepage}") + + license_info = pkg_metadata.get("License") + if license_info and license_info != "UNKNOWN": + print(f"License: {license_info}") + + # Show classifiers + classifiers = pkg_metadata.get_all("Classifier", []) + if classifiers: + print("Classifiers:") + for classifier in sorted( + classifiers[:5] + ): # Sort and limit to first 5 + print(f" {classifier}") + + if len(classifiers) > 5: + print(f" ... and {len(classifiers) - 5} more") + + # Show dependencies + requires_dist = pkg_metadata.get_all("Requires-Dist", []) + if requires_dist: + print("Requires-Dist:") + for req in sorted(requires_dist): # Sort dependencies + print(f" {req}") + except KeyError: + print("Warning: METADATA file not found", file=sys.stderr) + + # File information + file_count = len(wf.filelist) + total_size = sum(zinfo.file_size for zinfo in wf.filelist) + + print(f"Files: {file_count}") + print(f"Size: {total_size:,} bytes") + + # Show file listing if verbose + if verbose: + print("\nFile listing:") + for zinfo in wf.filelist: + size_str = f"{zinfo.file_size:,}" if zinfo.file_size > 0 else "0" + print(f" {zinfo.filename:60} {size_str:>10} bytes") diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/pack.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/pack.py new file mode 100644 index 0000000000000000000000000000000000000000..5164d0082e2027b98631a1ad5928a82923a0cbda --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/pack.py @@ -0,0 +1,136 @@ +from __future__ import annotations + +import email.policy +import os.path +import re +from email.generator import BytesGenerator +from email.parser import BytesParser + +from packaging.version import InvalidVersion, Version + +from ..wheelfile import WheelError, WheelFile + +DIST_INFO_RE = re.compile(r"^(?P(?P.+?)-(?P\d.*?))\.dist-info$") + + +def pack( + directory: str, + dest_dir: str, + build_number: str | None, + local_version: str | None = None, +) -> None: + """Repack a previously unpacked wheel directory into a new wheel file. + + The .dist-info/WHEEL file must contain one or more tags so that the target + wheel file name can be determined. + + :param directory: The unpacked wheel directory + :param dest_dir: Destination directory (defaults to the current directory) + :param build_number: Build tag to use in the wheel name + :param local_version: Local version identifier to add or replace + """ + # Find the .dist-info directory + dist_info_dirs = [ + fn + for fn in os.listdir(directory) + if os.path.isdir(os.path.join(directory, fn)) and DIST_INFO_RE.match(fn) + ] + if len(dist_info_dirs) > 1: + raise WheelError(f"Multiple .dist-info directories found in {directory}") + elif not dist_info_dirs: + raise WheelError(f"No .dist-info directories found in {directory}") + + # Determine the target wheel filename + dist_info_dir = dist_info_dirs[0] + match = DIST_INFO_RE.match(dist_info_dir) + name_version = match.group("namever") + name = match.group("name") + version = match.group("ver") + + # Update the local version identifier if requested + if local_version is not None: + base_version = version.split("+", 1)[0] + new_version = ( + base_version if local_version == "" else f"{base_version}+{local_version}" + ) + try: + Version(new_version) + except InvalidVersion as e: + raise WheelError(f"Invalid version {new_version!r}: {e}") from None + + if "-" in new_version: + raise WheelError( + f"Invalid local version identifier {local_version!r}: " + "wheel filenames cannot contain '-' in the version; " + "use '_' instead of '-'" + ) + + new_namever = f"{name}-{new_version}" + new_dist_info_dir = f"{new_namever}.dist-info" + os.rename( + os.path.join(directory, dist_info_dir), + os.path.join(directory, new_dist_info_dir), + ) + dist_info_dir = new_dist_info_dir + name_version = new_namever + + # Update the Version field in .dist-info/METADATA + metadata_path = os.path.join(directory, dist_info_dir, "METADATA") + try: + with open(metadata_path, "rb") as f: + metadata = BytesParser(policy=email.policy.compat32).parse(f) + except FileNotFoundError: + raise WheelError(f"Missing {dist_info_dir}/METADATA file") from None + + del metadata["Version"] + metadata["Version"] = new_version + with open(metadata_path, "wb") as f: + BytesGenerator(f, maxheaderlen=0).flatten(metadata) + + # Read the tags and the existing build number from .dist-info/WHEEL + wheel_file_path = os.path.join(directory, dist_info_dir, "WHEEL") + with open(wheel_file_path, "rb") as f: + info = BytesParser(policy=email.policy.compat32).parse(f) + tags: list[str] = info.get_all("Tag", []) + existing_build_number = info.get("Build") + + if not tags: + raise WheelError( + f"No tags present in {dist_info_dir}/WHEEL; cannot determine target " + f"wheel filename" + ) + + # Set the wheel file name and add/replace/remove the Build tag in .dist-info/WHEEL + build_number = build_number if build_number is not None else existing_build_number + if build_number is not None: + del info["Build"] + if build_number: + info["Build"] = build_number + name_version += "-" + build_number + + if build_number != existing_build_number: + with open(wheel_file_path, "wb") as f: + BytesGenerator(f, maxheaderlen=0).flatten(info) + + # Reassemble the tags for the wheel file + tagline = compute_tagline(tags) + + # Repack the wheel + wheel_path = os.path.join(dest_dir, f"{name_version}-{tagline}.whl") + with WheelFile(wheel_path, "w") as wf: + print(f"Repacking wheel as {wheel_path}...", end="", flush=True) + wf.write_files(directory) + + print("OK") + + +def compute_tagline(tags: list[str]) -> str: + """Compute a tagline from a list of tags. + + :param tags: A list of tags + :return: A tagline + """ + impls = sorted({tag.split("-")[0] for tag in tags}) + abivers = sorted({tag.split("-")[1] for tag in tags}) + platforms = sorted({tag.split("-")[2] for tag in tags}) + return "-".join([".".join(impls), ".".join(abivers), ".".join(platforms)]) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/tags.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/tags.py new file mode 100644 index 0000000000000000000000000000000000000000..76e798b37e0298faa8b67ea02eb858fd05463374 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/tags.py @@ -0,0 +1,165 @@ +from __future__ import annotations + +import email.policy +import itertools +import os +import struct +from collections.abc import Iterable +from email.parser import BytesParser + +from ..wheelfile import WheelFile + +# Header ID of the ZIP64 extended information extra field. +_ZIP64_EXTRA_ID = 0x0001 + + +def _compute_tags(original_tags: Iterable[str], new_tags: str | None) -> set[str]: + """Add or replace tags. Supports dot-separated tags""" + if new_tags is None: + return set(original_tags) + + if new_tags.startswith("+"): + return {*original_tags, *new_tags[1:].split(".")} + + if new_tags.startswith("-"): + return set(original_tags) - set(new_tags[1:].split(".")) + + return set(new_tags.split(".")) + + +def _strip_zip64_extra(extra: bytes) -> bytes: + """Drop the ZIP64 extra field copied from a central-directory entry. + + The ZIP64 field encodes the local-header offset, which is meaningful only + in the central directory. Keeping it in a local header produces an invalid + archive; removing it lets zipfile regenerate a correct field when needed. + """ + kept: list[bytes] = [] + while len(extra) >= 4: + field_id, field_size = struct.unpack(" str: + """Change the tags on a wheel file. + + The tags are left unchanged if they are not specified. To specify "none", + use ["none"]. To append to the previous tags, a tag should start with a + "+". If a tag starts with "-", it will be removed from existing tags. + Processing is done left to right. + + :param wheel: The paths to the wheels + :param python_tags: The Python tags to set + :param abi_tags: The ABI tags to set + :param platform_tags: The platform tags to set + :param build_tag: The build tag to set + :param remove: Remove the original wheel + """ + with WheelFile(wheel, "r") as f: + assert f.filename, f"{f.filename} must be available" + + wheel_info = f.read(f.dist_info_path + "/WHEEL") + info = BytesParser(policy=email.policy.compat32).parsebytes(wheel_info) + + original_wheel_name = os.path.basename(f.filename) + namever = f.parsed_filename.group("namever") + build = f.parsed_filename.group("build") + original_python_tags = f.parsed_filename.group("pyver").split(".") + original_abi_tags = f.parsed_filename.group("abi").split(".") + original_plat_tags = f.parsed_filename.group("plat").split(".") + + tags: list[str] = info.get_all("Tag", []) + existing_build_tag = info.get("Build") + + impls = {tag.split("-")[0] for tag in tags} + abivers = {tag.split("-")[1] for tag in tags} + platforms = {tag.split("-")[2] for tag in tags} + + if impls != set(original_python_tags): + msg = f"Wheel internal tags {impls!r} != filename tags {original_python_tags!r}" + raise AssertionError(msg) + + if abivers != set(original_abi_tags): + msg = f"Wheel internal tags {abivers!r} != filename tags {original_abi_tags!r}" + raise AssertionError(msg) + + if platforms != set(original_plat_tags): + msg = ( + f"Wheel internal tags {platforms!r} != filename tags {original_plat_tags!r}" + ) + raise AssertionError(msg) + + if existing_build_tag != build: + msg = ( + f"Incorrect filename '{build}' " + f"& *.dist-info/WHEEL '{existing_build_tag}' build numbers" + ) + raise AssertionError(msg) + + # Start changing as needed + if build_tag is not None: + build = build_tag + + final_python_tags = sorted(_compute_tags(original_python_tags, python_tags)) + final_abi_tags = sorted(_compute_tags(original_abi_tags, abi_tags)) + final_plat_tags = sorted(_compute_tags(original_plat_tags, platform_tags)) + + final_tags = [ + namever, + ".".join(final_python_tags), + ".".join(final_abi_tags), + ".".join(final_plat_tags), + ] + if build: + final_tags.insert(1, build) + + final_wheel_name = "-".join(final_tags) + ".whl" + + if original_wheel_name != final_wheel_name: + del info["Tag"], info["Build"] + for a, b, c in itertools.product( + final_python_tags, final_abi_tags, final_plat_tags + ): + info["Tag"] = f"{a}-{b}-{c}" + if build: + info["Build"] = build + + original_wheel_path = os.path.join( + os.path.dirname(f.filename), original_wheel_name + ) + final_wheel_path = os.path.join(os.path.dirname(f.filename), final_wheel_name) + + with ( + WheelFile(original_wheel_path, "r") as fin, + WheelFile(final_wheel_path, "w") as fout, + ): + fout.comment = fin.comment # preserve the comment + for item in fin.infolist(): + if item.is_dir(): + continue + item.extra = _strip_zip64_extra(item.extra) + if item.filename == f.dist_info_path + "/RECORD": + continue + if item.filename == f.dist_info_path + "/WHEEL": + fout.writestr(item, info.as_bytes()) + else: + fout.writestr(item, fin.read(item)) + + if remove: + os.remove(original_wheel_path) + + return final_wheel_name diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/unpack.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/unpack.py new file mode 100644 index 0000000000000000000000000000000000000000..83dc7423f8171a3b6ffd6641475af037b7c59495 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_commands/unpack.py @@ -0,0 +1,30 @@ +from __future__ import annotations + +from pathlib import Path + +from ..wheelfile import WheelFile + + +def unpack(path: str, dest: str = ".") -> None: + """Unpack a wheel. + + Wheel content will be unpacked to {dest}/{name}-{ver}, where {name} + is the package name and {ver} its version. + + :param path: The path to the wheel. + :param dest: Destination directory (default to current directory). + """ + with WheelFile(path) as wf: + namever = wf.parsed_filename.group("namever") + destination = Path(dest) / namever + print(f"Unpacking to: {destination}...", end="", flush=True) + for zinfo in wf.filelist: + target_path = Path(wf.extract(zinfo, destination)) + + # Set permissions to the same values as they were set in the archive + # We have to do this manually due to + # https://github.com/python/cpython/issues/59999 + permissions = zinfo.external_attr >> 16 & 0o777 + target_path.chmod(permissions) + + print("OK") diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_metadata.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_metadata.py new file mode 100644 index 0000000000000000000000000000000000000000..e17a7b924526b9fcad83fc44996f17695dea0161 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_metadata.py @@ -0,0 +1,184 @@ +""" +Tools for converting old- to new-style metadata. +""" + +from __future__ import annotations + +import functools +import itertools +import os.path +import re +import textwrap +from collections.abc import Generator, Iterable, Iterator +from email.message import Message +from email.parser import Parser +from typing import Literal + +from packaging.requirements import Requirement + + +def _nonblank(str: str) -> bool | Literal[""]: + return str and not str.startswith("#") + + +@functools.singledispatch +def yield_lines(iterable: Iterable[str]) -> Iterator[str]: + r""" + Yield valid lines of a string or iterable. + >>> list(yield_lines('')) + [] + >>> list(yield_lines(['foo', 'bar'])) + ['foo', 'bar'] + >>> list(yield_lines('foo\nbar')) + ['foo', 'bar'] + >>> list(yield_lines('\nfoo\n#bar\nbaz #comment')) + ['foo', 'baz #comment'] + >>> list(yield_lines(['foo\nbar', 'baz', 'bing\n\n\n'])) + ['foo', 'bar', 'baz', 'bing'] + """ + return itertools.chain.from_iterable(map(yield_lines, iterable)) + + +@yield_lines.register(str) +def _(text: str) -> Iterator[str]: + return filter(_nonblank, map(str.strip, text.splitlines())) + + +def split_sections( + s: str | Iterator[str], +) -> Generator[tuple[str | None, list[str]], None, None]: + """Split a string or iterable thereof into (section, content) pairs + Each ``section`` is a stripped version of the section header ("[section]") + and each ``content`` is a list of stripped lines excluding blank lines and + comment-only lines. If there are any such lines before the first section + header, they're returned in a first ``section`` of ``None``. + """ + section = None + content: list[str] = [] + for line in yield_lines(s): + if line.startswith("["): + if line.endswith("]"): + if section or content: + yield section, content + section = line[1:-1].strip() + content = [] + else: + raise ValueError("Invalid section heading", line) + else: + content.append(line) + + # wrap up last segment + yield section, content + + +def safe_extra(extra: str) -> str: + """Convert an arbitrary string to a standard 'extra' name + Any runs of non-alphanumeric characters are replaced with a single '_', + and the result is always lowercased. + """ + return re.sub("[^A-Za-z0-9.-]+", "_", extra).lower() + + +def safe_name(name: str) -> str: + """Convert an arbitrary string to a standard distribution name + Any runs of non-alphanumeric/. characters are replaced with a single '-'. + """ + return re.sub("[^A-Za-z0-9.]+", "-", name) + + +def requires_to_requires_dist(requirement: Requirement) -> str: + """Return the version specifier for a requirement in PEP 345/566 fashion.""" + if requirement.url: + return " @ " + requirement.url + + requires_dist: list[str] = [] + for spec in requirement.specifier: + requires_dist.append(spec.operator + spec.version) + + if requires_dist: + return " " + ",".join(sorted(requires_dist)) + else: + return "" + + +def convert_requirements(requirements: list[str]) -> Iterator[str]: + """Yield Requires-Dist: strings for parsed requirements strings.""" + for req in requirements: + parsed_requirement = Requirement(req) + spec = requires_to_requires_dist(parsed_requirement) + extras = ",".join(sorted(safe_extra(e) for e in parsed_requirement.extras)) + if extras: + extras = f"[{extras}]" + + yield safe_name(parsed_requirement.name) + extras + spec + + +def generate_requirements( + extras_require: dict[str | None, list[str]], +) -> Iterator[tuple[str, str]]: + """ + Convert requirements from a setup()-style dictionary to + ('Requires-Dist', 'requirement') and ('Provides-Extra', 'extra') tuples. + + extras_require is a dictionary of {extra: [requirements]} as passed to setup(), + using the empty extra {'': [requirements]} to hold install_requires. + """ + for extra, depends in extras_require.items(): + condition = "" + extra = extra or "" + if ":" in extra: # setuptools extra:condition syntax + extra, condition = extra.split(":", 1) + + extra = safe_extra(extra) + if extra: + yield "Provides-Extra", extra + if condition: + condition = "(" + condition + ") and " + condition += f"extra == '{extra}'" + + if condition: + condition = " ; " + condition + + for new_req in convert_requirements(depends): + canonical_req = str(Requirement(new_req + condition)) + yield "Requires-Dist", canonical_req + + +def pkginfo_to_metadata(egg_info_path: str, pkginfo_path: str) -> Message: + """ + Convert .egg-info directory with PKG-INFO to the Metadata 2.1 format + """ + with open(pkginfo_path, encoding="utf-8") as headers: + pkg_info = Parser().parse(headers) + + pkg_info.replace_header("Metadata-Version", "2.1") + # Those will be regenerated from `requires.txt`. + del pkg_info["Provides-Extra"] + del pkg_info["Requires-Dist"] + requires_path = os.path.join(egg_info_path, "requires.txt") + if os.path.exists(requires_path): + with open(requires_path, encoding="utf-8") as requires_file: + requires = requires_file.read() + + parsed_requirements = sorted(split_sections(requires), key=lambda x: x[0] or "") + for extra, reqs in parsed_requirements: + for key, value in generate_requirements({extra: reqs}): + if (key, value) not in pkg_info.items(): + pkg_info[key] = value + + description = pkg_info["Description"] + if description: + description_lines = pkg_info["Description"].splitlines() + dedented_description = "\n".join( + # if the first line of long_description is blank, + # the first line here will be indented. + ( + description_lines[0].lstrip(), + textwrap.dedent("\n".join(description_lines[1:])), + "\n", + ) + ) + pkg_info.set_payload(dedented_description) + del pkg_info["Description"] + + return pkg_info diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_setuptools_logging.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_setuptools_logging.py new file mode 100644 index 0000000000000000000000000000000000000000..a1a2482ba29ac5290c8f7d7688452ec3faf59332 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/_setuptools_logging.py @@ -0,0 +1,26 @@ +# copied from setuptools.logging, omitting monkeypatching +from __future__ import annotations + +import logging +import sys + + +def _not_warning(record: logging.LogRecord) -> bool: + return record.levelno < logging.WARNING + + +def configure() -> None: + """ + Configure logging to emit warning and above to stderr + and everything else to stdout. This behavior is provided + for compatibility with distutils.log but may change in + the future. + """ + err_handler = logging.StreamHandler() + err_handler.setLevel(logging.WARNING) + out_handler = logging.StreamHandler(sys.stdout) + out_handler.addFilter(_not_warning) + handlers = err_handler, out_handler + logging.basicConfig( + format="{message}", style="{", handlers=handlers, level=logging.DEBUG + ) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/bdist_wheel.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/bdist_wheel.py new file mode 100644 index 0000000000000000000000000000000000000000..24199c246d44a6874ad991c2f3492ca30fc10f27 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/bdist_wheel.py @@ -0,0 +1,26 @@ +from typing import TYPE_CHECKING +from warnings import warn + +warn( + "The 'wheel' package is no longer the canonical location of the 'bdist_wheel' " + "command, and will be removed in a future release. Please update to setuptools " + "v70.1 or later which contains an integrated version of this command.", + FutureWarning, + stacklevel=1, +) + +if TYPE_CHECKING: + from ._bdist_wheel import bdist_wheel as bdist_wheel +else: + try: + # Better integration/compatibility with setuptools: + # in the case new fixes or PEPs are implemented in setuptools + # there is no need to backport them to the deprecated code base. + # This is useful in the case of old packages in the ecosystem + # that are still used but have low maintenance. + from setuptools.command.bdist_wheel import bdist_wheel + except ImportError: + # Only used in the case of old setuptools versions. + # If the user wants to get the latest fixes/PEPs, + # they are encouraged to address the deprecation warning. + from ._bdist_wheel import bdist_wheel as bdist_wheel diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/macosx_libfile.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/macosx_libfile.py new file mode 100644 index 0000000000000000000000000000000000000000..06e51af299d0fe15f7618f803cfb8ff52d199cf7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/macosx_libfile.py @@ -0,0 +1,486 @@ +""" +IMPORTANT: DO NOT IMPORT THIS MODULE DIRECTLY. +THIS IS ONLY KEPT IN PLACE FOR BACKWARDS COMPATIBILITY WITH +setuptools.command.bdist_wheel. + +This module contains function to analyse dynamic library +headers to extract system information + +Currently only for MacOSX + +Library file on macosx system starts with Mach-O or Fat field. +This can be distinguish by first 32 bites and it is called magic number. +Proper value of magic number is with suffix _MAGIC. Suffix _CIGAM means +reversed bytes order. +Both fields can occur in two types: 32 and 64 bytes. + +FAT field inform that this library contains few version of library +(typically for different types version). It contains +information where Mach-O headers starts. + +Each section started with Mach-O header contains one library +(So if file starts with this field it contains only one version). + +After filed Mach-O there are section fields. +Each of them starts with two fields: +cmd - magic number for this command +cmdsize - total size occupied by this section information. + +In this case only sections LC_VERSION_MIN_MACOSX (for macosx 10.13 and earlier) +and LC_BUILD_VERSION (for macosx 10.14 and newer) are interesting, +because them contains information about minimal system version. + +Important remarks: +- For fat files this implementation looks for maximum number version. + It not check if it is 32 or 64 and do not compare it with currently built package. + So it is possible to false report higher version that needed. +- All structures signatures are taken form macosx header files. +- I think that binary format will be more stable than `otool` output. + and if apple introduce some changes both implementation will need to be updated. +- The system compile will set the deployment target no lower than + 11.0 for arm64 builds. For "Universal 2" builds use the x86_64 deployment + target when the arm64 target is 11.0. +""" + +from __future__ import annotations + +import ctypes +import os +import sys +from io import BufferedIOBase +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from typing import Union + + StrPath = Union[str, os.PathLike[str]] + +"""here the needed const and struct from mach-o header files""" + +FAT_MAGIC = 0xCAFEBABE +FAT_CIGAM = 0xBEBAFECA +FAT_MAGIC_64 = 0xCAFEBABF +FAT_CIGAM_64 = 0xBFBAFECA +MH_MAGIC = 0xFEEDFACE +MH_CIGAM = 0xCEFAEDFE +MH_MAGIC_64 = 0xFEEDFACF +MH_CIGAM_64 = 0xCFFAEDFE + +LC_VERSION_MIN_MACOSX = 0x24 +LC_BUILD_VERSION = 0x32 + +CPU_TYPE_ARM64 = 0x0100000C + +mach_header_fields = [ + ("magic", ctypes.c_uint32), + ("cputype", ctypes.c_int), + ("cpusubtype", ctypes.c_int), + ("filetype", ctypes.c_uint32), + ("ncmds", ctypes.c_uint32), + ("sizeofcmds", ctypes.c_uint32), + ("flags", ctypes.c_uint32), +] +""" +struct mach_header { + uint32_t magic; /* mach magic number identifier */ + cpu_type_t cputype; /* cpu specifier */ + cpu_subtype_t cpusubtype; /* machine specifier */ + uint32_t filetype; /* type of file */ + uint32_t ncmds; /* number of load commands */ + uint32_t sizeofcmds; /* the size of all the load commands */ + uint32_t flags; /* flags */ +}; +typedef integer_t cpu_type_t; +typedef integer_t cpu_subtype_t; +""" + +mach_header_fields_64 = mach_header_fields + [("reserved", ctypes.c_uint32)] +""" +struct mach_header_64 { + uint32_t magic; /* mach magic number identifier */ + cpu_type_t cputype; /* cpu specifier */ + cpu_subtype_t cpusubtype; /* machine specifier */ + uint32_t filetype; /* type of file */ + uint32_t ncmds; /* number of load commands */ + uint32_t sizeofcmds; /* the size of all the load commands */ + uint32_t flags; /* flags */ + uint32_t reserved; /* reserved */ +}; +""" + +fat_header_fields = [("magic", ctypes.c_uint32), ("nfat_arch", ctypes.c_uint32)] +""" +struct fat_header { + uint32_t magic; /* FAT_MAGIC or FAT_MAGIC_64 */ + uint32_t nfat_arch; /* number of structs that follow */ +}; +""" + +fat_arch_fields = [ + ("cputype", ctypes.c_int), + ("cpusubtype", ctypes.c_int), + ("offset", ctypes.c_uint32), + ("size", ctypes.c_uint32), + ("align", ctypes.c_uint32), +] +""" +struct fat_arch { + cpu_type_t cputype; /* cpu specifier (int) */ + cpu_subtype_t cpusubtype; /* machine specifier (int) */ + uint32_t offset; /* file offset to this object file */ + uint32_t size; /* size of this object file */ + uint32_t align; /* alignment as a power of 2 */ +}; +""" + +fat_arch_64_fields = [ + ("cputype", ctypes.c_int), + ("cpusubtype", ctypes.c_int), + ("offset", ctypes.c_uint64), + ("size", ctypes.c_uint64), + ("align", ctypes.c_uint32), + ("reserved", ctypes.c_uint32), +] +""" +struct fat_arch_64 { + cpu_type_t cputype; /* cpu specifier (int) */ + cpu_subtype_t cpusubtype; /* machine specifier (int) */ + uint64_t offset; /* file offset to this object file */ + uint64_t size; /* size of this object file */ + uint32_t align; /* alignment as a power of 2 */ + uint32_t reserved; /* reserved */ +}; +""" + +segment_base_fields = [("cmd", ctypes.c_uint32), ("cmdsize", ctypes.c_uint32)] +"""base for reading segment info""" + +segment_command_fields = [ + ("cmd", ctypes.c_uint32), + ("cmdsize", ctypes.c_uint32), + ("segname", ctypes.c_char * 16), + ("vmaddr", ctypes.c_uint32), + ("vmsize", ctypes.c_uint32), + ("fileoff", ctypes.c_uint32), + ("filesize", ctypes.c_uint32), + ("maxprot", ctypes.c_int), + ("initprot", ctypes.c_int), + ("nsects", ctypes.c_uint32), + ("flags", ctypes.c_uint32), +] +""" +struct segment_command { /* for 32-bit architectures */ + uint32_t cmd; /* LC_SEGMENT */ + uint32_t cmdsize; /* includes sizeof section structs */ + char segname[16]; /* segment name */ + uint32_t vmaddr; /* memory address of this segment */ + uint32_t vmsize; /* memory size of this segment */ + uint32_t fileoff; /* file offset of this segment */ + uint32_t filesize; /* amount to map from the file */ + vm_prot_t maxprot; /* maximum VM protection */ + vm_prot_t initprot; /* initial VM protection */ + uint32_t nsects; /* number of sections in segment */ + uint32_t flags; /* flags */ +}; +typedef int vm_prot_t; +""" + +segment_command_fields_64 = [ + ("cmd", ctypes.c_uint32), + ("cmdsize", ctypes.c_uint32), + ("segname", ctypes.c_char * 16), + ("vmaddr", ctypes.c_uint64), + ("vmsize", ctypes.c_uint64), + ("fileoff", ctypes.c_uint64), + ("filesize", ctypes.c_uint64), + ("maxprot", ctypes.c_int), + ("initprot", ctypes.c_int), + ("nsects", ctypes.c_uint32), + ("flags", ctypes.c_uint32), +] +""" +struct segment_command_64 { /* for 64-bit architectures */ + uint32_t cmd; /* LC_SEGMENT_64 */ + uint32_t cmdsize; /* includes sizeof section_64 structs */ + char segname[16]; /* segment name */ + uint64_t vmaddr; /* memory address of this segment */ + uint64_t vmsize; /* memory size of this segment */ + uint64_t fileoff; /* file offset of this segment */ + uint64_t filesize; /* amount to map from the file */ + vm_prot_t maxprot; /* maximum VM protection */ + vm_prot_t initprot; /* initial VM protection */ + uint32_t nsects; /* number of sections in segment */ + uint32_t flags; /* flags */ +}; +""" + +version_min_command_fields = segment_base_fields + [ + ("version", ctypes.c_uint32), + ("sdk", ctypes.c_uint32), +] +""" +struct version_min_command { + uint32_t cmd; /* LC_VERSION_MIN_MACOSX or + LC_VERSION_MIN_IPHONEOS or + LC_VERSION_MIN_WATCHOS or + LC_VERSION_MIN_TVOS */ + uint32_t cmdsize; /* sizeof(struct min_version_command) */ + uint32_t version; /* X.Y.Z is encoded in nibbles xxxx.yy.zz */ + uint32_t sdk; /* X.Y.Z is encoded in nibbles xxxx.yy.zz */ +}; +""" + +build_version_command_fields = segment_base_fields + [ + ("platform", ctypes.c_uint32), + ("minos", ctypes.c_uint32), + ("sdk", ctypes.c_uint32), + ("ntools", ctypes.c_uint32), +] +""" +struct build_version_command { + uint32_t cmd; /* LC_BUILD_VERSION */ + uint32_t cmdsize; /* sizeof(struct build_version_command) plus */ + /* ntools * sizeof(struct build_tool_version) */ + uint32_t platform; /* platform */ + uint32_t minos; /* X.Y.Z is encoded in nibbles xxxx.yy.zz */ + uint32_t sdk; /* X.Y.Z is encoded in nibbles xxxx.yy.zz */ + uint32_t ntools; /* number of tool entries following this */ +}; +""" + + +def swap32(x: int) -> int: + return ( + ((x << 24) & 0xFF000000) + | ((x << 8) & 0x00FF0000) + | ((x >> 8) & 0x0000FF00) + | ((x >> 24) & 0x000000FF) + ) + + +def get_base_class_and_magic_number( + lib_file: BufferedIOBase, + seek: int | None = None, +) -> tuple[type[ctypes.Structure], int]: + if seek is None: + seek = lib_file.tell() + else: + lib_file.seek(seek) + magic_number = ctypes.c_uint32.from_buffer_copy( + lib_file.read(ctypes.sizeof(ctypes.c_uint32)) + ).value + + # Handle wrong byte order + if magic_number in [FAT_CIGAM, FAT_CIGAM_64, MH_CIGAM, MH_CIGAM_64]: + if sys.byteorder == "little": + BaseClass = ctypes.BigEndianStructure + else: + BaseClass = ctypes.LittleEndianStructure + + magic_number = swap32(magic_number) + else: + BaseClass = ctypes.Structure + + lib_file.seek(seek) + return BaseClass, magic_number + + +def read_data(struct_class: type[ctypes.Structure], lib_file: BufferedIOBase): + return struct_class.from_buffer_copy(lib_file.read(ctypes.sizeof(struct_class))) + + +def extract_macosx_min_system_version(path_to_lib: str): + with open(path_to_lib, "rb") as lib_file: + BaseClass, magic_number = get_base_class_and_magic_number(lib_file, 0) + if magic_number not in [FAT_MAGIC, FAT_MAGIC_64, MH_MAGIC, MH_MAGIC_64]: + return + + if magic_number in [FAT_MAGIC, FAT_CIGAM_64]: + + class FatHeader(BaseClass): + _fields_ = fat_header_fields + + fat_header = read_data(FatHeader, lib_file) + if magic_number == FAT_MAGIC: + + class FatArch(BaseClass): + _fields_ = fat_arch_fields + + else: + + class FatArch(BaseClass): + _fields_ = fat_arch_64_fields + + fat_arch_list = [ + read_data(FatArch, lib_file) for _ in range(fat_header.nfat_arch) + ] + + versions_list: list[tuple[int, int, int]] = [] + for el in fat_arch_list: + try: + version = read_mach_header(lib_file, el.offset) + if version is not None: + if el.cputype == CPU_TYPE_ARM64 and len(fat_arch_list) != 1: + # Xcode will not set the deployment target below 11.0.0 + # for the arm64 architecture. Ignore the arm64 deployment + # in fat binaries when the target is 11.0.0, that way + # the other architectures can select a lower deployment + # target. + # This is safe because there is no arm64 variant for + # macOS 10.15 or earlier. + if version == (11, 0, 0): + continue + versions_list.append(version) + except ValueError: + pass + + if len(versions_list) > 0: + return max(versions_list) + else: + return None + + else: + try: + return read_mach_header(lib_file, 0) + except ValueError: + """when some error during read library files""" + return None + + +def read_mach_header( + lib_file: BufferedIOBase, + seek: int | None = None, +) -> tuple[int, int, int] | None: + """ + This function parses a Mach-O header and extracts + information about the minimal macOS version. + + :param lib_file: reference to opened library file with pointer + """ + base_class, magic_number = get_base_class_and_magic_number(lib_file, seek) + arch = "32" if magic_number == MH_MAGIC else "64" + + class SegmentBase(base_class): + _fields_ = segment_base_fields + + if arch == "32": + + class MachHeader(base_class): + _fields_ = mach_header_fields + + else: + + class MachHeader(base_class): + _fields_ = mach_header_fields_64 + + mach_header = read_data(MachHeader, lib_file) + for _i in range(mach_header.ncmds): + pos = lib_file.tell() + segment_base = read_data(SegmentBase, lib_file) + lib_file.seek(pos) + if segment_base.cmd == LC_VERSION_MIN_MACOSX: + + class VersionMinCommand(base_class): + _fields_ = version_min_command_fields + + version_info = read_data(VersionMinCommand, lib_file) + return parse_version(version_info.version) + elif segment_base.cmd == LC_BUILD_VERSION: + + class VersionBuild(base_class): + _fields_ = build_version_command_fields + + version_info = read_data(VersionBuild, lib_file) + return parse_version(version_info.minos) + else: + lib_file.seek(pos + segment_base.cmdsize) + continue + + +def parse_version(version: int) -> tuple[int, int, int]: + x = (version & 0xFFFF0000) >> 16 + y = (version & 0x0000FF00) >> 8 + z = version & 0x000000FF + return x, y, z + + +def calculate_macosx_platform_tag(archive_root: StrPath, platform_tag: str) -> str: + """ + Calculate proper macosx platform tag basing on files which are included to wheel + + Example platform tag `macosx-10.14-x86_64` + """ + prefix, base_version, suffix = platform_tag.split("-") + base_version = tuple(int(x) for x in base_version.split(".")) + base_version = base_version[:2] + if base_version[0] > 10: + base_version = (base_version[0], 0) + assert len(base_version) == 2 + if "MACOSX_DEPLOYMENT_TARGET" in os.environ: + deploy_target = tuple( + int(x) for x in os.environ["MACOSX_DEPLOYMENT_TARGET"].split(".") + ) + deploy_target = deploy_target[:2] + if deploy_target[0] > 10: + deploy_target = (deploy_target[0], 0) + if deploy_target < base_version: + sys.stderr.write( + "[WARNING] MACOSX_DEPLOYMENT_TARGET is set to a lower value ({}) than " + "the version on which the Python interpreter was compiled ({}), and " + "will be ignored.\n".format( + ".".join(str(x) for x in deploy_target), + ".".join(str(x) for x in base_version), + ) + ) + else: + base_version = deploy_target + + assert len(base_version) == 2 + start_version = base_version + versions_dict: dict[str, tuple[int, int]] = {} + for dirpath, _dirnames, filenames in os.walk(archive_root): + for filename in filenames: + if filename.endswith(".dylib") or filename.endswith(".so"): + lib_path = os.path.join(dirpath, filename) + min_ver = extract_macosx_min_system_version(lib_path) + if min_ver is not None: + min_ver = min_ver[0:2] + if min_ver[0] > 10: + min_ver = (min_ver[0], 0) + versions_dict[lib_path] = min_ver + + if len(versions_dict) > 0: + base_version = max(base_version, max(versions_dict.values())) + + # macosx platform tag do not support minor bugfix release + fin_base_version = "_".join([str(x) for x in base_version]) + if start_version < base_version: + problematic_files = [k for k, v in versions_dict.items() if v > start_version] + problematic_files = "\n".join(problematic_files) + if len(problematic_files) == 1: + files_form = "this file" + else: + files_form = "these files" + error_message = ( + "[WARNING] This wheel needs a higher macOS version than {} " + "To silence this warning, set MACOSX_DEPLOYMENT_TARGET to at least " + + fin_base_version + + " or recreate " + + files_form + + " with lower " + "MACOSX_DEPLOYMENT_TARGET: \n" + problematic_files + ) + + if "MACOSX_DEPLOYMENT_TARGET" in os.environ: + error_message = error_message.format( + "is set in MACOSX_DEPLOYMENT_TARGET variable." + ) + else: + error_message = error_message.format( + "the version your Python interpreter is compiled against." + ) + + sys.stderr.write(error_message) + + platform_tag = prefix + "_" + fin_base_version + "_" + suffix + return platform_tag diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/metadata.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/metadata.py new file mode 100644 index 0000000000000000000000000000000000000000..e27900a2565c859ff32b0e4bf497c2548e4912de --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/metadata.py @@ -0,0 +1,17 @@ +from warnings import warn + +from ._metadata import convert_requirements as convert_requirements +from ._metadata import generate_requirements as generate_requirements +from ._metadata import pkginfo_to_metadata as pkginfo_to_metadata +from ._metadata import requires_to_requires_dist as requires_to_requires_dist +from ._metadata import safe_extra as safe_extra +from ._metadata import safe_name as safe_name +from ._metadata import split_sections as split_sections + +warn( + f"The {__name__!r} package has been made private and should no longer be imported. " + f"Please either copy the code or find an alternative library to import it from, as " + f"this warning will be removed in a future version of 'wheel'.", + DeprecationWarning, + stacklevel=2, +) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/wheelfile.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/wheelfile.py new file mode 100644 index 0000000000000000000000000000000000000000..bb96a2ac706b8504c7c2556df20fe35eea02a083 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/wheel/wheelfile.py @@ -0,0 +1,252 @@ +from __future__ import annotations + +__all__ = ["WHEEL_INFO_RE", "WheelFile", "WheelError"] + +import base64 +import csv +import hashlib +import logging +import os.path +import re +import stat +import time +from io import StringIO, TextIOWrapper +from typing import IO, TYPE_CHECKING, Literal +from zipfile import ZIP_DEFLATED, ZipFile, ZipInfo + +if TYPE_CHECKING: + from _typeshed import SizedBuffer, StrPath + + +# Non-greedy matching of an optional build number may be too clever (more +# invalid wheel filenames will match). Separate regex for .dist-info? +WHEEL_INFO_RE = re.compile( + r"""^(?P(?P[^\s-]+?)-(?P[^\s-]+?))(-(?P\d[^\s-]*))? + -(?P[^\s-]+?)-(?P[^\s-]+?)-(?P\S+)\.whl$""", + re.VERBOSE, +) +MINIMUM_TIMESTAMP = 315532800 # 1980-01-01 00:00:00 UTC + +log = logging.getLogger("wheel") + + +class WheelError(Exception): + pass + + +def urlsafe_b64encode(data: bytes) -> bytes: + """urlsafe_b64encode without padding""" + return base64.urlsafe_b64encode(data).rstrip(b"=") + + +def urlsafe_b64decode(data: bytes) -> bytes: + """urlsafe_b64decode without padding""" + pad = b"=" * (4 - (len(data) & 3)) + return base64.urlsafe_b64decode(data + pad) + + +def get_zipinfo_datetime( + timestamp: float | None = None, +) -> tuple[int, int, int, int, int]: + # Some applications need reproducible .whl files, but they can't do this without + # forcing the timestamp of the individual ZipInfo objects. See issue #143. + timestamp = int(os.environ.get("SOURCE_DATE_EPOCH", timestamp or time.time())) + timestamp = max(timestamp, MINIMUM_TIMESTAMP) + return time.gmtime(timestamp)[0:6] + + +class WheelFile(ZipFile): + """A ZipFile derivative class that also reads SHA-256 hashes from + .dist-info/RECORD and checks any read files against those. + """ + + _default_algorithm = hashlib.sha256 + + def __init__( + self, + file: StrPath, + mode: Literal["r", "w", "x", "a"] = "r", + compression: int = ZIP_DEFLATED, + ): + basename = os.path.basename(file) + self.parsed_filename = WHEEL_INFO_RE.match(basename) + if not basename.endswith(".whl") or self.parsed_filename is None: + raise WheelError(f"Bad wheel filename {basename!r}") + + ZipFile.__init__(self, file, mode, compression=compression, allowZip64=True) + + self.dist_info_path = "{}.dist-info".format( + self.parsed_filename.group("namever") + ) + self.record_path = self.dist_info_path + "/RECORD" + self._file_hashes: dict[str, tuple[None, None] | tuple[int, bytes]] = {} + self._file_sizes = {} + if mode == "r": + # The .dist-info directory inside the wheel may use normalized + # (lowercase) naming even when the filename does not. Resolve the + # actual path case-insensitively. + if self.record_path not in self.namelist(): + lowered = self.dist_info_path.lower() + "/record" + for name in self.namelist(): + if name.lower() == lowered: + self.dist_info_path = name.rsplit("/RECORD", 1)[0] + self.record_path = name + break + + # Ignore RECORD and any embedded wheel signatures + self._file_hashes[self.record_path] = None, None + self._file_hashes[self.record_path + ".jws"] = None, None + self._file_hashes[self.record_path + ".p7s"] = None, None + + # Fill in the expected hashes by reading them from RECORD + try: + record = self.open(self.record_path) + except KeyError: + raise WheelError(f"Missing {self.record_path} file") from None + + with record: + for line in csv.reader( + TextIOWrapper(record, newline="", encoding="utf-8") + ): + path, hash_sum, size = line + if not hash_sum: + continue + + algorithm, hash_sum = hash_sum.split("=") + try: + hashlib.new(algorithm) + except ValueError: + raise WheelError( + f"Unsupported hash algorithm: {algorithm}" + ) from None + + if algorithm.lower() in {"md5", "sha1"}: + raise WheelError( + f"Weak hash algorithm ({algorithm}) is not permitted by " + f"PEP 427" + ) + + self._file_hashes[path] = ( + algorithm, + urlsafe_b64decode(hash_sum.encode("ascii")), + ) + + def open( + self, + name_or_info: str | ZipInfo, + mode: Literal["r", "w"] = "r", + pwd: bytes | None = None, + ) -> IO[bytes]: + def _update_crc(newdata: bytes) -> None: + eof = ef._eof + update_crc_orig(newdata) + running_hash.update(newdata) + if eof and running_hash.digest() != expected_hash: + raise WheelError(f"Hash mismatch for file '{ef_name}'") + + ef_name = ( + name_or_info.filename if isinstance(name_or_info, ZipInfo) else name_or_info + ) + if ( + mode == "r" + and not ef_name.endswith("/") + and ef_name not in self._file_hashes + ): + raise WheelError(f"No hash found for file '{ef_name}'") + + ef = ZipFile.open(self, name_or_info, mode, pwd) + if mode == "r" and not ef_name.endswith("/"): + algorithm, expected_hash = self._file_hashes[ef_name] + if expected_hash is not None: + # Monkey patch the _update_crc method to also check for the hash from + # RECORD + running_hash = hashlib.new(algorithm) + update_crc_orig, ef._update_crc = ef._update_crc, _update_crc + + return ef + + def write_files(self, base_dir: str) -> None: + log.info("creating %r and adding %r to it", self.filename, base_dir) + deferred: list[tuple[str, str]] = [] + for root, dirnames, filenames in os.walk(base_dir): + # Sort the directory names so that `os.walk` will walk them in a + # defined order on the next iteration. + dirnames.sort() + for name in sorted(filenames): + path = os.path.normpath(os.path.join(root, name)) + if os.path.isfile(path): + arcname = os.path.relpath(path, base_dir).replace(os.path.sep, "/") + if arcname == self.record_path: + pass + elif root.endswith(".dist-info"): + deferred.append((path, arcname)) + else: + self.write(path, arcname) + + deferred.sort() + for path, arcname in deferred: + self.write(path, arcname) + + def write( + self, + filename: str, + arcname: str | None = None, + compress_type: int | None = None, + ) -> None: + with open(filename, "rb") as f: + st = os.fstat(f.fileno()) + data = f.read() + + zinfo = ZipInfo( + arcname or filename, date_time=get_zipinfo_datetime(st.st_mtime) + ) + zinfo.external_attr = (stat.S_IMODE(st.st_mode) | stat.S_IFMT(st.st_mode)) << 16 + zinfo.compress_type = compress_type or self.compression + self.writestr(zinfo, data, compress_type) + + def writestr( + self, + zinfo_or_arcname: str | ZipInfo, + data: SizedBuffer | str, + compress_type: int | None = None, + ) -> None: + if isinstance(zinfo_or_arcname, str): + zinfo_or_arcname = ZipInfo( + zinfo_or_arcname, date_time=get_zipinfo_datetime() + ) + zinfo_or_arcname.compress_type = self.compression + zinfo_or_arcname.external_attr = (0o664 | stat.S_IFREG) << 16 + + if isinstance(data, str): + data = data.encode("utf-8") + + ZipFile.writestr(self, zinfo_or_arcname, data, compress_type) + fname = ( + zinfo_or_arcname.filename + if isinstance(zinfo_or_arcname, ZipInfo) + else zinfo_or_arcname + ) + log.info("adding %r", fname) + if fname != self.record_path: + hash_ = self._default_algorithm(data) + self._file_hashes[fname] = ( + hash_.name, + urlsafe_b64encode(hash_.digest()).decode("ascii"), + ) + self._file_sizes[fname] = len(data) + + def close(self) -> None: + # Write RECORD + if self.fp is not None and self.mode == "w" and self._file_hashes: + data = StringIO() + writer = csv.writer(data, delimiter=",", quotechar='"', lineterminator="\n") + writer.writerows( + ( + (fname, algorithm + "=" + hash_, self._file_sizes[fname]) + for fname, (algorithm, hash_) in self._file_hashes.items() + ) + ) + writer.writerow((format(self.record_path), "", "")) + self.writestr(self.record_path, data.getvalue()) + + ZipFile.close(self) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d58f0891737def7f38e5d86dde2dbf9be0c13dce --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__init__.py @@ -0,0 +1,390 @@ + +from .error import * + +from .tokens import * +from .events import * +from .nodes import * + +from .loader import * +from .dumper import * + +__version__ = '6.0.3' +try: + from .cyaml import * + __with_libyaml__ = True +except ImportError: + __with_libyaml__ = False + +import io + +#------------------------------------------------------------------------------ +# XXX "Warnings control" is now deprecated. Leaving in the API function to not +# break code that uses it. +#------------------------------------------------------------------------------ +def warnings(settings=None): + if settings is None: + return {} + +#------------------------------------------------------------------------------ +def scan(stream, Loader=Loader): + """ + Scan a YAML stream and produce scanning tokens. + """ + loader = Loader(stream) + try: + while loader.check_token(): + yield loader.get_token() + finally: + loader.dispose() + +def parse(stream, Loader=Loader): + """ + Parse a YAML stream and produce parsing events. + """ + loader = Loader(stream) + try: + while loader.check_event(): + yield loader.get_event() + finally: + loader.dispose() + +def compose(stream, Loader=Loader): + """ + Parse the first YAML document in a stream + and produce the corresponding representation tree. + """ + loader = Loader(stream) + try: + return loader.get_single_node() + finally: + loader.dispose() + +def compose_all(stream, Loader=Loader): + """ + Parse all YAML documents in a stream + and produce corresponding representation trees. + """ + loader = Loader(stream) + try: + while loader.check_node(): + yield loader.get_node() + finally: + loader.dispose() + +def load(stream, Loader): + """ + Parse the first YAML document in a stream + and produce the corresponding Python object. + """ + loader = Loader(stream) + try: + return loader.get_single_data() + finally: + loader.dispose() + +def load_all(stream, Loader): + """ + Parse all YAML documents in a stream + and produce corresponding Python objects. + """ + loader = Loader(stream) + try: + while loader.check_data(): + yield loader.get_data() + finally: + loader.dispose() + +def full_load(stream): + """ + Parse the first YAML document in a stream + and produce the corresponding Python object. + + Resolve all tags except those known to be + unsafe on untrusted input. + """ + return load(stream, FullLoader) + +def full_load_all(stream): + """ + Parse all YAML documents in a stream + and produce corresponding Python objects. + + Resolve all tags except those known to be + unsafe on untrusted input. + """ + return load_all(stream, FullLoader) + +def safe_load(stream): + """ + Parse the first YAML document in a stream + and produce the corresponding Python object. + + Resolve only basic YAML tags. This is known + to be safe for untrusted input. + """ + return load(stream, SafeLoader) + +def safe_load_all(stream): + """ + Parse all YAML documents in a stream + and produce corresponding Python objects. + + Resolve only basic YAML tags. This is known + to be safe for untrusted input. + """ + return load_all(stream, SafeLoader) + +def unsafe_load(stream): + """ + Parse the first YAML document in a stream + and produce the corresponding Python object. + + Resolve all tags, even those known to be + unsafe on untrusted input. + """ + return load(stream, UnsafeLoader) + +def unsafe_load_all(stream): + """ + Parse all YAML documents in a stream + and produce corresponding Python objects. + + Resolve all tags, even those known to be + unsafe on untrusted input. + """ + return load_all(stream, UnsafeLoader) + +def emit(events, stream=None, Dumper=Dumper, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None): + """ + Emit YAML parsing events into a stream. + If stream is None, return the produced string instead. + """ + getvalue = None + if stream is None: + stream = io.StringIO() + getvalue = stream.getvalue + dumper = Dumper(stream, canonical=canonical, indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break) + try: + for event in events: + dumper.emit(event) + finally: + dumper.dispose() + if getvalue: + return getvalue() + +def serialize_all(nodes, stream=None, Dumper=Dumper, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None): + """ + Serialize a sequence of representation trees into a YAML stream. + If stream is None, return the produced string instead. + """ + getvalue = None + if stream is None: + if encoding is None: + stream = io.StringIO() + else: + stream = io.BytesIO() + getvalue = stream.getvalue + dumper = Dumper(stream, canonical=canonical, indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break, + encoding=encoding, version=version, tags=tags, + explicit_start=explicit_start, explicit_end=explicit_end) + try: + dumper.open() + for node in nodes: + dumper.serialize(node) + dumper.close() + finally: + dumper.dispose() + if getvalue: + return getvalue() + +def serialize(node, stream=None, Dumper=Dumper, **kwds): + """ + Serialize a representation tree into a YAML stream. + If stream is None, return the produced string instead. + """ + return serialize_all([node], stream, Dumper=Dumper, **kwds) + +def dump_all(documents, stream=None, Dumper=Dumper, + default_style=None, default_flow_style=False, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None, sort_keys=True): + """ + Serialize a sequence of Python objects into a YAML stream. + If stream is None, return the produced string instead. + """ + getvalue = None + if stream is None: + if encoding is None: + stream = io.StringIO() + else: + stream = io.BytesIO() + getvalue = stream.getvalue + dumper = Dumper(stream, default_style=default_style, + default_flow_style=default_flow_style, + canonical=canonical, indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break, + encoding=encoding, version=version, tags=tags, + explicit_start=explicit_start, explicit_end=explicit_end, sort_keys=sort_keys) + try: + dumper.open() + for data in documents: + dumper.represent(data) + dumper.close() + finally: + dumper.dispose() + if getvalue: + return getvalue() + +def dump(data, stream=None, Dumper=Dumper, **kwds): + """ + Serialize a Python object into a YAML stream. + If stream is None, return the produced string instead. + """ + return dump_all([data], stream, Dumper=Dumper, **kwds) + +def safe_dump_all(documents, stream=None, **kwds): + """ + Serialize a sequence of Python objects into a YAML stream. + Produce only basic YAML tags. + If stream is None, return the produced string instead. + """ + return dump_all(documents, stream, Dumper=SafeDumper, **kwds) + +def safe_dump(data, stream=None, **kwds): + """ + Serialize a Python object into a YAML stream. + Produce only basic YAML tags. + If stream is None, return the produced string instead. + """ + return dump_all([data], stream, Dumper=SafeDumper, **kwds) + +def add_implicit_resolver(tag, regexp, first=None, + Loader=None, Dumper=Dumper): + """ + Add an implicit scalar detector. + If an implicit scalar value matches the given regexp, + the corresponding tag is assigned to the scalar. + first is a sequence of possible initial characters or None. + """ + if Loader is None: + loader.Loader.add_implicit_resolver(tag, regexp, first) + loader.FullLoader.add_implicit_resolver(tag, regexp, first) + loader.UnsafeLoader.add_implicit_resolver(tag, regexp, first) + else: + Loader.add_implicit_resolver(tag, regexp, first) + Dumper.add_implicit_resolver(tag, regexp, first) + +def add_path_resolver(tag, path, kind=None, Loader=None, Dumper=Dumper): + """ + Add a path based resolver for the given tag. + A path is a list of keys that forms a path + to a node in the representation tree. + Keys can be string values, integers, or None. + """ + if Loader is None: + loader.Loader.add_path_resolver(tag, path, kind) + loader.FullLoader.add_path_resolver(tag, path, kind) + loader.UnsafeLoader.add_path_resolver(tag, path, kind) + else: + Loader.add_path_resolver(tag, path, kind) + Dumper.add_path_resolver(tag, path, kind) + +def add_constructor(tag, constructor, Loader=None): + """ + Add a constructor for the given tag. + Constructor is a function that accepts a Loader instance + and a node object and produces the corresponding Python object. + """ + if Loader is None: + loader.Loader.add_constructor(tag, constructor) + loader.FullLoader.add_constructor(tag, constructor) + loader.UnsafeLoader.add_constructor(tag, constructor) + else: + Loader.add_constructor(tag, constructor) + +def add_multi_constructor(tag_prefix, multi_constructor, Loader=None): + """ + Add a multi-constructor for the given tag prefix. + Multi-constructor is called for a node if its tag starts with tag_prefix. + Multi-constructor accepts a Loader instance, a tag suffix, + and a node object and produces the corresponding Python object. + """ + if Loader is None: + loader.Loader.add_multi_constructor(tag_prefix, multi_constructor) + loader.FullLoader.add_multi_constructor(tag_prefix, multi_constructor) + loader.UnsafeLoader.add_multi_constructor(tag_prefix, multi_constructor) + else: + Loader.add_multi_constructor(tag_prefix, multi_constructor) + +def add_representer(data_type, representer, Dumper=Dumper): + """ + Add a representer for the given type. + Representer is a function accepting a Dumper instance + and an instance of the given data type + and producing the corresponding representation node. + """ + Dumper.add_representer(data_type, representer) + +def add_multi_representer(data_type, multi_representer, Dumper=Dumper): + """ + Add a representer for the given type. + Multi-representer is a function accepting a Dumper instance + and an instance of the given data type or subtype + and producing the corresponding representation node. + """ + Dumper.add_multi_representer(data_type, multi_representer) + +class YAMLObjectMetaclass(type): + """ + The metaclass for YAMLObject. + """ + def __init__(cls, name, bases, kwds): + super(YAMLObjectMetaclass, cls).__init__(name, bases, kwds) + if 'yaml_tag' in kwds and kwds['yaml_tag'] is not None: + if isinstance(cls.yaml_loader, list): + for loader in cls.yaml_loader: + loader.add_constructor(cls.yaml_tag, cls.from_yaml) + else: + cls.yaml_loader.add_constructor(cls.yaml_tag, cls.from_yaml) + + cls.yaml_dumper.add_representer(cls, cls.to_yaml) + +class YAMLObject(metaclass=YAMLObjectMetaclass): + """ + An object that can dump itself to a YAML stream + and load itself from a YAML stream. + """ + + __slots__ = () # no direct instantiation, so allow immutable subclasses + + yaml_loader = [Loader, FullLoader, UnsafeLoader] + yaml_dumper = Dumper + + yaml_tag = None + yaml_flow_style = None + + @classmethod + def from_yaml(cls, loader, node): + """ + Convert a representation node to a Python object. + """ + return loader.construct_yaml_object(node, cls) + + @classmethod + def to_yaml(cls, dumper, data): + """ + Convert a Python object to a representation node. + """ + return dumper.represent_yaml_object(cls.yaml_tag, data, cls, + flow_style=cls.yaml_flow_style) + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc03193c1870727f8ecaad103743b2298e915497 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/composer.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/composer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..83dceb9ec137bea71ef43669136620cb064dd8d3 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/composer.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/constructor.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/constructor.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a4d89ce55382249d53f78dba848309e99b8865c1 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/constructor.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/cyaml.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/cyaml.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a2bb8f27205e093fee10da899c32904111817c15 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/cyaml.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/dumper.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/dumper.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d2eaef4107b162419b8a06e376fa7fd6e7def3ad Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/dumper.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/emitter.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/emitter.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..89327ac206bf30770587b7e1ffd8615851acb35e Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/emitter.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/error.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/error.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aee1d6502bd2cae7fa8d45bb608700dc27cdb828 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/error.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/events.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/events.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1a95853e8497ece6cc740a264111236b1ebd00dc Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/events.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/loader.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/loader.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3d72324eb2510e6586156f680200fed47748b027 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/loader.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/nodes.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/nodes.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7fbba9c4ad9f8da36324ba93fe7d19b33d63c95 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/nodes.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/parser.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/parser.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a395059ef618826807dbdc501a57fa84ef492760 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/parser.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/reader.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/reader.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a65ad07df12c813e6ecf45cfcbb8110ca755c6b0 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/reader.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/representer.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/representer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3d04bff6a6a42d7480d9798f9747001f513d5f1e Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/representer.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/resolver.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/resolver.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0fad1ec607e0b83ceaa5ff499125b33bd859f187 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/resolver.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/scanner.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/scanner.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c699e8427c7e26a1c4626db0b06e2ff50ebdcb1c Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/scanner.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/serializer.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/serializer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1c02022bbb3882f2b811478548c61784abb9680c Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/serializer.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/tokens.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/tokens.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a17f514ed9714190e2a7d207dfe6703ca1ff8381 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/__pycache__/tokens.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/_yaml.cpython-311-x86_64-linux-gnu.so b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/_yaml.cpython-311-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..6d50c98f35246af731971776e5886e776333785a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/_yaml.cpython-311-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aa9bb0d7b261b8266ababd9e19f5bf2f505d9a84ba360ce16502297e8a033765 +size 2650176 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/composer.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/composer.py new file mode 100644 index 0000000000000000000000000000000000000000..6d15cb40e3b4198819c91c6f8d8b32807fcf53b2 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/composer.py @@ -0,0 +1,139 @@ + +__all__ = ['Composer', 'ComposerError'] + +from .error import MarkedYAMLError +from .events import * +from .nodes import * + +class ComposerError(MarkedYAMLError): + pass + +class Composer: + + def __init__(self): + self.anchors = {} + + def check_node(self): + # Drop the STREAM-START event. + if self.check_event(StreamStartEvent): + self.get_event() + + # If there are more documents available? + return not self.check_event(StreamEndEvent) + + def get_node(self): + # Get the root node of the next document. + if not self.check_event(StreamEndEvent): + return self.compose_document() + + def get_single_node(self): + # Drop the STREAM-START event. + self.get_event() + + # Compose a document if the stream is not empty. + document = None + if not self.check_event(StreamEndEvent): + document = self.compose_document() + + # Ensure that the stream contains no more documents. + if not self.check_event(StreamEndEvent): + event = self.get_event() + raise ComposerError("expected a single document in the stream", + document.start_mark, "but found another document", + event.start_mark) + + # Drop the STREAM-END event. + self.get_event() + + return document + + def compose_document(self): + # Drop the DOCUMENT-START event. + self.get_event() + + # Compose the root node. + node = self.compose_node(None, None) + + # Drop the DOCUMENT-END event. + self.get_event() + + self.anchors = {} + return node + + def compose_node(self, parent, index): + if self.check_event(AliasEvent): + event = self.get_event() + anchor = event.anchor + if anchor not in self.anchors: + raise ComposerError(None, None, "found undefined alias %r" + % anchor, event.start_mark) + return self.anchors[anchor] + event = self.peek_event() + anchor = event.anchor + if anchor is not None: + if anchor in self.anchors: + raise ComposerError("found duplicate anchor %r; first occurrence" + % anchor, self.anchors[anchor].start_mark, + "second occurrence", event.start_mark) + self.descend_resolver(parent, index) + if self.check_event(ScalarEvent): + node = self.compose_scalar_node(anchor) + elif self.check_event(SequenceStartEvent): + node = self.compose_sequence_node(anchor) + elif self.check_event(MappingStartEvent): + node = self.compose_mapping_node(anchor) + self.ascend_resolver() + return node + + def compose_scalar_node(self, anchor): + event = self.get_event() + tag = event.tag + if tag is None or tag == '!': + tag = self.resolve(ScalarNode, event.value, event.implicit) + node = ScalarNode(tag, event.value, + event.start_mark, event.end_mark, style=event.style) + if anchor is not None: + self.anchors[anchor] = node + return node + + def compose_sequence_node(self, anchor): + start_event = self.get_event() + tag = start_event.tag + if tag is None or tag == '!': + tag = self.resolve(SequenceNode, None, start_event.implicit) + node = SequenceNode(tag, [], + start_event.start_mark, None, + flow_style=start_event.flow_style) + if anchor is not None: + self.anchors[anchor] = node + index = 0 + while not self.check_event(SequenceEndEvent): + node.value.append(self.compose_node(node, index)) + index += 1 + end_event = self.get_event() + node.end_mark = end_event.end_mark + return node + + def compose_mapping_node(self, anchor): + start_event = self.get_event() + tag = start_event.tag + if tag is None or tag == '!': + tag = self.resolve(MappingNode, None, start_event.implicit) + node = MappingNode(tag, [], + start_event.start_mark, None, + flow_style=start_event.flow_style) + if anchor is not None: + self.anchors[anchor] = node + while not self.check_event(MappingEndEvent): + #key_event = self.peek_event() + item_key = self.compose_node(node, None) + #if item_key in node.value: + # raise ComposerError("while composing a mapping", start_event.start_mark, + # "found duplicate key", key_event.start_mark) + item_value = self.compose_node(node, item_key) + #node.value[item_key] = item_value + node.value.append((item_key, item_value)) + end_event = self.get_event() + node.end_mark = end_event.end_mark + return node + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/constructor.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/constructor.py new file mode 100644 index 0000000000000000000000000000000000000000..619acd3070a4845c653fcf22a626e05158035bc2 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/constructor.py @@ -0,0 +1,748 @@ + +__all__ = [ + 'BaseConstructor', + 'SafeConstructor', + 'FullConstructor', + 'UnsafeConstructor', + 'Constructor', + 'ConstructorError' +] + +from .error import * +from .nodes import * + +import collections.abc, datetime, base64, binascii, re, sys, types + +class ConstructorError(MarkedYAMLError): + pass + +class BaseConstructor: + + yaml_constructors = {} + yaml_multi_constructors = {} + + def __init__(self): + self.constructed_objects = {} + self.recursive_objects = {} + self.state_generators = [] + self.deep_construct = False + + def check_data(self): + # If there are more documents available? + return self.check_node() + + def check_state_key(self, key): + """Block special attributes/methods from being set in a newly created + object, to prevent user-controlled methods from being called during + deserialization""" + if self.get_state_keys_blacklist_regexp().match(key): + raise ConstructorError(None, None, + "blacklisted key '%s' in instance state found" % (key,), None) + + def get_data(self): + # Construct and return the next document. + if self.check_node(): + return self.construct_document(self.get_node()) + + def get_single_data(self): + # Ensure that the stream contains a single document and construct it. + node = self.get_single_node() + if node is not None: + return self.construct_document(node) + return None + + def construct_document(self, node): + data = self.construct_object(node) + while self.state_generators: + state_generators = self.state_generators + self.state_generators = [] + for generator in state_generators: + for dummy in generator: + pass + self.constructed_objects = {} + self.recursive_objects = {} + self.deep_construct = False + return data + + def construct_object(self, node, deep=False): + if node in self.constructed_objects: + return self.constructed_objects[node] + if deep: + old_deep = self.deep_construct + self.deep_construct = True + if node in self.recursive_objects: + raise ConstructorError(None, None, + "found unconstructable recursive node", node.start_mark) + self.recursive_objects[node] = None + constructor = None + tag_suffix = None + if node.tag in self.yaml_constructors: + constructor = self.yaml_constructors[node.tag] + else: + for tag_prefix in self.yaml_multi_constructors: + if tag_prefix is not None and node.tag.startswith(tag_prefix): + tag_suffix = node.tag[len(tag_prefix):] + constructor = self.yaml_multi_constructors[tag_prefix] + break + else: + if None in self.yaml_multi_constructors: + tag_suffix = node.tag + constructor = self.yaml_multi_constructors[None] + elif None in self.yaml_constructors: + constructor = self.yaml_constructors[None] + elif isinstance(node, ScalarNode): + constructor = self.__class__.construct_scalar + elif isinstance(node, SequenceNode): + constructor = self.__class__.construct_sequence + elif isinstance(node, MappingNode): + constructor = self.__class__.construct_mapping + if tag_suffix is None: + data = constructor(self, node) + else: + data = constructor(self, tag_suffix, node) + if isinstance(data, types.GeneratorType): + generator = data + data = next(generator) + if self.deep_construct: + for dummy in generator: + pass + else: + self.state_generators.append(generator) + self.constructed_objects[node] = data + del self.recursive_objects[node] + if deep: + self.deep_construct = old_deep + return data + + def construct_scalar(self, node): + if not isinstance(node, ScalarNode): + raise ConstructorError(None, None, + "expected a scalar node, but found %s" % node.id, + node.start_mark) + return node.value + + def construct_sequence(self, node, deep=False): + if not isinstance(node, SequenceNode): + raise ConstructorError(None, None, + "expected a sequence node, but found %s" % node.id, + node.start_mark) + return [self.construct_object(child, deep=deep) + for child in node.value] + + def construct_mapping(self, node, deep=False): + if not isinstance(node, MappingNode): + raise ConstructorError(None, None, + "expected a mapping node, but found %s" % node.id, + node.start_mark) + mapping = {} + for key_node, value_node in node.value: + key = self.construct_object(key_node, deep=deep) + if not isinstance(key, collections.abc.Hashable): + raise ConstructorError("while constructing a mapping", node.start_mark, + "found unhashable key", key_node.start_mark) + value = self.construct_object(value_node, deep=deep) + mapping[key] = value + return mapping + + def construct_pairs(self, node, deep=False): + if not isinstance(node, MappingNode): + raise ConstructorError(None, None, + "expected a mapping node, but found %s" % node.id, + node.start_mark) + pairs = [] + for key_node, value_node in node.value: + key = self.construct_object(key_node, deep=deep) + value = self.construct_object(value_node, deep=deep) + pairs.append((key, value)) + return pairs + + @classmethod + def add_constructor(cls, tag, constructor): + if not 'yaml_constructors' in cls.__dict__: + cls.yaml_constructors = cls.yaml_constructors.copy() + cls.yaml_constructors[tag] = constructor + + @classmethod + def add_multi_constructor(cls, tag_prefix, multi_constructor): + if not 'yaml_multi_constructors' in cls.__dict__: + cls.yaml_multi_constructors = cls.yaml_multi_constructors.copy() + cls.yaml_multi_constructors[tag_prefix] = multi_constructor + +class SafeConstructor(BaseConstructor): + + def construct_scalar(self, node): + if isinstance(node, MappingNode): + for key_node, value_node in node.value: + if key_node.tag == 'tag:yaml.org,2002:value': + return self.construct_scalar(value_node) + return super().construct_scalar(node) + + def flatten_mapping(self, node): + merge = [] + index = 0 + while index < len(node.value): + key_node, value_node = node.value[index] + if key_node.tag == 'tag:yaml.org,2002:merge': + del node.value[index] + if isinstance(value_node, MappingNode): + self.flatten_mapping(value_node) + merge.extend(value_node.value) + elif isinstance(value_node, SequenceNode): + submerge = [] + for subnode in value_node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError("while constructing a mapping", + node.start_mark, + "expected a mapping for merging, but found %s" + % subnode.id, subnode.start_mark) + self.flatten_mapping(subnode) + submerge.append(subnode.value) + submerge.reverse() + for value in submerge: + merge.extend(value) + else: + raise ConstructorError("while constructing a mapping", node.start_mark, + "expected a mapping or list of mappings for merging, but found %s" + % value_node.id, value_node.start_mark) + elif key_node.tag == 'tag:yaml.org,2002:value': + key_node.tag = 'tag:yaml.org,2002:str' + index += 1 + else: + index += 1 + if merge: + node.value = merge + node.value + + def construct_mapping(self, node, deep=False): + if isinstance(node, MappingNode): + self.flatten_mapping(node) + return super().construct_mapping(node, deep=deep) + + def construct_yaml_null(self, node): + self.construct_scalar(node) + return None + + bool_values = { + 'yes': True, + 'no': False, + 'true': True, + 'false': False, + 'on': True, + 'off': False, + } + + def construct_yaml_bool(self, node): + value = self.construct_scalar(node) + return self.bool_values[value.lower()] + + def construct_yaml_int(self, node): + value = self.construct_scalar(node) + value = value.replace('_', '') + sign = +1 + if value[0] == '-': + sign = -1 + if value[0] in '+-': + value = value[1:] + if value == '0': + return 0 + elif value.startswith('0b'): + return sign*int(value[2:], 2) + elif value.startswith('0x'): + return sign*int(value[2:], 16) + elif value[0] == '0': + return sign*int(value, 8) + elif ':' in value: + digits = [int(part) for part in value.split(':')] + digits.reverse() + base = 1 + value = 0 + for digit in digits: + value += digit*base + base *= 60 + return sign*value + else: + return sign*int(value) + + inf_value = 1e300 + while inf_value != inf_value*inf_value: + inf_value *= inf_value + nan_value = -inf_value/inf_value # Trying to make a quiet NaN (like C99). + + def construct_yaml_float(self, node): + value = self.construct_scalar(node) + value = value.replace('_', '').lower() + sign = +1 + if value[0] == '-': + sign = -1 + if value[0] in '+-': + value = value[1:] + if value == '.inf': + return sign*self.inf_value + elif value == '.nan': + return self.nan_value + elif ':' in value: + digits = [float(part) for part in value.split(':')] + digits.reverse() + base = 1 + value = 0.0 + for digit in digits: + value += digit*base + base *= 60 + return sign*value + else: + return sign*float(value) + + def construct_yaml_binary(self, node): + try: + value = self.construct_scalar(node).encode('ascii') + except UnicodeEncodeError as exc: + raise ConstructorError(None, None, + "failed to convert base64 data into ascii: %s" % exc, + node.start_mark) + try: + if hasattr(base64, 'decodebytes'): + return base64.decodebytes(value) + else: + return base64.decodestring(value) + except binascii.Error as exc: + raise ConstructorError(None, None, + "failed to decode base64 data: %s" % exc, node.start_mark) + + timestamp_regexp = re.compile( + r'''^(?P[0-9][0-9][0-9][0-9]) + -(?P[0-9][0-9]?) + -(?P[0-9][0-9]?) + (?:(?:[Tt]|[ \t]+) + (?P[0-9][0-9]?) + :(?P[0-9][0-9]) + :(?P[0-9][0-9]) + (?:\.(?P[0-9]*))? + (?:[ \t]*(?PZ|(?P[-+])(?P[0-9][0-9]?) + (?::(?P[0-9][0-9]))?))?)?$''', re.X) + + def construct_yaml_timestamp(self, node): + value = self.construct_scalar(node) + match = self.timestamp_regexp.match(node.value) + values = match.groupdict() + year = int(values['year']) + month = int(values['month']) + day = int(values['day']) + if not values['hour']: + return datetime.date(year, month, day) + hour = int(values['hour']) + minute = int(values['minute']) + second = int(values['second']) + fraction = 0 + tzinfo = None + if values['fraction']: + fraction = values['fraction'][:6] + while len(fraction) < 6: + fraction += '0' + fraction = int(fraction) + if values['tz_sign']: + tz_hour = int(values['tz_hour']) + tz_minute = int(values['tz_minute'] or 0) + delta = datetime.timedelta(hours=tz_hour, minutes=tz_minute) + if values['tz_sign'] == '-': + delta = -delta + tzinfo = datetime.timezone(delta) + elif values['tz']: + tzinfo = datetime.timezone.utc + return datetime.datetime(year, month, day, hour, minute, second, fraction, + tzinfo=tzinfo) + + def construct_yaml_omap(self, node): + # Note: we do not check for duplicate keys, because it's too + # CPU-expensive. + omap = [] + yield omap + if not isinstance(node, SequenceNode): + raise ConstructorError("while constructing an ordered map", node.start_mark, + "expected a sequence, but found %s" % node.id, node.start_mark) + for subnode in node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError("while constructing an ordered map", node.start_mark, + "expected a mapping of length 1, but found %s" % subnode.id, + subnode.start_mark) + if len(subnode.value) != 1: + raise ConstructorError("while constructing an ordered map", node.start_mark, + "expected a single mapping item, but found %d items" % len(subnode.value), + subnode.start_mark) + key_node, value_node = subnode.value[0] + key = self.construct_object(key_node) + value = self.construct_object(value_node) + omap.append((key, value)) + + def construct_yaml_pairs(self, node): + # Note: the same code as `construct_yaml_omap`. + pairs = [] + yield pairs + if not isinstance(node, SequenceNode): + raise ConstructorError("while constructing pairs", node.start_mark, + "expected a sequence, but found %s" % node.id, node.start_mark) + for subnode in node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError("while constructing pairs", node.start_mark, + "expected a mapping of length 1, but found %s" % subnode.id, + subnode.start_mark) + if len(subnode.value) != 1: + raise ConstructorError("while constructing pairs", node.start_mark, + "expected a single mapping item, but found %d items" % len(subnode.value), + subnode.start_mark) + key_node, value_node = subnode.value[0] + key = self.construct_object(key_node) + value = self.construct_object(value_node) + pairs.append((key, value)) + + def construct_yaml_set(self, node): + data = set() + yield data + value = self.construct_mapping(node) + data.update(value) + + def construct_yaml_str(self, node): + return self.construct_scalar(node) + + def construct_yaml_seq(self, node): + data = [] + yield data + data.extend(self.construct_sequence(node)) + + def construct_yaml_map(self, node): + data = {} + yield data + value = self.construct_mapping(node) + data.update(value) + + def construct_yaml_object(self, node, cls): + data = cls.__new__(cls) + yield data + if hasattr(data, '__setstate__'): + state = self.construct_mapping(node, deep=True) + data.__setstate__(state) + else: + state = self.construct_mapping(node) + data.__dict__.update(state) + + def construct_undefined(self, node): + raise ConstructorError(None, None, + "could not determine a constructor for the tag %r" % node.tag, + node.start_mark) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:null', + SafeConstructor.construct_yaml_null) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:bool', + SafeConstructor.construct_yaml_bool) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:int', + SafeConstructor.construct_yaml_int) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:float', + SafeConstructor.construct_yaml_float) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:binary', + SafeConstructor.construct_yaml_binary) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:timestamp', + SafeConstructor.construct_yaml_timestamp) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:omap', + SafeConstructor.construct_yaml_omap) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:pairs', + SafeConstructor.construct_yaml_pairs) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:set', + SafeConstructor.construct_yaml_set) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:str', + SafeConstructor.construct_yaml_str) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:seq', + SafeConstructor.construct_yaml_seq) + +SafeConstructor.add_constructor( + 'tag:yaml.org,2002:map', + SafeConstructor.construct_yaml_map) + +SafeConstructor.add_constructor(None, + SafeConstructor.construct_undefined) + +class FullConstructor(SafeConstructor): + # 'extend' is blacklisted because it is used by + # construct_python_object_apply to add `listitems` to a newly generate + # python instance + def get_state_keys_blacklist(self): + return ['^extend$', '^__.*__$'] + + def get_state_keys_blacklist_regexp(self): + if not hasattr(self, 'state_keys_blacklist_regexp'): + self.state_keys_blacklist_regexp = re.compile('(' + '|'.join(self.get_state_keys_blacklist()) + ')') + return self.state_keys_blacklist_regexp + + def construct_python_str(self, node): + return self.construct_scalar(node) + + def construct_python_unicode(self, node): + return self.construct_scalar(node) + + def construct_python_bytes(self, node): + try: + value = self.construct_scalar(node).encode('ascii') + except UnicodeEncodeError as exc: + raise ConstructorError(None, None, + "failed to convert base64 data into ascii: %s" % exc, + node.start_mark) + try: + if hasattr(base64, 'decodebytes'): + return base64.decodebytes(value) + else: + return base64.decodestring(value) + except binascii.Error as exc: + raise ConstructorError(None, None, + "failed to decode base64 data: %s" % exc, node.start_mark) + + def construct_python_long(self, node): + return self.construct_yaml_int(node) + + def construct_python_complex(self, node): + return complex(self.construct_scalar(node)) + + def construct_python_tuple(self, node): + return tuple(self.construct_sequence(node)) + + def find_python_module(self, name, mark, unsafe=False): + if not name: + raise ConstructorError("while constructing a Python module", mark, + "expected non-empty name appended to the tag", mark) + if unsafe: + try: + __import__(name) + except ImportError as exc: + raise ConstructorError("while constructing a Python module", mark, + "cannot find module %r (%s)" % (name, exc), mark) + if name not in sys.modules: + raise ConstructorError("while constructing a Python module", mark, + "module %r is not imported" % name, mark) + return sys.modules[name] + + def find_python_name(self, name, mark, unsafe=False): + if not name: + raise ConstructorError("while constructing a Python object", mark, + "expected non-empty name appended to the tag", mark) + if '.' in name: + module_name, object_name = name.rsplit('.', 1) + else: + module_name = 'builtins' + object_name = name + if unsafe: + try: + __import__(module_name) + except ImportError as exc: + raise ConstructorError("while constructing a Python object", mark, + "cannot find module %r (%s)" % (module_name, exc), mark) + if module_name not in sys.modules: + raise ConstructorError("while constructing a Python object", mark, + "module %r is not imported" % module_name, mark) + module = sys.modules[module_name] + if not hasattr(module, object_name): + raise ConstructorError("while constructing a Python object", mark, + "cannot find %r in the module %r" + % (object_name, module.__name__), mark) + return getattr(module, object_name) + + def construct_python_name(self, suffix, node): + value = self.construct_scalar(node) + if value: + raise ConstructorError("while constructing a Python name", node.start_mark, + "expected the empty value, but found %r" % value, node.start_mark) + return self.find_python_name(suffix, node.start_mark) + + def construct_python_module(self, suffix, node): + value = self.construct_scalar(node) + if value: + raise ConstructorError("while constructing a Python module", node.start_mark, + "expected the empty value, but found %r" % value, node.start_mark) + return self.find_python_module(suffix, node.start_mark) + + def make_python_instance(self, suffix, node, + args=None, kwds=None, newobj=False, unsafe=False): + if not args: + args = [] + if not kwds: + kwds = {} + cls = self.find_python_name(suffix, node.start_mark) + if not (unsafe or isinstance(cls, type)): + raise ConstructorError("while constructing a Python instance", node.start_mark, + "expected a class, but found %r" % type(cls), + node.start_mark) + if newobj and isinstance(cls, type): + return cls.__new__(cls, *args, **kwds) + else: + return cls(*args, **kwds) + + def set_python_instance_state(self, instance, state, unsafe=False): + if hasattr(instance, '__setstate__'): + instance.__setstate__(state) + else: + slotstate = {} + if isinstance(state, tuple) and len(state) == 2: + state, slotstate = state + if hasattr(instance, '__dict__'): + if not unsafe and state: + for key in state.keys(): + self.check_state_key(key) + instance.__dict__.update(state) + elif state: + slotstate.update(state) + for key, value in slotstate.items(): + if not unsafe: + self.check_state_key(key) + setattr(instance, key, value) + + def construct_python_object(self, suffix, node): + # Format: + # !!python/object:module.name { ... state ... } + instance = self.make_python_instance(suffix, node, newobj=True) + yield instance + deep = hasattr(instance, '__setstate__') + state = self.construct_mapping(node, deep=deep) + self.set_python_instance_state(instance, state) + + def construct_python_object_apply(self, suffix, node, newobj=False): + # Format: + # !!python/object/apply # (or !!python/object/new) + # args: [ ... arguments ... ] + # kwds: { ... keywords ... } + # state: ... state ... + # listitems: [ ... listitems ... ] + # dictitems: { ... dictitems ... } + # or short format: + # !!python/object/apply [ ... arguments ... ] + # The difference between !!python/object/apply and !!python/object/new + # is how an object is created, check make_python_instance for details. + if isinstance(node, SequenceNode): + args = self.construct_sequence(node, deep=True) + kwds = {} + state = {} + listitems = [] + dictitems = {} + else: + value = self.construct_mapping(node, deep=True) + args = value.get('args', []) + kwds = value.get('kwds', {}) + state = value.get('state', {}) + listitems = value.get('listitems', []) + dictitems = value.get('dictitems', {}) + instance = self.make_python_instance(suffix, node, args, kwds, newobj) + if state: + self.set_python_instance_state(instance, state) + if listitems: + instance.extend(listitems) + if dictitems: + for key in dictitems: + instance[key] = dictitems[key] + return instance + + def construct_python_object_new(self, suffix, node): + return self.construct_python_object_apply(suffix, node, newobj=True) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/none', + FullConstructor.construct_yaml_null) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/bool', + FullConstructor.construct_yaml_bool) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/str', + FullConstructor.construct_python_str) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/unicode', + FullConstructor.construct_python_unicode) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/bytes', + FullConstructor.construct_python_bytes) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/int', + FullConstructor.construct_yaml_int) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/long', + FullConstructor.construct_python_long) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/float', + FullConstructor.construct_yaml_float) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/complex', + FullConstructor.construct_python_complex) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/list', + FullConstructor.construct_yaml_seq) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/tuple', + FullConstructor.construct_python_tuple) + +FullConstructor.add_constructor( + 'tag:yaml.org,2002:python/dict', + FullConstructor.construct_yaml_map) + +FullConstructor.add_multi_constructor( + 'tag:yaml.org,2002:python/name:', + FullConstructor.construct_python_name) + +class UnsafeConstructor(FullConstructor): + + def find_python_module(self, name, mark): + return super(UnsafeConstructor, self).find_python_module(name, mark, unsafe=True) + + def find_python_name(self, name, mark): + return super(UnsafeConstructor, self).find_python_name(name, mark, unsafe=True) + + def make_python_instance(self, suffix, node, args=None, kwds=None, newobj=False): + return super(UnsafeConstructor, self).make_python_instance( + suffix, node, args, kwds, newobj, unsafe=True) + + def set_python_instance_state(self, instance, state): + return super(UnsafeConstructor, self).set_python_instance_state( + instance, state, unsafe=True) + +UnsafeConstructor.add_multi_constructor( + 'tag:yaml.org,2002:python/module:', + UnsafeConstructor.construct_python_module) + +UnsafeConstructor.add_multi_constructor( + 'tag:yaml.org,2002:python/object:', + UnsafeConstructor.construct_python_object) + +UnsafeConstructor.add_multi_constructor( + 'tag:yaml.org,2002:python/object/new:', + UnsafeConstructor.construct_python_object_new) + +UnsafeConstructor.add_multi_constructor( + 'tag:yaml.org,2002:python/object/apply:', + UnsafeConstructor.construct_python_object_apply) + +# Constructor is same as UnsafeConstructor. Need to leave this in place in case +# people have extended it directly. +class Constructor(UnsafeConstructor): + pass diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/cyaml.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/cyaml.py new file mode 100644 index 0000000000000000000000000000000000000000..0c21345879b298bb8668201bebe7d289586b17f9 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/cyaml.py @@ -0,0 +1,101 @@ + +__all__ = [ + 'CBaseLoader', 'CSafeLoader', 'CFullLoader', 'CUnsafeLoader', 'CLoader', + 'CBaseDumper', 'CSafeDumper', 'CDumper' +] + +from yaml._yaml import CParser, CEmitter + +from .constructor import * + +from .serializer import * +from .representer import * + +from .resolver import * + +class CBaseLoader(CParser, BaseConstructor, BaseResolver): + + def __init__(self, stream): + CParser.__init__(self, stream) + BaseConstructor.__init__(self) + BaseResolver.__init__(self) + +class CSafeLoader(CParser, SafeConstructor, Resolver): + + def __init__(self, stream): + CParser.__init__(self, stream) + SafeConstructor.__init__(self) + Resolver.__init__(self) + +class CFullLoader(CParser, FullConstructor, Resolver): + + def __init__(self, stream): + CParser.__init__(self, stream) + FullConstructor.__init__(self) + Resolver.__init__(self) + +class CUnsafeLoader(CParser, UnsafeConstructor, Resolver): + + def __init__(self, stream): + CParser.__init__(self, stream) + UnsafeConstructor.__init__(self) + Resolver.__init__(self) + +class CLoader(CParser, Constructor, Resolver): + + def __init__(self, stream): + CParser.__init__(self, stream) + Constructor.__init__(self) + Resolver.__init__(self) + +class CBaseDumper(CEmitter, BaseRepresenter, BaseResolver): + + def __init__(self, stream, + default_style=None, default_flow_style=False, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None, sort_keys=True): + CEmitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, encoding=encoding, + allow_unicode=allow_unicode, line_break=line_break, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + Representer.__init__(self, default_style=default_style, + default_flow_style=default_flow_style, sort_keys=sort_keys) + Resolver.__init__(self) + +class CSafeDumper(CEmitter, SafeRepresenter, Resolver): + + def __init__(self, stream, + default_style=None, default_flow_style=False, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None, sort_keys=True): + CEmitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, encoding=encoding, + allow_unicode=allow_unicode, line_break=line_break, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + SafeRepresenter.__init__(self, default_style=default_style, + default_flow_style=default_flow_style, sort_keys=sort_keys) + Resolver.__init__(self) + +class CDumper(CEmitter, Serializer, Representer, Resolver): + + def __init__(self, stream, + default_style=None, default_flow_style=False, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None, sort_keys=True): + CEmitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, encoding=encoding, + allow_unicode=allow_unicode, line_break=line_break, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + Representer.__init__(self, default_style=default_style, + default_flow_style=default_flow_style, sort_keys=sort_keys) + Resolver.__init__(self) + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/dumper.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/dumper.py new file mode 100644 index 0000000000000000000000000000000000000000..6aadba551f3836b02f4752277f4b3027073defad --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/dumper.py @@ -0,0 +1,62 @@ + +__all__ = ['BaseDumper', 'SafeDumper', 'Dumper'] + +from .emitter import * +from .serializer import * +from .representer import * +from .resolver import * + +class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver): + + def __init__(self, stream, + default_style=None, default_flow_style=False, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None, sort_keys=True): + Emitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break) + Serializer.__init__(self, encoding=encoding, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + Representer.__init__(self, default_style=default_style, + default_flow_style=default_flow_style, sort_keys=sort_keys) + Resolver.__init__(self) + +class SafeDumper(Emitter, Serializer, SafeRepresenter, Resolver): + + def __init__(self, stream, + default_style=None, default_flow_style=False, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None, sort_keys=True): + Emitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break) + Serializer.__init__(self, encoding=encoding, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + SafeRepresenter.__init__(self, default_style=default_style, + default_flow_style=default_flow_style, sort_keys=sort_keys) + Resolver.__init__(self) + +class Dumper(Emitter, Serializer, Representer, Resolver): + + def __init__(self, stream, + default_style=None, default_flow_style=False, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None, sort_keys=True): + Emitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break) + Serializer.__init__(self, encoding=encoding, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + Representer.__init__(self, default_style=default_style, + default_flow_style=default_flow_style, sort_keys=sort_keys) + Resolver.__init__(self) + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/emitter.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/emitter.py new file mode 100644 index 0000000000000000000000000000000000000000..a664d011162af69184df2f8e59ab7feec818f7c7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/emitter.py @@ -0,0 +1,1137 @@ + +# Emitter expects events obeying the following grammar: +# stream ::= STREAM-START document* STREAM-END +# document ::= DOCUMENT-START node DOCUMENT-END +# node ::= SCALAR | sequence | mapping +# sequence ::= SEQUENCE-START node* SEQUENCE-END +# mapping ::= MAPPING-START (node node)* MAPPING-END + +__all__ = ['Emitter', 'EmitterError'] + +from .error import YAMLError +from .events import * + +class EmitterError(YAMLError): + pass + +class ScalarAnalysis: + def __init__(self, scalar, empty, multiline, + allow_flow_plain, allow_block_plain, + allow_single_quoted, allow_double_quoted, + allow_block): + self.scalar = scalar + self.empty = empty + self.multiline = multiline + self.allow_flow_plain = allow_flow_plain + self.allow_block_plain = allow_block_plain + self.allow_single_quoted = allow_single_quoted + self.allow_double_quoted = allow_double_quoted + self.allow_block = allow_block + +class Emitter: + + DEFAULT_TAG_PREFIXES = { + '!' : '!', + 'tag:yaml.org,2002:' : '!!', + } + + def __init__(self, stream, canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None): + + # The stream should have the methods `write` and possibly `flush`. + self.stream = stream + + # Encoding can be overridden by STREAM-START. + self.encoding = None + + # Emitter is a state machine with a stack of states to handle nested + # structures. + self.states = [] + self.state = self.expect_stream_start + + # Current event and the event queue. + self.events = [] + self.event = None + + # The current indentation level and the stack of previous indents. + self.indents = [] + self.indent = None + + # Flow level. + self.flow_level = 0 + + # Contexts. + self.root_context = False + self.sequence_context = False + self.mapping_context = False + self.simple_key_context = False + + # Characteristics of the last emitted character: + # - current position. + # - is it a whitespace? + # - is it an indention character + # (indentation space, '-', '?', or ':')? + self.line = 0 + self.column = 0 + self.whitespace = True + self.indention = True + + # Whether the document requires an explicit document indicator + self.open_ended = False + + # Formatting details. + self.canonical = canonical + self.allow_unicode = allow_unicode + self.best_indent = 2 + if indent and 1 < indent < 10: + self.best_indent = indent + self.best_width = 80 + if width and width > self.best_indent*2: + self.best_width = width + self.best_line_break = '\n' + if line_break in ['\r', '\n', '\r\n']: + self.best_line_break = line_break + + # Tag prefixes. + self.tag_prefixes = None + + # Prepared anchor and tag. + self.prepared_anchor = None + self.prepared_tag = None + + # Scalar analysis and style. + self.analysis = None + self.style = None + + def dispose(self): + # Reset the state attributes (to clear self-references) + self.states = [] + self.state = None + + def emit(self, event): + self.events.append(event) + while not self.need_more_events(): + self.event = self.events.pop(0) + self.state() + self.event = None + + # In some cases, we wait for a few next events before emitting. + + def need_more_events(self): + if not self.events: + return True + event = self.events[0] + if isinstance(event, DocumentStartEvent): + return self.need_events(1) + elif isinstance(event, SequenceStartEvent): + return self.need_events(2) + elif isinstance(event, MappingStartEvent): + return self.need_events(3) + else: + return False + + def need_events(self, count): + level = 0 + for event in self.events[1:]: + if isinstance(event, (DocumentStartEvent, CollectionStartEvent)): + level += 1 + elif isinstance(event, (DocumentEndEvent, CollectionEndEvent)): + level -= 1 + elif isinstance(event, StreamEndEvent): + level = -1 + if level < 0: + return False + return (len(self.events) < count+1) + + def increase_indent(self, flow=False, indentless=False): + self.indents.append(self.indent) + if self.indent is None: + if flow: + self.indent = self.best_indent + else: + self.indent = 0 + elif not indentless: + self.indent += self.best_indent + + # States. + + # Stream handlers. + + def expect_stream_start(self): + if isinstance(self.event, StreamStartEvent): + if self.event.encoding and not hasattr(self.stream, 'encoding'): + self.encoding = self.event.encoding + self.write_stream_start() + self.state = self.expect_first_document_start + else: + raise EmitterError("expected StreamStartEvent, but got %s" + % self.event) + + def expect_nothing(self): + raise EmitterError("expected nothing, but got %s" % self.event) + + # Document handlers. + + def expect_first_document_start(self): + return self.expect_document_start(first=True) + + def expect_document_start(self, first=False): + if isinstance(self.event, DocumentStartEvent): + if (self.event.version or self.event.tags) and self.open_ended: + self.write_indicator('...', True) + self.write_indent() + if self.event.version: + version_text = self.prepare_version(self.event.version) + self.write_version_directive(version_text) + self.tag_prefixes = self.DEFAULT_TAG_PREFIXES.copy() + if self.event.tags: + handles = sorted(self.event.tags.keys()) + for handle in handles: + prefix = self.event.tags[handle] + self.tag_prefixes[prefix] = handle + handle_text = self.prepare_tag_handle(handle) + prefix_text = self.prepare_tag_prefix(prefix) + self.write_tag_directive(handle_text, prefix_text) + implicit = (first and not self.event.explicit and not self.canonical + and not self.event.version and not self.event.tags + and not self.check_empty_document()) + if not implicit: + self.write_indent() + self.write_indicator('---', True) + if self.canonical: + self.write_indent() + self.state = self.expect_document_root + elif isinstance(self.event, StreamEndEvent): + if self.open_ended: + self.write_indicator('...', True) + self.write_indent() + self.write_stream_end() + self.state = self.expect_nothing + else: + raise EmitterError("expected DocumentStartEvent, but got %s" + % self.event) + + def expect_document_end(self): + if isinstance(self.event, DocumentEndEvent): + self.write_indent() + if self.event.explicit: + self.write_indicator('...', True) + self.write_indent() + self.flush_stream() + self.state = self.expect_document_start + else: + raise EmitterError("expected DocumentEndEvent, but got %s" + % self.event) + + def expect_document_root(self): + self.states.append(self.expect_document_end) + self.expect_node(root=True) + + # Node handlers. + + def expect_node(self, root=False, sequence=False, mapping=False, + simple_key=False): + self.root_context = root + self.sequence_context = sequence + self.mapping_context = mapping + self.simple_key_context = simple_key + if isinstance(self.event, AliasEvent): + self.expect_alias() + elif isinstance(self.event, (ScalarEvent, CollectionStartEvent)): + self.process_anchor('&') + self.process_tag() + if isinstance(self.event, ScalarEvent): + self.expect_scalar() + elif isinstance(self.event, SequenceStartEvent): + if self.flow_level or self.canonical or self.event.flow_style \ + or self.check_empty_sequence(): + self.expect_flow_sequence() + else: + self.expect_block_sequence() + elif isinstance(self.event, MappingStartEvent): + if self.flow_level or self.canonical or self.event.flow_style \ + or self.check_empty_mapping(): + self.expect_flow_mapping() + else: + self.expect_block_mapping() + else: + raise EmitterError("expected NodeEvent, but got %s" % self.event) + + def expect_alias(self): + if self.event.anchor is None: + raise EmitterError("anchor is not specified for alias") + self.process_anchor('*') + self.state = self.states.pop() + + def expect_scalar(self): + self.increase_indent(flow=True) + self.process_scalar() + self.indent = self.indents.pop() + self.state = self.states.pop() + + # Flow sequence handlers. + + def expect_flow_sequence(self): + self.write_indicator('[', True, whitespace=True) + self.flow_level += 1 + self.increase_indent(flow=True) + self.state = self.expect_first_flow_sequence_item + + def expect_first_flow_sequence_item(self): + if isinstance(self.event, SequenceEndEvent): + self.indent = self.indents.pop() + self.flow_level -= 1 + self.write_indicator(']', False) + self.state = self.states.pop() + else: + if self.canonical or self.column > self.best_width: + self.write_indent() + self.states.append(self.expect_flow_sequence_item) + self.expect_node(sequence=True) + + def expect_flow_sequence_item(self): + if isinstance(self.event, SequenceEndEvent): + self.indent = self.indents.pop() + self.flow_level -= 1 + if self.canonical: + self.write_indicator(',', False) + self.write_indent() + self.write_indicator(']', False) + self.state = self.states.pop() + else: + self.write_indicator(',', False) + if self.canonical or self.column > self.best_width: + self.write_indent() + self.states.append(self.expect_flow_sequence_item) + self.expect_node(sequence=True) + + # Flow mapping handlers. + + def expect_flow_mapping(self): + self.write_indicator('{', True, whitespace=True) + self.flow_level += 1 + self.increase_indent(flow=True) + self.state = self.expect_first_flow_mapping_key + + def expect_first_flow_mapping_key(self): + if isinstance(self.event, MappingEndEvent): + self.indent = self.indents.pop() + self.flow_level -= 1 + self.write_indicator('}', False) + self.state = self.states.pop() + else: + if self.canonical or self.column > self.best_width: + self.write_indent() + if not self.canonical and self.check_simple_key(): + self.states.append(self.expect_flow_mapping_simple_value) + self.expect_node(mapping=True, simple_key=True) + else: + self.write_indicator('?', True) + self.states.append(self.expect_flow_mapping_value) + self.expect_node(mapping=True) + + def expect_flow_mapping_key(self): + if isinstance(self.event, MappingEndEvent): + self.indent = self.indents.pop() + self.flow_level -= 1 + if self.canonical: + self.write_indicator(',', False) + self.write_indent() + self.write_indicator('}', False) + self.state = self.states.pop() + else: + self.write_indicator(',', False) + if self.canonical or self.column > self.best_width: + self.write_indent() + if not self.canonical and self.check_simple_key(): + self.states.append(self.expect_flow_mapping_simple_value) + self.expect_node(mapping=True, simple_key=True) + else: + self.write_indicator('?', True) + self.states.append(self.expect_flow_mapping_value) + self.expect_node(mapping=True) + + def expect_flow_mapping_simple_value(self): + self.write_indicator(':', False) + self.states.append(self.expect_flow_mapping_key) + self.expect_node(mapping=True) + + def expect_flow_mapping_value(self): + if self.canonical or self.column > self.best_width: + self.write_indent() + self.write_indicator(':', True) + self.states.append(self.expect_flow_mapping_key) + self.expect_node(mapping=True) + + # Block sequence handlers. + + def expect_block_sequence(self): + indentless = (self.mapping_context and not self.indention) + self.increase_indent(flow=False, indentless=indentless) + self.state = self.expect_first_block_sequence_item + + def expect_first_block_sequence_item(self): + return self.expect_block_sequence_item(first=True) + + def expect_block_sequence_item(self, first=False): + if not first and isinstance(self.event, SequenceEndEvent): + self.indent = self.indents.pop() + self.state = self.states.pop() + else: + self.write_indent() + self.write_indicator('-', True, indention=True) + self.states.append(self.expect_block_sequence_item) + self.expect_node(sequence=True) + + # Block mapping handlers. + + def expect_block_mapping(self): + self.increase_indent(flow=False) + self.state = self.expect_first_block_mapping_key + + def expect_first_block_mapping_key(self): + return self.expect_block_mapping_key(first=True) + + def expect_block_mapping_key(self, first=False): + if not first and isinstance(self.event, MappingEndEvent): + self.indent = self.indents.pop() + self.state = self.states.pop() + else: + self.write_indent() + if self.check_simple_key(): + self.states.append(self.expect_block_mapping_simple_value) + self.expect_node(mapping=True, simple_key=True) + else: + self.write_indicator('?', True, indention=True) + self.states.append(self.expect_block_mapping_value) + self.expect_node(mapping=True) + + def expect_block_mapping_simple_value(self): + self.write_indicator(':', False) + self.states.append(self.expect_block_mapping_key) + self.expect_node(mapping=True) + + def expect_block_mapping_value(self): + self.write_indent() + self.write_indicator(':', True, indention=True) + self.states.append(self.expect_block_mapping_key) + self.expect_node(mapping=True) + + # Checkers. + + def check_empty_sequence(self): + return (isinstance(self.event, SequenceStartEvent) and self.events + and isinstance(self.events[0], SequenceEndEvent)) + + def check_empty_mapping(self): + return (isinstance(self.event, MappingStartEvent) and self.events + and isinstance(self.events[0], MappingEndEvent)) + + def check_empty_document(self): + if not isinstance(self.event, DocumentStartEvent) or not self.events: + return False + event = self.events[0] + return (isinstance(event, ScalarEvent) and event.anchor is None + and event.tag is None and event.implicit and event.value == '') + + def check_simple_key(self): + length = 0 + if isinstance(self.event, NodeEvent) and self.event.anchor is not None: + if self.prepared_anchor is None: + self.prepared_anchor = self.prepare_anchor(self.event.anchor) + length += len(self.prepared_anchor) + if isinstance(self.event, (ScalarEvent, CollectionStartEvent)) \ + and self.event.tag is not None: + if self.prepared_tag is None: + self.prepared_tag = self.prepare_tag(self.event.tag) + length += len(self.prepared_tag) + if isinstance(self.event, ScalarEvent): + if self.analysis is None: + self.analysis = self.analyze_scalar(self.event.value) + length += len(self.analysis.scalar) + return (length < 128 and (isinstance(self.event, AliasEvent) + or (isinstance(self.event, ScalarEvent) + and not self.analysis.empty and not self.analysis.multiline) + or self.check_empty_sequence() or self.check_empty_mapping())) + + # Anchor, Tag, and Scalar processors. + + def process_anchor(self, indicator): + if self.event.anchor is None: + self.prepared_anchor = None + return + if self.prepared_anchor is None: + self.prepared_anchor = self.prepare_anchor(self.event.anchor) + if self.prepared_anchor: + self.write_indicator(indicator+self.prepared_anchor, True) + self.prepared_anchor = None + + def process_tag(self): + tag = self.event.tag + if isinstance(self.event, ScalarEvent): + if self.style is None: + self.style = self.choose_scalar_style() + if ((not self.canonical or tag is None) and + ((self.style == '' and self.event.implicit[0]) + or (self.style != '' and self.event.implicit[1]))): + self.prepared_tag = None + return + if self.event.implicit[0] and tag is None: + tag = '!' + self.prepared_tag = None + else: + if (not self.canonical or tag is None) and self.event.implicit: + self.prepared_tag = None + return + if tag is None: + raise EmitterError("tag is not specified") + if self.prepared_tag is None: + self.prepared_tag = self.prepare_tag(tag) + if self.prepared_tag: + self.write_indicator(self.prepared_tag, True) + self.prepared_tag = None + + def choose_scalar_style(self): + if self.analysis is None: + self.analysis = self.analyze_scalar(self.event.value) + if self.event.style == '"' or self.canonical: + return '"' + if not self.event.style and self.event.implicit[0]: + if (not (self.simple_key_context and + (self.analysis.empty or self.analysis.multiline)) + and (self.flow_level and self.analysis.allow_flow_plain + or (not self.flow_level and self.analysis.allow_block_plain))): + return '' + if self.event.style and self.event.style in '|>': + if (not self.flow_level and not self.simple_key_context + and self.analysis.allow_block): + return self.event.style + if not self.event.style or self.event.style == '\'': + if (self.analysis.allow_single_quoted and + not (self.simple_key_context and self.analysis.multiline)): + return '\'' + return '"' + + def process_scalar(self): + if self.analysis is None: + self.analysis = self.analyze_scalar(self.event.value) + if self.style is None: + self.style = self.choose_scalar_style() + split = (not self.simple_key_context) + #if self.analysis.multiline and split \ + # and (not self.style or self.style in '\'\"'): + # self.write_indent() + if self.style == '"': + self.write_double_quoted(self.analysis.scalar, split) + elif self.style == '\'': + self.write_single_quoted(self.analysis.scalar, split) + elif self.style == '>': + self.write_folded(self.analysis.scalar) + elif self.style == '|': + self.write_literal(self.analysis.scalar) + else: + self.write_plain(self.analysis.scalar, split) + self.analysis = None + self.style = None + + # Analyzers. + + def prepare_version(self, version): + major, minor = version + if major != 1: + raise EmitterError("unsupported YAML version: %d.%d" % (major, minor)) + return '%d.%d' % (major, minor) + + def prepare_tag_handle(self, handle): + if not handle: + raise EmitterError("tag handle must not be empty") + if handle[0] != '!' or handle[-1] != '!': + raise EmitterError("tag handle must start and end with '!': %r" % handle) + for ch in handle[1:-1]: + if not ('0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ + or ch in '-_'): + raise EmitterError("invalid character %r in the tag handle: %r" + % (ch, handle)) + return handle + + def prepare_tag_prefix(self, prefix): + if not prefix: + raise EmitterError("tag prefix must not be empty") + chunks = [] + start = end = 0 + if prefix[0] == '!': + end = 1 + while end < len(prefix): + ch = prefix[end] + if '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ + or ch in '-;/?!:@&=+$,_.~*\'()[]': + end += 1 + else: + if start < end: + chunks.append(prefix[start:end]) + start = end = end+1 + data = ch.encode('utf-8') + for ch in data: + chunks.append('%%%02X' % ord(ch)) + if start < end: + chunks.append(prefix[start:end]) + return ''.join(chunks) + + def prepare_tag(self, tag): + if not tag: + raise EmitterError("tag must not be empty") + if tag == '!': + return tag + handle = None + suffix = tag + prefixes = sorted(self.tag_prefixes.keys()) + for prefix in prefixes: + if tag.startswith(prefix) \ + and (prefix == '!' or len(prefix) < len(tag)): + handle = self.tag_prefixes[prefix] + suffix = tag[len(prefix):] + chunks = [] + start = end = 0 + while end < len(suffix): + ch = suffix[end] + if '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ + or ch in '-;/?:@&=+$,_.~*\'()[]' \ + or (ch == '!' and handle != '!'): + end += 1 + else: + if start < end: + chunks.append(suffix[start:end]) + start = end = end+1 + data = ch.encode('utf-8') + for ch in data: + chunks.append('%%%02X' % ch) + if start < end: + chunks.append(suffix[start:end]) + suffix_text = ''.join(chunks) + if handle: + return '%s%s' % (handle, suffix_text) + else: + return '!<%s>' % suffix_text + + def prepare_anchor(self, anchor): + if not anchor: + raise EmitterError("anchor must not be empty") + for ch in anchor: + if not ('0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ + or ch in '-_'): + raise EmitterError("invalid character %r in the anchor: %r" + % (ch, anchor)) + return anchor + + def analyze_scalar(self, scalar): + + # Empty scalar is a special case. + if not scalar: + return ScalarAnalysis(scalar=scalar, empty=True, multiline=False, + allow_flow_plain=False, allow_block_plain=True, + allow_single_quoted=True, allow_double_quoted=True, + allow_block=False) + + # Indicators and special characters. + block_indicators = False + flow_indicators = False + line_breaks = False + special_characters = False + + # Important whitespace combinations. + leading_space = False + leading_break = False + trailing_space = False + trailing_break = False + break_space = False + space_break = False + + # Check document indicators. + if scalar.startswith('---') or scalar.startswith('...'): + block_indicators = True + flow_indicators = True + + # First character or preceded by a whitespace. + preceded_by_whitespace = True + + # Last character or followed by a whitespace. + followed_by_whitespace = (len(scalar) == 1 or + scalar[1] in '\0 \t\r\n\x85\u2028\u2029') + + # The previous character is a space. + previous_space = False + + # The previous character is a break. + previous_break = False + + index = 0 + while index < len(scalar): + ch = scalar[index] + + # Check for indicators. + if index == 0: + # Leading indicators are special characters. + if ch in '#,[]{}&*!|>\'\"%@`': + flow_indicators = True + block_indicators = True + if ch in '?:': + flow_indicators = True + if followed_by_whitespace: + block_indicators = True + if ch == '-' and followed_by_whitespace: + flow_indicators = True + block_indicators = True + else: + # Some indicators cannot appear within a scalar as well. + if ch in ',?[]{}': + flow_indicators = True + if ch == ':': + flow_indicators = True + if followed_by_whitespace: + block_indicators = True + if ch == '#' and preceded_by_whitespace: + flow_indicators = True + block_indicators = True + + # Check for line breaks, special, and unicode characters. + if ch in '\n\x85\u2028\u2029': + line_breaks = True + if not (ch == '\n' or '\x20' <= ch <= '\x7E'): + if (ch == '\x85' or '\xA0' <= ch <= '\uD7FF' + or '\uE000' <= ch <= '\uFFFD' + or '\U00010000' <= ch < '\U0010ffff') and ch != '\uFEFF': + unicode_characters = True + if not self.allow_unicode: + special_characters = True + else: + special_characters = True + + # Detect important whitespace combinations. + if ch == ' ': + if index == 0: + leading_space = True + if index == len(scalar)-1: + trailing_space = True + if previous_break: + break_space = True + previous_space = True + previous_break = False + elif ch in '\n\x85\u2028\u2029': + if index == 0: + leading_break = True + if index == len(scalar)-1: + trailing_break = True + if previous_space: + space_break = True + previous_space = False + previous_break = True + else: + previous_space = False + previous_break = False + + # Prepare for the next character. + index += 1 + preceded_by_whitespace = (ch in '\0 \t\r\n\x85\u2028\u2029') + followed_by_whitespace = (index+1 >= len(scalar) or + scalar[index+1] in '\0 \t\r\n\x85\u2028\u2029') + + # Let's decide what styles are allowed. + allow_flow_plain = True + allow_block_plain = True + allow_single_quoted = True + allow_double_quoted = True + allow_block = True + + # Leading and trailing whitespaces are bad for plain scalars. + if (leading_space or leading_break + or trailing_space or trailing_break): + allow_flow_plain = allow_block_plain = False + + # We do not permit trailing spaces for block scalars. + if trailing_space: + allow_block = False + + # Spaces at the beginning of a new line are only acceptable for block + # scalars. + if break_space: + allow_flow_plain = allow_block_plain = allow_single_quoted = False + + # Spaces followed by breaks, as well as special character are only + # allowed for double quoted scalars. + if space_break or special_characters: + allow_flow_plain = allow_block_plain = \ + allow_single_quoted = allow_block = False + + # Although the plain scalar writer supports breaks, we never emit + # multiline plain scalars. + if line_breaks: + allow_flow_plain = allow_block_plain = False + + # Flow indicators are forbidden for flow plain scalars. + if flow_indicators: + allow_flow_plain = False + + # Block indicators are forbidden for block plain scalars. + if block_indicators: + allow_block_plain = False + + return ScalarAnalysis(scalar=scalar, + empty=False, multiline=line_breaks, + allow_flow_plain=allow_flow_plain, + allow_block_plain=allow_block_plain, + allow_single_quoted=allow_single_quoted, + allow_double_quoted=allow_double_quoted, + allow_block=allow_block) + + # Writers. + + def flush_stream(self): + if hasattr(self.stream, 'flush'): + self.stream.flush() + + def write_stream_start(self): + # Write BOM if needed. + if self.encoding and self.encoding.startswith('utf-16'): + self.stream.write('\uFEFF'.encode(self.encoding)) + + def write_stream_end(self): + self.flush_stream() + + def write_indicator(self, indicator, need_whitespace, + whitespace=False, indention=False): + if self.whitespace or not need_whitespace: + data = indicator + else: + data = ' '+indicator + self.whitespace = whitespace + self.indention = self.indention and indention + self.column += len(data) + self.open_ended = False + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + + def write_indent(self): + indent = self.indent or 0 + if not self.indention or self.column > indent \ + or (self.column == indent and not self.whitespace): + self.write_line_break() + if self.column < indent: + self.whitespace = True + data = ' '*(indent-self.column) + self.column = indent + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + + def write_line_break(self, data=None): + if data is None: + data = self.best_line_break + self.whitespace = True + self.indention = True + self.line += 1 + self.column = 0 + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + + def write_version_directive(self, version_text): + data = '%%YAML %s' % version_text + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + self.write_line_break() + + def write_tag_directive(self, handle_text, prefix_text): + data = '%%TAG %s %s' % (handle_text, prefix_text) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + self.write_line_break() + + # Scalar streams. + + def write_single_quoted(self, text, split=True): + self.write_indicator('\'', True) + spaces = False + breaks = False + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if spaces: + if ch is None or ch != ' ': + if start+1 == end and self.column > self.best_width and split \ + and start != 0 and end != len(text): + self.write_indent() + else: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + elif breaks: + if ch is None or ch not in '\n\x85\u2028\u2029': + if text[start] == '\n': + self.write_line_break() + for br in text[start:end]: + if br == '\n': + self.write_line_break() + else: + self.write_line_break(br) + self.write_indent() + start = end + else: + if ch is None or ch in ' \n\x85\u2028\u2029' or ch == '\'': + if start < end: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + if ch == '\'': + data = '\'\'' + self.column += 2 + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + 1 + if ch is not None: + spaces = (ch == ' ') + breaks = (ch in '\n\x85\u2028\u2029') + end += 1 + self.write_indicator('\'', False) + + ESCAPE_REPLACEMENTS = { + '\0': '0', + '\x07': 'a', + '\x08': 'b', + '\x09': 't', + '\x0A': 'n', + '\x0B': 'v', + '\x0C': 'f', + '\x0D': 'r', + '\x1B': 'e', + '\"': '\"', + '\\': '\\', + '\x85': 'N', + '\xA0': '_', + '\u2028': 'L', + '\u2029': 'P', + } + + def write_double_quoted(self, text, split=True): + self.write_indicator('"', True) + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if ch is None or ch in '"\\\x85\u2028\u2029\uFEFF' \ + or not ('\x20' <= ch <= '\x7E' + or (self.allow_unicode + and ('\xA0' <= ch <= '\uD7FF' + or '\uE000' <= ch <= '\uFFFD'))): + if start < end: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + if ch is not None: + if ch in self.ESCAPE_REPLACEMENTS: + data = '\\'+self.ESCAPE_REPLACEMENTS[ch] + elif ch <= '\xFF': + data = '\\x%02X' % ord(ch) + elif ch <= '\uFFFF': + data = '\\u%04X' % ord(ch) + else: + data = '\\U%08X' % ord(ch) + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end+1 + if 0 < end < len(text)-1 and (ch == ' ' or start >= end) \ + and self.column+(end-start) > self.best_width and split: + data = text[start:end]+'\\' + if start < end: + start = end + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + self.write_indent() + self.whitespace = False + self.indention = False + if text[start] == ' ': + data = '\\' + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + end += 1 + self.write_indicator('"', False) + + def determine_block_hints(self, text): + hints = '' + if text: + if text[0] in ' \n\x85\u2028\u2029': + hints += str(self.best_indent) + if text[-1] not in '\n\x85\u2028\u2029': + hints += '-' + elif len(text) == 1 or text[-2] in '\n\x85\u2028\u2029': + hints += '+' + return hints + + def write_folded(self, text): + hints = self.determine_block_hints(text) + self.write_indicator('>'+hints, True) + if hints[-1:] == '+': + self.open_ended = True + self.write_line_break() + leading_space = True + spaces = False + breaks = True + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if breaks: + if ch is None or ch not in '\n\x85\u2028\u2029': + if not leading_space and ch is not None and ch != ' ' \ + and text[start] == '\n': + self.write_line_break() + leading_space = (ch == ' ') + for br in text[start:end]: + if br == '\n': + self.write_line_break() + else: + self.write_line_break(br) + if ch is not None: + self.write_indent() + start = end + elif spaces: + if ch != ' ': + if start+1 == end and self.column > self.best_width: + self.write_indent() + else: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + else: + if ch is None or ch in ' \n\x85\u2028\u2029': + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + if ch is None: + self.write_line_break() + start = end + if ch is not None: + breaks = (ch in '\n\x85\u2028\u2029') + spaces = (ch == ' ') + end += 1 + + def write_literal(self, text): + hints = self.determine_block_hints(text) + self.write_indicator('|'+hints, True) + if hints[-1:] == '+': + self.open_ended = True + self.write_line_break() + breaks = True + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if breaks: + if ch is None or ch not in '\n\x85\u2028\u2029': + for br in text[start:end]: + if br == '\n': + self.write_line_break() + else: + self.write_line_break(br) + if ch is not None: + self.write_indent() + start = end + else: + if ch is None or ch in '\n\x85\u2028\u2029': + data = text[start:end] + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + if ch is None: + self.write_line_break() + start = end + if ch is not None: + breaks = (ch in '\n\x85\u2028\u2029') + end += 1 + + def write_plain(self, text, split=True): + if self.root_context: + self.open_ended = True + if not text: + return + if not self.whitespace: + data = ' ' + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + self.whitespace = False + self.indention = False + spaces = False + breaks = False + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if spaces: + if ch != ' ': + if start+1 == end and self.column > self.best_width and split: + self.write_indent() + self.whitespace = False + self.indention = False + else: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + elif breaks: + if ch not in '\n\x85\u2028\u2029': + if text[start] == '\n': + self.write_line_break() + for br in text[start:end]: + if br == '\n': + self.write_line_break() + else: + self.write_line_break(br) + self.write_indent() + self.whitespace = False + self.indention = False + start = end + else: + if ch is None or ch in ' \n\x85\u2028\u2029': + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + if ch is not None: + spaces = (ch == ' ') + breaks = (ch in '\n\x85\u2028\u2029') + end += 1 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/error.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/error.py new file mode 100644 index 0000000000000000000000000000000000000000..b796b4dc519512c4825ff539a2e6aa20f4d370d0 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/error.py @@ -0,0 +1,75 @@ + +__all__ = ['Mark', 'YAMLError', 'MarkedYAMLError'] + +class Mark: + + def __init__(self, name, index, line, column, buffer, pointer): + self.name = name + self.index = index + self.line = line + self.column = column + self.buffer = buffer + self.pointer = pointer + + def get_snippet(self, indent=4, max_length=75): + if self.buffer is None: + return None + head = '' + start = self.pointer + while start > 0 and self.buffer[start-1] not in '\0\r\n\x85\u2028\u2029': + start -= 1 + if self.pointer-start > max_length/2-1: + head = ' ... ' + start += 5 + break + tail = '' + end = self.pointer + while end < len(self.buffer) and self.buffer[end] not in '\0\r\n\x85\u2028\u2029': + end += 1 + if end-self.pointer > max_length/2-1: + tail = ' ... ' + end -= 5 + break + snippet = self.buffer[start:end] + return ' '*indent + head + snippet + tail + '\n' \ + + ' '*(indent+self.pointer-start+len(head)) + '^' + + def __str__(self): + snippet = self.get_snippet() + where = " in \"%s\", line %d, column %d" \ + % (self.name, self.line+1, self.column+1) + if snippet is not None: + where += ":\n"+snippet + return where + +class YAMLError(Exception): + pass + +class MarkedYAMLError(YAMLError): + + def __init__(self, context=None, context_mark=None, + problem=None, problem_mark=None, note=None): + self.context = context + self.context_mark = context_mark + self.problem = problem + self.problem_mark = problem_mark + self.note = note + + def __str__(self): + lines = [] + if self.context is not None: + lines.append(self.context) + if self.context_mark is not None \ + and (self.problem is None or self.problem_mark is None + or self.context_mark.name != self.problem_mark.name + or self.context_mark.line != self.problem_mark.line + or self.context_mark.column != self.problem_mark.column): + lines.append(str(self.context_mark)) + if self.problem is not None: + lines.append(self.problem) + if self.problem_mark is not None: + lines.append(str(self.problem_mark)) + if self.note is not None: + lines.append(self.note) + return '\n'.join(lines) + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/events.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/events.py new file mode 100644 index 0000000000000000000000000000000000000000..f79ad389cb6c9517e391dcd25534866bc9ccd36a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/events.py @@ -0,0 +1,86 @@ + +# Abstract classes. + +class Event(object): + def __init__(self, start_mark=None, end_mark=None): + self.start_mark = start_mark + self.end_mark = end_mark + def __repr__(self): + attributes = [key for key in ['anchor', 'tag', 'implicit', 'value'] + if hasattr(self, key)] + arguments = ', '.join(['%s=%r' % (key, getattr(self, key)) + for key in attributes]) + return '%s(%s)' % (self.__class__.__name__, arguments) + +class NodeEvent(Event): + def __init__(self, anchor, start_mark=None, end_mark=None): + self.anchor = anchor + self.start_mark = start_mark + self.end_mark = end_mark + +class CollectionStartEvent(NodeEvent): + def __init__(self, anchor, tag, implicit, start_mark=None, end_mark=None, + flow_style=None): + self.anchor = anchor + self.tag = tag + self.implicit = implicit + self.start_mark = start_mark + self.end_mark = end_mark + self.flow_style = flow_style + +class CollectionEndEvent(Event): + pass + +# Implementations. + +class StreamStartEvent(Event): + def __init__(self, start_mark=None, end_mark=None, encoding=None): + self.start_mark = start_mark + self.end_mark = end_mark + self.encoding = encoding + +class StreamEndEvent(Event): + pass + +class DocumentStartEvent(Event): + def __init__(self, start_mark=None, end_mark=None, + explicit=None, version=None, tags=None): + self.start_mark = start_mark + self.end_mark = end_mark + self.explicit = explicit + self.version = version + self.tags = tags + +class DocumentEndEvent(Event): + def __init__(self, start_mark=None, end_mark=None, + explicit=None): + self.start_mark = start_mark + self.end_mark = end_mark + self.explicit = explicit + +class AliasEvent(NodeEvent): + pass + +class ScalarEvent(NodeEvent): + def __init__(self, anchor, tag, implicit, value, + start_mark=None, end_mark=None, style=None): + self.anchor = anchor + self.tag = tag + self.implicit = implicit + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + self.style = style + +class SequenceStartEvent(CollectionStartEvent): + pass + +class SequenceEndEvent(CollectionEndEvent): + pass + +class MappingStartEvent(CollectionStartEvent): + pass + +class MappingEndEvent(CollectionEndEvent): + pass + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/loader.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/loader.py new file mode 100644 index 0000000000000000000000000000000000000000..e90c11224c38e559cdf0cb205f0692ebd4fb8681 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/loader.py @@ -0,0 +1,63 @@ + +__all__ = ['BaseLoader', 'FullLoader', 'SafeLoader', 'Loader', 'UnsafeLoader'] + +from .reader import * +from .scanner import * +from .parser import * +from .composer import * +from .constructor import * +from .resolver import * + +class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver): + + def __init__(self, stream): + Reader.__init__(self, stream) + Scanner.__init__(self) + Parser.__init__(self) + Composer.__init__(self) + BaseConstructor.__init__(self) + BaseResolver.__init__(self) + +class FullLoader(Reader, Scanner, Parser, Composer, FullConstructor, Resolver): + + def __init__(self, stream): + Reader.__init__(self, stream) + Scanner.__init__(self) + Parser.__init__(self) + Composer.__init__(self) + FullConstructor.__init__(self) + Resolver.__init__(self) + +class SafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, Resolver): + + def __init__(self, stream): + Reader.__init__(self, stream) + Scanner.__init__(self) + Parser.__init__(self) + Composer.__init__(self) + SafeConstructor.__init__(self) + Resolver.__init__(self) + +class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver): + + def __init__(self, stream): + Reader.__init__(self, stream) + Scanner.__init__(self) + Parser.__init__(self) + Composer.__init__(self) + Constructor.__init__(self) + Resolver.__init__(self) + +# UnsafeLoader is the same as Loader (which is and was always unsafe on +# untrusted input). Use of either Loader or UnsafeLoader should be rare, since +# FullLoad should be able to load almost all YAML safely. Loader is left intact +# to ensure backwards compatibility. +class UnsafeLoader(Reader, Scanner, Parser, Composer, Constructor, Resolver): + + def __init__(self, stream): + Reader.__init__(self, stream) + Scanner.__init__(self) + Parser.__init__(self) + Composer.__init__(self) + Constructor.__init__(self) + Resolver.__init__(self) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/nodes.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/nodes.py new file mode 100644 index 0000000000000000000000000000000000000000..c4f070c41e1fb1bc01af27d69329e92dded38908 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/nodes.py @@ -0,0 +1,49 @@ + +class Node(object): + def __init__(self, tag, value, start_mark, end_mark): + self.tag = tag + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + def __repr__(self): + value = self.value + #if isinstance(value, list): + # if len(value) == 0: + # value = '' + # elif len(value) == 1: + # value = '<1 item>' + # else: + # value = '<%d items>' % len(value) + #else: + # if len(value) > 75: + # value = repr(value[:70]+u' ... ') + # else: + # value = repr(value) + value = repr(value) + return '%s(tag=%r, value=%s)' % (self.__class__.__name__, self.tag, value) + +class ScalarNode(Node): + id = 'scalar' + def __init__(self, tag, value, + start_mark=None, end_mark=None, style=None): + self.tag = tag + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + self.style = style + +class CollectionNode(Node): + def __init__(self, tag, value, + start_mark=None, end_mark=None, flow_style=None): + self.tag = tag + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + self.flow_style = flow_style + +class SequenceNode(CollectionNode): + id = 'sequence' + +class MappingNode(CollectionNode): + id = 'mapping' + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/parser.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/parser.py new file mode 100644 index 0000000000000000000000000000000000000000..13a5995d292045d0f865a99abf692bd35dc87814 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/parser.py @@ -0,0 +1,589 @@ + +# The following YAML grammar is LL(1) and is parsed by a recursive descent +# parser. +# +# stream ::= STREAM-START implicit_document? explicit_document* STREAM-END +# implicit_document ::= block_node DOCUMENT-END* +# explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* +# block_node_or_indentless_sequence ::= +# ALIAS +# | properties (block_content | indentless_block_sequence)? +# | block_content +# | indentless_block_sequence +# block_node ::= ALIAS +# | properties block_content? +# | block_content +# flow_node ::= ALIAS +# | properties flow_content? +# | flow_content +# properties ::= TAG ANCHOR? | ANCHOR TAG? +# block_content ::= block_collection | flow_collection | SCALAR +# flow_content ::= flow_collection | SCALAR +# block_collection ::= block_sequence | block_mapping +# flow_collection ::= flow_sequence | flow_mapping +# block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END +# indentless_sequence ::= (BLOCK-ENTRY block_node?)+ +# block_mapping ::= BLOCK-MAPPING_START +# ((KEY block_node_or_indentless_sequence?)? +# (VALUE block_node_or_indentless_sequence?)?)* +# BLOCK-END +# flow_sequence ::= FLOW-SEQUENCE-START +# (flow_sequence_entry FLOW-ENTRY)* +# flow_sequence_entry? +# FLOW-SEQUENCE-END +# flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +# flow_mapping ::= FLOW-MAPPING-START +# (flow_mapping_entry FLOW-ENTRY)* +# flow_mapping_entry? +# FLOW-MAPPING-END +# flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +# +# FIRST sets: +# +# stream: { STREAM-START } +# explicit_document: { DIRECTIVE DOCUMENT-START } +# implicit_document: FIRST(block_node) +# block_node: { ALIAS TAG ANCHOR SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START } +# flow_node: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START } +# block_content: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR } +# flow_content: { FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR } +# block_collection: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START } +# flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START } +# block_sequence: { BLOCK-SEQUENCE-START } +# block_mapping: { BLOCK-MAPPING-START } +# block_node_or_indentless_sequence: { ALIAS ANCHOR TAG SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START BLOCK-ENTRY } +# indentless_sequence: { ENTRY } +# flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START } +# flow_sequence: { FLOW-SEQUENCE-START } +# flow_mapping: { FLOW-MAPPING-START } +# flow_sequence_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY } +# flow_mapping_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY } + +__all__ = ['Parser', 'ParserError'] + +from .error import MarkedYAMLError +from .tokens import * +from .events import * +from .scanner import * + +class ParserError(MarkedYAMLError): + pass + +class Parser: + # Since writing a recursive-descendant parser is a straightforward task, we + # do not give many comments here. + + DEFAULT_TAGS = { + '!': '!', + '!!': 'tag:yaml.org,2002:', + } + + def __init__(self): + self.current_event = None + self.yaml_version = None + self.tag_handles = {} + self.states = [] + self.marks = [] + self.state = self.parse_stream_start + + def dispose(self): + # Reset the state attributes (to clear self-references) + self.states = [] + self.state = None + + def check_event(self, *choices): + # Check the type of the next event. + if self.current_event is None: + if self.state: + self.current_event = self.state() + if self.current_event is not None: + if not choices: + return True + for choice in choices: + if isinstance(self.current_event, choice): + return True + return False + + def peek_event(self): + # Get the next event. + if self.current_event is None: + if self.state: + self.current_event = self.state() + return self.current_event + + def get_event(self): + # Get the next event and proceed further. + if self.current_event is None: + if self.state: + self.current_event = self.state() + value = self.current_event + self.current_event = None + return value + + # stream ::= STREAM-START implicit_document? explicit_document* STREAM-END + # implicit_document ::= block_node DOCUMENT-END* + # explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* + + def parse_stream_start(self): + + # Parse the stream start. + token = self.get_token() + event = StreamStartEvent(token.start_mark, token.end_mark, + encoding=token.encoding) + + # Prepare the next state. + self.state = self.parse_implicit_document_start + + return event + + def parse_implicit_document_start(self): + + # Parse an implicit document. + if not self.check_token(DirectiveToken, DocumentStartToken, + StreamEndToken): + self.tag_handles = self.DEFAULT_TAGS + token = self.peek_token() + start_mark = end_mark = token.start_mark + event = DocumentStartEvent(start_mark, end_mark, + explicit=False) + + # Prepare the next state. + self.states.append(self.parse_document_end) + self.state = self.parse_block_node + + return event + + else: + return self.parse_document_start() + + def parse_document_start(self): + + # Parse any extra document end indicators. + while self.check_token(DocumentEndToken): + self.get_token() + + # Parse an explicit document. + if not self.check_token(StreamEndToken): + token = self.peek_token() + start_mark = token.start_mark + version, tags = self.process_directives() + if not self.check_token(DocumentStartToken): + raise ParserError(None, None, + "expected '', but found %r" + % self.peek_token().id, + self.peek_token().start_mark) + token = self.get_token() + end_mark = token.end_mark + event = DocumentStartEvent(start_mark, end_mark, + explicit=True, version=version, tags=tags) + self.states.append(self.parse_document_end) + self.state = self.parse_document_content + else: + # Parse the end of the stream. + token = self.get_token() + event = StreamEndEvent(token.start_mark, token.end_mark) + assert not self.states + assert not self.marks + self.state = None + return event + + def parse_document_end(self): + + # Parse the document end. + token = self.peek_token() + start_mark = end_mark = token.start_mark + explicit = False + if self.check_token(DocumentEndToken): + token = self.get_token() + end_mark = token.end_mark + explicit = True + event = DocumentEndEvent(start_mark, end_mark, + explicit=explicit) + + # Prepare the next state. + self.state = self.parse_document_start + + return event + + def parse_document_content(self): + if self.check_token(DirectiveToken, + DocumentStartToken, DocumentEndToken, StreamEndToken): + event = self.process_empty_scalar(self.peek_token().start_mark) + self.state = self.states.pop() + return event + else: + return self.parse_block_node() + + def process_directives(self): + self.yaml_version = None + self.tag_handles = {} + while self.check_token(DirectiveToken): + token = self.get_token() + if token.name == 'YAML': + if self.yaml_version is not None: + raise ParserError(None, None, + "found duplicate YAML directive", token.start_mark) + major, minor = token.value + if major != 1: + raise ParserError(None, None, + "found incompatible YAML document (version 1.* is required)", + token.start_mark) + self.yaml_version = token.value + elif token.name == 'TAG': + handle, prefix = token.value + if handle in self.tag_handles: + raise ParserError(None, None, + "duplicate tag handle %r" % handle, + token.start_mark) + self.tag_handles[handle] = prefix + if self.tag_handles: + value = self.yaml_version, self.tag_handles.copy() + else: + value = self.yaml_version, None + for key in self.DEFAULT_TAGS: + if key not in self.tag_handles: + self.tag_handles[key] = self.DEFAULT_TAGS[key] + return value + + # block_node_or_indentless_sequence ::= ALIAS + # | properties (block_content | indentless_block_sequence)? + # | block_content + # | indentless_block_sequence + # block_node ::= ALIAS + # | properties block_content? + # | block_content + # flow_node ::= ALIAS + # | properties flow_content? + # | flow_content + # properties ::= TAG ANCHOR? | ANCHOR TAG? + # block_content ::= block_collection | flow_collection | SCALAR + # flow_content ::= flow_collection | SCALAR + # block_collection ::= block_sequence | block_mapping + # flow_collection ::= flow_sequence | flow_mapping + + def parse_block_node(self): + return self.parse_node(block=True) + + def parse_flow_node(self): + return self.parse_node() + + def parse_block_node_or_indentless_sequence(self): + return self.parse_node(block=True, indentless_sequence=True) + + def parse_node(self, block=False, indentless_sequence=False): + if self.check_token(AliasToken): + token = self.get_token() + event = AliasEvent(token.value, token.start_mark, token.end_mark) + self.state = self.states.pop() + else: + anchor = None + tag = None + start_mark = end_mark = tag_mark = None + if self.check_token(AnchorToken): + token = self.get_token() + start_mark = token.start_mark + end_mark = token.end_mark + anchor = token.value + if self.check_token(TagToken): + token = self.get_token() + tag_mark = token.start_mark + end_mark = token.end_mark + tag = token.value + elif self.check_token(TagToken): + token = self.get_token() + start_mark = tag_mark = token.start_mark + end_mark = token.end_mark + tag = token.value + if self.check_token(AnchorToken): + token = self.get_token() + end_mark = token.end_mark + anchor = token.value + if tag is not None: + handle, suffix = tag + if handle is not None: + if handle not in self.tag_handles: + raise ParserError("while parsing a node", start_mark, + "found undefined tag handle %r" % handle, + tag_mark) + tag = self.tag_handles[handle]+suffix + else: + tag = suffix + #if tag == '!': + # raise ParserError("while parsing a node", start_mark, + # "found non-specific tag '!'", tag_mark, + # "Please check 'http://pyyaml.org/wiki/YAMLNonSpecificTag' and share your opinion.") + if start_mark is None: + start_mark = end_mark = self.peek_token().start_mark + event = None + implicit = (tag is None or tag == '!') + if indentless_sequence and self.check_token(BlockEntryToken): + end_mark = self.peek_token().end_mark + event = SequenceStartEvent(anchor, tag, implicit, + start_mark, end_mark) + self.state = self.parse_indentless_sequence_entry + else: + if self.check_token(ScalarToken): + token = self.get_token() + end_mark = token.end_mark + if (token.plain and tag is None) or tag == '!': + implicit = (True, False) + elif tag is None: + implicit = (False, True) + else: + implicit = (False, False) + event = ScalarEvent(anchor, tag, implicit, token.value, + start_mark, end_mark, style=token.style) + self.state = self.states.pop() + elif self.check_token(FlowSequenceStartToken): + end_mark = self.peek_token().end_mark + event = SequenceStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style=True) + self.state = self.parse_flow_sequence_first_entry + elif self.check_token(FlowMappingStartToken): + end_mark = self.peek_token().end_mark + event = MappingStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style=True) + self.state = self.parse_flow_mapping_first_key + elif block and self.check_token(BlockSequenceStartToken): + end_mark = self.peek_token().start_mark + event = SequenceStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style=False) + self.state = self.parse_block_sequence_first_entry + elif block and self.check_token(BlockMappingStartToken): + end_mark = self.peek_token().start_mark + event = MappingStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style=False) + self.state = self.parse_block_mapping_first_key + elif anchor is not None or tag is not None: + # Empty scalars are allowed even if a tag or an anchor is + # specified. + event = ScalarEvent(anchor, tag, (implicit, False), '', + start_mark, end_mark) + self.state = self.states.pop() + else: + if block: + node = 'block' + else: + node = 'flow' + token = self.peek_token() + raise ParserError("while parsing a %s node" % node, start_mark, + "expected the node content, but found %r" % token.id, + token.start_mark) + return event + + # block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END + + def parse_block_sequence_first_entry(self): + token = self.get_token() + self.marks.append(token.start_mark) + return self.parse_block_sequence_entry() + + def parse_block_sequence_entry(self): + if self.check_token(BlockEntryToken): + token = self.get_token() + if not self.check_token(BlockEntryToken, BlockEndToken): + self.states.append(self.parse_block_sequence_entry) + return self.parse_block_node() + else: + self.state = self.parse_block_sequence_entry + return self.process_empty_scalar(token.end_mark) + if not self.check_token(BlockEndToken): + token = self.peek_token() + raise ParserError("while parsing a block collection", self.marks[-1], + "expected , but found %r" % token.id, token.start_mark) + token = self.get_token() + event = SequenceEndEvent(token.start_mark, token.end_mark) + self.state = self.states.pop() + self.marks.pop() + return event + + # indentless_sequence ::= (BLOCK-ENTRY block_node?)+ + + def parse_indentless_sequence_entry(self): + if self.check_token(BlockEntryToken): + token = self.get_token() + if not self.check_token(BlockEntryToken, + KeyToken, ValueToken, BlockEndToken): + self.states.append(self.parse_indentless_sequence_entry) + return self.parse_block_node() + else: + self.state = self.parse_indentless_sequence_entry + return self.process_empty_scalar(token.end_mark) + token = self.peek_token() + event = SequenceEndEvent(token.start_mark, token.start_mark) + self.state = self.states.pop() + return event + + # block_mapping ::= BLOCK-MAPPING_START + # ((KEY block_node_or_indentless_sequence?)? + # (VALUE block_node_or_indentless_sequence?)?)* + # BLOCK-END + + def parse_block_mapping_first_key(self): + token = self.get_token() + self.marks.append(token.start_mark) + return self.parse_block_mapping_key() + + def parse_block_mapping_key(self): + if self.check_token(KeyToken): + token = self.get_token() + if not self.check_token(KeyToken, ValueToken, BlockEndToken): + self.states.append(self.parse_block_mapping_value) + return self.parse_block_node_or_indentless_sequence() + else: + self.state = self.parse_block_mapping_value + return self.process_empty_scalar(token.end_mark) + if not self.check_token(BlockEndToken): + token = self.peek_token() + raise ParserError("while parsing a block mapping", self.marks[-1], + "expected , but found %r" % token.id, token.start_mark) + token = self.get_token() + event = MappingEndEvent(token.start_mark, token.end_mark) + self.state = self.states.pop() + self.marks.pop() + return event + + def parse_block_mapping_value(self): + if self.check_token(ValueToken): + token = self.get_token() + if not self.check_token(KeyToken, ValueToken, BlockEndToken): + self.states.append(self.parse_block_mapping_key) + return self.parse_block_node_or_indentless_sequence() + else: + self.state = self.parse_block_mapping_key + return self.process_empty_scalar(token.end_mark) + else: + self.state = self.parse_block_mapping_key + token = self.peek_token() + return self.process_empty_scalar(token.start_mark) + + # flow_sequence ::= FLOW-SEQUENCE-START + # (flow_sequence_entry FLOW-ENTRY)* + # flow_sequence_entry? + # FLOW-SEQUENCE-END + # flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + # + # Note that while production rules for both flow_sequence_entry and + # flow_mapping_entry are equal, their interpretations are different. + # For `flow_sequence_entry`, the part `KEY flow_node? (VALUE flow_node?)?` + # generate an inline mapping (set syntax). + + def parse_flow_sequence_first_entry(self): + token = self.get_token() + self.marks.append(token.start_mark) + return self.parse_flow_sequence_entry(first=True) + + def parse_flow_sequence_entry(self, first=False): + if not self.check_token(FlowSequenceEndToken): + if not first: + if self.check_token(FlowEntryToken): + self.get_token() + else: + token = self.peek_token() + raise ParserError("while parsing a flow sequence", self.marks[-1], + "expected ',' or ']', but got %r" % token.id, token.start_mark) + + if self.check_token(KeyToken): + token = self.peek_token() + event = MappingStartEvent(None, None, True, + token.start_mark, token.end_mark, + flow_style=True) + self.state = self.parse_flow_sequence_entry_mapping_key + return event + elif not self.check_token(FlowSequenceEndToken): + self.states.append(self.parse_flow_sequence_entry) + return self.parse_flow_node() + token = self.get_token() + event = SequenceEndEvent(token.start_mark, token.end_mark) + self.state = self.states.pop() + self.marks.pop() + return event + + def parse_flow_sequence_entry_mapping_key(self): + token = self.get_token() + if not self.check_token(ValueToken, + FlowEntryToken, FlowSequenceEndToken): + self.states.append(self.parse_flow_sequence_entry_mapping_value) + return self.parse_flow_node() + else: + self.state = self.parse_flow_sequence_entry_mapping_value + return self.process_empty_scalar(token.end_mark) + + def parse_flow_sequence_entry_mapping_value(self): + if self.check_token(ValueToken): + token = self.get_token() + if not self.check_token(FlowEntryToken, FlowSequenceEndToken): + self.states.append(self.parse_flow_sequence_entry_mapping_end) + return self.parse_flow_node() + else: + self.state = self.parse_flow_sequence_entry_mapping_end + return self.process_empty_scalar(token.end_mark) + else: + self.state = self.parse_flow_sequence_entry_mapping_end + token = self.peek_token() + return self.process_empty_scalar(token.start_mark) + + def parse_flow_sequence_entry_mapping_end(self): + self.state = self.parse_flow_sequence_entry + token = self.peek_token() + return MappingEndEvent(token.start_mark, token.start_mark) + + # flow_mapping ::= FLOW-MAPPING-START + # (flow_mapping_entry FLOW-ENTRY)* + # flow_mapping_entry? + # FLOW-MAPPING-END + # flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + + def parse_flow_mapping_first_key(self): + token = self.get_token() + self.marks.append(token.start_mark) + return self.parse_flow_mapping_key(first=True) + + def parse_flow_mapping_key(self, first=False): + if not self.check_token(FlowMappingEndToken): + if not first: + if self.check_token(FlowEntryToken): + self.get_token() + else: + token = self.peek_token() + raise ParserError("while parsing a flow mapping", self.marks[-1], + "expected ',' or '}', but got %r" % token.id, token.start_mark) + if self.check_token(KeyToken): + token = self.get_token() + if not self.check_token(ValueToken, + FlowEntryToken, FlowMappingEndToken): + self.states.append(self.parse_flow_mapping_value) + return self.parse_flow_node() + else: + self.state = self.parse_flow_mapping_value + return self.process_empty_scalar(token.end_mark) + elif not self.check_token(FlowMappingEndToken): + self.states.append(self.parse_flow_mapping_empty_value) + return self.parse_flow_node() + token = self.get_token() + event = MappingEndEvent(token.start_mark, token.end_mark) + self.state = self.states.pop() + self.marks.pop() + return event + + def parse_flow_mapping_value(self): + if self.check_token(ValueToken): + token = self.get_token() + if not self.check_token(FlowEntryToken, FlowMappingEndToken): + self.states.append(self.parse_flow_mapping_key) + return self.parse_flow_node() + else: + self.state = self.parse_flow_mapping_key + return self.process_empty_scalar(token.end_mark) + else: + self.state = self.parse_flow_mapping_key + token = self.peek_token() + return self.process_empty_scalar(token.start_mark) + + def parse_flow_mapping_empty_value(self): + self.state = self.parse_flow_mapping_key + return self.process_empty_scalar(self.peek_token().start_mark) + + def process_empty_scalar(self, mark): + return ScalarEvent(None, None, (True, False), '', mark, mark) + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/reader.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/reader.py new file mode 100644 index 0000000000000000000000000000000000000000..774b0219b5932a0ee1c27e637371de5ba8d9cb16 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/reader.py @@ -0,0 +1,185 @@ +# This module contains abstractions for the input stream. You don't have to +# looks further, there are no pretty code. +# +# We define two classes here. +# +# Mark(source, line, column) +# It's just a record and its only use is producing nice error messages. +# Parser does not use it for any other purposes. +# +# Reader(source, data) +# Reader determines the encoding of `data` and converts it to unicode. +# Reader provides the following methods and attributes: +# reader.peek(length=1) - return the next `length` characters +# reader.forward(length=1) - move the current position to `length` characters. +# reader.index - the number of the current character. +# reader.line, stream.column - the line and the column of the current character. + +__all__ = ['Reader', 'ReaderError'] + +from .error import YAMLError, Mark + +import codecs, re + +class ReaderError(YAMLError): + + def __init__(self, name, position, character, encoding, reason): + self.name = name + self.character = character + self.position = position + self.encoding = encoding + self.reason = reason + + def __str__(self): + if isinstance(self.character, bytes): + return "'%s' codec can't decode byte #x%02x: %s\n" \ + " in \"%s\", position %d" \ + % (self.encoding, ord(self.character), self.reason, + self.name, self.position) + else: + return "unacceptable character #x%04x: %s\n" \ + " in \"%s\", position %d" \ + % (self.character, self.reason, + self.name, self.position) + +class Reader(object): + # Reader: + # - determines the data encoding and converts it to a unicode string, + # - checks if characters are in allowed range, + # - adds '\0' to the end. + + # Reader accepts + # - a `bytes` object, + # - a `str` object, + # - a file-like object with its `read` method returning `str`, + # - a file-like object with its `read` method returning `unicode`. + + # Yeah, it's ugly and slow. + + def __init__(self, stream): + self.name = None + self.stream = None + self.stream_pointer = 0 + self.eof = True + self.buffer = '' + self.pointer = 0 + self.raw_buffer = None + self.raw_decode = None + self.encoding = None + self.index = 0 + self.line = 0 + self.column = 0 + if isinstance(stream, str): + self.name = "" + self.check_printable(stream) + self.buffer = stream+'\0' + elif isinstance(stream, bytes): + self.name = "" + self.raw_buffer = stream + self.determine_encoding() + else: + self.stream = stream + self.name = getattr(stream, 'name', "") + self.eof = False + self.raw_buffer = None + self.determine_encoding() + + def peek(self, index=0): + try: + return self.buffer[self.pointer+index] + except IndexError: + self.update(index+1) + return self.buffer[self.pointer+index] + + def prefix(self, length=1): + if self.pointer+length >= len(self.buffer): + self.update(length) + return self.buffer[self.pointer:self.pointer+length] + + def forward(self, length=1): + if self.pointer+length+1 >= len(self.buffer): + self.update(length+1) + while length: + ch = self.buffer[self.pointer] + self.pointer += 1 + self.index += 1 + if ch in '\n\x85\u2028\u2029' \ + or (ch == '\r' and self.buffer[self.pointer] != '\n'): + self.line += 1 + self.column = 0 + elif ch != '\uFEFF': + self.column += 1 + length -= 1 + + def get_mark(self): + if self.stream is None: + return Mark(self.name, self.index, self.line, self.column, + self.buffer, self.pointer) + else: + return Mark(self.name, self.index, self.line, self.column, + None, None) + + def determine_encoding(self): + while not self.eof and (self.raw_buffer is None or len(self.raw_buffer) < 2): + self.update_raw() + if isinstance(self.raw_buffer, bytes): + if self.raw_buffer.startswith(codecs.BOM_UTF16_LE): + self.raw_decode = codecs.utf_16_le_decode + self.encoding = 'utf-16-le' + elif self.raw_buffer.startswith(codecs.BOM_UTF16_BE): + self.raw_decode = codecs.utf_16_be_decode + self.encoding = 'utf-16-be' + else: + self.raw_decode = codecs.utf_8_decode + self.encoding = 'utf-8' + self.update(1) + + NON_PRINTABLE = re.compile('[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD\U00010000-\U0010ffff]') + def check_printable(self, data): + match = self.NON_PRINTABLE.search(data) + if match: + character = match.group() + position = self.index+(len(self.buffer)-self.pointer)+match.start() + raise ReaderError(self.name, position, ord(character), + 'unicode', "special characters are not allowed") + + def update(self, length): + if self.raw_buffer is None: + return + self.buffer = self.buffer[self.pointer:] + self.pointer = 0 + while len(self.buffer) < length: + if not self.eof: + self.update_raw() + if self.raw_decode is not None: + try: + data, converted = self.raw_decode(self.raw_buffer, + 'strict', self.eof) + except UnicodeDecodeError as exc: + character = self.raw_buffer[exc.start] + if self.stream is not None: + position = self.stream_pointer-len(self.raw_buffer)+exc.start + else: + position = exc.start + raise ReaderError(self.name, position, character, + exc.encoding, exc.reason) + else: + data = self.raw_buffer + converted = len(data) + self.check_printable(data) + self.buffer += data + self.raw_buffer = self.raw_buffer[converted:] + if self.eof: + self.buffer += '\0' + self.raw_buffer = None + break + + def update_raw(self, size=4096): + data = self.stream.read(size) + if self.raw_buffer is None: + self.raw_buffer = data + else: + self.raw_buffer += data + self.stream_pointer += len(data) + if not data: + self.eof = True diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/representer.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/representer.py new file mode 100644 index 0000000000000000000000000000000000000000..808ca06dfbd60c9a23eb079151b74a82ef688749 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/representer.py @@ -0,0 +1,389 @@ + +__all__ = ['BaseRepresenter', 'SafeRepresenter', 'Representer', + 'RepresenterError'] + +from .error import * +from .nodes import * + +import datetime, copyreg, types, base64, collections + +class RepresenterError(YAMLError): + pass + +class BaseRepresenter: + + yaml_representers = {} + yaml_multi_representers = {} + + def __init__(self, default_style=None, default_flow_style=False, sort_keys=True): + self.default_style = default_style + self.sort_keys = sort_keys + self.default_flow_style = default_flow_style + self.represented_objects = {} + self.object_keeper = [] + self.alias_key = None + + def represent(self, data): + node = self.represent_data(data) + self.serialize(node) + self.represented_objects = {} + self.object_keeper = [] + self.alias_key = None + + def represent_data(self, data): + if self.ignore_aliases(data): + self.alias_key = None + else: + self.alias_key = id(data) + if self.alias_key is not None: + if self.alias_key in self.represented_objects: + node = self.represented_objects[self.alias_key] + #if node is None: + # raise RepresenterError("recursive objects are not allowed: %r" % data) + return node + #self.represented_objects[alias_key] = None + self.object_keeper.append(data) + data_types = type(data).__mro__ + if data_types[0] in self.yaml_representers: + node = self.yaml_representers[data_types[0]](self, data) + else: + for data_type in data_types: + if data_type in self.yaml_multi_representers: + node = self.yaml_multi_representers[data_type](self, data) + break + else: + if None in self.yaml_multi_representers: + node = self.yaml_multi_representers[None](self, data) + elif None in self.yaml_representers: + node = self.yaml_representers[None](self, data) + else: + node = ScalarNode(None, str(data)) + #if alias_key is not None: + # self.represented_objects[alias_key] = node + return node + + @classmethod + def add_representer(cls, data_type, representer): + if not 'yaml_representers' in cls.__dict__: + cls.yaml_representers = cls.yaml_representers.copy() + cls.yaml_representers[data_type] = representer + + @classmethod + def add_multi_representer(cls, data_type, representer): + if not 'yaml_multi_representers' in cls.__dict__: + cls.yaml_multi_representers = cls.yaml_multi_representers.copy() + cls.yaml_multi_representers[data_type] = representer + + def represent_scalar(self, tag, value, style=None): + if style is None: + style = self.default_style + node = ScalarNode(tag, value, style=style) + if self.alias_key is not None: + self.represented_objects[self.alias_key] = node + return node + + def represent_sequence(self, tag, sequence, flow_style=None): + value = [] + node = SequenceNode(tag, value, flow_style=flow_style) + if self.alias_key is not None: + self.represented_objects[self.alias_key] = node + best_style = True + for item in sequence: + node_item = self.represent_data(item) + if not (isinstance(node_item, ScalarNode) and not node_item.style): + best_style = False + value.append(node_item) + if flow_style is None: + if self.default_flow_style is not None: + node.flow_style = self.default_flow_style + else: + node.flow_style = best_style + return node + + def represent_mapping(self, tag, mapping, flow_style=None): + value = [] + node = MappingNode(tag, value, flow_style=flow_style) + if self.alias_key is not None: + self.represented_objects[self.alias_key] = node + best_style = True + if hasattr(mapping, 'items'): + mapping = list(mapping.items()) + if self.sort_keys: + try: + mapping = sorted(mapping) + except TypeError: + pass + for item_key, item_value in mapping: + node_key = self.represent_data(item_key) + node_value = self.represent_data(item_value) + if not (isinstance(node_key, ScalarNode) and not node_key.style): + best_style = False + if not (isinstance(node_value, ScalarNode) and not node_value.style): + best_style = False + value.append((node_key, node_value)) + if flow_style is None: + if self.default_flow_style is not None: + node.flow_style = self.default_flow_style + else: + node.flow_style = best_style + return node + + def ignore_aliases(self, data): + return False + +class SafeRepresenter(BaseRepresenter): + + def ignore_aliases(self, data): + if data is None: + return True + if isinstance(data, tuple) and data == (): + return True + if isinstance(data, (str, bytes, bool, int, float)): + return True + + def represent_none(self, data): + return self.represent_scalar('tag:yaml.org,2002:null', 'null') + + def represent_str(self, data): + return self.represent_scalar('tag:yaml.org,2002:str', data) + + def represent_binary(self, data): + if hasattr(base64, 'encodebytes'): + data = base64.encodebytes(data).decode('ascii') + else: + data = base64.encodestring(data).decode('ascii') + return self.represent_scalar('tag:yaml.org,2002:binary', data, style='|') + + def represent_bool(self, data): + if data: + value = 'true' + else: + value = 'false' + return self.represent_scalar('tag:yaml.org,2002:bool', value) + + def represent_int(self, data): + return self.represent_scalar('tag:yaml.org,2002:int', str(data)) + + inf_value = 1e300 + while repr(inf_value) != repr(inf_value*inf_value): + inf_value *= inf_value + + def represent_float(self, data): + if data != data or (data == 0.0 and data == 1.0): + value = '.nan' + elif data == self.inf_value: + value = '.inf' + elif data == -self.inf_value: + value = '-.inf' + else: + value = repr(data).lower() + # Note that in some cases `repr(data)` represents a float number + # without the decimal parts. For instance: + # >>> repr(1e17) + # '1e17' + # Unfortunately, this is not a valid float representation according + # to the definition of the `!!float` tag. We fix this by adding + # '.0' before the 'e' symbol. + if '.' not in value and 'e' in value: + value = value.replace('e', '.0e', 1) + return self.represent_scalar('tag:yaml.org,2002:float', value) + + def represent_list(self, data): + #pairs = (len(data) > 0 and isinstance(data, list)) + #if pairs: + # for item in data: + # if not isinstance(item, tuple) or len(item) != 2: + # pairs = False + # break + #if not pairs: + return self.represent_sequence('tag:yaml.org,2002:seq', data) + #value = [] + #for item_key, item_value in data: + # value.append(self.represent_mapping(u'tag:yaml.org,2002:map', + # [(item_key, item_value)])) + #return SequenceNode(u'tag:yaml.org,2002:pairs', value) + + def represent_dict(self, data): + return self.represent_mapping('tag:yaml.org,2002:map', data) + + def represent_set(self, data): + value = {} + for key in data: + value[key] = None + return self.represent_mapping('tag:yaml.org,2002:set', value) + + def represent_date(self, data): + value = data.isoformat() + return self.represent_scalar('tag:yaml.org,2002:timestamp', value) + + def represent_datetime(self, data): + value = data.isoformat(' ') + return self.represent_scalar('tag:yaml.org,2002:timestamp', value) + + def represent_yaml_object(self, tag, data, cls, flow_style=None): + if hasattr(data, '__getstate__'): + state = data.__getstate__() + else: + state = data.__dict__.copy() + return self.represent_mapping(tag, state, flow_style=flow_style) + + def represent_undefined(self, data): + raise RepresenterError("cannot represent an object", data) + +SafeRepresenter.add_representer(type(None), + SafeRepresenter.represent_none) + +SafeRepresenter.add_representer(str, + SafeRepresenter.represent_str) + +SafeRepresenter.add_representer(bytes, + SafeRepresenter.represent_binary) + +SafeRepresenter.add_representer(bool, + SafeRepresenter.represent_bool) + +SafeRepresenter.add_representer(int, + SafeRepresenter.represent_int) + +SafeRepresenter.add_representer(float, + SafeRepresenter.represent_float) + +SafeRepresenter.add_representer(list, + SafeRepresenter.represent_list) + +SafeRepresenter.add_representer(tuple, + SafeRepresenter.represent_list) + +SafeRepresenter.add_representer(dict, + SafeRepresenter.represent_dict) + +SafeRepresenter.add_representer(set, + SafeRepresenter.represent_set) + +SafeRepresenter.add_representer(datetime.date, + SafeRepresenter.represent_date) + +SafeRepresenter.add_representer(datetime.datetime, + SafeRepresenter.represent_datetime) + +SafeRepresenter.add_representer(None, + SafeRepresenter.represent_undefined) + +class Representer(SafeRepresenter): + + def represent_complex(self, data): + if data.imag == 0.0: + data = '%r' % data.real + elif data.real == 0.0: + data = '%rj' % data.imag + elif data.imag > 0: + data = '%r+%rj' % (data.real, data.imag) + else: + data = '%r%rj' % (data.real, data.imag) + return self.represent_scalar('tag:yaml.org,2002:python/complex', data) + + def represent_tuple(self, data): + return self.represent_sequence('tag:yaml.org,2002:python/tuple', data) + + def represent_name(self, data): + name = '%s.%s' % (data.__module__, data.__name__) + return self.represent_scalar('tag:yaml.org,2002:python/name:'+name, '') + + def represent_module(self, data): + return self.represent_scalar( + 'tag:yaml.org,2002:python/module:'+data.__name__, '') + + def represent_object(self, data): + # We use __reduce__ API to save the data. data.__reduce__ returns + # a tuple of length 2-5: + # (function, args, state, listitems, dictitems) + + # For reconstructing, we calls function(*args), then set its state, + # listitems, and dictitems if they are not None. + + # A special case is when function.__name__ == '__newobj__'. In this + # case we create the object with args[0].__new__(*args). + + # Another special case is when __reduce__ returns a string - we don't + # support it. + + # We produce a !!python/object, !!python/object/new or + # !!python/object/apply node. + + cls = type(data) + if cls in copyreg.dispatch_table: + reduce = copyreg.dispatch_table[cls](data) + elif hasattr(data, '__reduce_ex__'): + reduce = data.__reduce_ex__(2) + elif hasattr(data, '__reduce__'): + reduce = data.__reduce__() + else: + raise RepresenterError("cannot represent an object", data) + reduce = (list(reduce)+[None]*5)[:5] + function, args, state, listitems, dictitems = reduce + args = list(args) + if state is None: + state = {} + if listitems is not None: + listitems = list(listitems) + if dictitems is not None: + dictitems = dict(dictitems) + if function.__name__ == '__newobj__': + function = args[0] + args = args[1:] + tag = 'tag:yaml.org,2002:python/object/new:' + newobj = True + else: + tag = 'tag:yaml.org,2002:python/object/apply:' + newobj = False + function_name = '%s.%s' % (function.__module__, function.__name__) + if not args and not listitems and not dictitems \ + and isinstance(state, dict) and newobj: + return self.represent_mapping( + 'tag:yaml.org,2002:python/object:'+function_name, state) + if not listitems and not dictitems \ + and isinstance(state, dict) and not state: + return self.represent_sequence(tag+function_name, args) + value = {} + if args: + value['args'] = args + if state or not isinstance(state, dict): + value['state'] = state + if listitems: + value['listitems'] = listitems + if dictitems: + value['dictitems'] = dictitems + return self.represent_mapping(tag+function_name, value) + + def represent_ordered_dict(self, data): + # Provide uniform representation across different Python versions. + data_type = type(data) + tag = 'tag:yaml.org,2002:python/object/apply:%s.%s' \ + % (data_type.__module__, data_type.__name__) + items = [[key, value] for key, value in data.items()] + return self.represent_sequence(tag, [items]) + +Representer.add_representer(complex, + Representer.represent_complex) + +Representer.add_representer(tuple, + Representer.represent_tuple) + +Representer.add_multi_representer(type, + Representer.represent_name) + +Representer.add_representer(collections.OrderedDict, + Representer.represent_ordered_dict) + +Representer.add_representer(types.FunctionType, + Representer.represent_name) + +Representer.add_representer(types.BuiltinFunctionType, + Representer.represent_name) + +Representer.add_representer(types.ModuleType, + Representer.represent_module) + +Representer.add_multi_representer(object, + Representer.represent_object) + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/resolver.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/resolver.py new file mode 100644 index 0000000000000000000000000000000000000000..3522bdaaf6358110b608f4e6503b9d314c82d887 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/resolver.py @@ -0,0 +1,227 @@ + +__all__ = ['BaseResolver', 'Resolver'] + +from .error import * +from .nodes import * + +import re + +class ResolverError(YAMLError): + pass + +class BaseResolver: + + DEFAULT_SCALAR_TAG = 'tag:yaml.org,2002:str' + DEFAULT_SEQUENCE_TAG = 'tag:yaml.org,2002:seq' + DEFAULT_MAPPING_TAG = 'tag:yaml.org,2002:map' + + yaml_implicit_resolvers = {} + yaml_path_resolvers = {} + + def __init__(self): + self.resolver_exact_paths = [] + self.resolver_prefix_paths = [] + + @classmethod + def add_implicit_resolver(cls, tag, regexp, first): + if not 'yaml_implicit_resolvers' in cls.__dict__: + implicit_resolvers = {} + for key in cls.yaml_implicit_resolvers: + implicit_resolvers[key] = cls.yaml_implicit_resolvers[key][:] + cls.yaml_implicit_resolvers = implicit_resolvers + if first is None: + first = [None] + for ch in first: + cls.yaml_implicit_resolvers.setdefault(ch, []).append((tag, regexp)) + + @classmethod + def add_path_resolver(cls, tag, path, kind=None): + # Note: `add_path_resolver` is experimental. The API could be changed. + # `new_path` is a pattern that is matched against the path from the + # root to the node that is being considered. `node_path` elements are + # tuples `(node_check, index_check)`. `node_check` is a node class: + # `ScalarNode`, `SequenceNode`, `MappingNode` or `None`. `None` + # matches any kind of a node. `index_check` could be `None`, a boolean + # value, a string value, or a number. `None` and `False` match against + # any _value_ of sequence and mapping nodes. `True` matches against + # any _key_ of a mapping node. A string `index_check` matches against + # a mapping value that corresponds to a scalar key which content is + # equal to the `index_check` value. An integer `index_check` matches + # against a sequence value with the index equal to `index_check`. + if not 'yaml_path_resolvers' in cls.__dict__: + cls.yaml_path_resolvers = cls.yaml_path_resolvers.copy() + new_path = [] + for element in path: + if isinstance(element, (list, tuple)): + if len(element) == 2: + node_check, index_check = element + elif len(element) == 1: + node_check = element[0] + index_check = True + else: + raise ResolverError("Invalid path element: %s" % element) + else: + node_check = None + index_check = element + if node_check is str: + node_check = ScalarNode + elif node_check is list: + node_check = SequenceNode + elif node_check is dict: + node_check = MappingNode + elif node_check not in [ScalarNode, SequenceNode, MappingNode] \ + and not isinstance(node_check, str) \ + and node_check is not None: + raise ResolverError("Invalid node checker: %s" % node_check) + if not isinstance(index_check, (str, int)) \ + and index_check is not None: + raise ResolverError("Invalid index checker: %s" % index_check) + new_path.append((node_check, index_check)) + if kind is str: + kind = ScalarNode + elif kind is list: + kind = SequenceNode + elif kind is dict: + kind = MappingNode + elif kind not in [ScalarNode, SequenceNode, MappingNode] \ + and kind is not None: + raise ResolverError("Invalid node kind: %s" % kind) + cls.yaml_path_resolvers[tuple(new_path), kind] = tag + + def descend_resolver(self, current_node, current_index): + if not self.yaml_path_resolvers: + return + exact_paths = {} + prefix_paths = [] + if current_node: + depth = len(self.resolver_prefix_paths) + for path, kind in self.resolver_prefix_paths[-1]: + if self.check_resolver_prefix(depth, path, kind, + current_node, current_index): + if len(path) > depth: + prefix_paths.append((path, kind)) + else: + exact_paths[kind] = self.yaml_path_resolvers[path, kind] + else: + for path, kind in self.yaml_path_resolvers: + if not path: + exact_paths[kind] = self.yaml_path_resolvers[path, kind] + else: + prefix_paths.append((path, kind)) + self.resolver_exact_paths.append(exact_paths) + self.resolver_prefix_paths.append(prefix_paths) + + def ascend_resolver(self): + if not self.yaml_path_resolvers: + return + self.resolver_exact_paths.pop() + self.resolver_prefix_paths.pop() + + def check_resolver_prefix(self, depth, path, kind, + current_node, current_index): + node_check, index_check = path[depth-1] + if isinstance(node_check, str): + if current_node.tag != node_check: + return + elif node_check is not None: + if not isinstance(current_node, node_check): + return + if index_check is True and current_index is not None: + return + if (index_check is False or index_check is None) \ + and current_index is None: + return + if isinstance(index_check, str): + if not (isinstance(current_index, ScalarNode) + and index_check == current_index.value): + return + elif isinstance(index_check, int) and not isinstance(index_check, bool): + if index_check != current_index: + return + return True + + def resolve(self, kind, value, implicit): + if kind is ScalarNode and implicit[0]: + if value == '': + resolvers = self.yaml_implicit_resolvers.get('', []) + else: + resolvers = self.yaml_implicit_resolvers.get(value[0], []) + wildcard_resolvers = self.yaml_implicit_resolvers.get(None, []) + for tag, regexp in resolvers + wildcard_resolvers: + if regexp.match(value): + return tag + implicit = implicit[1] + if self.yaml_path_resolvers: + exact_paths = self.resolver_exact_paths[-1] + if kind in exact_paths: + return exact_paths[kind] + if None in exact_paths: + return exact_paths[None] + if kind is ScalarNode: + return self.DEFAULT_SCALAR_TAG + elif kind is SequenceNode: + return self.DEFAULT_SEQUENCE_TAG + elif kind is MappingNode: + return self.DEFAULT_MAPPING_TAG + +class Resolver(BaseResolver): + pass + +Resolver.add_implicit_resolver( + 'tag:yaml.org,2002:bool', + re.compile(r'''^(?:yes|Yes|YES|no|No|NO + |true|True|TRUE|false|False|FALSE + |on|On|ON|off|Off|OFF)$''', re.X), + list('yYnNtTfFoO')) + +Resolver.add_implicit_resolver( + 'tag:yaml.org,2002:float', + re.compile(r'''^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)? + |\.[0-9][0-9_]*(?:[eE][-+][0-9]+)? + |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]* + |[-+]?\.(?:inf|Inf|INF) + |\.(?:nan|NaN|NAN))$''', re.X), + list('-+0123456789.')) + +Resolver.add_implicit_resolver( + 'tag:yaml.org,2002:int', + re.compile(r'''^(?:[-+]?0b[0-1_]+ + |[-+]?0[0-7_]+ + |[-+]?(?:0|[1-9][0-9_]*) + |[-+]?0x[0-9a-fA-F_]+ + |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$''', re.X), + list('-+0123456789')) + +Resolver.add_implicit_resolver( + 'tag:yaml.org,2002:merge', + re.compile(r'^(?:<<)$'), + ['<']) + +Resolver.add_implicit_resolver( + 'tag:yaml.org,2002:null', + re.compile(r'''^(?: ~ + |null|Null|NULL + | )$''', re.X), + ['~', 'n', 'N', '']) + +Resolver.add_implicit_resolver( + 'tag:yaml.org,2002:timestamp', + re.compile(r'''^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] + |[0-9][0-9][0-9][0-9] -[0-9][0-9]? -[0-9][0-9]? + (?:[Tt]|[ \t]+)[0-9][0-9]? + :[0-9][0-9] :[0-9][0-9] (?:\.[0-9]*)? + (?:[ \t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$''', re.X), + list('0123456789')) + +Resolver.add_implicit_resolver( + 'tag:yaml.org,2002:value', + re.compile(r'^(?:=)$'), + ['=']) + +# The following resolver is only for documentation purposes. It cannot work +# because plain scalars cannot start with '!', '&', or '*'. +Resolver.add_implicit_resolver( + 'tag:yaml.org,2002:yaml', + re.compile(r'^(?:!|&|\*)$'), + list('!&*')) + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/scanner.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/scanner.py new file mode 100644 index 0000000000000000000000000000000000000000..de925b07f1eaec33c9c305a8a69f9eb7ac5983c5 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/scanner.py @@ -0,0 +1,1435 @@ + +# Scanner produces tokens of the following types: +# STREAM-START +# STREAM-END +# DIRECTIVE(name, value) +# DOCUMENT-START +# DOCUMENT-END +# BLOCK-SEQUENCE-START +# BLOCK-MAPPING-START +# BLOCK-END +# FLOW-SEQUENCE-START +# FLOW-MAPPING-START +# FLOW-SEQUENCE-END +# FLOW-MAPPING-END +# BLOCK-ENTRY +# FLOW-ENTRY +# KEY +# VALUE +# ALIAS(value) +# ANCHOR(value) +# TAG(value) +# SCALAR(value, plain, style) +# +# Read comments in the Scanner code for more details. +# + +__all__ = ['Scanner', 'ScannerError'] + +from .error import MarkedYAMLError +from .tokens import * + +class ScannerError(MarkedYAMLError): + pass + +class SimpleKey: + # See below simple keys treatment. + + def __init__(self, token_number, required, index, line, column, mark): + self.token_number = token_number + self.required = required + self.index = index + self.line = line + self.column = column + self.mark = mark + +class Scanner: + + def __init__(self): + """Initialize the scanner.""" + # It is assumed that Scanner and Reader will have a common descendant. + # Reader do the dirty work of checking for BOM and converting the + # input data to Unicode. It also adds NUL to the end. + # + # Reader supports the following methods + # self.peek(i=0) # peek the next i-th character + # self.prefix(l=1) # peek the next l characters + # self.forward(l=1) # read the next l characters and move the pointer. + + # Had we reached the end of the stream? + self.done = False + + # The number of unclosed '{' and '['. `flow_level == 0` means block + # context. + self.flow_level = 0 + + # List of processed tokens that are not yet emitted. + self.tokens = [] + + # Add the STREAM-START token. + self.fetch_stream_start() + + # Number of tokens that were emitted through the `get_token` method. + self.tokens_taken = 0 + + # The current indentation level. + self.indent = -1 + + # Past indentation levels. + self.indents = [] + + # Variables related to simple keys treatment. + + # A simple key is a key that is not denoted by the '?' indicator. + # Example of simple keys: + # --- + # block simple key: value + # ? not a simple key: + # : { flow simple key: value } + # We emit the KEY token before all keys, so when we find a potential + # simple key, we try to locate the corresponding ':' indicator. + # Simple keys should be limited to a single line and 1024 characters. + + # Can a simple key start at the current position? A simple key may + # start: + # - at the beginning of the line, not counting indentation spaces + # (in block context), + # - after '{', '[', ',' (in the flow context), + # - after '?', ':', '-' (in the block context). + # In the block context, this flag also signifies if a block collection + # may start at the current position. + self.allow_simple_key = True + + # Keep track of possible simple keys. This is a dictionary. The key + # is `flow_level`; there can be no more that one possible simple key + # for each level. The value is a SimpleKey record: + # (token_number, required, index, line, column, mark) + # A simple key may start with ALIAS, ANCHOR, TAG, SCALAR(flow), + # '[', or '{' tokens. + self.possible_simple_keys = {} + + # Public methods. + + def check_token(self, *choices): + # Check if the next token is one of the given types. + while self.need_more_tokens(): + self.fetch_more_tokens() + if self.tokens: + if not choices: + return True + for choice in choices: + if isinstance(self.tokens[0], choice): + return True + return False + + def peek_token(self): + # Return the next token, but do not delete if from the queue. + # Return None if no more tokens. + while self.need_more_tokens(): + self.fetch_more_tokens() + if self.tokens: + return self.tokens[0] + else: + return None + + def get_token(self): + # Return the next token. + while self.need_more_tokens(): + self.fetch_more_tokens() + if self.tokens: + self.tokens_taken += 1 + return self.tokens.pop(0) + + # Private methods. + + def need_more_tokens(self): + if self.done: + return False + if not self.tokens: + return True + # The current token may be a potential simple key, so we + # need to look further. + self.stale_possible_simple_keys() + if self.next_possible_simple_key() == self.tokens_taken: + return True + + def fetch_more_tokens(self): + + # Eat whitespaces and comments until we reach the next token. + self.scan_to_next_token() + + # Remove obsolete possible simple keys. + self.stale_possible_simple_keys() + + # Compare the current indentation and column. It may add some tokens + # and decrease the current indentation level. + self.unwind_indent(self.column) + + # Peek the next character. + ch = self.peek() + + # Is it the end of stream? + if ch == '\0': + return self.fetch_stream_end() + + # Is it a directive? + if ch == '%' and self.check_directive(): + return self.fetch_directive() + + # Is it the document start? + if ch == '-' and self.check_document_start(): + return self.fetch_document_start() + + # Is it the document end? + if ch == '.' and self.check_document_end(): + return self.fetch_document_end() + + # TODO: support for BOM within a stream. + #if ch == '\uFEFF': + # return self.fetch_bom() <-- issue BOMToken + + # Note: the order of the following checks is NOT significant. + + # Is it the flow sequence start indicator? + if ch == '[': + return self.fetch_flow_sequence_start() + + # Is it the flow mapping start indicator? + if ch == '{': + return self.fetch_flow_mapping_start() + + # Is it the flow sequence end indicator? + if ch == ']': + return self.fetch_flow_sequence_end() + + # Is it the flow mapping end indicator? + if ch == '}': + return self.fetch_flow_mapping_end() + + # Is it the flow entry indicator? + if ch == ',': + return self.fetch_flow_entry() + + # Is it the block entry indicator? + if ch == '-' and self.check_block_entry(): + return self.fetch_block_entry() + + # Is it the key indicator? + if ch == '?' and self.check_key(): + return self.fetch_key() + + # Is it the value indicator? + if ch == ':' and self.check_value(): + return self.fetch_value() + + # Is it an alias? + if ch == '*': + return self.fetch_alias() + + # Is it an anchor? + if ch == '&': + return self.fetch_anchor() + + # Is it a tag? + if ch == '!': + return self.fetch_tag() + + # Is it a literal scalar? + if ch == '|' and not self.flow_level: + return self.fetch_literal() + + # Is it a folded scalar? + if ch == '>' and not self.flow_level: + return self.fetch_folded() + + # Is it a single quoted scalar? + if ch == '\'': + return self.fetch_single() + + # Is it a double quoted scalar? + if ch == '\"': + return self.fetch_double() + + # It must be a plain scalar then. + if self.check_plain(): + return self.fetch_plain() + + # No? It's an error. Let's produce a nice error message. + raise ScannerError("while scanning for the next token", None, + "found character %r that cannot start any token" % ch, + self.get_mark()) + + # Simple keys treatment. + + def next_possible_simple_key(self): + # Return the number of the nearest possible simple key. Actually we + # don't need to loop through the whole dictionary. We may replace it + # with the following code: + # if not self.possible_simple_keys: + # return None + # return self.possible_simple_keys[ + # min(self.possible_simple_keys.keys())].token_number + min_token_number = None + for level in self.possible_simple_keys: + key = self.possible_simple_keys[level] + if min_token_number is None or key.token_number < min_token_number: + min_token_number = key.token_number + return min_token_number + + def stale_possible_simple_keys(self): + # Remove entries that are no longer possible simple keys. According to + # the YAML specification, simple keys + # - should be limited to a single line, + # - should be no longer than 1024 characters. + # Disabling this procedure will allow simple keys of any length and + # height (may cause problems if indentation is broken though). + for level in list(self.possible_simple_keys): + key = self.possible_simple_keys[level] + if key.line != self.line \ + or self.index-key.index > 1024: + if key.required: + raise ScannerError("while scanning a simple key", key.mark, + "could not find expected ':'", self.get_mark()) + del self.possible_simple_keys[level] + + def save_possible_simple_key(self): + # The next token may start a simple key. We check if it's possible + # and save its position. This function is called for + # ALIAS, ANCHOR, TAG, SCALAR(flow), '[', and '{'. + + # Check if a simple key is required at the current position. + required = not self.flow_level and self.indent == self.column + + # The next token might be a simple key. Let's save it's number and + # position. + if self.allow_simple_key: + self.remove_possible_simple_key() + token_number = self.tokens_taken+len(self.tokens) + key = SimpleKey(token_number, required, + self.index, self.line, self.column, self.get_mark()) + self.possible_simple_keys[self.flow_level] = key + + def remove_possible_simple_key(self): + # Remove the saved possible key position at the current flow level. + if self.flow_level in self.possible_simple_keys: + key = self.possible_simple_keys[self.flow_level] + + if key.required: + raise ScannerError("while scanning a simple key", key.mark, + "could not find expected ':'", self.get_mark()) + + del self.possible_simple_keys[self.flow_level] + + # Indentation functions. + + def unwind_indent(self, column): + + ## In flow context, tokens should respect indentation. + ## Actually the condition should be `self.indent >= column` according to + ## the spec. But this condition will prohibit intuitively correct + ## constructions such as + ## key : { + ## } + #if self.flow_level and self.indent > column: + # raise ScannerError(None, None, + # "invalid indentation or unclosed '[' or '{'", + # self.get_mark()) + + # In the flow context, indentation is ignored. We make the scanner less + # restrictive then specification requires. + if self.flow_level: + return + + # In block context, we may need to issue the BLOCK-END tokens. + while self.indent > column: + mark = self.get_mark() + self.indent = self.indents.pop() + self.tokens.append(BlockEndToken(mark, mark)) + + def add_indent(self, column): + # Check if we need to increase indentation. + if self.indent < column: + self.indents.append(self.indent) + self.indent = column + return True + return False + + # Fetchers. + + def fetch_stream_start(self): + # We always add STREAM-START as the first token and STREAM-END as the + # last token. + + # Read the token. + mark = self.get_mark() + + # Add STREAM-START. + self.tokens.append(StreamStartToken(mark, mark, + encoding=self.encoding)) + + + def fetch_stream_end(self): + + # Set the current indentation to -1. + self.unwind_indent(-1) + + # Reset simple keys. + self.remove_possible_simple_key() + self.allow_simple_key = False + self.possible_simple_keys = {} + + # Read the token. + mark = self.get_mark() + + # Add STREAM-END. + self.tokens.append(StreamEndToken(mark, mark)) + + # The steam is finished. + self.done = True + + def fetch_directive(self): + + # Set the current indentation to -1. + self.unwind_indent(-1) + + # Reset simple keys. + self.remove_possible_simple_key() + self.allow_simple_key = False + + # Scan and add DIRECTIVE. + self.tokens.append(self.scan_directive()) + + def fetch_document_start(self): + self.fetch_document_indicator(DocumentStartToken) + + def fetch_document_end(self): + self.fetch_document_indicator(DocumentEndToken) + + def fetch_document_indicator(self, TokenClass): + + # Set the current indentation to -1. + self.unwind_indent(-1) + + # Reset simple keys. Note that there could not be a block collection + # after '---'. + self.remove_possible_simple_key() + self.allow_simple_key = False + + # Add DOCUMENT-START or DOCUMENT-END. + start_mark = self.get_mark() + self.forward(3) + end_mark = self.get_mark() + self.tokens.append(TokenClass(start_mark, end_mark)) + + def fetch_flow_sequence_start(self): + self.fetch_flow_collection_start(FlowSequenceStartToken) + + def fetch_flow_mapping_start(self): + self.fetch_flow_collection_start(FlowMappingStartToken) + + def fetch_flow_collection_start(self, TokenClass): + + # '[' and '{' may start a simple key. + self.save_possible_simple_key() + + # Increase the flow level. + self.flow_level += 1 + + # Simple keys are allowed after '[' and '{'. + self.allow_simple_key = True + + # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(TokenClass(start_mark, end_mark)) + + def fetch_flow_sequence_end(self): + self.fetch_flow_collection_end(FlowSequenceEndToken) + + def fetch_flow_mapping_end(self): + self.fetch_flow_collection_end(FlowMappingEndToken) + + def fetch_flow_collection_end(self, TokenClass): + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Decrease the flow level. + self.flow_level -= 1 + + # No simple keys after ']' or '}'. + self.allow_simple_key = False + + # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(TokenClass(start_mark, end_mark)) + + def fetch_flow_entry(self): + + # Simple keys are allowed after ','. + self.allow_simple_key = True + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Add FLOW-ENTRY. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(FlowEntryToken(start_mark, end_mark)) + + def fetch_block_entry(self): + + # Block context needs additional checks. + if not self.flow_level: + + # Are we allowed to start a new entry? + if not self.allow_simple_key: + raise ScannerError(None, None, + "sequence entries are not allowed here", + self.get_mark()) + + # We may need to add BLOCK-SEQUENCE-START. + if self.add_indent(self.column): + mark = self.get_mark() + self.tokens.append(BlockSequenceStartToken(mark, mark)) + + # It's an error for the block entry to occur in the flow context, + # but we let the parser detect this. + else: + pass + + # Simple keys are allowed after '-'. + self.allow_simple_key = True + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Add BLOCK-ENTRY. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(BlockEntryToken(start_mark, end_mark)) + + def fetch_key(self): + + # Block context needs additional checks. + if not self.flow_level: + + # Are we allowed to start a key (not necessary a simple)? + if not self.allow_simple_key: + raise ScannerError(None, None, + "mapping keys are not allowed here", + self.get_mark()) + + # We may need to add BLOCK-MAPPING-START. + if self.add_indent(self.column): + mark = self.get_mark() + self.tokens.append(BlockMappingStartToken(mark, mark)) + + # Simple keys are allowed after '?' in the block context. + self.allow_simple_key = not self.flow_level + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Add KEY. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(KeyToken(start_mark, end_mark)) + + def fetch_value(self): + + # Do we determine a simple key? + if self.flow_level in self.possible_simple_keys: + + # Add KEY. + key = self.possible_simple_keys[self.flow_level] + del self.possible_simple_keys[self.flow_level] + self.tokens.insert(key.token_number-self.tokens_taken, + KeyToken(key.mark, key.mark)) + + # If this key starts a new block mapping, we need to add + # BLOCK-MAPPING-START. + if not self.flow_level: + if self.add_indent(key.column): + self.tokens.insert(key.token_number-self.tokens_taken, + BlockMappingStartToken(key.mark, key.mark)) + + # There cannot be two simple keys one after another. + self.allow_simple_key = False + + # It must be a part of a complex key. + else: + + # Block context needs additional checks. + # (Do we really need them? They will be caught by the parser + # anyway.) + if not self.flow_level: + + # We are allowed to start a complex value if and only if + # we can start a simple key. + if not self.allow_simple_key: + raise ScannerError(None, None, + "mapping values are not allowed here", + self.get_mark()) + + # If this value starts a new block mapping, we need to add + # BLOCK-MAPPING-START. It will be detected as an error later by + # the parser. + if not self.flow_level: + if self.add_indent(self.column): + mark = self.get_mark() + self.tokens.append(BlockMappingStartToken(mark, mark)) + + # Simple keys are allowed after ':' in the block context. + self.allow_simple_key = not self.flow_level + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Add VALUE. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(ValueToken(start_mark, end_mark)) + + def fetch_alias(self): + + # ALIAS could be a simple key. + self.save_possible_simple_key() + + # No simple keys after ALIAS. + self.allow_simple_key = False + + # Scan and add ALIAS. + self.tokens.append(self.scan_anchor(AliasToken)) + + def fetch_anchor(self): + + # ANCHOR could start a simple key. + self.save_possible_simple_key() + + # No simple keys after ANCHOR. + self.allow_simple_key = False + + # Scan and add ANCHOR. + self.tokens.append(self.scan_anchor(AnchorToken)) + + def fetch_tag(self): + + # TAG could start a simple key. + self.save_possible_simple_key() + + # No simple keys after TAG. + self.allow_simple_key = False + + # Scan and add TAG. + self.tokens.append(self.scan_tag()) + + def fetch_literal(self): + self.fetch_block_scalar(style='|') + + def fetch_folded(self): + self.fetch_block_scalar(style='>') + + def fetch_block_scalar(self, style): + + # A simple key may follow a block scalar. + self.allow_simple_key = True + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Scan and add SCALAR. + self.tokens.append(self.scan_block_scalar(style)) + + def fetch_single(self): + self.fetch_flow_scalar(style='\'') + + def fetch_double(self): + self.fetch_flow_scalar(style='"') + + def fetch_flow_scalar(self, style): + + # A flow scalar could be a simple key. + self.save_possible_simple_key() + + # No simple keys after flow scalars. + self.allow_simple_key = False + + # Scan and add SCALAR. + self.tokens.append(self.scan_flow_scalar(style)) + + def fetch_plain(self): + + # A plain scalar could be a simple key. + self.save_possible_simple_key() + + # No simple keys after plain scalars. But note that `scan_plain` will + # change this flag if the scan is finished at the beginning of the + # line. + self.allow_simple_key = False + + # Scan and add SCALAR. May change `allow_simple_key`. + self.tokens.append(self.scan_plain()) + + # Checkers. + + def check_directive(self): + + # DIRECTIVE: ^ '%' ... + # The '%' indicator is already checked. + if self.column == 0: + return True + + def check_document_start(self): + + # DOCUMENT-START: ^ '---' (' '|'\n') + if self.column == 0: + if self.prefix(3) == '---' \ + and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': + return True + + def check_document_end(self): + + # DOCUMENT-END: ^ '...' (' '|'\n') + if self.column == 0: + if self.prefix(3) == '...' \ + and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': + return True + + def check_block_entry(self): + + # BLOCK-ENTRY: '-' (' '|'\n') + return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029' + + def check_key(self): + + # KEY(flow context): '?' + if self.flow_level: + return True + + # KEY(block context): '?' (' '|'\n') + else: + return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029' + + def check_value(self): + + # VALUE(flow context): ':' + if self.flow_level: + return True + + # VALUE(block context): ':' (' '|'\n') + else: + return self.peek(1) in '\0 \t\r\n\x85\u2028\u2029' + + def check_plain(self): + + # A plain scalar may start with any non-space character except: + # '-', '?', ':', ',', '[', ']', '{', '}', + # '#', '&', '*', '!', '|', '>', '\'', '\"', + # '%', '@', '`'. + # + # It may also start with + # '-', '?', ':' + # if it is followed by a non-space character. + # + # Note that we limit the last rule to the block context (except the + # '-' character) because we want the flow context to be space + # independent. + ch = self.peek() + return ch not in '\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`' \ + or (self.peek(1) not in '\0 \t\r\n\x85\u2028\u2029' + and (ch == '-' or (not self.flow_level and ch in '?:'))) + + # Scanners. + + def scan_to_next_token(self): + # We ignore spaces, line breaks and comments. + # If we find a line break in the block context, we set the flag + # `allow_simple_key` on. + # The byte order mark is stripped if it's the first character in the + # stream. We do not yet support BOM inside the stream as the + # specification requires. Any such mark will be considered as a part + # of the document. + # + # TODO: We need to make tab handling rules more sane. A good rule is + # Tabs cannot precede tokens + # BLOCK-SEQUENCE-START, BLOCK-MAPPING-START, BLOCK-END, + # KEY(block), VALUE(block), BLOCK-ENTRY + # So the checking code is + # if : + # self.allow_simple_keys = False + # We also need to add the check for `allow_simple_keys == True` to + # `unwind_indent` before issuing BLOCK-END. + # Scanners for block, flow, and plain scalars need to be modified. + + if self.index == 0 and self.peek() == '\uFEFF': + self.forward() + found = False + while not found: + while self.peek() == ' ': + self.forward() + if self.peek() == '#': + while self.peek() not in '\0\r\n\x85\u2028\u2029': + self.forward() + if self.scan_line_break(): + if not self.flow_level: + self.allow_simple_key = True + else: + found = True + + def scan_directive(self): + # See the specification for details. + start_mark = self.get_mark() + self.forward() + name = self.scan_directive_name(start_mark) + value = None + if name == 'YAML': + value = self.scan_yaml_directive_value(start_mark) + end_mark = self.get_mark() + elif name == 'TAG': + value = self.scan_tag_directive_value(start_mark) + end_mark = self.get_mark() + else: + end_mark = self.get_mark() + while self.peek() not in '\0\r\n\x85\u2028\u2029': + self.forward() + self.scan_directive_ignored_line(start_mark) + return DirectiveToken(name, value, start_mark, end_mark) + + def scan_directive_name(self, start_mark): + # See the specification for details. + length = 0 + ch = self.peek(length) + while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ + or ch in '-_': + length += 1 + ch = self.peek(length) + if not length: + raise ScannerError("while scanning a directive", start_mark, + "expected alphabetic or numeric character, but found %r" + % ch, self.get_mark()) + value = self.prefix(length) + self.forward(length) + ch = self.peek() + if ch not in '\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a directive", start_mark, + "expected alphabetic or numeric character, but found %r" + % ch, self.get_mark()) + return value + + def scan_yaml_directive_value(self, start_mark): + # See the specification for details. + while self.peek() == ' ': + self.forward() + major = self.scan_yaml_directive_number(start_mark) + if self.peek() != '.': + raise ScannerError("while scanning a directive", start_mark, + "expected a digit or '.', but found %r" % self.peek(), + self.get_mark()) + self.forward() + minor = self.scan_yaml_directive_number(start_mark) + if self.peek() not in '\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a directive", start_mark, + "expected a digit or ' ', but found %r" % self.peek(), + self.get_mark()) + return (major, minor) + + def scan_yaml_directive_number(self, start_mark): + # See the specification for details. + ch = self.peek() + if not ('0' <= ch <= '9'): + raise ScannerError("while scanning a directive", start_mark, + "expected a digit, but found %r" % ch, self.get_mark()) + length = 0 + while '0' <= self.peek(length) <= '9': + length += 1 + value = int(self.prefix(length)) + self.forward(length) + return value + + def scan_tag_directive_value(self, start_mark): + # See the specification for details. + while self.peek() == ' ': + self.forward() + handle = self.scan_tag_directive_handle(start_mark) + while self.peek() == ' ': + self.forward() + prefix = self.scan_tag_directive_prefix(start_mark) + return (handle, prefix) + + def scan_tag_directive_handle(self, start_mark): + # See the specification for details. + value = self.scan_tag_handle('directive', start_mark) + ch = self.peek() + if ch != ' ': + raise ScannerError("while scanning a directive", start_mark, + "expected ' ', but found %r" % ch, self.get_mark()) + return value + + def scan_tag_directive_prefix(self, start_mark): + # See the specification for details. + value = self.scan_tag_uri('directive', start_mark) + ch = self.peek() + if ch not in '\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a directive", start_mark, + "expected ' ', but found %r" % ch, self.get_mark()) + return value + + def scan_directive_ignored_line(self, start_mark): + # See the specification for details. + while self.peek() == ' ': + self.forward() + if self.peek() == '#': + while self.peek() not in '\0\r\n\x85\u2028\u2029': + self.forward() + ch = self.peek() + if ch not in '\0\r\n\x85\u2028\u2029': + raise ScannerError("while scanning a directive", start_mark, + "expected a comment or a line break, but found %r" + % ch, self.get_mark()) + self.scan_line_break() + + def scan_anchor(self, TokenClass): + # The specification does not restrict characters for anchors and + # aliases. This may lead to problems, for instance, the document: + # [ *alias, value ] + # can be interpreted in two ways, as + # [ "value" ] + # and + # [ *alias , "value" ] + # Therefore we restrict aliases to numbers and ASCII letters. + start_mark = self.get_mark() + indicator = self.peek() + if indicator == '*': + name = 'alias' + else: + name = 'anchor' + self.forward() + length = 0 + ch = self.peek(length) + while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ + or ch in '-_': + length += 1 + ch = self.peek(length) + if not length: + raise ScannerError("while scanning an %s" % name, start_mark, + "expected alphabetic or numeric character, but found %r" + % ch, self.get_mark()) + value = self.prefix(length) + self.forward(length) + ch = self.peek() + if ch not in '\0 \t\r\n\x85\u2028\u2029?:,]}%@`': + raise ScannerError("while scanning an %s" % name, start_mark, + "expected alphabetic or numeric character, but found %r" + % ch, self.get_mark()) + end_mark = self.get_mark() + return TokenClass(value, start_mark, end_mark) + + def scan_tag(self): + # See the specification for details. + start_mark = self.get_mark() + ch = self.peek(1) + if ch == '<': + handle = None + self.forward(2) + suffix = self.scan_tag_uri('tag', start_mark) + if self.peek() != '>': + raise ScannerError("while parsing a tag", start_mark, + "expected '>', but found %r" % self.peek(), + self.get_mark()) + self.forward() + elif ch in '\0 \t\r\n\x85\u2028\u2029': + handle = None + suffix = '!' + self.forward() + else: + length = 1 + use_handle = False + while ch not in '\0 \r\n\x85\u2028\u2029': + if ch == '!': + use_handle = True + break + length += 1 + ch = self.peek(length) + handle = '!' + if use_handle: + handle = self.scan_tag_handle('tag', start_mark) + else: + handle = '!' + self.forward() + suffix = self.scan_tag_uri('tag', start_mark) + ch = self.peek() + if ch not in '\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a tag", start_mark, + "expected ' ', but found %r" % ch, self.get_mark()) + value = (handle, suffix) + end_mark = self.get_mark() + return TagToken(value, start_mark, end_mark) + + def scan_block_scalar(self, style): + # See the specification for details. + + if style == '>': + folded = True + else: + folded = False + + chunks = [] + start_mark = self.get_mark() + + # Scan the header. + self.forward() + chomping, increment = self.scan_block_scalar_indicators(start_mark) + self.scan_block_scalar_ignored_line(start_mark) + + # Determine the indentation level and go to the first non-empty line. + min_indent = self.indent+1 + if min_indent < 1: + min_indent = 1 + if increment is None: + breaks, max_indent, end_mark = self.scan_block_scalar_indentation() + indent = max(min_indent, max_indent) + else: + indent = min_indent+increment-1 + breaks, end_mark = self.scan_block_scalar_breaks(indent) + line_break = '' + + # Scan the inner part of the block scalar. + while self.column == indent and self.peek() != '\0': + chunks.extend(breaks) + leading_non_space = self.peek() not in ' \t' + length = 0 + while self.peek(length) not in '\0\r\n\x85\u2028\u2029': + length += 1 + chunks.append(self.prefix(length)) + self.forward(length) + line_break = self.scan_line_break() + breaks, end_mark = self.scan_block_scalar_breaks(indent) + if self.column == indent and self.peek() != '\0': + + # Unfortunately, folding rules are ambiguous. + # + # This is the folding according to the specification: + + if folded and line_break == '\n' \ + and leading_non_space and self.peek() not in ' \t': + if not breaks: + chunks.append(' ') + else: + chunks.append(line_break) + + # This is Clark Evans's interpretation (also in the spec + # examples): + # + #if folded and line_break == '\n': + # if not breaks: + # if self.peek() not in ' \t': + # chunks.append(' ') + # else: + # chunks.append(line_break) + #else: + # chunks.append(line_break) + else: + break + + # Chomp the tail. + if chomping is not False: + chunks.append(line_break) + if chomping is True: + chunks.extend(breaks) + + # We are done. + return ScalarToken(''.join(chunks), False, start_mark, end_mark, + style) + + def scan_block_scalar_indicators(self, start_mark): + # See the specification for details. + chomping = None + increment = None + ch = self.peek() + if ch in '+-': + if ch == '+': + chomping = True + else: + chomping = False + self.forward() + ch = self.peek() + if ch in '0123456789': + increment = int(ch) + if increment == 0: + raise ScannerError("while scanning a block scalar", start_mark, + "expected indentation indicator in the range 1-9, but found 0", + self.get_mark()) + self.forward() + elif ch in '0123456789': + increment = int(ch) + if increment == 0: + raise ScannerError("while scanning a block scalar", start_mark, + "expected indentation indicator in the range 1-9, but found 0", + self.get_mark()) + self.forward() + ch = self.peek() + if ch in '+-': + if ch == '+': + chomping = True + else: + chomping = False + self.forward() + ch = self.peek() + if ch not in '\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a block scalar", start_mark, + "expected chomping or indentation indicators, but found %r" + % ch, self.get_mark()) + return chomping, increment + + def scan_block_scalar_ignored_line(self, start_mark): + # See the specification for details. + while self.peek() == ' ': + self.forward() + if self.peek() == '#': + while self.peek() not in '\0\r\n\x85\u2028\u2029': + self.forward() + ch = self.peek() + if ch not in '\0\r\n\x85\u2028\u2029': + raise ScannerError("while scanning a block scalar", start_mark, + "expected a comment or a line break, but found %r" % ch, + self.get_mark()) + self.scan_line_break() + + def scan_block_scalar_indentation(self): + # See the specification for details. + chunks = [] + max_indent = 0 + end_mark = self.get_mark() + while self.peek() in ' \r\n\x85\u2028\u2029': + if self.peek() != ' ': + chunks.append(self.scan_line_break()) + end_mark = self.get_mark() + else: + self.forward() + if self.column > max_indent: + max_indent = self.column + return chunks, max_indent, end_mark + + def scan_block_scalar_breaks(self, indent): + # See the specification for details. + chunks = [] + end_mark = self.get_mark() + while self.column < indent and self.peek() == ' ': + self.forward() + while self.peek() in '\r\n\x85\u2028\u2029': + chunks.append(self.scan_line_break()) + end_mark = self.get_mark() + while self.column < indent and self.peek() == ' ': + self.forward() + return chunks, end_mark + + def scan_flow_scalar(self, style): + # See the specification for details. + # Note that we loose indentation rules for quoted scalars. Quoted + # scalars don't need to adhere indentation because " and ' clearly + # mark the beginning and the end of them. Therefore we are less + # restrictive then the specification requires. We only need to check + # that document separators are not included in scalars. + if style == '"': + double = True + else: + double = False + chunks = [] + start_mark = self.get_mark() + quote = self.peek() + self.forward() + chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark)) + while self.peek() != quote: + chunks.extend(self.scan_flow_scalar_spaces(double, start_mark)) + chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark)) + self.forward() + end_mark = self.get_mark() + return ScalarToken(''.join(chunks), False, start_mark, end_mark, + style) + + ESCAPE_REPLACEMENTS = { + '0': '\0', + 'a': '\x07', + 'b': '\x08', + 't': '\x09', + '\t': '\x09', + 'n': '\x0A', + 'v': '\x0B', + 'f': '\x0C', + 'r': '\x0D', + 'e': '\x1B', + ' ': '\x20', + '\"': '\"', + '\\': '\\', + '/': '/', + 'N': '\x85', + '_': '\xA0', + 'L': '\u2028', + 'P': '\u2029', + } + + ESCAPE_CODES = { + 'x': 2, + 'u': 4, + 'U': 8, + } + + def scan_flow_scalar_non_spaces(self, double, start_mark): + # See the specification for details. + chunks = [] + while True: + length = 0 + while self.peek(length) not in '\'\"\\\0 \t\r\n\x85\u2028\u2029': + length += 1 + if length: + chunks.append(self.prefix(length)) + self.forward(length) + ch = self.peek() + if not double and ch == '\'' and self.peek(1) == '\'': + chunks.append('\'') + self.forward(2) + elif (double and ch == '\'') or (not double and ch in '\"\\'): + chunks.append(ch) + self.forward() + elif double and ch == '\\': + self.forward() + ch = self.peek() + if ch in self.ESCAPE_REPLACEMENTS: + chunks.append(self.ESCAPE_REPLACEMENTS[ch]) + self.forward() + elif ch in self.ESCAPE_CODES: + length = self.ESCAPE_CODES[ch] + self.forward() + for k in range(length): + if self.peek(k) not in '0123456789ABCDEFabcdef': + raise ScannerError("while scanning a double-quoted scalar", start_mark, + "expected escape sequence of %d hexadecimal numbers, but found %r" % + (length, self.peek(k)), self.get_mark()) + code = int(self.prefix(length), 16) + chunks.append(chr(code)) + self.forward(length) + elif ch in '\r\n\x85\u2028\u2029': + self.scan_line_break() + chunks.extend(self.scan_flow_scalar_breaks(double, start_mark)) + else: + raise ScannerError("while scanning a double-quoted scalar", start_mark, + "found unknown escape character %r" % ch, self.get_mark()) + else: + return chunks + + def scan_flow_scalar_spaces(self, double, start_mark): + # See the specification for details. + chunks = [] + length = 0 + while self.peek(length) in ' \t': + length += 1 + whitespaces = self.prefix(length) + self.forward(length) + ch = self.peek() + if ch == '\0': + raise ScannerError("while scanning a quoted scalar", start_mark, + "found unexpected end of stream", self.get_mark()) + elif ch in '\r\n\x85\u2028\u2029': + line_break = self.scan_line_break() + breaks = self.scan_flow_scalar_breaks(double, start_mark) + if line_break != '\n': + chunks.append(line_break) + elif not breaks: + chunks.append(' ') + chunks.extend(breaks) + else: + chunks.append(whitespaces) + return chunks + + def scan_flow_scalar_breaks(self, double, start_mark): + # See the specification for details. + chunks = [] + while True: + # Instead of checking indentation, we check for document + # separators. + prefix = self.prefix(3) + if (prefix == '---' or prefix == '...') \ + and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': + raise ScannerError("while scanning a quoted scalar", start_mark, + "found unexpected document separator", self.get_mark()) + while self.peek() in ' \t': + self.forward() + if self.peek() in '\r\n\x85\u2028\u2029': + chunks.append(self.scan_line_break()) + else: + return chunks + + def scan_plain(self): + # See the specification for details. + # We add an additional restriction for the flow context: + # plain scalars in the flow context cannot contain ',' or '?'. + # We also keep track of the `allow_simple_key` flag here. + # Indentation rules are loosed for the flow context. + chunks = [] + start_mark = self.get_mark() + end_mark = start_mark + indent = self.indent+1 + # We allow zero indentation for scalars, but then we need to check for + # document separators at the beginning of the line. + #if indent == 0: + # indent = 1 + spaces = [] + while True: + length = 0 + if self.peek() == '#': + break + while True: + ch = self.peek(length) + if ch in '\0 \t\r\n\x85\u2028\u2029' \ + or (ch == ':' and + self.peek(length+1) in '\0 \t\r\n\x85\u2028\u2029' + + (u',[]{}' if self.flow_level else u''))\ + or (self.flow_level and ch in ',?[]{}'): + break + length += 1 + if length == 0: + break + self.allow_simple_key = False + chunks.extend(spaces) + chunks.append(self.prefix(length)) + self.forward(length) + end_mark = self.get_mark() + spaces = self.scan_plain_spaces(indent, start_mark) + if not spaces or self.peek() == '#' \ + or (not self.flow_level and self.column < indent): + break + return ScalarToken(''.join(chunks), True, start_mark, end_mark) + + def scan_plain_spaces(self, indent, start_mark): + # See the specification for details. + # The specification is really confusing about tabs in plain scalars. + # We just forbid them completely. Do not use tabs in YAML! + chunks = [] + length = 0 + while self.peek(length) in ' ': + length += 1 + whitespaces = self.prefix(length) + self.forward(length) + ch = self.peek() + if ch in '\r\n\x85\u2028\u2029': + line_break = self.scan_line_break() + self.allow_simple_key = True + prefix = self.prefix(3) + if (prefix == '---' or prefix == '...') \ + and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': + return + breaks = [] + while self.peek() in ' \r\n\x85\u2028\u2029': + if self.peek() == ' ': + self.forward() + else: + breaks.append(self.scan_line_break()) + prefix = self.prefix(3) + if (prefix == '---' or prefix == '...') \ + and self.peek(3) in '\0 \t\r\n\x85\u2028\u2029': + return + if line_break != '\n': + chunks.append(line_break) + elif not breaks: + chunks.append(' ') + chunks.extend(breaks) + elif whitespaces: + chunks.append(whitespaces) + return chunks + + def scan_tag_handle(self, name, start_mark): + # See the specification for details. + # For some strange reasons, the specification does not allow '_' in + # tag handles. I have allowed it anyway. + ch = self.peek() + if ch != '!': + raise ScannerError("while scanning a %s" % name, start_mark, + "expected '!', but found %r" % ch, self.get_mark()) + length = 1 + ch = self.peek(length) + if ch != ' ': + while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ + or ch in '-_': + length += 1 + ch = self.peek(length) + if ch != '!': + self.forward(length) + raise ScannerError("while scanning a %s" % name, start_mark, + "expected '!', but found %r" % ch, self.get_mark()) + length += 1 + value = self.prefix(length) + self.forward(length) + return value + + def scan_tag_uri(self, name, start_mark): + # See the specification for details. + # Note: we do not check if URI is well-formed. + chunks = [] + length = 0 + ch = self.peek(length) + while '0' <= ch <= '9' or 'A' <= ch <= 'Z' or 'a' <= ch <= 'z' \ + or ch in '-;/?:@&=+$,_.!~*\'()[]%': + if ch == '%': + chunks.append(self.prefix(length)) + self.forward(length) + length = 0 + chunks.append(self.scan_uri_escapes(name, start_mark)) + else: + length += 1 + ch = self.peek(length) + if length: + chunks.append(self.prefix(length)) + self.forward(length) + length = 0 + if not chunks: + raise ScannerError("while parsing a %s" % name, start_mark, + "expected URI, but found %r" % ch, self.get_mark()) + return ''.join(chunks) + + def scan_uri_escapes(self, name, start_mark): + # See the specification for details. + codes = [] + mark = self.get_mark() + while self.peek() == '%': + self.forward() + for k in range(2): + if self.peek(k) not in '0123456789ABCDEFabcdef': + raise ScannerError("while scanning a %s" % name, start_mark, + "expected URI escape sequence of 2 hexadecimal numbers, but found %r" + % self.peek(k), self.get_mark()) + codes.append(int(self.prefix(2), 16)) + self.forward(2) + try: + value = bytes(codes).decode('utf-8') + except UnicodeDecodeError as exc: + raise ScannerError("while scanning a %s" % name, start_mark, str(exc), mark) + return value + + def scan_line_break(self): + # Transforms: + # '\r\n' : '\n' + # '\r' : '\n' + # '\n' : '\n' + # '\x85' : '\n' + # '\u2028' : '\u2028' + # '\u2029 : '\u2029' + # default : '' + ch = self.peek() + if ch in '\r\n\x85': + if self.prefix(2) == '\r\n': + self.forward(2) + else: + self.forward() + return '\n' + elif ch in '\u2028\u2029': + self.forward() + return ch + return '' diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/serializer.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/serializer.py new file mode 100644 index 0000000000000000000000000000000000000000..fe911e67ae7a739abb491fbbc6834b9c37bbda4b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/serializer.py @@ -0,0 +1,111 @@ + +__all__ = ['Serializer', 'SerializerError'] + +from .error import YAMLError +from .events import * +from .nodes import * + +class SerializerError(YAMLError): + pass + +class Serializer: + + ANCHOR_TEMPLATE = 'id%03d' + + def __init__(self, encoding=None, + explicit_start=None, explicit_end=None, version=None, tags=None): + self.use_encoding = encoding + self.use_explicit_start = explicit_start + self.use_explicit_end = explicit_end + self.use_version = version + self.use_tags = tags + self.serialized_nodes = {} + self.anchors = {} + self.last_anchor_id = 0 + self.closed = None + + def open(self): + if self.closed is None: + self.emit(StreamStartEvent(encoding=self.use_encoding)) + self.closed = False + elif self.closed: + raise SerializerError("serializer is closed") + else: + raise SerializerError("serializer is already opened") + + def close(self): + if self.closed is None: + raise SerializerError("serializer is not opened") + elif not self.closed: + self.emit(StreamEndEvent()) + self.closed = True + + #def __del__(self): + # self.close() + + def serialize(self, node): + if self.closed is None: + raise SerializerError("serializer is not opened") + elif self.closed: + raise SerializerError("serializer is closed") + self.emit(DocumentStartEvent(explicit=self.use_explicit_start, + version=self.use_version, tags=self.use_tags)) + self.anchor_node(node) + self.serialize_node(node, None, None) + self.emit(DocumentEndEvent(explicit=self.use_explicit_end)) + self.serialized_nodes = {} + self.anchors = {} + self.last_anchor_id = 0 + + def anchor_node(self, node): + if node in self.anchors: + if self.anchors[node] is None: + self.anchors[node] = self.generate_anchor(node) + else: + self.anchors[node] = None + if isinstance(node, SequenceNode): + for item in node.value: + self.anchor_node(item) + elif isinstance(node, MappingNode): + for key, value in node.value: + self.anchor_node(key) + self.anchor_node(value) + + def generate_anchor(self, node): + self.last_anchor_id += 1 + return self.ANCHOR_TEMPLATE % self.last_anchor_id + + def serialize_node(self, node, parent, index): + alias = self.anchors[node] + if node in self.serialized_nodes: + self.emit(AliasEvent(alias)) + else: + self.serialized_nodes[node] = True + self.descend_resolver(parent, index) + if isinstance(node, ScalarNode): + detected_tag = self.resolve(ScalarNode, node.value, (True, False)) + default_tag = self.resolve(ScalarNode, node.value, (False, True)) + implicit = (node.tag == detected_tag), (node.tag == default_tag) + self.emit(ScalarEvent(alias, node.tag, implicit, node.value, + style=node.style)) + elif isinstance(node, SequenceNode): + implicit = (node.tag + == self.resolve(SequenceNode, node.value, True)) + self.emit(SequenceStartEvent(alias, node.tag, implicit, + flow_style=node.flow_style)) + index = 0 + for item in node.value: + self.serialize_node(item, node, index) + index += 1 + self.emit(SequenceEndEvent()) + elif isinstance(node, MappingNode): + implicit = (node.tag + == self.resolve(MappingNode, node.value, True)) + self.emit(MappingStartEvent(alias, node.tag, implicit, + flow_style=node.flow_style)) + for key, value in node.value: + self.serialize_node(key, node, None) + self.serialize_node(value, node, key) + self.emit(MappingEndEvent()) + self.ascend_resolver() + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/tokens.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/tokens.py new file mode 100644 index 0000000000000000000000000000000000000000..4d0b48a394ac8c019b401516a12f688df361cf90 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/tokens.py @@ -0,0 +1,104 @@ + +class Token(object): + def __init__(self, start_mark, end_mark): + self.start_mark = start_mark + self.end_mark = end_mark + def __repr__(self): + attributes = [key for key in self.__dict__ + if not key.endswith('_mark')] + attributes.sort() + arguments = ', '.join(['%s=%r' % (key, getattr(self, key)) + for key in attributes]) + return '%s(%s)' % (self.__class__.__name__, arguments) + +#class BOMToken(Token): +# id = '' + +class DirectiveToken(Token): + id = '' + def __init__(self, name, value, start_mark, end_mark): + self.name = name + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + +class DocumentStartToken(Token): + id = '' + +class DocumentEndToken(Token): + id = '' + +class StreamStartToken(Token): + id = '' + def __init__(self, start_mark=None, end_mark=None, + encoding=None): + self.start_mark = start_mark + self.end_mark = end_mark + self.encoding = encoding + +class StreamEndToken(Token): + id = '' + +class BlockSequenceStartToken(Token): + id = '' + +class BlockMappingStartToken(Token): + id = '' + +class BlockEndToken(Token): + id = '' + +class FlowSequenceStartToken(Token): + id = '[' + +class FlowMappingStartToken(Token): + id = '{' + +class FlowSequenceEndToken(Token): + id = ']' + +class FlowMappingEndToken(Token): + id = '}' + +class KeyToken(Token): + id = '?' + +class ValueToken(Token): + id = ':' + +class BlockEntryToken(Token): + id = '-' + +class FlowEntryToken(Token): + id = ',' + +class AliasToken(Token): + id = '' + def __init__(self, value, start_mark, end_mark): + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + +class AnchorToken(Token): + id = '' + def __init__(self, value, start_mark, end_mark): + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + +class TagToken(Token): + id = '' + def __init__(self, value, start_mark, end_mark): + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + +class ScalarToken(Token): + id = '' + def __init__(self, value, plain, start_mark, end_mark, style=None): + self.value = value + self.plain = plain + self.start_mark = start_mark + self.end_mark = end_mark + self.style = style + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site.py new file mode 100644 index 0000000000000000000000000000000000000000..2904e44cffd7359ae55eeb8ec8dc2a4d17649f29 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site.py @@ -0,0 +1,683 @@ +"""Append module search paths for third-party packages to sys.path. + +**************************************************************** +* This module is automatically imported during initialization. * +**************************************************************** + +This will append site-specific paths to the module search path. On +Unix (including Mac OSX), it starts with sys.prefix and +sys.exec_prefix (if different) and appends +lib/python/site-packages. +On other platforms (such as Windows), it tries each of the +prefixes directly, as well as with lib/site-packages appended. The +resulting directories, if they exist, are appended to sys.path, and +also inspected for path configuration files. + +If a file named "pyvenv.cfg" exists one directory above sys.executable, +sys.prefix and sys.exec_prefix are set to that directory and +it is also checked for site-packages (sys.base_prefix and +sys.base_exec_prefix will always be the "real" prefixes of the Python +installation). If "pyvenv.cfg" (a bootstrap configuration file) contains +the key "include-system-site-packages" set to anything other than "false" +(case-insensitive), the system-level prefixes will still also be +searched for site-packages; otherwise they won't. + +All of the resulting site-specific directories, if they exist, are +appended to sys.path, and also inspected for path configuration +files. + +A path configuration file is a file whose name has the form +.pth; its contents are additional directories (one per line) +to be added to sys.path. Non-existing directories (or +non-directories) are never added to sys.path; no directory is added to +sys.path more than once. Blank lines and lines beginning with +'#' are skipped. Lines starting with 'import' are executed. + +For example, suppose sys.prefix and sys.exec_prefix are set to +/usr/local and there is a directory /usr/local/lib/python2.5/site-packages +with three subdirectories, foo, bar and spam, and two path +configuration files, foo.pth and bar.pth. Assume foo.pth contains the +following: + + # foo package configuration + foo + bar + bletch + +and bar.pth contains: + + # bar package configuration + bar + +Then the following directories are added to sys.path, in this order: + + /usr/local/lib/python2.5/site-packages/bar + /usr/local/lib/python2.5/site-packages/foo + +Note that bletch is omitted because it doesn't exist; bar precedes foo +because bar.pth comes alphabetically before foo.pth; and spam is +omitted because it is not mentioned in either path configuration file. + +The readline module is also automatically configured to enable +completion for systems that support it. This can be overridden in +sitecustomize, usercustomize or PYTHONSTARTUP. Starting Python in +isolated mode (-I) disables automatic readline configuration. + +After these operations, an attempt is made to import a module +named sitecustomize, which can perform arbitrary additional +site-specific customizations. If this import fails with an +ImportError exception, it is silently ignored. +""" + +import sys +import os +import builtins +import _sitebuiltins +import io +import stat + +# Prefixes for site-packages; add additional prefixes like /usr/local here +PREFIXES = [sys.prefix, sys.exec_prefix] +# Enable per user site-packages directory +# set it to False to disable the feature or True to force the feature +ENABLE_USER_SITE = None + +# for distutils.commands.install +# These values are initialized by the getuserbase() and getusersitepackages() +# functions, through the main() function when Python starts. +USER_SITE = None +USER_BASE = None + + +def _trace(message): + if sys.flags.verbose: + print(message, file=sys.stderr) + + +def makepath(*paths): + dir = os.path.join(*paths) + try: + dir = os.path.abspath(dir) + except OSError: + pass + return dir, os.path.normcase(dir) + + +def abs_paths(): + """Set all module __file__ and __cached__ attributes to an absolute path""" + for m in set(sys.modules.values()): + loader_module = None + try: + loader_module = m.__loader__.__module__ + except AttributeError: + try: + loader_module = m.__spec__.loader.__module__ + except AttributeError: + pass + if loader_module not in {'_frozen_importlib', '_frozen_importlib_external'}: + continue # don't mess with a PEP 302-supplied __file__ + try: + m.__file__ = os.path.abspath(m.__file__) + except (AttributeError, OSError, TypeError): + pass + try: + m.__cached__ = os.path.abspath(m.__cached__) + except (AttributeError, OSError, TypeError): + pass + + +def removeduppaths(): + """ Remove duplicate entries from sys.path along with making them + absolute""" + # This ensures that the initial path provided by the interpreter contains + # only absolute pathnames, even if we're running from the build directory. + L = [] + known_paths = set() + for dir in sys.path: + # Filter out duplicate paths (on case-insensitive file systems also + # if they only differ in case); turn relative paths into absolute + # paths. + dir, dircase = makepath(dir) + if dircase not in known_paths: + L.append(dir) + known_paths.add(dircase) + sys.path[:] = L + return known_paths + + +def _init_pathinfo(): + """Return a set containing all existing file system items from sys.path.""" + d = set() + for item in sys.path: + try: + if os.path.exists(item): + _, itemcase = makepath(item) + d.add(itemcase) + except TypeError: + continue + return d + + +def addpackage(sitedir, name, known_paths): + """Process a .pth file within the site-packages directory: + For each line in the file, either combine it with sitedir to a path + and add that to known_paths, or execute it if it starts with 'import '. + """ + if known_paths is None: + known_paths = _init_pathinfo() + reset = True + else: + reset = False + fullname = os.path.join(sitedir, name) + try: + st = os.lstat(fullname) + except OSError: + return + if ((getattr(st, 'st_flags', 0) & stat.UF_HIDDEN) or + (getattr(st, 'st_file_attributes', 0) & stat.FILE_ATTRIBUTE_HIDDEN)): + _trace(f"Skipping hidden .pth file: {fullname!r}") + return + _trace(f"Processing .pth file: {fullname!r}") + try: + # locale encoding is not ideal especially on Windows. But we have used + # it for a long time. setuptools uses the locale encoding too. + f = io.TextIOWrapper(io.open_code(fullname), encoding="locale") + except OSError: + return + with f: + for n, line in enumerate(f): + if line.startswith("#"): + continue + if line.strip() == "": + continue + try: + if line.startswith(("import ", "import\t")): + exec(line) + continue + line = line.rstrip() + dir, dircase = makepath(sitedir, line) + if not dircase in known_paths and os.path.exists(dir): + sys.path.append(dir) + known_paths.add(dircase) + except Exception: + print("Error processing line {:d} of {}:\n".format(n+1, fullname), + file=sys.stderr) + import traceback + for record in traceback.format_exception(*sys.exc_info()): + for line in record.splitlines(): + print(' '+line, file=sys.stderr) + print("\nRemainder of file ignored", file=sys.stderr) + break + if reset: + known_paths = None + return known_paths + + +def addsitedir(sitedir, known_paths=None): + """Add 'sitedir' argument to sys.path if missing and handle .pth files in + 'sitedir'""" + _trace(f"Adding directory: {sitedir!r}") + if known_paths is None: + known_paths = _init_pathinfo() + reset = True + else: + reset = False + sitedir, sitedircase = makepath(sitedir) + if not sitedircase in known_paths: + sys.path.append(sitedir) # Add path component + known_paths.add(sitedircase) + try: + names = os.listdir(sitedir) + except OSError: + return + names = [name for name in names + if name.endswith(".pth") and not name.startswith(".")] + for name in sorted(names): + addpackage(sitedir, name, known_paths) + if reset: + known_paths = None + return known_paths + + +def check_enableusersite(): + """Check if user site directory is safe for inclusion + + The function tests for the command line flag (including environment var), + process uid/gid equal to effective uid/gid. + + None: Disabled for security reasons + False: Disabled by user (command line option) + True: Safe and enabled + """ + if sys.flags.no_user_site: + return False + + if hasattr(os, "getuid") and hasattr(os, "geteuid"): + # check process uid == effective uid + if os.geteuid() != os.getuid(): + return None + if hasattr(os, "getgid") and hasattr(os, "getegid"): + # check process gid == effective gid + if os.getegid() != os.getgid(): + return None + + return True + + +# NOTE: sysconfig and it's dependencies are relatively large but site module +# needs very limited part of them. +# To speedup startup time, we have copy of them. +# +# See https://bugs.python.org/issue29585 + +# Copy of sysconfig._getuserbase() +def _getuserbase(): + env_base = os.environ.get("PYTHONUSERBASE", None) + if env_base: + return env_base + + # Emscripten, VxWorks, and WASI have no home directories + if sys.platform in {"emscripten", "vxworks", "wasi"}: + return None + + def joinuser(*args): + return os.path.expanduser(os.path.join(*args)) + + if os.name == "nt": + base = os.environ.get("APPDATA") or "~" + return joinuser(base, "Python") + + if sys.platform == "darwin" and sys._framework: + return joinuser("~", "Library", sys._framework, + "%d.%d" % sys.version_info[:2]) + + return joinuser("~", ".local") + + +# Same to sysconfig.get_path('purelib', os.name+'_user') +def _get_path(userbase): + version = sys.version_info + + if os.name == 'nt': + ver_nodot = sys.winver.replace('.', '') + return f'{userbase}\\Python{ver_nodot}\\site-packages' + + if sys.platform == 'darwin' and sys._framework: + return f'{userbase}/lib/python/site-packages' + + return f'{userbase}/lib/python{version[0]}.{version[1]}/site-packages' + + +def getuserbase(): + """Returns the `user base` directory path. + + The `user base` directory can be used to store data. If the global + variable ``USER_BASE`` is not initialized yet, this function will also set + it. + """ + global USER_BASE + if USER_BASE is None: + USER_BASE = _getuserbase() + return USER_BASE + + +def getusersitepackages(): + """Returns the user-specific site-packages directory path. + + If the global variable ``USER_SITE`` is not initialized yet, this + function will also set it. + """ + global USER_SITE, ENABLE_USER_SITE + userbase = getuserbase() # this will also set USER_BASE + + if USER_SITE is None: + if userbase is None: + ENABLE_USER_SITE = False # disable user site and return None + else: + USER_SITE = _get_path(userbase) + + return USER_SITE + +def addusersitepackages(known_paths): + """Add a per user site-package to sys.path + + Each user has its own python directory with site-packages in the + home directory. + """ + # get the per user site-package path + # this call will also make sure USER_BASE and USER_SITE are set + _trace("Processing user site-packages") + user_site = getusersitepackages() + + if ENABLE_USER_SITE and os.path.isdir(user_site): + addsitedir(user_site, known_paths) + return known_paths + +def getsitepackages(prefixes=None): + """Returns a list containing all global site-packages directories. + + For each directory present in ``prefixes`` (or the global ``PREFIXES``), + this function will find its `site-packages` subdirectory depending on the + system environment, and will return a list of full paths. + """ + sitepackages = [] + seen = set() + + if prefixes is None: + prefixes = PREFIXES + + for prefix in prefixes: + if not prefix or prefix in seen: + continue + seen.add(prefix) + + if os.sep == '/': + libdirs = [sys.platlibdir] + if sys.platlibdir != "lib": + libdirs.append("lib") + + for libdir in libdirs: + path = os.path.join(prefix, libdir, + "python%d.%d" % sys.version_info[:2], + "site-packages") + sitepackages.append(path) + else: + sitepackages.append(prefix) + sitepackages.append(os.path.join(prefix, "Lib", "site-packages")) + return sitepackages + +def addsitepackages(known_paths, prefixes=None): + """Add site-packages to sys.path""" + _trace("Processing global site-packages") + for sitedir in getsitepackages(prefixes): + if os.path.isdir(sitedir): + addsitedir(sitedir, known_paths) + + return known_paths + +def setquit(): + """Define new builtins 'quit' and 'exit'. + + These are objects which make the interpreter exit when called. + The repr of each object contains a hint at how it works. + + """ + if os.sep == '\\': + eof = 'Ctrl-Z plus Return' + else: + eof = 'Ctrl-D (i.e. EOF)' + + builtins.quit = _sitebuiltins.Quitter('quit', eof) + builtins.exit = _sitebuiltins.Quitter('exit', eof) + + +def setcopyright(): + """Set 'copyright' and 'credits' in builtins""" + builtins.copyright = _sitebuiltins._Printer("copyright", sys.copyright) + if sys.platform[:4] == 'java': + builtins.credits = _sitebuiltins._Printer( + "credits", + "Jython is maintained by the Jython developers (www.jython.org).") + else: + builtins.credits = _sitebuiltins._Printer("credits", """\ + Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands + for supporting Python development. See www.python.org for more information.""") + files, dirs = [], [] + # Not all modules are required to have a __file__ attribute. See + # PEP 420 for more details. + here = getattr(sys, '_stdlib_dir', None) + if not here and hasattr(os, '__file__'): + here = os.path.dirname(os.__file__) + if here: + files.extend(["LICENSE.txt", "LICENSE"]) + dirs.extend([os.path.join(here, os.pardir), here, os.curdir]) + builtins.license = _sitebuiltins._Printer( + "license", + "See https://www.python.org/psf/license/", + files, dirs) + + +def sethelper(): + builtins.help = _sitebuiltins._Helper() + +def enablerlcompleter(): + """Enable default readline configuration on interactive prompts, by + registering a sys.__interactivehook__. + + If the readline module can be imported, the hook will set the Tab key + as completion key and register ~/.python_history as history file. + This can be overridden in the sitecustomize or usercustomize module, + or in a PYTHONSTARTUP file. + """ + def register_readline(): + import atexit + try: + import readline + import rlcompleter + except ImportError: + return + + # Reading the initialization (config) file may not be enough to set a + # completion key, so we set one first and then read the file. + readline_doc = getattr(readline, '__doc__', '') + if readline_doc is not None and 'libedit' in readline_doc: + readline.parse_and_bind('bind ^I rl_complete') + else: + readline.parse_and_bind('tab: complete') + + try: + readline.read_init_file() + except OSError: + # An OSError here could have many causes, but the most likely one + # is that there's no .inputrc file (or .editrc file in the case of + # Mac OS X + libedit) in the expected location. In that case, we + # want to ignore the exception. + pass + + if readline.get_current_history_length() == 0: + # If no history was loaded, default to .python_history. + # The guard is necessary to avoid doubling history size at + # each interpreter exit when readline was already configured + # through a PYTHONSTARTUP hook, see: + # http://bugs.python.org/issue5845#msg198636 + history = os.path.join(os.path.expanduser('~'), + '.python_history') + try: + readline.read_history_file(history) + except OSError: + pass + + def write_history(): + try: + readline.write_history_file(history) + except OSError: + # bpo-19891, bpo-41193: Home directory does not exist + # or is not writable, or the filesystem is read-only. + pass + + atexit.register(write_history) + + sys.__interactivehook__ = register_readline + +def venv(known_paths): + global PREFIXES, ENABLE_USER_SITE + + env = os.environ + if sys.platform == 'darwin' and '__PYVENV_LAUNCHER__' in env: + executable = sys._base_executable = os.environ['__PYVENV_LAUNCHER__'] + else: + executable = sys.executable + exe_dir, _ = os.path.split(os.path.abspath(executable)) + site_prefix = os.path.dirname(exe_dir) + sys._home = None + conf_basename = 'pyvenv.cfg' + candidate_confs = [ + conffile for conffile in ( + os.path.join(exe_dir, conf_basename), + os.path.join(site_prefix, conf_basename) + ) + if os.path.isfile(conffile) + ] + + if candidate_confs: + virtual_conf = candidate_confs[0] + system_site = "true" + # Issue 25185: Use UTF-8, as that's what the venv module uses when + # writing the file. + with open(virtual_conf, encoding='utf-8') as f: + for line in f: + if '=' in line: + key, _, value = line.partition('=') + key = key.strip().lower() + value = value.strip() + if key == 'include-system-site-packages': + system_site = value.lower() + elif key == 'home': + sys._home = value + + sys.prefix = sys.exec_prefix = site_prefix + + # Doing this here ensures venv takes precedence over user-site + addsitepackages(known_paths, [sys.prefix]) + + # addsitepackages will process site_prefix again if its in PREFIXES, + # but that's ok; known_paths will prevent anything being added twice + if system_site == "true": + PREFIXES.insert(0, sys.prefix) + else: + PREFIXES = [sys.prefix] + ENABLE_USER_SITE = False + + return known_paths + + +def execsitecustomize(): + """Run custom site specific code, if available.""" + try: + try: + import sitecustomize + except ImportError as exc: + if exc.name == 'sitecustomize': + pass + else: + raise + except Exception as err: + if sys.flags.verbose: + sys.excepthook(*sys.exc_info()) + else: + sys.stderr.write( + "Error in sitecustomize; set PYTHONVERBOSE for traceback:\n" + "%s: %s\n" % + (err.__class__.__name__, err)) + + +def execusercustomize(): + """Run custom user specific code, if available.""" + try: + try: + import usercustomize + except ImportError as exc: + if exc.name == 'usercustomize': + pass + else: + raise + except Exception as err: + if sys.flags.verbose: + sys.excepthook(*sys.exc_info()) + else: + sys.stderr.write( + "Error in usercustomize; set PYTHONVERBOSE for traceback:\n" + "%s: %s\n" % + (err.__class__.__name__, err)) + + +def main(): + """Add standard site-specific directories to the module search path. + + This function is called automatically when this module is imported, + unless the python interpreter was started with the -S flag. + """ + global ENABLE_USER_SITE + + orig_path = sys.path[:] + known_paths = removeduppaths() + if orig_path != sys.path: + # removeduppaths() might make sys.path absolute. + # fix __file__ and __cached__ of already imported modules too. + abs_paths() + + known_paths = venv(known_paths) + if ENABLE_USER_SITE is None: + ENABLE_USER_SITE = check_enableusersite() + known_paths = addusersitepackages(known_paths) + known_paths = addsitepackages(known_paths) + setquit() + setcopyright() + sethelper() + if not sys.flags.isolated: + enablerlcompleter() + execsitecustomize() + if ENABLE_USER_SITE: + execusercustomize() + +# Prevent extending of sys.path when python was started with -S and +# site is imported later. +if not sys.flags.no_site: + main() + +def _script(): + help = """\ + %s [--user-base] [--user-site] + + Without arguments print some useful information + With arguments print the value of USER_BASE and/or USER_SITE separated + by '%s'. + + Exit codes with --user-base or --user-site: + 0 - user site directory is enabled + 1 - user site directory is disabled by user + 2 - user site directory is disabled by super user + or for security reasons + >2 - unknown error + """ + args = sys.argv[1:] + if not args: + user_base = getuserbase() + user_site = getusersitepackages() + print("sys.path = [") + for dir in sys.path: + print(" %r," % (dir,)) + print("]") + def exists(path): + if path is not None and os.path.isdir(path): + return "exists" + else: + return "doesn't exist" + print(f"USER_BASE: {user_base!r} ({exists(user_base)})") + print(f"USER_SITE: {user_site!r} ({exists(user_site)})") + print(f"ENABLE_USER_SITE: {ENABLE_USER_SITE!r}") + sys.exit(0) + + buffer = [] + if '--user-base' in args: + buffer.append(USER_BASE) + if '--user-site' in args: + buffer.append(USER_SITE) + + if buffer: + print(os.pathsep.join(buffer)) + if ENABLE_USER_SITE: + sys.exit(0) + elif ENABLE_USER_SITE is False: + sys.exit(1) + elif ENABLE_USER_SITE is None: + sys.exit(2) + else: + sys.exit(3) + else: + import textwrap + print(textwrap.dedent(help % (sys.argv[0], os.pathsep))) + sys.exit(10) + +if __name__ == '__main__': + _script() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/smtpd.py b/physworld_p1_20261018/envs/p1/lib/python3.11/smtpd.py new file mode 100644 index 0000000000000000000000000000000000000000..b23579f120716fe7a356a3510d93bd1cdd892a77 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/smtpd.py @@ -0,0 +1,885 @@ +#! /usr/bin/env python3 +"""An RFC 5321 smtp proxy with optional RFC 1870 and RFC 6531 extensions. + +Usage: %(program)s [options] [localhost:localport [remotehost:remoteport]] + +Options: + + --nosetuid + -n + This program generally tries to setuid `nobody', unless this flag is + set. The setuid call will fail if this program is not run as root (in + which case, use this flag). + + --version + -V + Print the version number and exit. + + --class classname + -c classname + Use `classname' as the concrete SMTP proxy class. Uses `PureProxy' by + default. + + --size limit + -s limit + Restrict the total size of the incoming message to "limit" number of + bytes via the RFC 1870 SIZE extension. Defaults to 33554432 bytes. + + --smtputf8 + -u + Enable the SMTPUTF8 extension and behave as an RFC 6531 smtp proxy. + + --debug + -d + Turn on debugging prints. + + --help + -h + Print this message and exit. + +Version: %(__version__)s + +If localhost is not given then `localhost' is used, and if localport is not +given then 8025 is used. If remotehost is not given then `localhost' is used, +and if remoteport is not given, then 25 is used. +""" + +# Overview: +# +# This file implements the minimal SMTP protocol as defined in RFC 5321. It +# has a hierarchy of classes which implement the backend functionality for the +# smtpd. A number of classes are provided: +# +# SMTPServer - the base class for the backend. Raises NotImplementedError +# if you try to use it. +# +# DebuggingServer - simply prints each message it receives on stdout. +# +# PureProxy - Proxies all messages to a real smtpd which does final +# delivery. One known problem with this class is that it doesn't handle +# SMTP errors from the backend server at all. This should be fixed +# (contributions are welcome!). +# +# +# Author: Barry Warsaw +# +# TODO: +# +# - support mailbox delivery +# - alias files +# - Handle more ESMTP extensions +# - handle error codes from the backend smtpd + +import sys +import os +import errno +import getopt +import time +import socket +import collections +from warnings import _deprecated, warn +from email._header_value_parser import get_addr_spec, get_angle_addr + +__all__ = [ + "SMTPChannel", "SMTPServer", "DebuggingServer", "PureProxy", +] + +_DEPRECATION_MSG = ('The {name} module is deprecated and unmaintained and will ' + 'be removed in Python {remove}. Please see aiosmtpd ' + '(https://aiosmtpd.readthedocs.io/) for the recommended ' + 'replacement.') +_deprecated(__name__, _DEPRECATION_MSG, remove=(3, 12)) + + +# These are imported after the above warning so that users get the correct +# deprecation warning. +import asyncore +import asynchat + + +program = sys.argv[0] +__version__ = 'Python SMTP proxy version 0.3' + + +class Devnull: + def write(self, msg): pass + def flush(self): pass + + +DEBUGSTREAM = Devnull() +NEWLINE = '\n' +COMMASPACE = ', ' +DATA_SIZE_DEFAULT = 33554432 + + +def usage(code, msg=''): + print(__doc__ % globals(), file=sys.stderr) + if msg: + print(msg, file=sys.stderr) + sys.exit(code) + + +class SMTPChannel(asynchat.async_chat): + COMMAND = 0 + DATA = 1 + + command_size_limit = 512 + command_size_limits = collections.defaultdict(lambda x=command_size_limit: x) + + @property + def max_command_size_limit(self): + try: + return max(self.command_size_limits.values()) + except ValueError: + return self.command_size_limit + + def __init__(self, server, conn, addr, data_size_limit=DATA_SIZE_DEFAULT, + map=None, enable_SMTPUTF8=False, decode_data=False): + asynchat.async_chat.__init__(self, conn, map=map) + self.smtp_server = server + self.conn = conn + self.addr = addr + self.data_size_limit = data_size_limit + self.enable_SMTPUTF8 = enable_SMTPUTF8 + self._decode_data = decode_data + if enable_SMTPUTF8 and decode_data: + raise ValueError("decode_data and enable_SMTPUTF8 cannot" + " be set to True at the same time") + if decode_data: + self._emptystring = '' + self._linesep = '\r\n' + self._dotsep = '.' + self._newline = NEWLINE + else: + self._emptystring = b'' + self._linesep = b'\r\n' + self._dotsep = ord(b'.') + self._newline = b'\n' + self._set_rset_state() + self.seen_greeting = '' + self.extended_smtp = False + self.command_size_limits.clear() + self.fqdn = socket.getfqdn() + try: + self.peer = conn.getpeername() + except OSError as err: + # a race condition may occur if the other end is closing + # before we can get the peername + self.close() + if err.errno != errno.ENOTCONN: + raise + return + print('Peer:', repr(self.peer), file=DEBUGSTREAM) + self.push('220 %s %s' % (self.fqdn, __version__)) + + def _set_post_data_state(self): + """Reset state variables to their post-DATA state.""" + self.smtp_state = self.COMMAND + self.mailfrom = None + self.rcpttos = [] + self.require_SMTPUTF8 = False + self.num_bytes = 0 + self.set_terminator(b'\r\n') + + def _set_rset_state(self): + """Reset all state variables except the greeting.""" + self._set_post_data_state() + self.received_data = '' + self.received_lines = [] + + + # properties for backwards-compatibility + @property + def __server(self): + warn("Access to __server attribute on SMTPChannel is deprecated, " + "use 'smtp_server' instead", DeprecationWarning, 2) + return self.smtp_server + @__server.setter + def __server(self, value): + warn("Setting __server attribute on SMTPChannel is deprecated, " + "set 'smtp_server' instead", DeprecationWarning, 2) + self.smtp_server = value + + @property + def __line(self): + warn("Access to __line attribute on SMTPChannel is deprecated, " + "use 'received_lines' instead", DeprecationWarning, 2) + return self.received_lines + @__line.setter + def __line(self, value): + warn("Setting __line attribute on SMTPChannel is deprecated, " + "set 'received_lines' instead", DeprecationWarning, 2) + self.received_lines = value + + @property + def __state(self): + warn("Access to __state attribute on SMTPChannel is deprecated, " + "use 'smtp_state' instead", DeprecationWarning, 2) + return self.smtp_state + @__state.setter + def __state(self, value): + warn("Setting __state attribute on SMTPChannel is deprecated, " + "set 'smtp_state' instead", DeprecationWarning, 2) + self.smtp_state = value + + @property + def __greeting(self): + warn("Access to __greeting attribute on SMTPChannel is deprecated, " + "use 'seen_greeting' instead", DeprecationWarning, 2) + return self.seen_greeting + @__greeting.setter + def __greeting(self, value): + warn("Setting __greeting attribute on SMTPChannel is deprecated, " + "set 'seen_greeting' instead", DeprecationWarning, 2) + self.seen_greeting = value + + @property + def __mailfrom(self): + warn("Access to __mailfrom attribute on SMTPChannel is deprecated, " + "use 'mailfrom' instead", DeprecationWarning, 2) + return self.mailfrom + @__mailfrom.setter + def __mailfrom(self, value): + warn("Setting __mailfrom attribute on SMTPChannel is deprecated, " + "set 'mailfrom' instead", DeprecationWarning, 2) + self.mailfrom = value + + @property + def __rcpttos(self): + warn("Access to __rcpttos attribute on SMTPChannel is deprecated, " + "use 'rcpttos' instead", DeprecationWarning, 2) + return self.rcpttos + @__rcpttos.setter + def __rcpttos(self, value): + warn("Setting __rcpttos attribute on SMTPChannel is deprecated, " + "set 'rcpttos' instead", DeprecationWarning, 2) + self.rcpttos = value + + @property + def __data(self): + warn("Access to __data attribute on SMTPChannel is deprecated, " + "use 'received_data' instead", DeprecationWarning, 2) + return self.received_data + @__data.setter + def __data(self, value): + warn("Setting __data attribute on SMTPChannel is deprecated, " + "set 'received_data' instead", DeprecationWarning, 2) + self.received_data = value + + @property + def __fqdn(self): + warn("Access to __fqdn attribute on SMTPChannel is deprecated, " + "use 'fqdn' instead", DeprecationWarning, 2) + return self.fqdn + @__fqdn.setter + def __fqdn(self, value): + warn("Setting __fqdn attribute on SMTPChannel is deprecated, " + "set 'fqdn' instead", DeprecationWarning, 2) + self.fqdn = value + + @property + def __peer(self): + warn("Access to __peer attribute on SMTPChannel is deprecated, " + "use 'peer' instead", DeprecationWarning, 2) + return self.peer + @__peer.setter + def __peer(self, value): + warn("Setting __peer attribute on SMTPChannel is deprecated, " + "set 'peer' instead", DeprecationWarning, 2) + self.peer = value + + @property + def __conn(self): + warn("Access to __conn attribute on SMTPChannel is deprecated, " + "use 'conn' instead", DeprecationWarning, 2) + return self.conn + @__conn.setter + def __conn(self, value): + warn("Setting __conn attribute on SMTPChannel is deprecated, " + "set 'conn' instead", DeprecationWarning, 2) + self.conn = value + + @property + def __addr(self): + warn("Access to __addr attribute on SMTPChannel is deprecated, " + "use 'addr' instead", DeprecationWarning, 2) + return self.addr + @__addr.setter + def __addr(self, value): + warn("Setting __addr attribute on SMTPChannel is deprecated, " + "set 'addr' instead", DeprecationWarning, 2) + self.addr = value + + # Overrides base class for convenience. + def push(self, msg): + asynchat.async_chat.push(self, bytes( + msg + '\r\n', 'utf-8' if self.require_SMTPUTF8 else 'ascii')) + + # Implementation of base class abstract method + def collect_incoming_data(self, data): + limit = None + if self.smtp_state == self.COMMAND: + limit = self.max_command_size_limit + elif self.smtp_state == self.DATA: + limit = self.data_size_limit + if limit and self.num_bytes > limit: + return + elif limit: + self.num_bytes += len(data) + if self._decode_data: + self.received_lines.append(str(data, 'utf-8')) + else: + self.received_lines.append(data) + + # Implementation of base class abstract method + def found_terminator(self): + line = self._emptystring.join(self.received_lines) + print('Data:', repr(line), file=DEBUGSTREAM) + self.received_lines = [] + if self.smtp_state == self.COMMAND: + sz, self.num_bytes = self.num_bytes, 0 + if not line: + self.push('500 Error: bad syntax') + return + if not self._decode_data: + line = str(line, 'utf-8') + i = line.find(' ') + if i < 0: + command = line.upper() + arg = None + else: + command = line[:i].upper() + arg = line[i+1:].strip() + max_sz = (self.command_size_limits[command] + if self.extended_smtp else self.command_size_limit) + if sz > max_sz: + self.push('500 Error: line too long') + return + method = getattr(self, 'smtp_' + command, None) + if not method: + self.push('500 Error: command "%s" not recognized' % command) + return + method(arg) + return + else: + if self.smtp_state != self.DATA: + self.push('451 Internal confusion') + self.num_bytes = 0 + return + if self.data_size_limit and self.num_bytes > self.data_size_limit: + self.push('552 Error: Too much mail data') + self.num_bytes = 0 + return + # Remove extraneous carriage returns and de-transparency according + # to RFC 5321, Section 4.5.2. + data = [] + for text in line.split(self._linesep): + if text and text[0] == self._dotsep: + data.append(text[1:]) + else: + data.append(text) + self.received_data = self._newline.join(data) + args = (self.peer, self.mailfrom, self.rcpttos, self.received_data) + kwargs = {} + if not self._decode_data: + kwargs = { + 'mail_options': self.mail_options, + 'rcpt_options': self.rcpt_options, + } + status = self.smtp_server.process_message(*args, **kwargs) + self._set_post_data_state() + if not status: + self.push('250 OK') + else: + self.push(status) + + # SMTP and ESMTP commands + def smtp_HELO(self, arg): + if not arg: + self.push('501 Syntax: HELO hostname') + return + # See issue #21783 for a discussion of this behavior. + if self.seen_greeting: + self.push('503 Duplicate HELO/EHLO') + return + self._set_rset_state() + self.seen_greeting = arg + self.push('250 %s' % self.fqdn) + + def smtp_EHLO(self, arg): + if not arg: + self.push('501 Syntax: EHLO hostname') + return + # See issue #21783 for a discussion of this behavior. + if self.seen_greeting: + self.push('503 Duplicate HELO/EHLO') + return + self._set_rset_state() + self.seen_greeting = arg + self.extended_smtp = True + self.push('250-%s' % self.fqdn) + if self.data_size_limit: + self.push('250-SIZE %s' % self.data_size_limit) + self.command_size_limits['MAIL'] += 26 + if not self._decode_data: + self.push('250-8BITMIME') + if self.enable_SMTPUTF8: + self.push('250-SMTPUTF8') + self.command_size_limits['MAIL'] += 10 + self.push('250 HELP') + + def smtp_NOOP(self, arg): + if arg: + self.push('501 Syntax: NOOP') + else: + self.push('250 OK') + + def smtp_QUIT(self, arg): + # args is ignored + self.push('221 Bye') + self.close_when_done() + + def _strip_command_keyword(self, keyword, arg): + keylen = len(keyword) + if arg[:keylen].upper() == keyword: + return arg[keylen:].strip() + return '' + + def _getaddr(self, arg): + if not arg: + return '', '' + if arg.lstrip().startswith('<'): + address, rest = get_angle_addr(arg) + else: + address, rest = get_addr_spec(arg) + if not address: + return address, rest + return address.addr_spec, rest + + def _getparams(self, params): + # Return params as dictionary. Return None if not all parameters + # appear to be syntactically valid according to RFC 1869. + result = {} + for param in params: + param, eq, value = param.partition('=') + if not param.isalnum() or eq and not value: + return None + result[param] = value if eq else True + return result + + def smtp_HELP(self, arg): + if arg: + extended = ' [SP ]' + lc_arg = arg.upper() + if lc_arg == 'EHLO': + self.push('250 Syntax: EHLO hostname') + elif lc_arg == 'HELO': + self.push('250 Syntax: HELO hostname') + elif lc_arg == 'MAIL': + msg = '250 Syntax: MAIL FROM:
' + if self.extended_smtp: + msg += extended + self.push(msg) + elif lc_arg == 'RCPT': + msg = '250 Syntax: RCPT TO:
' + if self.extended_smtp: + msg += extended + self.push(msg) + elif lc_arg == 'DATA': + self.push('250 Syntax: DATA') + elif lc_arg == 'RSET': + self.push('250 Syntax: RSET') + elif lc_arg == 'NOOP': + self.push('250 Syntax: NOOP') + elif lc_arg == 'QUIT': + self.push('250 Syntax: QUIT') + elif lc_arg == 'VRFY': + self.push('250 Syntax: VRFY
') + else: + self.push('501 Supported commands: EHLO HELO MAIL RCPT ' + 'DATA RSET NOOP QUIT VRFY') + else: + self.push('250 Supported commands: EHLO HELO MAIL RCPT DATA ' + 'RSET NOOP QUIT VRFY') + + def smtp_VRFY(self, arg): + if arg: + address, params = self._getaddr(arg) + if address: + self.push('252 Cannot VRFY user, but will accept message ' + 'and attempt delivery') + else: + self.push('502 Could not VRFY %s' % arg) + else: + self.push('501 Syntax: VRFY
') + + def smtp_MAIL(self, arg): + if not self.seen_greeting: + self.push('503 Error: send HELO first') + return + print('===> MAIL', arg, file=DEBUGSTREAM) + syntaxerr = '501 Syntax: MAIL FROM:
' + if self.extended_smtp: + syntaxerr += ' [SP ]' + if arg is None: + self.push(syntaxerr) + return + arg = self._strip_command_keyword('FROM:', arg) + address, params = self._getaddr(arg) + if not address: + self.push(syntaxerr) + return + if not self.extended_smtp and params: + self.push(syntaxerr) + return + if self.mailfrom: + self.push('503 Error: nested MAIL command') + return + self.mail_options = params.upper().split() + params = self._getparams(self.mail_options) + if params is None: + self.push(syntaxerr) + return + if not self._decode_data: + body = params.pop('BODY', '7BIT') + if body not in ['7BIT', '8BITMIME']: + self.push('501 Error: BODY can only be one of 7BIT, 8BITMIME') + return + if self.enable_SMTPUTF8: + smtputf8 = params.pop('SMTPUTF8', False) + if smtputf8 is True: + self.require_SMTPUTF8 = True + elif smtputf8 is not False: + self.push('501 Error: SMTPUTF8 takes no arguments') + return + size = params.pop('SIZE', None) + if size: + if not size.isdigit(): + self.push(syntaxerr) + return + elif self.data_size_limit and int(size) > self.data_size_limit: + self.push('552 Error: message size exceeds fixed maximum message size') + return + if len(params.keys()) > 0: + self.push('555 MAIL FROM parameters not recognized or not implemented') + return + self.mailfrom = address + print('sender:', self.mailfrom, file=DEBUGSTREAM) + self.push('250 OK') + + def smtp_RCPT(self, arg): + if not self.seen_greeting: + self.push('503 Error: send HELO first'); + return + print('===> RCPT', arg, file=DEBUGSTREAM) + if not self.mailfrom: + self.push('503 Error: need MAIL command') + return + syntaxerr = '501 Syntax: RCPT TO:
' + if self.extended_smtp: + syntaxerr += ' [SP ]' + if arg is None: + self.push(syntaxerr) + return + arg = self._strip_command_keyword('TO:', arg) + address, params = self._getaddr(arg) + if not address: + self.push(syntaxerr) + return + if not self.extended_smtp and params: + self.push(syntaxerr) + return + self.rcpt_options = params.upper().split() + params = self._getparams(self.rcpt_options) + if params is None: + self.push(syntaxerr) + return + # XXX currently there are no options we recognize. + if len(params.keys()) > 0: + self.push('555 RCPT TO parameters not recognized or not implemented') + return + self.rcpttos.append(address) + print('recips:', self.rcpttos, file=DEBUGSTREAM) + self.push('250 OK') + + def smtp_RSET(self, arg): + if arg: + self.push('501 Syntax: RSET') + return + self._set_rset_state() + self.push('250 OK') + + def smtp_DATA(self, arg): + if not self.seen_greeting: + self.push('503 Error: send HELO first'); + return + if not self.rcpttos: + self.push('503 Error: need RCPT command') + return + if arg: + self.push('501 Syntax: DATA') + return + self.smtp_state = self.DATA + self.set_terminator(b'\r\n.\r\n') + self.push('354 End data with .') + + # Commands that have not been implemented + def smtp_EXPN(self, arg): + self.push('502 EXPN not implemented') + + +class SMTPServer(asyncore.dispatcher): + # SMTPChannel class to use for managing client connections + channel_class = SMTPChannel + + def __init__(self, localaddr, remoteaddr, + data_size_limit=DATA_SIZE_DEFAULT, map=None, + enable_SMTPUTF8=False, decode_data=False): + self._localaddr = localaddr + self._remoteaddr = remoteaddr + self.data_size_limit = data_size_limit + self.enable_SMTPUTF8 = enable_SMTPUTF8 + self._decode_data = decode_data + if enable_SMTPUTF8 and decode_data: + raise ValueError("decode_data and enable_SMTPUTF8 cannot" + " be set to True at the same time") + asyncore.dispatcher.__init__(self, map=map) + try: + gai_results = socket.getaddrinfo(*localaddr, + type=socket.SOCK_STREAM) + self.create_socket(gai_results[0][0], gai_results[0][1]) + # try to re-use a server port if possible + self.set_reuse_addr() + self.bind(localaddr) + self.listen(5) + except: + self.close() + raise + else: + print('%s started at %s\n\tLocal addr: %s\n\tRemote addr:%s' % ( + self.__class__.__name__, time.ctime(time.time()), + localaddr, remoteaddr), file=DEBUGSTREAM) + + def handle_accepted(self, conn, addr): + print('Incoming connection from %s' % repr(addr), file=DEBUGSTREAM) + channel = self.channel_class(self, + conn, + addr, + self.data_size_limit, + self._map, + self.enable_SMTPUTF8, + self._decode_data) + + # API for "doing something useful with the message" + def process_message(self, peer, mailfrom, rcpttos, data, **kwargs): + """Override this abstract method to handle messages from the client. + + peer is a tuple containing (ipaddr, port) of the client that made the + socket connection to our smtp port. + + mailfrom is the raw address the client claims the message is coming + from. + + rcpttos is a list of raw addresses the client wishes to deliver the + message to. + + data is a string containing the entire full text of the message, + headers (if supplied) and all. It has been `de-transparencied' + according to RFC 821, Section 4.5.2. In other words, a line + containing a `.' followed by other text has had the leading dot + removed. + + kwargs is a dictionary containing additional information. It is + empty if decode_data=True was given as init parameter, otherwise + it will contain the following keys: + 'mail_options': list of parameters to the mail command. All + elements are uppercase strings. Example: + ['BODY=8BITMIME', 'SMTPUTF8']. + 'rcpt_options': same, for the rcpt command. + + This function should return None for a normal `250 Ok' response; + otherwise, it should return the desired response string in RFC 821 + format. + + """ + raise NotImplementedError + + +class DebuggingServer(SMTPServer): + + def _print_message_content(self, peer, data): + inheaders = 1 + lines = data.splitlines() + for line in lines: + # headers first + if inheaders and not line: + peerheader = 'X-Peer: ' + peer[0] + if not isinstance(data, str): + # decoded_data=false; make header match other binary output + peerheader = repr(peerheader.encode('utf-8')) + print(peerheader) + inheaders = 0 + if not isinstance(data, str): + # Avoid spurious 'str on bytes instance' warning. + line = repr(line) + print(line) + + def process_message(self, peer, mailfrom, rcpttos, data, **kwargs): + print('---------- MESSAGE FOLLOWS ----------') + if kwargs: + if kwargs.get('mail_options'): + print('mail options: %s' % kwargs['mail_options']) + if kwargs.get('rcpt_options'): + print('rcpt options: %s\n' % kwargs['rcpt_options']) + self._print_message_content(peer, data) + print('------------ END MESSAGE ------------') + + +class PureProxy(SMTPServer): + def __init__(self, *args, **kwargs): + if 'enable_SMTPUTF8' in kwargs and kwargs['enable_SMTPUTF8']: + raise ValueError("PureProxy does not support SMTPUTF8.") + super(PureProxy, self).__init__(*args, **kwargs) + + def process_message(self, peer, mailfrom, rcpttos, data): + lines = data.split('\n') + # Look for the last header + i = 0 + for line in lines: + if not line: + break + i += 1 + lines.insert(i, 'X-Peer: %s' % peer[0]) + data = NEWLINE.join(lines) + refused = self._deliver(mailfrom, rcpttos, data) + # TBD: what to do with refused addresses? + print('we got some refusals:', refused, file=DEBUGSTREAM) + + def _deliver(self, mailfrom, rcpttos, data): + import smtplib + refused = {} + try: + s = smtplib.SMTP() + s.connect(self._remoteaddr[0], self._remoteaddr[1]) + try: + refused = s.sendmail(mailfrom, rcpttos, data) + finally: + s.quit() + except smtplib.SMTPRecipientsRefused as e: + print('got SMTPRecipientsRefused', file=DEBUGSTREAM) + refused = e.recipients + except (OSError, smtplib.SMTPException) as e: + print('got', e.__class__, file=DEBUGSTREAM) + # All recipients were refused. If the exception had an associated + # error code, use it. Otherwise,fake it with a non-triggering + # exception code. + errcode = getattr(e, 'smtp_code', -1) + errmsg = getattr(e, 'smtp_error', 'ignore') + for r in rcpttos: + refused[r] = (errcode, errmsg) + return refused + + +class Options: + setuid = True + classname = 'PureProxy' + size_limit = None + enable_SMTPUTF8 = False + + +def parseargs(): + global DEBUGSTREAM + try: + opts, args = getopt.getopt( + sys.argv[1:], 'nVhc:s:du', + ['class=', 'nosetuid', 'version', 'help', 'size=', 'debug', + 'smtputf8']) + except getopt.error as e: + usage(1, e) + + options = Options() + for opt, arg in opts: + if opt in ('-h', '--help'): + usage(0) + elif opt in ('-V', '--version'): + print(__version__) + sys.exit(0) + elif opt in ('-n', '--nosetuid'): + options.setuid = False + elif opt in ('-c', '--class'): + options.classname = arg + elif opt in ('-d', '--debug'): + DEBUGSTREAM = sys.stderr + elif opt in ('-u', '--smtputf8'): + options.enable_SMTPUTF8 = True + elif opt in ('-s', '--size'): + try: + int_size = int(arg) + options.size_limit = int_size + except: + print('Invalid size: ' + arg, file=sys.stderr) + sys.exit(1) + + # parse the rest of the arguments + if len(args) < 1: + localspec = 'localhost:8025' + remotespec = 'localhost:25' + elif len(args) < 2: + localspec = args[0] + remotespec = 'localhost:25' + elif len(args) < 3: + localspec = args[0] + remotespec = args[1] + else: + usage(1, 'Invalid arguments: %s' % COMMASPACE.join(args)) + + # split into host/port pairs + i = localspec.find(':') + if i < 0: + usage(1, 'Bad local spec: %s' % localspec) + options.localhost = localspec[:i] + try: + options.localport = int(localspec[i+1:]) + except ValueError: + usage(1, 'Bad local port: %s' % localspec) + i = remotespec.find(':') + if i < 0: + usage(1, 'Bad remote spec: %s' % remotespec) + options.remotehost = remotespec[:i] + try: + options.remoteport = int(remotespec[i+1:]) + except ValueError: + usage(1, 'Bad remote port: %s' % remotespec) + return options + + +if __name__ == '__main__': + options = parseargs() + # Become nobody + classname = options.classname + if "." in classname: + lastdot = classname.rfind(".") + mod = __import__(classname[:lastdot], globals(), locals(), [""]) + classname = classname[lastdot+1:] + else: + import __main__ as mod + class_ = getattr(mod, classname) + proxy = class_((options.localhost, options.localport), + (options.remotehost, options.remoteport), + options.size_limit, enable_SMTPUTF8=options.enable_SMTPUTF8) + if options.setuid: + try: + import pwd + except ImportError: + print('Cannot import module "pwd"; try running with -n option.', file=sys.stderr) + sys.exit(1) + nobody = pwd.getpwnam('nobody')[2] + try: + os.setuid(nobody) + except PermissionError: + print('Cannot setuid "nobody"; try running with -n option.', file=sys.stderr) + sys.exit(1) + try: + asyncore.loop() + except KeyboardInterrupt: + pass diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/smtplib.py b/physworld_p1_20261018/envs/p1/lib/python3.11/smtplib.py new file mode 100644 index 0000000000000000000000000000000000000000..324a1c19f12afe52cfdc3e375d4b4157f3937c54 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/smtplib.py @@ -0,0 +1,1140 @@ +#! /usr/bin/env python3 + +'''SMTP/ESMTP client class. + +This should follow RFC 821 (SMTP), RFC 1869 (ESMTP), RFC 2554 (SMTP +Authentication) and RFC 2487 (Secure SMTP over TLS). + +Notes: + +Please remember, when doing ESMTP, that the names of the SMTP service +extensions are NOT the same thing as the option keywords for the RCPT +and MAIL commands! + +Example: + + >>> import smtplib + >>> s=smtplib.SMTP("localhost") + >>> print(s.help()) + This is Sendmail version 8.8.4 + Topics: + HELO EHLO MAIL RCPT DATA + RSET NOOP QUIT HELP VRFY + EXPN VERB ETRN DSN + For more info use "HELP ". + To report bugs in the implementation send email to + sendmail-bugs@sendmail.org. + For local information send email to Postmaster at your site. + End of HELP info + >>> s.putcmd("vrfy","someone@here") + >>> s.getreply() + (250, "Somebody OverHere ") + >>> s.quit() +''' + +# Author: The Dragon De Monsyne +# ESMTP support, test code and doc fixes added by +# Eric S. Raymond +# Better RFC 821 compliance (MAIL and RCPT, and CRLF in data) +# by Carey Evans , for picky mail servers. +# RFC 2554 (authentication) support by Gerhard Haering . +# +# This was modified from the Python 1.5 library HTTP lib. + +import socket +import io +import re +import email.utils +import email.message +import email.generator +import base64 +import hmac +import copy +import datetime +import sys +from email.base64mime import body_encode as encode_base64 + +__all__ = ["SMTPException", "SMTPNotSupportedError", "SMTPServerDisconnected", "SMTPResponseException", + "SMTPSenderRefused", "SMTPRecipientsRefused", "SMTPDataError", + "SMTPConnectError", "SMTPHeloError", "SMTPAuthenticationError", + "quoteaddr", "quotedata", "SMTP"] + +SMTP_PORT = 25 +SMTP_SSL_PORT = 465 +CRLF = "\r\n" +bCRLF = b"\r\n" +_MAXLINE = 8192 # more than 8 times larger than RFC 821, 4.5.3 +_MAXCHALLENGE = 5 # Maximum number of AUTH challenges sent + +OLDSTYLE_AUTH = re.compile(r"auth=(.*)", re.I) + +# Exception classes used by this module. +class SMTPException(OSError): + """Base class for all exceptions raised by this module.""" + +class SMTPNotSupportedError(SMTPException): + """The command or option is not supported by the SMTP server. + + This exception is raised when an attempt is made to run a command or a + command with an option which is not supported by the server. + """ + +class SMTPServerDisconnected(SMTPException): + """Not connected to any SMTP server. + + This exception is raised when the server unexpectedly disconnects, + or when an attempt is made to use the SMTP instance before + connecting it to a server. + """ + +class SMTPResponseException(SMTPException): + """Base class for all exceptions that include an SMTP error code. + + These exceptions are generated in some instances when the SMTP + server returns an error code. The error code is stored in the + `smtp_code' attribute of the error, and the `smtp_error' attribute + is set to the error message. + """ + + def __init__(self, code, msg): + self.smtp_code = code + self.smtp_error = msg + self.args = (code, msg) + +class SMTPSenderRefused(SMTPResponseException): + """Sender address refused. + + In addition to the attributes set by on all SMTPResponseException + exceptions, this sets `sender' to the string that the SMTP refused. + """ + + def __init__(self, code, msg, sender): + self.smtp_code = code + self.smtp_error = msg + self.sender = sender + self.args = (code, msg, sender) + +class SMTPRecipientsRefused(SMTPException): + """All recipient addresses refused. + + The errors for each recipient are accessible through the attribute + 'recipients', which is a dictionary of exactly the same sort as + SMTP.sendmail() returns. + """ + + def __init__(self, recipients): + self.recipients = recipients + self.args = (recipients,) + + +class SMTPDataError(SMTPResponseException): + """The SMTP server didn't accept the data.""" + +class SMTPConnectError(SMTPResponseException): + """Error during connection establishment.""" + +class SMTPHeloError(SMTPResponseException): + """The server refused our HELO reply.""" + +class SMTPAuthenticationError(SMTPResponseException): + """Authentication error. + + Most probably the server didn't accept the username/password + combination provided. + """ + +def quoteaddr(addrstring): + """Quote a subset of the email addresses defined by RFC 821. + + Should be able to handle anything email.utils.parseaddr can handle. + """ + displayname, addr = email.utils.parseaddr(addrstring) + if (displayname, addr) == ('', ''): + # parseaddr couldn't parse it, use it as is and hope for the best. + if addrstring.strip().startswith('<'): + return addrstring + return "<%s>" % addrstring + return "<%s>" % addr + +def _addr_only(addrstring): + displayname, addr = email.utils.parseaddr(addrstring) + if (displayname, addr) == ('', ''): + # parseaddr couldn't parse it, so use it as is. + return addrstring + return addr + +# Legacy method kept for backward compatibility. +def quotedata(data): + """Quote data for email. + + Double leading '.', and change Unix newline '\\n', or Mac '\\r' into + internet CRLF end-of-line. + """ + return re.sub(r'(?m)^\.', '..', + re.sub(r'(?:\r\n|\n|\r(?!\n))', CRLF, data)) + +def _quote_periods(bindata): + return re.sub(br'(?m)^\.', b'..', bindata) + +def _fix_eols(data): + return re.sub(r'(?:\r\n|\n|\r(?!\n))', CRLF, data) + +try: + import ssl +except ImportError: + _have_ssl = False +else: + _have_ssl = True + + +class SMTP: + """This class manages a connection to an SMTP or ESMTP server. + SMTP Objects: + SMTP objects have the following attributes: + helo_resp + This is the message given by the server in response to the + most recent HELO command. + + ehlo_resp + This is the message given by the server in response to the + most recent EHLO command. This is usually multiline. + + does_esmtp + This is a True value _after you do an EHLO command_, if the + server supports ESMTP. + + esmtp_features + This is a dictionary, which, if the server supports ESMTP, + will _after you do an EHLO command_, contain the names of the + SMTP service extensions this server supports, and their + parameters (if any). + + Note, all extension names are mapped to lower case in the + dictionary. + + See each method's docstrings for details. In general, there is a + method of the same name to perform each SMTP command. There is also a + method called 'sendmail' that will do an entire mail transaction. + """ + debuglevel = 0 + + sock = None + file = None + helo_resp = None + ehlo_msg = "ehlo" + ehlo_resp = None + does_esmtp = False + default_port = SMTP_PORT + + def __init__(self, host='', port=0, local_hostname=None, + timeout=socket._GLOBAL_DEFAULT_TIMEOUT, + source_address=None): + """Initialize a new instance. + + If specified, `host` is the name of the remote host to which to + connect. If specified, `port` specifies the port to which to connect. + By default, smtplib.SMTP_PORT is used. If a host is specified the + connect method is called, and if it returns anything other than a + success code an SMTPConnectError is raised. If specified, + `local_hostname` is used as the FQDN of the local host in the HELO/EHLO + command. Otherwise, the local hostname is found using + socket.getfqdn(). The `source_address` parameter takes a 2-tuple (host, + port) for the socket to bind to as its source address before + connecting. If the host is '' and port is 0, the OS default behavior + will be used. + + """ + self._host = host + self.timeout = timeout + self.esmtp_features = {} + self.command_encoding = 'ascii' + self.source_address = source_address + self._auth_challenge_count = 0 + + if host: + (code, msg) = self.connect(host, port) + if code != 220: + self.close() + raise SMTPConnectError(code, msg) + if local_hostname is not None: + self.local_hostname = local_hostname + else: + # RFC 2821 says we should use the fqdn in the EHLO/HELO verb, and + # if that can't be calculated, that we should use a domain literal + # instead (essentially an encoded IP address like [A.B.C.D]). + fqdn = socket.getfqdn() + if '.' in fqdn: + self.local_hostname = fqdn + else: + # We can't find an fqdn hostname, so use a domain literal + addr = '127.0.0.1' + try: + addr = socket.gethostbyname(socket.gethostname()) + except socket.gaierror: + pass + self.local_hostname = '[%s]' % addr + + def __enter__(self): + return self + + def __exit__(self, *args): + try: + code, message = self.docmd("QUIT") + if code != 221: + raise SMTPResponseException(code, message) + except SMTPServerDisconnected: + pass + finally: + self.close() + + def set_debuglevel(self, debuglevel): + """Set the debug output level. + + A non-false value results in debug messages for connection and for all + messages sent to and received from the server. + + """ + self.debuglevel = debuglevel + + def _print_debug(self, *args): + if self.debuglevel > 1: + print(datetime.datetime.now().time(), *args, file=sys.stderr) + else: + print(*args, file=sys.stderr) + + def _get_socket(self, host, port, timeout): + # This makes it simpler for SMTP_SSL to use the SMTP connect code + # and just alter the socket connection bit. + if timeout is not None and not timeout: + raise ValueError('Non-blocking socket (timeout=0) is not supported') + if self.debuglevel > 0: + self._print_debug('connect: to', (host, port), self.source_address) + return socket.create_connection((host, port), timeout, + self.source_address) + + def connect(self, host='localhost', port=0, source_address=None): + """Connect to a host on a given port. + + If the hostname ends with a colon (`:') followed by a number, and + there is no port specified, that suffix will be stripped off and the + number interpreted as the port number to use. + + Note: This method is automatically invoked by __init__, if a host is + specified during instantiation. + + """ + + if source_address: + self.source_address = source_address + + if not port and (host.find(':') == host.rfind(':')): + i = host.rfind(':') + if i >= 0: + host, port = host[:i], host[i + 1:] + try: + port = int(port) + except ValueError: + raise OSError("nonnumeric port") + if not port: + port = self.default_port + sys.audit("smtplib.connect", self, host, port) + self.sock = self._get_socket(host, port, self.timeout) + self.file = None + (code, msg) = self.getreply() + if self.debuglevel > 0: + self._print_debug('connect:', repr(msg)) + return (code, msg) + + def send(self, s): + """Send `s' to the server.""" + if self.debuglevel > 0: + self._print_debug('send:', repr(s)) + if self.sock: + if isinstance(s, str): + # send is used by the 'data' command, where command_encoding + # should not be used, but 'data' needs to convert the string to + # binary itself anyway, so that's not a problem. + s = s.encode(self.command_encoding) + sys.audit("smtplib.send", self, s) + try: + self.sock.sendall(s) + except OSError: + self.close() + raise SMTPServerDisconnected('Server not connected') + else: + raise SMTPServerDisconnected('please run connect() first') + + def putcmd(self, cmd, args=""): + """Send a command to the server.""" + if args == "": + s = cmd + else: + s = f'{cmd} {args}' + if '\r' in s or '\n' in s: + s = s.replace('\n', '\\n').replace('\r', '\\r') + raise ValueError( + f'command and arguments contain prohibited newline characters: {s}' + ) + self.send(f'{s}{CRLF}') + + def getreply(self): + """Get a reply from the server. + + Returns a tuple consisting of: + + - server response code (e.g. '250', or such, if all goes well) + Note: returns -1 if it can't read response code. + + - server response string corresponding to response code (multiline + responses are converted to a single, multiline string). + + Raises SMTPServerDisconnected if end-of-file is reached. + """ + resp = [] + if self.file is None: + self.file = self.sock.makefile('rb') + while 1: + try: + line = self.file.readline(_MAXLINE + 1) + except OSError as e: + self.close() + raise SMTPServerDisconnected("Connection unexpectedly closed: " + + str(e)) + if not line: + self.close() + raise SMTPServerDisconnected("Connection unexpectedly closed") + if self.debuglevel > 0: + self._print_debug('reply:', repr(line)) + if len(line) > _MAXLINE: + self.close() + raise SMTPResponseException(500, "Line too long.") + resp.append(line[4:].strip(b' \t\r\n')) + code = line[:3] + # Check that the error code is syntactically correct. + # Don't attempt to read a continuation line if it is broken. + try: + errcode = int(code) + except ValueError: + errcode = -1 + break + # Check if multiline response. + if line[3:4] != b"-": + break + + errmsg = b"\n".join(resp) + if self.debuglevel > 0: + self._print_debug('reply: retcode (%s); Msg: %a' % (errcode, errmsg)) + return errcode, errmsg + + def docmd(self, cmd, args=""): + """Send a command, and return its response code.""" + self.putcmd(cmd, args) + return self.getreply() + + # std smtp commands + def helo(self, name=''): + """SMTP 'helo' command. + Hostname to send for this command defaults to the FQDN of the local + host. + """ + self.putcmd("helo", name or self.local_hostname) + (code, msg) = self.getreply() + self.helo_resp = msg + return (code, msg) + + def ehlo(self, name=''): + """ SMTP 'ehlo' command. + Hostname to send for this command defaults to the FQDN of the local + host. + """ + self.esmtp_features = {} + self.putcmd(self.ehlo_msg, name or self.local_hostname) + (code, msg) = self.getreply() + # According to RFC1869 some (badly written) + # MTA's will disconnect on an ehlo. Toss an exception if + # that happens -ddm + if code == -1 and len(msg) == 0: + self.close() + raise SMTPServerDisconnected("Server not connected") + self.ehlo_resp = msg + if code != 250: + return (code, msg) + self.does_esmtp = True + #parse the ehlo response -ddm + assert isinstance(self.ehlo_resp, bytes), repr(self.ehlo_resp) + resp = self.ehlo_resp.decode("latin-1").split('\n') + del resp[0] + for each in resp: + # To be able to communicate with as many SMTP servers as possible, + # we have to take the old-style auth advertisement into account, + # because: + # 1) Else our SMTP feature parser gets confused. + # 2) There are some servers that only advertise the auth methods we + # support using the old style. + auth_match = OLDSTYLE_AUTH.match(each) + if auth_match: + # This doesn't remove duplicates, but that's no problem + self.esmtp_features["auth"] = self.esmtp_features.get("auth", "") \ + + " " + auth_match.groups(0)[0] + continue + + # RFC 1869 requires a space between ehlo keyword and parameters. + # It's actually stricter, in that only spaces are allowed between + # parameters, but were not going to check for that here. Note + # that the space isn't present if there are no parameters. + m = re.match(r'(?P[A-Za-z0-9][A-Za-z0-9\-]*) ?', each) + if m: + feature = m.group("feature").lower() + params = m.string[m.end("feature"):].strip() + if feature == "auth": + self.esmtp_features[feature] = self.esmtp_features.get(feature, "") \ + + " " + params + else: + self.esmtp_features[feature] = params + return (code, msg) + + def has_extn(self, opt): + """Does the server support a given SMTP service extension?""" + return opt.lower() in self.esmtp_features + + def help(self, args=''): + """SMTP 'help' command. + Returns help text from server.""" + self.putcmd("help", args) + return self.getreply()[1] + + def rset(self): + """SMTP 'rset' command -- resets session.""" + self.command_encoding = 'ascii' + return self.docmd("rset") + + def _rset(self): + """Internal 'rset' command which ignores any SMTPServerDisconnected error. + + Used internally in the library, since the server disconnected error + should appear to the application when the *next* command is issued, if + we are doing an internal "safety" reset. + """ + try: + self.rset() + except SMTPServerDisconnected: + pass + + def noop(self): + """SMTP 'noop' command -- doesn't do anything :>""" + return self.docmd("noop") + + def mail(self, sender, options=()): + """SMTP 'mail' command -- begins mail xfer session. + + This method may raise the following exceptions: + + SMTPNotSupportedError The options parameter includes 'SMTPUTF8' + but the SMTPUTF8 extension is not supported by + the server. + """ + optionlist = '' + if options and self.does_esmtp: + if any(x.lower()=='smtputf8' for x in options): + if self.has_extn('smtputf8'): + self.command_encoding = 'utf-8' + else: + raise SMTPNotSupportedError( + 'SMTPUTF8 not supported by server') + optionlist = ' ' + ' '.join(options) + self.putcmd("mail", "FROM:%s%s" % (quoteaddr(sender), optionlist)) + return self.getreply() + + def rcpt(self, recip, options=()): + """SMTP 'rcpt' command -- indicates 1 recipient for this mail.""" + optionlist = '' + if options and self.does_esmtp: + optionlist = ' ' + ' '.join(options) + self.putcmd("rcpt", "TO:%s%s" % (quoteaddr(recip), optionlist)) + return self.getreply() + + def data(self, msg): + """SMTP 'DATA' command -- sends message data to server. + + Automatically quotes lines beginning with a period per rfc821. + Raises SMTPDataError if there is an unexpected reply to the + DATA command; the return value from this method is the final + response code received when the all data is sent. If msg + is a string, lone '\\r' and '\\n' characters are converted to + '\\r\\n' characters. If msg is bytes, it is transmitted as is. + """ + self.putcmd("data") + (code, repl) = self.getreply() + if self.debuglevel > 0: + self._print_debug('data:', (code, repl)) + if code != 354: + raise SMTPDataError(code, repl) + else: + if isinstance(msg, str): + msg = _fix_eols(msg).encode('ascii') + q = _quote_periods(msg) + if q[-2:] != bCRLF: + q = q + bCRLF + q = q + b"." + bCRLF + self.send(q) + (code, msg) = self.getreply() + if self.debuglevel > 0: + self._print_debug('data:', (code, msg)) + return (code, msg) + + def verify(self, address): + """SMTP 'verify' command -- checks for address validity.""" + self.putcmd("vrfy", _addr_only(address)) + return self.getreply() + # a.k.a. + vrfy = verify + + def expn(self, address): + """SMTP 'expn' command -- expands a mailing list.""" + self.putcmd("expn", _addr_only(address)) + return self.getreply() + + # some useful methods + + def ehlo_or_helo_if_needed(self): + """Call self.ehlo() and/or self.helo() if needed. + + If there has been no previous EHLO or HELO command this session, this + method tries ESMTP EHLO first. + + This method may raise the following exceptions: + + SMTPHeloError The server didn't reply properly to + the helo greeting. + """ + if self.helo_resp is None and self.ehlo_resp is None: + if not (200 <= self.ehlo()[0] <= 299): + (code, resp) = self.helo() + if not (200 <= code <= 299): + raise SMTPHeloError(code, resp) + + def auth(self, mechanism, authobject, *, initial_response_ok=True): + """Authentication command - requires response processing. + + 'mechanism' specifies which authentication mechanism is to + be used - the valid values are those listed in the 'auth' + element of 'esmtp_features'. + + 'authobject' must be a callable object taking a single argument: + + data = authobject(challenge) + + It will be called to process the server's challenge response; the + challenge argument it is passed will be a bytes. It should return + an ASCII string that will be base64 encoded and sent to the server. + + Keyword arguments: + - initial_response_ok: Allow sending the RFC 4954 initial-response + to the AUTH command, if the authentication methods supports it. + """ + # RFC 4954 allows auth methods to provide an initial response. Not all + # methods support it. By definition, if they return something other + # than None when challenge is None, then they do. See issue #15014. + mechanism = mechanism.upper() + initial_response = (authobject() if initial_response_ok else None) + if initial_response is not None: + response = encode_base64(initial_response.encode('ascii'), eol='') + (code, resp) = self.docmd("AUTH", mechanism + " " + response) + self._auth_challenge_count = 1 + else: + (code, resp) = self.docmd("AUTH", mechanism) + self._auth_challenge_count = 0 + # If server responds with a challenge, send the response. + while code == 334: + self._auth_challenge_count += 1 + challenge = base64.decodebytes(resp) + response = encode_base64( + authobject(challenge).encode('ascii'), eol='') + (code, resp) = self.docmd(response) + # If server keeps sending challenges, something is wrong. + if self._auth_challenge_count > _MAXCHALLENGE: + raise SMTPException( + "Server AUTH mechanism infinite loop. Last response: " + + repr((code, resp)) + ) + if code in (235, 503): + return (code, resp) + raise SMTPAuthenticationError(code, resp) + + def auth_cram_md5(self, challenge=None): + """ Authobject to use with CRAM-MD5 authentication. Requires self.user + and self.password to be set.""" + # CRAM-MD5 does not support initial-response. + if challenge is None: + return None + return self.user + " " + hmac.HMAC( + self.password.encode('ascii'), challenge, 'md5').hexdigest() + + def auth_plain(self, challenge=None): + """ Authobject to use with PLAIN authentication. Requires self.user and + self.password to be set.""" + return "\0%s\0%s" % (self.user, self.password) + + def auth_login(self, challenge=None): + """ Authobject to use with LOGIN authentication. Requires self.user and + self.password to be set.""" + if challenge is None or self._auth_challenge_count < 2: + return self.user + else: + return self.password + + def login(self, user, password, *, initial_response_ok=True): + """Log in on an SMTP server that requires authentication. + + The arguments are: + - user: The user name to authenticate with. + - password: The password for the authentication. + + Keyword arguments: + - initial_response_ok: Allow sending the RFC 4954 initial-response + to the AUTH command, if the authentication methods supports it. + + If there has been no previous EHLO or HELO command this session, this + method tries ESMTP EHLO first. + + This method will return normally if the authentication was successful. + + This method may raise the following exceptions: + + SMTPHeloError The server didn't reply properly to + the helo greeting. + SMTPAuthenticationError The server didn't accept the username/ + password combination. + SMTPNotSupportedError The AUTH command is not supported by the + server. + SMTPException No suitable authentication method was + found. + """ + + self.ehlo_or_helo_if_needed() + if not self.has_extn("auth"): + raise SMTPNotSupportedError( + "SMTP AUTH extension not supported by server.") + + # Authentication methods the server claims to support + advertised_authlist = self.esmtp_features["auth"].split() + + # Authentication methods we can handle in our preferred order: + preferred_auths = ['CRAM-MD5', 'PLAIN', 'LOGIN'] + + # We try the supported authentications in our preferred order, if + # the server supports them. + authlist = [auth for auth in preferred_auths + if auth in advertised_authlist] + if not authlist: + raise SMTPException("No suitable authentication method found.") + + # Some servers advertise authentication methods they don't really + # support, so if authentication fails, we continue until we've tried + # all methods. + self.user, self.password = user, password + for authmethod in authlist: + method_name = 'auth_' + authmethod.lower().replace('-', '_') + try: + (code, resp) = self.auth( + authmethod, getattr(self, method_name), + initial_response_ok=initial_response_ok) + # 235 == 'Authentication successful' + # 503 == 'Error: already authenticated' + if code in (235, 503): + return (code, resp) + except SMTPAuthenticationError as e: + last_exception = e + + # We could not login successfully. Return result of last attempt. + raise last_exception + + def starttls(self, keyfile=None, certfile=None, context=None): + """Puts the connection to the SMTP server into TLS mode. + + If there has been no previous EHLO or HELO command this session, this + method tries ESMTP EHLO first. + + If the server supports TLS, this will encrypt the rest of the SMTP + session. If you provide the keyfile and certfile parameters, + the identity of the SMTP server and client can be checked. This, + however, depends on whether the socket module really checks the + certificates. + + This method may raise the following exceptions: + + SMTPHeloError The server didn't reply properly to + the helo greeting. + """ + self.ehlo_or_helo_if_needed() + if not self.has_extn("starttls"): + raise SMTPNotSupportedError( + "STARTTLS extension not supported by server.") + (resp, reply) = self.docmd("STARTTLS") + if resp == 220: + if not _have_ssl: + raise RuntimeError("No SSL support included in this Python") + if context is not None and keyfile is not None: + raise ValueError("context and keyfile arguments are mutually " + "exclusive") + if context is not None and certfile is not None: + raise ValueError("context and certfile arguments are mutually " + "exclusive") + if keyfile is not None or certfile is not None: + import warnings + warnings.warn("keyfile and certfile are deprecated, use a " + "custom context instead", DeprecationWarning, 2) + if context is None: + context = ssl._create_stdlib_context(certfile=certfile, + keyfile=keyfile) + self.sock = context.wrap_socket(self.sock, + server_hostname=self._host) + self.file = None + # RFC 3207: + # The client MUST discard any knowledge obtained from + # the server, such as the list of SMTP service extensions, + # which was not obtained from the TLS negotiation itself. + self.helo_resp = None + self.ehlo_resp = None + self.esmtp_features = {} + self.does_esmtp = False + else: + # RFC 3207: + # 501 Syntax error (no parameters allowed) + # 454 TLS not available due to temporary reason + raise SMTPResponseException(resp, reply) + return (resp, reply) + + def sendmail(self, from_addr, to_addrs, msg, mail_options=(), + rcpt_options=()): + """This command performs an entire mail transaction. + + The arguments are: + - from_addr : The address sending this mail. + - to_addrs : A list of addresses to send this mail to. A bare + string will be treated as a list with 1 address. + - msg : The message to send. + - mail_options : List of ESMTP options (such as 8bitmime) for the + mail command. + - rcpt_options : List of ESMTP options (such as DSN commands) for + all the rcpt commands. + + msg may be a string containing characters in the ASCII range, or a byte + string. A string is encoded to bytes using the ascii codec, and lone + \\r and \\n characters are converted to \\r\\n characters. + + If there has been no previous EHLO or HELO command this session, this + method tries ESMTP EHLO first. If the server does ESMTP, message size + and each of the specified options will be passed to it. If EHLO + fails, HELO will be tried and ESMTP options suppressed. + + This method will return normally if the mail is accepted for at least + one recipient. It returns a dictionary, with one entry for each + recipient that was refused. Each entry contains a tuple of the SMTP + error code and the accompanying error message sent by the server. + + This method may raise the following exceptions: + + SMTPHeloError The server didn't reply properly to + the helo greeting. + SMTPRecipientsRefused The server rejected ALL recipients + (no mail was sent). + SMTPSenderRefused The server didn't accept the from_addr. + SMTPDataError The server replied with an unexpected + error code (other than a refusal of + a recipient). + SMTPNotSupportedError The mail_options parameter includes 'SMTPUTF8' + but the SMTPUTF8 extension is not supported by + the server. + + Note: the connection will be open even after an exception is raised. + + Example: + + >>> import smtplib + >>> s=smtplib.SMTP("localhost") + >>> tolist=["one@one.org","two@two.org","three@three.org","four@four.org"] + >>> msg = '''\\ + ... From: Me@my.org + ... Subject: testin'... + ... + ... This is a test ''' + >>> s.sendmail("me@my.org",tolist,msg) + { "three@three.org" : ( 550 ,"User unknown" ) } + >>> s.quit() + + In the above example, the message was accepted for delivery to three + of the four addresses, and one was rejected, with the error code + 550. If all addresses are accepted, then the method will return an + empty dictionary. + + """ + self.ehlo_or_helo_if_needed() + esmtp_opts = [] + if isinstance(msg, str): + msg = _fix_eols(msg).encode('ascii') + if self.does_esmtp: + if self.has_extn('size'): + esmtp_opts.append("size=%d" % len(msg)) + for option in mail_options: + esmtp_opts.append(option) + (code, resp) = self.mail(from_addr, esmtp_opts) + if code != 250: + if code == 421: + self.close() + else: + self._rset() + raise SMTPSenderRefused(code, resp, from_addr) + senderrs = {} + if isinstance(to_addrs, str): + to_addrs = [to_addrs] + for each in to_addrs: + (code, resp) = self.rcpt(each, rcpt_options) + if (code != 250) and (code != 251): + senderrs[each] = (code, resp) + if code == 421: + self.close() + raise SMTPRecipientsRefused(senderrs) + if len(senderrs) == len(to_addrs): + # the server refused all our recipients + self._rset() + raise SMTPRecipientsRefused(senderrs) + (code, resp) = self.data(msg) + if code != 250: + if code == 421: + self.close() + else: + self._rset() + raise SMTPDataError(code, resp) + #if we got here then somebody got our mail + return senderrs + + def send_message(self, msg, from_addr=None, to_addrs=None, + mail_options=(), rcpt_options=()): + """Converts message to a bytestring and passes it to sendmail. + + The arguments are as for sendmail, except that msg is an + email.message.Message object. If from_addr is None or to_addrs is + None, these arguments are taken from the headers of the Message as + described in RFC 2822 (a ValueError is raised if there is more than + one set of 'Resent-' headers). Regardless of the values of from_addr and + to_addr, any Bcc field (or Resent-Bcc field, when the Message is a + resent) of the Message object won't be transmitted. The Message + object is then serialized using email.generator.BytesGenerator and + sendmail is called to transmit the message. If the sender or any of + the recipient addresses contain non-ASCII and the server advertises the + SMTPUTF8 capability, the policy is cloned with utf8 set to True for the + serialization, and SMTPUTF8 and BODY=8BITMIME are asserted on the send. + If the server does not support SMTPUTF8, an SMTPNotSupported error is + raised. Otherwise the generator is called without modifying the + policy. + + """ + # 'Resent-Date' is a mandatory field if the Message is resent (RFC 2822 + # Section 3.6.6). In such a case, we use the 'Resent-*' fields. However, + # if there is more than one 'Resent-' block there's no way to + # unambiguously determine which one is the most recent in all cases, + # so rather than guess we raise a ValueError in that case. + # + # TODO implement heuristics to guess the correct Resent-* block with an + # option allowing the user to enable the heuristics. (It should be + # possible to guess correctly almost all of the time.) + + self.ehlo_or_helo_if_needed() + resent = msg.get_all('Resent-Date') + if resent is None: + header_prefix = '' + elif len(resent) == 1: + header_prefix = 'Resent-' + else: + raise ValueError("message has more than one 'Resent-' header block") + if from_addr is None: + # Prefer the sender field per RFC 2822:3.6.2. + from_addr = (msg[header_prefix + 'Sender'] + if (header_prefix + 'Sender') in msg + else msg[header_prefix + 'From']) + from_addr = email.utils.getaddresses([from_addr])[0][1] + if to_addrs is None: + addr_fields = [f for f in (msg[header_prefix + 'To'], + msg[header_prefix + 'Bcc'], + msg[header_prefix + 'Cc']) + if f is not None] + to_addrs = [a[1] for a in email.utils.getaddresses(addr_fields)] + # Make a local copy so we can delete the bcc headers. + msg_copy = copy.copy(msg) + del msg_copy['Bcc'] + del msg_copy['Resent-Bcc'] + international = False + try: + ''.join([from_addr, *to_addrs]).encode('ascii') + except UnicodeEncodeError: + if not self.has_extn('smtputf8'): + raise SMTPNotSupportedError( + "One or more source or delivery addresses require" + " internationalized email support, but the server" + " does not advertise the required SMTPUTF8 capability") + international = True + with io.BytesIO() as bytesmsg: + if international: + g = email.generator.BytesGenerator( + bytesmsg, policy=msg.policy.clone(utf8=True)) + mail_options = (*mail_options, 'SMTPUTF8', 'BODY=8BITMIME') + else: + g = email.generator.BytesGenerator(bytesmsg) + g.flatten(msg_copy, linesep='\r\n') + flatmsg = bytesmsg.getvalue() + return self.sendmail(from_addr, to_addrs, flatmsg, mail_options, + rcpt_options) + + def close(self): + """Close the connection to the SMTP server.""" + try: + file = self.file + self.file = None + if file: + file.close() + finally: + sock = self.sock + self.sock = None + if sock: + sock.close() + + def quit(self): + """Terminate the SMTP session.""" + res = self.docmd("quit") + # A new EHLO is required after reconnecting with connect() + self.ehlo_resp = self.helo_resp = None + self.esmtp_features = {} + self.does_esmtp = False + self.close() + return res + +if _have_ssl: + + class SMTP_SSL(SMTP): + """ This is a subclass derived from SMTP that connects over an SSL + encrypted socket (to use this class you need a socket module that was + compiled with SSL support). If host is not specified, '' (the local + host) is used. If port is omitted, the standard SMTP-over-SSL port + (465) is used. local_hostname and source_address have the same meaning + as they do in the SMTP class. keyfile and certfile are also optional - + they can contain a PEM formatted private key and certificate chain file + for the SSL connection. context also optional, can contain a + SSLContext, and is an alternative to keyfile and certfile; If it is + specified both keyfile and certfile must be None. + + """ + + default_port = SMTP_SSL_PORT + + def __init__(self, host='', port=0, local_hostname=None, + keyfile=None, certfile=None, + timeout=socket._GLOBAL_DEFAULT_TIMEOUT, + source_address=None, context=None): + if context is not None and keyfile is not None: + raise ValueError("context and keyfile arguments are mutually " + "exclusive") + if context is not None and certfile is not None: + raise ValueError("context and certfile arguments are mutually " + "exclusive") + if keyfile is not None or certfile is not None: + import warnings + warnings.warn("keyfile and certfile are deprecated, use a " + "custom context instead", DeprecationWarning, 2) + self.keyfile = keyfile + self.certfile = certfile + if context is None: + context = ssl._create_stdlib_context(certfile=certfile, + keyfile=keyfile) + self.context = context + SMTP.__init__(self, host, port, local_hostname, timeout, + source_address) + + def _get_socket(self, host, port, timeout): + if self.debuglevel > 0: + self._print_debug('connect:', (host, port)) + new_socket = super()._get_socket(host, port, timeout) + new_socket = self.context.wrap_socket(new_socket, + server_hostname=self._host) + return new_socket + + __all__.append("SMTP_SSL") + +# +# LMTP extension +# +LMTP_PORT = 2003 + +class LMTP(SMTP): + """LMTP - Local Mail Transfer Protocol + + The LMTP protocol, which is very similar to ESMTP, is heavily based + on the standard SMTP client. It's common to use Unix sockets for + LMTP, so our connect() method must support that as well as a regular + host:port server. local_hostname and source_address have the same + meaning as they do in the SMTP class. To specify a Unix socket, + you must use an absolute path as the host, starting with a '/'. + + Authentication is supported, using the regular SMTP mechanism. When + using a Unix socket, LMTP generally don't support or require any + authentication, but your mileage might vary.""" + + ehlo_msg = "lhlo" + + def __init__(self, host='', port=LMTP_PORT, local_hostname=None, + source_address=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT): + """Initialize a new instance.""" + super().__init__(host, port, local_hostname=local_hostname, + source_address=source_address, timeout=timeout) + + def connect(self, host='localhost', port=0, source_address=None): + """Connect to the LMTP daemon, on either a Unix or a TCP socket.""" + if host[0] != '/': + return super().connect(host, port, source_address=source_address) + + if self.timeout is not None and not self.timeout: + raise ValueError('Non-blocking socket (timeout=0) is not supported') + + # Handle Unix-domain sockets. + try: + self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + if self.timeout is not socket._GLOBAL_DEFAULT_TIMEOUT: + self.sock.settimeout(self.timeout) + self.file = None + self.sock.connect(host) + except OSError: + if self.debuglevel > 0: + self._print_debug('connect fail:', host) + if self.sock: + self.sock.close() + self.sock = None + raise + (code, msg) = self.getreply() + if self.debuglevel > 0: + self._print_debug('connect:', msg) + return (code, msg) + + +# Test the sendmail method, which tests most of the others. +# Note: This always sends to localhost. +if __name__ == '__main__': + def prompt(prompt): + sys.stdout.write(prompt + ": ") + sys.stdout.flush() + return sys.stdin.readline().strip() + + fromaddr = prompt("From") + toaddrs = prompt("To").split(',') + print("Enter message, end with ^D:") + msg = '' + while 1: + line = sys.stdin.readline() + if not line: + break + msg = msg + line + print("Message length is %d" % len(msg)) + + server = SMTP('localhost') + server.set_debuglevel(1) + server.sendmail(fromaddr, toaddrs, msg) + server.quit() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/sndhdr.py b/physworld_p1_20261018/envs/p1/lib/python3.11/sndhdr.py new file mode 100644 index 0000000000000000000000000000000000000000..45def9ad16d32ca8d67a4e1b08747acde3dd159c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/sndhdr.py @@ -0,0 +1,271 @@ +"""Routines to help recognizing sound files. + +Function whathdr() recognizes various types of sound file headers. +It understands almost all headers that SOX can decode. + +The return tuple contains the following items, in this order: +- file type (as SOX understands it) +- sampling rate (0 if unknown or hard to decode) +- number of channels (0 if unknown or hard to decode) +- number of frames in the file (-1 if unknown or hard to decode) +- number of bits/sample, or 'U' for U-LAW, or 'A' for A-LAW + +If the file doesn't have a recognizable type, it returns None. +If the file can't be opened, OSError is raised. + +To compute the total time, divide the number of frames by the +sampling rate (a frame contains a sample for each channel). + +Function what() calls whathdr(). (It used to also use some +heuristics for raw data, but this doesn't work very well.) + +Finally, the function test() is a simple main program that calls +what() for all files mentioned on the argument list. For directory +arguments it calls what() for all files in that directory. Default +argument is "." (testing all files in the current directory). The +option -r tells it to recurse down directories found inside +explicitly given directories. +""" + +import warnings + +warnings._deprecated(__name__, remove=(3, 13)) + +# The file structure is top-down except that the test program and its +# subroutine come last. + +__all__ = ['what', 'whathdr'] + +from collections import namedtuple + +SndHeaders = namedtuple('SndHeaders', + 'filetype framerate nchannels nframes sampwidth') + +SndHeaders.filetype.__doc__ = ("""The value for type indicates the data type +and will be one of the strings 'aifc', 'aiff', 'au','hcom', +'sndr', 'sndt', 'voc', 'wav', '8svx', 'sb', 'ub', or 'ul'.""") +SndHeaders.framerate.__doc__ = ("""The sampling_rate will be either the actual +value or 0 if unknown or difficult to decode.""") +SndHeaders.nchannels.__doc__ = ("""The number of channels or 0 if it cannot be +determined or if the value is difficult to decode.""") +SndHeaders.nframes.__doc__ = ("""The value for frames will be either the number +of frames or -1.""") +SndHeaders.sampwidth.__doc__ = ("""Either the sample size in bits or +'A' for A-LAW or 'U' for u-LAW.""") + +def what(filename): + """Guess the type of a sound file.""" + res = whathdr(filename) + return res + + +def whathdr(filename): + """Recognize sound headers.""" + with open(filename, 'rb') as f: + h = f.read(512) + for tf in tests: + res = tf(h, f) + if res: + return SndHeaders(*res) + return None + + +#-----------------------------------# +# Subroutines per sound header type # +#-----------------------------------# + +tests = [] + +def test_aifc(h, f): + """AIFC and AIFF files""" + with warnings.catch_warnings(): + warnings.simplefilter('ignore', category=DeprecationWarning) + import aifc + if not h.startswith(b'FORM'): + return None + if h[8:12] == b'AIFC': + fmt = 'aifc' + elif h[8:12] == b'AIFF': + fmt = 'aiff' + else: + return None + f.seek(0) + try: + a = aifc.open(f, 'r') + except (EOFError, aifc.Error): + return None + return (fmt, a.getframerate(), a.getnchannels(), + a.getnframes(), 8 * a.getsampwidth()) + +tests.append(test_aifc) + + +def test_au(h, f): + """AU and SND files""" + if h.startswith(b'.snd'): + func = get_long_be + elif h[:4] in (b'\0ds.', b'dns.'): + func = get_long_le + else: + return None + filetype = 'au' + hdr_size = func(h[4:8]) + data_size = func(h[8:12]) + encoding = func(h[12:16]) + rate = func(h[16:20]) + nchannels = func(h[20:24]) + sample_size = 1 # default + if encoding == 1: + sample_bits = 'U' + elif encoding == 2: + sample_bits = 8 + elif encoding == 3: + sample_bits = 16 + sample_size = 2 + else: + sample_bits = '?' + frame_size = sample_size * nchannels + if frame_size: + nframe = data_size / frame_size + else: + nframe = -1 + return filetype, rate, nchannels, nframe, sample_bits + +tests.append(test_au) + + +def test_hcom(h, f): + """HCOM file""" + if h[65:69] != b'FSSD' or h[128:132] != b'HCOM': + return None + divisor = get_long_be(h[144:148]) + if divisor: + rate = 22050 / divisor + else: + rate = 0 + return 'hcom', rate, 1, -1, 8 + +tests.append(test_hcom) + + +def test_voc(h, f): + """VOC file""" + if not h.startswith(b'Creative Voice File\032'): + return None + sbseek = get_short_le(h[20:22]) + rate = 0 + if 0 <= sbseek < 500 and h[sbseek] == 1: + ratecode = 256 - h[sbseek+4] + if ratecode: + rate = int(1000000.0 / ratecode) + return 'voc', rate, 1, -1, 8 + +tests.append(test_voc) + + +def test_wav(h, f): + """WAV file""" + import wave + # 'RIFF' 'WAVE' 'fmt ' + if not h.startswith(b'RIFF') or h[8:12] != b'WAVE' or h[12:16] != b'fmt ': + return None + f.seek(0) + try: + w = wave.open(f, 'r') + except (EOFError, wave.Error): + return None + return ('wav', w.getframerate(), w.getnchannels(), + w.getnframes(), 8*w.getsampwidth()) + +tests.append(test_wav) + + +def test_8svx(h, f): + """8SVX file""" + if not h.startswith(b'FORM') or h[8:12] != b'8SVX': + return None + # Should decode it to get #channels -- assume always 1 + return '8svx', 0, 1, 0, 8 + +tests.append(test_8svx) + + +def test_sndt(h, f): + """SNDT file""" + if h.startswith(b'SOUND'): + nsamples = get_long_le(h[8:12]) + rate = get_short_le(h[20:22]) + return 'sndt', rate, 1, nsamples, 8 + +tests.append(test_sndt) + + +def test_sndr(h, f): + """SNDR file""" + if h.startswith(b'\0\0'): + rate = get_short_le(h[2:4]) + if 4000 <= rate <= 25000: + return 'sndr', rate, 1, -1, 8 + +tests.append(test_sndr) + + +#-------------------------------------------# +# Subroutines to extract numbers from bytes # +#-------------------------------------------# + +def get_long_be(b): + return (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3] + +def get_long_le(b): + return (b[3] << 24) | (b[2] << 16) | (b[1] << 8) | b[0] + +def get_short_be(b): + return (b[0] << 8) | b[1] + +def get_short_le(b): + return (b[1] << 8) | b[0] + + +#--------------------# +# Small test program # +#--------------------# + +def test(): + import sys + recursive = 0 + if sys.argv[1:] and sys.argv[1] == '-r': + del sys.argv[1:2] + recursive = 1 + try: + if sys.argv[1:]: + testall(sys.argv[1:], recursive, 1) + else: + testall(['.'], recursive, 1) + except KeyboardInterrupt: + sys.stderr.write('\n[Interrupted]\n') + sys.exit(1) + +def testall(list, recursive, toplevel): + import sys + import os + for filename in list: + if os.path.isdir(filename): + print(filename + '/:', end=' ') + if recursive or toplevel: + print('recursing down:') + import glob + names = glob.glob(os.path.join(glob.escape(filename), '*')) + testall(names, recursive, 0) + else: + print('*** directory (use -r) ***') + else: + print(filename + ':', end=' ') + sys.stdout.flush() + try: + print(what(filename)) + except OSError: + print('*** not found ***') + +if __name__ == '__main__': + test() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/socket.py b/physworld_p1_20261018/envs/p1/lib/python3.11/socket.py new file mode 100644 index 0000000000000000000000000000000000000000..f386241abfb79bff04a4863e25da326bc38a4abe --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/socket.py @@ -0,0 +1,979 @@ +# Wrapper module for _socket, providing some additional facilities +# implemented in Python. + +"""\ +This module provides socket operations and some related functions. +On Unix, it supports IP (Internet Protocol) and Unix domain sockets. +On other systems, it only supports IP. Functions specific for a +socket are available as methods of the socket object. + +Functions: + +socket() -- create a new socket object +socketpair() -- create a pair of new socket objects [*] +fromfd() -- create a socket object from an open file descriptor [*] +send_fds() -- Send file descriptor to the socket. +recv_fds() -- Receive file descriptors from the socket. +fromshare() -- create a socket object from data received from socket.share() [*] +gethostname() -- return the current hostname +gethostbyname() -- map a hostname to its IP number +gethostbyaddr() -- map an IP number or hostname to DNS info +getservbyname() -- map a service name and a protocol name to a port number +getprotobyname() -- map a protocol name (e.g. 'tcp') to a number +ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order +htons(), htonl() -- convert 16, 32 bit int from host to network byte order +inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format +inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89) +socket.getdefaulttimeout() -- get the default timeout value +socket.setdefaulttimeout() -- set the default timeout value +create_connection() -- connects to an address, with an optional timeout and + optional source address. + + [*] not available on all platforms! + +Special objects: + +SocketType -- type object for socket objects +error -- exception raised for I/O errors +has_ipv6 -- boolean value indicating if IPv6 is supported + +IntEnum constants: + +AF_INET, AF_UNIX -- socket domains (first argument to socket() call) +SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument) + +Integer constants: + +Many other constants may be defined; these may be used in calls to +the setsockopt() and getsockopt() methods. +""" + +import _socket +from _socket import * + +import os, sys, io, selectors +from enum import IntEnum, IntFlag + +try: + import errno +except ImportError: + errno = None +EBADF = getattr(errno, 'EBADF', 9) +EAGAIN = getattr(errno, 'EAGAIN', 11) +EWOULDBLOCK = getattr(errno, 'EWOULDBLOCK', 11) + +__all__ = ["fromfd", "getfqdn", "create_connection", "create_server", + "has_dualstack_ipv6", "AddressFamily", "SocketKind"] +__all__.extend(os._get_exports_list(_socket)) + +# Set up the socket.AF_* socket.SOCK_* constants as members of IntEnums for +# nicer string representations. +# Note that _socket only knows about the integer values. The public interface +# in this module understands the enums and translates them back from integers +# where needed (e.g. .family property of a socket object). + +IntEnum._convert_( + 'AddressFamily', + __name__, + lambda C: C.isupper() and C.startswith('AF_')) + +IntEnum._convert_( + 'SocketKind', + __name__, + lambda C: C.isupper() and C.startswith('SOCK_')) + +IntFlag._convert_( + 'MsgFlag', + __name__, + lambda C: C.isupper() and C.startswith('MSG_')) + +IntFlag._convert_( + 'AddressInfo', + __name__, + lambda C: C.isupper() and C.startswith('AI_')) + +_LOCALHOST = '127.0.0.1' +_LOCALHOST_V6 = '::1' + + +def _intenum_converter(value, enum_klass): + """Convert a numeric family value to an IntEnum member. + + If it's not a known member, return the numeric value itself. + """ + try: + return enum_klass(value) + except ValueError: + return value + + +# WSA error codes +if sys.platform.lower().startswith("win"): + errorTab = {} + errorTab[6] = "Specified event object handle is invalid." + errorTab[8] = "Insufficient memory available." + errorTab[87] = "One or more parameters are invalid." + errorTab[995] = "Overlapped operation aborted." + errorTab[996] = "Overlapped I/O event object not in signaled state." + errorTab[997] = "Overlapped operation will complete later." + errorTab[10004] = "The operation was interrupted." + errorTab[10009] = "A bad file handle was passed." + errorTab[10013] = "Permission denied." + errorTab[10014] = "A fault occurred on the network??" # WSAEFAULT + errorTab[10022] = "An invalid operation was attempted." + errorTab[10024] = "Too many open files." + errorTab[10035] = "The socket operation would block." + errorTab[10036] = "A blocking operation is already in progress." + errorTab[10037] = "Operation already in progress." + errorTab[10038] = "Socket operation on nonsocket." + errorTab[10039] = "Destination address required." + errorTab[10040] = "Message too long." + errorTab[10041] = "Protocol wrong type for socket." + errorTab[10042] = "Bad protocol option." + errorTab[10043] = "Protocol not supported." + errorTab[10044] = "Socket type not supported." + errorTab[10045] = "Operation not supported." + errorTab[10046] = "Protocol family not supported." + errorTab[10047] = "Address family not supported by protocol family." + errorTab[10048] = "The network address is in use." + errorTab[10049] = "Cannot assign requested address." + errorTab[10050] = "Network is down." + errorTab[10051] = "Network is unreachable." + errorTab[10052] = "Network dropped connection on reset." + errorTab[10053] = "Software caused connection abort." + errorTab[10054] = "The connection has been reset." + errorTab[10055] = "No buffer space available." + errorTab[10056] = "Socket is already connected." + errorTab[10057] = "Socket is not connected." + errorTab[10058] = "The network has been shut down." + errorTab[10059] = "Too many references." + errorTab[10060] = "The operation timed out." + errorTab[10061] = "Connection refused." + errorTab[10062] = "Cannot translate name." + errorTab[10063] = "The name is too long." + errorTab[10064] = "The host is down." + errorTab[10065] = "The host is unreachable." + errorTab[10066] = "Directory not empty." + errorTab[10067] = "Too many processes." + errorTab[10068] = "User quota exceeded." + errorTab[10069] = "Disk quota exceeded." + errorTab[10070] = "Stale file handle reference." + errorTab[10071] = "Item is remote." + errorTab[10091] = "Network subsystem is unavailable." + errorTab[10092] = "Winsock.dll version out of range." + errorTab[10093] = "Successful WSAStartup not yet performed." + errorTab[10101] = "Graceful shutdown in progress." + errorTab[10102] = "No more results from WSALookupServiceNext." + errorTab[10103] = "Call has been canceled." + errorTab[10104] = "Procedure call table is invalid." + errorTab[10105] = "Service provider is invalid." + errorTab[10106] = "Service provider failed to initialize." + errorTab[10107] = "System call failure." + errorTab[10108] = "Service not found." + errorTab[10109] = "Class type not found." + errorTab[10110] = "No more results from WSALookupServiceNext." + errorTab[10111] = "Call was canceled." + errorTab[10112] = "Database query was refused." + errorTab[11001] = "Host not found." + errorTab[11002] = "Nonauthoritative host not found." + errorTab[11003] = "This is a nonrecoverable error." + errorTab[11004] = "Valid name, no data record requested type." + errorTab[11005] = "QoS receivers." + errorTab[11006] = "QoS senders." + errorTab[11007] = "No QoS senders." + errorTab[11008] = "QoS no receivers." + errorTab[11009] = "QoS request confirmed." + errorTab[11010] = "QoS admission error." + errorTab[11011] = "QoS policy failure." + errorTab[11012] = "QoS bad style." + errorTab[11013] = "QoS bad object." + errorTab[11014] = "QoS traffic control error." + errorTab[11015] = "QoS generic error." + errorTab[11016] = "QoS service type error." + errorTab[11017] = "QoS flowspec error." + errorTab[11018] = "Invalid QoS provider buffer." + errorTab[11019] = "Invalid QoS filter style." + errorTab[11020] = "Invalid QoS filter style." + errorTab[11021] = "Incorrect QoS filter count." + errorTab[11022] = "Invalid QoS object length." + errorTab[11023] = "Incorrect QoS flow count." + errorTab[11024] = "Unrecognized QoS object." + errorTab[11025] = "Invalid QoS policy object." + errorTab[11026] = "Invalid QoS flow descriptor." + errorTab[11027] = "Invalid QoS provider-specific flowspec." + errorTab[11028] = "Invalid QoS provider-specific filterspec." + errorTab[11029] = "Invalid QoS shape discard mode object." + errorTab[11030] = "Invalid QoS shaping rate object." + errorTab[11031] = "Reserved policy QoS element type." + __all__.append("errorTab") + + +class _GiveupOnSendfile(Exception): pass + + +class socket(_socket.socket): + + """A subclass of _socket.socket adding the makefile() method.""" + + __slots__ = ["__weakref__", "_io_refs", "_closed"] + + def __init__(self, family=-1, type=-1, proto=-1, fileno=None): + # For user code address family and type values are IntEnum members, but + # for the underlying _socket.socket they're just integers. The + # constructor of _socket.socket converts the given argument to an + # integer automatically. + if fileno is None: + if family == -1: + family = AF_INET + if type == -1: + type = SOCK_STREAM + if proto == -1: + proto = 0 + _socket.socket.__init__(self, family, type, proto, fileno) + self._io_refs = 0 + self._closed = False + + def __enter__(self): + return self + + def __exit__(self, *args): + if not self._closed: + self.close() + + def __repr__(self): + """Wrap __repr__() to reveal the real class name and socket + address(es). + """ + closed = getattr(self, '_closed', False) + s = "<%s.%s%s fd=%i, family=%s, type=%s, proto=%i" \ + % (self.__class__.__module__, + self.__class__.__qualname__, + " [closed]" if closed else "", + self.fileno(), + self.family, + self.type, + self.proto) + if not closed: + # getsockname and getpeername may not be available on WASI. + try: + laddr = self.getsockname() + if laddr: + s += ", laddr=%s" % str(laddr) + except (error, AttributeError): + pass + try: + raddr = self.getpeername() + if raddr: + s += ", raddr=%s" % str(raddr) + except (error, AttributeError): + pass + s += '>' + return s + + def __getstate__(self): + raise TypeError(f"cannot pickle {self.__class__.__name__!r} object") + + def dup(self): + """dup() -> socket object + + Duplicate the socket. Return a new socket object connected to the same + system resource. The new socket is non-inheritable. + """ + fd = dup(self.fileno()) + sock = self.__class__(self.family, self.type, self.proto, fileno=fd) + sock.settimeout(self.gettimeout()) + return sock + + def accept(self): + """accept() -> (socket object, address info) + + Wait for an incoming connection. Return a new socket + representing the connection, and the address of the client. + For IP sockets, the address info is a pair (hostaddr, port). + """ + fd, addr = self._accept() + sock = socket(self.family, self.type, self.proto, fileno=fd) + # Issue #7995: if no default timeout is set and the listening + # socket had a (non-zero) timeout, force the new socket in blocking + # mode to override platform-specific socket flags inheritance. + if getdefaulttimeout() is None and self.gettimeout(): + sock.setblocking(True) + return sock, addr + + def makefile(self, mode="r", buffering=None, *, + encoding=None, errors=None, newline=None): + """makefile(...) -> an I/O stream connected to the socket + + The arguments are as for io.open() after the filename, except the only + supported mode values are 'r' (default), 'w' and 'b'. + """ + # XXX refactor to share code? + if not set(mode) <= {"r", "w", "b"}: + raise ValueError("invalid mode %r (only r, w, b allowed)" % (mode,)) + writing = "w" in mode + reading = "r" in mode or not writing + assert reading or writing + binary = "b" in mode + rawmode = "" + if reading: + rawmode += "r" + if writing: + rawmode += "w" + raw = SocketIO(self, rawmode) + self._io_refs += 1 + if buffering is None: + buffering = -1 + if buffering < 0: + buffering = io.DEFAULT_BUFFER_SIZE + if buffering == 0: + if not binary: + raise ValueError("unbuffered streams must be binary") + return raw + if reading and writing: + buffer = io.BufferedRWPair(raw, raw, buffering) + elif reading: + buffer = io.BufferedReader(raw, buffering) + else: + assert writing + buffer = io.BufferedWriter(raw, buffering) + if binary: + return buffer + encoding = io.text_encoding(encoding) + text = io.TextIOWrapper(buffer, encoding, errors, newline) + text.mode = mode + return text + + if hasattr(os, 'sendfile'): + + def _sendfile_use_sendfile(self, file, offset=0, count=None): + self._check_sendfile_params(file, offset, count) + sockno = self.fileno() + try: + fileno = file.fileno() + except (AttributeError, io.UnsupportedOperation) as err: + raise _GiveupOnSendfile(err) # not a regular file + try: + fsize = os.fstat(fileno).st_size + except OSError as err: + raise _GiveupOnSendfile(err) # not a regular file + if not fsize: + return 0 # empty file + # Truncate to 1GiB to avoid OverflowError, see bpo-38319. + blocksize = min(count or fsize, 2 ** 30) + timeout = self.gettimeout() + if timeout == 0: + raise ValueError("non-blocking sockets are not supported") + # poll/select have the advantage of not requiring any + # extra file descriptor, contrarily to epoll/kqueue + # (also, they require a single syscall). + if hasattr(selectors, 'PollSelector'): + selector = selectors.PollSelector() + else: + selector = selectors.SelectSelector() + selector.register(sockno, selectors.EVENT_WRITE) + + total_sent = 0 + # localize variable access to minimize overhead + selector_select = selector.select + os_sendfile = os.sendfile + try: + while True: + if timeout and not selector_select(timeout): + raise TimeoutError('timed out') + if count: + blocksize = min(count - total_sent, blocksize) + if blocksize <= 0: + break + try: + sent = os_sendfile(sockno, fileno, offset, blocksize) + except BlockingIOError: + if not timeout: + # Block until the socket is ready to send some + # data; avoids hogging CPU resources. + selector_select() + continue + except OSError as err: + if total_sent == 0: + # We can get here for different reasons, the main + # one being 'file' is not a regular mmap(2)-like + # file, in which case we'll fall back on using + # plain send(). + raise _GiveupOnSendfile(err) + raise err from None + else: + if sent == 0: + break # EOF + offset += sent + total_sent += sent + return total_sent + finally: + if total_sent > 0 and hasattr(file, 'seek'): + file.seek(offset) + else: + def _sendfile_use_sendfile(self, file, offset=0, count=None): + raise _GiveupOnSendfile( + "os.sendfile() not available on this platform") + + def _sendfile_use_send(self, file, offset=0, count=None): + self._check_sendfile_params(file, offset, count) + if self.gettimeout() == 0: + raise ValueError("non-blocking sockets are not supported") + if offset: + file.seek(offset) + blocksize = min(count, 8192) if count else 8192 + total_sent = 0 + # localize variable access to minimize overhead + file_read = file.read + sock_send = self.send + try: + while True: + if count: + blocksize = min(count - total_sent, blocksize) + if blocksize <= 0: + break + data = memoryview(file_read(blocksize)) + if not data: + break # EOF + while True: + try: + sent = sock_send(data) + except BlockingIOError: + continue + else: + total_sent += sent + if sent < len(data): + data = data[sent:] + else: + break + return total_sent + finally: + if total_sent > 0 and hasattr(file, 'seek'): + file.seek(offset + total_sent) + + def _check_sendfile_params(self, file, offset, count): + if 'b' not in getattr(file, 'mode', 'b'): + raise ValueError("file should be opened in binary mode") + if not self.type & SOCK_STREAM: + raise ValueError("only SOCK_STREAM type sockets are supported") + if count is not None: + if not isinstance(count, int): + raise TypeError( + "count must be a positive integer (got {!r})".format(count)) + if count <= 0: + raise ValueError( + "count must be a positive integer (got {!r})".format(count)) + + def sendfile(self, file, offset=0, count=None): + """sendfile(file[, offset[, count]]) -> sent + + Send a file until EOF is reached by using high-performance + os.sendfile() and return the total number of bytes which + were sent. + *file* must be a regular file object opened in binary mode. + If os.sendfile() is not available (e.g. Windows) or file is + not a regular file socket.send() will be used instead. + *offset* tells from where to start reading the file. + If specified, *count* is the total number of bytes to transmit + as opposed to sending the file until EOF is reached. + File position is updated on return or also in case of error in + which case file.tell() can be used to figure out the number of + bytes which were sent. + The socket must be of SOCK_STREAM type. + Non-blocking sockets are not supported. + """ + try: + return self._sendfile_use_sendfile(file, offset, count) + except _GiveupOnSendfile: + return self._sendfile_use_send(file, offset, count) + + def _decref_socketios(self): + if self._io_refs > 0: + self._io_refs -= 1 + if self._closed: + self.close() + + def _real_close(self, _ss=_socket.socket): + # This function should not reference any globals. See issue #808164. + _ss.close(self) + + def close(self): + # This function should not reference any globals. See issue #808164. + self._closed = True + if self._io_refs <= 0: + self._real_close() + + def detach(self): + """detach() -> file descriptor + + Close the socket object without closing the underlying file descriptor. + The object cannot be used after this call, but the file descriptor + can be reused for other purposes. The file descriptor is returned. + """ + self._closed = True + return super().detach() + + @property + def family(self): + """Read-only access to the address family for this socket. + """ + return _intenum_converter(super().family, AddressFamily) + + @property + def type(self): + """Read-only access to the socket type. + """ + return _intenum_converter(super().type, SocketKind) + + if os.name == 'nt': + def get_inheritable(self): + return os.get_handle_inheritable(self.fileno()) + def set_inheritable(self, inheritable): + os.set_handle_inheritable(self.fileno(), inheritable) + else: + def get_inheritable(self): + return os.get_inheritable(self.fileno()) + def set_inheritable(self, inheritable): + os.set_inheritable(self.fileno(), inheritable) + get_inheritable.__doc__ = "Get the inheritable flag of the socket" + set_inheritable.__doc__ = "Set the inheritable flag of the socket" + +def fromfd(fd, family, type, proto=0): + """ fromfd(fd, family, type[, proto]) -> socket object + + Create a socket object from a duplicate of the given file + descriptor. The remaining arguments are the same as for socket(). + """ + nfd = dup(fd) + return socket(family, type, proto, nfd) + +if hasattr(_socket.socket, "sendmsg"): + import array + + def send_fds(sock, buffers, fds, flags=0, address=None): + """ send_fds(sock, buffers, fds[, flags[, address]]) -> integer + + Send the list of file descriptors fds over an AF_UNIX socket. + """ + return sock.sendmsg(buffers, [(_socket.SOL_SOCKET, + _socket.SCM_RIGHTS, array.array("i", fds))]) + __all__.append("send_fds") + +if hasattr(_socket.socket, "recvmsg"): + import array + + def recv_fds(sock, bufsize, maxfds, flags=0): + """ recv_fds(sock, bufsize, maxfds[, flags]) -> (data, list of file + descriptors, msg_flags, address) + + Receive up to maxfds file descriptors returning the message + data and a list containing the descriptors. + """ + # Array of ints + fds = array.array("i") + msg, ancdata, flags, addr = sock.recvmsg(bufsize, + _socket.CMSG_LEN(maxfds * fds.itemsize)) + for cmsg_level, cmsg_type, cmsg_data in ancdata: + if (cmsg_level == _socket.SOL_SOCKET and cmsg_type == _socket.SCM_RIGHTS): + fds.frombytes(cmsg_data[: + len(cmsg_data) - (len(cmsg_data) % fds.itemsize)]) + + return msg, list(fds), flags, addr + __all__.append("recv_fds") + +if hasattr(_socket.socket, "share"): + def fromshare(info): + """ fromshare(info) -> socket object + + Create a socket object from the bytes object returned by + socket.share(pid). + """ + return socket(0, 0, 0, info) + __all__.append("fromshare") + +# Origin: https://gist.github.com/4325783, by Geert Jansen. Public domain. +# This is used if _socket doesn't natively provide socketpair. It's +# always defined so that it can be patched in for testing purposes. +def _fallback_socketpair(family=AF_INET, type=SOCK_STREAM, proto=0): + if family == AF_INET: + host = _LOCALHOST + elif family == AF_INET6: + host = _LOCALHOST_V6 + else: + raise ValueError("Only AF_INET and AF_INET6 socket address families " + "are supported") + if type != SOCK_STREAM: + raise ValueError("Only SOCK_STREAM socket type is supported") + if proto != 0: + raise ValueError("Only protocol zero is supported") + + # We create a connected TCP socket. Note the trick with + # setblocking(False) that prevents us from having to create a thread. + lsock = socket(family, type, proto) + try: + lsock.bind((host, 0)) + lsock.listen() + # On IPv6, ignore flow_info and scope_id + addr, port = lsock.getsockname()[:2] + csock = socket(family, type, proto) + try: + csock.setblocking(False) + try: + csock.connect((addr, port)) + except (BlockingIOError, InterruptedError): + pass + csock.setblocking(True) + ssock, _ = lsock.accept() + except: + csock.close() + raise + finally: + lsock.close() + + # Authenticating avoids using a connection from something else + # able to connect to {host}:{port} instead of us. + # We expect only AF_INET and AF_INET6 families. + try: + if ( + ssock.getsockname() != csock.getpeername() + or csock.getsockname() != ssock.getpeername() + ): + raise ConnectionError("Unexpected peer connection") + except: + # getsockname() and getpeername() can fail + # if either socket isn't connected. + ssock.close() + csock.close() + raise + + return (ssock, csock) + +if hasattr(_socket, "socketpair"): + def socketpair(family=None, type=SOCK_STREAM, proto=0): + if family is None: + try: + family = AF_UNIX + except NameError: + family = AF_INET + a, b = _socket.socketpair(family, type, proto) + a = socket(family, type, proto, a.detach()) + b = socket(family, type, proto, b.detach()) + return a, b + +else: + socketpair = _fallback_socketpair + __all__.append("socketpair") + +socketpair.__doc__ = """socketpair([family[, type[, proto]]]) -> (socket object, socket object) +Create a pair of socket objects from the sockets returned by the platform +socketpair() function. +The arguments are the same as for socket() except the default family is AF_UNIX +if defined on the platform; otherwise, the default is AF_INET. +""" + +_blocking_errnos = { EAGAIN, EWOULDBLOCK } + +class SocketIO(io.RawIOBase): + + """Raw I/O implementation for stream sockets. + + This class supports the makefile() method on sockets. It provides + the raw I/O interface on top of a socket object. + """ + + # One might wonder why not let FileIO do the job instead. There are two + # main reasons why FileIO is not adapted: + # - it wouldn't work under Windows (where you can't used read() and + # write() on a socket handle) + # - it wouldn't work with socket timeouts (FileIO would ignore the + # timeout and consider the socket non-blocking) + + # XXX More docs + + def __init__(self, sock, mode): + if mode not in ("r", "w", "rw", "rb", "wb", "rwb"): + raise ValueError("invalid mode: %r" % mode) + io.RawIOBase.__init__(self) + self._sock = sock + if "b" not in mode: + mode += "b" + self._mode = mode + self._reading = "r" in mode + self._writing = "w" in mode + self._timeout_occurred = False + + def readinto(self, b): + """Read up to len(b) bytes into the writable buffer *b* and return + the number of bytes read. If the socket is non-blocking and no bytes + are available, None is returned. + + If *b* is non-empty, a 0 return value indicates that the connection + was shutdown at the other end. + """ + self._checkClosed() + self._checkReadable() + if self._timeout_occurred: + raise OSError("cannot read from timed out object") + while True: + try: + return self._sock.recv_into(b) + except timeout: + self._timeout_occurred = True + raise + except error as e: + if e.errno in _blocking_errnos: + return None + raise + + def write(self, b): + """Write the given bytes or bytearray object *b* to the socket + and return the number of bytes written. This can be less than + len(b) if not all data could be written. If the socket is + non-blocking and no bytes could be written None is returned. + """ + self._checkClosed() + self._checkWritable() + try: + return self._sock.send(b) + except error as e: + # XXX what about EINTR? + if e.errno in _blocking_errnos: + return None + raise + + def readable(self): + """True if the SocketIO is open for reading. + """ + if self.closed: + raise ValueError("I/O operation on closed socket.") + return self._reading + + def writable(self): + """True if the SocketIO is open for writing. + """ + if self.closed: + raise ValueError("I/O operation on closed socket.") + return self._writing + + def seekable(self): + """True if the SocketIO is open for seeking. + """ + if self.closed: + raise ValueError("I/O operation on closed socket.") + return super().seekable() + + def fileno(self): + """Return the file descriptor of the underlying socket. + """ + self._checkClosed() + return self._sock.fileno() + + @property + def name(self): + if not self.closed: + return self.fileno() + else: + return -1 + + @property + def mode(self): + return self._mode + + def close(self): + """Close the SocketIO object. This doesn't close the underlying + socket, except if all references to it have disappeared. + """ + if self.closed: + return + io.RawIOBase.close(self) + self._sock._decref_socketios() + self._sock = None + + +def getfqdn(name=''): + """Get fully qualified domain name from name. + + An empty argument is interpreted as meaning the local host. + + First the hostname returned by gethostbyaddr() is checked, then + possibly existing aliases. In case no FQDN is available and `name` + was given, it is returned unchanged. If `name` was empty, '0.0.0.0' or '::', + hostname from gethostname() is returned. + """ + name = name.strip() + if not name or name in ('0.0.0.0', '::'): + name = gethostname() + try: + hostname, aliases, ipaddrs = gethostbyaddr(name) + except error: + pass + else: + aliases.insert(0, hostname) + for name in aliases: + if '.' in name: + break + else: + name = hostname + return name + + +_GLOBAL_DEFAULT_TIMEOUT = object() + +def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT, + source_address=None, *, all_errors=False): + """Connect to *address* and return the socket object. + + Convenience function. Connect to *address* (a 2-tuple ``(host, + port)``) and return the socket object. Passing the optional + *timeout* parameter will set the timeout on the socket instance + before attempting to connect. If no *timeout* is supplied, the + global default timeout setting returned by :func:`getdefaulttimeout` + is used. If *source_address* is set it must be a tuple of (host, port) + for the socket to bind as a source address before making the connection. + A host of '' or port 0 tells the OS to use the default. When a connection + cannot be created, raises the last error if *all_errors* is False, + and an ExceptionGroup of all errors if *all_errors* is True. + """ + + host, port = address + exceptions = [] + for res in getaddrinfo(host, port, 0, SOCK_STREAM): + af, socktype, proto, canonname, sa = res + sock = None + try: + sock = socket(af, socktype, proto) + if timeout is not _GLOBAL_DEFAULT_TIMEOUT: + sock.settimeout(timeout) + if source_address: + sock.bind(source_address) + sock.connect(sa) + # Break explicitly a reference cycle + exceptions.clear() + return sock + + except error as exc: + if not all_errors: + exceptions.clear() # raise only the last error + exceptions.append(exc) + if sock is not None: + sock.close() + + if len(exceptions): + try: + if not all_errors: + raise exceptions[0] + raise ExceptionGroup("create_connection failed", exceptions) + finally: + # Break explicitly a reference cycle + exceptions.clear() + else: + raise error("getaddrinfo returns an empty list") + + +def has_dualstack_ipv6(): + """Return True if the platform supports creating a SOCK_STREAM socket + which can handle both AF_INET and AF_INET6 (IPv4 / IPv6) connections. + """ + if not has_ipv6 \ + or not hasattr(_socket, 'IPPROTO_IPV6') \ + or not hasattr(_socket, 'IPV6_V6ONLY'): + return False + try: + with socket(AF_INET6, SOCK_STREAM) as sock: + sock.setsockopt(IPPROTO_IPV6, IPV6_V6ONLY, 0) + return True + except error: + return False + + +def create_server(address, *, family=AF_INET, backlog=None, reuse_port=False, + dualstack_ipv6=False): + """Convenience function which creates a SOCK_STREAM type socket + bound to *address* (a 2-tuple (host, port)) and return the socket + object. + + *family* should be either AF_INET or AF_INET6. + *backlog* is the queue size passed to socket.listen(). + *reuse_port* dictates whether to use the SO_REUSEPORT socket option. + *dualstack_ipv6*: if true and the platform supports it, it will + create an AF_INET6 socket able to accept both IPv4 or IPv6 + connections. When false it will explicitly disable this option on + platforms that enable it by default (e.g. Linux). + + >>> with create_server(('', 8000)) as server: + ... while True: + ... conn, addr = server.accept() + ... # handle new connection + """ + if reuse_port and not hasattr(_socket, "SO_REUSEPORT"): + raise ValueError("SO_REUSEPORT not supported on this platform") + if dualstack_ipv6: + if not has_dualstack_ipv6(): + raise ValueError("dualstack_ipv6 not supported on this platform") + if family != AF_INET6: + raise ValueError("dualstack_ipv6 requires AF_INET6 family") + sock = socket(family, SOCK_STREAM) + try: + # Note about Windows. We don't set SO_REUSEADDR because: + # 1) It's unnecessary: bind() will succeed even in case of a + # previous closed socket on the same address and still in + # TIME_WAIT state. + # 2) If set, another socket is free to bind() on the same + # address, effectively preventing this one from accepting + # connections. Also, it may set the process in a state where + # it'll no longer respond to any signals or graceful kills. + # See: https://learn.microsoft.com/windows/win32/winsock/using-so-reuseaddr-and-so-exclusiveaddruse + if os.name not in ('nt', 'cygwin') and \ + hasattr(_socket, 'SO_REUSEADDR'): + try: + sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) + except error: + # Fail later on bind(), for platforms which may not + # support this option. + pass + if reuse_port: + sock.setsockopt(SOL_SOCKET, SO_REUSEPORT, 1) + if has_ipv6 and family == AF_INET6: + if dualstack_ipv6: + sock.setsockopt(IPPROTO_IPV6, IPV6_V6ONLY, 0) + elif hasattr(_socket, "IPV6_V6ONLY") and \ + hasattr(_socket, "IPPROTO_IPV6"): + sock.setsockopt(IPPROTO_IPV6, IPV6_V6ONLY, 1) + try: + sock.bind(address) + except error as err: + msg = '%s (while attempting to bind on address %r)' % \ + (err.strerror, address) + raise error(err.errno, msg) from None + if backlog is None: + sock.listen() + else: + sock.listen(backlog) + return sock + except error: + sock.close() + raise + + +def getaddrinfo(host, port, family=0, type=0, proto=0, flags=0): + """Resolve host and port into list of address info entries. + + Translate the host/port argument into a sequence of 5-tuples that contain + all the necessary arguments for creating a socket connected to that service. + host is a domain name, a string representation of an IPv4/v6 address or + None. port is a string service name such as 'http', a numeric port number or + None. By passing None as the value of host and port, you can pass NULL to + the underlying C API. + + The family, type and proto arguments can be optionally specified in order to + narrow the list of addresses returned. Passing zero as a value for each of + these arguments selects the full range of results. + """ + # We override this function since we want to translate the numeric family + # and socket type values to enum constants. + addrlist = [] + for res in _socket.getaddrinfo(host, port, family, type, proto, flags): + af, socktype, proto, canonname, sa = res + addrlist.append((_intenum_converter(af, AddressFamily), + _intenum_converter(socktype, SocketKind), + proto, canonname, sa)) + return addrlist diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/socketserver.py b/physworld_p1_20261018/envs/p1/lib/python3.11/socketserver.py new file mode 100644 index 0000000000000000000000000000000000000000..30a5cfa59fe05ba55e252b9a78b710f56845d0a7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/socketserver.py @@ -0,0 +1,852 @@ +"""Generic socket server classes. + +This module tries to capture the various aspects of defining a server: + +For socket-based servers: + +- address family: + - AF_INET{,6}: IP (Internet Protocol) sockets (default) + - AF_UNIX: Unix domain sockets + - others, e.g. AF_DECNET are conceivable (see +- socket type: + - SOCK_STREAM (reliable stream, e.g. TCP) + - SOCK_DGRAM (datagrams, e.g. UDP) + +For request-based servers (including socket-based): + +- client address verification before further looking at the request + (This is actually a hook for any processing that needs to look + at the request before anything else, e.g. logging) +- how to handle multiple requests: + - synchronous (one request is handled at a time) + - forking (each request is handled by a new process) + - threading (each request is handled by a new thread) + +The classes in this module favor the server type that is simplest to +write: a synchronous TCP/IP server. This is bad class design, but +saves some typing. (There's also the issue that a deep class hierarchy +slows down method lookups.) + +There are five classes in an inheritance diagram, four of which represent +synchronous servers of four types: + + +------------+ + | BaseServer | + +------------+ + | + v + +-----------+ +------------------+ + | TCPServer |------->| UnixStreamServer | + +-----------+ +------------------+ + | + v + +-----------+ +--------------------+ + | UDPServer |------->| UnixDatagramServer | + +-----------+ +--------------------+ + +Note that UnixDatagramServer derives from UDPServer, not from +UnixStreamServer -- the only difference between an IP and a Unix +stream server is the address family, which is simply repeated in both +unix server classes. + +Forking and threading versions of each type of server can be created +using the ForkingMixIn and ThreadingMixIn mix-in classes. For +instance, a threading UDP server class is created as follows: + + class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass + +The Mix-in class must come first, since it overrides a method defined +in UDPServer! Setting the various member variables also changes +the behavior of the underlying server mechanism. + +To implement a service, you must derive a class from +BaseRequestHandler and redefine its handle() method. You can then run +various versions of the service by combining one of the server classes +with your request handler class. + +The request handler class must be different for datagram or stream +services. This can be hidden by using the request handler +subclasses StreamRequestHandler or DatagramRequestHandler. + +Of course, you still have to use your head! + +For instance, it makes no sense to use a forking server if the service +contains state in memory that can be modified by requests (since the +modifications in the child process would never reach the initial state +kept in the parent process and passed to each child). In this case, +you can use a threading server, but you will probably have to use +locks to avoid two requests that come in nearly simultaneous to apply +conflicting changes to the server state. + +On the other hand, if you are building e.g. an HTTP server, where all +data is stored externally (e.g. in the file system), a synchronous +class will essentially render the service "deaf" while one request is +being handled -- which may be for a very long time if a client is slow +to read all the data it has requested. Here a threading or forking +server is appropriate. + +In some cases, it may be appropriate to process part of a request +synchronously, but to finish processing in a forked child depending on +the request data. This can be implemented by using a synchronous +server and doing an explicit fork in the request handler class +handle() method. + +Another approach to handling multiple simultaneous requests in an +environment that supports neither threads nor fork (or where these are +too expensive or inappropriate for the service) is to maintain an +explicit table of partially finished requests and to use a selector to +decide which request to work on next (or whether to handle a new +incoming request). This is particularly important for stream services +where each client can potentially be connected for a long time (if +threads or subprocesses cannot be used). + +Future work: +- Standard classes for Sun RPC (which uses either UDP or TCP) +- Standard mix-in classes to implement various authentication + and encryption schemes + +XXX Open problems: +- What to do with out-of-band data? + +BaseServer: +- split generic "request" functionality out into BaseServer class. + Copyright (C) 2000 Luke Kenneth Casson Leighton + + example: read entries from a SQL database (requires overriding + get_request() to return a table entry from the database). + entry is processed by a RequestHandlerClass. + +""" + +# Author of the BaseServer patch: Luke Kenneth Casson Leighton + +__version__ = "0.4" + + +import socket +import selectors +import os +import sys +import threading +from io import BufferedIOBase +from time import monotonic as time + +__all__ = ["BaseServer", "TCPServer", "UDPServer", + "ThreadingUDPServer", "ThreadingTCPServer", + "BaseRequestHandler", "StreamRequestHandler", + "DatagramRequestHandler", "ThreadingMixIn"] +if hasattr(os, "fork"): + __all__.extend(["ForkingUDPServer","ForkingTCPServer", "ForkingMixIn"]) +if hasattr(socket, "AF_UNIX"): + __all__.extend(["UnixStreamServer","UnixDatagramServer", + "ThreadingUnixStreamServer", + "ThreadingUnixDatagramServer"]) + +# poll/select have the advantage of not requiring any extra file descriptor, +# contrarily to epoll/kqueue (also, they require a single syscall). +if hasattr(selectors, 'PollSelector'): + _ServerSelector = selectors.PollSelector +else: + _ServerSelector = selectors.SelectSelector + + +class BaseServer: + + """Base class for server classes. + + Methods for the caller: + + - __init__(server_address, RequestHandlerClass) + - serve_forever(poll_interval=0.5) + - shutdown() + - handle_request() # if you do not use serve_forever() + - fileno() -> int # for selector + + Methods that may be overridden: + + - server_bind() + - server_activate() + - get_request() -> request, client_address + - handle_timeout() + - verify_request(request, client_address) + - server_close() + - process_request(request, client_address) + - shutdown_request(request) + - close_request(request) + - service_actions() + - handle_error() + + Methods for derived classes: + + - finish_request(request, client_address) + + Class variables that may be overridden by derived classes or + instances: + + - timeout + - address_family + - socket_type + - allow_reuse_address + - allow_reuse_port + + Instance variables: + + - RequestHandlerClass + - socket + + """ + + timeout = None + + def __init__(self, server_address, RequestHandlerClass): + """Constructor. May be extended, do not override.""" + self.server_address = server_address + self.RequestHandlerClass = RequestHandlerClass + self.__is_shut_down = threading.Event() + self.__shutdown_request = False + + def server_activate(self): + """Called by constructor to activate the server. + + May be overridden. + + """ + pass + + def serve_forever(self, poll_interval=0.5): + """Handle one request at a time until shutdown. + + Polls for shutdown every poll_interval seconds. Ignores + self.timeout. If you need to do periodic tasks, do them in + another thread. + """ + self.__is_shut_down.clear() + try: + # XXX: Consider using another file descriptor or connecting to the + # socket to wake this up instead of polling. Polling reduces our + # responsiveness to a shutdown request and wastes cpu at all other + # times. + with _ServerSelector() as selector: + selector.register(self, selectors.EVENT_READ) + + while not self.__shutdown_request: + ready = selector.select(poll_interval) + # bpo-35017: shutdown() called during select(), exit immediately. + if self.__shutdown_request: + break + if ready: + self._handle_request_noblock() + + self.service_actions() + finally: + self.__shutdown_request = False + self.__is_shut_down.set() + + def shutdown(self): + """Stops the serve_forever loop. + + Blocks until the loop has finished. This must be called while + serve_forever() is running in another thread, or it will + deadlock. + """ + self.__shutdown_request = True + self.__is_shut_down.wait() + + def service_actions(self): + """Called by the serve_forever() loop. + + May be overridden by a subclass / Mixin to implement any code that + needs to be run during the loop. + """ + pass + + # The distinction between handling, getting, processing and finishing a + # request is fairly arbitrary. Remember: + # + # - handle_request() is the top-level call. It calls selector.select(), + # get_request(), verify_request() and process_request() + # - get_request() is different for stream or datagram sockets + # - process_request() is the place that may fork a new process or create a + # new thread to finish the request + # - finish_request() instantiates the request handler class; this + # constructor will handle the request all by itself + + def handle_request(self): + """Handle one request, possibly blocking. + + Respects self.timeout. + """ + # Support people who used socket.settimeout() to escape + # handle_request before self.timeout was available. + timeout = self.socket.gettimeout() + if timeout is None: + timeout = self.timeout + elif self.timeout is not None: + timeout = min(timeout, self.timeout) + if timeout is not None: + deadline = time() + timeout + + # Wait until a request arrives or the timeout expires - the loop is + # necessary to accommodate early wakeups due to EINTR. + with _ServerSelector() as selector: + selector.register(self, selectors.EVENT_READ) + + while True: + ready = selector.select(timeout) + if ready: + return self._handle_request_noblock() + else: + if timeout is not None: + timeout = deadline - time() + if timeout < 0: + return self.handle_timeout() + + def _handle_request_noblock(self): + """Handle one request, without blocking. + + I assume that selector.select() has returned that the socket is + readable before this function was called, so there should be no risk of + blocking in get_request(). + """ + try: + request, client_address = self.get_request() + except OSError: + return + if self.verify_request(request, client_address): + try: + self.process_request(request, client_address) + except Exception: + self.handle_error(request, client_address) + self.shutdown_request(request) + except: + self.shutdown_request(request) + raise + else: + self.shutdown_request(request) + + def handle_timeout(self): + """Called if no new request arrives within self.timeout. + + Overridden by ForkingMixIn. + """ + pass + + def verify_request(self, request, client_address): + """Verify the request. May be overridden. + + Return True if we should proceed with this request. + + """ + return True + + def process_request(self, request, client_address): + """Call finish_request. + + Overridden by ForkingMixIn and ThreadingMixIn. + + """ + self.finish_request(request, client_address) + self.shutdown_request(request) + + def server_close(self): + """Called to clean-up the server. + + May be overridden. + + """ + pass + + def finish_request(self, request, client_address): + """Finish one request by instantiating RequestHandlerClass.""" + self.RequestHandlerClass(request, client_address, self) + + def shutdown_request(self, request): + """Called to shutdown and close an individual request.""" + self.close_request(request) + + def close_request(self, request): + """Called to clean up an individual request.""" + pass + + def handle_error(self, request, client_address): + """Handle an error gracefully. May be overridden. + + The default is to print a traceback and continue. + + """ + print('-'*40, file=sys.stderr) + print('Exception occurred during processing of request from', + client_address, file=sys.stderr) + import traceback + traceback.print_exc() + print('-'*40, file=sys.stderr) + + def __enter__(self): + return self + + def __exit__(self, *args): + self.server_close() + + +class TCPServer(BaseServer): + + """Base class for various socket-based server classes. + + Defaults to synchronous IP stream (i.e., TCP). + + Methods for the caller: + + - __init__(server_address, RequestHandlerClass, bind_and_activate=True) + - serve_forever(poll_interval=0.5) + - shutdown() + - handle_request() # if you don't use serve_forever() + - fileno() -> int # for selector + + Methods that may be overridden: + + - server_bind() + - server_activate() + - get_request() -> request, client_address + - handle_timeout() + - verify_request(request, client_address) + - process_request(request, client_address) + - shutdown_request(request) + - close_request(request) + - handle_error() + + Methods for derived classes: + + - finish_request(request, client_address) + + Class variables that may be overridden by derived classes or + instances: + + - timeout + - address_family + - socket_type + - request_queue_size (only for stream sockets) + - allow_reuse_address + - allow_reuse_port + + Instance variables: + + - server_address + - RequestHandlerClass + - socket + + """ + + address_family = socket.AF_INET + + socket_type = socket.SOCK_STREAM + + request_queue_size = 5 + + allow_reuse_address = False + + allow_reuse_port = False + + def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True): + """Constructor. May be extended, do not override.""" + BaseServer.__init__(self, server_address, RequestHandlerClass) + self.socket = socket.socket(self.address_family, + self.socket_type) + if bind_and_activate: + try: + self.server_bind() + self.server_activate() + except: + self.server_close() + raise + + def server_bind(self): + """Called by constructor to bind the socket. + + May be overridden. + + """ + if self.allow_reuse_address and hasattr(socket, "SO_REUSEADDR"): + self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + if self.allow_reuse_port and hasattr(socket, "SO_REUSEPORT"): + self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) + self.socket.bind(self.server_address) + self.server_address = self.socket.getsockname() + + def server_activate(self): + """Called by constructor to activate the server. + + May be overridden. + + """ + self.socket.listen(self.request_queue_size) + + def server_close(self): + """Called to clean-up the server. + + May be overridden. + + """ + self.socket.close() + + def fileno(self): + """Return socket file number. + + Interface required by selector. + + """ + return self.socket.fileno() + + def get_request(self): + """Get the request and client address from the socket. + + May be overridden. + + """ + return self.socket.accept() + + def shutdown_request(self, request): + """Called to shutdown and close an individual request.""" + try: + #explicitly shutdown. socket.close() merely releases + #the socket and waits for GC to perform the actual close. + request.shutdown(socket.SHUT_WR) + except OSError: + pass #some platforms may raise ENOTCONN here + self.close_request(request) + + def close_request(self, request): + """Called to clean up an individual request.""" + request.close() + + +class UDPServer(TCPServer): + + """UDP server class.""" + + allow_reuse_address = False + + allow_reuse_port = False + + socket_type = socket.SOCK_DGRAM + + max_packet_size = 8192 + + def get_request(self): + data, client_addr = self.socket.recvfrom(self.max_packet_size) + return (data, self.socket), client_addr + + def server_activate(self): + # No need to call listen() for UDP. + pass + + def shutdown_request(self, request): + # No need to shutdown anything. + self.close_request(request) + + def close_request(self, request): + # No need to close anything. + pass + +if hasattr(os, "fork"): + class ForkingMixIn: + """Mix-in class to handle each request in a new process.""" + + timeout = 300 + active_children = None + max_children = 40 + # If true, server_close() waits until all child processes complete. + block_on_close = True + + def collect_children(self, *, blocking=False): + """Internal routine to wait for children that have exited.""" + if self.active_children is None: + return + + # If we're above the max number of children, wait and reap them until + # we go back below threshold. Note that we use waitpid(-1) below to be + # able to collect children in size() syscalls instead + # of size(): the downside is that this might reap children + # which we didn't spawn, which is why we only resort to this when we're + # above max_children. + while len(self.active_children) >= self.max_children: + try: + pid, _ = os.waitpid(-1, 0) + self.active_children.discard(pid) + except ChildProcessError: + # we don't have any children, we're done + self.active_children.clear() + except OSError: + break + + # Now reap all defunct children. + for pid in self.active_children.copy(): + try: + flags = 0 if blocking else os.WNOHANG + pid, _ = os.waitpid(pid, flags) + # if the child hasn't exited yet, pid will be 0 and ignored by + # discard() below + self.active_children.discard(pid) + except ChildProcessError: + # someone else reaped it + self.active_children.discard(pid) + except OSError: + pass + + def handle_timeout(self): + """Wait for zombies after self.timeout seconds of inactivity. + + May be extended, do not override. + """ + self.collect_children() + + def service_actions(self): + """Collect the zombie child processes regularly in the ForkingMixIn. + + service_actions is called in the BaseServer's serve_forever loop. + """ + self.collect_children() + + def process_request(self, request, client_address): + """Fork a new subprocess to process the request.""" + pid = os.fork() + if pid: + # Parent process + if self.active_children is None: + self.active_children = set() + self.active_children.add(pid) + self.close_request(request) + return + else: + # Child process. + # This must never return, hence os._exit()! + status = 1 + try: + self.finish_request(request, client_address) + status = 0 + except Exception: + self.handle_error(request, client_address) + finally: + try: + self.shutdown_request(request) + finally: + os._exit(status) + + def server_close(self): + super().server_close() + self.collect_children(blocking=self.block_on_close) + + +class _Threads(list): + """ + Joinable list of all non-daemon threads. + """ + def append(self, thread): + self.reap() + if thread.daemon: + return + super().append(thread) + + def pop_all(self): + self[:], result = [], self[:] + return result + + def join(self): + for thread in self.pop_all(): + thread.join() + + def reap(self): + self[:] = (thread for thread in self if thread.is_alive()) + + +class _NoThreads: + """ + Degenerate version of _Threads. + """ + def append(self, thread): + pass + + def join(self): + pass + + +class ThreadingMixIn: + """Mix-in class to handle each request in a new thread.""" + + # Decides how threads will act upon termination of the + # main process + daemon_threads = False + # If true, server_close() waits until all non-daemonic threads terminate. + block_on_close = True + # Threads object + # used by server_close() to wait for all threads completion. + _threads = _NoThreads() + + def process_request_thread(self, request, client_address): + """Same as in BaseServer but as a thread. + + In addition, exception handling is done here. + + """ + try: + self.finish_request(request, client_address) + except Exception: + self.handle_error(request, client_address) + finally: + self.shutdown_request(request) + + def process_request(self, request, client_address): + """Start a new thread to process the request.""" + if self.block_on_close: + vars(self).setdefault('_threads', _Threads()) + t = threading.Thread(target = self.process_request_thread, + args = (request, client_address)) + t.daemon = self.daemon_threads + self._threads.append(t) + t.start() + + def server_close(self): + super().server_close() + self._threads.join() + + +if hasattr(os, "fork"): + class ForkingUDPServer(ForkingMixIn, UDPServer): pass + class ForkingTCPServer(ForkingMixIn, TCPServer): pass + +class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass +class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass + +if hasattr(socket, 'AF_UNIX'): + + class UnixStreamServer(TCPServer): + address_family = socket.AF_UNIX + + class UnixDatagramServer(UDPServer): + address_family = socket.AF_UNIX + + class ThreadingUnixStreamServer(ThreadingMixIn, UnixStreamServer): pass + + class ThreadingUnixDatagramServer(ThreadingMixIn, UnixDatagramServer): pass + +class BaseRequestHandler: + + """Base class for request handler classes. + + This class is instantiated for each request to be handled. The + constructor sets the instance variables request, client_address + and server, and then calls the handle() method. To implement a + specific service, all you need to do is to derive a class which + defines a handle() method. + + The handle() method can find the request as self.request, the + client address as self.client_address, and the server (in case it + needs access to per-server information) as self.server. Since a + separate instance is created for each request, the handle() method + can define other arbitrary instance variables. + + """ + + def __init__(self, request, client_address, server): + self.request = request + self.client_address = client_address + self.server = server + self.setup() + try: + self.handle() + finally: + self.finish() + + def setup(self): + pass + + def handle(self): + pass + + def finish(self): + pass + + +# The following two classes make it possible to use the same service +# class for stream or datagram servers. +# Each class sets up these instance variables: +# - rfile: a file object from which receives the request is read +# - wfile: a file object to which the reply is written +# When the handle() method returns, wfile is flushed properly + + +class StreamRequestHandler(BaseRequestHandler): + + """Define self.rfile and self.wfile for stream sockets.""" + + # Default buffer sizes for rfile, wfile. + # We default rfile to buffered because otherwise it could be + # really slow for large data (a getc() call per byte); we make + # wfile unbuffered because (a) often after a write() we want to + # read and we need to flush the line; (b) big writes to unbuffered + # files are typically optimized by stdio even when big reads + # aren't. + rbufsize = -1 + wbufsize = 0 + + # A timeout to apply to the request socket, if not None. + timeout = None + + # Disable nagle algorithm for this socket, if True. + # Use only when wbufsize != 0, to avoid small packets. + disable_nagle_algorithm = False + + def setup(self): + self.connection = self.request + if self.timeout is not None: + self.connection.settimeout(self.timeout) + if self.disable_nagle_algorithm: + self.connection.setsockopt(socket.IPPROTO_TCP, + socket.TCP_NODELAY, True) + self.rfile = self.connection.makefile('rb', self.rbufsize) + if self.wbufsize == 0: + self.wfile = _SocketWriter(self.connection) + else: + self.wfile = self.connection.makefile('wb', self.wbufsize) + + def finish(self): + if not self.wfile.closed: + try: + self.wfile.flush() + except socket.error: + # A final socket error may have occurred here, such as + # the local error ECONNABORTED. + pass + self.wfile.close() + self.rfile.close() + +class _SocketWriter(BufferedIOBase): + """Simple writable BufferedIOBase implementation for a socket + + Does not hold data in a buffer, avoiding any need to call flush().""" + + def __init__(self, sock): + self._sock = sock + + def writable(self): + return True + + def write(self, b): + self._sock.sendall(b) + with memoryview(b) as view: + return view.nbytes + + def fileno(self): + return self._sock.fileno() + +class DatagramRequestHandler(BaseRequestHandler): + + """Define self.rfile and self.wfile for datagram sockets.""" + + def setup(self): + from io import BytesIO + self.packet, self.socket = self.request + self.rfile = BytesIO(self.packet) + self.wfile = BytesIO() + + def finish(self): + self.socket.sendto(self.wfile.getvalue(), self.client_address) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5a2dbd360fb49f5189206f811d36543e5782ee16 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/__init__.py @@ -0,0 +1,71 @@ +# pysqlite2/__init__.py: the pysqlite2 package. +# +# Copyright (C) 2005 Gerhard Häring +# +# This file is part of pysqlite. +# +# This software is provided 'as-is', without any express or implied +# warranty. In no event will the authors be held liable for any damages +# arising from the use of this software. +# +# Permission is granted to anyone to use this software for any purpose, +# including commercial applications, and to alter it and redistribute it +# freely, subject to the following restrictions: +# +# 1. The origin of this software must not be misrepresented; you must not +# claim that you wrote the original software. If you use this software +# in a product, an acknowledgment in the product documentation would be +# appreciated but is not required. +# 2. Altered source versions must be plainly marked as such, and must not be +# misrepresented as being the original software. +# 3. This notice may not be removed or altered from any source distribution. + +""" +The sqlite3 extension module provides a DB-API 2.0 (PEP 249) compliant +interface to the SQLite library, and requires SQLite 3.7.15 or newer. + +To use the module, start by creating a database Connection object: + + import sqlite3 + cx = sqlite3.connect("test.db") # test.db will be created or opened + +The special path name ":memory:" can be provided to connect to a transient +in-memory database: + + cx = sqlite3.connect(":memory:") # connect to a database in RAM + +Once a connection has been established, create a Cursor object and call +its execute() method to perform SQL queries: + + cu = cx.cursor() + + # create a table + cu.execute("create table lang(name, first_appeared)") + + # insert values into a table + cu.execute("insert into lang values (?, ?)", ("C", 1972)) + + # execute a query and iterate over the result + for row in cu.execute("select * from lang"): + print(row) + + cx.close() + +The sqlite3 module is written by Gerhard Häring . +""" + +from sqlite3.dbapi2 import * + + +# bpo-42264: OptimizedUnicode was deprecated in Python 3.10. It's scheduled +# for removal in Python 3.12. +def __getattr__(name): + if name == "OptimizedUnicode": + import warnings + msg = (""" + OptimizedUnicode is deprecated and will be removed in Python 3.12. + Since Python 3.3 it has simply been an alias for 'str'. + """) + warnings.warn(msg, DeprecationWarning, stacklevel=2) + return str + raise AttributeError(f"module 'sqlite3' has no attribute '{name}'") diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6435297bf20b5f9fa0f510ce11f86423e172ed1f Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/__pycache__/dbapi2.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/__pycache__/dbapi2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..358292dd6455a2025c5a63826c0faf1b481e4d83 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/__pycache__/dbapi2.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/__pycache__/dump.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/__pycache__/dump.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7378fdce9048d44c5e6eb87c389516f9fa71da38 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/__pycache__/dump.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/dbapi2.py b/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/dbapi2.py new file mode 100644 index 0000000000000000000000000000000000000000..7cf4dd32d541dd984d113d86559b20e02b84ff32 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/dbapi2.py @@ -0,0 +1,101 @@ +# pysqlite2/dbapi2.py: the DB-API 2.0 interface +# +# Copyright (C) 2004-2005 Gerhard Häring +# +# This file is part of pysqlite. +# +# This software is provided 'as-is', without any express or implied +# warranty. In no event will the authors be held liable for any damages +# arising from the use of this software. +# +# Permission is granted to anyone to use this software for any purpose, +# including commercial applications, and to alter it and redistribute it +# freely, subject to the following restrictions: +# +# 1. The origin of this software must not be misrepresented; you must not +# claim that you wrote the original software. If you use this software +# in a product, an acknowledgment in the product documentation would be +# appreciated but is not required. +# 2. Altered source versions must be plainly marked as such, and must not be +# misrepresented as being the original software. +# 3. This notice may not be removed or altered from any source distribution. + +import datetime +import time +import collections.abc + +from _sqlite3 import * + +paramstyle = "qmark" + +apilevel = "2.0" + +Date = datetime.date + +Time = datetime.time + +Timestamp = datetime.datetime + +def DateFromTicks(ticks): + return Date(*time.localtime(ticks)[:3]) + +def TimeFromTicks(ticks): + return Time(*time.localtime(ticks)[3:6]) + +def TimestampFromTicks(ticks): + return Timestamp(*time.localtime(ticks)[:6]) + +version_info = tuple([int(x) for x in version.split(".")]) +sqlite_version_info = tuple([int(x) for x in sqlite_version.split(".")]) + +Binary = memoryview +collections.abc.Sequence.register(Row) + +def register_adapters_and_converters(): + def adapt_date(val): + return val.isoformat() + + def adapt_datetime(val): + return val.isoformat(" ") + + def convert_date(val): + return datetime.date(*map(int, val.split(b"-"))) + + def convert_timestamp(val): + datepart, timepart = val.split(b" ") + year, month, day = map(int, datepart.split(b"-")) + timepart_full = timepart.split(b".") + hours, minutes, seconds = map(int, timepart_full[0].split(b":")) + if len(timepart_full) == 2: + microseconds = int('{:0<6.6}'.format(timepart_full[1].decode())) + else: + microseconds = 0 + + val = datetime.datetime(year, month, day, hours, minutes, seconds, microseconds) + return val + + + register_adapter(datetime.date, adapt_date) + register_adapter(datetime.datetime, adapt_datetime) + register_converter("date", convert_date) + register_converter("timestamp", convert_timestamp) + +register_adapters_and_converters() + +# bpo-24464: enable_shared_cache was deprecated in Python 3.10. It's +# scheduled for removal in Python 3.12. +def enable_shared_cache(enable): + from _sqlite3 import enable_shared_cache as _old_enable_shared_cache + import warnings + msg = ( + "enable_shared_cache is deprecated and will be removed in Python 3.12. " + "Shared cache is strongly discouraged by the SQLite 3 documentation. " + "If shared cache must be used, open the database in URI mode using" + "the cache=shared query parameter." + ) + warnings.warn(msg, DeprecationWarning, stacklevel=2) + return _old_enable_shared_cache(enable) + +# Clean up namespace + +del(register_adapters_and_converters) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/dump.py b/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/dump.py new file mode 100644 index 0000000000000000000000000000000000000000..1cf8759f8970f1ea7259b1c849d82e6d64d78e57 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/sqlite3/dump.py @@ -0,0 +1,88 @@ +# Mimic the sqlite3 console shell's .dump command +# Author: Paul Kippes + +# Every identifier in sql is quoted based on a comment in sqlite +# documentation "SQLite adds new keywords from time to time when it +# takes on new features. So to prevent your code from being broken by +# future enhancements, you should normally quote any identifier that +# is an English language word, even if you do not have to." + +def _iterdump(connection): + """ + Returns an iterator to the dump of the database in an SQL text format. + + Used to produce an SQL dump of the database. Useful to save an in-memory + database for later restoration. This function should not be called + directly but instead called from the Connection method, iterdump(). + """ + + writeable_schema = False + cu = connection.cursor() + yield('BEGIN TRANSACTION;') + + # sqlite_master table contains the SQL CREATE statements for the database. + q = """ + SELECT "name", "type", "sql" + FROM "sqlite_master" + WHERE "sql" NOT NULL AND + "type" == 'table' + ORDER BY "name" + """ + schema_res = cu.execute(q) + sqlite_sequence = [] + for table_name, type, sql in schema_res.fetchall(): + if table_name == 'sqlite_sequence': + rows = cu.execute('SELECT * FROM "sqlite_sequence";').fetchall() + sqlite_sequence = ['DELETE FROM "sqlite_sequence"'] + sqlite_sequence += [ + f'INSERT INTO "sqlite_sequence" VALUES(\'{row[0]}\',{row[1]})' + for row in rows + ] + continue + elif table_name == 'sqlite_stat1': + yield('ANALYZE "sqlite_master";') + elif table_name.startswith('sqlite_'): + continue + elif sql.startswith('CREATE VIRTUAL TABLE'): + if not writeable_schema: + writeable_schema = True + yield('PRAGMA writable_schema=ON;') + yield("INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)" + "VALUES('table','{0}','{0}',0,'{1}');".format( + table_name.replace("'", "''"), + sql.replace("'", "''"), + )) + else: + yield('{0};'.format(sql)) + + # Build the insert statement for each row of the current table + table_name_ident = table_name.replace('"', '""') + res = cu.execute('PRAGMA table_info("{0}")'.format(table_name_ident)) + column_names = [str(table_info[1]) for table_info in res.fetchall()] + q = """SELECT 'INSERT INTO "{0}" VALUES({1})' FROM "{0}";""".format( + table_name_ident, + ",".join("""'||quote("{0}")||'""".format(col.replace('"', '""')) for col in column_names)) + query_res = cu.execute(q) + for row in query_res: + yield("{0};".format(row[0])) + + # Now when the type is 'index', 'trigger', or 'view' + q = """ + SELECT "name", "type", "sql" + FROM "sqlite_master" + WHERE "sql" NOT NULL AND + "type" IN ('index', 'trigger', 'view') + """ + schema_res = cu.execute(q) + for name, type, sql in schema_res.fetchall(): + yield('{0};'.format(sql)) + + if writeable_schema: + yield('PRAGMA writable_schema=OFF;') + + # gh-79009: Yield statements concerning the sqlite_sequence table at the + # end of the transaction. + for row in sqlite_sequence: + yield('{0};'.format(row)) + + yield('COMMIT;') diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/sre_compile.py b/physworld_p1_20261018/envs/p1/lib/python3.11/sre_compile.py new file mode 100644 index 0000000000000000000000000000000000000000..f9da61e6487869b7f416b0a4e92064ad8e877fa2 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/sre_compile.py @@ -0,0 +1,7 @@ +import warnings +warnings.warn(f"module {__name__!r} is deprecated", + DeprecationWarning, + stacklevel=2) + +from re import _compiler as _ +globals().update({k: v for k, v in vars(_).items() if k[:2] != '__'}) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/sre_constants.py b/physworld_p1_20261018/envs/p1/lib/python3.11/sre_constants.py new file mode 100644 index 0000000000000000000000000000000000000000..fa09d044292965a05a9c67e579d73091b56da892 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/sre_constants.py @@ -0,0 +1,7 @@ +import warnings +warnings.warn(f"module {__name__!r} is deprecated", + DeprecationWarning, + stacklevel=2) + +from re import _constants as _ +globals().update({k: v for k, v in vars(_).items() if k[:2] != '__'}) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/sre_parse.py b/physworld_p1_20261018/envs/p1/lib/python3.11/sre_parse.py new file mode 100644 index 0000000000000000000000000000000000000000..25a3f557d44c61fae2a8bf7ede49c2845b73a3d7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/sre_parse.py @@ -0,0 +1,7 @@ +import warnings +warnings.warn(f"module {__name__!r} is deprecated", + DeprecationWarning, + stacklevel=2) + +from re import _parser as _ +globals().update({k: v for k, v in vars(_).items() if k[:2] != '__'}) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/ssl.py b/physworld_p1_20261018/envs/p1/lib/python3.11/ssl.py new file mode 100644 index 0000000000000000000000000000000000000000..8aee67ba9ec7b8903e346486aa551a4a9e5c6733 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/ssl.py @@ -0,0 +1,1582 @@ +# Wrapper module for _ssl, providing some additional facilities +# implemented in Python. Written by Bill Janssen. + +"""This module provides some more Pythonic support for SSL. + +Object types: + + SSLSocket -- subtype of socket.socket which does SSL over the socket + +Exceptions: + + SSLError -- exception raised for I/O errors + +Functions: + + cert_time_to_seconds -- convert time string used for certificate + notBefore and notAfter functions to integer + seconds past the Epoch (the time values + returned from time.time()) + + get_server_certificate (addr, ssl_version, ca_certs, timeout) -- Retrieve the + certificate from the server at the specified + address and return it as a PEM-encoded string + + +Integer constants: + +SSL_ERROR_ZERO_RETURN +SSL_ERROR_WANT_READ +SSL_ERROR_WANT_WRITE +SSL_ERROR_WANT_X509_LOOKUP +SSL_ERROR_SYSCALL +SSL_ERROR_SSL +SSL_ERROR_WANT_CONNECT + +SSL_ERROR_EOF +SSL_ERROR_INVALID_ERROR_CODE + +The following group define certificate requirements that one side is +allowing/requiring from the other side: + +CERT_NONE - no certificates from the other side are required (or will + be looked at if provided) +CERT_OPTIONAL - certificates are not required, but if provided will be + validated, and if validation fails, the connection will + also fail +CERT_REQUIRED - certificates are required, and will be validated, and + if validation fails, the connection will also fail + +The following constants identify various SSL protocol variants: + +PROTOCOL_SSLv2 +PROTOCOL_SSLv3 +PROTOCOL_SSLv23 +PROTOCOL_TLS +PROTOCOL_TLS_CLIENT +PROTOCOL_TLS_SERVER +PROTOCOL_TLSv1 +PROTOCOL_TLSv1_1 +PROTOCOL_TLSv1_2 + +The following constants identify various SSL alert message descriptions as per +http://www.iana.org/assignments/tls-parameters/tls-parameters.xml#tls-parameters-6 + +ALERT_DESCRIPTION_CLOSE_NOTIFY +ALERT_DESCRIPTION_UNEXPECTED_MESSAGE +ALERT_DESCRIPTION_BAD_RECORD_MAC +ALERT_DESCRIPTION_RECORD_OVERFLOW +ALERT_DESCRIPTION_DECOMPRESSION_FAILURE +ALERT_DESCRIPTION_HANDSHAKE_FAILURE +ALERT_DESCRIPTION_BAD_CERTIFICATE +ALERT_DESCRIPTION_UNSUPPORTED_CERTIFICATE +ALERT_DESCRIPTION_CERTIFICATE_REVOKED +ALERT_DESCRIPTION_CERTIFICATE_EXPIRED +ALERT_DESCRIPTION_CERTIFICATE_UNKNOWN +ALERT_DESCRIPTION_ILLEGAL_PARAMETER +ALERT_DESCRIPTION_UNKNOWN_CA +ALERT_DESCRIPTION_ACCESS_DENIED +ALERT_DESCRIPTION_DECODE_ERROR +ALERT_DESCRIPTION_DECRYPT_ERROR +ALERT_DESCRIPTION_PROTOCOL_VERSION +ALERT_DESCRIPTION_INSUFFICIENT_SECURITY +ALERT_DESCRIPTION_INTERNAL_ERROR +ALERT_DESCRIPTION_USER_CANCELLED +ALERT_DESCRIPTION_NO_RENEGOTIATION +ALERT_DESCRIPTION_UNSUPPORTED_EXTENSION +ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE +ALERT_DESCRIPTION_UNRECOGNIZED_NAME +ALERT_DESCRIPTION_BAD_CERTIFICATE_STATUS_RESPONSE +ALERT_DESCRIPTION_BAD_CERTIFICATE_HASH_VALUE +ALERT_DESCRIPTION_UNKNOWN_PSK_IDENTITY +""" + +import sys +import os +from collections import namedtuple +from enum import Enum as _Enum, IntEnum as _IntEnum, IntFlag as _IntFlag +from enum import _simple_enum + +import _ssl # if we can't import it, let the error propagate + +from _ssl import OPENSSL_VERSION_NUMBER, OPENSSL_VERSION_INFO, OPENSSL_VERSION +from _ssl import _SSLContext, MemoryBIO, SSLSession +from _ssl import ( + SSLError, SSLZeroReturnError, SSLWantReadError, SSLWantWriteError, + SSLSyscallError, SSLEOFError, SSLCertVerificationError + ) +from _ssl import txt2obj as _txt2obj, nid2obj as _nid2obj +from _ssl import RAND_status, RAND_add, RAND_bytes, RAND_pseudo_bytes +try: + from _ssl import RAND_egd +except ImportError: + # LibreSSL does not provide RAND_egd + pass + + +from _ssl import ( + HAS_SNI, HAS_ECDH, HAS_NPN, HAS_ALPN, HAS_SSLv2, HAS_SSLv3, HAS_TLSv1, + HAS_TLSv1_1, HAS_TLSv1_2, HAS_TLSv1_3 +) +from _ssl import _DEFAULT_CIPHERS, _OPENSSL_API_VERSION + +_IntEnum._convert_( + '_SSLMethod', __name__, + lambda name: name.startswith('PROTOCOL_') and name != 'PROTOCOL_SSLv23', + source=_ssl) + +_IntFlag._convert_( + 'Options', __name__, + lambda name: name.startswith('OP_'), + source=_ssl) + +_IntEnum._convert_( + 'AlertDescription', __name__, + lambda name: name.startswith('ALERT_DESCRIPTION_'), + source=_ssl) + +_IntEnum._convert_( + 'SSLErrorNumber', __name__, + lambda name: name.startswith('SSL_ERROR_'), + source=_ssl) + +_IntFlag._convert_( + 'VerifyFlags', __name__, + lambda name: name.startswith('VERIFY_'), + source=_ssl) + +_IntEnum._convert_( + 'VerifyMode', __name__, + lambda name: name.startswith('CERT_'), + source=_ssl) + +PROTOCOL_SSLv23 = _SSLMethod.PROTOCOL_SSLv23 = _SSLMethod.PROTOCOL_TLS +_PROTOCOL_NAMES = {value: name for name, value in _SSLMethod.__members__.items()} + +_SSLv2_IF_EXISTS = getattr(_SSLMethod, 'PROTOCOL_SSLv2', None) + + +@_simple_enum(_IntEnum) +class TLSVersion: + MINIMUM_SUPPORTED = _ssl.PROTO_MINIMUM_SUPPORTED + SSLv3 = _ssl.PROTO_SSLv3 + TLSv1 = _ssl.PROTO_TLSv1 + TLSv1_1 = _ssl.PROTO_TLSv1_1 + TLSv1_2 = _ssl.PROTO_TLSv1_2 + TLSv1_3 = _ssl.PROTO_TLSv1_3 + MAXIMUM_SUPPORTED = _ssl.PROTO_MAXIMUM_SUPPORTED + + +@_simple_enum(_IntEnum) +class _TLSContentType: + """Content types (record layer) + + See RFC 8446, section B.1 + """ + CHANGE_CIPHER_SPEC = 20 + ALERT = 21 + HANDSHAKE = 22 + APPLICATION_DATA = 23 + # pseudo content types + HEADER = 0x100 + INNER_CONTENT_TYPE = 0x101 + + +@_simple_enum(_IntEnum) +class _TLSAlertType: + """Alert types for TLSContentType.ALERT messages + + See RFC 8466, section B.2 + """ + CLOSE_NOTIFY = 0 + UNEXPECTED_MESSAGE = 10 + BAD_RECORD_MAC = 20 + DECRYPTION_FAILED = 21 + RECORD_OVERFLOW = 22 + DECOMPRESSION_FAILURE = 30 + HANDSHAKE_FAILURE = 40 + NO_CERTIFICATE = 41 + BAD_CERTIFICATE = 42 + UNSUPPORTED_CERTIFICATE = 43 + CERTIFICATE_REVOKED = 44 + CERTIFICATE_EXPIRED = 45 + CERTIFICATE_UNKNOWN = 46 + ILLEGAL_PARAMETER = 47 + UNKNOWN_CA = 48 + ACCESS_DENIED = 49 + DECODE_ERROR = 50 + DECRYPT_ERROR = 51 + EXPORT_RESTRICTION = 60 + PROTOCOL_VERSION = 70 + INSUFFICIENT_SECURITY = 71 + INTERNAL_ERROR = 80 + INAPPROPRIATE_FALLBACK = 86 + USER_CANCELED = 90 + NO_RENEGOTIATION = 100 + MISSING_EXTENSION = 109 + UNSUPPORTED_EXTENSION = 110 + CERTIFICATE_UNOBTAINABLE = 111 + UNRECOGNIZED_NAME = 112 + BAD_CERTIFICATE_STATUS_RESPONSE = 113 + BAD_CERTIFICATE_HASH_VALUE = 114 + UNKNOWN_PSK_IDENTITY = 115 + CERTIFICATE_REQUIRED = 116 + NO_APPLICATION_PROTOCOL = 120 + + +@_simple_enum(_IntEnum) +class _TLSMessageType: + """Message types (handshake protocol) + + See RFC 8446, section B.3 + """ + HELLO_REQUEST = 0 + CLIENT_HELLO = 1 + SERVER_HELLO = 2 + HELLO_VERIFY_REQUEST = 3 + NEWSESSION_TICKET = 4 + END_OF_EARLY_DATA = 5 + HELLO_RETRY_REQUEST = 6 + ENCRYPTED_EXTENSIONS = 8 + CERTIFICATE = 11 + SERVER_KEY_EXCHANGE = 12 + CERTIFICATE_REQUEST = 13 + SERVER_DONE = 14 + CERTIFICATE_VERIFY = 15 + CLIENT_KEY_EXCHANGE = 16 + FINISHED = 20 + CERTIFICATE_URL = 21 + CERTIFICATE_STATUS = 22 + SUPPLEMENTAL_DATA = 23 + KEY_UPDATE = 24 + NEXT_PROTO = 67 + MESSAGE_HASH = 254 + CHANGE_CIPHER_SPEC = 0x0101 + + +if sys.platform == "win32": + from _ssl import enum_certificates, enum_crls + +from socket import socket, SOCK_STREAM, create_connection +from socket import SOL_SOCKET, SO_TYPE, _GLOBAL_DEFAULT_TIMEOUT +import socket as _socket +import base64 # for DER-to-PEM translation +import errno +import warnings + + +socket_error = OSError # keep that public name in module namespace + +CHANNEL_BINDING_TYPES = ['tls-unique'] + +HAS_NEVER_CHECK_COMMON_NAME = hasattr(_ssl, 'HOSTFLAG_NEVER_CHECK_SUBJECT') + + +_RESTRICTED_SERVER_CIPHERS = _DEFAULT_CIPHERS + +CertificateError = SSLCertVerificationError + + +def _dnsname_match(dn, hostname): + """Matching according to RFC 6125, section 6.4.3 + + - Hostnames are compared lower-case. + - For IDNA, both dn and hostname must be encoded as IDN A-label (ACE). + - Partial wildcards like 'www*.example.org', multiple wildcards, sole + wildcard or wildcards in labels other then the left-most label are not + supported and a CertificateError is raised. + - A wildcard must match at least one character. + """ + if not dn: + return False + + wildcards = dn.count('*') + # speed up common case w/o wildcards + if not wildcards: + return dn.lower() == hostname.lower() + + if wildcards > 1: + raise CertificateError( + "too many wildcards in certificate DNS name: {!r}.".format(dn)) + + dn_leftmost, sep, dn_remainder = dn.partition('.') + + if '*' in dn_remainder: + # Only match wildcard in leftmost segment. + raise CertificateError( + "wildcard can only be present in the leftmost label: " + "{!r}.".format(dn)) + + if not sep: + # no right side + raise CertificateError( + "sole wildcard without additional labels are not support: " + "{!r}.".format(dn)) + + if dn_leftmost != '*': + # no partial wildcard matching + raise CertificateError( + "partial wildcards in leftmost label are not supported: " + "{!r}.".format(dn)) + + hostname_leftmost, sep, hostname_remainder = hostname.partition('.') + if not hostname_leftmost or not sep: + # wildcard must match at least one char + return False + return dn_remainder.lower() == hostname_remainder.lower() + + +def _inet_paton(ipname): + """Try to convert an IP address to packed binary form + + Supports IPv4 addresses on all platforms and IPv6 on platforms with IPv6 + support. + """ + # inet_aton() also accepts strings like '1', '127.1', some also trailing + # data like '127.0.0.1 whatever'. + try: + addr = _socket.inet_aton(ipname) + except OSError: + # not an IPv4 address + pass + else: + if _socket.inet_ntoa(addr) == ipname: + # only accept injective ipnames + return addr + else: + # refuse for short IPv4 notation and additional trailing data + raise ValueError( + "{!r} is not a quad-dotted IPv4 address.".format(ipname) + ) + + try: + return _socket.inet_pton(_socket.AF_INET6, ipname) + except OSError: + raise ValueError("{!r} is neither an IPv4 nor an IP6 " + "address.".format(ipname)) + except AttributeError: + # AF_INET6 not available + pass + + raise ValueError("{!r} is not an IPv4 address.".format(ipname)) + + +def _ipaddress_match(cert_ipaddress, host_ip): + """Exact matching of IP addresses. + + RFC 6125 explicitly doesn't define an algorithm for this + (section 1.7.2 - "Out of Scope"). + """ + # OpenSSL may add a trailing newline to a subjectAltName's IP address, + # commonly with IPv6 addresses. Strip off trailing \n. + ip = _inet_paton(cert_ipaddress.rstrip()) + return ip == host_ip + + +def match_hostname(cert, hostname): + """Verify that *cert* (in decoded format as returned by + SSLSocket.getpeercert()) matches the *hostname*. RFC 2818 and RFC 6125 + rules are followed. + + The function matches IP addresses rather than dNSNames if hostname is a + valid ipaddress string. IPv4 addresses are supported on all platforms. + IPv6 addresses are supported on platforms with IPv6 support (AF_INET6 + and inet_pton). + + CertificateError is raised on failure. On success, the function + returns nothing. + """ + warnings.warn( + "ssl.match_hostname() is deprecated", + category=DeprecationWarning, + stacklevel=2 + ) + if not cert: + raise ValueError("empty or no certificate, match_hostname needs a " + "SSL socket or SSL context with either " + "CERT_OPTIONAL or CERT_REQUIRED") + try: + host_ip = _inet_paton(hostname) + except ValueError: + # Not an IP address (common case) + host_ip = None + dnsnames = [] + san = cert.get('subjectAltName', ()) + for key, value in san: + if key == 'DNS': + if host_ip is None and _dnsname_match(value, hostname): + return + dnsnames.append(value) + elif key == 'IP Address': + if host_ip is not None and _ipaddress_match(value, host_ip): + return + dnsnames.append(value) + if not dnsnames: + # The subject is only checked when there is no dNSName entry + # in subjectAltName + for sub in cert.get('subject', ()): + for key, value in sub: + # XXX according to RFC 2818, the most specific Common Name + # must be used. + if key == 'commonName': + if _dnsname_match(value, hostname): + return + dnsnames.append(value) + if len(dnsnames) > 1: + raise CertificateError("hostname %r " + "doesn't match either of %s" + % (hostname, ', '.join(map(repr, dnsnames)))) + elif len(dnsnames) == 1: + raise CertificateError("hostname %r " + "doesn't match %r" + % (hostname, dnsnames[0])) + else: + raise CertificateError("no appropriate commonName or " + "subjectAltName fields were found") + + +DefaultVerifyPaths = namedtuple("DefaultVerifyPaths", + "cafile capath openssl_cafile_env openssl_cafile openssl_capath_env " + "openssl_capath") + +def get_default_verify_paths(): + """Return paths to default cafile and capath. + """ + parts = _ssl.get_default_verify_paths() + + # environment vars shadow paths + cafile = os.environ.get(parts[0], parts[1]) + capath = os.environ.get(parts[2], parts[3]) + + return DefaultVerifyPaths(cafile if os.path.isfile(cafile) else None, + capath if os.path.isdir(capath) else None, + *parts) + + +class _ASN1Object(namedtuple("_ASN1Object", "nid shortname longname oid")): + """ASN.1 object identifier lookup + """ + __slots__ = () + + def __new__(cls, oid): + return super().__new__(cls, *_txt2obj(oid, name=False)) + + @classmethod + def fromnid(cls, nid): + """Create _ASN1Object from OpenSSL numeric ID + """ + return super().__new__(cls, *_nid2obj(nid)) + + @classmethod + def fromname(cls, name): + """Create _ASN1Object from short name, long name or OID + """ + return super().__new__(cls, *_txt2obj(name, name=True)) + + +class Purpose(_ASN1Object, _Enum): + """SSLContext purpose flags with X509v3 Extended Key Usage objects + """ + SERVER_AUTH = '1.3.6.1.5.5.7.3.1' + CLIENT_AUTH = '1.3.6.1.5.5.7.3.2' + + +class SSLContext(_SSLContext): + """An SSLContext holds various SSL-related configuration options and + data, such as certificates and possibly a private key.""" + _windows_cert_stores = ("CA", "ROOT") + + sslsocket_class = None # SSLSocket is assigned later. + sslobject_class = None # SSLObject is assigned later. + + def __new__(cls, protocol=None, *args, **kwargs): + if protocol is None: + warnings.warn( + "ssl.SSLContext() without protocol argument is deprecated.", + category=DeprecationWarning, + stacklevel=2 + ) + protocol = PROTOCOL_TLS + self = _SSLContext.__new__(cls, protocol) + return self + + def _encode_hostname(self, hostname): + if hostname is None: + return None + elif isinstance(hostname, str): + return hostname.encode('idna').decode('ascii') + else: + return hostname.decode('ascii') + + def wrap_socket(self, sock, server_side=False, + do_handshake_on_connect=True, + suppress_ragged_eofs=True, + server_hostname=None, session=None): + # SSLSocket class handles server_hostname encoding before it calls + # ctx._wrap_socket() + return self.sslsocket_class._create( + sock=sock, + server_side=server_side, + do_handshake_on_connect=do_handshake_on_connect, + suppress_ragged_eofs=suppress_ragged_eofs, + server_hostname=server_hostname, + context=self, + session=session + ) + + def wrap_bio(self, incoming, outgoing, server_side=False, + server_hostname=None, session=None): + # Need to encode server_hostname here because _wrap_bio() can only + # handle ASCII str. + return self.sslobject_class._create( + incoming, outgoing, server_side=server_side, + server_hostname=self._encode_hostname(server_hostname), + session=session, context=self, + ) + + def set_npn_protocols(self, npn_protocols): + warnings.warn( + "ssl NPN is deprecated, use ALPN instead", + DeprecationWarning, + stacklevel=2 + ) + protos = bytearray() + for protocol in npn_protocols: + b = bytes(protocol, 'ascii') + if len(b) == 0 or len(b) > 255: + raise SSLError('NPN protocols must be 1 to 255 in length') + protos.append(len(b)) + protos.extend(b) + + self._set_npn_protocols(protos) + + def set_servername_callback(self, server_name_callback): + if server_name_callback is None: + self.sni_callback = None + else: + if not callable(server_name_callback): + raise TypeError("not a callable object") + + def shim_cb(sslobj, servername, sslctx): + servername = self._encode_hostname(servername) + return server_name_callback(sslobj, servername, sslctx) + + self.sni_callback = shim_cb + + def set_alpn_protocols(self, alpn_protocols): + protos = bytearray() + for protocol in alpn_protocols: + b = bytes(protocol, 'ascii') + if len(b) == 0 or len(b) > 255: + raise SSLError('ALPN protocols must be 1 to 255 in length') + protos.append(len(b)) + protos.extend(b) + + self._set_alpn_protocols(protos) + + def _load_windows_store_certs(self, storename, purpose): + certs = bytearray() + try: + for cert, encoding, trust in enum_certificates(storename): + # CA certs are never PKCS#7 encoded + if encoding == "x509_asn": + if trust is True or purpose.oid in trust: + certs.extend(cert) + except PermissionError: + warnings.warn("unable to enumerate Windows certificate store") + if certs: + self.load_verify_locations(cadata=certs) + return certs + + def load_default_certs(self, purpose=Purpose.SERVER_AUTH): + if not isinstance(purpose, _ASN1Object): + raise TypeError(purpose) + if sys.platform == "win32": + for storename in self._windows_cert_stores: + self._load_windows_store_certs(storename, purpose) + self.set_default_verify_paths() + + if hasattr(_SSLContext, 'minimum_version'): + @property + def minimum_version(self): + return TLSVersion(super().minimum_version) + + @minimum_version.setter + def minimum_version(self, value): + if value == TLSVersion.SSLv3: + self.options &= ~Options.OP_NO_SSLv3 + super(SSLContext, SSLContext).minimum_version.__set__(self, value) + + @property + def maximum_version(self): + return TLSVersion(super().maximum_version) + + @maximum_version.setter + def maximum_version(self, value): + super(SSLContext, SSLContext).maximum_version.__set__(self, value) + + @property + def options(self): + return Options(super().options) + + @options.setter + def options(self, value): + super(SSLContext, SSLContext).options.__set__(self, value) + + if hasattr(_ssl, 'HOSTFLAG_NEVER_CHECK_SUBJECT'): + @property + def hostname_checks_common_name(self): + ncs = self._host_flags & _ssl.HOSTFLAG_NEVER_CHECK_SUBJECT + return ncs != _ssl.HOSTFLAG_NEVER_CHECK_SUBJECT + + @hostname_checks_common_name.setter + def hostname_checks_common_name(self, value): + if value: + self._host_flags &= ~_ssl.HOSTFLAG_NEVER_CHECK_SUBJECT + else: + self._host_flags |= _ssl.HOSTFLAG_NEVER_CHECK_SUBJECT + else: + @property + def hostname_checks_common_name(self): + return True + + @property + def _msg_callback(self): + """TLS message callback + + The message callback provides a debugging hook to analyze TLS + connections. The callback is called for any TLS protocol message + (header, handshake, alert, and more), but not for application data. + Due to technical limitations, the callback can't be used to filter + traffic or to abort a connection. Any exception raised in the + callback is delayed until the handshake, read, or write operation + has been performed. + + def msg_cb(conn, direction, version, content_type, msg_type, data): + pass + + conn + :class:`SSLSocket` or :class:`SSLObject` instance + direction + ``read`` or ``write`` + version + :class:`TLSVersion` enum member or int for unknown version. For a + frame header, it's the header version. + content_type + :class:`_TLSContentType` enum member or int for unsupported + content type. + msg_type + Either a :class:`_TLSContentType` enum number for a header + message, a :class:`_TLSAlertType` enum member for an alert + message, a :class:`_TLSMessageType` enum member for other + messages, or int for unsupported message types. + data + Raw, decrypted message content as bytes + """ + inner = super()._msg_callback + if inner is not None: + return inner.user_function + else: + return None + + @_msg_callback.setter + def _msg_callback(self, callback): + if callback is None: + super(SSLContext, SSLContext)._msg_callback.__set__(self, None) + return + + if not hasattr(callback, '__call__'): + raise TypeError(f"{callback} is not callable.") + + def inner(conn, direction, version, content_type, msg_type, data): + try: + version = TLSVersion(version) + except ValueError: + pass + + try: + content_type = _TLSContentType(content_type) + except ValueError: + pass + + if content_type == _TLSContentType.HEADER: + msg_enum = _TLSContentType + elif content_type == _TLSContentType.ALERT: + msg_enum = _TLSAlertType + else: + msg_enum = _TLSMessageType + try: + msg_type = msg_enum(msg_type) + except ValueError: + pass + + return callback(conn, direction, version, + content_type, msg_type, data) + + inner.user_function = callback + + super(SSLContext, SSLContext)._msg_callback.__set__(self, inner) + + @property + def protocol(self): + return _SSLMethod(super().protocol) + + @property + def verify_flags(self): + return VerifyFlags(super().verify_flags) + + @verify_flags.setter + def verify_flags(self, value): + super(SSLContext, SSLContext).verify_flags.__set__(self, value) + + @property + def verify_mode(self): + value = super().verify_mode + try: + return VerifyMode(value) + except ValueError: + return value + + @verify_mode.setter + def verify_mode(self, value): + super(SSLContext, SSLContext).verify_mode.__set__(self, value) + + +def create_default_context(purpose=Purpose.SERVER_AUTH, *, cafile=None, + capath=None, cadata=None): + """Create a SSLContext object with default settings. + + NOTE: The protocol and settings may change anytime without prior + deprecation. The values represent a fair balance between maximum + compatibility and security. + """ + if not isinstance(purpose, _ASN1Object): + raise TypeError(purpose) + + # SSLContext sets OP_NO_SSLv2, OP_NO_SSLv3, OP_NO_COMPRESSION, + # OP_CIPHER_SERVER_PREFERENCE, OP_SINGLE_DH_USE and OP_SINGLE_ECDH_USE + # by default. + if purpose == Purpose.SERVER_AUTH: + # verify certs and host name in client mode + context = SSLContext(PROTOCOL_TLS_CLIENT) + context.verify_mode = CERT_REQUIRED + context.check_hostname = True + elif purpose == Purpose.CLIENT_AUTH: + context = SSLContext(PROTOCOL_TLS_SERVER) + else: + raise ValueError(purpose) + + if cafile or capath or cadata: + context.load_verify_locations(cafile, capath, cadata) + elif context.verify_mode != CERT_NONE: + # no explicit cafile, capath or cadata but the verify mode is + # CERT_OPTIONAL or CERT_REQUIRED. Let's try to load default system + # root CA certificates for the given purpose. This may fail silently. + context.load_default_certs(purpose) + # OpenSSL 1.1.1 keylog file + if hasattr(context, 'keylog_filename'): + keylogfile = os.environ.get('SSLKEYLOGFILE') + if keylogfile and not sys.flags.ignore_environment: + context.keylog_filename = keylogfile + return context + +def _create_unverified_context(protocol=None, *, cert_reqs=CERT_NONE, + check_hostname=False, purpose=Purpose.SERVER_AUTH, + certfile=None, keyfile=None, + cafile=None, capath=None, cadata=None): + """Create a SSLContext object for Python stdlib modules + + All Python stdlib modules shall use this function to create SSLContext + objects in order to keep common settings in one place. The configuration + is less restrict than create_default_context()'s to increase backward + compatibility. + """ + if not isinstance(purpose, _ASN1Object): + raise TypeError(purpose) + + # SSLContext sets OP_NO_SSLv2, OP_NO_SSLv3, OP_NO_COMPRESSION, + # OP_CIPHER_SERVER_PREFERENCE, OP_SINGLE_DH_USE and OP_SINGLE_ECDH_USE + # by default. + if purpose == Purpose.SERVER_AUTH: + # verify certs and host name in client mode + if protocol is None: + protocol = PROTOCOL_TLS_CLIENT + elif purpose == Purpose.CLIENT_AUTH: + if protocol is None: + protocol = PROTOCOL_TLS_SERVER + else: + raise ValueError(purpose) + + context = SSLContext(protocol) + context.check_hostname = check_hostname + if cert_reqs is not None: + context.verify_mode = cert_reqs + if check_hostname: + context.check_hostname = True + + if keyfile and not certfile: + raise ValueError("certfile must be specified") + if certfile or keyfile: + context.load_cert_chain(certfile, keyfile) + + # load CA root certs + if cafile or capath or cadata: + context.load_verify_locations(cafile, capath, cadata) + elif context.verify_mode != CERT_NONE: + # no explicit cafile, capath or cadata but the verify mode is + # CERT_OPTIONAL or CERT_REQUIRED. Let's try to load default system + # root CA certificates for the given purpose. This may fail silently. + context.load_default_certs(purpose) + # OpenSSL 1.1.1 keylog file + if hasattr(context, 'keylog_filename'): + keylogfile = os.environ.get('SSLKEYLOGFILE') + if keylogfile and not sys.flags.ignore_environment: + context.keylog_filename = keylogfile + return context + +# Used by http.client if no context is explicitly passed. +_create_default_https_context = create_default_context + + +# Backwards compatibility alias, even though it's not a public name. +_create_stdlib_context = _create_unverified_context + + +class SSLObject: + """This class implements an interface on top of a low-level SSL object as + implemented by OpenSSL. This object captures the state of an SSL connection + but does not provide any network IO itself. IO needs to be performed + through separate "BIO" objects which are OpenSSL's IO abstraction layer. + + This class does not have a public constructor. Instances are returned by + ``SSLContext.wrap_bio``. This class is typically used by framework authors + that want to implement asynchronous IO for SSL through memory buffers. + + When compared to ``SSLSocket``, this object lacks the following features: + + * Any form of network IO, including methods such as ``recv`` and ``send``. + * The ``do_handshake_on_connect`` and ``suppress_ragged_eofs`` machinery. + """ + def __init__(self, *args, **kwargs): + raise TypeError( + f"{self.__class__.__name__} does not have a public " + f"constructor. Instances are returned by SSLContext.wrap_bio()." + ) + + @classmethod + def _create(cls, incoming, outgoing, server_side=False, + server_hostname=None, session=None, context=None): + if server_side: + if server_hostname: + raise ValueError("server_hostname can only be specified " + "in client mode") + if session is not None: + raise ValueError("session can only be specified in " + "client mode") + if context.check_hostname and server_hostname is None: + # Note: server_hostname='' is handled within _wrap_bio(). + warnings.warn("check_hostname requires server_hostname", + category=DeprecationWarning, + stacklevel=3) + + self = cls.__new__(cls) + sslobj = context._wrap_bio( + incoming, outgoing, server_side=server_side, + server_hostname=server_hostname, + owner=self, session=session + ) + self._sslobj = sslobj + return self + + @property + def context(self): + """The SSLContext that is currently in use.""" + return self._sslobj.context + + @context.setter + def context(self, ctx): + self._sslobj.context = ctx + + @property + def session(self): + """The SSLSession for client socket.""" + return self._sslobj.session + + @session.setter + def session(self, session): + self._sslobj.session = session + + @property + def session_reused(self): + """Was the client session reused during handshake""" + return self._sslobj.session_reused + + @property + def server_side(self): + """Whether this is a server-side socket.""" + return self._sslobj.server_side + + @property + def server_hostname(self): + """The currently set server hostname (for SNI), or ``None`` if no + server hostname is set.""" + return self._sslobj.server_hostname + + def read(self, len=1024, buffer=None): + """Read up to 'len' bytes from the SSL object and return them. + + If 'buffer' is provided, read into this buffer and return the number of + bytes read. + """ + if buffer is not None: + v = self._sslobj.read(len, buffer) + else: + v = self._sslobj.read(len) + return v + + def write(self, data): + """Write 'data' to the SSL object and return the number of bytes + written. + + The 'data' argument must support the buffer interface. + """ + return self._sslobj.write(data) + + def getpeercert(self, binary_form=False): + """Returns a formatted version of the data in the certificate provided + by the other end of the SSL channel. + + Return None if no certificate was provided, {} if a certificate was + provided, but not validated. + """ + return self._sslobj.getpeercert(binary_form) + + def selected_npn_protocol(self): + """Return the currently selected NPN protocol as a string, or ``None`` + if a next protocol was not negotiated or if NPN is not supported by one + of the peers.""" + warnings.warn( + "ssl NPN is deprecated, use ALPN instead", + DeprecationWarning, + stacklevel=2 + ) + + def selected_alpn_protocol(self): + """Return the currently selected ALPN protocol as a string, or ``None`` + if a next protocol was not negotiated or if ALPN is not supported by one + of the peers.""" + return self._sslobj.selected_alpn_protocol() + + def cipher(self): + """Return the currently selected cipher as a 3-tuple ``(name, + ssl_version, secret_bits)``.""" + return self._sslobj.cipher() + + def shared_ciphers(self): + """Return a list of ciphers shared by the client during the handshake or + None if this is not a valid server connection. + """ + return self._sslobj.shared_ciphers() + + def compression(self): + """Return the current compression algorithm in use, or ``None`` if + compression was not negotiated or not supported by one of the peers.""" + return self._sslobj.compression() + + def pending(self): + """Return the number of bytes that can be read immediately.""" + return self._sslobj.pending() + + def do_handshake(self): + """Start the SSL/TLS handshake.""" + self._sslobj.do_handshake() + + def unwrap(self): + """Start the SSL shutdown handshake.""" + return self._sslobj.shutdown() + + def get_channel_binding(self, cb_type="tls-unique"): + """Get channel binding data for current connection. Raise ValueError + if the requested `cb_type` is not supported. Return bytes of the data + or None if the data is not available (e.g. before the handshake).""" + return self._sslobj.get_channel_binding(cb_type) + + def version(self): + """Return a string identifying the protocol version used by the + current SSL channel. """ + return self._sslobj.version() + + def verify_client_post_handshake(self): + return self._sslobj.verify_client_post_handshake() + + +def _sslcopydoc(func): + """Copy docstring from SSLObject to SSLSocket""" + func.__doc__ = getattr(SSLObject, func.__name__).__doc__ + return func + + +class SSLSocket(socket): + """This class implements a subtype of socket.socket that wraps + the underlying OS socket in an SSL context when necessary, and + provides read and write methods over that channel. """ + + def __init__(self, *args, **kwargs): + raise TypeError( + f"{self.__class__.__name__} does not have a public " + f"constructor. Instances are returned by " + f"SSLContext.wrap_socket()." + ) + + @classmethod + def _create(cls, sock, server_side=False, do_handshake_on_connect=True, + suppress_ragged_eofs=True, server_hostname=None, + context=None, session=None): + if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM: + raise NotImplementedError("only stream sockets are supported") + if server_side: + if server_hostname: + raise ValueError("server_hostname can only be specified " + "in client mode") + if session is not None: + raise ValueError("session can only be specified in " + "client mode") + if context.check_hostname and not server_hostname: + raise ValueError("check_hostname requires server_hostname") + + sock_timeout = sock.gettimeout() + kwargs = dict( + family=sock.family, type=sock.type, proto=sock.proto, + fileno=sock.fileno() + ) + self = cls.__new__(cls, **kwargs) + super(SSLSocket, self).__init__(**kwargs) + sock.detach() + # Now SSLSocket is responsible for closing the file descriptor. + try: + self._context = context + self._session = session + self._closed = False + self._sslobj = None + self.server_side = server_side + self.server_hostname = context._encode_hostname(server_hostname) + self.do_handshake_on_connect = do_handshake_on_connect + self.suppress_ragged_eofs = suppress_ragged_eofs + + # See if we are connected + try: + self.getpeername() + except OSError as e: + if e.errno != errno.ENOTCONN: + raise + connected = False + blocking = self.getblocking() + self.setblocking(False) + try: + # We are not connected so this is not supposed to block, but + # testing revealed otherwise on macOS and Windows so we do + # the non-blocking dance regardless. Our raise when any data + # is found means consuming the data is harmless. + notconn_pre_handshake_data = self.recv(1) + except OSError as e: + # EINVAL occurs for recv(1) on non-connected on unix sockets. + if e.errno not in (errno.ENOTCONN, errno.EINVAL): + raise + notconn_pre_handshake_data = b'' + self.setblocking(blocking) + if notconn_pre_handshake_data: + # This prevents pending data sent to the socket before it was + # closed from escaping to the caller who could otherwise + # presume it came through a successful TLS connection. + reason = "Closed before TLS handshake with data in recv buffer." + notconn_pre_handshake_data_error = SSLError(e.errno, reason) + # Add the SSLError attributes that _ssl.c always adds. + notconn_pre_handshake_data_error.reason = reason + notconn_pre_handshake_data_error.library = None + try: + raise notconn_pre_handshake_data_error + finally: + # Explicitly break the reference cycle. + notconn_pre_handshake_data_error = None + else: + connected = True + + self.settimeout(sock_timeout) # Must come after setblocking() calls. + self._connected = connected + if connected: + # create the SSL object + self._sslobj = self._context._wrap_socket( + self, server_side, self.server_hostname, + owner=self, session=self._session, + ) + if do_handshake_on_connect: + timeout = self.gettimeout() + if timeout == 0.0: + # non-blocking + raise ValueError("do_handshake_on_connect should not be specified for non-blocking sockets") + self.do_handshake() + except: + try: + self.close() + except OSError: + pass + raise + return self + + @property + @_sslcopydoc + def context(self): + return self._context + + @context.setter + def context(self, ctx): + self._context = ctx + self._sslobj.context = ctx + + @property + @_sslcopydoc + def session(self): + if self._sslobj is not None: + return self._sslobj.session + + @session.setter + def session(self, session): + self._session = session + if self._sslobj is not None: + self._sslobj.session = session + + @property + @_sslcopydoc + def session_reused(self): + if self._sslobj is not None: + return self._sslobj.session_reused + + def dup(self): + raise NotImplementedError("Can't dup() %s instances" % + self.__class__.__name__) + + def _checkClosed(self, msg=None): + # raise an exception here if you wish to check for spurious closes + pass + + def _check_connected(self): + if not self._connected: + # getpeername() will raise ENOTCONN if the socket is really + # not connected; note that we can be connected even without + # _connected being set, e.g. if connect() first returned + # EAGAIN. + self.getpeername() + + def read(self, len=1024, buffer=None): + """Read up to LEN bytes and return them. + Return zero-length string on EOF.""" + + self._checkClosed() + if self._sslobj is None: + raise ValueError("Read on closed or unwrapped SSL socket.") + try: + if buffer is not None: + return self._sslobj.read(len, buffer) + else: + return self._sslobj.read(len) + except SSLError as x: + if x.args[0] == SSL_ERROR_EOF and self.suppress_ragged_eofs: + if buffer is not None: + return 0 + else: + return b'' + else: + raise + + def write(self, data): + """Write DATA to the underlying SSL channel. Returns + number of bytes of DATA actually transmitted.""" + + self._checkClosed() + if self._sslobj is None: + raise ValueError("Write on closed or unwrapped SSL socket.") + return self._sslobj.write(data) + + @_sslcopydoc + def getpeercert(self, binary_form=False): + self._checkClosed() + self._check_connected() + return self._sslobj.getpeercert(binary_form) + + @_sslcopydoc + def selected_npn_protocol(self): + self._checkClosed() + warnings.warn( + "ssl NPN is deprecated, use ALPN instead", + DeprecationWarning, + stacklevel=2 + ) + return None + + @_sslcopydoc + def selected_alpn_protocol(self): + self._checkClosed() + if self._sslobj is None or not _ssl.HAS_ALPN: + return None + else: + return self._sslobj.selected_alpn_protocol() + + @_sslcopydoc + def cipher(self): + self._checkClosed() + if self._sslobj is None: + return None + else: + return self._sslobj.cipher() + + @_sslcopydoc + def shared_ciphers(self): + self._checkClosed() + if self._sslobj is None: + return None + else: + return self._sslobj.shared_ciphers() + + @_sslcopydoc + def compression(self): + self._checkClosed() + if self._sslobj is None: + return None + else: + return self._sslobj.compression() + + def send(self, data, flags=0): + self._checkClosed() + if self._sslobj is not None: + if flags != 0: + raise ValueError( + "non-zero flags not allowed in calls to send() on %s" % + self.__class__) + return self._sslobj.write(data) + else: + return super().send(data, flags) + + def sendto(self, data, flags_or_addr, addr=None): + self._checkClosed() + if self._sslobj is not None: + raise ValueError("sendto not allowed on instances of %s" % + self.__class__) + elif addr is None: + return super().sendto(data, flags_or_addr) + else: + return super().sendto(data, flags_or_addr, addr) + + def sendmsg(self, *args, **kwargs): + # Ensure programs don't send data unencrypted if they try to + # use this method. + raise NotImplementedError("sendmsg not allowed on instances of %s" % + self.__class__) + + def sendall(self, data, flags=0): + self._checkClosed() + if self._sslobj is not None: + if flags != 0: + raise ValueError( + "non-zero flags not allowed in calls to sendall() on %s" % + self.__class__) + count = 0 + with memoryview(data) as view, view.cast("B") as byte_view: + amount = len(byte_view) + while count < amount: + v = self.send(byte_view[count:]) + count += v + else: + return super().sendall(data, flags) + + def sendfile(self, file, offset=0, count=None): + """Send a file, possibly by using os.sendfile() if this is a + clear-text socket. Return the total number of bytes sent. + """ + if self._sslobj is not None: + return self._sendfile_use_send(file, offset, count) + else: + # os.sendfile() works with plain sockets only + return super().sendfile(file, offset, count) + + def recv(self, buflen=1024, flags=0): + self._checkClosed() + if self._sslobj is not None: + if flags != 0: + raise ValueError( + "non-zero flags not allowed in calls to recv() on %s" % + self.__class__) + return self.read(buflen) + else: + return super().recv(buflen, flags) + + def recv_into(self, buffer, nbytes=None, flags=0): + self._checkClosed() + if nbytes is None: + if buffer is not None: + with memoryview(buffer) as view: + nbytes = view.nbytes + if not nbytes: + nbytes = 1024 + else: + nbytes = 1024 + if self._sslobj is not None: + if flags != 0: + raise ValueError( + "non-zero flags not allowed in calls to recv_into() on %s" % + self.__class__) + return self.read(nbytes, buffer) + else: + return super().recv_into(buffer, nbytes, flags) + + def recvfrom(self, buflen=1024, flags=0): + self._checkClosed() + if self._sslobj is not None: + raise ValueError("recvfrom not allowed on instances of %s" % + self.__class__) + else: + return super().recvfrom(buflen, flags) + + def recvfrom_into(self, buffer, nbytes=None, flags=0): + self._checkClosed() + if self._sslobj is not None: + raise ValueError("recvfrom_into not allowed on instances of %s" % + self.__class__) + else: + return super().recvfrom_into(buffer, nbytes, flags) + + def recvmsg(self, *args, **kwargs): + raise NotImplementedError("recvmsg not allowed on instances of %s" % + self.__class__) + + def recvmsg_into(self, *args, **kwargs): + raise NotImplementedError("recvmsg_into not allowed on instances of " + "%s" % self.__class__) + + @_sslcopydoc + def pending(self): + self._checkClosed() + if self._sslobj is not None: + return self._sslobj.pending() + else: + return 0 + + def shutdown(self, how): + self._checkClosed() + self._sslobj = None + super().shutdown(how) + + @_sslcopydoc + def unwrap(self): + if self._sslobj: + s = self._sslobj.shutdown() + self._sslobj = None + return s + else: + raise ValueError("No SSL wrapper around " + str(self)) + + @_sslcopydoc + def verify_client_post_handshake(self): + if self._sslobj: + return self._sslobj.verify_client_post_handshake() + else: + raise ValueError("No SSL wrapper around " + str(self)) + + def _real_close(self): + self._sslobj = None + super()._real_close() + + @_sslcopydoc + def do_handshake(self, block=False): + self._check_connected() + timeout = self.gettimeout() + try: + if timeout == 0.0 and block: + self.settimeout(None) + self._sslobj.do_handshake() + finally: + self.settimeout(timeout) + + def _real_connect(self, addr, connect_ex): + if self.server_side: + raise ValueError("can't connect in server-side mode") + # Here we assume that the socket is client-side, and not + # connected at the time of the call. We connect it, then wrap it. + if self._connected or self._sslobj is not None: + raise ValueError("attempt to connect already-connected SSLSocket!") + self._sslobj = self.context._wrap_socket( + self, False, self.server_hostname, + owner=self, session=self._session + ) + try: + if connect_ex: + rc = super().connect_ex(addr) + else: + rc = None + super().connect(addr) + if not rc: + self._connected = True + if self.do_handshake_on_connect: + self.do_handshake() + return rc + except (OSError, ValueError): + self._sslobj = None + raise + + def connect(self, addr): + """Connects to remote ADDR, and then wraps the connection in + an SSL channel.""" + self._real_connect(addr, False) + + def connect_ex(self, addr): + """Connects to remote ADDR, and then wraps the connection in + an SSL channel.""" + return self._real_connect(addr, True) + + def accept(self): + """Accepts a new connection from a remote client, and returns + a tuple containing that new connection wrapped with a server-side + SSL channel, and the address of the remote client.""" + + newsock, addr = super().accept() + newsock = self.context.wrap_socket(newsock, + do_handshake_on_connect=self.do_handshake_on_connect, + suppress_ragged_eofs=self.suppress_ragged_eofs, + server_side=True) + return newsock, addr + + @_sslcopydoc + def get_channel_binding(self, cb_type="tls-unique"): + if self._sslobj is not None: + return self._sslobj.get_channel_binding(cb_type) + else: + if cb_type not in CHANNEL_BINDING_TYPES: + raise ValueError( + "{0} channel binding type not implemented".format(cb_type) + ) + return None + + @_sslcopydoc + def version(self): + if self._sslobj is not None: + return self._sslobj.version() + else: + return None + + +# Python does not support forward declaration of types. +SSLContext.sslsocket_class = SSLSocket +SSLContext.sslobject_class = SSLObject + + +def wrap_socket(sock, keyfile=None, certfile=None, + server_side=False, cert_reqs=CERT_NONE, + ssl_version=PROTOCOL_TLS, ca_certs=None, + do_handshake_on_connect=True, + suppress_ragged_eofs=True, + ciphers=None): + warnings.warn( + "ssl.wrap_socket() is deprecated, use SSLContext.wrap_socket()", + category=DeprecationWarning, + stacklevel=2 + ) + if server_side and not certfile: + raise ValueError("certfile must be specified for server-side " + "operations") + if keyfile and not certfile: + raise ValueError("certfile must be specified") + context = SSLContext(ssl_version) + context.verify_mode = cert_reqs + if ca_certs: + context.load_verify_locations(ca_certs) + if certfile: + context.load_cert_chain(certfile, keyfile) + if ciphers: + context.set_ciphers(ciphers) + return context.wrap_socket( + sock=sock, server_side=server_side, + do_handshake_on_connect=do_handshake_on_connect, + suppress_ragged_eofs=suppress_ragged_eofs + ) + +# some utility functions + +def cert_time_to_seconds(cert_time): + """Return the time in seconds since the Epoch, given the timestring + representing the "notBefore" or "notAfter" date from a certificate + in ``"%b %d %H:%M:%S %Y %Z"`` strptime format (C locale). + + "notBefore" or "notAfter" dates must use UTC (RFC 5280). + + Month is one of: Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec + UTC should be specified as GMT (see ASN1_TIME_print()) + """ + from time import strptime + from calendar import timegm + + months = ( + "Jan","Feb","Mar","Apr","May","Jun", + "Jul","Aug","Sep","Oct","Nov","Dec" + ) + time_format = ' %d %H:%M:%S %Y GMT' # NOTE: no month, fixed GMT + try: + month_number = months.index(cert_time[:3].title()) + 1 + except ValueError: + raise ValueError('time data %r does not match ' + 'format "%%b%s"' % (cert_time, time_format)) + else: + # found valid month + tt = strptime(cert_time[3:], time_format) + # return an integer, the previous mktime()-based implementation + # returned a float (fractional seconds are always zero here). + return timegm((tt[0], month_number) + tt[2:6]) + +PEM_HEADER = "-----BEGIN CERTIFICATE-----" +PEM_FOOTER = "-----END CERTIFICATE-----" + +def DER_cert_to_PEM_cert(der_cert_bytes): + """Takes a certificate in binary DER format and returns the + PEM version of it as a string.""" + + f = str(base64.standard_b64encode(der_cert_bytes), 'ASCII', 'strict') + ss = [PEM_HEADER] + ss += [f[i:i+64] for i in range(0, len(f), 64)] + ss.append(PEM_FOOTER + '\n') + return '\n'.join(ss) + +def PEM_cert_to_DER_cert(pem_cert_string): + """Takes a certificate in ASCII PEM format and returns the + DER-encoded version of it as a byte sequence""" + + if not pem_cert_string.startswith(PEM_HEADER): + raise ValueError("Invalid PEM encoding; must start with %s" + % PEM_HEADER) + if not pem_cert_string.strip().endswith(PEM_FOOTER): + raise ValueError("Invalid PEM encoding; must end with %s" + % PEM_FOOTER) + d = pem_cert_string.strip()[len(PEM_HEADER):-len(PEM_FOOTER)] + return base64.decodebytes(d.encode('ASCII', 'strict')) + +def get_server_certificate(addr, ssl_version=PROTOCOL_TLS_CLIENT, + ca_certs=None, timeout=_GLOBAL_DEFAULT_TIMEOUT): + """Retrieve the certificate from the server at the specified address, + and return it as a PEM-encoded string. + If 'ca_certs' is specified, validate the server cert against it. + If 'ssl_version' is specified, use it in the connection attempt. + If 'timeout' is specified, use it in the connection attempt. + """ + + host, port = addr + if ca_certs is not None: + cert_reqs = CERT_REQUIRED + else: + cert_reqs = CERT_NONE + context = _create_stdlib_context(ssl_version, + cert_reqs=cert_reqs, + cafile=ca_certs) + with create_connection(addr, timeout=timeout) as sock: + with context.wrap_socket(sock, server_hostname=host) as sslsock: + dercert = sslsock.getpeercert(True) + return DER_cert_to_PEM_cert(dercert) + +def get_protocol_name(protocol_code): + return _PROTOCOL_NAMES.get(protocol_code, '') diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/stat.py b/physworld_p1_20261018/envs/p1/lib/python3.11/stat.py new file mode 100644 index 0000000000000000000000000000000000000000..fc024db3f4fbeeb903272363ee2bad19de0e635b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/stat.py @@ -0,0 +1,195 @@ +"""Constants/functions for interpreting results of os.stat() and os.lstat(). + +Suggested usage: from stat import * +""" + +# Indices for stat struct members in the tuple returned by os.stat() + +ST_MODE = 0 +ST_INO = 1 +ST_DEV = 2 +ST_NLINK = 3 +ST_UID = 4 +ST_GID = 5 +ST_SIZE = 6 +ST_ATIME = 7 +ST_MTIME = 8 +ST_CTIME = 9 + +# Extract bits from the mode + +def S_IMODE(mode): + """Return the portion of the file's mode that can be set by + os.chmod(). + """ + return mode & 0o7777 + +def S_IFMT(mode): + """Return the portion of the file's mode that describes the + file type. + """ + return mode & 0o170000 + +# Constants used as S_IFMT() for various file types +# (not all are implemented on all systems) + +S_IFDIR = 0o040000 # directory +S_IFCHR = 0o020000 # character device +S_IFBLK = 0o060000 # block device +S_IFREG = 0o100000 # regular file +S_IFIFO = 0o010000 # fifo (named pipe) +S_IFLNK = 0o120000 # symbolic link +S_IFSOCK = 0o140000 # socket file +# Fallbacks for uncommon platform-specific constants +S_IFDOOR = 0 +S_IFPORT = 0 +S_IFWHT = 0 + +# Functions to test for each file type + +def S_ISDIR(mode): + """Return True if mode is from a directory.""" + return S_IFMT(mode) == S_IFDIR + +def S_ISCHR(mode): + """Return True if mode is from a character special device file.""" + return S_IFMT(mode) == S_IFCHR + +def S_ISBLK(mode): + """Return True if mode is from a block special device file.""" + return S_IFMT(mode) == S_IFBLK + +def S_ISREG(mode): + """Return True if mode is from a regular file.""" + return S_IFMT(mode) == S_IFREG + +def S_ISFIFO(mode): + """Return True if mode is from a FIFO (named pipe).""" + return S_IFMT(mode) == S_IFIFO + +def S_ISLNK(mode): + """Return True if mode is from a symbolic link.""" + return S_IFMT(mode) == S_IFLNK + +def S_ISSOCK(mode): + """Return True if mode is from a socket.""" + return S_IFMT(mode) == S_IFSOCK + +def S_ISDOOR(mode): + """Return True if mode is from a door.""" + return False + +def S_ISPORT(mode): + """Return True if mode is from an event port.""" + return False + +def S_ISWHT(mode): + """Return True if mode is from a whiteout.""" + return False + +# Names for permission bits + +S_ISUID = 0o4000 # set UID bit +S_ISGID = 0o2000 # set GID bit +S_ENFMT = S_ISGID # file locking enforcement +S_ISVTX = 0o1000 # sticky bit +S_IREAD = 0o0400 # Unix V7 synonym for S_IRUSR +S_IWRITE = 0o0200 # Unix V7 synonym for S_IWUSR +S_IEXEC = 0o0100 # Unix V7 synonym for S_IXUSR +S_IRWXU = 0o0700 # mask for owner permissions +S_IRUSR = 0o0400 # read by owner +S_IWUSR = 0o0200 # write by owner +S_IXUSR = 0o0100 # execute by owner +S_IRWXG = 0o0070 # mask for group permissions +S_IRGRP = 0o0040 # read by group +S_IWGRP = 0o0020 # write by group +S_IXGRP = 0o0010 # execute by group +S_IRWXO = 0o0007 # mask for others (not in group) permissions +S_IROTH = 0o0004 # read by others +S_IWOTH = 0o0002 # write by others +S_IXOTH = 0o0001 # execute by others + +# Names for file flags + +UF_NODUMP = 0x00000001 # do not dump file +UF_IMMUTABLE = 0x00000002 # file may not be changed +UF_APPEND = 0x00000004 # file may only be appended to +UF_OPAQUE = 0x00000008 # directory is opaque when viewed through a union stack +UF_NOUNLINK = 0x00000010 # file may not be renamed or deleted +UF_COMPRESSED = 0x00000020 # OS X: file is hfs-compressed +UF_HIDDEN = 0x00008000 # OS X: file should not be displayed +SF_ARCHIVED = 0x00010000 # file may be archived +SF_IMMUTABLE = 0x00020000 # file may not be changed +SF_APPEND = 0x00040000 # file may only be appended to +SF_NOUNLINK = 0x00100000 # file may not be renamed or deleted +SF_SNAPSHOT = 0x00200000 # file is a snapshot file + + +_filemode_table = ( + ((S_IFLNK, "l"), + (S_IFSOCK, "s"), # Must appear before IFREG and IFDIR as IFSOCK == IFREG | IFDIR + (S_IFREG, "-"), + (S_IFBLK, "b"), + (S_IFDIR, "d"), + (S_IFCHR, "c"), + (S_IFIFO, "p")), + + ((S_IRUSR, "r"),), + ((S_IWUSR, "w"),), + ((S_IXUSR|S_ISUID, "s"), + (S_ISUID, "S"), + (S_IXUSR, "x")), + + ((S_IRGRP, "r"),), + ((S_IWGRP, "w"),), + ((S_IXGRP|S_ISGID, "s"), + (S_ISGID, "S"), + (S_IXGRP, "x")), + + ((S_IROTH, "r"),), + ((S_IWOTH, "w"),), + ((S_IXOTH|S_ISVTX, "t"), + (S_ISVTX, "T"), + (S_IXOTH, "x")) +) + +def filemode(mode): + """Convert a file's mode to a string of the form '-rwxrwxrwx'.""" + perm = [] + for table in _filemode_table: + for bit, char in table: + if mode & bit == bit: + perm.append(char) + break + else: + perm.append("-") + return "".join(perm) + + +# Windows FILE_ATTRIBUTE constants for interpreting os.stat()'s +# "st_file_attributes" member + +FILE_ATTRIBUTE_ARCHIVE = 32 +FILE_ATTRIBUTE_COMPRESSED = 2048 +FILE_ATTRIBUTE_DEVICE = 64 +FILE_ATTRIBUTE_DIRECTORY = 16 +FILE_ATTRIBUTE_ENCRYPTED = 16384 +FILE_ATTRIBUTE_HIDDEN = 2 +FILE_ATTRIBUTE_INTEGRITY_STREAM = 32768 +FILE_ATTRIBUTE_NORMAL = 128 +FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = 8192 +FILE_ATTRIBUTE_NO_SCRUB_DATA = 131072 +FILE_ATTRIBUTE_OFFLINE = 4096 +FILE_ATTRIBUTE_READONLY = 1 +FILE_ATTRIBUTE_REPARSE_POINT = 1024 +FILE_ATTRIBUTE_SPARSE_FILE = 512 +FILE_ATTRIBUTE_SYSTEM = 4 +FILE_ATTRIBUTE_TEMPORARY = 256 +FILE_ATTRIBUTE_VIRTUAL = 65536 + + +# If available, use C implementation +try: + from _stat import * +except ImportError: + pass diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/statistics.py b/physworld_p1_20261018/envs/p1/lib/python3.11/statistics.py new file mode 100644 index 0000000000000000000000000000000000000000..3b3b43babb42e2f07d04b95c08d7a743d30dc920 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/statistics.py @@ -0,0 +1,1390 @@ +""" +Basic statistics module. + +This module provides functions for calculating statistics of data, including +averages, variance, and standard deviation. + +Calculating averages +-------------------- + +================== ================================================== +Function Description +================== ================================================== +mean Arithmetic mean (average) of data. +fmean Fast, floating point arithmetic mean. +geometric_mean Geometric mean of data. +harmonic_mean Harmonic mean of data. +median Median (middle value) of data. +median_low Low median of data. +median_high High median of data. +median_grouped Median, or 50th percentile, of grouped data. +mode Mode (most common value) of data. +multimode List of modes (most common values of data). +quantiles Divide data into intervals with equal probability. +================== ================================================== + +Calculate the arithmetic mean ("the average") of data: + +>>> mean([-1.0, 2.5, 3.25, 5.75]) +2.625 + + +Calculate the standard median of discrete data: + +>>> median([2, 3, 4, 5]) +3.5 + + +Calculate the median, or 50th percentile, of data grouped into class intervals +centred on the data values provided. E.g. if your data points are rounded to +the nearest whole number: + +>>> median_grouped([2, 2, 3, 3, 3, 4]) #doctest: +ELLIPSIS +2.8333333333... + +This should be interpreted in this way: you have two data points in the class +interval 1.5-2.5, three data points in the class interval 2.5-3.5, and one in +the class interval 3.5-4.5. The median of these data points is 2.8333... + + +Calculating variability or spread +--------------------------------- + +================== ============================================= +Function Description +================== ============================================= +pvariance Population variance of data. +variance Sample variance of data. +pstdev Population standard deviation of data. +stdev Sample standard deviation of data. +================== ============================================= + +Calculate the standard deviation of sample data: + +>>> stdev([2.5, 3.25, 5.5, 11.25, 11.75]) #doctest: +ELLIPSIS +4.38961843444... + +If you have previously calculated the mean, you can pass it as the optional +second argument to the four "spread" functions to avoid recalculating it: + +>>> data = [1, 2, 2, 4, 4, 4, 5, 6] +>>> mu = mean(data) +>>> pvariance(data, mu) +2.5 + + +Statistics for relations between two inputs +------------------------------------------- + +================== ==================================================== +Function Description +================== ==================================================== +covariance Sample covariance for two variables. +correlation Pearson's correlation coefficient for two variables. +linear_regression Intercept and slope for simple linear regression. +================== ==================================================== + +Calculate covariance, Pearson's correlation, and simple linear regression +for two inputs: + +>>> x = [1, 2, 3, 4, 5, 6, 7, 8, 9] +>>> y = [1, 2, 3, 1, 2, 3, 1, 2, 3] +>>> covariance(x, y) +0.75 +>>> correlation(x, y) #doctest: +ELLIPSIS +0.31622776601... +>>> linear_regression(x, y) #doctest: +LinearRegression(slope=0.1, intercept=1.5) + + +Exceptions +---------- + +A single exception is defined: StatisticsError is a subclass of ValueError. + +""" + +__all__ = [ + 'NormalDist', + 'StatisticsError', + 'correlation', + 'covariance', + 'fmean', + 'geometric_mean', + 'harmonic_mean', + 'linear_regression', + 'mean', + 'median', + 'median_grouped', + 'median_high', + 'median_low', + 'mode', + 'multimode', + 'pstdev', + 'pvariance', + 'quantiles', + 'stdev', + 'variance', +] + +import math +import numbers +import random +import sys + +from fractions import Fraction +from decimal import Decimal +from itertools import groupby, repeat +from bisect import bisect_left, bisect_right +from math import hypot, sqrt, fabs, exp, erf, tau, log, fsum +from functools import reduce +from operator import mul +from collections import Counter, namedtuple, defaultdict + +_SQRT2 = sqrt(2.0) + +# === Exceptions === + +class StatisticsError(ValueError): + pass + + +# === Private utilities === + +def _sum(data): + """_sum(data) -> (type, sum, count) + + Return a high-precision sum of the given numeric data as a fraction, + together with the type to be converted to and the count of items. + + Examples + -------- + + >>> _sum([3, 2.25, 4.5, -0.5, 0.25]) + (, Fraction(19, 2), 5) + + Some sources of round-off error will be avoided: + + # Built-in sum returns zero. + >>> _sum([1e50, 1, -1e50] * 1000) + (, Fraction(1000, 1), 3000) + + Fractions and Decimals are also supported: + + >>> from fractions import Fraction as F + >>> _sum([F(2, 3), F(7, 5), F(1, 4), F(5, 6)]) + (, Fraction(63, 20), 4) + + >>> from decimal import Decimal as D + >>> data = [D("0.1375"), D("0.2108"), D("0.3061"), D("0.0419")] + >>> _sum(data) + (, Fraction(6963, 10000), 4) + + Mixed types are currently treated as an error, except that int is + allowed. + """ + count = 0 + types = set() + types_add = types.add + partials = {} + partials_get = partials.get + for typ, values in groupby(data, type): + types_add(typ) + for n, d in map(_exact_ratio, values): + count += 1 + partials[d] = partials_get(d, 0) + n + if None in partials: + # The sum will be a NAN or INF. We can ignore all the finite + # partials, and just look at this special one. + total = partials[None] + assert not _isfinite(total) + else: + # Sum all the partial sums using builtin sum. + total = sum(Fraction(n, d) for d, n in partials.items()) + T = reduce(_coerce, types, int) # or raise TypeError + return (T, total, count) + + +def _ss(data, c=None): + """Return the exact mean and sum of square deviations of sequence data. + + Calculations are done in a single pass, allowing the input to be an iterator. + + If given *c* is used the mean; otherwise, it is calculated from the data. + Use the *c* argument with care, as it can lead to garbage results. + + """ + if c is not None: + T, ssd, count = _sum((d := x - c) * d for x in data) + return (T, ssd, c, count) + count = 0 + types = set() + types_add = types.add + sx_partials = defaultdict(int) + sxx_partials = defaultdict(int) + for typ, values in groupby(data, type): + types_add(typ) + for n, d in map(_exact_ratio, values): + count += 1 + sx_partials[d] += n + sxx_partials[d] += n * n + if not count: + ssd = c = Fraction(0) + elif None in sx_partials: + # The sum will be a NAN or INF. We can ignore all the finite + # partials, and just look at this special one. + ssd = c = sx_partials[None] + assert not _isfinite(ssd) + else: + sx = sum(Fraction(n, d) for d, n in sx_partials.items()) + sxx = sum(Fraction(n, d*d) for d, n in sxx_partials.items()) + # This formula has poor numeric properties for floats, + # but with fractions it is exact. + ssd = (count * sxx - sx * sx) / count + c = sx / count + T = reduce(_coerce, types, int) # or raise TypeError + return (T, ssd, c, count) + + +def _isfinite(x): + try: + return x.is_finite() # Likely a Decimal. + except AttributeError: + return math.isfinite(x) # Coerces to float first. + + +def _coerce(T, S): + """Coerce types T and S to a common type, or raise TypeError. + + Coercion rules are currently an implementation detail. See the CoerceTest + test class in test_statistics for details. + """ + # See http://bugs.python.org/issue24068. + assert T is not bool, "initial type T is bool" + # If the types are the same, no need to coerce anything. Put this + # first, so that the usual case (no coercion needed) happens as soon + # as possible. + if T is S: return T + # Mixed int & other coerce to the other type. + if S is int or S is bool: return T + if T is int: return S + # If one is a (strict) subclass of the other, coerce to the subclass. + if issubclass(S, T): return S + if issubclass(T, S): return T + # Ints coerce to the other type. + if issubclass(T, int): return S + if issubclass(S, int): return T + # Mixed fraction & float coerces to float (or float subclass). + if issubclass(T, Fraction) and issubclass(S, float): + return S + if issubclass(T, float) and issubclass(S, Fraction): + return T + # Any other combination is disallowed. + msg = "don't know how to coerce %s and %s" + raise TypeError(msg % (T.__name__, S.__name__)) + + +def _exact_ratio(x): + """Return Real number x to exact (numerator, denominator) pair. + + >>> _exact_ratio(0.25) + (1, 4) + + x is expected to be an int, Fraction, Decimal or float. + """ + + # XXX We should revisit whether using fractions to accumulate exact + # ratios is the right way to go. + + # The integer ratios for binary floats can have numerators or + # denominators with over 300 decimal digits. The problem is more + # acute with decimal floats where the default decimal context + # supports a huge range of exponents from Emin=-999999 to + # Emax=999999. When expanded with as_integer_ratio(), numbers like + # Decimal('3.14E+5000') and Decimal('3.14E-5000') have large + # numerators or denominators that will slow computation. + + # When the integer ratios are accumulated as fractions, the size + # grows to cover the full range from the smallest magnitude to the + # largest. For example, Fraction(3.14E+300) + Fraction(3.14E-300), + # has a 616 digit numerator. Likewise, + # Fraction(Decimal('3.14E+5000')) + Fraction(Decimal('3.14E-5000')) + # has 10,003 digit numerator. + + # This doesn't seem to have been problem in practice, but it is a + # potential pitfall. + + try: + return x.as_integer_ratio() + except AttributeError: + pass + except (OverflowError, ValueError): + # float NAN or INF. + assert not _isfinite(x) + return (x, None) + try: + # x may be an Integral ABC. + return (x.numerator, x.denominator) + except AttributeError: + msg = f"can't convert type '{type(x).__name__}' to numerator/denominator" + raise TypeError(msg) + + +def _convert(value, T): + """Convert value to given numeric type T.""" + if type(value) is T: + # This covers the cases where T is Fraction, or where value is + # a NAN or INF (Decimal or float). + return value + if issubclass(T, int) and value.denominator != 1: + T = float + try: + # FIXME: what do we do if this overflows? + return T(value) + except TypeError: + if issubclass(T, Decimal): + return T(value.numerator) / T(value.denominator) + else: + raise + + +def _fail_neg(values, errmsg='negative value'): + """Iterate over values, failing if any are less than zero.""" + for x in values: + if x < 0: + raise StatisticsError(errmsg) + yield x + + +def _integer_sqrt_of_frac_rto(n: int, m: int) -> int: + """Square root of n/m, rounded to the nearest integer using round-to-odd.""" + # Reference: https://www.lri.fr/~melquion/doc/05-imacs17_1-expose.pdf + a = math.isqrt(n // m) + return a | (a*a*m != n) + + +# For 53 bit precision floats, the bit width used in +# _float_sqrt_of_frac() is 109. +_sqrt_bit_width: int = 2 * sys.float_info.mant_dig + 3 + + +def _float_sqrt_of_frac(n: int, m: int) -> float: + """Square root of n/m as a float, correctly rounded.""" + # See principle and proof sketch at: https://bugs.python.org/msg407078 + q = (n.bit_length() - m.bit_length() - _sqrt_bit_width) // 2 + if q >= 0: + numerator = _integer_sqrt_of_frac_rto(n, m << 2 * q) << q + denominator = 1 + else: + numerator = _integer_sqrt_of_frac_rto(n << -2 * q, m) + denominator = 1 << -q + return numerator / denominator # Convert to float + + +def _decimal_sqrt_of_frac(n: int, m: int) -> Decimal: + """Square root of n/m as a Decimal, correctly rounded.""" + # Premise: For decimal, computing (n/m).sqrt() can be off + # by 1 ulp from the correctly rounded result. + # Method: Check the result, moving up or down a step if needed. + if n <= 0: + if not n: + return Decimal('0.0') + n, m = -n, -m + + root = (Decimal(n) / Decimal(m)).sqrt() + nr, dr = root.as_integer_ratio() + + plus = root.next_plus() + np, dp = plus.as_integer_ratio() + # test: n / m > ((root + plus) / 2) ** 2 + if 4 * n * (dr*dp)**2 > m * (dr*np + dp*nr)**2: + return plus + + minus = root.next_minus() + nm, dm = minus.as_integer_ratio() + # test: n / m < ((root + minus) / 2) ** 2 + if 4 * n * (dr*dm)**2 < m * (dr*nm + dm*nr)**2: + return minus + + return root + + +# === Measures of central tendency (averages) === + +def mean(data): + """Return the sample arithmetic mean of data. + + >>> mean([1, 2, 3, 4, 4]) + 2.8 + + >>> from fractions import Fraction as F + >>> mean([F(3, 7), F(1, 21), F(5, 3), F(1, 3)]) + Fraction(13, 21) + + >>> from decimal import Decimal as D + >>> mean([D("0.5"), D("0.75"), D("0.625"), D("0.375")]) + Decimal('0.5625') + + If ``data`` is empty, StatisticsError will be raised. + """ + T, total, n = _sum(data) + if n < 1: + raise StatisticsError('mean requires at least one data point') + return _convert(total / n, T) + + +def fmean(data, weights=None): + """Convert data to floats and compute the arithmetic mean. + + This runs faster than the mean() function and it always returns a float. + If the input dataset is empty, it raises a StatisticsError. + + >>> fmean([3.5, 4.0, 5.25]) + 4.25 + """ + try: + n = len(data) + except TypeError: + # Handle iterators that do not define __len__(). + n = 0 + def count(iterable): + nonlocal n + for n, x in enumerate(iterable, start=1): + yield x + data = count(data) + if weights is None: + total = fsum(data) + if not n: + raise StatisticsError('fmean requires at least one data point') + return total / n + try: + num_weights = len(weights) + except TypeError: + weights = list(weights) + num_weights = len(weights) + num = fsum(map(mul, data, weights)) + if n != num_weights: + raise StatisticsError('data and weights must be the same length') + den = fsum(weights) + if not den: + raise StatisticsError('sum of weights must be non-zero') + return num / den + + +def geometric_mean(data): + """Convert data to floats and compute the geometric mean. + + Raises a StatisticsError if the input dataset is empty, + if it contains a zero, or if it contains a negative value. + + No special efforts are made to achieve exact results. + (However, this may change in the future.) + + >>> round(geometric_mean([54, 24, 36]), 9) + 36.0 + """ + try: + return exp(fmean(map(log, data))) + except ValueError: + raise StatisticsError('geometric mean requires a non-empty dataset ' + 'containing positive numbers') from None + + +def harmonic_mean(data, weights=None): + """Return the harmonic mean of data. + + The harmonic mean is the reciprocal of the arithmetic mean of the + reciprocals of the data. It can be used for averaging ratios or + rates, for example speeds. + + Suppose a car travels 40 km/hr for 5 km and then speeds-up to + 60 km/hr for another 5 km. What is the average speed? + + >>> harmonic_mean([40, 60]) + 48.0 + + Suppose a car travels 40 km/hr for 5 km, and when traffic clears, + speeds-up to 60 km/hr for the remaining 30 km of the journey. What + is the average speed? + + >>> harmonic_mean([40, 60], weights=[5, 30]) + 56.0 + + If ``data`` is empty, or any element is less than zero, + ``harmonic_mean`` will raise ``StatisticsError``. + """ + if iter(data) is data: + data = list(data) + errmsg = 'harmonic mean does not support negative values' + n = len(data) + if n < 1: + raise StatisticsError('harmonic_mean requires at least one data point') + elif n == 1 and weights is None: + x = data[0] + if isinstance(x, (numbers.Real, Decimal)): + if x < 0: + raise StatisticsError(errmsg) + return x + else: + raise TypeError('unsupported type') + if weights is None: + weights = repeat(1, n) + sum_weights = n + else: + if iter(weights) is weights: + weights = list(weights) + if len(weights) != n: + raise StatisticsError('Number of weights does not match data size') + _, sum_weights, _ = _sum(w for w in _fail_neg(weights, errmsg)) + try: + data = _fail_neg(data, errmsg) + T, total, count = _sum(w / x if w else 0 for w, x in zip(weights, data)) + except ZeroDivisionError: + return 0 + if total <= 0: + raise StatisticsError('Weighted sum must be positive') + return _convert(sum_weights / total, T) + +# FIXME: investigate ways to calculate medians without sorting? Quickselect? +def median(data): + """Return the median (middle value) of numeric data. + + When the number of data points is odd, return the middle data point. + When the number of data points is even, the median is interpolated by + taking the average of the two middle values: + + >>> median([1, 3, 5]) + 3 + >>> median([1, 3, 5, 7]) + 4.0 + + """ + data = sorted(data) + n = len(data) + if n == 0: + raise StatisticsError("no median for empty data") + if n % 2 == 1: + return data[n // 2] + else: + i = n // 2 + return (data[i - 1] + data[i]) / 2 + + +def median_low(data): + """Return the low median of numeric data. + + When the number of data points is odd, the middle value is returned. + When it is even, the smaller of the two middle values is returned. + + >>> median_low([1, 3, 5]) + 3 + >>> median_low([1, 3, 5, 7]) + 3 + + """ + data = sorted(data) + n = len(data) + if n == 0: + raise StatisticsError("no median for empty data") + if n % 2 == 1: + return data[n // 2] + else: + return data[n // 2 - 1] + + +def median_high(data): + """Return the high median of data. + + When the number of data points is odd, the middle value is returned. + When it is even, the larger of the two middle values is returned. + + >>> median_high([1, 3, 5]) + 3 + >>> median_high([1, 3, 5, 7]) + 5 + + """ + data = sorted(data) + n = len(data) + if n == 0: + raise StatisticsError("no median for empty data") + return data[n // 2] + + +def median_grouped(data, interval=1.0): + """Estimates the median for numeric data binned around the midpoints + of consecutive, fixed-width intervals. + + The *data* can be any iterable of numeric data with each value being + exactly the midpoint of a bin. At least one value must be present. + + The *interval* is width of each bin. + + For example, demographic information may have been summarized into + consecutive ten-year age groups with each group being represented + by the 5-year midpoints of the intervals: + + >>> demographics = Counter({ + ... 25: 172, # 20 to 30 years old + ... 35: 484, # 30 to 40 years old + ... 45: 387, # 40 to 50 years old + ... 55: 22, # 50 to 60 years old + ... 65: 6, # 60 to 70 years old + ... }) + + The 50th percentile (median) is the 536th person out of the 1071 + member cohort. That person is in the 30 to 40 year old age group. + + The regular median() function would assume that everyone in the + tricenarian age group was exactly 35 years old. A more tenable + assumption is that the 484 members of that age group are evenly + distributed between 30 and 40. For that, we use median_grouped(). + + >>> data = list(demographics.elements()) + >>> median(data) + 35 + >>> round(median_grouped(data, interval=10), 1) + 37.5 + + The caller is responsible for making sure the data points are separated + by exact multiples of *interval*. This is essential for getting a + correct result. The function does not check this precondition. + + Inputs may be any numeric type that can be coerced to a float during + the interpolation step. + + """ + data = sorted(data) + n = len(data) + if not n: + raise StatisticsError("no median for empty data") + + # Find the value at the midpoint. Remember this corresponds to the + # midpoint of the class interval. + x = data[n // 2] + + # Using O(log n) bisection, find where all the x values occur in the data. + # All x will lie within data[i:j]. + i = bisect_left(data, x) + j = bisect_right(data, x, lo=i) + + # Coerce to floats, raising a TypeError if not possible + try: + interval = float(interval) + x = float(x) + except ValueError: + raise TypeError(f'Value cannot be converted to a float') + + # Interpolate the median using the formula found at: + # https://www.cuemath.com/data/median-of-grouped-data/ + L = x - interval / 2.0 # Lower limit of the median interval + cf = i # Cumulative frequency of the preceding interval + f = j - i # Number of elements in the median internal + return L + interval * (n / 2 - cf) / f + + +def mode(data): + """Return the most common data point from discrete or nominal data. + + ``mode`` assumes discrete data, and returns a single value. This is the + standard treatment of the mode as commonly taught in schools: + + >>> mode([1, 1, 2, 3, 3, 3, 3, 4]) + 3 + + This also works with nominal (non-numeric) data: + + >>> mode(["red", "blue", "blue", "red", "green", "red", "red"]) + 'red' + + If there are multiple modes with same frequency, return the first one + encountered: + + >>> mode(['red', 'red', 'green', 'blue', 'blue']) + 'red' + + If *data* is empty, ``mode``, raises StatisticsError. + + """ + pairs = Counter(iter(data)).most_common(1) + try: + return pairs[0][0] + except IndexError: + raise StatisticsError('no mode for empty data') from None + + +def multimode(data): + """Return a list of the most frequently occurring values. + + Will return more than one result if there are multiple modes + or an empty list if *data* is empty. + + >>> multimode('aabbbbbbbbcc') + ['b'] + >>> multimode('aabbbbccddddeeffffgg') + ['b', 'd', 'f'] + >>> multimode('') + [] + """ + counts = Counter(iter(data)) + if not counts: + return [] + maxcount = max(counts.values()) + return [value for value, count in counts.items() if count == maxcount] + + +# Notes on methods for computing quantiles +# ---------------------------------------- +# +# There is no one perfect way to compute quantiles. Here we offer +# two methods that serve common needs. Most other packages +# surveyed offered at least one or both of these two, making them +# "standard" in the sense of "widely-adopted and reproducible". +# They are also easy to explain, easy to compute manually, and have +# straight-forward interpretations that aren't surprising. + +# The default method is known as "R6", "PERCENTILE.EXC", or "expected +# value of rank order statistics". The alternative method is known as +# "R7", "PERCENTILE.INC", or "mode of rank order statistics". + +# For sample data where there is a positive probability for values +# beyond the range of the data, the R6 exclusive method is a +# reasonable choice. Consider a random sample of nine values from a +# population with a uniform distribution from 0.0 to 1.0. The +# distribution of the third ranked sample point is described by +# betavariate(alpha=3, beta=7) which has mode=0.250, median=0.286, and +# mean=0.300. Only the latter (which corresponds with R6) gives the +# desired cut point with 30% of the population falling below that +# value, making it comparable to a result from an inv_cdf() function. +# The R6 exclusive method is also idempotent. + +# For describing population data where the end points are known to +# be included in the data, the R7 inclusive method is a reasonable +# choice. Instead of the mean, it uses the mode of the beta +# distribution for the interior points. Per Hyndman & Fan, "One nice +# property is that the vertices of Q7(p) divide the range into n - 1 +# intervals, and exactly 100p% of the intervals lie to the left of +# Q7(p) and 100(1 - p)% of the intervals lie to the right of Q7(p)." + +# If needed, other methods could be added. However, for now, the +# position is that fewer options make for easier choices and that +# external packages can be used for anything more advanced. + +def quantiles(data, *, n=4, method='exclusive'): + """Divide *data* into *n* continuous intervals with equal probability. + + Returns a list of (n - 1) cut points separating the intervals. + + Set *n* to 4 for quartiles (the default). Set *n* to 10 for deciles. + Set *n* to 100 for percentiles which gives the 99 cuts points that + separate *data* in to 100 equal sized groups. + + The *data* can be any iterable containing sample. + The cut points are linearly interpolated between data points. + + If *method* is set to *inclusive*, *data* is treated as population + data. The minimum value is treated as the 0th percentile and the + maximum value is treated as the 100th percentile. + """ + if n < 1: + raise StatisticsError('n must be at least 1') + data = sorted(data) + ld = len(data) + if ld < 2: + raise StatisticsError('must have at least two data points') + if method == 'inclusive': + m = ld - 1 + result = [] + for i in range(1, n): + j, delta = divmod(i * m, n) + interpolated = (data[j] * (n - delta) + data[j + 1] * delta) / n + result.append(interpolated) + return result + if method == 'exclusive': + m = ld + 1 + result = [] + for i in range(1, n): + j = i * m // n # rescale i to m/n + j = 1 if j < 1 else ld-1 if j > ld-1 else j # clamp to 1 .. ld-1 + delta = i*m - j*n # exact integer math + interpolated = (data[j - 1] * (n - delta) + data[j] * delta) / n + result.append(interpolated) + return result + raise ValueError(f'Unknown method: {method!r}') + + +# === Measures of spread === + +# See http://mathworld.wolfram.com/Variance.html +# http://mathworld.wolfram.com/SampleVariance.html + + +def variance(data, xbar=None): + """Return the sample variance of data. + + data should be an iterable of Real-valued numbers, with at least two + values. The optional argument xbar, if given, should be the mean of + the data. If it is missing or None, the mean is automatically calculated. + + Use this function when your data is a sample from a population. To + calculate the variance from the entire population, see ``pvariance``. + + Examples: + + >>> data = [2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5] + >>> variance(data) + 1.3720238095238095 + + If you have already calculated the mean of your data, you can pass it as + the optional second argument ``xbar`` to avoid recalculating it: + + >>> m = mean(data) + >>> variance(data, m) + 1.3720238095238095 + + This function does not check that ``xbar`` is actually the mean of + ``data``. Giving arbitrary values for ``xbar`` may lead to invalid or + impossible results. + + Decimals and Fractions are supported: + + >>> from decimal import Decimal as D + >>> variance([D("27.5"), D("30.25"), D("30.25"), D("34.5"), D("41.75")]) + Decimal('31.01875') + + >>> from fractions import Fraction as F + >>> variance([F(1, 6), F(1, 2), F(5, 3)]) + Fraction(67, 108) + + """ + T, ss, c, n = _ss(data, xbar) + if n < 2: + raise StatisticsError('variance requires at least two data points') + return _convert(ss / (n - 1), T) + + +def pvariance(data, mu=None): + """Return the population variance of ``data``. + + data should be a sequence or iterable of Real-valued numbers, with at least one + value. The optional argument mu, if given, should be the mean of + the data. If it is missing or None, the mean is automatically calculated. + + Use this function to calculate the variance from the entire population. + To estimate the variance from a sample, the ``variance`` function is + usually a better choice. + + Examples: + + >>> data = [0.0, 0.25, 0.25, 1.25, 1.5, 1.75, 2.75, 3.25] + >>> pvariance(data) + 1.25 + + If you have already calculated the mean of the data, you can pass it as + the optional second argument to avoid recalculating it: + + >>> mu = mean(data) + >>> pvariance(data, mu) + 1.25 + + Decimals and Fractions are supported: + + >>> from decimal import Decimal as D + >>> pvariance([D("27.5"), D("30.25"), D("30.25"), D("34.5"), D("41.75")]) + Decimal('24.815') + + >>> from fractions import Fraction as F + >>> pvariance([F(1, 4), F(5, 4), F(1, 2)]) + Fraction(13, 72) + + """ + T, ss, c, n = _ss(data, mu) + if n < 1: + raise StatisticsError('pvariance requires at least one data point') + return _convert(ss / n, T) + + +def stdev(data, xbar=None): + """Return the square root of the sample variance. + + See ``variance`` for arguments and other details. + + >>> stdev([1.5, 2.5, 2.5, 2.75, 3.25, 4.75]) + 1.0810874155219827 + + """ + T, ss, c, n = _ss(data, xbar) + if n < 2: + raise StatisticsError('stdev requires at least two data points') + mss = ss / (n - 1) + if issubclass(T, Decimal): + return _decimal_sqrt_of_frac(mss.numerator, mss.denominator) + return _float_sqrt_of_frac(mss.numerator, mss.denominator) + + +def pstdev(data, mu=None): + """Return the square root of the population variance. + + See ``pvariance`` for arguments and other details. + + >>> pstdev([1.5, 2.5, 2.5, 2.75, 3.25, 4.75]) + 0.986893273527251 + + """ + T, ss, c, n = _ss(data, mu) + if n < 1: + raise StatisticsError('pstdev requires at least one data point') + mss = ss / n + if issubclass(T, Decimal): + return _decimal_sqrt_of_frac(mss.numerator, mss.denominator) + return _float_sqrt_of_frac(mss.numerator, mss.denominator) + + +def _mean_stdev(data): + """In one pass, compute the mean and sample standard deviation as floats.""" + T, ss, xbar, n = _ss(data) + if n < 2: + raise StatisticsError('stdev requires at least two data points') + mss = ss / (n - 1) + try: + return float(xbar), _float_sqrt_of_frac(mss.numerator, mss.denominator) + except AttributeError: + # Handle Nans and Infs gracefully + return float(xbar), float(xbar) / float(ss) + + +# === Statistics for relations between two inputs === + +# See https://en.wikipedia.org/wiki/Covariance +# https://en.wikipedia.org/wiki/Pearson_correlation_coefficient +# https://en.wikipedia.org/wiki/Simple_linear_regression + + +def covariance(x, y, /): + """Covariance + + Return the sample covariance of two inputs *x* and *y*. Covariance + is a measure of the joint variability of two inputs. + + >>> x = [1, 2, 3, 4, 5, 6, 7, 8, 9] + >>> y = [1, 2, 3, 1, 2, 3, 1, 2, 3] + >>> covariance(x, y) + 0.75 + >>> z = [9, 8, 7, 6, 5, 4, 3, 2, 1] + >>> covariance(x, z) + -7.5 + >>> covariance(z, x) + -7.5 + + """ + n = len(x) + if len(y) != n: + raise StatisticsError('covariance requires that both inputs have same number of data points') + if n < 2: + raise StatisticsError('covariance requires at least two data points') + xbar = fsum(x) / n + ybar = fsum(y) / n + sxy = fsum((xi - xbar) * (yi - ybar) for xi, yi in zip(x, y)) + return sxy / (n - 1) + + +def correlation(x, y, /): + """Pearson's correlation coefficient + + Return the Pearson's correlation coefficient for two inputs. Pearson's + correlation coefficient *r* takes values between -1 and +1. It measures the + strength and direction of the linear relationship, where +1 means very + strong, positive linear relationship, -1 very strong, negative linear + relationship, and 0 no linear relationship. + + >>> x = [1, 2, 3, 4, 5, 6, 7, 8, 9] + >>> y = [9, 8, 7, 6, 5, 4, 3, 2, 1] + >>> correlation(x, x) + 1.0 + >>> correlation(x, y) + -1.0 + + """ + n = len(x) + if len(y) != n: + raise StatisticsError('correlation requires that both inputs have same number of data points') + if n < 2: + raise StatisticsError('correlation requires at least two data points') + xbar = fsum(x) / n + ybar = fsum(y) / n + sxy = fsum((xi - xbar) * (yi - ybar) for xi, yi in zip(x, y)) + sxx = fsum((d := xi - xbar) * d for xi in x) + syy = fsum((d := yi - ybar) * d for yi in y) + try: + return sxy / sqrt(sxx * syy) + except ZeroDivisionError: + raise StatisticsError('at least one of the inputs is constant') + + +LinearRegression = namedtuple('LinearRegression', ('slope', 'intercept')) + + +def linear_regression(x, y, /, *, proportional=False): + """Slope and intercept for simple linear regression. + + Return the slope and intercept of simple linear regression + parameters estimated using ordinary least squares. Simple linear + regression describes relationship between an independent variable + *x* and a dependent variable *y* in terms of a linear function: + + y = slope * x + intercept + noise + + where *slope* and *intercept* are the regression parameters that are + estimated, and noise represents the variability of the data that was + not explained by the linear regression (it is equal to the + difference between predicted and actual values of the dependent + variable). + + The parameters are returned as a named tuple. + + >>> x = [1, 2, 3, 4, 5] + >>> noise = NormalDist().samples(5, seed=42) + >>> y = [3 * x[i] + 2 + noise[i] for i in range(5)] + >>> linear_regression(x, y) #doctest: +ELLIPSIS + LinearRegression(slope=3.09078914170..., intercept=1.75684970486...) + + If *proportional* is true, the independent variable *x* and the + dependent variable *y* are assumed to be directly proportional. + The data is fit to a line passing through the origin. + + Since the *intercept* will always be 0.0, the underlying linear + function simplifies to: + + y = slope * x + noise + + >>> y = [3 * x[i] + noise[i] for i in range(5)] + >>> linear_regression(x, y, proportional=True) #doctest: +ELLIPSIS + LinearRegression(slope=3.02447542484..., intercept=0.0) + + """ + n = len(x) + if len(y) != n: + raise StatisticsError('linear regression requires that both inputs have same number of data points') + if n < 2: + raise StatisticsError('linear regression requires at least two data points') + if proportional: + sxy = fsum(xi * yi for xi, yi in zip(x, y)) + sxx = fsum(xi * xi for xi in x) + else: + xbar = fsum(x) / n + ybar = fsum(y) / n + sxy = fsum((xi - xbar) * (yi - ybar) for xi, yi in zip(x, y)) + sxx = fsum((d := xi - xbar) * d for xi in x) + try: + slope = sxy / sxx # equivalent to: covariance(x, y) / variance(x) + except ZeroDivisionError: + raise StatisticsError('x is constant') + intercept = 0.0 if proportional else ybar - slope * xbar + return LinearRegression(slope=slope, intercept=intercept) + + +## Normal Distribution ##################################################### + + +def _normal_dist_inv_cdf(p, mu, sigma): + # There is no closed-form solution to the inverse CDF for the normal + # distribution, so we use a rational approximation instead: + # Wichura, M.J. (1988). "Algorithm AS241: The Percentage Points of the + # Normal Distribution". Applied Statistics. Blackwell Publishing. 37 + # (3): 477–484. doi:10.2307/2347330. JSTOR 2347330. + q = p - 0.5 + if fabs(q) <= 0.425: + r = 0.180625 - q * q + # Hash sum: 55.88319_28806_14901_4439 + num = (((((((2.50908_09287_30122_6727e+3 * r + + 3.34305_75583_58812_8105e+4) * r + + 6.72657_70927_00870_0853e+4) * r + + 4.59219_53931_54987_1457e+4) * r + + 1.37316_93765_50946_1125e+4) * r + + 1.97159_09503_06551_4427e+3) * r + + 1.33141_66789_17843_7745e+2) * r + + 3.38713_28727_96366_6080e+0) * q + den = (((((((5.22649_52788_52854_5610e+3 * r + + 2.87290_85735_72194_2674e+4) * r + + 3.93078_95800_09271_0610e+4) * r + + 2.12137_94301_58659_5867e+4) * r + + 5.39419_60214_24751_1077e+3) * r + + 6.87187_00749_20579_0830e+2) * r + + 4.23133_30701_60091_1252e+1) * r + + 1.0) + x = num / den + return mu + (x * sigma) + r = p if q <= 0.0 else 1.0 - p + r = sqrt(-log(r)) + if r <= 5.0: + r = r - 1.6 + # Hash sum: 49.33206_50330_16102_89036 + num = (((((((7.74545_01427_83414_07640e-4 * r + + 2.27238_44989_26918_45833e-2) * r + + 2.41780_72517_74506_11770e-1) * r + + 1.27045_82524_52368_38258e+0) * r + + 3.64784_83247_63204_60504e+0) * r + + 5.76949_72214_60691_40550e+0) * r + + 4.63033_78461_56545_29590e+0) * r + + 1.42343_71107_49683_57734e+0) + den = (((((((1.05075_00716_44416_84324e-9 * r + + 5.47593_80849_95344_94600e-4) * r + + 1.51986_66563_61645_71966e-2) * r + + 1.48103_97642_74800_74590e-1) * r + + 6.89767_33498_51000_04550e-1) * r + + 1.67638_48301_83803_84940e+0) * r + + 2.05319_16266_37758_82187e+0) * r + + 1.0) + else: + r = r - 5.0 + # Hash sum: 47.52583_31754_92896_71629 + num = (((((((2.01033_43992_92288_13265e-7 * r + + 2.71155_55687_43487_57815e-5) * r + + 1.24266_09473_88078_43860e-3) * r + + 2.65321_89526_57612_30930e-2) * r + + 2.96560_57182_85048_91230e-1) * r + + 1.78482_65399_17291_33580e+0) * r + + 5.46378_49111_64114_36990e+0) * r + + 6.65790_46435_01103_77720e+0) + den = (((((((2.04426_31033_89939_78564e-15 * r + + 1.42151_17583_16445_88870e-7) * r + + 1.84631_83175_10054_68180e-5) * r + + 7.86869_13114_56132_59100e-4) * r + + 1.48753_61290_85061_48525e-2) * r + + 1.36929_88092_27358_05310e-1) * r + + 5.99832_20655_58879_37690e-1) * r + + 1.0) + x = num / den + if q < 0.0: + x = -x + return mu + (x * sigma) + + +# If available, use C implementation +try: + from _statistics import _normal_dist_inv_cdf +except ImportError: + pass + + +class NormalDist: + "Normal distribution of a random variable" + # https://en.wikipedia.org/wiki/Normal_distribution + # https://en.wikipedia.org/wiki/Variance#Properties + + __slots__ = { + '_mu': 'Arithmetic mean of a normal distribution', + '_sigma': 'Standard deviation of a normal distribution', + } + + def __init__(self, mu=0.0, sigma=1.0): + "NormalDist where mu is the mean and sigma is the standard deviation." + if sigma < 0.0: + raise StatisticsError('sigma must be non-negative') + self._mu = float(mu) + self._sigma = float(sigma) + + @classmethod + def from_samples(cls, data): + "Make a normal distribution instance from sample data." + return cls(*_mean_stdev(data)) + + def samples(self, n, *, seed=None): + "Generate *n* samples for a given mean and standard deviation." + gauss = random.gauss if seed is None else random.Random(seed).gauss + mu, sigma = self._mu, self._sigma + return [gauss(mu, sigma) for i in range(n)] + + def pdf(self, x): + "Probability density function. P(x <= X < x+dx) / dx" + variance = self._sigma * self._sigma + if not variance: + raise StatisticsError('pdf() not defined when sigma is zero') + diff = x - self._mu + return exp(diff * diff / (-2.0 * variance)) / sqrt(tau * variance) + + def cdf(self, x): + "Cumulative distribution function. P(X <= x)" + if not self._sigma: + raise StatisticsError('cdf() not defined when sigma is zero') + return 0.5 * (1.0 + erf((x - self._mu) / (self._sigma * _SQRT2))) + + def inv_cdf(self, p): + """Inverse cumulative distribution function. x : P(X <= x) = p + + Finds the value of the random variable such that the probability of + the variable being less than or equal to that value equals the given + probability. + + This function is also called the percent point function or quantile + function. + """ + if p <= 0.0 or p >= 1.0: + raise StatisticsError('p must be in the range 0.0 < p < 1.0') + if self._sigma <= 0.0: + raise StatisticsError('cdf() not defined when sigma at or below zero') + return _normal_dist_inv_cdf(p, self._mu, self._sigma) + + def quantiles(self, n=4): + """Divide into *n* continuous intervals with equal probability. + + Returns a list of (n - 1) cut points separating the intervals. + + Set *n* to 4 for quartiles (the default). Set *n* to 10 for deciles. + Set *n* to 100 for percentiles which gives the 99 cuts points that + separate the normal distribution in to 100 equal sized groups. + """ + return [self.inv_cdf(i / n) for i in range(1, n)] + + def overlap(self, other): + """Compute the overlapping coefficient (OVL) between two normal distributions. + + Measures the agreement between two normal probability distributions. + Returns a value between 0.0 and 1.0 giving the overlapping area in + the two underlying probability density functions. + + >>> N1 = NormalDist(2.4, 1.6) + >>> N2 = NormalDist(3.2, 2.0) + >>> N1.overlap(N2) + 0.8035050657330205 + """ + # See: "The overlapping coefficient as a measure of agreement between + # probability distributions and point estimation of the overlap of two + # normal densities" -- Henry F. Inman and Edwin L. Bradley Jr + # http://dx.doi.org/10.1080/03610928908830127 + if not isinstance(other, NormalDist): + raise TypeError('Expected another NormalDist instance') + X, Y = self, other + if (Y._sigma, Y._mu) < (X._sigma, X._mu): # sort to assure commutativity + X, Y = Y, X + X_var, Y_var = X.variance, Y.variance + if not X_var or not Y_var: + raise StatisticsError('overlap() not defined when sigma is zero') + dv = Y_var - X_var + dm = fabs(Y._mu - X._mu) + if not dv: + return 1.0 - erf(dm / (2.0 * X._sigma * _SQRT2)) + a = X._mu * Y_var - Y._mu * X_var + b = X._sigma * Y._sigma * sqrt(dm * dm + dv * log(Y_var / X_var)) + x1 = (a + b) / dv + x2 = (a - b) / dv + return 1.0 - (fabs(Y.cdf(x1) - X.cdf(x1)) + fabs(Y.cdf(x2) - X.cdf(x2))) + + def zscore(self, x): + """Compute the Standard Score. (x - mean) / stdev + + Describes *x* in terms of the number of standard deviations + above or below the mean of the normal distribution. + """ + # https://www.statisticshowto.com/probability-and-statistics/z-score/ + if not self._sigma: + raise StatisticsError('zscore() not defined when sigma is zero') + return (x - self._mu) / self._sigma + + @property + def mean(self): + "Arithmetic mean of the normal distribution." + return self._mu + + @property + def median(self): + "Return the median of the normal distribution" + return self._mu + + @property + def mode(self): + """Return the mode of the normal distribution + + The mode is the value x where which the probability density + function (pdf) takes its maximum value. + """ + return self._mu + + @property + def stdev(self): + "Standard deviation of the normal distribution." + return self._sigma + + @property + def variance(self): + "Square of the standard deviation." + return self._sigma * self._sigma + + def __add__(x1, x2): + """Add a constant or another NormalDist instance. + + If *other* is a constant, translate mu by the constant, + leaving sigma unchanged. + + If *other* is a NormalDist, add both the means and the variances. + Mathematically, this works only if the two distributions are + independent or if they are jointly normally distributed. + """ + if isinstance(x2, NormalDist): + return NormalDist(x1._mu + x2._mu, hypot(x1._sigma, x2._sigma)) + return NormalDist(x1._mu + x2, x1._sigma) + + def __sub__(x1, x2): + """Subtract a constant or another NormalDist instance. + + If *other* is a constant, translate by the constant mu, + leaving sigma unchanged. + + If *other* is a NormalDist, subtract the means and add the variances. + Mathematically, this works only if the two distributions are + independent or if they are jointly normally distributed. + """ + if isinstance(x2, NormalDist): + return NormalDist(x1._mu - x2._mu, hypot(x1._sigma, x2._sigma)) + return NormalDist(x1._mu - x2, x1._sigma) + + def __mul__(x1, x2): + """Multiply both mu and sigma by a constant. + + Used for rescaling, perhaps to change measurement units. + Sigma is scaled with the absolute value of the constant. + """ + return NormalDist(x1._mu * x2, x1._sigma * fabs(x2)) + + def __truediv__(x1, x2): + """Divide both mu and sigma by a constant. + + Used for rescaling, perhaps to change measurement units. + Sigma is scaled with the absolute value of the constant. + """ + return NormalDist(x1._mu / x2, x1._sigma / fabs(x2)) + + def __pos__(x1): + "Return a copy of the instance." + return NormalDist(x1._mu, x1._sigma) + + def __neg__(x1): + "Negates mu while keeping sigma the same." + return NormalDist(-x1._mu, x1._sigma) + + __radd__ = __add__ + + def __rsub__(x1, x2): + "Subtract a NormalDist from a constant or another NormalDist." + return -(x1 - x2) + + __rmul__ = __mul__ + + def __eq__(x1, x2): + "Two NormalDist objects are equal if their mu and sigma are both equal." + if not isinstance(x2, NormalDist): + return NotImplemented + return x1._mu == x2._mu and x1._sigma == x2._sigma + + def __hash__(self): + "NormalDist objects hash equal if their mu and sigma are both equal." + return hash((self._mu, self._sigma)) + + def __repr__(self): + return f'{type(self).__name__}(mu={self._mu!r}, sigma={self._sigma!r})' + + def __getstate__(self): + return self._mu, self._sigma + + def __setstate__(self, state): + self._mu, self._sigma = state diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/string.py b/physworld_p1_20261018/envs/p1/lib/python3.11/string.py new file mode 100644 index 0000000000000000000000000000000000000000..2eab6d4f595c4e1b42a4902fcaf790ce5dd8e5f2 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/string.py @@ -0,0 +1,309 @@ +"""A collection of string constants. + +Public module variables: + +whitespace -- a string containing all ASCII whitespace +ascii_lowercase -- a string containing all ASCII lowercase letters +ascii_uppercase -- a string containing all ASCII uppercase letters +ascii_letters -- a string containing all ASCII letters +digits -- a string containing all ASCII decimal digits +hexdigits -- a string containing all ASCII hexadecimal digits +octdigits -- a string containing all ASCII octal digits +punctuation -- a string containing all ASCII punctuation characters +printable -- a string containing all ASCII characters considered printable + +""" + +__all__ = ["ascii_letters", "ascii_lowercase", "ascii_uppercase", "capwords", + "digits", "hexdigits", "octdigits", "printable", "punctuation", + "whitespace", "Formatter", "Template"] + +import _string + +# Some strings for ctype-style character classification +whitespace = ' \t\n\r\v\f' +ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz' +ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' +ascii_letters = ascii_lowercase + ascii_uppercase +digits = '0123456789' +hexdigits = digits + 'abcdef' + 'ABCDEF' +octdigits = '01234567' +punctuation = r"""!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~""" +printable = digits + ascii_letters + punctuation + whitespace + +# Functions which aren't available as string methods. + +# Capitalize the words in a string, e.g. " aBc dEf " -> "Abc Def". +def capwords(s, sep=None): + """capwords(s [,sep]) -> string + + Split the argument into words using split, capitalize each + word using capitalize, and join the capitalized words using + join. If the optional second argument sep is absent or None, + runs of whitespace characters are replaced by a single space + and leading and trailing whitespace are removed, otherwise + sep is used to split and join the words. + + """ + return (sep or ' ').join(map(str.capitalize, s.split(sep))) + + +#################################################################### +import re as _re +from collections import ChainMap as _ChainMap + +_sentinel_dict = {} + +class Template: + """A string class for supporting $-substitutions.""" + + delimiter = '$' + # r'[a-z]' matches to non-ASCII letters when used with IGNORECASE, but + # without the ASCII flag. We can't add re.ASCII to flags because of + # backward compatibility. So we use the ?a local flag and [a-z] pattern. + # See https://bugs.python.org/issue31672 + idpattern = r'(?a:[_a-z][_a-z0-9]*)' + braceidpattern = None + flags = _re.IGNORECASE + + def __init_subclass__(cls): + super().__init_subclass__() + if 'pattern' in cls.__dict__: + pattern = cls.pattern + else: + delim = _re.escape(cls.delimiter) + id = cls.idpattern + bid = cls.braceidpattern or cls.idpattern + pattern = fr""" + {delim}(?: + (?P{delim}) | # Escape sequence of two delimiters + (?P{id}) | # delimiter and a Python identifier + {{(?P{bid})}} | # delimiter and a braced identifier + (?P) # Other ill-formed delimiter exprs + ) + """ + cls.pattern = _re.compile(pattern, cls.flags | _re.VERBOSE) + + def __init__(self, template): + self.template = template + + # Search for $$, $identifier, ${identifier}, and any bare $'s + + def _invalid(self, mo): + i = mo.start('invalid') + lines = self.template[:i].splitlines(keepends=True) + if not lines: + colno = 1 + lineno = 1 + else: + colno = i - len(''.join(lines[:-1])) + lineno = len(lines) + raise ValueError('Invalid placeholder in string: line %d, col %d' % + (lineno, colno)) + + def substitute(self, mapping=_sentinel_dict, /, **kws): + if mapping is _sentinel_dict: + mapping = kws + elif kws: + mapping = _ChainMap(kws, mapping) + # Helper function for .sub() + def convert(mo): + # Check the most common path first. + named = mo.group('named') or mo.group('braced') + if named is not None: + return str(mapping[named]) + if mo.group('escaped') is not None: + return self.delimiter + if mo.group('invalid') is not None: + self._invalid(mo) + raise ValueError('Unrecognized named group in pattern', + self.pattern) + return self.pattern.sub(convert, self.template) + + def safe_substitute(self, mapping=_sentinel_dict, /, **kws): + if mapping is _sentinel_dict: + mapping = kws + elif kws: + mapping = _ChainMap(kws, mapping) + # Helper function for .sub() + def convert(mo): + named = mo.group('named') or mo.group('braced') + if named is not None: + try: + return str(mapping[named]) + except KeyError: + return mo.group() + if mo.group('escaped') is not None: + return self.delimiter + if mo.group('invalid') is not None: + return mo.group() + raise ValueError('Unrecognized named group in pattern', + self.pattern) + return self.pattern.sub(convert, self.template) + + def is_valid(self): + for mo in self.pattern.finditer(self.template): + if mo.group('invalid') is not None: + return False + if (mo.group('named') is None + and mo.group('braced') is None + and mo.group('escaped') is None): + # If all the groups are None, there must be + # another group we're not expecting + raise ValueError('Unrecognized named group in pattern', + self.pattern) + return True + + def get_identifiers(self): + ids = [] + for mo in self.pattern.finditer(self.template): + named = mo.group('named') or mo.group('braced') + if named is not None and named not in ids: + # add a named group only the first time it appears + ids.append(named) + elif (named is None + and mo.group('invalid') is None + and mo.group('escaped') is None): + # If all the groups are None, there must be + # another group we're not expecting + raise ValueError('Unrecognized named group in pattern', + self.pattern) + return ids + +# Initialize Template.pattern. __init_subclass__() is automatically called +# only for subclasses, not for the Template class itself. +Template.__init_subclass__() + + +######################################################################## +# the Formatter class +# see PEP 3101 for details and purpose of this class + +# The hard parts are reused from the C implementation. They're exposed as "_" +# prefixed methods of str. + +# The overall parser is implemented in _string.formatter_parser. +# The field name parser is implemented in _string.formatter_field_name_split + +class Formatter: + def format(self, format_string, /, *args, **kwargs): + return self.vformat(format_string, args, kwargs) + + def vformat(self, format_string, args, kwargs): + used_args = set() + result, _ = self._vformat(format_string, args, kwargs, used_args, 2) + self.check_unused_args(used_args, args, kwargs) + return result + + def _vformat(self, format_string, args, kwargs, used_args, recursion_depth, + auto_arg_index=0): + if recursion_depth < 0: + raise ValueError('Max string recursion exceeded') + result = [] + for literal_text, field_name, format_spec, conversion in \ + self.parse(format_string): + + # output the literal text + if literal_text: + result.append(literal_text) + + # if there's a field, output it + if field_name is not None: + # this is some markup, find the object and do + # the formatting + + # handle arg indexing when empty field_names are given. + if field_name == '': + if auto_arg_index is False: + raise ValueError('cannot switch from manual field ' + 'specification to automatic field ' + 'numbering') + field_name = str(auto_arg_index) + auto_arg_index += 1 + elif field_name.isdigit(): + if auto_arg_index: + raise ValueError('cannot switch from manual field ' + 'specification to automatic field ' + 'numbering') + # disable auto arg incrementing, if it gets + # used later on, then an exception will be raised + auto_arg_index = False + + # given the field_name, find the object it references + # and the argument it came from + obj, arg_used = self.get_field(field_name, args, kwargs) + used_args.add(arg_used) + + # do any conversion on the resulting object + obj = self.convert_field(obj, conversion) + + # expand the format spec, if needed + format_spec, auto_arg_index = self._vformat( + format_spec, args, kwargs, + used_args, recursion_depth-1, + auto_arg_index=auto_arg_index) + + # format the object and append to the result + result.append(self.format_field(obj, format_spec)) + + return ''.join(result), auto_arg_index + + + def get_value(self, key, args, kwargs): + if isinstance(key, int): + return args[key] + else: + return kwargs[key] + + + def check_unused_args(self, used_args, args, kwargs): + pass + + + def format_field(self, value, format_spec): + return format(value, format_spec) + + + def convert_field(self, value, conversion): + # do any conversion on the resulting object + if conversion is None: + return value + elif conversion == 's': + return str(value) + elif conversion == 'r': + return repr(value) + elif conversion == 'a': + return ascii(value) + raise ValueError("Unknown conversion specifier {0!s}".format(conversion)) + + + # returns an iterable that contains tuples of the form: + # (literal_text, field_name, format_spec, conversion) + # literal_text can be zero length + # field_name can be None, in which case there's no + # object to format and output + # if field_name is not None, it is looked up, formatted + # with format_spec and conversion and then used + def parse(self, format_string): + return _string.formatter_parser(format_string) + + + # given a field_name, find the object it references. + # field_name: the field being looked up, e.g. "0.name" + # or "lookup[3]" + # used_args: a set of which args have been used + # args, kwargs: as passed in to vformat + def get_field(self, field_name, args, kwargs): + first, rest = _string.formatter_field_name_split(field_name) + + obj = self.get_value(first, args, kwargs) + + # loop through the rest of the field_name, doing + # getattr or getitem as needed + for is_attr, i in rest: + if is_attr: + obj = getattr(obj, i) + else: + obj = obj[i] + + return obj, first diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/stringprep.py b/physworld_p1_20261018/envs/p1/lib/python3.11/stringprep.py new file mode 100644 index 0000000000000000000000000000000000000000..6a900c8228f0e56807263e1dc431bdb4ba412177 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/stringprep.py @@ -0,0 +1,449 @@ +# This file is generated by mkstringprep.py. DO NOT EDIT. +"""Library that exposes various tables found in the StringPrep RFC 3454. + +There are two kinds of tables: sets, for which a member test is provided, +and mappings, for which a mapping function is provided. +""" + +# This check asserts that mkstringprep.py has been run +# when unicodedata is modified to ensure conformant behavior. +import unicodedata + +assert unicodedata.unidata_version == '14.0.0' + +from unicodedata import ucd_3_2_0 as unicodedata_320 + +assert unicodedata_320.unidata_version == '3.2.0' + +def in_table_a1(code): + if unicodedata_320.category(code) != 'Cn': return False + c = ord(code) + if 0xFDD0 <= c < 0xFDF0: return False + return (c & 0xFFFF) not in (0xFFFE, 0xFFFF) + + +b1_set = set([173, 847, 6150, 6155, 6156, 6157, 8203, 8204, 8205, 8288, 65279] + list(range(65024,65040))) +def in_table_b1(code): + return ord(code) in b1_set + + +b3_exceptions = { +0xb5:'\u03bc', 0xdf:'ss', 0x149:'\u02bcn', 0x17f:'s', +0x1f0:'j\u030c', 0x23a:'\u023a', 0x23b:'\u023b', 0x23d:'\u023d', +0x23e:'\u023e', 0x241:'\u0241', 0x243:'\u0243', 0x244:'\u0244', +0x245:'\u0245', 0x246:'\u0246', 0x248:'\u0248', 0x24a:'\u024a', +0x24c:'\u024c', 0x24e:'\u024e', 0x345:'\u03b9', 0x370:'\u0370', +0x372:'\u0372', 0x376:'\u0376', 0x37a:' \u03b9', 0x37f:'\u037f', +0x390:'\u03b9\u0308\u0301', 0x3b0:'\u03c5\u0308\u0301', 0x3c2:'\u03c3', 0x3cf:'\u03cf', +0x3d0:'\u03b2', 0x3d1:'\u03b8', 0x3d2:'\u03c5', 0x3d3:'\u03cd', +0x3d4:'\u03cb', 0x3d5:'\u03c6', 0x3d6:'\u03c0', 0x3f0:'\u03ba', +0x3f1:'\u03c1', 0x3f2:'\u03c3', 0x3f5:'\u03b5', 0x3f7:'\u03f7', +0x3f9:'\u03f9', 0x3fa:'\u03fa', 0x3fd:'\u03fd', 0x3fe:'\u03fe', +0x3ff:'\u03ff', 0x4c0:'\u04c0', 0x4f6:'\u04f6', 0x4fa:'\u04fa', +0x4fc:'\u04fc', 0x4fe:'\u04fe', 0x510:'\u0510', 0x512:'\u0512', +0x514:'\u0514', 0x516:'\u0516', 0x518:'\u0518', 0x51a:'\u051a', +0x51c:'\u051c', 0x51e:'\u051e', 0x520:'\u0520', 0x522:'\u0522', +0x524:'\u0524', 0x526:'\u0526', 0x528:'\u0528', 0x52a:'\u052a', +0x52c:'\u052c', 0x52e:'\u052e', 0x587:'\u0565\u0582', 0x10a0:'\u10a0', +0x10a1:'\u10a1', 0x10a2:'\u10a2', 0x10a3:'\u10a3', 0x10a4:'\u10a4', +0x10a5:'\u10a5', 0x10a6:'\u10a6', 0x10a7:'\u10a7', 0x10a8:'\u10a8', +0x10a9:'\u10a9', 0x10aa:'\u10aa', 0x10ab:'\u10ab', 0x10ac:'\u10ac', +0x10ad:'\u10ad', 0x10ae:'\u10ae', 0x10af:'\u10af', 0x10b0:'\u10b0', +0x10b1:'\u10b1', 0x10b2:'\u10b2', 0x10b3:'\u10b3', 0x10b4:'\u10b4', +0x10b5:'\u10b5', 0x10b6:'\u10b6', 0x10b7:'\u10b7', 0x10b8:'\u10b8', +0x10b9:'\u10b9', 0x10ba:'\u10ba', 0x10bb:'\u10bb', 0x10bc:'\u10bc', +0x10bd:'\u10bd', 0x10be:'\u10be', 0x10bf:'\u10bf', 0x10c0:'\u10c0', +0x10c1:'\u10c1', 0x10c2:'\u10c2', 0x10c3:'\u10c3', 0x10c4:'\u10c4', +0x10c5:'\u10c5', 0x10c7:'\u10c7', 0x10cd:'\u10cd', 0x13a0:'\u13a0', +0x13a1:'\u13a1', 0x13a2:'\u13a2', 0x13a3:'\u13a3', 0x13a4:'\u13a4', +0x13a5:'\u13a5', 0x13a6:'\u13a6', 0x13a7:'\u13a7', 0x13a8:'\u13a8', +0x13a9:'\u13a9', 0x13aa:'\u13aa', 0x13ab:'\u13ab', 0x13ac:'\u13ac', +0x13ad:'\u13ad', 0x13ae:'\u13ae', 0x13af:'\u13af', 0x13b0:'\u13b0', +0x13b1:'\u13b1', 0x13b2:'\u13b2', 0x13b3:'\u13b3', 0x13b4:'\u13b4', +0x13b5:'\u13b5', 0x13b6:'\u13b6', 0x13b7:'\u13b7', 0x13b8:'\u13b8', +0x13b9:'\u13b9', 0x13ba:'\u13ba', 0x13bb:'\u13bb', 0x13bc:'\u13bc', +0x13bd:'\u13bd', 0x13be:'\u13be', 0x13bf:'\u13bf', 0x13c0:'\u13c0', +0x13c1:'\u13c1', 0x13c2:'\u13c2', 0x13c3:'\u13c3', 0x13c4:'\u13c4', +0x13c5:'\u13c5', 0x13c6:'\u13c6', 0x13c7:'\u13c7', 0x13c8:'\u13c8', +0x13c9:'\u13c9', 0x13ca:'\u13ca', 0x13cb:'\u13cb', 0x13cc:'\u13cc', +0x13cd:'\u13cd', 0x13ce:'\u13ce', 0x13cf:'\u13cf', 0x13d0:'\u13d0', +0x13d1:'\u13d1', 0x13d2:'\u13d2', 0x13d3:'\u13d3', 0x13d4:'\u13d4', +0x13d5:'\u13d5', 0x13d6:'\u13d6', 0x13d7:'\u13d7', 0x13d8:'\u13d8', +0x13d9:'\u13d9', 0x13da:'\u13da', 0x13db:'\u13db', 0x13dc:'\u13dc', +0x13dd:'\u13dd', 0x13de:'\u13de', 0x13df:'\u13df', 0x13e0:'\u13e0', +0x13e1:'\u13e1', 0x13e2:'\u13e2', 0x13e3:'\u13e3', 0x13e4:'\u13e4', +0x13e5:'\u13e5', 0x13e6:'\u13e6', 0x13e7:'\u13e7', 0x13e8:'\u13e8', +0x13e9:'\u13e9', 0x13ea:'\u13ea', 0x13eb:'\u13eb', 0x13ec:'\u13ec', +0x13ed:'\u13ed', 0x13ee:'\u13ee', 0x13ef:'\u13ef', 0x13f0:'\u13f0', +0x13f1:'\u13f1', 0x13f2:'\u13f2', 0x13f3:'\u13f3', 0x13f4:'\u13f4', +0x13f5:'\u13f5', 0x1c90:'\u1c90', 0x1c91:'\u1c91', 0x1c92:'\u1c92', +0x1c93:'\u1c93', 0x1c94:'\u1c94', 0x1c95:'\u1c95', 0x1c96:'\u1c96', +0x1c97:'\u1c97', 0x1c98:'\u1c98', 0x1c99:'\u1c99', 0x1c9a:'\u1c9a', +0x1c9b:'\u1c9b', 0x1c9c:'\u1c9c', 0x1c9d:'\u1c9d', 0x1c9e:'\u1c9e', +0x1c9f:'\u1c9f', 0x1ca0:'\u1ca0', 0x1ca1:'\u1ca1', 0x1ca2:'\u1ca2', +0x1ca3:'\u1ca3', 0x1ca4:'\u1ca4', 0x1ca5:'\u1ca5', 0x1ca6:'\u1ca6', +0x1ca7:'\u1ca7', 0x1ca8:'\u1ca8', 0x1ca9:'\u1ca9', 0x1caa:'\u1caa', +0x1cab:'\u1cab', 0x1cac:'\u1cac', 0x1cad:'\u1cad', 0x1cae:'\u1cae', +0x1caf:'\u1caf', 0x1cb0:'\u1cb0', 0x1cb1:'\u1cb1', 0x1cb2:'\u1cb2', +0x1cb3:'\u1cb3', 0x1cb4:'\u1cb4', 0x1cb5:'\u1cb5', 0x1cb6:'\u1cb6', +0x1cb7:'\u1cb7', 0x1cb8:'\u1cb8', 0x1cb9:'\u1cb9', 0x1cba:'\u1cba', +0x1cbd:'\u1cbd', 0x1cbe:'\u1cbe', 0x1cbf:'\u1cbf', 0x1e96:'h\u0331', +0x1e97:'t\u0308', 0x1e98:'w\u030a', 0x1e99:'y\u030a', 0x1e9a:'a\u02be', +0x1e9b:'\u1e61', 0x1e9e:'\u1e9e', 0x1efa:'\u1efa', 0x1efc:'\u1efc', +0x1efe:'\u1efe', 0x1f50:'\u03c5\u0313', 0x1f52:'\u03c5\u0313\u0300', 0x1f54:'\u03c5\u0313\u0301', +0x1f56:'\u03c5\u0313\u0342', 0x1f80:'\u1f00\u03b9', 0x1f81:'\u1f01\u03b9', 0x1f82:'\u1f02\u03b9', +0x1f83:'\u1f03\u03b9', 0x1f84:'\u1f04\u03b9', 0x1f85:'\u1f05\u03b9', 0x1f86:'\u1f06\u03b9', +0x1f87:'\u1f07\u03b9', 0x1f88:'\u1f00\u03b9', 0x1f89:'\u1f01\u03b9', 0x1f8a:'\u1f02\u03b9', +0x1f8b:'\u1f03\u03b9', 0x1f8c:'\u1f04\u03b9', 0x1f8d:'\u1f05\u03b9', 0x1f8e:'\u1f06\u03b9', +0x1f8f:'\u1f07\u03b9', 0x1f90:'\u1f20\u03b9', 0x1f91:'\u1f21\u03b9', 0x1f92:'\u1f22\u03b9', +0x1f93:'\u1f23\u03b9', 0x1f94:'\u1f24\u03b9', 0x1f95:'\u1f25\u03b9', 0x1f96:'\u1f26\u03b9', +0x1f97:'\u1f27\u03b9', 0x1f98:'\u1f20\u03b9', 0x1f99:'\u1f21\u03b9', 0x1f9a:'\u1f22\u03b9', +0x1f9b:'\u1f23\u03b9', 0x1f9c:'\u1f24\u03b9', 0x1f9d:'\u1f25\u03b9', 0x1f9e:'\u1f26\u03b9', +0x1f9f:'\u1f27\u03b9', 0x1fa0:'\u1f60\u03b9', 0x1fa1:'\u1f61\u03b9', 0x1fa2:'\u1f62\u03b9', +0x1fa3:'\u1f63\u03b9', 0x1fa4:'\u1f64\u03b9', 0x1fa5:'\u1f65\u03b9', 0x1fa6:'\u1f66\u03b9', +0x1fa7:'\u1f67\u03b9', 0x1fa8:'\u1f60\u03b9', 0x1fa9:'\u1f61\u03b9', 0x1faa:'\u1f62\u03b9', +0x1fab:'\u1f63\u03b9', 0x1fac:'\u1f64\u03b9', 0x1fad:'\u1f65\u03b9', 0x1fae:'\u1f66\u03b9', +0x1faf:'\u1f67\u03b9', 0x1fb2:'\u1f70\u03b9', 0x1fb3:'\u03b1\u03b9', 0x1fb4:'\u03ac\u03b9', +0x1fb6:'\u03b1\u0342', 0x1fb7:'\u03b1\u0342\u03b9', 0x1fbc:'\u03b1\u03b9', 0x1fbe:'\u03b9', +0x1fc2:'\u1f74\u03b9', 0x1fc3:'\u03b7\u03b9', 0x1fc4:'\u03ae\u03b9', 0x1fc6:'\u03b7\u0342', +0x1fc7:'\u03b7\u0342\u03b9', 0x1fcc:'\u03b7\u03b9', 0x1fd2:'\u03b9\u0308\u0300', 0x1fd3:'\u03b9\u0308\u0301', +0x1fd6:'\u03b9\u0342', 0x1fd7:'\u03b9\u0308\u0342', 0x1fe2:'\u03c5\u0308\u0300', 0x1fe3:'\u03c5\u0308\u0301', +0x1fe4:'\u03c1\u0313', 0x1fe6:'\u03c5\u0342', 0x1fe7:'\u03c5\u0308\u0342', 0x1ff2:'\u1f7c\u03b9', +0x1ff3:'\u03c9\u03b9', 0x1ff4:'\u03ce\u03b9', 0x1ff6:'\u03c9\u0342', 0x1ff7:'\u03c9\u0342\u03b9', +0x1ffc:'\u03c9\u03b9', 0x20a8:'rs', 0x2102:'c', 0x2103:'\xb0c', +0x2107:'\u025b', 0x2109:'\xb0f', 0x210b:'h', 0x210c:'h', +0x210d:'h', 0x2110:'i', 0x2111:'i', 0x2112:'l', +0x2115:'n', 0x2116:'no', 0x2119:'p', 0x211a:'q', +0x211b:'r', 0x211c:'r', 0x211d:'r', 0x2120:'sm', +0x2121:'tel', 0x2122:'tm', 0x2124:'z', 0x2128:'z', +0x212c:'b', 0x212d:'c', 0x2130:'e', 0x2131:'f', +0x2132:'\u2132', 0x2133:'m', 0x213e:'\u03b3', 0x213f:'\u03c0', +0x2145:'d', 0x2183:'\u2183', 0x2c00:'\u2c00', 0x2c01:'\u2c01', +0x2c02:'\u2c02', 0x2c03:'\u2c03', 0x2c04:'\u2c04', 0x2c05:'\u2c05', +0x2c06:'\u2c06', 0x2c07:'\u2c07', 0x2c08:'\u2c08', 0x2c09:'\u2c09', +0x2c0a:'\u2c0a', 0x2c0b:'\u2c0b', 0x2c0c:'\u2c0c', 0x2c0d:'\u2c0d', +0x2c0e:'\u2c0e', 0x2c0f:'\u2c0f', 0x2c10:'\u2c10', 0x2c11:'\u2c11', +0x2c12:'\u2c12', 0x2c13:'\u2c13', 0x2c14:'\u2c14', 0x2c15:'\u2c15', +0x2c16:'\u2c16', 0x2c17:'\u2c17', 0x2c18:'\u2c18', 0x2c19:'\u2c19', +0x2c1a:'\u2c1a', 0x2c1b:'\u2c1b', 0x2c1c:'\u2c1c', 0x2c1d:'\u2c1d', +0x2c1e:'\u2c1e', 0x2c1f:'\u2c1f', 0x2c20:'\u2c20', 0x2c21:'\u2c21', +0x2c22:'\u2c22', 0x2c23:'\u2c23', 0x2c24:'\u2c24', 0x2c25:'\u2c25', +0x2c26:'\u2c26', 0x2c27:'\u2c27', 0x2c28:'\u2c28', 0x2c29:'\u2c29', +0x2c2a:'\u2c2a', 0x2c2b:'\u2c2b', 0x2c2c:'\u2c2c', 0x2c2d:'\u2c2d', +0x2c2e:'\u2c2e', 0x2c2f:'\u2c2f', 0x2c60:'\u2c60', 0x2c62:'\u2c62', +0x2c63:'\u2c63', 0x2c64:'\u2c64', 0x2c67:'\u2c67', 0x2c69:'\u2c69', +0x2c6b:'\u2c6b', 0x2c6d:'\u2c6d', 0x2c6e:'\u2c6e', 0x2c6f:'\u2c6f', +0x2c70:'\u2c70', 0x2c72:'\u2c72', 0x2c75:'\u2c75', 0x2c7e:'\u2c7e', +0x2c7f:'\u2c7f', 0x2c80:'\u2c80', 0x2c82:'\u2c82', 0x2c84:'\u2c84', +0x2c86:'\u2c86', 0x2c88:'\u2c88', 0x2c8a:'\u2c8a', 0x2c8c:'\u2c8c', +0x2c8e:'\u2c8e', 0x2c90:'\u2c90', 0x2c92:'\u2c92', 0x2c94:'\u2c94', +0x2c96:'\u2c96', 0x2c98:'\u2c98', 0x2c9a:'\u2c9a', 0x2c9c:'\u2c9c', +0x2c9e:'\u2c9e', 0x2ca0:'\u2ca0', 0x2ca2:'\u2ca2', 0x2ca4:'\u2ca4', +0x2ca6:'\u2ca6', 0x2ca8:'\u2ca8', 0x2caa:'\u2caa', 0x2cac:'\u2cac', +0x2cae:'\u2cae', 0x2cb0:'\u2cb0', 0x2cb2:'\u2cb2', 0x2cb4:'\u2cb4', +0x2cb6:'\u2cb6', 0x2cb8:'\u2cb8', 0x2cba:'\u2cba', 0x2cbc:'\u2cbc', +0x2cbe:'\u2cbe', 0x2cc0:'\u2cc0', 0x2cc2:'\u2cc2', 0x2cc4:'\u2cc4', +0x2cc6:'\u2cc6', 0x2cc8:'\u2cc8', 0x2cca:'\u2cca', 0x2ccc:'\u2ccc', +0x2cce:'\u2cce', 0x2cd0:'\u2cd0', 0x2cd2:'\u2cd2', 0x2cd4:'\u2cd4', +0x2cd6:'\u2cd6', 0x2cd8:'\u2cd8', 0x2cda:'\u2cda', 0x2cdc:'\u2cdc', +0x2cde:'\u2cde', 0x2ce0:'\u2ce0', 0x2ce2:'\u2ce2', 0x2ceb:'\u2ceb', +0x2ced:'\u2ced', 0x2cf2:'\u2cf2', 0x3371:'hpa', 0x3373:'au', +0x3375:'ov', 0x3380:'pa', 0x3381:'na', 0x3382:'\u03bca', +0x3383:'ma', 0x3384:'ka', 0x3385:'kb', 0x3386:'mb', +0x3387:'gb', 0x338a:'pf', 0x338b:'nf', 0x338c:'\u03bcf', +0x3390:'hz', 0x3391:'khz', 0x3392:'mhz', 0x3393:'ghz', +0x3394:'thz', 0x33a9:'pa', 0x33aa:'kpa', 0x33ab:'mpa', +0x33ac:'gpa', 0x33b4:'pv', 0x33b5:'nv', 0x33b6:'\u03bcv', +0x33b7:'mv', 0x33b8:'kv', 0x33b9:'mv', 0x33ba:'pw', +0x33bb:'nw', 0x33bc:'\u03bcw', 0x33bd:'mw', 0x33be:'kw', +0x33bf:'mw', 0x33c0:'k\u03c9', 0x33c1:'m\u03c9', 0x33c3:'bq', +0x33c6:'c\u2215kg', 0x33c7:'co.', 0x33c8:'db', 0x33c9:'gy', +0x33cb:'hp', 0x33cd:'kk', 0x33ce:'km', 0x33d7:'ph', +0x33d9:'ppm', 0x33da:'pr', 0x33dc:'sv', 0x33dd:'wb', +0xa640:'\ua640', 0xa642:'\ua642', 0xa644:'\ua644', 0xa646:'\ua646', +0xa648:'\ua648', 0xa64a:'\ua64a', 0xa64c:'\ua64c', 0xa64e:'\ua64e', +0xa650:'\ua650', 0xa652:'\ua652', 0xa654:'\ua654', 0xa656:'\ua656', +0xa658:'\ua658', 0xa65a:'\ua65a', 0xa65c:'\ua65c', 0xa65e:'\ua65e', +0xa660:'\ua660', 0xa662:'\ua662', 0xa664:'\ua664', 0xa666:'\ua666', +0xa668:'\ua668', 0xa66a:'\ua66a', 0xa66c:'\ua66c', 0xa680:'\ua680', +0xa682:'\ua682', 0xa684:'\ua684', 0xa686:'\ua686', 0xa688:'\ua688', +0xa68a:'\ua68a', 0xa68c:'\ua68c', 0xa68e:'\ua68e', 0xa690:'\ua690', +0xa692:'\ua692', 0xa694:'\ua694', 0xa696:'\ua696', 0xa698:'\ua698', +0xa69a:'\ua69a', 0xa722:'\ua722', 0xa724:'\ua724', 0xa726:'\ua726', +0xa728:'\ua728', 0xa72a:'\ua72a', 0xa72c:'\ua72c', 0xa72e:'\ua72e', +0xa732:'\ua732', 0xa734:'\ua734', 0xa736:'\ua736', 0xa738:'\ua738', +0xa73a:'\ua73a', 0xa73c:'\ua73c', 0xa73e:'\ua73e', 0xa740:'\ua740', +0xa742:'\ua742', 0xa744:'\ua744', 0xa746:'\ua746', 0xa748:'\ua748', +0xa74a:'\ua74a', 0xa74c:'\ua74c', 0xa74e:'\ua74e', 0xa750:'\ua750', +0xa752:'\ua752', 0xa754:'\ua754', 0xa756:'\ua756', 0xa758:'\ua758', +0xa75a:'\ua75a', 0xa75c:'\ua75c', 0xa75e:'\ua75e', 0xa760:'\ua760', +0xa762:'\ua762', 0xa764:'\ua764', 0xa766:'\ua766', 0xa768:'\ua768', +0xa76a:'\ua76a', 0xa76c:'\ua76c', 0xa76e:'\ua76e', 0xa779:'\ua779', +0xa77b:'\ua77b', 0xa77d:'\ua77d', 0xa77e:'\ua77e', 0xa780:'\ua780', +0xa782:'\ua782', 0xa784:'\ua784', 0xa786:'\ua786', 0xa78b:'\ua78b', +0xa78d:'\ua78d', 0xa790:'\ua790', 0xa792:'\ua792', 0xa796:'\ua796', +0xa798:'\ua798', 0xa79a:'\ua79a', 0xa79c:'\ua79c', 0xa79e:'\ua79e', +0xa7a0:'\ua7a0', 0xa7a2:'\ua7a2', 0xa7a4:'\ua7a4', 0xa7a6:'\ua7a6', +0xa7a8:'\ua7a8', 0xa7aa:'\ua7aa', 0xa7ab:'\ua7ab', 0xa7ac:'\ua7ac', +0xa7ad:'\ua7ad', 0xa7ae:'\ua7ae', 0xa7b0:'\ua7b0', 0xa7b1:'\ua7b1', +0xa7b2:'\ua7b2', 0xa7b3:'\ua7b3', 0xa7b4:'\ua7b4', 0xa7b6:'\ua7b6', +0xa7b8:'\ua7b8', 0xa7ba:'\ua7ba', 0xa7bc:'\ua7bc', 0xa7be:'\ua7be', +0xa7c0:'\ua7c0', 0xa7c2:'\ua7c2', 0xa7c4:'\ua7c4', 0xa7c5:'\ua7c5', +0xa7c6:'\ua7c6', 0xa7c7:'\ua7c7', 0xa7c9:'\ua7c9', 0xa7d0:'\ua7d0', +0xa7d6:'\ua7d6', 0xa7d8:'\ua7d8', 0xa7f5:'\ua7f5', 0xfb00:'ff', +0xfb01:'fi', 0xfb02:'fl', 0xfb03:'ffi', 0xfb04:'ffl', +0xfb05:'st', 0xfb06:'st', 0xfb13:'\u0574\u0576', 0xfb14:'\u0574\u0565', +0xfb15:'\u0574\u056b', 0xfb16:'\u057e\u0576', 0xfb17:'\u0574\u056d', 0x10426:'\U00010426', +0x10427:'\U00010427', 0x104b0:'\U000104b0', 0x104b1:'\U000104b1', 0x104b2:'\U000104b2', +0x104b3:'\U000104b3', 0x104b4:'\U000104b4', 0x104b5:'\U000104b5', 0x104b6:'\U000104b6', +0x104b7:'\U000104b7', 0x104b8:'\U000104b8', 0x104b9:'\U000104b9', 0x104ba:'\U000104ba', +0x104bb:'\U000104bb', 0x104bc:'\U000104bc', 0x104bd:'\U000104bd', 0x104be:'\U000104be', +0x104bf:'\U000104bf', 0x104c0:'\U000104c0', 0x104c1:'\U000104c1', 0x104c2:'\U000104c2', +0x104c3:'\U000104c3', 0x104c4:'\U000104c4', 0x104c5:'\U000104c5', 0x104c6:'\U000104c6', +0x104c7:'\U000104c7', 0x104c8:'\U000104c8', 0x104c9:'\U000104c9', 0x104ca:'\U000104ca', +0x104cb:'\U000104cb', 0x104cc:'\U000104cc', 0x104cd:'\U000104cd', 0x104ce:'\U000104ce', +0x104cf:'\U000104cf', 0x104d0:'\U000104d0', 0x104d1:'\U000104d1', 0x104d2:'\U000104d2', +0x104d3:'\U000104d3', 0x10570:'\U00010570', 0x10571:'\U00010571', 0x10572:'\U00010572', +0x10573:'\U00010573', 0x10574:'\U00010574', 0x10575:'\U00010575', 0x10576:'\U00010576', +0x10577:'\U00010577', 0x10578:'\U00010578', 0x10579:'\U00010579', 0x1057a:'\U0001057a', +0x1057c:'\U0001057c', 0x1057d:'\U0001057d', 0x1057e:'\U0001057e', 0x1057f:'\U0001057f', +0x10580:'\U00010580', 0x10581:'\U00010581', 0x10582:'\U00010582', 0x10583:'\U00010583', +0x10584:'\U00010584', 0x10585:'\U00010585', 0x10586:'\U00010586', 0x10587:'\U00010587', +0x10588:'\U00010588', 0x10589:'\U00010589', 0x1058a:'\U0001058a', 0x1058c:'\U0001058c', +0x1058d:'\U0001058d', 0x1058e:'\U0001058e', 0x1058f:'\U0001058f', 0x10590:'\U00010590', +0x10591:'\U00010591', 0x10592:'\U00010592', 0x10594:'\U00010594', 0x10595:'\U00010595', +0x10c80:'\U00010c80', 0x10c81:'\U00010c81', 0x10c82:'\U00010c82', 0x10c83:'\U00010c83', +0x10c84:'\U00010c84', 0x10c85:'\U00010c85', 0x10c86:'\U00010c86', 0x10c87:'\U00010c87', +0x10c88:'\U00010c88', 0x10c89:'\U00010c89', 0x10c8a:'\U00010c8a', 0x10c8b:'\U00010c8b', +0x10c8c:'\U00010c8c', 0x10c8d:'\U00010c8d', 0x10c8e:'\U00010c8e', 0x10c8f:'\U00010c8f', +0x10c90:'\U00010c90', 0x10c91:'\U00010c91', 0x10c92:'\U00010c92', 0x10c93:'\U00010c93', +0x10c94:'\U00010c94', 0x10c95:'\U00010c95', 0x10c96:'\U00010c96', 0x10c97:'\U00010c97', +0x10c98:'\U00010c98', 0x10c99:'\U00010c99', 0x10c9a:'\U00010c9a', 0x10c9b:'\U00010c9b', +0x10c9c:'\U00010c9c', 0x10c9d:'\U00010c9d', 0x10c9e:'\U00010c9e', 0x10c9f:'\U00010c9f', +0x10ca0:'\U00010ca0', 0x10ca1:'\U00010ca1', 0x10ca2:'\U00010ca2', 0x10ca3:'\U00010ca3', +0x10ca4:'\U00010ca4', 0x10ca5:'\U00010ca5', 0x10ca6:'\U00010ca6', 0x10ca7:'\U00010ca7', +0x10ca8:'\U00010ca8', 0x10ca9:'\U00010ca9', 0x10caa:'\U00010caa', 0x10cab:'\U00010cab', +0x10cac:'\U00010cac', 0x10cad:'\U00010cad', 0x10cae:'\U00010cae', 0x10caf:'\U00010caf', +0x10cb0:'\U00010cb0', 0x10cb1:'\U00010cb1', 0x10cb2:'\U00010cb2', 0x118a0:'\U000118a0', +0x118a1:'\U000118a1', 0x118a2:'\U000118a2', 0x118a3:'\U000118a3', 0x118a4:'\U000118a4', +0x118a5:'\U000118a5', 0x118a6:'\U000118a6', 0x118a7:'\U000118a7', 0x118a8:'\U000118a8', +0x118a9:'\U000118a9', 0x118aa:'\U000118aa', 0x118ab:'\U000118ab', 0x118ac:'\U000118ac', +0x118ad:'\U000118ad', 0x118ae:'\U000118ae', 0x118af:'\U000118af', 0x118b0:'\U000118b0', +0x118b1:'\U000118b1', 0x118b2:'\U000118b2', 0x118b3:'\U000118b3', 0x118b4:'\U000118b4', +0x118b5:'\U000118b5', 0x118b6:'\U000118b6', 0x118b7:'\U000118b7', 0x118b8:'\U000118b8', +0x118b9:'\U000118b9', 0x118ba:'\U000118ba', 0x118bb:'\U000118bb', 0x118bc:'\U000118bc', +0x118bd:'\U000118bd', 0x118be:'\U000118be', 0x118bf:'\U000118bf', 0x16e40:'\U00016e40', +0x16e41:'\U00016e41', 0x16e42:'\U00016e42', 0x16e43:'\U00016e43', 0x16e44:'\U00016e44', +0x16e45:'\U00016e45', 0x16e46:'\U00016e46', 0x16e47:'\U00016e47', 0x16e48:'\U00016e48', +0x16e49:'\U00016e49', 0x16e4a:'\U00016e4a', 0x16e4b:'\U00016e4b', 0x16e4c:'\U00016e4c', +0x16e4d:'\U00016e4d', 0x16e4e:'\U00016e4e', 0x16e4f:'\U00016e4f', 0x16e50:'\U00016e50', +0x16e51:'\U00016e51', 0x16e52:'\U00016e52', 0x16e53:'\U00016e53', 0x16e54:'\U00016e54', +0x16e55:'\U00016e55', 0x16e56:'\U00016e56', 0x16e57:'\U00016e57', 0x16e58:'\U00016e58', +0x16e59:'\U00016e59', 0x16e5a:'\U00016e5a', 0x16e5b:'\U00016e5b', 0x16e5c:'\U00016e5c', +0x16e5d:'\U00016e5d', 0x16e5e:'\U00016e5e', 0x16e5f:'\U00016e5f', 0x1d400:'a', +0x1d401:'b', 0x1d402:'c', 0x1d403:'d', 0x1d404:'e', +0x1d405:'f', 0x1d406:'g', 0x1d407:'h', 0x1d408:'i', +0x1d409:'j', 0x1d40a:'k', 0x1d40b:'l', 0x1d40c:'m', +0x1d40d:'n', 0x1d40e:'o', 0x1d40f:'p', 0x1d410:'q', +0x1d411:'r', 0x1d412:'s', 0x1d413:'t', 0x1d414:'u', +0x1d415:'v', 0x1d416:'w', 0x1d417:'x', 0x1d418:'y', +0x1d419:'z', 0x1d434:'a', 0x1d435:'b', 0x1d436:'c', +0x1d437:'d', 0x1d438:'e', 0x1d439:'f', 0x1d43a:'g', +0x1d43b:'h', 0x1d43c:'i', 0x1d43d:'j', 0x1d43e:'k', +0x1d43f:'l', 0x1d440:'m', 0x1d441:'n', 0x1d442:'o', +0x1d443:'p', 0x1d444:'q', 0x1d445:'r', 0x1d446:'s', +0x1d447:'t', 0x1d448:'u', 0x1d449:'v', 0x1d44a:'w', +0x1d44b:'x', 0x1d44c:'y', 0x1d44d:'z', 0x1d468:'a', +0x1d469:'b', 0x1d46a:'c', 0x1d46b:'d', 0x1d46c:'e', +0x1d46d:'f', 0x1d46e:'g', 0x1d46f:'h', 0x1d470:'i', +0x1d471:'j', 0x1d472:'k', 0x1d473:'l', 0x1d474:'m', +0x1d475:'n', 0x1d476:'o', 0x1d477:'p', 0x1d478:'q', +0x1d479:'r', 0x1d47a:'s', 0x1d47b:'t', 0x1d47c:'u', +0x1d47d:'v', 0x1d47e:'w', 0x1d47f:'x', 0x1d480:'y', +0x1d481:'z', 0x1d49c:'a', 0x1d49e:'c', 0x1d49f:'d', +0x1d4a2:'g', 0x1d4a5:'j', 0x1d4a6:'k', 0x1d4a9:'n', +0x1d4aa:'o', 0x1d4ab:'p', 0x1d4ac:'q', 0x1d4ae:'s', +0x1d4af:'t', 0x1d4b0:'u', 0x1d4b1:'v', 0x1d4b2:'w', +0x1d4b3:'x', 0x1d4b4:'y', 0x1d4b5:'z', 0x1d4d0:'a', +0x1d4d1:'b', 0x1d4d2:'c', 0x1d4d3:'d', 0x1d4d4:'e', +0x1d4d5:'f', 0x1d4d6:'g', 0x1d4d7:'h', 0x1d4d8:'i', +0x1d4d9:'j', 0x1d4da:'k', 0x1d4db:'l', 0x1d4dc:'m', +0x1d4dd:'n', 0x1d4de:'o', 0x1d4df:'p', 0x1d4e0:'q', +0x1d4e1:'r', 0x1d4e2:'s', 0x1d4e3:'t', 0x1d4e4:'u', +0x1d4e5:'v', 0x1d4e6:'w', 0x1d4e7:'x', 0x1d4e8:'y', +0x1d4e9:'z', 0x1d504:'a', 0x1d505:'b', 0x1d507:'d', +0x1d508:'e', 0x1d509:'f', 0x1d50a:'g', 0x1d50d:'j', +0x1d50e:'k', 0x1d50f:'l', 0x1d510:'m', 0x1d511:'n', +0x1d512:'o', 0x1d513:'p', 0x1d514:'q', 0x1d516:'s', +0x1d517:'t', 0x1d518:'u', 0x1d519:'v', 0x1d51a:'w', +0x1d51b:'x', 0x1d51c:'y', 0x1d538:'a', 0x1d539:'b', +0x1d53b:'d', 0x1d53c:'e', 0x1d53d:'f', 0x1d53e:'g', +0x1d540:'i', 0x1d541:'j', 0x1d542:'k', 0x1d543:'l', +0x1d544:'m', 0x1d546:'o', 0x1d54a:'s', 0x1d54b:'t', +0x1d54c:'u', 0x1d54d:'v', 0x1d54e:'w', 0x1d54f:'x', +0x1d550:'y', 0x1d56c:'a', 0x1d56d:'b', 0x1d56e:'c', +0x1d56f:'d', 0x1d570:'e', 0x1d571:'f', 0x1d572:'g', +0x1d573:'h', 0x1d574:'i', 0x1d575:'j', 0x1d576:'k', +0x1d577:'l', 0x1d578:'m', 0x1d579:'n', 0x1d57a:'o', +0x1d57b:'p', 0x1d57c:'q', 0x1d57d:'r', 0x1d57e:'s', +0x1d57f:'t', 0x1d580:'u', 0x1d581:'v', 0x1d582:'w', +0x1d583:'x', 0x1d584:'y', 0x1d585:'z', 0x1d5a0:'a', +0x1d5a1:'b', 0x1d5a2:'c', 0x1d5a3:'d', 0x1d5a4:'e', +0x1d5a5:'f', 0x1d5a6:'g', 0x1d5a7:'h', 0x1d5a8:'i', +0x1d5a9:'j', 0x1d5aa:'k', 0x1d5ab:'l', 0x1d5ac:'m', +0x1d5ad:'n', 0x1d5ae:'o', 0x1d5af:'p', 0x1d5b0:'q', +0x1d5b1:'r', 0x1d5b2:'s', 0x1d5b3:'t', 0x1d5b4:'u', +0x1d5b5:'v', 0x1d5b6:'w', 0x1d5b7:'x', 0x1d5b8:'y', +0x1d5b9:'z', 0x1d5d4:'a', 0x1d5d5:'b', 0x1d5d6:'c', +0x1d5d7:'d', 0x1d5d8:'e', 0x1d5d9:'f', 0x1d5da:'g', +0x1d5db:'h', 0x1d5dc:'i', 0x1d5dd:'j', 0x1d5de:'k', +0x1d5df:'l', 0x1d5e0:'m', 0x1d5e1:'n', 0x1d5e2:'o', +0x1d5e3:'p', 0x1d5e4:'q', 0x1d5e5:'r', 0x1d5e6:'s', +0x1d5e7:'t', 0x1d5e8:'u', 0x1d5e9:'v', 0x1d5ea:'w', +0x1d5eb:'x', 0x1d5ec:'y', 0x1d5ed:'z', 0x1d608:'a', +0x1d609:'b', 0x1d60a:'c', 0x1d60b:'d', 0x1d60c:'e', +0x1d60d:'f', 0x1d60e:'g', 0x1d60f:'h', 0x1d610:'i', +0x1d611:'j', 0x1d612:'k', 0x1d613:'l', 0x1d614:'m', +0x1d615:'n', 0x1d616:'o', 0x1d617:'p', 0x1d618:'q', +0x1d619:'r', 0x1d61a:'s', 0x1d61b:'t', 0x1d61c:'u', +0x1d61d:'v', 0x1d61e:'w', 0x1d61f:'x', 0x1d620:'y', +0x1d621:'z', 0x1d63c:'a', 0x1d63d:'b', 0x1d63e:'c', +0x1d63f:'d', 0x1d640:'e', 0x1d641:'f', 0x1d642:'g', +0x1d643:'h', 0x1d644:'i', 0x1d645:'j', 0x1d646:'k', +0x1d647:'l', 0x1d648:'m', 0x1d649:'n', 0x1d64a:'o', +0x1d64b:'p', 0x1d64c:'q', 0x1d64d:'r', 0x1d64e:'s', +0x1d64f:'t', 0x1d650:'u', 0x1d651:'v', 0x1d652:'w', +0x1d653:'x', 0x1d654:'y', 0x1d655:'z', 0x1d670:'a', +0x1d671:'b', 0x1d672:'c', 0x1d673:'d', 0x1d674:'e', +0x1d675:'f', 0x1d676:'g', 0x1d677:'h', 0x1d678:'i', +0x1d679:'j', 0x1d67a:'k', 0x1d67b:'l', 0x1d67c:'m', +0x1d67d:'n', 0x1d67e:'o', 0x1d67f:'p', 0x1d680:'q', +0x1d681:'r', 0x1d682:'s', 0x1d683:'t', 0x1d684:'u', +0x1d685:'v', 0x1d686:'w', 0x1d687:'x', 0x1d688:'y', +0x1d689:'z', 0x1d6a8:'\u03b1', 0x1d6a9:'\u03b2', 0x1d6aa:'\u03b3', +0x1d6ab:'\u03b4', 0x1d6ac:'\u03b5', 0x1d6ad:'\u03b6', 0x1d6ae:'\u03b7', +0x1d6af:'\u03b8', 0x1d6b0:'\u03b9', 0x1d6b1:'\u03ba', 0x1d6b2:'\u03bb', +0x1d6b3:'\u03bc', 0x1d6b4:'\u03bd', 0x1d6b5:'\u03be', 0x1d6b6:'\u03bf', +0x1d6b7:'\u03c0', 0x1d6b8:'\u03c1', 0x1d6b9:'\u03b8', 0x1d6ba:'\u03c3', +0x1d6bb:'\u03c4', 0x1d6bc:'\u03c5', 0x1d6bd:'\u03c6', 0x1d6be:'\u03c7', +0x1d6bf:'\u03c8', 0x1d6c0:'\u03c9', 0x1d6d3:'\u03c3', 0x1d6e2:'\u03b1', +0x1d6e3:'\u03b2', 0x1d6e4:'\u03b3', 0x1d6e5:'\u03b4', 0x1d6e6:'\u03b5', +0x1d6e7:'\u03b6', 0x1d6e8:'\u03b7', 0x1d6e9:'\u03b8', 0x1d6ea:'\u03b9', +0x1d6eb:'\u03ba', 0x1d6ec:'\u03bb', 0x1d6ed:'\u03bc', 0x1d6ee:'\u03bd', +0x1d6ef:'\u03be', 0x1d6f0:'\u03bf', 0x1d6f1:'\u03c0', 0x1d6f2:'\u03c1', +0x1d6f3:'\u03b8', 0x1d6f4:'\u03c3', 0x1d6f5:'\u03c4', 0x1d6f6:'\u03c5', +0x1d6f7:'\u03c6', 0x1d6f8:'\u03c7', 0x1d6f9:'\u03c8', 0x1d6fa:'\u03c9', +0x1d70d:'\u03c3', 0x1d71c:'\u03b1', 0x1d71d:'\u03b2', 0x1d71e:'\u03b3', +0x1d71f:'\u03b4', 0x1d720:'\u03b5', 0x1d721:'\u03b6', 0x1d722:'\u03b7', +0x1d723:'\u03b8', 0x1d724:'\u03b9', 0x1d725:'\u03ba', 0x1d726:'\u03bb', +0x1d727:'\u03bc', 0x1d728:'\u03bd', 0x1d729:'\u03be', 0x1d72a:'\u03bf', +0x1d72b:'\u03c0', 0x1d72c:'\u03c1', 0x1d72d:'\u03b8', 0x1d72e:'\u03c3', +0x1d72f:'\u03c4', 0x1d730:'\u03c5', 0x1d731:'\u03c6', 0x1d732:'\u03c7', +0x1d733:'\u03c8', 0x1d734:'\u03c9', 0x1d747:'\u03c3', 0x1d756:'\u03b1', +0x1d757:'\u03b2', 0x1d758:'\u03b3', 0x1d759:'\u03b4', 0x1d75a:'\u03b5', +0x1d75b:'\u03b6', 0x1d75c:'\u03b7', 0x1d75d:'\u03b8', 0x1d75e:'\u03b9', +0x1d75f:'\u03ba', 0x1d760:'\u03bb', 0x1d761:'\u03bc', 0x1d762:'\u03bd', +0x1d763:'\u03be', 0x1d764:'\u03bf', 0x1d765:'\u03c0', 0x1d766:'\u03c1', +0x1d767:'\u03b8', 0x1d768:'\u03c3', 0x1d769:'\u03c4', 0x1d76a:'\u03c5', +0x1d76b:'\u03c6', 0x1d76c:'\u03c7', 0x1d76d:'\u03c8', 0x1d76e:'\u03c9', +0x1d781:'\u03c3', 0x1d790:'\u03b1', 0x1d791:'\u03b2', 0x1d792:'\u03b3', +0x1d793:'\u03b4', 0x1d794:'\u03b5', 0x1d795:'\u03b6', 0x1d796:'\u03b7', +0x1d797:'\u03b8', 0x1d798:'\u03b9', 0x1d799:'\u03ba', 0x1d79a:'\u03bb', +0x1d79b:'\u03bc', 0x1d79c:'\u03bd', 0x1d79d:'\u03be', 0x1d79e:'\u03bf', +0x1d79f:'\u03c0', 0x1d7a0:'\u03c1', 0x1d7a1:'\u03b8', 0x1d7a2:'\u03c3', +0x1d7a3:'\u03c4', 0x1d7a4:'\u03c5', 0x1d7a5:'\u03c6', 0x1d7a6:'\u03c7', +0x1d7a7:'\u03c8', 0x1d7a8:'\u03c9', 0x1d7bb:'\u03c3', 0x1e900:'\U0001e900', +0x1e901:'\U0001e901', 0x1e902:'\U0001e902', 0x1e903:'\U0001e903', 0x1e904:'\U0001e904', +0x1e905:'\U0001e905', 0x1e906:'\U0001e906', 0x1e907:'\U0001e907', 0x1e908:'\U0001e908', +0x1e909:'\U0001e909', 0x1e90a:'\U0001e90a', 0x1e90b:'\U0001e90b', 0x1e90c:'\U0001e90c', +0x1e90d:'\U0001e90d', 0x1e90e:'\U0001e90e', 0x1e90f:'\U0001e90f', 0x1e910:'\U0001e910', +0x1e911:'\U0001e911', 0x1e912:'\U0001e912', 0x1e913:'\U0001e913', 0x1e914:'\U0001e914', +0x1e915:'\U0001e915', 0x1e916:'\U0001e916', 0x1e917:'\U0001e917', 0x1e918:'\U0001e918', +0x1e919:'\U0001e919', 0x1e91a:'\U0001e91a', 0x1e91b:'\U0001e91b', 0x1e91c:'\U0001e91c', +0x1e91d:'\U0001e91d', 0x1e91e:'\U0001e91e', 0x1e91f:'\U0001e91f', 0x1e920:'\U0001e920', +0x1e921:'\U0001e921', } + +def map_table_b3(code): + r = b3_exceptions.get(ord(code)) + if r is not None: return r + return code.lower() + + +def map_table_b2(a): + al = map_table_b3(a) + b = unicodedata_320.normalize("NFKC", al) + bl = "".join([map_table_b3(ch) for ch in b]) + c = unicodedata_320.normalize("NFKC", bl) + if b != c: + return c + else: + return al + + +def in_table_c11(code): + return code == " " + + +def in_table_c12(code): + return unicodedata_320.category(code) == "Zs" and code != " " + +def in_table_c11_c12(code): + return unicodedata_320.category(code) == "Zs" + + +def in_table_c21(code): + return ord(code) < 128 and unicodedata_320.category(code) == "Cc" + +c22_specials = set([1757, 1807, 6158, 8204, 8205, 8232, 8233, 65279] + list(range(8288,8292)) + list(range(8298,8304)) + list(range(65529,65533)) + list(range(119155,119163))) +def in_table_c22(code): + c = ord(code) + if c < 128: return False + if unicodedata_320.category(code) == "Cc": return True + return c in c22_specials + +def in_table_c21_c22(code): + return unicodedata_320.category(code) == "Cc" or \ + ord(code) in c22_specials + + +def in_table_c3(code): + return unicodedata_320.category(code) == "Co" + + +def in_table_c4(code): + c = ord(code) + if c < 0xFDD0: return False + if c < 0xFDF0: return True + return (ord(code) & 0xFFFF) in (0xFFFE, 0xFFFF) + + +def in_table_c5(code): + return unicodedata_320.category(code) == "Cs" + + +c6_set = set(range(65529,65534)) +def in_table_c6(code): + return ord(code) in c6_set + + +c7_set = set(range(12272,12284)) +def in_table_c7(code): + return ord(code) in c7_set + + +c8_set = set([832, 833, 8206, 8207] + list(range(8234,8239)) + list(range(8298,8304))) +def in_table_c8(code): + return ord(code) in c8_set + + +c9_set = set([917505] + list(range(917536,917632))) +def in_table_c9(code): + return ord(code) in c9_set + + +def in_table_d1(code): + return unicodedata_320.bidirectional(code) in ("R","AL") + + +def in_table_d2(code): + return unicodedata_320.bidirectional(code) == "L" diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/struct.py b/physworld_p1_20261018/envs/p1/lib/python3.11/struct.py new file mode 100644 index 0000000000000000000000000000000000000000..d6bba58863649898a3f075cdda51cade9dc07f06 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/struct.py @@ -0,0 +1,15 @@ +__all__ = [ + # Functions + 'calcsize', 'pack', 'pack_into', 'unpack', 'unpack_from', + 'iter_unpack', + + # Classes + 'Struct', + + # Exceptions + 'error' + ] + +from _struct import * +from _struct import _clearcache +from _struct import __doc__ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/subprocess.py b/physworld_p1_20261018/envs/p1/lib/python3.11/subprocess.py new file mode 100644 index 0000000000000000000000000000000000000000..1d17ae3608a51aaf7de5629f69d1f7ee42cdd3d1 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/subprocess.py @@ -0,0 +1,2216 @@ +# subprocess - Subprocesses with accessible I/O streams +# +# For more information about this module, see PEP 324. +# +# Copyright (c) 2003-2005 by Peter Astrand +# +# Licensed to PSF under a Contributor Agreement. + +r"""Subprocesses with accessible I/O streams + +This module allows you to spawn processes, connect to their +input/output/error pipes, and obtain their return codes. + +For a complete description of this module see the Python documentation. + +Main API +======== +run(...): Runs a command, waits for it to complete, then returns a + CompletedProcess instance. +Popen(...): A class for flexibly executing a command in a new process + +Constants +--------- +DEVNULL: Special value that indicates that os.devnull should be used +PIPE: Special value that indicates a pipe should be created +STDOUT: Special value that indicates that stderr should go to stdout + + +Older API +========= +call(...): Runs a command, waits for it to complete, then returns + the return code. +check_call(...): Same as call() but raises CalledProcessError() + if return code is not 0 +check_output(...): Same as check_call() but returns the contents of + stdout instead of a return code +getoutput(...): Runs a command in the shell, waits for it to complete, + then returns the output +getstatusoutput(...): Runs a command in the shell, waits for it to complete, + then returns a (exitcode, output) tuple +""" + +import builtins +import errno +import io +import locale +import os +import time +import signal +import sys +import threading +import warnings +import contextlib +from time import monotonic as _time +import types + +try: + import fcntl +except ImportError: + fcntl = None + + +__all__ = ["Popen", "PIPE", "STDOUT", "call", "check_call", "getstatusoutput", + "getoutput", "check_output", "run", "CalledProcessError", "DEVNULL", + "SubprocessError", "TimeoutExpired", "CompletedProcess"] + # NOTE: We intentionally exclude list2cmdline as it is + # considered an internal implementation detail. issue10838. + +# use presence of msvcrt to detect Windows-like platforms (see bpo-8110) +try: + import msvcrt +except ModuleNotFoundError: + _mswindows = False +else: + _mswindows = True + +# wasm32-emscripten and wasm32-wasi do not support processes +_can_fork_exec = sys.platform not in {"emscripten", "wasi"} + +if _mswindows: + import _winapi + from _winapi import (CREATE_NEW_CONSOLE, CREATE_NEW_PROCESS_GROUP, + STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, + STD_ERROR_HANDLE, SW_HIDE, + STARTF_USESTDHANDLES, STARTF_USESHOWWINDOW, + ABOVE_NORMAL_PRIORITY_CLASS, BELOW_NORMAL_PRIORITY_CLASS, + HIGH_PRIORITY_CLASS, IDLE_PRIORITY_CLASS, + NORMAL_PRIORITY_CLASS, REALTIME_PRIORITY_CLASS, + CREATE_NO_WINDOW, DETACHED_PROCESS, + CREATE_DEFAULT_ERROR_MODE, CREATE_BREAKAWAY_FROM_JOB) + + __all__.extend(["CREATE_NEW_CONSOLE", "CREATE_NEW_PROCESS_GROUP", + "STD_INPUT_HANDLE", "STD_OUTPUT_HANDLE", + "STD_ERROR_HANDLE", "SW_HIDE", + "STARTF_USESTDHANDLES", "STARTF_USESHOWWINDOW", + "STARTUPINFO", + "ABOVE_NORMAL_PRIORITY_CLASS", "BELOW_NORMAL_PRIORITY_CLASS", + "HIGH_PRIORITY_CLASS", "IDLE_PRIORITY_CLASS", + "NORMAL_PRIORITY_CLASS", "REALTIME_PRIORITY_CLASS", + "CREATE_NO_WINDOW", "DETACHED_PROCESS", + "CREATE_DEFAULT_ERROR_MODE", "CREATE_BREAKAWAY_FROM_JOB"]) +else: + if _can_fork_exec: + from _posixsubprocess import fork_exec as _fork_exec + # used in methods that are called by __del__ + _waitpid = os.waitpid + _waitstatus_to_exitcode = os.waitstatus_to_exitcode + _WIFSTOPPED = os.WIFSTOPPED + _WSTOPSIG = os.WSTOPSIG + _WNOHANG = os.WNOHANG + else: + _fork_exec = None + _waitpid = None + _waitstatus_to_exitcode = None + _WIFSTOPPED = None + _WSTOPSIG = None + _WNOHANG = None + import select + import selectors + + +# Exception classes used by this module. +class SubprocessError(Exception): pass + + +class CalledProcessError(SubprocessError): + """Raised when run() is called with check=True and the process + returns a non-zero exit status. + + Attributes: + cmd, returncode, stdout, stderr, output + """ + def __init__(self, returncode, cmd, output=None, stderr=None): + self.returncode = returncode + self.cmd = cmd + self.output = output + self.stderr = stderr + + def __str__(self): + if self.returncode and self.returncode < 0: + try: + return "Command '%s' died with %r." % ( + self.cmd, signal.Signals(-self.returncode)) + except ValueError: + return "Command '%s' died with unknown signal %d." % ( + self.cmd, -self.returncode) + else: + return "Command '%s' returned non-zero exit status %d." % ( + self.cmd, self.returncode) + + @property + def stdout(self): + """Alias for output attribute, to match stderr""" + return self.output + + @stdout.setter + def stdout(self, value): + # There's no obvious reason to set this, but allow it anyway so + # .stdout is a transparent alias for .output + self.output = value + + +class TimeoutExpired(SubprocessError): + """This exception is raised when the timeout expires while waiting for a + child process. + + Attributes: + cmd, output, stdout, stderr, timeout + """ + def __init__(self, cmd, timeout, output=None, stderr=None): + self.cmd = cmd + self.timeout = timeout + self.output = output + self.stderr = stderr + + def __str__(self): + return ("Command '%s' timed out after %s seconds" % + (self.cmd, self.timeout)) + + @property + def stdout(self): + return self.output + + @stdout.setter + def stdout(self, value): + # There's no obvious reason to set this, but allow it anyway so + # .stdout is a transparent alias for .output + self.output = value + + +if _mswindows: + class STARTUPINFO: + def __init__(self, *, dwFlags=0, hStdInput=None, hStdOutput=None, + hStdError=None, wShowWindow=0, lpAttributeList=None): + self.dwFlags = dwFlags + self.hStdInput = hStdInput + self.hStdOutput = hStdOutput + self.hStdError = hStdError + self.wShowWindow = wShowWindow + self.lpAttributeList = lpAttributeList or {"handle_list": []} + + def copy(self): + attr_list = self.lpAttributeList.copy() + if 'handle_list' in attr_list: + attr_list['handle_list'] = list(attr_list['handle_list']) + + return STARTUPINFO(dwFlags=self.dwFlags, + hStdInput=self.hStdInput, + hStdOutput=self.hStdOutput, + hStdError=self.hStdError, + wShowWindow=self.wShowWindow, + lpAttributeList=attr_list) + + + class Handle(int): + closed = False + + def Close(self, CloseHandle=_winapi.CloseHandle): + if not self.closed: + self.closed = True + CloseHandle(self) + + def Detach(self): + if not self.closed: + self.closed = True + return int(self) + raise ValueError("already closed") + + def __repr__(self): + return "%s(%d)" % (self.__class__.__name__, int(self)) + + __del__ = Close +else: + # When select or poll has indicated that the file is writable, + # we can write up to _PIPE_BUF bytes without risk of blocking. + # POSIX defines PIPE_BUF as >= 512. + _PIPE_BUF = getattr(select, 'PIPE_BUF', 512) + + # poll/select have the advantage of not requiring any extra file + # descriptor, contrarily to epoll/kqueue (also, they require a single + # syscall). + if hasattr(selectors, 'PollSelector'): + _PopenSelector = selectors.PollSelector + else: + _PopenSelector = selectors.SelectSelector + + +if _mswindows: + # On Windows we just need to close `Popen._handle` when we no longer need + # it, so that the kernel can free it. `Popen._handle` gets closed + # implicitly when the `Popen` instance is finalized (see `Handle.__del__`, + # which is calling `CloseHandle` as requested in [1]), so there is nothing + # for `_cleanup` to do. + # + # [1] https://docs.microsoft.com/en-us/windows/desktop/ProcThread/ + # creating-processes + _active = None + + def _cleanup(): + pass +else: + # This lists holds Popen instances for which the underlying process had not + # exited at the time its __del__ method got called: those processes are + # wait()ed for synchronously from _cleanup() when a new Popen object is + # created, to avoid zombie processes. + _active = [] + + def _cleanup(): + if _active is None: + return + for inst in _active[:]: + res = inst._internal_poll(_deadstate=sys.maxsize) + if res is not None: + try: + _active.remove(inst) + except ValueError: + # This can happen if two threads create a new Popen instance. + # It's harmless that it was already removed, so ignore. + pass + +PIPE = -1 +STDOUT = -2 +DEVNULL = -3 + + +# XXX This function is only used by multiprocessing and the test suite, +# but it's here so that it can be imported when Python is compiled without +# threads. + +def _optim_args_from_interpreter_flags(): + """Return a list of command-line arguments reproducing the current + optimization settings in sys.flags.""" + args = [] + value = sys.flags.optimize + if value > 0: + args.append('-' + 'O' * value) + return args + + +def _args_from_interpreter_flags(): + """Return a list of command-line arguments reproducing the current + settings in sys.flags, sys.warnoptions and sys._xoptions.""" + flag_opt_map = { + 'debug': 'd', + # 'inspect': 'i', + # 'interactive': 'i', + 'dont_write_bytecode': 'B', + 'no_site': 'S', + 'verbose': 'v', + 'bytes_warning': 'b', + 'quiet': 'q', + # -O is handled in _optim_args_from_interpreter_flags() + } + args = _optim_args_from_interpreter_flags() + for flag, opt in flag_opt_map.items(): + v = getattr(sys.flags, flag) + if v > 0: + args.append('-' + opt * v) + + if sys.flags.isolated: + args.append('-I') + else: + if sys.flags.ignore_environment: + args.append('-E') + if sys.flags.no_user_site: + args.append('-s') + if sys.flags.safe_path: + args.append('-P') + + # -W options + warnopts = sys.warnoptions[:] + xoptions = getattr(sys, '_xoptions', {}) + bytes_warning = sys.flags.bytes_warning + dev_mode = sys.flags.dev_mode + + if bytes_warning > 1: + warnopts.remove("error::BytesWarning") + elif bytes_warning: + warnopts.remove("default::BytesWarning") + if dev_mode: + warnopts.remove('default') + for opt in warnopts: + args.append('-W' + opt) + + # -X options + if dev_mode: + args.extend(('-X', 'dev')) + for opt in ('faulthandler', 'tracemalloc', 'importtime', + 'frozen_modules', 'showrefcount', 'utf8'): + if opt in xoptions: + value = xoptions[opt] + if value is True: + arg = opt + else: + arg = '%s=%s' % (opt, value) + args.extend(('-X', arg)) + + return args + + +def _text_encoding(): + # Return default text encoding and emit EncodingWarning if + # sys.flags.warn_default_encoding is true. + if sys.flags.warn_default_encoding: + f = sys._getframe() + filename = f.f_code.co_filename + stacklevel = 2 + while f := f.f_back: + if f.f_code.co_filename != filename: + break + stacklevel += 1 + warnings.warn("'encoding' argument not specified.", + EncodingWarning, stacklevel) + + if sys.flags.utf8_mode: + return "utf-8" + else: + return locale.getencoding() + + +def call(*popenargs, timeout=None, **kwargs): + """Run command with arguments. Wait for command to complete or + timeout, then return the returncode attribute. + + The arguments are the same as for the Popen constructor. Example: + + retcode = call(["ls", "-l"]) + """ + with Popen(*popenargs, **kwargs) as p: + try: + return p.wait(timeout=timeout) + except: # Including KeyboardInterrupt, wait handled that. + p.kill() + # We don't call p.wait() again as p.__exit__ does that for us. + raise + + +def check_call(*popenargs, **kwargs): + """Run command with arguments. Wait for command to complete. If + the exit code was zero then return, otherwise raise + CalledProcessError. The CalledProcessError object will have the + return code in the returncode attribute. + + The arguments are the same as for the call function. Example: + + check_call(["ls", "-l"]) + """ + retcode = call(*popenargs, **kwargs) + if retcode: + cmd = kwargs.get("args") + if cmd is None: + cmd = popenargs[0] + raise CalledProcessError(retcode, cmd) + return 0 + + +def check_output(*popenargs, timeout=None, **kwargs): + r"""Run command with arguments and return its output. + + If the exit code was non-zero it raises a CalledProcessError. The + CalledProcessError object will have the return code in the returncode + attribute and output in the output attribute. + + The arguments are the same as for the Popen constructor. Example: + + >>> check_output(["ls", "-l", "/dev/null"]) + b'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n' + + The stdout argument is not allowed as it is used internally. + To capture standard error in the result, use stderr=STDOUT. + + >>> check_output(["/bin/sh", "-c", + ... "ls -l non_existent_file ; exit 0"], + ... stderr=STDOUT) + b'ls: non_existent_file: No such file or directory\n' + + There is an additional optional argument, "input", allowing you to + pass a string to the subprocess's stdin. If you use this argument + you may not also use the Popen constructor's "stdin" argument, as + it too will be used internally. Example: + + >>> check_output(["sed", "-e", "s/foo/bar/"], + ... input=b"when in the course of fooman events\n") + b'when in the course of barman events\n' + + By default, all communication is in bytes, and therefore any "input" + should be bytes, and the return value will be bytes. If in text mode, + any "input" should be a string, and the return value will be a string + decoded according to locale encoding, or by "encoding" if set. Text mode + is triggered by setting any of text, encoding, errors or universal_newlines. + """ + for kw in ('stdout', 'check'): + if kw in kwargs: + raise ValueError(f'{kw} argument not allowed, it will be overridden.') + + if 'input' in kwargs and kwargs['input'] is None: + # Explicitly passing input=None was previously equivalent to passing an + # empty string. That is maintained here for backwards compatibility. + if kwargs.get('universal_newlines') or kwargs.get('text') or kwargs.get('encoding') \ + or kwargs.get('errors'): + empty = '' + else: + empty = b'' + kwargs['input'] = empty + + return run(*popenargs, stdout=PIPE, timeout=timeout, check=True, + **kwargs).stdout + + +class CompletedProcess(object): + """A process that has finished running. + + This is returned by run(). + + Attributes: + args: The list or str args passed to run(). + returncode: The exit code of the process, negative for signals. + stdout: The standard output (None if not captured). + stderr: The standard error (None if not captured). + """ + def __init__(self, args, returncode, stdout=None, stderr=None): + self.args = args + self.returncode = returncode + self.stdout = stdout + self.stderr = stderr + + def __repr__(self): + args = ['args={!r}'.format(self.args), + 'returncode={!r}'.format(self.returncode)] + if self.stdout is not None: + args.append('stdout={!r}'.format(self.stdout)) + if self.stderr is not None: + args.append('stderr={!r}'.format(self.stderr)) + return "{}({})".format(type(self).__name__, ', '.join(args)) + + __class_getitem__ = classmethod(types.GenericAlias) + + + def check_returncode(self): + """Raise CalledProcessError if the exit code is non-zero.""" + if self.returncode: + raise CalledProcessError(self.returncode, self.args, self.stdout, + self.stderr) + + +def run(*popenargs, + input=None, capture_output=False, timeout=None, check=False, **kwargs): + """Run command with arguments and return a CompletedProcess instance. + + The returned instance will have attributes args, returncode, stdout and + stderr. By default, stdout and stderr are not captured, and those attributes + will be None. Pass stdout=PIPE and/or stderr=PIPE in order to capture them, + or pass capture_output=True to capture both. + + If check is True and the exit code was non-zero, it raises a + CalledProcessError. The CalledProcessError object will have the return code + in the returncode attribute, and output & stderr attributes if those streams + were captured. + + If timeout is given, and the process takes too long, a TimeoutExpired + exception will be raised. + + There is an optional argument "input", allowing you to + pass bytes or a string to the subprocess's stdin. If you use this argument + you may not also use the Popen constructor's "stdin" argument, as + it will be used internally. + + By default, all communication is in bytes, and therefore any "input" should + be bytes, and the stdout and stderr will be bytes. If in text mode, any + "input" should be a string, and stdout and stderr will be strings decoded + according to locale encoding, or by "encoding" if set. Text mode is + triggered by setting any of text, encoding, errors or universal_newlines. + + The other arguments are the same as for the Popen constructor. + """ + if input is not None: + if kwargs.get('stdin') is not None: + raise ValueError('stdin and input arguments may not both be used.') + kwargs['stdin'] = PIPE + + if capture_output: + if kwargs.get('stdout') is not None or kwargs.get('stderr') is not None: + raise ValueError('stdout and stderr arguments may not be used ' + 'with capture_output.') + kwargs['stdout'] = PIPE + kwargs['stderr'] = PIPE + + with Popen(*popenargs, **kwargs) as process: + try: + stdout, stderr = process.communicate(input, timeout=timeout) + except TimeoutExpired as exc: + process.kill() + if _mswindows: + # Windows accumulates the output in a single blocking + # read() call run on child threads, with the timeout + # being done in a join() on those threads. communicate() + # _after_ kill() is required to collect that and add it + # to the exception. + exc.stdout, exc.stderr = process.communicate() + else: + # POSIX _communicate already populated the output so + # far into the TimeoutExpired exception. + process.wait() + raise + except: # Including KeyboardInterrupt, communicate handled that. + process.kill() + # We don't call process.wait() as .__exit__ does that for us. + raise + retcode = process.poll() + if check and retcode: + raise CalledProcessError(retcode, process.args, + output=stdout, stderr=stderr) + return CompletedProcess(process.args, retcode, stdout, stderr) + + +def list2cmdline(seq): + """ + Translate a sequence of arguments into a command line + string, using the same rules as the MS C runtime: + + 1) Arguments are delimited by white space, which is either a + space or a tab. + + 2) A string surrounded by double quotation marks is + interpreted as a single argument, regardless of white space + contained within. A quoted string can be embedded in an + argument. + + 3) A double quotation mark preceded by a backslash is + interpreted as a literal double quotation mark. + + 4) Backslashes are interpreted literally, unless they + immediately precede a double quotation mark. + + 5) If backslashes immediately precede a double quotation mark, + every pair of backslashes is interpreted as a literal + backslash. If the number of backslashes is odd, the last + backslash escapes the next double quotation mark as + described in rule 3. + """ + + # See + # http://msdn.microsoft.com/en-us/library/17w5ykft.aspx + # or search http://msdn.microsoft.com for + # "Parsing C++ Command-Line Arguments" + result = [] + needquote = False + for arg in map(os.fsdecode, seq): + bs_buf = [] + + # Add a space to separate this argument from the others + if result: + result.append(' ') + + needquote = (" " in arg) or ("\t" in arg) or not arg + if needquote: + result.append('"') + + for c in arg: + if c == '\\': + # Don't know if we need to double yet. + bs_buf.append(c) + elif c == '"': + # Double backslashes. + result.append('\\' * len(bs_buf)*2) + bs_buf = [] + result.append('\\"') + else: + # Normal char + if bs_buf: + result.extend(bs_buf) + bs_buf = [] + result.append(c) + + # Add remaining backslashes, if any. + if bs_buf: + result.extend(bs_buf) + + if needquote: + result.extend(bs_buf) + result.append('"') + + return ''.join(result) + + +# Various tools for executing commands and looking at their output and status. +# + +def getstatusoutput(cmd, *, encoding=None, errors=None): + """Return (exitcode, output) of executing cmd in a shell. + + Execute the string 'cmd' in a shell with 'check_output' and + return a 2-tuple (status, output). The locale encoding is used + to decode the output and process newlines. + + A trailing newline is stripped from the output. + The exit status for the command can be interpreted + according to the rules for the function 'wait'. Example: + + >>> import subprocess + >>> subprocess.getstatusoutput('ls /bin/ls') + (0, '/bin/ls') + >>> subprocess.getstatusoutput('cat /bin/junk') + (1, 'cat: /bin/junk: No such file or directory') + >>> subprocess.getstatusoutput('/bin/junk') + (127, 'sh: /bin/junk: not found') + >>> subprocess.getstatusoutput('/bin/kill $$') + (-15, '') + """ + try: + data = check_output(cmd, shell=True, text=True, stderr=STDOUT, + encoding=encoding, errors=errors) + exitcode = 0 + except CalledProcessError as ex: + data = ex.output + exitcode = ex.returncode + if data[-1:] == '\n': + data = data[:-1] + return exitcode, data + +def getoutput(cmd, *, encoding=None, errors=None): + """Return output (stdout or stderr) of executing cmd in a shell. + + Like getstatusoutput(), except the exit status is ignored and the return + value is a string containing the command's output. Example: + + >>> import subprocess + >>> subprocess.getoutput('ls /bin/ls') + '/bin/ls' + """ + return getstatusoutput(cmd, encoding=encoding, errors=errors)[1] + + + +def _use_posix_spawn(): + """Check if posix_spawn() can be used for subprocess. + + subprocess requires a posix_spawn() implementation that properly reports + errors to the parent process, & sets errno on the following failures: + + * Process attribute actions failed. + * File actions failed. + * exec() failed. + + Prefer an implementation which can use vfork() in some cases for best + performance. + """ + if _mswindows or not hasattr(os, 'posix_spawn'): + # os.posix_spawn() is not available + return False + + if sys.platform in ('darwin', 'sunos5'): + # posix_spawn() is a syscall on both macOS and Solaris, + # and properly reports errors + return True + + # Check libc name and runtime libc version + try: + ver = os.confstr('CS_GNU_LIBC_VERSION') + # parse 'glibc 2.28' as ('glibc', (2, 28)) + parts = ver.split(maxsplit=1) + if len(parts) != 2: + # reject unknown format + raise ValueError + libc = parts[0] + version = tuple(map(int, parts[1].split('.'))) + + if sys.platform == 'linux' and libc == 'glibc' and version >= (2, 24): + # glibc 2.24 has a new Linux posix_spawn implementation using vfork + # which properly reports errors to the parent process. + return True + # Note: Don't use the implementation in earlier glibc because it doesn't + # use vfork (even if glibc 2.26 added a pipe to properly report errors + # to the parent process). + except (AttributeError, ValueError, OSError): + # os.confstr() or CS_GNU_LIBC_VERSION value not available + pass + + # By default, assume that posix_spawn() does not properly report errors. + return False + + +# These are primarily fail-safe knobs for negatives. A True value does not +# guarantee the given libc/syscall API will be used. +_USE_POSIX_SPAWN = _use_posix_spawn() +_USE_VFORK = True + + +class Popen: + """ Execute a child program in a new process. + + For a complete description of the arguments see the Python documentation. + + Arguments: + args: A string, or a sequence of program arguments. + + bufsize: supplied as the buffering argument to the open() function when + creating the stdin/stdout/stderr pipe file objects + + executable: A replacement program to execute. + + stdin, stdout and stderr: These specify the executed programs' standard + input, standard output and standard error file handles, respectively. + + preexec_fn: (POSIX only) An object to be called in the child process + just before the child is executed. + + close_fds: Controls closing or inheriting of file descriptors. + + shell: If true, the command will be executed through the shell. + + cwd: Sets the current directory before the child is executed. + + env: Defines the environment variables for the new process. + + text: If true, decode stdin, stdout and stderr using the given encoding + (if set) or the system default otherwise. + + universal_newlines: Alias of text, provided for backwards compatibility. + + startupinfo and creationflags (Windows only) + + restore_signals (POSIX only) + + start_new_session (POSIX only) + + process_group (POSIX only) + + group (POSIX only) + + extra_groups (POSIX only) + + user (POSIX only) + + umask (POSIX only) + + pass_fds (POSIX only) + + encoding and errors: Text mode encoding and error handling to use for + file objects stdin, stdout and stderr. + + Attributes: + stdin, stdout, stderr, pid, returncode + """ + _child_created = False # Set here since __del__ checks it + + def __init__(self, args, bufsize=-1, executable=None, + stdin=None, stdout=None, stderr=None, + preexec_fn=None, close_fds=True, + shell=False, cwd=None, env=None, universal_newlines=None, + startupinfo=None, creationflags=0, + restore_signals=True, start_new_session=False, + pass_fds=(), *, user=None, group=None, extra_groups=None, + encoding=None, errors=None, text=None, umask=-1, pipesize=-1, + process_group=None): + """Create new Popen instance.""" + if not _can_fork_exec: + raise OSError( + errno.ENOTSUP, f"{sys.platform} does not support processes." + ) + + _cleanup() + # Held while anything is calling waitpid before returncode has been + # updated to prevent clobbering returncode if wait() or poll() are + # called from multiple threads at once. After acquiring the lock, + # code must re-check self.returncode to see if another thread just + # finished a waitpid() call. + self._waitpid_lock = threading.Lock() + + self._input = None + self._communication_started = False + if bufsize is None: + bufsize = -1 # Restore default + if not isinstance(bufsize, int): + raise TypeError("bufsize must be an integer") + + if pipesize is None: + pipesize = -1 # Restore default + if not isinstance(pipesize, int): + raise TypeError("pipesize must be an integer") + + if _mswindows: + if preexec_fn is not None: + raise ValueError("preexec_fn is not supported on Windows " + "platforms") + else: + # POSIX + if pass_fds and not close_fds: + warnings.warn("pass_fds overriding close_fds.", RuntimeWarning) + close_fds = True + if startupinfo is not None: + raise ValueError("startupinfo is only supported on Windows " + "platforms") + if creationflags != 0: + raise ValueError("creationflags is only supported on Windows " + "platforms") + + self.args = args + self.stdin = None + self.stdout = None + self.stderr = None + self.pid = None + self.returncode = None + self.encoding = encoding + self.errors = errors + self.pipesize = pipesize + + # Validate the combinations of text and universal_newlines + if (text is not None and universal_newlines is not None + and bool(universal_newlines) != bool(text)): + raise SubprocessError('Cannot disambiguate when both text ' + 'and universal_newlines are supplied but ' + 'different. Pass one or the other.') + + self.text_mode = encoding or errors or text or universal_newlines + if self.text_mode and encoding is None: + self.encoding = encoding = _text_encoding() + + # How long to resume waiting on a child after the first ^C. + # There is no right value for this. The purpose is to be polite + # yet remain good for interactive users trying to exit a tool. + self._sigint_wait_secs = 0.25 # 1/xkcd221.getRandomNumber() + + self._closed_child_pipe_fds = False + + if self.text_mode: + if bufsize == 1: + line_buffering = True + # Use the default buffer size for the underlying binary streams + # since they don't support line buffering. + bufsize = -1 + else: + line_buffering = False + + if process_group is None: + process_group = -1 # The internal APIs are int-only + + gid = None + if group is not None: + if not hasattr(os, 'setregid'): + raise ValueError("The 'group' parameter is not supported on the " + "current platform") + + elif isinstance(group, str): + try: + import grp + except ImportError: + raise ValueError("The group parameter cannot be a string " + "on systems without the grp module") + + gid = grp.getgrnam(group).gr_gid + elif isinstance(group, int): + gid = group + else: + raise TypeError("Group must be a string or an integer, not {}" + .format(type(group))) + + if gid < 0: + raise ValueError(f"Group ID cannot be negative, got {gid}") + + gids = None + if extra_groups is not None: + if not hasattr(os, 'setgroups'): + raise ValueError("The 'extra_groups' parameter is not " + "supported on the current platform") + + elif isinstance(extra_groups, str): + raise ValueError("Groups must be a list, not a string") + + gids = [] + for extra_group in extra_groups: + if isinstance(extra_group, str): + try: + import grp + except ImportError: + raise ValueError("Items in extra_groups cannot be " + "strings on systems without the " + "grp module") + + gids.append(grp.getgrnam(extra_group).gr_gid) + elif isinstance(extra_group, int): + gids.append(extra_group) + else: + raise TypeError("Items in extra_groups must be a string " + "or integer, not {}" + .format(type(extra_group))) + + # make sure that the gids are all positive here so we can do less + # checking in the C code + for gid_check in gids: + if gid_check < 0: + raise ValueError(f"Group ID cannot be negative, got {gid_check}") + + uid = None + if user is not None: + if not hasattr(os, 'setreuid'): + raise ValueError("The 'user' parameter is not supported on " + "the current platform") + + elif isinstance(user, str): + try: + import pwd + except ImportError: + raise ValueError("The user parameter cannot be a string " + "on systems without the pwd module") + uid = pwd.getpwnam(user).pw_uid + elif isinstance(user, int): + uid = user + else: + raise TypeError("User must be a string or an integer") + + if uid < 0: + raise ValueError(f"User ID cannot be negative, got {uid}") + + # Input and output objects. The general principle is like + # this: + # + # Parent Child + # ------ ----- + # p2cwrite ---stdin---> p2cread + # c2pread <--stdout--- c2pwrite + # errread <--stderr--- errwrite + # + # On POSIX, the child objects are file descriptors. On + # Windows, these are Windows file handles. The parent objects + # are file descriptors on both platforms. The parent objects + # are -1 when not using PIPEs. The child objects are -1 + # when not redirecting. + + (p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite) = self._get_handles(stdin, stdout, stderr) + + # From here on, raising exceptions may cause file descriptor leakage + + # We wrap OS handles *before* launching the child, otherwise a + # quickly terminating child could make our fds unwrappable + # (see #8458). + + if _mswindows: + if p2cwrite != -1: + p2cwrite = msvcrt.open_osfhandle(p2cwrite.Detach(), 0) + if c2pread != -1: + c2pread = msvcrt.open_osfhandle(c2pread.Detach(), 0) + if errread != -1: + errread = msvcrt.open_osfhandle(errread.Detach(), 0) + + try: + if p2cwrite != -1: + self.stdin = io.open(p2cwrite, 'wb', bufsize) + if self.text_mode: + self.stdin = io.TextIOWrapper(self.stdin, write_through=True, + line_buffering=line_buffering, + encoding=encoding, errors=errors) + if c2pread != -1: + self.stdout = io.open(c2pread, 'rb', bufsize) + if self.text_mode: + self.stdout = io.TextIOWrapper(self.stdout, + encoding=encoding, errors=errors) + if errread != -1: + self.stderr = io.open(errread, 'rb', bufsize) + if self.text_mode: + self.stderr = io.TextIOWrapper(self.stderr, + encoding=encoding, errors=errors) + + self._execute_child(args, executable, preexec_fn, close_fds, + pass_fds, cwd, env, + startupinfo, creationflags, shell, + p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite, + restore_signals, + gid, gids, uid, umask, + start_new_session, process_group) + except: + # Cleanup if the child failed starting. + for f in filter(None, (self.stdin, self.stdout, self.stderr)): + try: + f.close() + except OSError: + pass # Ignore EBADF or other errors. + + if not self._closed_child_pipe_fds: + to_close = [] + if stdin == PIPE: + to_close.append(p2cread) + if stdout == PIPE: + to_close.append(c2pwrite) + if stderr == PIPE: + to_close.append(errwrite) + if hasattr(self, '_devnull'): + to_close.append(self._devnull) + for fd in to_close: + try: + if _mswindows and isinstance(fd, Handle): + fd.Close() + else: + os.close(fd) + except OSError: + pass + + raise + + def __repr__(self): + obj_repr = ( + f"<{self.__class__.__name__}: " + f"returncode: {self.returncode} args: {self.args!r}>" + ) + if len(obj_repr) > 80: + obj_repr = obj_repr[:76] + "...>" + return obj_repr + + __class_getitem__ = classmethod(types.GenericAlias) + + @property + def universal_newlines(self): + # universal_newlines as retained as an alias of text_mode for API + # compatibility. bpo-31756 + return self.text_mode + + @universal_newlines.setter + def universal_newlines(self, universal_newlines): + self.text_mode = bool(universal_newlines) + + def _translate_newlines(self, data, encoding, errors): + data = data.decode(encoding, errors) + return data.replace("\r\n", "\n").replace("\r", "\n") + + def __enter__(self): + return self + + def __exit__(self, exc_type, value, traceback): + if self.stdout: + self.stdout.close() + if self.stderr: + self.stderr.close() + try: # Flushing a BufferedWriter may raise an error + if self.stdin: + self.stdin.close() + finally: + if exc_type == KeyboardInterrupt: + # https://bugs.python.org/issue25942 + # In the case of a KeyboardInterrupt we assume the SIGINT + # was also already sent to our child processes. We can't + # block indefinitely as that is not user friendly. + # If we have not already waited a brief amount of time in + # an interrupted .wait() or .communicate() call, do so here + # for consistency. + if self._sigint_wait_secs > 0: + try: + self._wait(timeout=self._sigint_wait_secs) + except TimeoutExpired: + pass + self._sigint_wait_secs = 0 # Note that this has been done. + return # resume the KeyboardInterrupt + + # Wait for the process to terminate, to avoid zombies. + self.wait() + + def __del__(self, _maxsize=sys.maxsize, _warn=warnings.warn): + if not self._child_created: + # We didn't get to successfully create a child process. + return + if self.returncode is None: + # Not reading subprocess exit status creates a zombie process which + # is only destroyed at the parent python process exit + _warn("subprocess %s is still running" % self.pid, + ResourceWarning, source=self) + # In case the child hasn't been waited on, check if it's done. + self._internal_poll(_deadstate=_maxsize) + if self.returncode is None and _active is not None: + # Child is still running, keep us alive until we can wait on it. + _active.append(self) + + def _get_devnull(self): + if not hasattr(self, '_devnull'): + self._devnull = os.open(os.devnull, os.O_RDWR) + return self._devnull + + def _stdin_write(self, input): + if input: + try: + self.stdin.write(input) + except BrokenPipeError: + pass # communicate() must ignore broken pipe errors. + except OSError as exc: + if exc.errno == errno.EINVAL: + # bpo-19612, bpo-30418: On Windows, stdin.write() fails + # with EINVAL if the child process exited or if the child + # process is still running but closed the pipe. + pass + else: + raise + + try: + self.stdin.close() + except BrokenPipeError: + pass # communicate() must ignore broken pipe errors. + except OSError as exc: + if exc.errno == errno.EINVAL: + pass + else: + raise + + def communicate(self, input=None, timeout=None): + """Interact with process: Send data to stdin and close it. + Read data from stdout and stderr, until end-of-file is + reached. Wait for process to terminate. + + The optional "input" argument should be data to be sent to the + child process, or None, if no data should be sent to the child. + communicate() returns a tuple (stdout, stderr). + + By default, all communication is in bytes, and therefore any + "input" should be bytes, and the (stdout, stderr) will be bytes. + If in text mode (indicated by self.text_mode), any "input" should + be a string, and (stdout, stderr) will be strings decoded + according to locale encoding, or by "encoding" if set. Text mode + is triggered by setting any of text, encoding, errors or + universal_newlines. + """ + + if self._communication_started and input: + raise ValueError("Cannot send input after starting communication") + + # Optimization: If we are not worried about timeouts, we haven't + # started communicating, and we have one or zero pipes, using select() + # or threads is unnecessary. + if (timeout is None and not self._communication_started and + [self.stdin, self.stdout, self.stderr].count(None) >= 2): + stdout = None + stderr = None + if self.stdin: + self._stdin_write(input) + elif self.stdout: + stdout = self.stdout.read() + self.stdout.close() + elif self.stderr: + stderr = self.stderr.read() + self.stderr.close() + self.wait() + else: + if timeout is not None: + endtime = _time() + timeout + else: + endtime = None + + try: + stdout, stderr = self._communicate(input, endtime, timeout) + except KeyboardInterrupt: + # https://bugs.python.org/issue25942 + # See the detailed comment in .wait(). + if timeout is not None: + sigint_timeout = min(self._sigint_wait_secs, + self._remaining_time(endtime)) + else: + sigint_timeout = self._sigint_wait_secs + self._sigint_wait_secs = 0 # nothing else should wait. + try: + self._wait(timeout=sigint_timeout) + except TimeoutExpired: + pass + raise # resume the KeyboardInterrupt + + finally: + self._communication_started = True + + sts = self.wait(timeout=self._remaining_time(endtime)) + + return (stdout, stderr) + + + def poll(self): + """Check if child process has terminated. Set and return returncode + attribute.""" + return self._internal_poll() + + + def _remaining_time(self, endtime): + """Convenience for _communicate when computing timeouts.""" + if endtime is None: + return None + else: + return endtime - _time() + + + def _check_timeout(self, endtime, orig_timeout, stdout_seq, stderr_seq, + skip_check_and_raise=False): + """Convenience for checking if a timeout has expired.""" + if endtime is None: + return + if skip_check_and_raise or _time() > endtime: + raise TimeoutExpired( + self.args, orig_timeout, + output=b''.join(stdout_seq) if stdout_seq else None, + stderr=b''.join(stderr_seq) if stderr_seq else None) + + + def wait(self, timeout=None): + """Wait for child process to terminate; returns self.returncode.""" + if timeout is not None: + endtime = _time() + timeout + try: + return self._wait(timeout=timeout) + except KeyboardInterrupt: + # https://bugs.python.org/issue25942 + # The first keyboard interrupt waits briefly for the child to + # exit under the common assumption that it also received the ^C + # generated SIGINT and will exit rapidly. + if timeout is not None: + sigint_timeout = min(self._sigint_wait_secs, + self._remaining_time(endtime)) + else: + sigint_timeout = self._sigint_wait_secs + self._sigint_wait_secs = 0 # nothing else should wait. + try: + self._wait(timeout=sigint_timeout) + except TimeoutExpired: + pass + raise # resume the KeyboardInterrupt + + def _close_pipe_fds(self, + p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite): + # self._devnull is not always defined. + devnull_fd = getattr(self, '_devnull', None) + + with contextlib.ExitStack() as stack: + if _mswindows: + if p2cread != -1: + stack.callback(p2cread.Close) + if c2pwrite != -1: + stack.callback(c2pwrite.Close) + if errwrite != -1: + stack.callback(errwrite.Close) + else: + if p2cread != -1 and p2cwrite != -1 and p2cread != devnull_fd: + stack.callback(os.close, p2cread) + if c2pwrite != -1 and c2pread != -1 and c2pwrite != devnull_fd: + stack.callback(os.close, c2pwrite) + if errwrite != -1 and errread != -1 and errwrite != devnull_fd: + stack.callback(os.close, errwrite) + + if devnull_fd is not None: + stack.callback(os.close, devnull_fd) + + # Prevent a double close of these handles/fds from __init__ on error. + self._closed_child_pipe_fds = True + + @contextlib.contextmanager + def _on_error_fd_closer(self): + """Helper to ensure file descriptors opened in _get_handles are closed""" + to_close = [] + try: + yield to_close + except: + if hasattr(self, '_devnull'): + to_close.append(self._devnull) + del self._devnull + for fd in to_close: + try: + if _mswindows and isinstance(fd, Handle): + fd.Close() + else: + os.close(fd) + except OSError: + pass + raise + + if _mswindows: + # + # Windows methods + # + def _get_handles(self, stdin, stdout, stderr): + """Construct and return tuple with IO objects: + p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite + """ + if stdin is None and stdout is None and stderr is None: + return (-1, -1, -1, -1, -1, -1) + + p2cread, p2cwrite = -1, -1 + c2pread, c2pwrite = -1, -1 + errread, errwrite = -1, -1 + + with self._on_error_fd_closer() as err_close_fds: + if stdin is None: + p2cread = _winapi.GetStdHandle(_winapi.STD_INPUT_HANDLE) + if p2cread is None: + p2cread, _ = _winapi.CreatePipe(None, 0) + p2cread = Handle(p2cread) + err_close_fds.append(p2cread) + _winapi.CloseHandle(_) + elif stdin == PIPE: + p2cread, p2cwrite = _winapi.CreatePipe(None, 0) + p2cread, p2cwrite = Handle(p2cread), Handle(p2cwrite) + err_close_fds.extend((p2cread, p2cwrite)) + elif stdin == DEVNULL: + p2cread = msvcrt.get_osfhandle(self._get_devnull()) + elif isinstance(stdin, int): + p2cread = msvcrt.get_osfhandle(stdin) + else: + # Assuming file-like object + p2cread = msvcrt.get_osfhandle(stdin.fileno()) + p2cread = self._make_inheritable(p2cread) + + if stdout is None: + c2pwrite = _winapi.GetStdHandle(_winapi.STD_OUTPUT_HANDLE) + if c2pwrite is None: + _, c2pwrite = _winapi.CreatePipe(None, 0) + c2pwrite = Handle(c2pwrite) + err_close_fds.append(c2pwrite) + _winapi.CloseHandle(_) + elif stdout == PIPE: + c2pread, c2pwrite = _winapi.CreatePipe(None, 0) + c2pread, c2pwrite = Handle(c2pread), Handle(c2pwrite) + err_close_fds.extend((c2pread, c2pwrite)) + elif stdout == DEVNULL: + c2pwrite = msvcrt.get_osfhandle(self._get_devnull()) + elif isinstance(stdout, int): + c2pwrite = msvcrt.get_osfhandle(stdout) + else: + # Assuming file-like object + c2pwrite = msvcrt.get_osfhandle(stdout.fileno()) + c2pwrite = self._make_inheritable(c2pwrite) + + if stderr is None: + errwrite = _winapi.GetStdHandle(_winapi.STD_ERROR_HANDLE) + if errwrite is None: + _, errwrite = _winapi.CreatePipe(None, 0) + errwrite = Handle(errwrite) + err_close_fds.append(errwrite) + _winapi.CloseHandle(_) + elif stderr == PIPE: + errread, errwrite = _winapi.CreatePipe(None, 0) + errread, errwrite = Handle(errread), Handle(errwrite) + err_close_fds.extend((errread, errwrite)) + elif stderr == STDOUT: + errwrite = c2pwrite + elif stderr == DEVNULL: + errwrite = msvcrt.get_osfhandle(self._get_devnull()) + elif isinstance(stderr, int): + errwrite = msvcrt.get_osfhandle(stderr) + else: + # Assuming file-like object + errwrite = msvcrt.get_osfhandle(stderr.fileno()) + errwrite = self._make_inheritable(errwrite) + + return (p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite) + + + def _make_inheritable(self, handle): + """Return a duplicate of handle, which is inheritable""" + h = _winapi.DuplicateHandle( + _winapi.GetCurrentProcess(), handle, + _winapi.GetCurrentProcess(), 0, 1, + _winapi.DUPLICATE_SAME_ACCESS) + return Handle(h) + + + def _filter_handle_list(self, handle_list): + """Filter out console handles that can't be used + in lpAttributeList["handle_list"] and make sure the list + isn't empty. This also removes duplicate handles.""" + # An handle with it's lowest two bits set might be a special console + # handle that if passed in lpAttributeList["handle_list"], will + # cause it to fail. + return list({handle for handle in handle_list + if handle & 0x3 != 0x3 + or _winapi.GetFileType(handle) != + _winapi.FILE_TYPE_CHAR}) + + + def _execute_child(self, args, executable, preexec_fn, close_fds, + pass_fds, cwd, env, + startupinfo, creationflags, shell, + p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite, + unused_restore_signals, + unused_gid, unused_gids, unused_uid, + unused_umask, + unused_start_new_session, unused_process_group): + """Execute program (MS Windows version)""" + + assert not pass_fds, "pass_fds not supported on Windows." + + if isinstance(args, str): + pass + elif isinstance(args, bytes): + if shell: + raise TypeError('bytes args is not allowed on Windows') + args = list2cmdline([args]) + elif isinstance(args, os.PathLike): + if shell: + raise TypeError('path-like args is not allowed when ' + 'shell is true') + args = list2cmdline([args]) + else: + args = list2cmdline(args) + + if executable is not None: + executable = os.fsdecode(executable) + + # Process startup details + if startupinfo is None: + startupinfo = STARTUPINFO() + else: + # bpo-34044: Copy STARTUPINFO since it is modified above, + # so the caller can reuse it multiple times. + startupinfo = startupinfo.copy() + + use_std_handles = -1 not in (p2cread, c2pwrite, errwrite) + if use_std_handles: + startupinfo.dwFlags |= _winapi.STARTF_USESTDHANDLES + startupinfo.hStdInput = p2cread + startupinfo.hStdOutput = c2pwrite + startupinfo.hStdError = errwrite + + attribute_list = startupinfo.lpAttributeList + have_handle_list = bool(attribute_list and + "handle_list" in attribute_list and + attribute_list["handle_list"]) + + # If we were given an handle_list or need to create one + if have_handle_list or (use_std_handles and close_fds): + if attribute_list is None: + attribute_list = startupinfo.lpAttributeList = {} + handle_list = attribute_list["handle_list"] = \ + list(attribute_list.get("handle_list", [])) + + if use_std_handles: + handle_list += [int(p2cread), int(c2pwrite), int(errwrite)] + + handle_list[:] = self._filter_handle_list(handle_list) + + if handle_list: + if not close_fds: + warnings.warn("startupinfo.lpAttributeList['handle_list'] " + "overriding close_fds", RuntimeWarning) + + # When using the handle_list we always request to inherit + # handles but the only handles that will be inherited are + # the ones in the handle_list + close_fds = False + + if shell: + startupinfo.dwFlags |= _winapi.STARTF_USESHOWWINDOW + startupinfo.wShowWindow = _winapi.SW_HIDE + if not executable: + # gh-101283: without a fully-qualified path, before Windows + # checks the system directories, it first looks in the + # application directory, and also the current directory if + # NeedCurrentDirectoryForExePathW(ExeName) is true, so try + # to avoid executing unqualified "cmd.exe". + comspec = os.environ.get('ComSpec') + if not comspec: + system_root = os.environ.get('SystemRoot', '') + comspec = os.path.join(system_root, 'System32', 'cmd.exe') + if not os.path.isabs(comspec): + raise FileNotFoundError('shell not found: neither %ComSpec% nor %SystemRoot% is set') + if os.path.isabs(comspec): + executable = comspec + else: + comspec = executable + + args = '{} /c "{}"'.format (comspec, args) + + if cwd is not None: + cwd = os.fsdecode(cwd) + + sys.audit("subprocess.Popen", executable, args, cwd, env) + + # Start the process + try: + hp, ht, pid, tid = _winapi.CreateProcess(executable, args, + # no special security + None, None, + int(not close_fds), + creationflags, + env, + cwd, + startupinfo) + finally: + # Child is launched. Close the parent's copy of those pipe + # handles that only the child should have open. You need + # to make sure that no handles to the write end of the + # output pipe are maintained in this process or else the + # pipe will not close when the child process exits and the + # ReadFile will hang. + self._close_pipe_fds(p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite) + + # Retain the process handle, but close the thread handle + self._child_created = True + self._handle = Handle(hp) + self.pid = pid + _winapi.CloseHandle(ht) + + def _internal_poll(self, _deadstate=None, + _WaitForSingleObject=_winapi.WaitForSingleObject, + _WAIT_OBJECT_0=_winapi.WAIT_OBJECT_0, + _GetExitCodeProcess=_winapi.GetExitCodeProcess): + """Check if child process has terminated. Returns returncode + attribute. + + This method is called by __del__, so it can only refer to objects + in its local scope. + + """ + if self.returncode is None: + if _WaitForSingleObject(self._handle, 0) == _WAIT_OBJECT_0: + self.returncode = _GetExitCodeProcess(self._handle) + return self.returncode + + + def _wait(self, timeout): + """Internal implementation of wait() on Windows.""" + if timeout is None: + timeout_millis = _winapi.INFINITE + elif timeout <= 0: + timeout_millis = 0 + else: + timeout_millis = int(timeout * 1000) + if self.returncode is None: + # API note: Returns immediately if timeout_millis == 0. + result = _winapi.WaitForSingleObject(self._handle, + timeout_millis) + if result == _winapi.WAIT_TIMEOUT: + raise TimeoutExpired(self.args, timeout) + self.returncode = _winapi.GetExitCodeProcess(self._handle) + return self.returncode + + + def _readerthread(self, fh, buffer): + buffer.append(fh.read()) + fh.close() + + + def _communicate(self, input, endtime, orig_timeout): + # Start reader threads feeding into a list hanging off of this + # object, unless they've already been started. + if self.stdout and not hasattr(self, "_stdout_buff"): + self._stdout_buff = [] + self.stdout_thread = \ + threading.Thread(target=self._readerthread, + args=(self.stdout, self._stdout_buff)) + self.stdout_thread.daemon = True + self.stdout_thread.start() + if self.stderr and not hasattr(self, "_stderr_buff"): + self._stderr_buff = [] + self.stderr_thread = \ + threading.Thread(target=self._readerthread, + args=(self.stderr, self._stderr_buff)) + self.stderr_thread.daemon = True + self.stderr_thread.start() + + if self.stdin: + self._stdin_write(input) + + # Wait for the reader threads, or time out. If we time out, the + # threads remain reading and the fds left open in case the user + # calls communicate again. + if self.stdout is not None: + self.stdout_thread.join(self._remaining_time(endtime)) + if self.stdout_thread.is_alive(): + raise TimeoutExpired(self.args, orig_timeout) + if self.stderr is not None: + self.stderr_thread.join(self._remaining_time(endtime)) + if self.stderr_thread.is_alive(): + raise TimeoutExpired(self.args, orig_timeout) + + # Collect the output from and close both pipes, now that we know + # both have been read successfully. + stdout = None + stderr = None + if self.stdout: + stdout = self._stdout_buff + self.stdout.close() + if self.stderr: + stderr = self._stderr_buff + self.stderr.close() + + # All data exchanged. Translate lists into strings. + stdout = stdout[0] if stdout else None + stderr = stderr[0] if stderr else None + + return (stdout, stderr) + + def send_signal(self, sig): + """Send a signal to the process.""" + # Don't signal a process that we know has already died. + if self.returncode is not None: + return + if sig == signal.SIGTERM: + self.terminate() + elif sig == signal.CTRL_C_EVENT: + os.kill(self.pid, signal.CTRL_C_EVENT) + elif sig == signal.CTRL_BREAK_EVENT: + os.kill(self.pid, signal.CTRL_BREAK_EVENT) + else: + raise ValueError("Unsupported signal: {}".format(sig)) + + def terminate(self): + """Terminates the process.""" + # Don't terminate a process that we know has already died. + if self.returncode is not None: + return + try: + _winapi.TerminateProcess(self._handle, 1) + except PermissionError: + # ERROR_ACCESS_DENIED (winerror 5) is received when the + # process already died. + rc = _winapi.GetExitCodeProcess(self._handle) + if rc == _winapi.STILL_ACTIVE: + raise + self.returncode = rc + + kill = terminate + + else: + # + # POSIX methods + # + def _get_handles(self, stdin, stdout, stderr): + """Construct and return tuple with IO objects: + p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite + """ + p2cread, p2cwrite = -1, -1 + c2pread, c2pwrite = -1, -1 + errread, errwrite = -1, -1 + + with self._on_error_fd_closer() as err_close_fds: + if stdin is None: + pass + elif stdin == PIPE: + p2cread, p2cwrite = os.pipe() + err_close_fds.extend((p2cread, p2cwrite)) + if self.pipesize > 0 and hasattr(fcntl, "F_SETPIPE_SZ"): + fcntl.fcntl(p2cwrite, fcntl.F_SETPIPE_SZ, self.pipesize) + elif stdin == DEVNULL: + p2cread = self._get_devnull() + elif isinstance(stdin, int): + p2cread = stdin + else: + # Assuming file-like object + p2cread = stdin.fileno() + + if stdout is None: + pass + elif stdout == PIPE: + c2pread, c2pwrite = os.pipe() + err_close_fds.extend((c2pread, c2pwrite)) + if self.pipesize > 0 and hasattr(fcntl, "F_SETPIPE_SZ"): + fcntl.fcntl(c2pwrite, fcntl.F_SETPIPE_SZ, self.pipesize) + elif stdout == DEVNULL: + c2pwrite = self._get_devnull() + elif isinstance(stdout, int): + c2pwrite = stdout + else: + # Assuming file-like object + c2pwrite = stdout.fileno() + + if stderr is None: + pass + elif stderr == PIPE: + errread, errwrite = os.pipe() + err_close_fds.extend((errread, errwrite)) + if self.pipesize > 0 and hasattr(fcntl, "F_SETPIPE_SZ"): + fcntl.fcntl(errwrite, fcntl.F_SETPIPE_SZ, self.pipesize) + elif stderr == STDOUT: + if c2pwrite != -1: + errwrite = c2pwrite + else: # child's stdout is not set, use parent's stdout + errwrite = sys.__stdout__.fileno() + elif stderr == DEVNULL: + errwrite = self._get_devnull() + elif isinstance(stderr, int): + errwrite = stderr + else: + # Assuming file-like object + errwrite = stderr.fileno() + + return (p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite) + + + def _posix_spawn(self, args, executable, env, restore_signals, + p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite): + """Execute program using os.posix_spawn().""" + if env is None: + env = os.environ + + kwargs = {} + if restore_signals: + # See _Py_RestoreSignals() in Python/pylifecycle.c + sigset = [] + for signame in ('SIGPIPE', 'SIGXFZ', 'SIGXFSZ'): + signum = getattr(signal, signame, None) + if signum is not None: + sigset.append(signum) + kwargs['setsigdef'] = sigset + + file_actions = [] + for fd in (p2cwrite, c2pread, errread): + if fd != -1: + file_actions.append((os.POSIX_SPAWN_CLOSE, fd)) + for fd, fd2 in ( + (p2cread, 0), + (c2pwrite, 1), + (errwrite, 2), + ): + if fd != -1: + file_actions.append((os.POSIX_SPAWN_DUP2, fd, fd2)) + if file_actions: + kwargs['file_actions'] = file_actions + + self.pid = os.posix_spawn(executable, args, env, **kwargs) + self._child_created = True + + self._close_pipe_fds(p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite) + + def _execute_child(self, args, executable, preexec_fn, close_fds, + pass_fds, cwd, env, + startupinfo, creationflags, shell, + p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite, + restore_signals, + gid, gids, uid, umask, + start_new_session, process_group): + """Execute program (POSIX version)""" + + if isinstance(args, (str, bytes)): + args = [args] + elif isinstance(args, os.PathLike): + if shell: + raise TypeError('path-like args is not allowed when ' + 'shell is true') + args = [args] + else: + args = list(args) + + if shell: + # On Android the default shell is at '/system/bin/sh'. + unix_shell = ('/system/bin/sh' if + hasattr(sys, 'getandroidapilevel') else '/bin/sh') + args = [unix_shell, "-c"] + args + if executable: + args[0] = executable + + if executable is None: + executable = args[0] + + sys.audit("subprocess.Popen", executable, args, cwd, env) + + if (_USE_POSIX_SPAWN + and os.path.dirname(executable) + and preexec_fn is None + and not close_fds + and not pass_fds + and cwd is None + and (p2cread == -1 or p2cread > 2) + and (c2pwrite == -1 or c2pwrite > 2) + and (errwrite == -1 or errwrite > 2) + and not start_new_session + and process_group == -1 + and gid is None + and gids is None + and uid is None + and umask < 0): + self._posix_spawn(args, executable, env, restore_signals, + p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite) + return + + orig_executable = executable + + # For transferring possible exec failure from child to parent. + # Data format: "exception name:hex errno:description" + # Pickle is not used; it is complex and involves memory allocation. + errpipe_read, errpipe_write = os.pipe() + # errpipe_write must not be in the standard io 0, 1, or 2 fd range. + low_fds_to_close = [] + while errpipe_write < 3: + low_fds_to_close.append(errpipe_write) + errpipe_write = os.dup(errpipe_write) + for low_fd in low_fds_to_close: + os.close(low_fd) + try: + try: + # We must avoid complex work that could involve + # malloc or free in the child process to avoid + # potential deadlocks, thus we do all this here. + # and pass it to fork_exec() + + if env is not None: + env_list = [] + for k, v in env.items(): + k = os.fsencode(k) + if b'=' in k: + raise ValueError("illegal environment variable name") + env_list.append(k + b'=' + os.fsencode(v)) + else: + env_list = None # Use execv instead of execve. + executable = os.fsencode(executable) + if os.path.dirname(executable): + executable_list = (executable,) + else: + # This matches the behavior of os._execvpe(). + executable_list = tuple( + os.path.join(os.fsencode(dir), executable) + for dir in os.get_exec_path(env)) + fds_to_keep = set(pass_fds) + fds_to_keep.add(errpipe_write) + self.pid = _fork_exec( + args, executable_list, + close_fds, tuple(sorted(map(int, fds_to_keep))), + cwd, env_list, + p2cread, p2cwrite, c2pread, c2pwrite, + errread, errwrite, + errpipe_read, errpipe_write, + restore_signals, start_new_session, + process_group, gid, gids, uid, umask, + preexec_fn, _USE_VFORK) + self._child_created = True + finally: + # be sure the FD is closed no matter what + os.close(errpipe_write) + + self._close_pipe_fds(p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite) + + # Wait for exec to fail or succeed; possibly raising an + # exception (limited in size) + errpipe_data = bytearray() + while True: + part = os.read(errpipe_read, 50000) + errpipe_data += part + if not part or len(errpipe_data) > 50000: + break + finally: + # be sure the FD is closed no matter what + os.close(errpipe_read) + + if errpipe_data: + try: + pid, sts = os.waitpid(self.pid, 0) + if pid == self.pid: + self._handle_exitstatus(sts) + else: + self.returncode = sys.maxsize + except ChildProcessError: + pass + + try: + exception_name, hex_errno, err_msg = ( + errpipe_data.split(b':', 2)) + # The encoding here should match the encoding + # written in by the subprocess implementations + # like _posixsubprocess + err_msg = err_msg.decode() + except ValueError: + exception_name = b'SubprocessError' + hex_errno = b'0' + err_msg = 'Bad exception data from child: {!r}'.format( + bytes(errpipe_data)) + child_exception_type = getattr( + builtins, exception_name.decode('ascii'), + SubprocessError) + if issubclass(child_exception_type, OSError) and hex_errno: + errno_num = int(hex_errno, 16) + if err_msg == "noexec:chdir": + err_msg = "" + # The error must be from chdir(cwd). + err_filename = cwd + elif err_msg == "noexec": + err_msg = "" + err_filename = None + else: + err_filename = orig_executable + if errno_num != 0: + err_msg = os.strerror(errno_num) + if err_filename is not None: + raise child_exception_type(errno_num, err_msg, err_filename) + else: + raise child_exception_type(errno_num, err_msg) + raise child_exception_type(err_msg) + + + def _handle_exitstatus(self, sts, + _waitstatus_to_exitcode=_waitstatus_to_exitcode, + _WIFSTOPPED=_WIFSTOPPED, + _WSTOPSIG=_WSTOPSIG): + """All callers to this function MUST hold self._waitpid_lock.""" + # This method is called (indirectly) by __del__, so it cannot + # refer to anything outside of its local scope. + if _WIFSTOPPED(sts): + self.returncode = -_WSTOPSIG(sts) + else: + self.returncode = _waitstatus_to_exitcode(sts) + + def _internal_poll(self, _deadstate=None, _waitpid=_waitpid, + _WNOHANG=_WNOHANG, _ECHILD=errno.ECHILD): + """Check if child process has terminated. Returns returncode + attribute. + + This method is called by __del__, so it cannot reference anything + outside of the local scope (nor can any methods it calls). + + """ + if self.returncode is None: + if not self._waitpid_lock.acquire(False): + # Something else is busy calling waitpid. Don't allow two + # at once. We know nothing yet. + return None + try: + if self.returncode is not None: + return self.returncode # Another thread waited. + pid, sts = _waitpid(self.pid, _WNOHANG) + if pid == self.pid: + self._handle_exitstatus(sts) + except OSError as e: + if _deadstate is not None: + self.returncode = _deadstate + elif e.errno == _ECHILD: + # This happens if SIGCLD is set to be ignored or + # waiting for child processes has otherwise been + # disabled for our process. This child is dead, we + # can't get the status. + # http://bugs.python.org/issue15756 + self.returncode = 0 + finally: + self._waitpid_lock.release() + return self.returncode + + + def _try_wait(self, wait_flags): + """All callers to this function MUST hold self._waitpid_lock.""" + try: + (pid, sts) = os.waitpid(self.pid, wait_flags) + except ChildProcessError: + # This happens if SIGCLD is set to be ignored or waiting + # for child processes has otherwise been disabled for our + # process. This child is dead, we can't get the status. + pid = self.pid + sts = 0 + return (pid, sts) + + + def _wait(self, timeout): + """Internal implementation of wait() on POSIX.""" + if self.returncode is not None: + return self.returncode + + if timeout is not None: + endtime = _time() + timeout + # Enter a busy loop if we have a timeout. This busy loop was + # cribbed from Lib/threading.py in Thread.wait() at r71065. + delay = 0.0005 # 500 us -> initial delay of 1 ms + while True: + if self._waitpid_lock.acquire(False): + try: + if self.returncode is not None: + break # Another thread waited. + (pid, sts) = self._try_wait(os.WNOHANG) + assert pid == self.pid or pid == 0 + if pid == self.pid: + self._handle_exitstatus(sts) + break + finally: + self._waitpid_lock.release() + remaining = self._remaining_time(endtime) + if remaining <= 0: + raise TimeoutExpired(self.args, timeout) + delay = min(delay * 2, remaining, .05) + time.sleep(delay) + else: + while self.returncode is None: + with self._waitpid_lock: + if self.returncode is not None: + break # Another thread waited. + (pid, sts) = self._try_wait(0) + # Check the pid and loop as waitpid has been known to + # return 0 even without WNOHANG in odd situations. + # http://bugs.python.org/issue14396. + if pid == self.pid: + self._handle_exitstatus(sts) + return self.returncode + + + def _communicate(self, input, endtime, orig_timeout): + if self.stdin and not self._communication_started: + # Flush stdio buffer. This might block, if the user has + # been writing to .stdin in an uncontrolled fashion. + try: + self.stdin.flush() + except BrokenPipeError: + pass # communicate() must ignore BrokenPipeError. + if not input: + try: + self.stdin.close() + except BrokenPipeError: + pass # communicate() must ignore BrokenPipeError. + + stdout = None + stderr = None + + # Only create this mapping if we haven't already. + if not self._communication_started: + self._fileobj2output = {} + if self.stdout: + self._fileobj2output[self.stdout] = [] + if self.stderr: + self._fileobj2output[self.stderr] = [] + + if self.stdout: + stdout = self._fileobj2output[self.stdout] + if self.stderr: + stderr = self._fileobj2output[self.stderr] + + self._save_input(input) + + if self._input: + input_view = memoryview(self._input) + + with _PopenSelector() as selector: + if self.stdin and input: + selector.register(self.stdin, selectors.EVENT_WRITE) + if self.stdout and not self.stdout.closed: + selector.register(self.stdout, selectors.EVENT_READ) + if self.stderr and not self.stderr.closed: + selector.register(self.stderr, selectors.EVENT_READ) + + while selector.get_map(): + timeout = self._remaining_time(endtime) + if timeout is not None and timeout < 0: + self._check_timeout(endtime, orig_timeout, + stdout, stderr, + skip_check_and_raise=True) + raise RuntimeError( # Impossible :) + '_check_timeout(..., skip_check_and_raise=True) ' + 'failed to raise TimeoutExpired.') + + ready = selector.select(timeout) + self._check_timeout(endtime, orig_timeout, stdout, stderr) + + # XXX Rewrite these to use non-blocking I/O on the file + # objects; they are no longer using C stdio! + + for key, events in ready: + if key.fileobj is self.stdin: + chunk = input_view[self._input_offset : + self._input_offset + _PIPE_BUF] + try: + self._input_offset += os.write(key.fd, chunk) + except BrokenPipeError: + selector.unregister(key.fileobj) + key.fileobj.close() + else: + if self._input_offset >= len(self._input): + selector.unregister(key.fileobj) + key.fileobj.close() + elif key.fileobj in (self.stdout, self.stderr): + data = os.read(key.fd, 32768) + if not data: + selector.unregister(key.fileobj) + key.fileobj.close() + self._fileobj2output[key.fileobj].append(data) + + self.wait(timeout=self._remaining_time(endtime)) + + # All data exchanged. Translate lists into strings. + if stdout is not None: + stdout = b''.join(stdout) + if stderr is not None: + stderr = b''.join(stderr) + + # Translate newlines, if requested. + # This also turns bytes into strings. + if self.text_mode: + if stdout is not None: + stdout = self._translate_newlines(stdout, + self.stdout.encoding, + self.stdout.errors) + if stderr is not None: + stderr = self._translate_newlines(stderr, + self.stderr.encoding, + self.stderr.errors) + + return (stdout, stderr) + + + def _save_input(self, input): + # This method is called from the _communicate_with_*() methods + # so that if we time out while communicating, we can continue + # sending input if we retry. + if self.stdin and self._input is None: + self._input_offset = 0 + self._input = input + if input is not None and self.text_mode: + self._input = self._input.encode(self.stdin.encoding, + self.stdin.errors) + + + def send_signal(self, sig): + """Send a signal to the process.""" + # bpo-38630: Polling reduces the risk of sending a signal to the + # wrong process if the process completed, the Popen.returncode + # attribute is still None, and the pid has been reassigned + # (recycled) to a new different process. This race condition can + # happens in two cases. + # + # Case 1. Thread A calls Popen.poll(), thread B calls + # Popen.send_signal(). In thread A, waitpid() succeed and returns + # the exit status. Thread B calls kill() because poll() in thread A + # did not set returncode yet. Calling poll() in thread B prevents + # the race condition thanks to Popen._waitpid_lock. + # + # Case 2. waitpid(pid, 0) has been called directly, without + # using Popen methods: returncode is still None is this case. + # Calling Popen.poll() will set returncode to a default value, + # since waitpid() fails with ProcessLookupError. + self.poll() + if self.returncode is not None: + # Skip signalling a process that we know has already died. + return + + # The race condition can still happen if the race condition + # described above happens between the returncode test + # and the kill() call. + try: + os.kill(self.pid, sig) + except ProcessLookupError: + # Suppress the race condition error; bpo-40550. + pass + + def terminate(self): + """Terminate the process with SIGTERM + """ + self.send_signal(signal.SIGTERM) + + def kill(self): + """Kill the process with SIGKILL + """ + self.send_signal(signal.SIGKILL) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/sunau.py b/physworld_p1_20261018/envs/p1/lib/python3.11/sunau.py new file mode 100644 index 0000000000000000000000000000000000000000..94c42f1582c021db4b8862d6efe2e13af35948ed --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/sunau.py @@ -0,0 +1,533 @@ +"""Stuff to parse Sun and NeXT audio files. + +An audio file consists of a header followed by the data. The structure +of the header is as follows. + + +---------------+ + | magic word | + +---------------+ + | header size | + +---------------+ + | data size | + +---------------+ + | encoding | + +---------------+ + | sample rate | + +---------------+ + | # of channels | + +---------------+ + | info | + | | + +---------------+ + +The magic word consists of the 4 characters '.snd'. Apart from the +info field, all header fields are 4 bytes in size. They are all +32-bit unsigned integers encoded in big-endian byte order. + +The header size really gives the start of the data. +The data size is the physical size of the data. From the other +parameters the number of frames can be calculated. +The encoding gives the way in which audio samples are encoded. +Possible values are listed below. +The info field currently consists of an ASCII string giving a +human-readable description of the audio file. The info field is +padded with NUL bytes to the header size. + +Usage. + +Reading audio files: + f = sunau.open(file, 'r') +where file is either the name of a file or an open file pointer. +The open file pointer must have methods read(), seek(), and close(). +When the setpos() and rewind() methods are not used, the seek() +method is not necessary. + +This returns an instance of a class with the following public methods: + getnchannels() -- returns number of audio channels (1 for + mono, 2 for stereo) + getsampwidth() -- returns sample width in bytes + getframerate() -- returns sampling frequency + getnframes() -- returns number of audio frames + getcomptype() -- returns compression type ('NONE' or 'ULAW') + getcompname() -- returns human-readable version of + compression type ('not compressed' matches 'NONE') + getparams() -- returns a namedtuple consisting of all of the + above in the above order + getmarkers() -- returns None (for compatibility with the + aifc module) + getmark(id) -- raises an error since the mark does not + exist (for compatibility with the aifc module) + readframes(n) -- returns at most n frames of audio + rewind() -- rewind to the beginning of the audio stream + setpos(pos) -- seek to the specified position + tell() -- return the current position + close() -- close the instance (make it unusable) +The position returned by tell() and the position given to setpos() +are compatible and have nothing to do with the actual position in the +file. +The close() method is called automatically when the class instance +is destroyed. + +Writing audio files: + f = sunau.open(file, 'w') +where file is either the name of a file or an open file pointer. +The open file pointer must have methods write(), tell(), seek(), and +close(). + +This returns an instance of a class with the following public methods: + setnchannels(n) -- set the number of channels + setsampwidth(n) -- set the sample width + setframerate(n) -- set the frame rate + setnframes(n) -- set the number of frames + setcomptype(type, name) + -- set the compression type and the + human-readable compression type + setparams(tuple)-- set all parameters at once + tell() -- return current position in output file + writeframesraw(data) + -- write audio frames without pathing up the + file header + writeframes(data) + -- write audio frames and patch up the file header + close() -- patch up the file header and close the + output file +You should set the parameters before the first writeframesraw or +writeframes. The total number of frames does not need to be set, +but when it is set to the correct value, the header does not have to +be patched up. +It is best to first set all parameters, perhaps possibly the +compression type, and then write audio frames using writeframesraw. +When all frames have been written, either call writeframes(b'') or +close() to patch up the sizes in the header. +The close() method is called automatically when the class instance +is destroyed. +""" + +from collections import namedtuple +import warnings + +warnings._deprecated(__name__, remove=(3, 13)) + + +_sunau_params = namedtuple('_sunau_params', + 'nchannels sampwidth framerate nframes comptype compname') + +# from +AUDIO_FILE_MAGIC = 0x2e736e64 +AUDIO_FILE_ENCODING_MULAW_8 = 1 +AUDIO_FILE_ENCODING_LINEAR_8 = 2 +AUDIO_FILE_ENCODING_LINEAR_16 = 3 +AUDIO_FILE_ENCODING_LINEAR_24 = 4 +AUDIO_FILE_ENCODING_LINEAR_32 = 5 +AUDIO_FILE_ENCODING_FLOAT = 6 +AUDIO_FILE_ENCODING_DOUBLE = 7 +AUDIO_FILE_ENCODING_ADPCM_G721 = 23 +AUDIO_FILE_ENCODING_ADPCM_G722 = 24 +AUDIO_FILE_ENCODING_ADPCM_G723_3 = 25 +AUDIO_FILE_ENCODING_ADPCM_G723_5 = 26 +AUDIO_FILE_ENCODING_ALAW_8 = 27 + +# from +AUDIO_UNKNOWN_SIZE = 0xFFFFFFFF # ((unsigned)(~0)) + +_simple_encodings = [AUDIO_FILE_ENCODING_MULAW_8, + AUDIO_FILE_ENCODING_LINEAR_8, + AUDIO_FILE_ENCODING_LINEAR_16, + AUDIO_FILE_ENCODING_LINEAR_24, + AUDIO_FILE_ENCODING_LINEAR_32, + AUDIO_FILE_ENCODING_ALAW_8] + +class Error(Exception): + pass + +def _read_u32(file): + x = 0 + for i in range(4): + byte = file.read(1) + if not byte: + raise EOFError + x = x*256 + ord(byte) + return x + +def _write_u32(file, x): + data = [] + for i in range(4): + d, m = divmod(x, 256) + data.insert(0, int(m)) + x = d + file.write(bytes(data)) + +class Au_read: + + def __init__(self, f): + if type(f) == type(''): + import builtins + f = builtins.open(f, 'rb') + self._opened = True + else: + self._opened = False + self.initfp(f) + + def __del__(self): + if self._file: + self.close() + + def __enter__(self): + return self + + def __exit__(self, *args): + self.close() + + def initfp(self, file): + self._file = file + self._soundpos = 0 + magic = int(_read_u32(file)) + if magic != AUDIO_FILE_MAGIC: + raise Error('bad magic number') + self._hdr_size = int(_read_u32(file)) + if self._hdr_size < 24: + raise Error('header size too small') + if self._hdr_size > 100: + raise Error('header size ridiculously large') + self._data_size = _read_u32(file) + if self._data_size != AUDIO_UNKNOWN_SIZE: + self._data_size = int(self._data_size) + self._encoding = int(_read_u32(file)) + if self._encoding not in _simple_encodings: + raise Error('encoding not (yet) supported') + if self._encoding in (AUDIO_FILE_ENCODING_MULAW_8, + AUDIO_FILE_ENCODING_ALAW_8): + self._sampwidth = 2 + self._framesize = 1 + elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_8: + self._framesize = self._sampwidth = 1 + elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_16: + self._framesize = self._sampwidth = 2 + elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_24: + self._framesize = self._sampwidth = 3 + elif self._encoding == AUDIO_FILE_ENCODING_LINEAR_32: + self._framesize = self._sampwidth = 4 + else: + raise Error('unknown encoding') + self._framerate = int(_read_u32(file)) + self._nchannels = int(_read_u32(file)) + if not self._nchannels: + raise Error('bad # of channels') + self._framesize = self._framesize * self._nchannels + if self._hdr_size > 24: + self._info = file.read(self._hdr_size - 24) + self._info, _, _ = self._info.partition(b'\0') + else: + self._info = b'' + try: + self._data_pos = file.tell() + except (AttributeError, OSError): + self._data_pos = None + + def getfp(self): + return self._file + + def getnchannels(self): + return self._nchannels + + def getsampwidth(self): + return self._sampwidth + + def getframerate(self): + return self._framerate + + def getnframes(self): + if self._data_size == AUDIO_UNKNOWN_SIZE: + return AUDIO_UNKNOWN_SIZE + if self._encoding in _simple_encodings: + return self._data_size // self._framesize + return 0 # XXX--must do some arithmetic here + + def getcomptype(self): + if self._encoding == AUDIO_FILE_ENCODING_MULAW_8: + return 'ULAW' + elif self._encoding == AUDIO_FILE_ENCODING_ALAW_8: + return 'ALAW' + else: + return 'NONE' + + def getcompname(self): + if self._encoding == AUDIO_FILE_ENCODING_MULAW_8: + return 'CCITT G.711 u-law' + elif self._encoding == AUDIO_FILE_ENCODING_ALAW_8: + return 'CCITT G.711 A-law' + else: + return 'not compressed' + + def getparams(self): + return _sunau_params(self.getnchannels(), self.getsampwidth(), + self.getframerate(), self.getnframes(), + self.getcomptype(), self.getcompname()) + + def getmarkers(self): + return None + + def getmark(self, id): + raise Error('no marks') + + def readframes(self, nframes): + if self._encoding in _simple_encodings: + if nframes == AUDIO_UNKNOWN_SIZE: + data = self._file.read() + else: + data = self._file.read(nframes * self._framesize) + self._soundpos += len(data) // self._framesize + if self._encoding == AUDIO_FILE_ENCODING_MULAW_8: + with warnings.catch_warnings(): + warnings.simplefilter('ignore', category=DeprecationWarning) + import audioop + data = audioop.ulaw2lin(data, self._sampwidth) + return data + return None # XXX--not implemented yet + + def rewind(self): + if self._data_pos is None: + raise OSError('cannot seek') + self._file.seek(self._data_pos) + self._soundpos = 0 + + def tell(self): + return self._soundpos + + def setpos(self, pos): + if pos < 0 or pos > self.getnframes(): + raise Error('position not in range') + if self._data_pos is None: + raise OSError('cannot seek') + self._file.seek(self._data_pos + pos * self._framesize) + self._soundpos = pos + + def close(self): + file = self._file + if file: + self._file = None + if self._opened: + file.close() + +class Au_write: + + def __init__(self, f): + if type(f) == type(''): + import builtins + f = builtins.open(f, 'wb') + self._opened = True + else: + self._opened = False + self.initfp(f) + + def __del__(self): + if self._file: + self.close() + self._file = None + + def __enter__(self): + return self + + def __exit__(self, *args): + self.close() + + def initfp(self, file): + self._file = file + self._framerate = 0 + self._nchannels = 0 + self._sampwidth = 0 + self._framesize = 0 + self._nframes = AUDIO_UNKNOWN_SIZE + self._nframeswritten = 0 + self._datawritten = 0 + self._datalength = 0 + self._info = b'' + self._comptype = 'ULAW' # default is U-law + + def setnchannels(self, nchannels): + if self._nframeswritten: + raise Error('cannot change parameters after starting to write') + if nchannels not in (1, 2, 4): + raise Error('only 1, 2, or 4 channels supported') + self._nchannels = nchannels + + def getnchannels(self): + if not self._nchannels: + raise Error('number of channels not set') + return self._nchannels + + def setsampwidth(self, sampwidth): + if self._nframeswritten: + raise Error('cannot change parameters after starting to write') + if sampwidth not in (1, 2, 3, 4): + raise Error('bad sample width') + self._sampwidth = sampwidth + + def getsampwidth(self): + if not self._framerate: + raise Error('sample width not specified') + return self._sampwidth + + def setframerate(self, framerate): + if self._nframeswritten: + raise Error('cannot change parameters after starting to write') + self._framerate = framerate + + def getframerate(self): + if not self._framerate: + raise Error('frame rate not set') + return self._framerate + + def setnframes(self, nframes): + if self._nframeswritten: + raise Error('cannot change parameters after starting to write') + if nframes < 0: + raise Error('# of frames cannot be negative') + self._nframes = nframes + + def getnframes(self): + return self._nframeswritten + + def setcomptype(self, type, name): + if type in ('NONE', 'ULAW'): + self._comptype = type + else: + raise Error('unknown compression type') + + def getcomptype(self): + return self._comptype + + def getcompname(self): + if self._comptype == 'ULAW': + return 'CCITT G.711 u-law' + elif self._comptype == 'ALAW': + return 'CCITT G.711 A-law' + else: + return 'not compressed' + + def setparams(self, params): + nchannels, sampwidth, framerate, nframes, comptype, compname = params + self.setnchannels(nchannels) + self.setsampwidth(sampwidth) + self.setframerate(framerate) + self.setnframes(nframes) + self.setcomptype(comptype, compname) + + def getparams(self): + return _sunau_params(self.getnchannels(), self.getsampwidth(), + self.getframerate(), self.getnframes(), + self.getcomptype(), self.getcompname()) + + def tell(self): + return self._nframeswritten + + def writeframesraw(self, data): + if not isinstance(data, (bytes, bytearray)): + data = memoryview(data).cast('B') + self._ensure_header_written() + if self._comptype == 'ULAW': + with warnings.catch_warnings(): + warnings.simplefilter('ignore', category=DeprecationWarning) + import audioop + data = audioop.lin2ulaw(data, self._sampwidth) + nframes = len(data) // self._framesize + self._file.write(data) + self._nframeswritten = self._nframeswritten + nframes + self._datawritten = self._datawritten + len(data) + + def writeframes(self, data): + self.writeframesraw(data) + if self._nframeswritten != self._nframes or \ + self._datalength != self._datawritten: + self._patchheader() + + def close(self): + if self._file: + try: + self._ensure_header_written() + if self._nframeswritten != self._nframes or \ + self._datalength != self._datawritten: + self._patchheader() + self._file.flush() + finally: + file = self._file + self._file = None + if self._opened: + file.close() + + # + # private methods + # + + def _ensure_header_written(self): + if not self._nframeswritten: + if not self._nchannels: + raise Error('# of channels not specified') + if not self._sampwidth: + raise Error('sample width not specified') + if not self._framerate: + raise Error('frame rate not specified') + self._write_header() + + def _write_header(self): + if self._comptype == 'NONE': + if self._sampwidth == 1: + encoding = AUDIO_FILE_ENCODING_LINEAR_8 + self._framesize = 1 + elif self._sampwidth == 2: + encoding = AUDIO_FILE_ENCODING_LINEAR_16 + self._framesize = 2 + elif self._sampwidth == 3: + encoding = AUDIO_FILE_ENCODING_LINEAR_24 + self._framesize = 3 + elif self._sampwidth == 4: + encoding = AUDIO_FILE_ENCODING_LINEAR_32 + self._framesize = 4 + else: + raise Error('internal error') + elif self._comptype == 'ULAW': + encoding = AUDIO_FILE_ENCODING_MULAW_8 + self._framesize = 1 + else: + raise Error('internal error') + self._framesize = self._framesize * self._nchannels + _write_u32(self._file, AUDIO_FILE_MAGIC) + header_size = 25 + len(self._info) + header_size = (header_size + 7) & ~7 + _write_u32(self._file, header_size) + if self._nframes == AUDIO_UNKNOWN_SIZE: + length = AUDIO_UNKNOWN_SIZE + else: + length = self._nframes * self._framesize + try: + self._form_length_pos = self._file.tell() + except (AttributeError, OSError): + self._form_length_pos = None + _write_u32(self._file, length) + self._datalength = length + _write_u32(self._file, encoding) + _write_u32(self._file, self._framerate) + _write_u32(self._file, self._nchannels) + self._file.write(self._info) + self._file.write(b'\0'*(header_size - len(self._info) - 24)) + + def _patchheader(self): + if self._form_length_pos is None: + raise OSError('cannot seek') + self._file.seek(self._form_length_pos) + _write_u32(self._file, self._datawritten) + self._datalength = self._datawritten + self._file.seek(0, 2) + +def open(f, mode=None): + if mode is None: + if hasattr(f, 'mode'): + mode = f.mode + else: + mode = 'rb' + if mode in ('r', 'rb'): + return Au_read(f) + elif mode in ('w', 'wb'): + return Au_write(f) + else: + raise Error("mode must be 'r', 'rb', 'w', or 'wb'") diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/symtable.py b/physworld_p1_20261018/envs/p1/lib/python3.11/symtable.py new file mode 100644 index 0000000000000000000000000000000000000000..5dd71ffc6b4f195eb938549f6debc21c3f047d57 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/symtable.py @@ -0,0 +1,326 @@ +"""Interface to the compiler's internal symbol tables""" + +import _symtable +from _symtable import (USE, DEF_GLOBAL, DEF_NONLOCAL, DEF_LOCAL, DEF_PARAM, + DEF_IMPORT, DEF_BOUND, DEF_ANNOT, SCOPE_OFF, SCOPE_MASK, FREE, + LOCAL, GLOBAL_IMPLICIT, GLOBAL_EXPLICIT, CELL) + +import weakref + +__all__ = ["symtable", "SymbolTable", "Class", "Function", "Symbol"] + +def symtable(code, filename, compile_type): + """ Return the toplevel *SymbolTable* for the source code. + + *filename* is the name of the file with the code + and *compile_type* is the *compile()* mode argument. + """ + top = _symtable.symtable(code, filename, compile_type) + return _newSymbolTable(top, filename) + +class SymbolTableFactory: + def __init__(self): + self.__memo = weakref.WeakValueDictionary() + + def new(self, table, filename): + if table.type == _symtable.TYPE_FUNCTION: + return Function(table, filename) + if table.type == _symtable.TYPE_CLASS: + return Class(table, filename) + return SymbolTable(table, filename) + + def __call__(self, table, filename): + key = table, filename + obj = self.__memo.get(key, None) + if obj is None: + obj = self.__memo[key] = self.new(table, filename) + return obj + +_newSymbolTable = SymbolTableFactory() + + +class SymbolTable: + + def __init__(self, raw_table, filename): + self._table = raw_table + self._filename = filename + self._symbols = {} + + def __repr__(self): + if self.__class__ == SymbolTable: + kind = "" + else: + kind = "%s " % self.__class__.__name__ + + if self._table.name == "top": + return "<{0}SymbolTable for module {1}>".format(kind, self._filename) + else: + return "<{0}SymbolTable for {1} in {2}>".format(kind, + self._table.name, + self._filename) + + def get_type(self): + """Return the type of the symbol table. + + The values returned are 'class', 'module' and + 'function'. + """ + if self._table.type == _symtable.TYPE_MODULE: + return "module" + if self._table.type == _symtable.TYPE_FUNCTION: + return "function" + if self._table.type == _symtable.TYPE_CLASS: + return "class" + assert self._table.type in (1, 2, 3), \ + "unexpected type: {0}".format(self._table.type) + + def get_id(self): + """Return an identifier for the table. + """ + return self._table.id + + def get_name(self): + """Return the table's name. + + This corresponds to the name of the class, function + or 'top' if the table is for a class, function or + global respectively. + """ + return self._table.name + + def get_lineno(self): + """Return the number of the first line in the + block for the table. + """ + return self._table.lineno + + def is_optimized(self): + """Return *True* if the locals in the table + are optimizable. + """ + return bool(self._table.type == _symtable.TYPE_FUNCTION) + + def is_nested(self): + """Return *True* if the block is a nested class + or function.""" + return bool(self._table.nested) + + def has_children(self): + """Return *True* if the block has nested namespaces. + """ + return bool(self._table.children) + + def get_identifiers(self): + """Return a view object containing the names of symbols in the table. + """ + return self._table.symbols.keys() + + def lookup(self, name): + """Lookup a *name* in the table. + + Returns a *Symbol* instance. + """ + sym = self._symbols.get(name) + if sym is None: + flags = self._table.symbols[name] + namespaces = self.__check_children(name) + module_scope = (self._table.name == "top") + sym = self._symbols[name] = Symbol(name, flags, namespaces, + module_scope=module_scope) + return sym + + def get_symbols(self): + """Return a list of *Symbol* instances for + names in the table. + """ + return [self.lookup(ident) for ident in self.get_identifiers()] + + def __check_children(self, name): + return [_newSymbolTable(st, self._filename) + for st in self._table.children + if st.name == name] + + def get_children(self): + """Return a list of the nested symbol tables. + """ + return [_newSymbolTable(st, self._filename) + for st in self._table.children] + + +class Function(SymbolTable): + + # Default values for instance variables + __params = None + __locals = None + __frees = None + __globals = None + __nonlocals = None + + def __idents_matching(self, test_func): + return tuple(ident for ident in self.get_identifiers() + if test_func(self._table.symbols[ident])) + + def get_parameters(self): + """Return a tuple of parameters to the function. + """ + if self.__params is None: + self.__params = self.__idents_matching(lambda x:x & DEF_PARAM) + return self.__params + + def get_locals(self): + """Return a tuple of locals in the function. + """ + if self.__locals is None: + locs = (LOCAL, CELL) + test = lambda x: ((x >> SCOPE_OFF) & SCOPE_MASK) in locs + self.__locals = self.__idents_matching(test) + return self.__locals + + def get_globals(self): + """Return a tuple of globals in the function. + """ + if self.__globals is None: + glob = (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT) + test = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) in glob + self.__globals = self.__idents_matching(test) + return self.__globals + + def get_nonlocals(self): + """Return a tuple of nonlocals in the function. + """ + if self.__nonlocals is None: + self.__nonlocals = self.__idents_matching(lambda x:x & DEF_NONLOCAL) + return self.__nonlocals + + def get_frees(self): + """Return a tuple of free variables in the function. + """ + if self.__frees is None: + is_free = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) == FREE + self.__frees = self.__idents_matching(is_free) + return self.__frees + + +class Class(SymbolTable): + + __methods = None + + def get_methods(self): + """Return a tuple of methods declared in the class. + """ + if self.__methods is None: + d = {} + for st in self._table.children: + d[st.name] = 1 + self.__methods = tuple(d) + return self.__methods + + +class Symbol: + + def __init__(self, name, flags, namespaces=None, *, module_scope=False): + self.__name = name + self.__flags = flags + self.__scope = (flags >> SCOPE_OFF) & SCOPE_MASK # like PyST_GetScope() + self.__namespaces = namespaces or () + self.__module_scope = module_scope + + def __repr__(self): + return "".format(self.__name) + + def get_name(self): + """Return a name of a symbol. + """ + return self.__name + + def is_referenced(self): + """Return *True* if the symbol is used in + its block. + """ + return bool(self.__flags & _symtable.USE) + + def is_parameter(self): + """Return *True* if the symbol is a parameter. + """ + return bool(self.__flags & DEF_PARAM) + + def is_global(self): + """Return *True* if the symbol is global. + """ + return bool(self.__scope in (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT) + or (self.__module_scope and self.__flags & DEF_BOUND)) + + def is_nonlocal(self): + """Return *True* if the symbol is nonlocal.""" + return bool(self.__flags & DEF_NONLOCAL) + + def is_declared_global(self): + """Return *True* if the symbol is declared global + with a global statement.""" + return bool(self.__scope == GLOBAL_EXPLICIT) + + def is_local(self): + """Return *True* if the symbol is local. + """ + return bool(self.__scope in (LOCAL, CELL) + or (self.__module_scope and self.__flags & DEF_BOUND)) + + def is_annotated(self): + """Return *True* if the symbol is annotated. + """ + return bool(self.__flags & DEF_ANNOT) + + def is_free(self): + """Return *True* if a referenced symbol is + not assigned to. + """ + return bool(self.__scope == FREE) + + def is_imported(self): + """Return *True* if the symbol is created from + an import statement. + """ + return bool(self.__flags & DEF_IMPORT) + + def is_assigned(self): + """Return *True* if a symbol is assigned to.""" + return bool(self.__flags & DEF_LOCAL) + + def is_namespace(self): + """Returns *True* if name binding introduces new namespace. + + If the name is used as the target of a function or class + statement, this will be true. + + Note that a single name can be bound to multiple objects. If + is_namespace() is true, the name may also be bound to other + objects, like an int or list, that does not introduce a new + namespace. + """ + return bool(self.__namespaces) + + def get_namespaces(self): + """Return a list of namespaces bound to this name""" + return self.__namespaces + + def get_namespace(self): + """Return the single namespace bound to this name. + + Raises ValueError if the name is bound to multiple namespaces + or no namespace. + """ + if len(self.__namespaces) == 0: + raise ValueError("name is not bound to any namespaces") + elif len(self.__namespaces) > 1: + raise ValueError("name is bound to multiple namespaces") + else: + return self.__namespaces[0] + +if __name__ == "__main__": + import os, sys + with open(sys.argv[0]) as f: + src = f.read() + mod = symtable(src, os.path.split(sys.argv[0])[1], "exec") + for ident in mod.get_identifiers(): + info = mod.lookup(ident) + print(info, info.is_local(), info.is_namespace()) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/sysconfig.py b/physworld_p1_20261018/envs/p1/lib/python3.11/sysconfig.py new file mode 100644 index 0000000000000000000000000000000000000000..d51ba78d513c5a4deb0377de7f85486ff7461b33 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/sysconfig.py @@ -0,0 +1,852 @@ +"""Access to Python's configuration information.""" + +import os +import sys +from os.path import pardir, realpath + +__all__ = [ + 'get_config_h_filename', + 'get_config_var', + 'get_config_vars', + 'get_makefile_filename', + 'get_path', + 'get_path_names', + 'get_paths', + 'get_platform', + 'get_python_version', + 'get_scheme_names', + 'parse_config_h', +] + +# Keys for get_config_var() that are never converted to Python integers. +_ALWAYS_STR = { + 'MACOSX_DEPLOYMENT_TARGET', +} + +_INSTALL_SCHEMES = { + 'posix_prefix': { + 'stdlib': '{installed_base}/{platlibdir}/python{py_version_short}', + 'platstdlib': '{platbase}/{platlibdir}/python{py_version_short}', + 'purelib': '{base}/lib/python{py_version_short}/site-packages', + 'platlib': '{platbase}/{platlibdir}/python{py_version_short}/site-packages', + 'include': + '{installed_base}/include/python{py_version_short}{abiflags}', + 'platinclude': + '{installed_platbase}/include/python{py_version_short}{abiflags}', + 'scripts': '{base}/bin', + 'data': '{base}', + }, + 'posix_home': { + 'stdlib': '{installed_base}/lib/python', + 'platstdlib': '{base}/lib/python', + 'purelib': '{base}/lib/python', + 'platlib': '{base}/lib/python', + 'include': '{installed_base}/include/python', + 'platinclude': '{installed_base}/include/python', + 'scripts': '{base}/bin', + 'data': '{base}', + }, + 'nt': { + 'stdlib': '{installed_base}/Lib', + 'platstdlib': '{base}/Lib', + 'purelib': '{base}/Lib/site-packages', + 'platlib': '{base}/Lib/site-packages', + 'include': '{installed_base}/Include', + 'platinclude': '{installed_base}/Include', + 'scripts': '{base}/Scripts', + 'data': '{base}', + }, + # Downstream distributors can overwrite the default install scheme. + # This is done to support downstream modifications where distributors change + # the installation layout (eg. different site-packages directory). + # So, distributors will change the default scheme to one that correctly + # represents their layout. + # This presents an issue for projects/people that need to bootstrap virtual + # environments, like virtualenv. As distributors might now be customizing + # the default install scheme, there is no guarantee that the information + # returned by sysconfig.get_default_scheme/get_paths is correct for + # a virtual environment, the only guarantee we have is that it is correct + # for the *current* environment. When bootstrapping a virtual environment, + # we need to know its layout, so that we can place the files in the + # correct locations. + # The "*_venv" install scheme is a scheme to bootstrap virtual environments, + # essentially identical to the default posix_prefix/nt schemes. + # Downstream distributors who patch posix_prefix/nt scheme are encouraged to + # leave the following schemes unchanged + 'posix_venv': { + 'stdlib': '{installed_base}/{platlibdir}/python{py_version_short}', + 'platstdlib': '{platbase}/{platlibdir}/python{py_version_short}', + 'purelib': '{base}/lib/python{py_version_short}/site-packages', + 'platlib': '{platbase}/{platlibdir}/python{py_version_short}/site-packages', + 'include': + '{installed_base}/include/python{py_version_short}{abiflags}', + 'platinclude': + '{installed_platbase}/include/python{py_version_short}{abiflags}', + 'scripts': '{base}/bin', + 'data': '{base}', + }, + 'nt_venv': { + 'stdlib': '{installed_base}/Lib', + 'platstdlib': '{base}/Lib', + 'purelib': '{base}/Lib/site-packages', + 'platlib': '{base}/Lib/site-packages', + 'include': '{installed_base}/Include', + 'platinclude': '{installed_base}/Include', + 'scripts': '{base}/Scripts', + 'data': '{base}', + }, + } + +# For the OS-native venv scheme, we essentially provide an alias: +if os.name == 'nt': + _INSTALL_SCHEMES['venv'] = _INSTALL_SCHEMES['nt_venv'] +else: + _INSTALL_SCHEMES['venv'] = _INSTALL_SCHEMES['posix_venv'] + + +# NOTE: site.py has copy of this function. +# Sync it when modify this function. +def _getuserbase(): + env_base = os.environ.get("PYTHONUSERBASE", None) + if env_base: + return env_base + + # Emscripten, VxWorks, and WASI have no home directories + if sys.platform in {"emscripten", "vxworks", "wasi"}: + return None + + def joinuser(*args): + return os.path.expanduser(os.path.join(*args)) + + if os.name == "nt": + base = os.environ.get("APPDATA") or "~" + return joinuser(base, "Python") + + if sys.platform == "darwin" and sys._framework: + return joinuser("~", "Library", sys._framework, + f"{sys.version_info[0]}.{sys.version_info[1]}") + + return joinuser("~", ".local") + +_HAS_USER_BASE = (_getuserbase() is not None) + +if _HAS_USER_BASE: + _INSTALL_SCHEMES |= { + # NOTE: When modifying "purelib" scheme, update site._get_path() too. + 'nt_user': { + 'stdlib': '{userbase}/Python{py_version_nodot_plat}', + 'platstdlib': '{userbase}/Python{py_version_nodot_plat}', + 'purelib': '{userbase}/Python{py_version_nodot_plat}/site-packages', + 'platlib': '{userbase}/Python{py_version_nodot_plat}/site-packages', + 'include': '{userbase}/Python{py_version_nodot_plat}/Include', + 'scripts': '{userbase}/Python{py_version_nodot_plat}/Scripts', + 'data': '{userbase}', + }, + 'posix_user': { + 'stdlib': '{userbase}/{platlibdir}/python{py_version_short}', + 'platstdlib': '{userbase}/{platlibdir}/python{py_version_short}', + 'purelib': '{userbase}/lib/python{py_version_short}/site-packages', + 'platlib': '{userbase}/lib/python{py_version_short}/site-packages', + 'include': '{userbase}/include/python{py_version_short}', + 'scripts': '{userbase}/bin', + 'data': '{userbase}', + }, + 'osx_framework_user': { + 'stdlib': '{userbase}/lib/python', + 'platstdlib': '{userbase}/lib/python', + 'purelib': '{userbase}/lib/python/site-packages', + 'platlib': '{userbase}/lib/python/site-packages', + 'include': '{userbase}/include/python{py_version_short}', + 'scripts': '{userbase}/bin', + 'data': '{userbase}', + }, + } + +_SCHEME_KEYS = ('stdlib', 'platstdlib', 'purelib', 'platlib', 'include', + 'scripts', 'data') + +_PY_VERSION = sys.version.split()[0] +_PY_VERSION_SHORT = f'{sys.version_info[0]}.{sys.version_info[1]}' +_PY_VERSION_SHORT_NO_DOT = f'{sys.version_info[0]}{sys.version_info[1]}' +_PREFIX = os.path.normpath(sys.prefix) +_BASE_PREFIX = os.path.normpath(sys.base_prefix) +_EXEC_PREFIX = os.path.normpath(sys.exec_prefix) +_BASE_EXEC_PREFIX = os.path.normpath(sys.base_exec_prefix) +_CONFIG_VARS = None +_USER_BASE = None + +# Regexes needed for parsing Makefile (and similar syntaxes, +# like old-style Setup files). +_variable_rx = r"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)" +_findvar1_rx = r"\$\(([A-Za-z][A-Za-z0-9_]*)\)" +_findvar2_rx = r"\${([A-Za-z][A-Za-z0-9_]*)}" + + +def _safe_realpath(path): + try: + return realpath(path) + except OSError: + return path + +if sys.executable: + _PROJECT_BASE = os.path.dirname(_safe_realpath(sys.executable)) +else: + # sys.executable can be empty if argv[0] has been changed and Python is + # unable to retrieve the real program name + _PROJECT_BASE = _safe_realpath(os.getcwd()) + +# In a virtual environment, `sys._home` gives us the target directory +# `_PROJECT_BASE` for the executable that created it when the virtual +# python is an actual executable ('venv --copies' or Windows). +_sys_home = getattr(sys, '_home', None) +if _sys_home: + _PROJECT_BASE = _sys_home + +if os.name == 'nt': + # In a source build, the executable is in a subdirectory of the root + # that we want (\PCbuild\). + # `_BASE_PREFIX` is used as the base installation is where the source + # will be. The realpath is needed to prevent mount point confusion + # that can occur with just string comparisons. + if _safe_realpath(_PROJECT_BASE).startswith( + _safe_realpath(f'{_BASE_PREFIX}\\PCbuild')): + _PROJECT_BASE = _BASE_PREFIX + +# set for cross builds +if "_PYTHON_PROJECT_BASE" in os.environ: + _PROJECT_BASE = _safe_realpath(os.environ["_PYTHON_PROJECT_BASE"]) + +def is_python_build(check_home=None): + if check_home is not None: + import warnings + warnings.warn("check_home argument is deprecated and ignored.", + DeprecationWarning, stacklevel=2) + for fn in ("Setup", "Setup.local"): + if os.path.isfile(os.path.join(_PROJECT_BASE, "Modules", fn)): + return True + return False + +_PYTHON_BUILD = is_python_build() + +if _PYTHON_BUILD: + for scheme in ('posix_prefix', 'posix_home'): + # On POSIX-y platforms, Python will: + # - Build from .h files in 'headers' (which is only added to the + # scheme when building CPython) + # - Install .h files to 'include' + scheme = _INSTALL_SCHEMES[scheme] + scheme['headers'] = scheme['include'] + scheme['include'] = '{srcdir}/Include' + scheme['platinclude'] = '{projectbase}/.' + del scheme + + +def _subst_vars(s, local_vars): + try: + return s.format(**local_vars) + except KeyError as var: + try: + return s.format(**os.environ) + except KeyError: + raise AttributeError(f'{var}') from None + +def _extend_dict(target_dict, other_dict): + target_keys = target_dict.keys() + for key, value in other_dict.items(): + if key in target_keys: + continue + target_dict[key] = value + + +def _expand_vars(scheme, vars): + res = {} + if vars is None: + vars = {} + _extend_dict(vars, get_config_vars()) + if os.name == 'nt': + # On Windows we want to substitute 'lib' for schemes rather + # than the native value (without modifying vars, in case it + # was passed in) + vars = vars | {'platlibdir': 'lib'} + + for key, value in _INSTALL_SCHEMES[scheme].items(): + if os.name in ('posix', 'nt'): + value = os.path.expanduser(value) + res[key] = os.path.normpath(_subst_vars(value, vars)) + return res + + +def _get_preferred_schemes(): + if os.name == 'nt': + return { + 'prefix': 'nt', + 'home': 'posix_home', + 'user': 'nt_user', + } + if sys.platform == 'darwin' and sys._framework: + return { + 'prefix': 'posix_prefix', + 'home': 'posix_home', + 'user': 'osx_framework_user', + } + return { + 'prefix': 'posix_prefix', + 'home': 'posix_home', + 'user': 'posix_user', + } + + +def get_preferred_scheme(key): + if key == 'prefix' and sys.prefix != sys.base_prefix: + return 'venv' + scheme = _get_preferred_schemes()[key] + if scheme not in _INSTALL_SCHEMES: + raise ValueError( + f"{key!r} returned {scheme!r}, which is not a valid scheme " + f"on this platform" + ) + return scheme + + +def get_default_scheme(): + return get_preferred_scheme('prefix') + + +def _parse_makefile(filename, vars=None, keep_unresolved=True): + """Parse a Makefile-style file. + + A dictionary containing name/value pairs is returned. If an + optional dictionary is passed in as the second argument, it is + used instead of a new dictionary. + """ + import re + + if vars is None: + vars = {} + done = {} + notdone = {} + + with open(filename, encoding=sys.getfilesystemencoding(), + errors="surrogateescape") as f: + lines = f.readlines() + + for line in lines: + if line.startswith('#') or line.strip() == '': + continue + m = re.match(_variable_rx, line) + if m: + n, v = m.group(1, 2) + v = v.strip() + # `$$' is a literal `$' in make + tmpv = v.replace('$$', '') + + if "$" in tmpv: + notdone[n] = v + else: + try: + if n in _ALWAYS_STR: + raise ValueError + + v = int(v) + except ValueError: + # insert literal `$' + done[n] = v.replace('$$', '$') + else: + done[n] = v + + # do variable interpolation here + variables = list(notdone.keys()) + + # Variables with a 'PY_' prefix in the makefile. These need to + # be made available without that prefix through sysconfig. + # Special care is needed to ensure that variable expansion works, even + # if the expansion uses the name without a prefix. + renamed_variables = ('CFLAGS', 'LDFLAGS', 'CPPFLAGS') + + while len(variables) > 0: + for name in tuple(variables): + value = notdone[name] + m1 = re.search(_findvar1_rx, value) + m2 = re.search(_findvar2_rx, value) + if m1 and m2: + m = m1 if m1.start() < m2.start() else m2 + else: + m = m1 if m1 else m2 + if m is not None: + n = m.group(1) + found = True + if n in done: + item = str(done[n]) + elif n in notdone: + # get it on a subsequent round + found = False + elif n in os.environ: + # do it like make: fall back to environment + item = os.environ[n] + + elif n in renamed_variables: + if (name.startswith('PY_') and + name[3:] in renamed_variables): + item = "" + + elif 'PY_' + n in notdone: + found = False + + else: + item = str(done['PY_' + n]) + + else: + done[n] = item = "" + + if found: + after = value[m.end():] + value = value[:m.start()] + item + after + if "$" in after: + notdone[name] = value + else: + try: + if name in _ALWAYS_STR: + raise ValueError + value = int(value) + except ValueError: + done[name] = value.strip() + else: + done[name] = value + variables.remove(name) + + if name.startswith('PY_') \ + and name[3:] in renamed_variables: + + name = name[3:] + if name not in done: + done[name] = value + + else: + # Adds unresolved variables to the done dict. + # This is disabled when called from distutils.sysconfig + if keep_unresolved: + done[name] = value + # bogus variable reference (e.g. "prefix=$/opt/python"); + # just drop it since we can't deal + variables.remove(name) + + # strip spurious spaces + for k, v in done.items(): + if isinstance(v, str): + done[k] = v.strip() + + # save the results in the global dictionary + vars.update(done) + return vars + + +def get_makefile_filename(): + """Return the path of the Makefile.""" + if _PYTHON_BUILD: + return os.path.join(_PROJECT_BASE, "Makefile") + if hasattr(sys, 'abiflags'): + config_dir_name = f'config-{_PY_VERSION_SHORT}{sys.abiflags}' + else: + config_dir_name = 'config' + if hasattr(sys.implementation, '_multiarch'): + config_dir_name += f'-{sys.implementation._multiarch}' + return os.path.join(get_path('stdlib'), config_dir_name, 'Makefile') + + +def _get_sysconfigdata_name(): + multiarch = getattr(sys.implementation, '_multiarch', '') + return os.environ.get( + '_PYTHON_SYSCONFIGDATA_NAME', + f'_sysconfigdata_{sys.abiflags}_{sys.platform}_{multiarch}', + ) + + +def _generate_posix_vars(): + """Generate the Python module containing build-time variables.""" + import pprint + vars = {} + # load the installed Makefile: + makefile = get_makefile_filename() + try: + _parse_makefile(makefile, vars) + except OSError as e: + msg = f"invalid Python installation: unable to open {makefile}" + if hasattr(e, "strerror"): + msg = f"{msg} ({e.strerror})" + raise OSError(msg) + # load the installed pyconfig.h: + config_h = get_config_h_filename() + try: + with open(config_h, encoding="utf-8") as f: + parse_config_h(f, vars) + except OSError as e: + msg = f"invalid Python installation: unable to open {config_h}" + if hasattr(e, "strerror"): + msg = f"{msg} ({e.strerror})" + raise OSError(msg) + # On AIX, there are wrong paths to the linker scripts in the Makefile + # -- these paths are relative to the Python source, but when installed + # the scripts are in another directory. + if _PYTHON_BUILD: + vars['BLDSHARED'] = vars['LDSHARED'] + + # There's a chicken-and-egg situation on OS X with regards to the + # _sysconfigdata module after the changes introduced by #15298: + # get_config_vars() is called by get_platform() as part of the + # `make pybuilddir.txt` target -- which is a precursor to the + # _sysconfigdata.py module being constructed. Unfortunately, + # get_config_vars() eventually calls _init_posix(), which attempts + # to import _sysconfigdata, which we won't have built yet. In order + # for _init_posix() to work, if we're on Darwin, just mock up the + # _sysconfigdata module manually and populate it with the build vars. + # This is more than sufficient for ensuring the subsequent call to + # get_platform() succeeds. + name = _get_sysconfigdata_name() + if 'darwin' in sys.platform: + import types + module = types.ModuleType(name) + module.build_time_vars = vars + sys.modules[name] = module + + pybuilddir = f'build/lib.{get_platform()}-{_PY_VERSION_SHORT}' + if hasattr(sys, "gettotalrefcount"): + pybuilddir += '-pydebug' + os.makedirs(pybuilddir, exist_ok=True) + destfile = os.path.join(pybuilddir, name + '.py') + + with open(destfile, 'w', encoding='utf8') as f: + f.write('# system configuration generated and used by' + ' the sysconfig module\n') + f.write('build_time_vars = ') + pprint.pprint(vars, stream=f) + + # Create file used for sys.path fixup -- see Modules/getpath.c + with open('pybuilddir.txt', 'w', encoding='utf8') as f: + f.write(pybuilddir) + +def _init_posix(vars): + """Initialize the module as appropriate for POSIX systems.""" + # _sysconfigdata is generated at build time, see _generate_posix_vars() + name = _get_sysconfigdata_name() + _temp = __import__(name, globals(), locals(), ['build_time_vars'], 0) + build_time_vars = _temp.build_time_vars + vars.update(build_time_vars) + +def _init_non_posix(vars): + """Initialize the module as appropriate for NT""" + # set basic install directories + import _imp + vars['LIBDEST'] = get_path('stdlib') + vars['BINLIBDEST'] = get_path('platstdlib') + vars['INCLUDEPY'] = get_path('include') + vars['EXT_SUFFIX'] = _imp.extension_suffixes()[0] + vars['EXE'] = '.exe' + vars['VERSION'] = _PY_VERSION_SHORT_NO_DOT + vars['BINDIR'] = os.path.dirname(_safe_realpath(sys.executable)) + vars['TZPATH'] = '' + +# +# public APIs +# + + +def parse_config_h(fp, vars=None): + """Parse a config.h-style file. + + A dictionary containing name/value pairs is returned. If an + optional dictionary is passed in as the second argument, it is + used instead of a new dictionary. + """ + if vars is None: + vars = {} + import re + define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n") + undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n") + + while True: + line = fp.readline() + if not line: + break + m = define_rx.match(line) + if m: + n, v = m.group(1, 2) + try: + if n in _ALWAYS_STR: + raise ValueError + v = int(v) + except ValueError: + pass + vars[n] = v + else: + m = undef_rx.match(line) + if m: + vars[m.group(1)] = 0 + return vars + + +def get_config_h_filename(): + """Return the path of pyconfig.h.""" + if _PYTHON_BUILD: + if os.name == "nt": + inc_dir = os.path.join(_PROJECT_BASE, "PC") + else: + inc_dir = _PROJECT_BASE + else: + inc_dir = get_path('platinclude') + return os.path.join(inc_dir, 'pyconfig.h') + + +def get_scheme_names(): + """Return a tuple containing the schemes names.""" + return tuple(sorted(_INSTALL_SCHEMES)) + + +def get_path_names(): + """Return a tuple containing the paths names.""" + return _SCHEME_KEYS + + +def get_paths(scheme=get_default_scheme(), vars=None, expand=True): + """Return a mapping containing an install scheme. + + ``scheme`` is the install scheme name. If not provided, it will + return the default scheme for the current platform. + """ + if expand: + return _expand_vars(scheme, vars) + else: + return _INSTALL_SCHEMES[scheme] + + +def get_path(name, scheme=get_default_scheme(), vars=None, expand=True): + """Return a path corresponding to the scheme. + + ``scheme`` is the install scheme name. + """ + return get_paths(scheme, vars, expand)[name] + + +def get_config_vars(*args): + """With no arguments, return a dictionary of all configuration + variables relevant for the current platform. + + On Unix, this means every variable defined in Python's installed Makefile; + On Windows it's a much smaller set. + + With arguments, return a list of values that result from looking up + each argument in the configuration variable dictionary. + """ + global _CONFIG_VARS + if _CONFIG_VARS is None: + _CONFIG_VARS = {} + # Normalized versions of prefix and exec_prefix are handy to have; + # in fact, these are the standard versions used most places in the + # Distutils. + _CONFIG_VARS['prefix'] = _PREFIX + _CONFIG_VARS['exec_prefix'] = _EXEC_PREFIX + _CONFIG_VARS['py_version'] = _PY_VERSION + _CONFIG_VARS['py_version_short'] = _PY_VERSION_SHORT + _CONFIG_VARS['py_version_nodot'] = _PY_VERSION_SHORT_NO_DOT + _CONFIG_VARS['installed_base'] = _BASE_PREFIX + _CONFIG_VARS['base'] = _PREFIX + _CONFIG_VARS['installed_platbase'] = _BASE_EXEC_PREFIX + _CONFIG_VARS['platbase'] = _EXEC_PREFIX + _CONFIG_VARS['projectbase'] = _PROJECT_BASE + _CONFIG_VARS['platlibdir'] = sys.platlibdir + try: + _CONFIG_VARS['abiflags'] = sys.abiflags + except AttributeError: + # sys.abiflags may not be defined on all platforms. + _CONFIG_VARS['abiflags'] = '' + try: + _CONFIG_VARS['py_version_nodot_plat'] = sys.winver.replace('.', '') + except AttributeError: + _CONFIG_VARS['py_version_nodot_plat'] = '' + + if os.name == 'nt': + _init_non_posix(_CONFIG_VARS) + _CONFIG_VARS['VPATH'] = sys._vpath + _CONFIG_VARS['TZPATH'] = os.path.join(_PREFIX, "share", "zoneinfo") + if os.name == 'posix': + _init_posix(_CONFIG_VARS) + if _HAS_USER_BASE: + # Setting 'userbase' is done below the call to the + # init function to enable using 'get_config_var' in + # the init-function. + _CONFIG_VARS['userbase'] = _getuserbase() + + # Always convert srcdir to an absolute path + srcdir = _CONFIG_VARS.get('srcdir', _PROJECT_BASE) + if os.name == 'posix': + if _PYTHON_BUILD: + # If srcdir is a relative path (typically '.' or '..') + # then it should be interpreted relative to the directory + # containing Makefile. + base = os.path.dirname(get_makefile_filename()) + srcdir = os.path.join(base, srcdir) + else: + # srcdir is not meaningful since the installation is + # spread about the filesystem. We choose the + # directory containing the Makefile since we know it + # exists. + srcdir = os.path.dirname(get_makefile_filename()) + _CONFIG_VARS['srcdir'] = _safe_realpath(srcdir) + + # OS X platforms require special customization to handle + # multi-architecture, multi-os-version installers + if sys.platform == 'darwin': + import _osx_support + _osx_support.customize_config_vars(_CONFIG_VARS) + + if args: + vals = [] + for name in args: + vals.append(_CONFIG_VARS.get(name)) + return vals + else: + return _CONFIG_VARS + + +def get_config_var(name): + """Return the value of a single variable using the dictionary returned by + 'get_config_vars()'. + + Equivalent to get_config_vars().get(name) + """ + return get_config_vars().get(name) + + +def get_platform(): + """Return a string that identifies the current platform. + + This is used mainly to distinguish platform-specific build directories and + platform-specific built distributions. Typically includes the OS name and + version and the architecture (as supplied by 'os.uname()'), although the + exact information included depends on the OS; on Linux, the kernel version + isn't particularly important. + + Examples of returned values: + linux-i586 + linux-alpha (?) + solaris-2.6-sun4u + + Windows will return one of: + win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc) + win32 (all others - specifically, sys.platform is returned) + + For other non-POSIX platforms, currently just returns 'sys.platform'. + + """ + if os.name == 'nt': + if 'amd64' in sys.version.lower(): + return 'win-amd64' + if '(arm)' in sys.version.lower(): + return 'win-arm32' + if '(arm64)' in sys.version.lower(): + return 'win-arm64' + return sys.platform + + if os.name != "posix" or not hasattr(os, 'uname'): + # XXX what about the architecture? NT is Intel or Alpha + return sys.platform + + # Set for cross builds explicitly + if "_PYTHON_HOST_PLATFORM" in os.environ: + return os.environ["_PYTHON_HOST_PLATFORM"] + + # Try to distinguish various flavours of Unix + osname, host, release, version, machine = os.uname() + + # Convert the OS name to lowercase, remove '/' characters, and translate + # spaces (for "Power Macintosh") + osname = osname.lower().replace('/', '') + machine = machine.replace(' ', '_') + machine = machine.replace('/', '-') + + if osname[:5] == "linux": + # At least on Linux/Intel, 'machine' is the processor -- + # i386, etc. + # XXX what about Alpha, SPARC, etc? + return f"{osname}-{machine}" + elif osname[:5] == "sunos": + if release[0] >= "5": # SunOS 5 == Solaris 2 + osname = "solaris" + release = f"{int(release[0]) - 3}.{release[2:]}" + # We can't use "platform.architecture()[0]" because a + # bootstrap problem. We use a dict to get an error + # if some suspicious happens. + bitness = {2147483647:"32bit", 9223372036854775807:"64bit"} + machine += f".{bitness[sys.maxsize]}" + # fall through to standard osname-release-machine representation + elif osname[:3] == "aix": + from _aix_support import aix_platform + return aix_platform() + elif osname[:6] == "cygwin": + osname = "cygwin" + import re + rel_re = re.compile(r'[\d.]+') + m = rel_re.match(release) + if m: + release = m.group() + elif osname[:6] == "darwin": + import _osx_support + osname, release, machine = _osx_support.get_platform_osx( + get_config_vars(), + osname, release, machine) + + return f"{osname}-{release}-{machine}" + + +def get_python_version(): + return _PY_VERSION_SHORT + + +def expand_makefile_vars(s, vars): + """Expand Makefile-style variables -- "${foo}" or "$(foo)" -- in + 'string' according to 'vars' (a dictionary mapping variable names to + values). Variables not present in 'vars' are silently expanded to the + empty string. The variable values in 'vars' should not contain further + variable expansions; if 'vars' is the output of 'parse_makefile()', + you're fine. Returns a variable-expanded version of 's'. + """ + import re + + # This algorithm does multiple expansion, so if vars['foo'] contains + # "${bar}", it will expand ${foo} to ${bar}, and then expand + # ${bar}... and so forth. This is fine as long as 'vars' comes from + # 'parse_makefile()', which takes care of such expansions eagerly, + # according to make's variable expansion semantics. + + while True: + m = re.search(_findvar1_rx, s) or re.search(_findvar2_rx, s) + if m: + (beg, end) = m.span() + s = s[0:beg] + vars.get(m.group(1)) + s[end:] + else: + break + return s + + +def _print_dict(title, data): + for index, (key, value) in enumerate(sorted(data.items())): + if index == 0: + print(f'{title}: ') + print(f'\t{key} = "{value}"') + + +def _main(): + """Display all information sysconfig detains.""" + if '--generate-posix-vars' in sys.argv: + _generate_posix_vars() + return + print(f'Platform: "{get_platform()}"') + print(f'Python version: "{get_python_version()}"') + print(f'Current installation scheme: "{get_default_scheme()}"') + print() + _print_dict('Paths', get_paths()) + print() + _print_dict('Variables', get_config_vars()) + + +if __name__ == '__main__': + _main() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tabnanny.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tabnanny.py new file mode 100644 index 0000000000000000000000000000000000000000..a47f5a96b8972215bd2dfc7b4e07a11ea6a6921a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tabnanny.py @@ -0,0 +1,331 @@ +#! /usr/bin/env python3 + +"""The Tab Nanny despises ambiguous indentation. She knows no mercy. + +tabnanny -- Detection of ambiguous indentation + +For the time being this module is intended to be called as a script. +However it is possible to import it into an IDE and use the function +check() described below. + +Warning: The API provided by this module is likely to change in future +releases; such changes may not be backward compatible. +""" + +# Released to the public domain, by Tim Peters, 15 April 1998. + +# XXX Note: this is now a standard library module. +# XXX The API needs to undergo changes however; the current code is too +# XXX script-like. This will be addressed later. + +__version__ = "6" + +import os +import sys +import tokenize + +__all__ = ["check", "NannyNag", "process_tokens"] + +verbose = 0 +filename_only = 0 + +def errprint(*args): + sep = "" + for arg in args: + sys.stderr.write(sep + str(arg)) + sep = " " + sys.stderr.write("\n") + +def main(): + import getopt + + global verbose, filename_only + try: + opts, args = getopt.getopt(sys.argv[1:], "qv") + except getopt.error as msg: + errprint(msg) + return + for o, a in opts: + if o == '-q': + filename_only = filename_only + 1 + if o == '-v': + verbose = verbose + 1 + if not args: + errprint("Usage:", sys.argv[0], "[-v] file_or_directory ...") + return + for arg in args: + check(arg) + +class NannyNag(Exception): + """ + Raised by process_tokens() if detecting an ambiguous indent. + Captured and handled in check(). + """ + def __init__(self, lineno, msg, line): + self.lineno, self.msg, self.line = lineno, msg, line + def get_lineno(self): + return self.lineno + def get_msg(self): + return self.msg + def get_line(self): + return self.line + +def check(file): + """check(file_or_dir) + + If file_or_dir is a directory and not a symbolic link, then recursively + descend the directory tree named by file_or_dir, checking all .py files + along the way. If file_or_dir is an ordinary Python source file, it is + checked for whitespace related problems. The diagnostic messages are + written to standard output using the print statement. + """ + + if os.path.isdir(file) and not os.path.islink(file): + if verbose: + print("%r: listing directory" % (file,)) + names = os.listdir(file) + for name in names: + fullname = os.path.join(file, name) + if (os.path.isdir(fullname) and + not os.path.islink(fullname) or + os.path.normcase(name[-3:]) == ".py"): + check(fullname) + return + + try: + f = tokenize.open(file) + except OSError as msg: + errprint("%r: I/O Error: %s" % (file, msg)) + return + + if verbose > 1: + print("checking %r ..." % file) + + try: + process_tokens(tokenize.generate_tokens(f.readline)) + + except tokenize.TokenError as msg: + errprint("%r: Token Error: %s" % (file, msg)) + return + + except IndentationError as msg: + errprint("%r: Indentation Error: %s" % (file, msg)) + return + + except NannyNag as nag: + badline = nag.get_lineno() + line = nag.get_line() + if verbose: + print("%r: *** Line %d: trouble in tab city! ***" % (file, badline)) + print("offending line: %r" % (line,)) + print(nag.get_msg()) + else: + if ' ' in file: file = '"' + file + '"' + if filename_only: print(file) + else: print(file, badline, repr(line)) + return + + finally: + f.close() + + if verbose: + print("%r: Clean bill of health." % (file,)) + +class Whitespace: + # the characters used for space and tab + S, T = ' \t' + + # members: + # raw + # the original string + # n + # the number of leading whitespace characters in raw + # nt + # the number of tabs in raw[:n] + # norm + # the normal form as a pair (count, trailing), where: + # count + # a tuple such that raw[:n] contains count[i] + # instances of S * i + T + # trailing + # the number of trailing spaces in raw[:n] + # It's A Theorem that m.indent_level(t) == + # n.indent_level(t) for all t >= 1 iff m.norm == n.norm. + # is_simple + # true iff raw[:n] is of the form (T*)(S*) + + def __init__(self, ws): + self.raw = ws + S, T = Whitespace.S, Whitespace.T + count = [] + b = n = nt = 0 + for ch in self.raw: + if ch == S: + n = n + 1 + b = b + 1 + elif ch == T: + n = n + 1 + nt = nt + 1 + if b >= len(count): + count = count + [0] * (b - len(count) + 1) + count[b] = count[b] + 1 + b = 0 + else: + break + self.n = n + self.nt = nt + self.norm = tuple(count), b + self.is_simple = len(count) <= 1 + + # return length of longest contiguous run of spaces (whether or not + # preceding a tab) + def longest_run_of_spaces(self): + count, trailing = self.norm + return max(len(count)-1, trailing) + + def indent_level(self, tabsize): + # count, il = self.norm + # for i in range(len(count)): + # if count[i]: + # il = il + (i//tabsize + 1)*tabsize * count[i] + # return il + + # quicker: + # il = trailing + sum (i//ts + 1)*ts*count[i] = + # trailing + ts * sum (i//ts + 1)*count[i] = + # trailing + ts * sum i//ts*count[i] + count[i] = + # trailing + ts * [(sum i//ts*count[i]) + (sum count[i])] = + # trailing + ts * [(sum i//ts*count[i]) + num_tabs] + # and note that i//ts*count[i] is 0 when i < ts + + count, trailing = self.norm + il = 0 + for i in range(tabsize, len(count)): + il = il + i//tabsize * count[i] + return trailing + tabsize * (il + self.nt) + + # return true iff self.indent_level(t) == other.indent_level(t) + # for all t >= 1 + def equal(self, other): + return self.norm == other.norm + + # return a list of tuples (ts, i1, i2) such that + # i1 == self.indent_level(ts) != other.indent_level(ts) == i2. + # Intended to be used after not self.equal(other) is known, in which + # case it will return at least one witnessing tab size. + def not_equal_witness(self, other): + n = max(self.longest_run_of_spaces(), + other.longest_run_of_spaces()) + 1 + a = [] + for ts in range(1, n+1): + if self.indent_level(ts) != other.indent_level(ts): + a.append( (ts, + self.indent_level(ts), + other.indent_level(ts)) ) + return a + + # Return True iff self.indent_level(t) < other.indent_level(t) + # for all t >= 1. + # The algorithm is due to Vincent Broman. + # Easy to prove it's correct. + # XXXpost that. + # Trivial to prove n is sharp (consider T vs ST). + # Unknown whether there's a faster general way. I suspected so at + # first, but no longer. + # For the special (but common!) case where M and N are both of the + # form (T*)(S*), M.less(N) iff M.len() < N.len() and + # M.num_tabs() <= N.num_tabs(). Proof is easy but kinda long-winded. + # XXXwrite that up. + # Note that M is of the form (T*)(S*) iff len(M.norm[0]) <= 1. + def less(self, other): + if self.n >= other.n: + return False + if self.is_simple and other.is_simple: + return self.nt <= other.nt + n = max(self.longest_run_of_spaces(), + other.longest_run_of_spaces()) + 1 + # the self.n >= other.n test already did it for ts=1 + for ts in range(2, n+1): + if self.indent_level(ts) >= other.indent_level(ts): + return False + return True + + # return a list of tuples (ts, i1, i2) such that + # i1 == self.indent_level(ts) >= other.indent_level(ts) == i2. + # Intended to be used after not self.less(other) is known, in which + # case it will return at least one witnessing tab size. + def not_less_witness(self, other): + n = max(self.longest_run_of_spaces(), + other.longest_run_of_spaces()) + 1 + a = [] + for ts in range(1, n+1): + if self.indent_level(ts) >= other.indent_level(ts): + a.append( (ts, + self.indent_level(ts), + other.indent_level(ts)) ) + return a + +def format_witnesses(w): + firsts = (str(tup[0]) for tup in w) + prefix = "at tab size" + if len(w) > 1: + prefix = prefix + "s" + return prefix + " " + ', '.join(firsts) + +def process_tokens(tokens): + INDENT = tokenize.INDENT + DEDENT = tokenize.DEDENT + NEWLINE = tokenize.NEWLINE + JUNK = tokenize.COMMENT, tokenize.NL + indents = [Whitespace("")] + check_equal = 0 + + for (type, token, start, end, line) in tokens: + if type == NEWLINE: + # a program statement, or ENDMARKER, will eventually follow, + # after some (possibly empty) run of tokens of the form + # (NL | COMMENT)* (INDENT | DEDENT+)? + # If an INDENT appears, setting check_equal is wrong, and will + # be undone when we see the INDENT. + check_equal = 1 + + elif type == INDENT: + check_equal = 0 + thisguy = Whitespace(token) + if not indents[-1].less(thisguy): + witness = indents[-1].not_less_witness(thisguy) + msg = "indent not greater e.g. " + format_witnesses(witness) + raise NannyNag(start[0], msg, line) + indents.append(thisguy) + + elif type == DEDENT: + # there's nothing we need to check here! what's important is + # that when the run of DEDENTs ends, the indentation of the + # program statement (or ENDMARKER) that triggered the run is + # equal to what's left at the top of the indents stack + + # Ouch! This assert triggers if the last line of the source + # is indented *and* lacks a newline -- then DEDENTs pop out + # of thin air. + # assert check_equal # else no earlier NEWLINE, or an earlier INDENT + check_equal = 1 + + del indents[-1] + + elif check_equal and type not in JUNK: + # this is the first "real token" following a NEWLINE, so it + # must be the first token of the next program statement, or an + # ENDMARKER; the "line" argument exposes the leading whitespace + # for this statement; in the case of ENDMARKER, line is an empty + # string, so will properly match the empty string with which the + # "indents" stack was seeded + check_equal = 0 + thisguy = Whitespace(line) + if not indents[-1].equal(thisguy): + witness = indents[-1].not_equal_witness(thisguy) + msg = "indent not equal e.g. " + format_witnesses(witness) + raise NannyNag(start[0], msg, line) + + +if __name__ == '__main__': + main() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tarfile.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tarfile.py new file mode 100644 index 0000000000000000000000000000000000000000..8c2dd869db4788d5c1a934aae1c3bb9e4348f6c7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tarfile.py @@ -0,0 +1,3071 @@ +#!/usr/bin/env python3 +#------------------------------------------------------------------- +# tarfile.py +#------------------------------------------------------------------- +# Copyright (C) 2002 Lars Gustaebel +# All rights reserved. +# +# Permission is hereby granted, free of charge, to any person +# obtaining a copy of this software and associated documentation +# files (the "Software"), to deal in the Software without +# restriction, including without limitation the rights to use, +# copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following +# conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +# OTHER DEALINGS IN THE SOFTWARE. +# +"""Read from and write to tar format archives. +""" + +version = "0.9.0" +__author__ = "Lars Gust\u00e4bel (lars@gustaebel.de)" +__credits__ = "Gustavo Niemeyer, Niels Gust\u00e4bel, Richard Townsend." + +#--------- +# Imports +#--------- +from builtins import open as bltn_open +import sys +import os +import io +import shutil +import stat +import time +import struct +import copy +import re +import warnings + +try: + import pwd +except ImportError: + pwd = None +try: + import grp +except ImportError: + grp = None + +# os.symlink on Windows prior to 6.0 raises NotImplementedError +symlink_exception = (AttributeError, NotImplementedError) +try: + # OSError (winerror=1314) will be raised if the caller does not hold the + # SeCreateSymbolicLinkPrivilege privilege + symlink_exception += (OSError,) +except NameError: + pass + +# from tarfile import * +__all__ = ["TarFile", "TarInfo", "is_tarfile", "TarError", "ReadError", + "CompressionError", "StreamError", "ExtractError", "HeaderError", + "ENCODING", "USTAR_FORMAT", "GNU_FORMAT", "PAX_FORMAT", + "DEFAULT_FORMAT", "open"] + + +#--------------------------------------------------------- +# tar constants +#--------------------------------------------------------- +NUL = b"\0" # the null character +BLOCKSIZE = 512 # length of processing blocks +RECORDSIZE = BLOCKSIZE * 20 # length of records +GNU_MAGIC = b"ustar \0" # magic gnu tar string +POSIX_MAGIC = b"ustar\x0000" # magic posix tar string + +LENGTH_NAME = 100 # maximum length of a filename +LENGTH_LINK = 100 # maximum length of a linkname +LENGTH_PREFIX = 155 # maximum length of the prefix field + +REGTYPE = b"0" # regular file +AREGTYPE = b"\0" # regular file +LNKTYPE = b"1" # link (inside tarfile) +SYMTYPE = b"2" # symbolic link +CHRTYPE = b"3" # character special device +BLKTYPE = b"4" # block special device +DIRTYPE = b"5" # directory +FIFOTYPE = b"6" # fifo special device +CONTTYPE = b"7" # contiguous file + +GNUTYPE_LONGNAME = b"L" # GNU tar longname +GNUTYPE_LONGLINK = b"K" # GNU tar longlink +GNUTYPE_SPARSE = b"S" # GNU tar sparse file + +XHDTYPE = b"x" # POSIX.1-2001 extended header +XGLTYPE = b"g" # POSIX.1-2001 global header +SOLARIS_XHDTYPE = b"X" # Solaris extended header + +USTAR_FORMAT = 0 # POSIX.1-1988 (ustar) format +GNU_FORMAT = 1 # GNU tar format +PAX_FORMAT = 2 # POSIX.1-2001 (pax) format +DEFAULT_FORMAT = PAX_FORMAT + +#--------------------------------------------------------- +# tarfile constants +#--------------------------------------------------------- +# File types that tarfile supports: +SUPPORTED_TYPES = (REGTYPE, AREGTYPE, LNKTYPE, + SYMTYPE, DIRTYPE, FIFOTYPE, + CONTTYPE, CHRTYPE, BLKTYPE, + GNUTYPE_LONGNAME, GNUTYPE_LONGLINK, + GNUTYPE_SPARSE) + +# File types that will be treated as a regular file. +REGULAR_TYPES = (REGTYPE, AREGTYPE, + CONTTYPE, GNUTYPE_SPARSE) + +# File types that are part of the GNU tar format. +GNU_TYPES = (GNUTYPE_LONGNAME, GNUTYPE_LONGLINK, + GNUTYPE_SPARSE) + +# Fields from a pax header that override a TarInfo attribute. +PAX_FIELDS = ("path", "linkpath", "size", "mtime", + "uid", "gid", "uname", "gname") + +# Fields from a pax header that are affected by hdrcharset. +PAX_NAME_FIELDS = {"path", "linkpath", "uname", "gname"} + +# Fields in a pax header that are numbers, all other fields +# are treated as strings. +PAX_NUMBER_FIELDS = { + "atime": float, + "ctime": float, + "mtime": float, + "uid": int, + "gid": int, + "size": int +} + +#--------------------------------------------------------- +# initialization +#--------------------------------------------------------- +if os.name == "nt": + ENCODING = "utf-8" +else: + ENCODING = sys.getfilesystemencoding() + +#--------------------------------------------------------- +# Some useful functions +#--------------------------------------------------------- + +def stn(s, length, encoding, errors): + """Convert a string to a null-terminated bytes object. + """ + if s is None: + raise ValueError("metadata cannot contain None") + s = s.encode(encoding, errors) + return s[:length] + (length - len(s)) * NUL + +def nts(s, encoding, errors): + """Convert a null-terminated bytes object to a string. + """ + p = s.find(b"\0") + if p != -1: + s = s[:p] + return s.decode(encoding, errors) + +def nti(s): + """Convert a number field to a python number. + """ + # There are two possible encodings for a number field, see + # itn() below. + if s[0] in (0o200, 0o377): + n = 0 + for i in range(len(s) - 1): + n <<= 8 + n += s[i + 1] + if s[0] == 0o377: + n = -(256 ** (len(s) - 1) - n) + else: + try: + s = nts(s, "ascii", "strict") + n = int(s.strip() or "0", 8) + except ValueError: + raise InvalidHeaderError("invalid header") + return n + +def itn(n, digits=8, format=DEFAULT_FORMAT): + """Convert a python number to a number field. + """ + # POSIX 1003.1-1988 requires numbers to be encoded as a string of + # octal digits followed by a null-byte, this allows values up to + # (8**(digits-1))-1. GNU tar allows storing numbers greater than + # that if necessary. A leading 0o200 or 0o377 byte indicate this + # particular encoding, the following digits-1 bytes are a big-endian + # base-256 representation. This allows values up to (256**(digits-1))-1. + # A 0o200 byte indicates a positive number, a 0o377 byte a negative + # number. + original_n = n + n = int(n) + if 0 <= n < 8 ** (digits - 1): + s = bytes("%0*o" % (digits - 1, n), "ascii") + NUL + elif format == GNU_FORMAT and -256 ** (digits - 1) <= n < 256 ** (digits - 1): + if n >= 0: + s = bytearray([0o200]) + else: + s = bytearray([0o377]) + n = 256 ** digits + n + + for i in range(digits - 1): + s.insert(1, n & 0o377) + n >>= 8 + else: + raise ValueError("overflow in number field") + + return s + +def calc_chksums(buf): + """Calculate the checksum for a member's header by summing up all + characters except for the chksum field which is treated as if + it was filled with spaces. According to the GNU tar sources, + some tars (Sun and NeXT) calculate chksum with signed char, + which will be different if there are chars in the buffer with + the high bit set. So we calculate two checksums, unsigned and + signed. + """ + unsigned_chksum = 256 + sum(struct.unpack_from("148B8x356B", buf)) + signed_chksum = 256 + sum(struct.unpack_from("148b8x356b", buf)) + return unsigned_chksum, signed_chksum + +def copyfileobj(src, dst, length=None, exception=OSError, bufsize=None): + """Copy length bytes from fileobj src to fileobj dst. + If length is None, copy the entire content. + """ + bufsize = bufsize or 16 * 1024 + if length == 0: + return + if length is None: + shutil.copyfileobj(src, dst, bufsize) + return + + blocks, remainder = divmod(length, bufsize) + for b in range(blocks): + buf = src.read(bufsize) + if len(buf) < bufsize: + raise exception("unexpected end of data") + dst.write(buf) + + if remainder != 0: + buf = src.read(remainder) + if len(buf) < remainder: + raise exception("unexpected end of data") + dst.write(buf) + return + +def _safe_print(s): + encoding = getattr(sys.stdout, 'encoding', None) + if encoding is not None: + s = s.encode(encoding, 'backslashreplace').decode(encoding) + print(s, end=' ') + + +class TarError(Exception): + """Base exception.""" + pass +class ExtractError(TarError): + """General exception for extract errors.""" + pass +class ReadError(TarError): + """Exception for unreadable tar archives.""" + pass +class CompressionError(TarError): + """Exception for unavailable compression methods.""" + pass +class StreamError(TarError): + """Exception for unsupported operations on stream-like TarFiles.""" + pass +class HeaderError(TarError): + """Base exception for header errors.""" + pass +class EmptyHeaderError(HeaderError): + """Exception for empty headers.""" + pass +class TruncatedHeaderError(HeaderError): + """Exception for truncated headers.""" + pass +class EOFHeaderError(HeaderError): + """Exception for end of file headers.""" + pass +class InvalidHeaderError(HeaderError): + """Exception for invalid headers.""" + pass +class SubsequentHeaderError(HeaderError): + """Exception for missing and invalid extended headers.""" + pass + +#--------------------------- +# internal stream interface +#--------------------------- +class _LowLevelFile: + """Low-level file object. Supports reading and writing. + It is used instead of a regular file object for streaming + access. + """ + + def __init__(self, name, mode): + mode = { + "r": os.O_RDONLY, + "w": os.O_WRONLY | os.O_CREAT | os.O_TRUNC, + }[mode] + if hasattr(os, "O_BINARY"): + mode |= os.O_BINARY + self.fd = os.open(name, mode, 0o666) + + def close(self): + os.close(self.fd) + + def read(self, size): + return os.read(self.fd, size) + + def write(self, s): + os.write(self.fd, s) + +class _Stream: + """Class that serves as an adapter between TarFile and + a stream-like object. The stream-like object only + needs to have a read() or write() method that works with bytes, + and the method is accessed blockwise. + Use of gzip or bzip2 compression is possible. + A stream-like object could be for example: sys.stdin.buffer, + sys.stdout.buffer, a socket, a tape device etc. + + _Stream is intended to be used only internally. + """ + + def __init__(self, name, mode, comptype, fileobj, bufsize): + """Construct a _Stream object. + """ + self._extfileobj = True + if fileobj is None: + fileobj = _LowLevelFile(name, mode) + self._extfileobj = False + + if comptype == '*': + # Enable transparent compression detection for the + # stream interface + fileobj = _StreamProxy(fileobj) + comptype = fileobj.getcomptype() + + self.name = name or "" + self.mode = mode + self.comptype = comptype + self.fileobj = fileobj + self.bufsize = bufsize + self.buf = b"" + self.pos = 0 + self.closed = False + + try: + if comptype == "gz": + try: + import zlib + except ImportError: + raise CompressionError("zlib module is not available") from None + self.zlib = zlib + self.crc = zlib.crc32(b"") + if mode == "r": + self.exception = zlib.error + self._init_read_gz() + else: + self._init_write_gz() + + elif comptype == "bz2": + try: + import bz2 + except ImportError: + raise CompressionError("bz2 module is not available") from None + if mode == "r": + self.dbuf = b"" + self.cmp = bz2.BZ2Decompressor() + self.exception = OSError + else: + self.cmp = bz2.BZ2Compressor() + + elif comptype == "xz": + try: + import lzma + except ImportError: + raise CompressionError("lzma module is not available") from None + if mode == "r": + self.dbuf = b"" + self.cmp = lzma.LZMADecompressor() + self.exception = lzma.LZMAError + else: + self.cmp = lzma.LZMACompressor() + + elif comptype != "tar": + raise CompressionError("unknown compression type %r" % comptype) + + except: + if not self._extfileobj: + self.fileobj.close() + self.closed = True + raise + + def __del__(self): + if hasattr(self, "closed") and not self.closed: + self.close() + + def _init_write_gz(self): + """Initialize for writing with gzip compression. + """ + self.cmp = self.zlib.compressobj(9, self.zlib.DEFLATED, + -self.zlib.MAX_WBITS, + self.zlib.DEF_MEM_LEVEL, + 0) + timestamp = struct.pack(" self.bufsize: + self.fileobj.write(self.buf[:self.bufsize]) + self.buf = self.buf[self.bufsize:] + + def close(self): + """Close the _Stream object. No operation should be + done on it afterwards. + """ + if self.closed: + return + + self.closed = True + try: + if self.mode == "w" and self.comptype != "tar": + self.buf += self.cmp.flush() + + if self.mode == "w" and self.buf: + self.fileobj.write(self.buf) + self.buf = b"" + if self.comptype == "gz": + self.fileobj.write(struct.pack("= 0: + blocks, remainder = divmod(pos - self.pos, self.bufsize) + for i in range(blocks): + data = self.read(self.bufsize) + if not data: + break + self.read(remainder) + else: + raise StreamError("seeking backwards is not allowed") + return self.pos + + def read(self, size): + """Return the next size number of bytes from the stream.""" + assert size is not None + buf = self._read(size) + self.pos += len(buf) + return buf + + def _read(self, size): + """Return size bytes from the stream. + """ + if self.comptype == "tar": + return self.__read(size) + + c = len(self.dbuf) + t = [self.dbuf] + while c < size: + # Skip underlying buffer to avoid unaligned double buffering. + if self.buf: + buf = self.buf + self.buf = b"" + else: + buf = self.fileobj.read(self.bufsize) + if not buf: + break + try: + buf = self.cmp.decompress(buf) + except self.exception as e: + raise ReadError("invalid compressed data") from e + t.append(buf) + c += len(buf) + t = b"".join(t) + self.dbuf = t[size:] + return t[:size] + + def __read(self, size): + """Return size bytes from stream. If internal buffer is empty, + read another block from the stream. + """ + c = len(self.buf) + t = [self.buf] + while c < size: + buf = self.fileobj.read(self.bufsize) + if not buf: + break + t.append(buf) + c += len(buf) + t = b"".join(t) + self.buf = t[size:] + return t[:size] +# class _Stream + +class _StreamProxy(object): + """Small proxy class that enables transparent compression + detection for the Stream interface (mode 'r|*'). + """ + + def __init__(self, fileobj): + self.fileobj = fileobj + self.buf = self.fileobj.read(BLOCKSIZE) + + def read(self, size): + self.read = self.fileobj.read + return self.buf + + def getcomptype(self): + if self.buf.startswith(b"\x1f\x8b\x08"): + return "gz" + elif self.buf[0:3] == b"BZh" and self.buf[4:10] == b"1AY&SY": + return "bz2" + elif self.buf.startswith((b"\x5d\x00\x00\x80", b"\xfd7zXZ")): + return "xz" + else: + return "tar" + + def close(self): + self.fileobj.close() +# class StreamProxy + +#------------------------ +# Extraction file object +#------------------------ +class _FileInFile(object): + """A thin wrapper around an existing file object that + provides a part of its data as an individual file + object. + """ + + def __init__(self, fileobj, offset, size, blockinfo=None): + self.fileobj = fileobj + self.offset = offset + self.size = size + self.position = 0 + self.name = getattr(fileobj, "name", None) + self.closed = False + + if blockinfo is None: + blockinfo = [(0, size)] + + # Construct a map with data and zero blocks. + self.map_index = 0 + self.map = [] + lastpos = 0 + realpos = self.offset + for offset, size in blockinfo: + if offset > lastpos: + self.map.append((False, lastpos, offset, None)) + self.map.append((True, offset, offset + size, realpos)) + realpos += size + lastpos = offset + size + if lastpos < self.size: + self.map.append((False, lastpos, self.size, None)) + + def flush(self): + pass + + def readable(self): + return True + + def writable(self): + return False + + def seekable(self): + return self.fileobj.seekable() + + def tell(self): + """Return the current file position. + """ + return self.position + + def seek(self, position, whence=io.SEEK_SET): + """Seek to a position in the file. + """ + if whence == io.SEEK_SET: + self.position = min(max(position, 0), self.size) + elif whence == io.SEEK_CUR: + if position < 0: + self.position = max(self.position + position, 0) + else: + self.position = min(self.position + position, self.size) + elif whence == io.SEEK_END: + self.position = max(min(self.size + position, self.size), 0) + else: + raise ValueError("Invalid argument") + return self.position + + def read(self, size=None): + """Read data from the file. + """ + if size is None: + size = self.size - self.position + else: + size = min(size, self.size - self.position) + + buf = b"" + while size > 0: + while True: + data, start, stop, offset = self.map[self.map_index] + if start <= self.position < stop: + break + else: + self.map_index += 1 + if self.map_index == len(self.map): + self.map_index = 0 + length = min(size, stop - self.position) + if data: + self.fileobj.seek(offset + (self.position - start)) + b = self.fileobj.read(length) + if len(b) != length: + raise ReadError("unexpected end of data") + buf += b + else: + buf += NUL * length + size -= length + self.position += length + return buf + + def readinto(self, b): + buf = self.read(len(b)) + b[:len(buf)] = buf + return len(buf) + + def close(self): + self.closed = True +#class _FileInFile + +class ExFileObject(io.BufferedReader): + + def __init__(self, tarfile, tarinfo): + fileobj = _FileInFile(tarfile.fileobj, tarinfo.offset_data, + tarinfo.size, tarinfo.sparse) + super().__init__(fileobj) +#class ExFileObject + + +#----------------------------- +# extraction filters (PEP 706) +#----------------------------- + +class FilterError(TarError): + pass + +class AbsolutePathError(FilterError): + def __init__(self, tarinfo): + self.tarinfo = tarinfo + super().__init__(f'member {tarinfo.name!r} has an absolute path') + +class OutsideDestinationError(FilterError): + def __init__(self, tarinfo, path): + self.tarinfo = tarinfo + self._path = path + super().__init__(f'{tarinfo.name!r} would be extracted to {path!r}, ' + + 'which is outside the destination') + +class SpecialFileError(FilterError): + def __init__(self, tarinfo): + self.tarinfo = tarinfo + super().__init__(f'{tarinfo.name!r} is a special file') + +class AbsoluteLinkError(FilterError): + def __init__(self, tarinfo): + self.tarinfo = tarinfo + super().__init__(f'{tarinfo.name!r} is a link to an absolute path') + +class LinkOutsideDestinationError(FilterError): + def __init__(self, tarinfo, path): + self.tarinfo = tarinfo + self._path = path + super().__init__(f'{tarinfo.name!r} would link to {path!r}, ' + + 'which is outside the destination') + +class LinkFallbackError(FilterError): + def __init__(self, tarinfo, path): + self.tarinfo = tarinfo + self._path = path + super().__init__(f'link {tarinfo.name!r} would be extracted as a ' + + f'copy of {path!r}, which was rejected') + +# Errors caused by filters -- both "fatal" and "non-fatal" -- that +# we consider to be issues with the argument, rather than a bug in the +# filter function +_FILTER_ERRORS = (FilterError, OSError, ExtractError) + +def _get_filtered_attrs(member, dest_path, for_data=True): + new_attrs = {} + name = member.name + dest_path = os.path.realpath(dest_path, strict=os.path.ALLOW_MISSING) + # Strip leading / (tar's directory separator) from filenames. + # Include os.sep (target OS directory separator) as well. + if name.startswith(('/', os.sep)): + name = new_attrs['name'] = member.path.lstrip('/' + os.sep) + if os.path.isabs(name): + # Path is absolute even after stripping. + # For example, 'C:/foo' on Windows. + raise AbsolutePathError(member) + # Ensure we stay in the destination + if '..' in name.replace(os.sep, '/').split('/'): + # Directories are created from the name as given, so a name that + # leaves the destination part-way through would create them + # outside it even if the resolved path stays inside. + normalized = os.path.normpath(name) + if normalized != name: + name = new_attrs['name'] = normalized + target_path = os.path.realpath(os.path.join(dest_path, name), + strict=os.path.ALLOW_MISSING) + if os.path.commonpath([target_path, dest_path]) != dest_path: + raise OutsideDestinationError(member, target_path) + # Limit permissions (no high bits, and go-w) + mode = member.mode + if mode is not None: + # Strip high bits & group/other write bits + mode = mode & 0o755 + if for_data: + # For data, handle permissions & file types + if member.isreg() or member.islnk(): + if not mode & 0o100: + # Clear executable bits if not executable by user + mode &= ~0o111 + # Ensure owner can read & write + mode |= 0o600 + elif member.isdir() or member.issym(): + # Ignore mode for directories & symlinks + mode = None + else: + # Reject special files + raise SpecialFileError(member) + if mode != member.mode: + new_attrs['mode'] = mode + if for_data: + # Ignore ownership for 'data' + if member.uid is not None: + new_attrs['uid'] = None + if member.gid is not None: + new_attrs['gid'] = None + if member.uname is not None: + new_attrs['uname'] = None + if member.gname is not None: + new_attrs['gname'] = None + # Check link destination for 'data' + if member.islnk() or member.issym(): + if os.path.isabs(member.linkname): + raise AbsoluteLinkError(member) + # A link member that resolves to the destination directory itself + # would replace it with a (sym)link, redirecting the destination + # for all subsequent members. + if target_path == dest_path: + raise OutsideDestinationError(member, target_path) + normalized = os.path.normpath(member.linkname) + if normalized != member.linkname: + new_attrs['linkname'] = normalized + if member.issym(): + # The symlink is created at `name` with trailing separators + # stripped, so its target is relative to the directory + # containing that path. + link_dir = os.path.dirname(name.rstrip('/' + os.sep)) + target_path = os.path.join(dest_path, link_dir, normalized) + else: + target_path = os.path.join(dest_path, normalized) + target_path = os.path.realpath(target_path, + strict=os.path.ALLOW_MISSING) + if os.path.commonpath([target_path, dest_path]) != dest_path: + raise LinkOutsideDestinationError(member, target_path) + return new_attrs + +def fully_trusted_filter(member, dest_path): + return member + +def tar_filter(member, dest_path): + new_attrs = _get_filtered_attrs(member, dest_path, False) + if new_attrs: + return member.replace(**new_attrs, deep=False) + return member + +def data_filter(member, dest_path): + new_attrs = _get_filtered_attrs(member, dest_path, True) + if new_attrs: + return member.replace(**new_attrs, deep=False) + return member + +_NAMED_FILTERS = { + "fully_trusted": fully_trusted_filter, + "tar": tar_filter, + "data": data_filter, +} + +#------------------ +# Exported Classes +#------------------ + +# Sentinel for replace() defaults, meaning "don't change the attribute" +_KEEP = object() + +# Header length is digits followed by a space. +_header_length_prefix_re = re.compile(br"([0-9]{1,20}) ") + +class TarInfo(object): + """Informational class which holds the details about an + archive member given by a tar header block. + TarInfo objects are returned by TarFile.getmember(), + TarFile.getmembers() and TarFile.gettarinfo() and are + usually created internally. + """ + + __slots__ = dict( + name = 'Name of the archive member.', + mode = 'Permission bits.', + uid = 'User ID of the user who originally stored this member.', + gid = 'Group ID of the user who originally stored this member.', + size = 'Size in bytes.', + mtime = 'Time of last modification.', + chksum = 'Header checksum.', + type = ('File type. type is usually one of these constants: ' + 'REGTYPE, AREGTYPE, LNKTYPE, SYMTYPE, DIRTYPE, FIFOTYPE, ' + 'CONTTYPE, CHRTYPE, BLKTYPE, GNUTYPE_SPARSE.'), + linkname = ('Name of the target file name, which is only present ' + 'in TarInfo objects of type LNKTYPE and SYMTYPE.'), + uname = 'User name.', + gname = 'Group name.', + devmajor = 'Device major number.', + devminor = 'Device minor number.', + offset = 'The tar header starts here.', + offset_data = "The file's data starts here.", + pax_headers = ('A dictionary containing key-value pairs of an ' + 'associated pax extended header.'), + sparse = 'Sparse member information.', + tarfile = None, + _sparse_structs = None, + _link_target = None, + ) + + def __init__(self, name=""): + """Construct a TarInfo object. name is the optional name + of the member. + """ + self.name = name # member name + self.mode = 0o644 # file permissions + self.uid = 0 # user id + self.gid = 0 # group id + self.size = 0 # file size + self.mtime = 0 # modification time + self.chksum = 0 # header checksum + self.type = REGTYPE # member type + self.linkname = "" # link name + self.uname = "" # user name + self.gname = "" # group name + self.devmajor = 0 # device major number + self.devminor = 0 # device minor number + + self.offset = 0 # the tar header starts here + self.offset_data = 0 # the file's data starts here + + self.sparse = None # sparse member information + self.pax_headers = {} # pax header information + + @property + def path(self): + 'In pax headers, "name" is called "path".' + return self.name + + @path.setter + def path(self, name): + self.name = name + + @property + def linkpath(self): + 'In pax headers, "linkname" is called "linkpath".' + return self.linkname + + @linkpath.setter + def linkpath(self, linkname): + self.linkname = linkname + + def __repr__(self): + return "<%s %r at %#x>" % (self.__class__.__name__,self.name,id(self)) + + def replace(self, *, + name=_KEEP, mtime=_KEEP, mode=_KEEP, linkname=_KEEP, + uid=_KEEP, gid=_KEEP, uname=_KEEP, gname=_KEEP, + deep=True, _KEEP=_KEEP): + """Return a deep copy of self with the given attributes replaced. + """ + if deep: + result = copy.deepcopy(self) + else: + result = copy.copy(self) + if name is not _KEEP: + result.name = name + if mtime is not _KEEP: + result.mtime = mtime + if mode is not _KEEP: + result.mode = mode + if linkname is not _KEEP: + result.linkname = linkname + if uid is not _KEEP: + result.uid = uid + if gid is not _KEEP: + result.gid = gid + if uname is not _KEEP: + result.uname = uname + if gname is not _KEEP: + result.gname = gname + return result + + def get_info(self): + """Return the TarInfo's attributes as a dictionary. + """ + if self.mode is None: + mode = None + else: + mode = self.mode & 0o7777 + info = { + "name": self.name, + "mode": mode, + "uid": self.uid, + "gid": self.gid, + "size": self.size, + "mtime": self.mtime, + "chksum": self.chksum, + "type": self.type, + "linkname": self.linkname, + "uname": self.uname, + "gname": self.gname, + "devmajor": self.devmajor, + "devminor": self.devminor + } + + if info["type"] == DIRTYPE and not info["name"].endswith("/"): + info["name"] += "/" + + return info + + def tobuf(self, format=DEFAULT_FORMAT, encoding=ENCODING, errors="surrogateescape"): + """Return a tar header as a string of 512 byte blocks. + """ + info = self.get_info() + for name, value in info.items(): + if value is None: + raise ValueError("%s may not be None" % name) + + if format == USTAR_FORMAT: + return self.create_ustar_header(info, encoding, errors) + elif format == GNU_FORMAT: + return self.create_gnu_header(info, encoding, errors) + elif format == PAX_FORMAT: + return self.create_pax_header(info, encoding) + else: + raise ValueError("invalid format") + + def create_ustar_header(self, info, encoding, errors): + """Return the object as a ustar header block. + """ + info["magic"] = POSIX_MAGIC + + if len(info["linkname"].encode(encoding, errors)) > LENGTH_LINK: + raise ValueError("linkname is too long") + + if len(info["name"].encode(encoding, errors)) > LENGTH_NAME: + info["prefix"], info["name"] = self._posix_split_name(info["name"], encoding, errors) + + return self._create_header(info, USTAR_FORMAT, encoding, errors) + + def create_gnu_header(self, info, encoding, errors): + """Return the object as a GNU header block sequence. + """ + info["magic"] = GNU_MAGIC + + buf = b"" + if len(info["linkname"].encode(encoding, errors)) > LENGTH_LINK: + buf += self._create_gnu_long_header(info["linkname"], GNUTYPE_LONGLINK, encoding, errors) + + if len(info["name"].encode(encoding, errors)) > LENGTH_NAME: + buf += self._create_gnu_long_header(info["name"], GNUTYPE_LONGNAME, encoding, errors) + + return buf + self._create_header(info, GNU_FORMAT, encoding, errors) + + def create_pax_header(self, info, encoding): + """Return the object as a ustar header block. If it cannot be + represented this way, prepend a pax extended header sequence + with supplement information. + """ + info["magic"] = POSIX_MAGIC + pax_headers = self.pax_headers.copy() + + # Test string fields for values that exceed the field length or cannot + # be represented in ASCII encoding. + for name, hname, length in ( + ("name", "path", LENGTH_NAME), ("linkname", "linkpath", LENGTH_LINK), + ("uname", "uname", 32), ("gname", "gname", 32)): + + if hname in pax_headers: + # The pax header has priority. + continue + + # Try to encode the string as ASCII. + try: + info[name].encode("ascii", "strict") + except UnicodeEncodeError: + pax_headers[hname] = info[name] + continue + + if len(info[name]) > length: + pax_headers[hname] = info[name] + + # Test number fields for values that exceed the field limit or values + # that like to be stored as float. + for name, digits in (("uid", 8), ("gid", 8), ("size", 12), ("mtime", 12)): + needs_pax = False + + val = info[name] + val_is_float = isinstance(val, float) + val_int = round(val) if val_is_float else val + if not 0 <= val_int < 8 ** (digits - 1): + # Avoid overflow. + info[name] = 0 + needs_pax = True + elif val_is_float: + # Put rounded value in ustar header, and full + # precision value in pax header. + info[name] = val_int + needs_pax = True + + # The existing pax header has priority. + if needs_pax and name not in pax_headers: + pax_headers[name] = str(val) + + # Create a pax extended header if necessary. + if pax_headers: + buf = self._create_pax_generic_header(pax_headers, XHDTYPE, encoding) + else: + buf = b"" + + return buf + self._create_header(info, USTAR_FORMAT, "ascii", "replace") + + @classmethod + def create_pax_global_header(cls, pax_headers): + """Return the object as a pax global header block sequence. + """ + return cls._create_pax_generic_header(pax_headers, XGLTYPE, "utf-8") + + def _posix_split_name(self, name, encoding, errors): + """Split a name longer than 100 chars into a prefix + and a name part. + """ + components = name.split("/") + for i in range(1, len(components)): + prefix = "/".join(components[:i]) + name = "/".join(components[i:]) + if len(prefix.encode(encoding, errors)) <= LENGTH_PREFIX and \ + len(name.encode(encoding, errors)) <= LENGTH_NAME: + break + else: + raise ValueError("name is too long") + + return prefix, name + + @staticmethod + def _create_header(info, format, encoding, errors): + """Return a header block. info is a dictionary with file + information, format must be one of the *_FORMAT constants. + """ + has_device_fields = info.get("type") in (CHRTYPE, BLKTYPE) + if has_device_fields: + devmajor = itn(info.get("devmajor", 0), 8, format) + devminor = itn(info.get("devminor", 0), 8, format) + else: + devmajor = stn("", 8, encoding, errors) + devminor = stn("", 8, encoding, errors) + + # None values in metadata should cause ValueError. + # itn()/stn() do this for all fields except type. + filetype = info.get("type", REGTYPE) + if filetype is None: + raise ValueError("TarInfo.type must not be None") + + parts = [ + stn(info.get("name", ""), 100, encoding, errors), + itn(info.get("mode", 0) & 0o7777, 8, format), + itn(info.get("uid", 0), 8, format), + itn(info.get("gid", 0), 8, format), + itn(info.get("size", 0), 12, format), + itn(info.get("mtime", 0), 12, format), + b" ", # checksum field + filetype, + stn(info.get("linkname", ""), 100, encoding, errors), + info.get("magic", POSIX_MAGIC), + stn(info.get("uname", ""), 32, encoding, errors), + stn(info.get("gname", ""), 32, encoding, errors), + devmajor, + devminor, + stn(info.get("prefix", ""), 155, encoding, errors) + ] + + buf = struct.pack("%ds" % BLOCKSIZE, b"".join(parts)) + chksum = calc_chksums(buf[-BLOCKSIZE:])[0] + buf = buf[:-364] + bytes("%06o\0" % chksum, "ascii") + buf[-357:] + return buf + + @staticmethod + def _create_payload(payload): + """Return the string payload filled with zero bytes + up to the next 512 byte border. + """ + blocks, remainder = divmod(len(payload), BLOCKSIZE) + if remainder > 0: + payload += (BLOCKSIZE - remainder) * NUL + return payload + + @classmethod + def _create_gnu_long_header(cls, name, type, encoding, errors): + """Return a GNUTYPE_LONGNAME or GNUTYPE_LONGLINK sequence + for name. + """ + name = name.encode(encoding, errors) + NUL + + info = {} + info["name"] = "././@LongLink" + info["type"] = type + info["size"] = len(name) + info["magic"] = GNU_MAGIC + + # create extended header + name blocks. + return cls._create_header(info, USTAR_FORMAT, encoding, errors) + \ + cls._create_payload(name) + + @classmethod + def _create_pax_generic_header(cls, pax_headers, type, encoding): + """Return a POSIX.1-2008 extended or global header sequence + that contains a list of keyword, value pairs. The values + must be strings. + """ + # Check if one of the fields contains surrogate characters and thereby + # forces hdrcharset=BINARY, see _proc_pax() for more information. + binary = False + for keyword, value in pax_headers.items(): + try: + value.encode("utf-8", "strict") + except UnicodeEncodeError: + binary = True + break + + records = b"" + if binary: + # Put the hdrcharset field at the beginning of the header. + records += b"21 hdrcharset=BINARY\n" + + for keyword, value in pax_headers.items(): + keyword = keyword.encode("utf-8") + if binary: + # Try to restore the original byte representation of `value'. + # Needless to say, that the encoding must match the string. + value = value.encode(encoding, "surrogateescape") + else: + value = value.encode("utf-8") + + l = len(keyword) + len(value) + 3 # ' ' + '=' + '\n' + n = p = 0 + while True: + n = l + len(str(p)) + if n == p: + break + p = n + records += bytes(str(p), "ascii") + b" " + keyword + b"=" + value + b"\n" + + # We use a hardcoded "././@PaxHeader" name like star does + # instead of the one that POSIX recommends. + info = {} + info["name"] = "././@PaxHeader" + info["type"] = type + info["size"] = len(records) + info["magic"] = POSIX_MAGIC + + # Create pax header + record blocks. + return cls._create_header(info, USTAR_FORMAT, "ascii", "replace") + \ + cls._create_payload(records) + + @classmethod + def frombuf(cls, buf, encoding, errors): + """Construct a TarInfo object from a 512 byte bytes object. + + To support the old v7 tar format AREGTYPE headers are + transformed to DIRTYPE headers if their name ends in '/'. + """ + return cls._frombuf(buf, encoding, errors) + + @classmethod + def _frombuf(cls, buf, encoding, errors, *, dircheck=True): + """Construct a TarInfo object from a 512 byte bytes object. + + If ``dircheck`` is set to ``True`` then ``AREGTYPE`` headers will + be normalized to ``DIRTYPE`` if the name ends in a trailing slash. + ``dircheck`` must be set to ``False`` if this function is called + on a follow-up header such as ``GNUTYPE_LONGNAME``. + """ + if len(buf) == 0: + raise EmptyHeaderError("empty header") + if len(buf) != BLOCKSIZE: + raise TruncatedHeaderError("truncated header") + if buf.count(NUL) == BLOCKSIZE: + raise EOFHeaderError("end of file header") + + chksum = nti(buf[148:156]) + if chksum not in calc_chksums(buf): + raise InvalidHeaderError("bad checksum") + + obj = cls() + obj.name = nts(buf[0:100], encoding, errors) + obj.mode = nti(buf[100:108]) + obj.uid = nti(buf[108:116]) + obj.gid = nti(buf[116:124]) + obj.size = nti(buf[124:136]) + obj.mtime = nti(buf[136:148]) + obj.chksum = chksum + obj.type = buf[156:157] + obj.linkname = nts(buf[157:257], encoding, errors) + obj.uname = nts(buf[265:297], encoding, errors) + obj.gname = nts(buf[297:329], encoding, errors) + obj.devmajor = nti(buf[329:337]) + obj.devminor = nti(buf[337:345]) + prefix = nts(buf[345:500], encoding, errors) + + # Old V7 tar format represents a directory as a regular + # file with a trailing slash. + if dircheck and obj.type == AREGTYPE and obj.name.endswith("/"): + obj.type = DIRTYPE + + # The old GNU sparse format occupies some of the unused + # space in the buffer for up to 4 sparse structures. + # Save them for later processing in _proc_sparse(). + if obj.type == GNUTYPE_SPARSE: + pos = 386 + structs = [] + for i in range(4): + try: + offset = nti(buf[pos:pos + 12]) + numbytes = nti(buf[pos + 12:pos + 24]) + except ValueError: + break + structs.append((offset, numbytes)) + pos += 24 + isextended = bool(buf[482]) + origsize = nti(buf[483:495]) + obj._sparse_structs = (structs, isextended, origsize) + + # Remove redundant slashes from directories. + if obj.isdir(): + obj.name = obj.name.rstrip("/") + + # Reconstruct a ustar longname. + if prefix and obj.type not in GNU_TYPES: + obj.name = prefix + "/" + obj.name + return obj + + @classmethod + def fromtarfile(cls, tarfile): + """Return the next TarInfo object from TarFile object + tarfile. + """ + return cls._fromtarfile(tarfile) + + @classmethod + def _fromtarfile(cls, tarfile, *, dircheck=True): + """ + See dircheck documentation in _frombuf(). + """ + buf = tarfile.fileobj.read(BLOCKSIZE) + obj = cls._frombuf(buf, tarfile.encoding, tarfile.errors, dircheck=dircheck) + obj.offset = tarfile.fileobj.tell() - BLOCKSIZE + return obj._proc_member(tarfile) + + #-------------------------------------------------------------------------- + # The following are methods that are called depending on the type of a + # member. The entry point is _proc_member() which can be overridden in a + # subclass to add custom _proc_*() methods. A _proc_*() method MUST + # implement the following + # operations: + # 1. Set self.offset_data to the position where the data blocks begin, + # if there is data that follows. + # 2. Set tarfile.offset to the position where the next member's header will + # begin. + # 3. Return self or another valid TarInfo object. + def _proc_member(self, tarfile): + """Choose the right processing method depending on + the type and call it. + """ + if self.type in (GNUTYPE_LONGNAME, GNUTYPE_LONGLINK): + return self._proc_gnulong(tarfile) + elif self.type == GNUTYPE_SPARSE: + return self._proc_sparse(tarfile) + elif self.type in (XHDTYPE, XGLTYPE, SOLARIS_XHDTYPE): + return self._proc_pax(tarfile) + else: + return self._proc_builtin(tarfile) + + def _proc_builtin(self, tarfile): + """Process a builtin type or an unknown type which + will be treated as a regular file. + """ + self.offset_data = tarfile.fileobj.tell() + offset = self.offset_data + if self.isreg() or self.type not in SUPPORTED_TYPES: + # Skip the following data blocks. + offset += self._block(self.size) + tarfile.offset = offset + + # Patch the TarInfo object with saved global + # header information. + self._apply_pax_info(tarfile.pax_headers, tarfile.encoding, tarfile.errors) + + # Remove redundant slashes from directories. This is to be consistent + # with frombuf(). + if self.isdir(): + self.name = self.name.rstrip("/") + + return self + + def _proc_gnulong(self, tarfile): + """Process the blocks that hold a GNU longname + or longlink member. + """ + buf = tarfile.fileobj.read(self._block(self.size)) + + # Fetch the next header and process it. + try: + next = self._fromtarfile(tarfile, dircheck=False) + except HeaderError as e: + raise SubsequentHeaderError(str(e)) from None + + # Patch the TarInfo object from the next header with + # the longname information. + next.offset = self.offset + if self.type == GNUTYPE_LONGNAME: + next.name = nts(buf, tarfile.encoding, tarfile.errors) + elif self.type == GNUTYPE_LONGLINK: + next.linkname = nts(buf, tarfile.encoding, tarfile.errors) + + # Remove redundant slashes from directories. This is to be consistent + # with frombuf(). + if next.isdir(): + next.name = next.name.removesuffix("/") + + return next + + def _proc_sparse(self, tarfile): + """Process a GNU sparse header plus extra headers. + """ + # We already collected some sparse structures in frombuf(). + structs, isextended, origsize = self._sparse_structs + del self._sparse_structs + + # Collect sparse structures from extended header blocks. + while isextended: + buf = tarfile.fileobj.read(BLOCKSIZE) + pos = 0 + for i in range(21): + try: + offset = nti(buf[pos:pos + 12]) + numbytes = nti(buf[pos + 12:pos + 24]) + except ValueError: + break + if offset and numbytes: + structs.append((offset, numbytes)) + pos += 24 + isextended = bool(buf[504]) + self.sparse = structs + + self.offset_data = tarfile.fileobj.tell() + tarfile.offset = self.offset_data + self._block(self.size) + self.size = origsize + return self + + def _proc_pax(self, tarfile): + """Process an extended or global header as described in + POSIX.1-2008. + """ + # Read the header information. + buf = tarfile.fileobj.read(self._block(self.size)) + + # A pax header stores supplemental information for either + # the following file (extended) or all following files + # (global). + if self.type == XGLTYPE: + pax_headers = tarfile.pax_headers + else: + pax_headers = tarfile.pax_headers.copy() + + # Parse pax header information. A record looks like that: + # "%d %s=%s\n" % (length, keyword, value). length is the size + # of the complete record including the length field itself and + # the newline. + pos = 0 + encoding = None + raw_headers = [] + while len(buf) > pos and buf[pos] != 0x00: + if not (match := _header_length_prefix_re.match(buf, pos)): + raise InvalidHeaderError("invalid header") + try: + length = int(match.group(1)) + except ValueError: + raise InvalidHeaderError("invalid header") + # Headers must be at least 5 bytes, shortest being '5 x=\n'. + # Value is allowed to be empty. + if length < 5: + raise InvalidHeaderError("invalid header") + if pos + length > len(buf): + raise InvalidHeaderError("invalid header") + + header_value_end_offset = match.start(1) + length - 1 # Last byte of the header + keyword_and_value = buf[match.end(1) + 1:header_value_end_offset] + raw_keyword, equals, raw_value = keyword_and_value.partition(b"=") + + # Check the framing of the header. The last character must be '\n' (0x0A) + if not raw_keyword or equals != b"=" or buf[header_value_end_offset] != 0x0A: + raise InvalidHeaderError("invalid header") + raw_headers.append((length, raw_keyword, raw_value)) + + # Check if the pax header contains a hdrcharset field. This tells us + # the encoding of the path, linkpath, uname and gname fields. Normally, + # these fields are UTF-8 encoded but since POSIX.1-2008 tar + # implementations are allowed to store them as raw binary strings if + # the translation to UTF-8 fails. For the time being, we don't care about + # anything other than "BINARY". The only other value that is currently + # allowed by the standard is "ISO-IR 10646 2000 UTF-8" in other words UTF-8. + # Note that we only follow the initial 'hdrcharset' setting to preserve + # the initial behavior of the 'tarfile' module. + if raw_keyword == b"hdrcharset" and encoding is None: + if raw_value == b"BINARY": + encoding = tarfile.encoding + else: # This branch ensures only the first 'hdrcharset' header is used. + encoding = "utf-8" + + pos += length + + # If no explicit hdrcharset is set, we use UTF-8 as a default. + if encoding is None: + encoding = "utf-8" + + # After parsing the raw headers we can decode them to text. + for length, raw_keyword, raw_value in raw_headers: + # Normally, we could just use "utf-8" as the encoding and "strict" + # as the error handler, but we better not take the risk. For + # example, GNU tar <= 1.23 is known to store filenames it cannot + # translate to UTF-8 as raw strings (unfortunately without a + # hdrcharset=BINARY header). + # We first try the strict standard encoding, and if that fails we + # fall back on the user's encoding and error handler. + keyword = self._decode_pax_field(raw_keyword, "utf-8", "utf-8", + tarfile.errors) + if keyword in PAX_NAME_FIELDS: + value = self._decode_pax_field(raw_value, encoding, tarfile.encoding, + tarfile.errors) + else: + value = self._decode_pax_field(raw_value, "utf-8", "utf-8", + tarfile.errors) + + pax_headers[keyword] = value + + # Fetch the next header. + try: + next = self._fromtarfile(tarfile, dircheck=False) + except HeaderError as e: + raise SubsequentHeaderError(str(e)) from None + + # Process GNU sparse information. + if "GNU.sparse.map" in pax_headers: + # GNU extended sparse format version 0.1. + self._proc_gnusparse_01(next, pax_headers) + + elif "GNU.sparse.size" in pax_headers: + # GNU extended sparse format version 0.0. + self._proc_gnusparse_00(next, raw_headers) + + elif pax_headers.get("GNU.sparse.major") == "1" and pax_headers.get("GNU.sparse.minor") == "0": + # GNU extended sparse format version 1.0. + self._proc_gnusparse_10(next, pax_headers, tarfile) + + if self.type in (XHDTYPE, SOLARIS_XHDTYPE): + # Patch the TarInfo object with the extended header info. + next._apply_pax_info(pax_headers, tarfile.encoding, tarfile.errors) + next.offset = self.offset + + if "size" in pax_headers: + # If the extended header replaces the size field, + # we need to recalculate the offset where the next + # header starts. + offset = next.offset_data + if next.isreg() or next.type not in SUPPORTED_TYPES: + offset += next._block(next.size) + tarfile.offset = offset + + return next + + def _proc_gnusparse_00(self, next, raw_headers): + """Process a GNU tar extended sparse header, version 0.0. + """ + offsets = [] + numbytes = [] + for _, keyword, value in raw_headers: + if keyword == b"GNU.sparse.offset": + try: + offsets.append(int(value.decode())) + except ValueError: + raise InvalidHeaderError("invalid header") + + elif keyword == b"GNU.sparse.numbytes": + try: + numbytes.append(int(value.decode())) + except ValueError: + raise InvalidHeaderError("invalid header") + + next.sparse = list(zip(offsets, numbytes)) + + def _proc_gnusparse_01(self, next, pax_headers): + """Process a GNU tar extended sparse header, version 0.1. + """ + sparse = [int(x) for x in pax_headers["GNU.sparse.map"].split(",")] + next.sparse = list(zip(sparse[::2], sparse[1::2])) + + def _proc_gnusparse_10(self, next, pax_headers, tarfile): + """Process a GNU tar extended sparse header, version 1.0. + """ + fields = None + sparse = [] + buf = tarfile.fileobj.read(BLOCKSIZE) + fields, buf = buf.split(b"\n", 1) + fields = int(fields) + while len(sparse) < fields * 2: + if b"\n" not in buf: + buf += tarfile.fileobj.read(BLOCKSIZE) + number, buf = buf.split(b"\n", 1) + sparse.append(int(number)) + next.offset_data = tarfile.fileobj.tell() + next.sparse = list(zip(sparse[::2], sparse[1::2])) + + def _apply_pax_info(self, pax_headers, encoding, errors): + """Replace fields with supplemental information from a previous + pax extended or global header. + """ + for keyword, value in pax_headers.items(): + if keyword == "GNU.sparse.name": + setattr(self, "path", value) + elif keyword == "GNU.sparse.size": + setattr(self, "size", int(value)) + elif keyword == "GNU.sparse.realsize": + setattr(self, "size", int(value)) + elif keyword in PAX_FIELDS: + if keyword in PAX_NUMBER_FIELDS: + try: + value = PAX_NUMBER_FIELDS[keyword](value) + except ValueError: + value = 0 + if keyword == "path": + value = value.rstrip("/") + setattr(self, keyword, value) + + self.pax_headers = pax_headers.copy() + + def _decode_pax_field(self, value, encoding, fallback_encoding, fallback_errors): + """Decode a single field from a pax record. + """ + try: + return value.decode(encoding, "strict") + except UnicodeDecodeError: + return value.decode(fallback_encoding, fallback_errors) + + def _block(self, count): + """Round up a byte count by BLOCKSIZE and return it, + e.g. _block(834) => 1024. + """ + # Only non-negative offsets are allowed + if count < 0: + raise InvalidHeaderError("invalid offset") + blocks, remainder = divmod(count, BLOCKSIZE) + if remainder: + blocks += 1 + return blocks * BLOCKSIZE + + def isreg(self): + 'Return True if the Tarinfo object is a regular file.' + return self.type in REGULAR_TYPES + + def isfile(self): + 'Return True if the Tarinfo object is a regular file.' + return self.isreg() + + def isdir(self): + 'Return True if it is a directory.' + return self.type == DIRTYPE + + def issym(self): + 'Return True if it is a symbolic link.' + return self.type == SYMTYPE + + def islnk(self): + 'Return True if it is a hard link.' + return self.type == LNKTYPE + + def ischr(self): + 'Return True if it is a character device.' + return self.type == CHRTYPE + + def isblk(self): + 'Return True if it is a block device.' + return self.type == BLKTYPE + + def isfifo(self): + 'Return True if it is a FIFO.' + return self.type == FIFOTYPE + + def issparse(self): + return self.sparse is not None + + def isdev(self): + 'Return True if it is one of character device, block device or FIFO.' + return self.type in (CHRTYPE, BLKTYPE, FIFOTYPE) +# class TarInfo + +class TarFile(object): + """The TarFile Class provides an interface to tar archives. + """ + + debug = 0 # May be set from 0 (no msgs) to 3 (all msgs) + + dereference = False # If true, add content of linked file to the + # tar file, else the link. + + ignore_zeros = False # If true, skips empty or invalid blocks and + # continues processing. + + errorlevel = 1 # If 0, fatal errors only appear in debug + # messages (if debug >= 0). If > 0, errors + # are passed to the caller as exceptions. + + format = DEFAULT_FORMAT # The format to use when creating an archive. + + encoding = ENCODING # Encoding for 8-bit character strings. + + errors = None # Error handler for unicode conversion. + + tarinfo = TarInfo # The default TarInfo class to use. + + fileobject = ExFileObject # The file-object for extractfile(). + + extraction_filter = None # The default filter for extraction. + + def __init__(self, name=None, mode="r", fileobj=None, format=None, + tarinfo=None, dereference=None, ignore_zeros=None, encoding=None, + errors="surrogateescape", pax_headers=None, debug=None, + errorlevel=None, copybufsize=None): + """Open an (uncompressed) tar archive `name'. `mode' is either 'r' to + read from an existing archive, 'a' to append data to an existing + file or 'w' to create a new file overwriting an existing one. `mode' + defaults to 'r'. + If `fileobj' is given, it is used for reading or writing data. If it + can be determined, `mode' is overridden by `fileobj's mode. + `fileobj' is not closed, when TarFile is closed. + """ + modes = {"r": "rb", "a": "r+b", "w": "wb", "x": "xb"} + if mode not in modes: + raise ValueError("mode must be 'r', 'a', 'w' or 'x'") + self.mode = mode + self._mode = modes[mode] + + if not fileobj: + if self.mode == "a" and not os.path.exists(name): + # Create nonexistent files in append mode. + self.mode = "w" + self._mode = "wb" + fileobj = bltn_open(name, self._mode) + self._extfileobj = False + else: + if (name is None and hasattr(fileobj, "name") and + isinstance(fileobj.name, (str, bytes))): + name = fileobj.name + if hasattr(fileobj, "mode"): + self._mode = fileobj.mode + self._extfileobj = True + self.name = os.path.abspath(name) if name else None + self.fileobj = fileobj + + # Init attributes. + if format is not None: + self.format = format + if tarinfo is not None: + self.tarinfo = tarinfo + if dereference is not None: + self.dereference = dereference + if ignore_zeros is not None: + self.ignore_zeros = ignore_zeros + if encoding is not None: + self.encoding = encoding + self.errors = errors + + if pax_headers is not None and self.format == PAX_FORMAT: + self.pax_headers = pax_headers + else: + self.pax_headers = {} + + if debug is not None: + self.debug = debug + if errorlevel is not None: + self.errorlevel = errorlevel + + # Init datastructures. + self.copybufsize = copybufsize + self.closed = False + self.members = [] # list of members as TarInfo objects + self._loaded = False # flag if all members have been read + self.offset = self.fileobj.tell() + # current position in the archive file + self.inodes = {} # dictionary caching the inodes of + # archive members already added + + try: + if self.mode == "r": + self.firstmember = None + self.firstmember = self.next() + + if self.mode == "a": + # Move to the end of the archive, + # before the first empty block. + while True: + self.fileobj.seek(self.offset) + try: + tarinfo = self.tarinfo.fromtarfile(self) + self.members.append(tarinfo) + except EOFHeaderError: + self.fileobj.seek(self.offset) + break + except HeaderError as e: + raise ReadError(str(e)) from None + + if self.mode in ("a", "w", "x"): + self._loaded = True + + if self.pax_headers: + buf = self.tarinfo.create_pax_global_header(self.pax_headers.copy()) + self.fileobj.write(buf) + self.offset += len(buf) + except: + if not self._extfileobj: + self.fileobj.close() + self.closed = True + raise + + #-------------------------------------------------------------------------- + # Below are the classmethods which act as alternate constructors to the + # TarFile class. The open() method is the only one that is needed for + # public use; it is the "super"-constructor and is able to select an + # adequate "sub"-constructor for a particular compression using the mapping + # from OPEN_METH. + # + # This concept allows one to subclass TarFile without losing the comfort of + # the super-constructor. A sub-constructor is registered and made available + # by adding it to the mapping in OPEN_METH. + + @classmethod + def open(cls, name=None, mode="r", fileobj=None, bufsize=RECORDSIZE, **kwargs): + """Open a tar archive for reading, writing or appending. Return + an appropriate TarFile class. + + mode: + 'r' or 'r:*' open for reading with transparent compression + 'r:' open for reading exclusively uncompressed + 'r:gz' open for reading with gzip compression + 'r:bz2' open for reading with bzip2 compression + 'r:xz' open for reading with lzma compression + 'a' or 'a:' open for appending, creating the file if necessary + 'w' or 'w:' open for writing without compression + 'w:gz' open for writing with gzip compression + 'w:bz2' open for writing with bzip2 compression + 'w:xz' open for writing with lzma compression + + 'x' or 'x:' create a tarfile exclusively without compression, raise + an exception if the file is already created + 'x:gz' create a gzip compressed tarfile, raise an exception + if the file is already created + 'x:bz2' create a bzip2 compressed tarfile, raise an exception + if the file is already created + 'x:xz' create an lzma compressed tarfile, raise an exception + if the file is already created + + 'r|*' open a stream of tar blocks with transparent compression + 'r|' open an uncompressed stream of tar blocks for reading + 'r|gz' open a gzip compressed stream of tar blocks + 'r|bz2' open a bzip2 compressed stream of tar blocks + 'r|xz' open an lzma compressed stream of tar blocks + 'w|' open an uncompressed stream for writing + 'w|gz' open a gzip compressed stream for writing + 'w|bz2' open a bzip2 compressed stream for writing + 'w|xz' open an lzma compressed stream for writing + """ + + if not name and not fileobj: + raise ValueError("nothing to open") + + if mode in ("r", "r:*"): + # Find out which *open() is appropriate for opening the file. + def not_compressed(comptype): + return cls.OPEN_METH[comptype] == 'taropen' + error_msgs = [] + for comptype in sorted(cls.OPEN_METH, key=not_compressed): + func = getattr(cls, cls.OPEN_METH[comptype]) + if fileobj is not None: + saved_pos = fileobj.tell() + try: + return func(name, "r", fileobj, **kwargs) + except (ReadError, CompressionError) as e: + error_msgs.append(f'- method {comptype}: {e!r}') + if fileobj is not None: + fileobj.seek(saved_pos) + continue + error_msgs_summary = '\n'.join(error_msgs) + raise ReadError(f"file could not be opened successfully:\n{error_msgs_summary}") + + elif ":" in mode: + filemode, comptype = mode.split(":", 1) + filemode = filemode or "r" + comptype = comptype or "tar" + + # Select the *open() function according to + # given compression. + if comptype in cls.OPEN_METH: + func = getattr(cls, cls.OPEN_METH[comptype]) + else: + raise CompressionError("unknown compression type %r" % comptype) + return func(name, filemode, fileobj, **kwargs) + + elif "|" in mode: + filemode, comptype = mode.split("|", 1) + filemode = filemode or "r" + comptype = comptype or "tar" + + if filemode not in ("r", "w"): + raise ValueError("mode must be 'r' or 'w'") + + stream = _Stream(name, filemode, comptype, fileobj, bufsize) + try: + t = cls(name, filemode, stream, **kwargs) + except: + stream.close() + raise + t._extfileobj = False + return t + + elif mode in ("a", "w", "x"): + return cls.taropen(name, mode, fileobj, **kwargs) + + raise ValueError("undiscernible mode") + + @classmethod + def taropen(cls, name, mode="r", fileobj=None, **kwargs): + """Open uncompressed tar archive name for reading or writing. + """ + if mode not in ("r", "a", "w", "x"): + raise ValueError("mode must be 'r', 'a', 'w' or 'x'") + return cls(name, mode, fileobj, **kwargs) + + @classmethod + def gzopen(cls, name, mode="r", fileobj=None, compresslevel=9, **kwargs): + """Open gzip compressed tar archive name for reading or writing. + Appending is not allowed. + """ + if mode not in ("r", "w", "x"): + raise ValueError("mode must be 'r', 'w' or 'x'") + + try: + from gzip import GzipFile + except ImportError: + raise CompressionError("gzip module is not available") from None + + try: + fileobj = GzipFile(name, mode + "b", compresslevel, fileobj) + except OSError as e: + if fileobj is not None and mode == 'r': + raise ReadError("not a gzip file") from e + raise + + try: + t = cls.taropen(name, mode, fileobj, **kwargs) + except OSError as e: + fileobj.close() + if mode == 'r': + raise ReadError("not a gzip file") from e + raise + except: + fileobj.close() + raise + t._extfileobj = False + return t + + @classmethod + def bz2open(cls, name, mode="r", fileobj=None, compresslevel=9, **kwargs): + """Open bzip2 compressed tar archive name for reading or writing. + Appending is not allowed. + """ + if mode not in ("r", "w", "x"): + raise ValueError("mode must be 'r', 'w' or 'x'") + + try: + from bz2 import BZ2File + except ImportError: + raise CompressionError("bz2 module is not available") from None + + fileobj = BZ2File(fileobj or name, mode, compresslevel=compresslevel) + + try: + t = cls.taropen(name, mode, fileobj, **kwargs) + except (OSError, EOFError) as e: + fileobj.close() + if mode == 'r': + raise ReadError("not a bzip2 file") from e + raise + except: + fileobj.close() + raise + t._extfileobj = False + return t + + @classmethod + def xzopen(cls, name, mode="r", fileobj=None, preset=None, **kwargs): + """Open lzma compressed tar archive name for reading or writing. + Appending is not allowed. + """ + if mode not in ("r", "w", "x"): + raise ValueError("mode must be 'r', 'w' or 'x'") + + try: + from lzma import LZMAFile, LZMAError + except ImportError: + raise CompressionError("lzma module is not available") from None + + fileobj = LZMAFile(fileobj or name, mode, preset=preset) + + try: + t = cls.taropen(name, mode, fileobj, **kwargs) + except (LZMAError, EOFError) as e: + fileobj.close() + if mode == 'r': + raise ReadError("not an lzma file") from e + raise + except: + fileobj.close() + raise + t._extfileobj = False + return t + + # All *open() methods are registered here. + OPEN_METH = { + "tar": "taropen", # uncompressed tar + "gz": "gzopen", # gzip compressed tar + "bz2": "bz2open", # bzip2 compressed tar + "xz": "xzopen" # lzma compressed tar + } + + #-------------------------------------------------------------------------- + # The public methods which TarFile provides: + + def close(self): + """Close the TarFile. In write-mode, two finishing zero blocks are + appended to the archive. + """ + if self.closed: + return + + self.closed = True + try: + if self.mode in ("a", "w", "x"): + self.fileobj.write(NUL * (BLOCKSIZE * 2)) + self.offset += (BLOCKSIZE * 2) + # fill up the end with zero-blocks + # (like option -b20 for tar does) + blocks, remainder = divmod(self.offset, RECORDSIZE) + if remainder > 0: + self.fileobj.write(NUL * (RECORDSIZE - remainder)) + finally: + if not self._extfileobj: + self.fileobj.close() + + def getmember(self, name): + """Return a TarInfo object for member `name'. If `name' can not be + found in the archive, KeyError is raised. If a member occurs more + than once in the archive, its last occurrence is assumed to be the + most up-to-date version. + """ + tarinfo = self._getmember(name.rstrip('/')) + if tarinfo is None: + raise KeyError("filename %r not found" % name) + return tarinfo + + def getmembers(self): + """Return the members of the archive as a list of TarInfo objects. The + list has the same order as the members in the archive. + """ + self._check() + if not self._loaded: # if we want to obtain a list of + self._load() # all members, we first have to + # scan the whole archive. + return self.members + + def getnames(self): + """Return the members of the archive as a list of their names. It has + the same order as the list returned by getmembers(). + """ + return [tarinfo.name for tarinfo in self.getmembers()] + + def gettarinfo(self, name=None, arcname=None, fileobj=None): + """Create a TarInfo object from the result of os.stat or equivalent + on an existing file. The file is either named by `name', or + specified as a file object `fileobj' with a file descriptor. If + given, `arcname' specifies an alternative name for the file in the + archive, otherwise, the name is taken from the 'name' attribute of + 'fileobj', or the 'name' argument. The name should be a text + string. + """ + self._check("awx") + + # When fileobj is given, replace name by + # fileobj's real name. + if fileobj is not None: + name = fileobj.name + + # Building the name of the member in the archive. + # Backward slashes are converted to forward slashes, + # Absolute paths are turned to relative paths. + if arcname is None: + arcname = name + drv, arcname = os.path.splitdrive(arcname) + arcname = arcname.replace(os.sep, "/") + arcname = arcname.lstrip("/") + + # Now, fill the TarInfo object with + # information specific for the file. + tarinfo = self.tarinfo() + tarinfo.tarfile = self # Not needed + + # Use os.stat or os.lstat, depending on if symlinks shall be resolved. + if fileobj is None: + if not self.dereference: + statres = os.lstat(name) + else: + statres = os.stat(name) + else: + statres = os.fstat(fileobj.fileno()) + linkname = "" + + stmd = statres.st_mode + if stat.S_ISREG(stmd): + inode = (statres.st_ino, statres.st_dev) + if not self.dereference and statres.st_nlink > 1 and \ + inode in self.inodes and arcname != self.inodes[inode]: + # Is it a hardlink to an already + # archived file? + type = LNKTYPE + linkname = self.inodes[inode] + else: + # The inode is added only if its valid. + # For win32 it is always 0. + type = REGTYPE + if inode[0]: + self.inodes[inode] = arcname + elif stat.S_ISDIR(stmd): + type = DIRTYPE + elif stat.S_ISFIFO(stmd): + type = FIFOTYPE + elif stat.S_ISLNK(stmd): + type = SYMTYPE + linkname = os.readlink(name) + elif stat.S_ISCHR(stmd): + type = CHRTYPE + elif stat.S_ISBLK(stmd): + type = BLKTYPE + else: + return None + + # Fill the TarInfo object with all + # information we can get. + tarinfo.name = arcname + tarinfo.mode = stmd + tarinfo.uid = statres.st_uid + tarinfo.gid = statres.st_gid + if type == REGTYPE: + tarinfo.size = statres.st_size + else: + tarinfo.size = 0 + tarinfo.mtime = statres.st_mtime + tarinfo.type = type + tarinfo.linkname = linkname + if pwd: + try: + tarinfo.uname = pwd.getpwuid(tarinfo.uid)[0] + except KeyError: + pass + if grp: + try: + tarinfo.gname = grp.getgrgid(tarinfo.gid)[0] + except KeyError: + pass + + if type in (CHRTYPE, BLKTYPE): + if hasattr(os, "major") and hasattr(os, "minor"): + tarinfo.devmajor = os.major(statres.st_rdev) + tarinfo.devminor = os.minor(statres.st_rdev) + return tarinfo + + def list(self, verbose=True, *, members=None): + """Print a table of contents to sys.stdout. If `verbose' is False, only + the names of the members are printed. If it is True, an `ls -l'-like + output is produced. `members' is optional and must be a subset of the + list returned by getmembers(). + """ + self._check() + + if members is None: + members = self + for tarinfo in members: + if verbose: + if tarinfo.mode is None: + _safe_print("??????????") + else: + _safe_print(stat.filemode(tarinfo.mode)) + _safe_print("%s/%s" % (tarinfo.uname or tarinfo.uid, + tarinfo.gname or tarinfo.gid)) + if tarinfo.ischr() or tarinfo.isblk(): + _safe_print("%10s" % + ("%d,%d" % (tarinfo.devmajor, tarinfo.devminor))) + else: + _safe_print("%10d" % tarinfo.size) + if tarinfo.mtime is None: + _safe_print("????-??-?? ??:??:??") + else: + _safe_print("%d-%02d-%02d %02d:%02d:%02d" \ + % time.localtime(tarinfo.mtime)[:6]) + + _safe_print(tarinfo.name + ("/" if tarinfo.isdir() else "")) + + if verbose: + if tarinfo.issym(): + _safe_print("-> " + tarinfo.linkname) + if tarinfo.islnk(): + _safe_print("link to " + tarinfo.linkname) + print() + + def add(self, name, arcname=None, recursive=True, *, filter=None): + """Add the file `name' to the archive. `name' may be any type of file + (directory, fifo, symbolic link, etc.). If given, `arcname' + specifies an alternative name for the file in the archive. + Directories are added recursively by default. This can be avoided by + setting `recursive' to False. `filter' is a function + that expects a TarInfo object argument and returns the changed + TarInfo object, if it returns None the TarInfo object will be + excluded from the archive. + """ + self._check("awx") + + if arcname is None: + arcname = name + + # Skip if somebody tries to archive the archive... + if self.name is not None and os.path.abspath(name) == self.name: + self._dbg(2, "tarfile: Skipped %r" % name) + return + + self._dbg(1, name) + + # Create a TarInfo object from the file. + tarinfo = self.gettarinfo(name, arcname) + + if tarinfo is None: + self._dbg(1, "tarfile: Unsupported type %r" % name) + return + + # Change or exclude the TarInfo object. + if filter is not None: + tarinfo = filter(tarinfo) + if tarinfo is None: + self._dbg(2, "tarfile: Excluded %r" % name) + return + + # Append the tar header and data to the archive. + if tarinfo.isreg(): + with bltn_open(name, "rb") as f: + self.addfile(tarinfo, f) + + elif tarinfo.isdir(): + self.addfile(tarinfo) + if recursive: + for f in sorted(os.listdir(name)): + self.add(os.path.join(name, f), os.path.join(arcname, f), + recursive, filter=filter) + + else: + self.addfile(tarinfo) + + def addfile(self, tarinfo, fileobj=None): + """Add the TarInfo object `tarinfo' to the archive. If `fileobj' is + given, it should be a binary file, and tarinfo.size bytes are read + from it and added to the archive. You can create TarInfo objects + directly, or by using gettarinfo(). + """ + self._check("awx") + + tarinfo = copy.copy(tarinfo) + + buf = tarinfo.tobuf(self.format, self.encoding, self.errors) + self.fileobj.write(buf) + self.offset += len(buf) + bufsize=self.copybufsize + # If there's data to follow, append it. + if fileobj is not None: + copyfileobj(fileobj, self.fileobj, tarinfo.size, bufsize=bufsize) + blocks, remainder = divmod(tarinfo.size, BLOCKSIZE) + if remainder > 0: + self.fileobj.write(NUL * (BLOCKSIZE - remainder)) + blocks += 1 + self.offset += blocks * BLOCKSIZE + + self.members.append(tarinfo) + + def _get_filter_function(self, filter): + if filter is None: + filter = self.extraction_filter + if filter is None: + return fully_trusted_filter + if isinstance(filter, str): + raise TypeError( + 'String names are not supported for ' + + 'TarFile.extraction_filter. Use a function such as ' + + 'tarfile.data_filter directly.') + return filter + if callable(filter): + return filter + try: + return _NAMED_FILTERS[filter] + except KeyError: + raise ValueError(f"filter {filter!r} not found") from None + + def extractall(self, path=".", members=None, *, numeric_owner=False, + filter=None): + """Extract all members from the archive to the current working + directory and set owner, modification time and permissions on + directories afterwards. `path' specifies a different directory + to extract to. `members' is optional and must be a subset of the + list returned by getmembers(). If `numeric_owner` is True, only + the numbers for user/group names are used and not the names. + + The `filter` function will be called on each member just + before extraction. + It can return a changed TarInfo or None to skip the member. + String names of common filters are accepted. + """ + directories = [] + + filter_function = self._get_filter_function(filter) + if members is None: + members = self + + for member in members: + tarinfo, unfiltered = self._get_extract_tarinfo( + member, filter_function, path) + if tarinfo is None: + continue + if tarinfo.isdir(): + # For directories, delay setting attributes until later, + # since permissions can interfere with extraction and + # extracting contents can reset mtime. + directories.append(unfiltered) + self._extract_one(tarinfo, path, set_attrs=not tarinfo.isdir(), + numeric_owner=numeric_owner, + filter_function=filter_function) + + # Reverse sort directories. + directories.sort(key=lambda a: a.name, reverse=True) + + + # Set correct owner, mtime and filemode on directories. + for unfiltered in directories: + try: + # Need to re-apply any filter, to take the *current* filesystem + # state into account. + try: + tarinfo = filter_function(unfiltered, path) + except _FILTER_ERRORS as exc: + self._log_no_directory_fixup(unfiltered, repr(exc)) + continue + if tarinfo is None: + self._log_no_directory_fixup(unfiltered, + 'excluded by filter') + continue + dirpath = os.path.join(path, tarinfo.name) + try: + lstat = os.lstat(dirpath) + except FileNotFoundError: + self._log_no_directory_fixup(tarinfo, 'missing') + continue + if not stat.S_ISDIR(lstat.st_mode): + # This is no longer a directory; presumably a later + # member overwrote the entry. + self._log_no_directory_fixup(tarinfo, 'not a directory') + continue + self.chown(tarinfo, dirpath, numeric_owner=numeric_owner) + self.utime(tarinfo, dirpath) + self.chmod(tarinfo, dirpath) + except ExtractError as e: + self._handle_nonfatal_error(e) + + def _log_no_directory_fixup(self, member, reason): + self._dbg(2, "tarfile: Not fixing up directory %r (%s)" % + (member.name, reason)) + + def extract(self, member, path="", set_attrs=True, *, numeric_owner=False, + filter=None): + """Extract a member from the archive to the current working directory, + using its full name. Its file information is extracted as accurately + as possible. `member' may be a filename or a TarInfo object. You can + specify a different directory using `path'. File attributes (owner, + mtime, mode) are set unless `set_attrs' is False. If `numeric_owner` + is True, only the numbers for user/group names are used and not + the names. + + The `filter` function will be called before extraction. + It can return a changed TarInfo or None to skip the member. + String names of common filters are accepted. + """ + filter_function = self._get_filter_function(filter) + tarinfo, unfiltered = self._get_extract_tarinfo( + member, filter_function, path) + if tarinfo is not None: + self._extract_one(tarinfo, path, set_attrs, numeric_owner, + filter_function=filter_function) + + def _get_extract_tarinfo(self, member, filter_function, path): + """Get (filtered, unfiltered) TarInfos from *member* + + *member* might be a string. + + Return (None, None) if not found. + """ + + if isinstance(member, str): + unfiltered = self.getmember(member) + else: + unfiltered = member + + filtered = None + try: + filtered = filter_function(unfiltered, path) + except (OSError, FilterError) as e: + self._handle_fatal_error(e) + except ExtractError as e: + self._handle_nonfatal_error(e) + if filtered is None: + self._dbg(2, "tarfile: Excluded %r" % unfiltered.name) + return None, None + + # Prepare the link target for makelink(). + if filtered.islnk(): + filtered = copy.copy(filtered) + filtered._link_target = os.path.join(path, filtered.linkname) + return filtered, unfiltered + + def _extract_one(self, tarinfo, path, set_attrs, numeric_owner, + filter_function=None): + """Extract from filtered tarinfo to disk. + + filter_function is only used when extracting a *different* + member (e.g. as fallback to creating a symlink) + """ + self._check("r") + + try: + self._extract_member(tarinfo, os.path.join(path, tarinfo.name), + set_attrs=set_attrs, + numeric_owner=numeric_owner, + filter_function=filter_function, + extraction_root=path) + except OSError as e: + self._handle_fatal_error(e) + except ExtractError as e: + self._handle_nonfatal_error(e) + + def _handle_nonfatal_error(self, e): + """Handle non-fatal error (ExtractError) according to errorlevel""" + if self.errorlevel > 1: + raise + else: + self._dbg(1, "tarfile: %s" % e) + + def _handle_fatal_error(self, e): + """Handle "fatal" error according to self.errorlevel""" + if self.errorlevel > 0: + raise + elif isinstance(e, OSError): + if e.filename is None: + self._dbg(1, "tarfile: %s" % e.strerror) + else: + self._dbg(1, "tarfile: %s %r" % (e.strerror, e.filename)) + else: + self._dbg(1, "tarfile: %s %s" % (type(e).__name__, e)) + + def extractfile(self, member): + """Extract a member from the archive as a file object. `member' may be + a filename or a TarInfo object. If `member' is a regular file or + a link, an io.BufferedReader object is returned. For all other + existing members, None is returned. If `member' does not appear + in the archive, KeyError is raised. + """ + self._check("r") + + if isinstance(member, str): + tarinfo = self.getmember(member) + else: + tarinfo = member + + if tarinfo.isreg() or tarinfo.type not in SUPPORTED_TYPES: + # Members with unknown types are treated as regular files. + return self.fileobject(self, tarinfo) + + elif tarinfo.islnk() or tarinfo.issym(): + if isinstance(self.fileobj, _Stream): + # A small but ugly workaround for the case that someone tries + # to extract a (sym)link as a file-object from a non-seekable + # stream of tar blocks. + raise StreamError("cannot extract (sym)link as file object") + else: + # A (sym)link's file object is its target's file object. + return self.extractfile(self._find_link_target(tarinfo)) + else: + # If there's no data associated with the member (directory, chrdev, + # blkdev, etc.), return None instead of a file object. + return None + + def _extract_member(self, tarinfo, targetpath, set_attrs=True, + numeric_owner=False, *, filter_function=None, + extraction_root=None): + """Extract the filtered TarInfo object tarinfo to a physical + file called targetpath. + + filter_function is only used when extracting a *different* + member (e.g. as fallback to creating a symlink) + """ + # Fetch the TarInfo object for the given name + # and build the destination pathname, replacing + # forward slashes to platform specific separators. + targetpath = targetpath.rstrip("/") + targetpath = targetpath.replace("/", os.sep) + + # Create all upper directories. + upperdirs = os.path.dirname(targetpath) + if upperdirs and not os.path.exists(upperdirs): + # Create directories that are not part of the archive with + # default permissions. + os.makedirs(upperdirs) + + if tarinfo.islnk() or tarinfo.issym(): + self._dbg(1, "%s -> %s" % (tarinfo.name, tarinfo.linkname)) + else: + self._dbg(1, tarinfo.name) + + if tarinfo.isreg(): + self.makefile(tarinfo, targetpath) + elif tarinfo.isdir(): + self.makedir(tarinfo, targetpath) + elif tarinfo.isfifo(): + self.makefifo(tarinfo, targetpath) + elif tarinfo.ischr() or tarinfo.isblk(): + self.makedev(tarinfo, targetpath) + elif tarinfo.islnk() or tarinfo.issym(): + self.makelink_with_filter( + tarinfo, targetpath, + filter_function=filter_function, + extraction_root=extraction_root) + elif tarinfo.type not in SUPPORTED_TYPES: + self.makeunknown(tarinfo, targetpath) + else: + self.makefile(tarinfo, targetpath) + + if set_attrs: + self.chown(tarinfo, targetpath, numeric_owner) + if not tarinfo.issym(): + self.chmod(tarinfo, targetpath) + self.utime(tarinfo, targetpath) + + #-------------------------------------------------------------------------- + # Below are the different file methods. They are called via + # _extract_member() when extract() is called. They can be replaced in a + # subclass to implement other functionality. + + def makedir(self, tarinfo, targetpath): + """Make a directory called targetpath. + """ + try: + if tarinfo.mode is None: + # Use the system's default mode + os.mkdir(targetpath) + else: + # Use a safe mode for the directory, the real mode is set + # later in _extract_member(). + os.mkdir(targetpath, 0o700) + except FileExistsError: + if not os.path.isdir(targetpath): + raise + + def makefile(self, tarinfo, targetpath): + """Make a file called targetpath. + """ + source = self.fileobj + source.seek(tarinfo.offset_data) + bufsize = self.copybufsize + with bltn_open(targetpath, "wb") as target: + if tarinfo.sparse is not None: + for offset, size in tarinfo.sparse: + target.seek(offset) + copyfileobj(source, target, size, ReadError, bufsize) + target.seek(tarinfo.size) + target.truncate() + else: + copyfileobj(source, target, tarinfo.size, ReadError, bufsize) + + def makeunknown(self, tarinfo, targetpath): + """Make a file from a TarInfo object with an unknown type + at targetpath. + """ + self.makefile(tarinfo, targetpath) + self._dbg(1, "tarfile: Unknown file type %r, " \ + "extracted as regular file." % tarinfo.type) + + def makefifo(self, tarinfo, targetpath): + """Make a fifo called targetpath. + """ + if hasattr(os, "mkfifo"): + os.mkfifo(targetpath) + else: + raise ExtractError("fifo not supported by system") + + def makedev(self, tarinfo, targetpath): + """Make a character or block device called targetpath. + """ + if not hasattr(os, "mknod") or not hasattr(os, "makedev"): + raise ExtractError("special devices not supported by system") + + mode = tarinfo.mode + if mode is None: + # Use mknod's default + mode = 0o600 + if tarinfo.isblk(): + mode |= stat.S_IFBLK + else: + mode |= stat.S_IFCHR + + os.mknod(targetpath, mode, + os.makedev(tarinfo.devmajor, tarinfo.devminor)) + + def makelink(self, tarinfo, targetpath): + return self.makelink_with_filter(tarinfo, targetpath, None, None) + + def makelink_with_filter(self, tarinfo, targetpath, + filter_function, extraction_root): + """Make a (symbolic) link called targetpath. If it cannot be created + (platform limitation), we try to make a copy of the referenced file + instead of a link. + + filter_function is only used when extracting a *different* + member (e.g. as fallback to creating a link). + """ + keyerror_to_extracterror = False + try: + # For systems that support symbolic and hard links. + if tarinfo.issym(): + if os.path.lexists(targetpath): + # Avoid FileExistsError on following os.symlink. + os.unlink(targetpath) + os.symlink(tarinfo.linkname, targetpath) + return + else: + if os.path.exists(tarinfo._link_target): + # Resolve the target so the hard link points to the file + # itself. Otherwise os.link() may duplicate a symlink to a + # shallower location, where it's relative target escapes the + # destination directory. (CVE-2026-82049) + os.link(os.path.realpath(tarinfo._link_target), targetpath) + return + except symlink_exception: + keyerror_to_extracterror = True + + try: + unfiltered = self._find_link_target(tarinfo) + except KeyError: + if keyerror_to_extracterror: + raise ExtractError( + "unable to resolve link inside archive") from None + else: + raise + + if filter_function is None: + filtered = unfiltered + else: + if extraction_root is None: + raise ExtractError( + "makelink_with_filter: if filter_function is not None, " + + "extraction_root must also not be None") + try: + filtered = filter_function( + unfiltered.replace(name=tarinfo.name, deep=False), + extraction_root) + if filtered is None: + return + filtered = filter_function(unfiltered, extraction_root) + except _FILTER_ERRORS as cause: + raise LinkFallbackError(tarinfo, unfiltered.name) from cause + if filtered is not None: + self._extract_member(filtered, targetpath, + filter_function=filter_function, + extraction_root=extraction_root) + + def chown(self, tarinfo, targetpath, numeric_owner): + """Set owner of targetpath according to tarinfo. If numeric_owner + is True, use .gid/.uid instead of .gname/.uname. If numeric_owner + is False, fall back to .gid/.uid when the search based on name + fails. + """ + if hasattr(os, "geteuid") and os.geteuid() == 0: + # We have to be root to do so. + g = tarinfo.gid + u = tarinfo.uid + if not numeric_owner: + try: + if grp and tarinfo.gname: + g = grp.getgrnam(tarinfo.gname)[2] + except KeyError: + pass + try: + if pwd and tarinfo.uname: + u = pwd.getpwnam(tarinfo.uname)[2] + except KeyError: + pass + if g is None: + g = -1 + if u is None: + u = -1 + try: + if tarinfo.issym() and hasattr(os, "lchown"): + os.lchown(targetpath, u, g) + else: + os.chown(targetpath, u, g) + except OSError as e: + raise ExtractError("could not change owner") from e + + def chmod(self, tarinfo, targetpath): + """Set file permissions of targetpath according to tarinfo. + """ + if tarinfo.mode is None: + return + try: + os.chmod(targetpath, tarinfo.mode) + except OSError as e: + raise ExtractError("could not change mode") from e + + def utime(self, tarinfo, targetpath): + """Set modification time of targetpath according to tarinfo. + """ + mtime = tarinfo.mtime + if mtime is None: + return + if not hasattr(os, 'utime'): + return + try: + os.utime(targetpath, (mtime, mtime)) + except OSError as e: + raise ExtractError("could not change modification time") from e + + #-------------------------------------------------------------------------- + def next(self): + """Return the next member of the archive as a TarInfo object, when + TarFile is opened for reading. Return None if there is no more + available. + """ + self._check("ra") + if self.firstmember is not None: + m = self.firstmember + self.firstmember = None + return m + + # Advance the file pointer. + if self.offset != self.fileobj.tell(): + if self.offset == 0: + return None + self.fileobj.seek(self.offset - 1) + if not self.fileobj.read(1): + raise ReadError("unexpected end of data") + + # Read the next block. + tarinfo = None + while True: + try: + tarinfo = self.tarinfo.fromtarfile(self) + except EOFHeaderError as e: + if self.ignore_zeros: + self._dbg(2, "0x%X: %s" % (self.offset, e)) + self.offset += BLOCKSIZE + continue + except InvalidHeaderError as e: + if self.ignore_zeros: + self._dbg(2, "0x%X: %s" % (self.offset, e)) + self.offset += BLOCKSIZE + continue + elif self.offset == 0: + raise ReadError(str(e)) from None + except EmptyHeaderError: + if self.offset == 0: + raise ReadError("empty file") from None + except TruncatedHeaderError as e: + if self.offset == 0: + raise ReadError(str(e)) from None + except SubsequentHeaderError as e: + raise ReadError(str(e)) from None + except Exception as e: + try: + import zlib + if isinstance(e, zlib.error): + raise ReadError(f'zlib error: {e}') from None + else: + raise e + except ImportError: + raise e + break + + if tarinfo is not None: + self.members.append(tarinfo) + else: + self._loaded = True + + return tarinfo + + #-------------------------------------------------------------------------- + # Little helper methods: + + def _getmember(self, name, tarinfo=None, normalize=False): + """Find an archive member by name from bottom to top. + If tarinfo is given, it is used as the starting point. + """ + # Ensure that all members have been loaded. + members = self.getmembers() + + # Limit the member search list up to tarinfo. + skipping = False + if tarinfo is not None: + try: + index = members.index(tarinfo) + except ValueError: + # The given starting point might be a (modified) copy. + # We'll later skip members until we find an equivalent. + skipping = True + else: + # Happy fast path + members = members[:index] + + if normalize: + name = os.path.normpath(name) + + for member in reversed(members): + if skipping: + if tarinfo.offset == member.offset: + skipping = False + continue + if normalize: + member_name = os.path.normpath(member.name) + else: + member_name = member.name + + if name == member_name: + return member + + if skipping: + # Starting point was not found + raise ValueError(tarinfo) + + def _load(self): + """Read through the entire archive file and look for readable + members. + """ + while True: + tarinfo = self.next() + if tarinfo is None: + break + self._loaded = True + + def _check(self, mode=None): + """Check if TarFile is still open, and if the operation's mode + corresponds to TarFile's mode. + """ + if self.closed: + raise OSError("%s is closed" % self.__class__.__name__) + if mode is not None and self.mode not in mode: + raise OSError("bad operation for mode %r" % self.mode) + + def _find_link_target(self, tarinfo): + """Find the target member of a symlink or hardlink member in the + archive. + """ + if tarinfo.issym(): + # Always search the entire archive. + linkname = "/".join(filter(None, (os.path.dirname(tarinfo.name), tarinfo.linkname))) + limit = None + else: + # Search the archive before the link, because a hard link is + # just a reference to an already archived file. + linkname = tarinfo.linkname + limit = tarinfo + + member = self._getmember(linkname, tarinfo=limit, normalize=True) + if member is None: + raise KeyError("linkname %r not found" % linkname) + return member + + def __iter__(self): + """Provide an iterator object. + """ + if self._loaded: + yield from self.members + return + + # Yield items using TarFile's next() method. + # When all members have been read, set TarFile as _loaded. + index = 0 + # Fix for SF #1100429: Under rare circumstances it can + # happen that getmembers() is called during iteration, + # which will have already exhausted the next() method. + if self.firstmember is not None: + tarinfo = self.next() + index += 1 + yield tarinfo + + while True: + if index < len(self.members): + tarinfo = self.members[index] + elif not self._loaded: + tarinfo = self.next() + if not tarinfo: + self._loaded = True + return + else: + return + index += 1 + yield tarinfo + + def _dbg(self, level, msg): + """Write debugging output to sys.stderr. + """ + if level <= self.debug: + print(msg, file=sys.stderr) + + def __enter__(self): + self._check() + return self + + def __exit__(self, type, value, traceback): + if type is None: + self.close() + else: + # An exception occurred. We must not call close() because + # it would try to write end-of-archive blocks and padding. + if not self._extfileobj: + self.fileobj.close() + self.closed = True + +#-------------------- +# exported functions +#-------------------- + +def is_tarfile(name): + """Return True if name points to a tar archive that we + are able to handle, else return False. + + 'name' should be a string, file, or file-like object. + """ + try: + if hasattr(name, "read"): + pos = name.tell() + t = open(fileobj=name) + name.seek(pos) + else: + t = open(name) + t.close() + return True + except TarError: + return False + +open = TarFile.open + + +def main(): + import argparse + + description = 'A simple command-line interface for tarfile module.' + parser = argparse.ArgumentParser(description=description) + parser.add_argument('-v', '--verbose', action='store_true', default=False, + help='Verbose output') + parser.add_argument('--filter', metavar='', + choices=_NAMED_FILTERS, + help='Filter for extraction') + + group = parser.add_mutually_exclusive_group(required=True) + group.add_argument('-l', '--list', metavar='', + help='Show listing of a tarfile') + group.add_argument('-e', '--extract', nargs='+', + metavar=('', ''), + help='Extract tarfile into target dir') + group.add_argument('-c', '--create', nargs='+', + metavar=('', ''), + help='Create tarfile from sources') + group.add_argument('-t', '--test', metavar='', + help='Test if a tarfile is valid') + + args = parser.parse_args() + + if args.filter and args.extract is None: + parser.exit(1, '--filter is only valid for extraction\n') + + if args.test is not None: + src = args.test + if is_tarfile(src): + with open(src, 'r') as tar: + tar.getmembers() + print(tar.getmembers(), file=sys.stderr) + if args.verbose: + print('{!r} is a tar archive.'.format(src)) + else: + parser.exit(1, '{!r} is not a tar archive.\n'.format(src)) + + elif args.list is not None: + src = args.list + if is_tarfile(src): + with TarFile.open(src, 'r:*') as tf: + tf.list(verbose=args.verbose) + else: + parser.exit(1, '{!r} is not a tar archive.\n'.format(src)) + + elif args.extract is not None: + if len(args.extract) == 1: + src = args.extract[0] + curdir = os.curdir + elif len(args.extract) == 2: + src, curdir = args.extract + else: + parser.exit(1, parser.format_help()) + + if is_tarfile(src): + with TarFile.open(src, 'r:*') as tf: + tf.extractall(path=curdir, filter=args.filter) + if args.verbose: + if curdir == '.': + msg = '{!r} file is extracted.'.format(src) + else: + msg = ('{!r} file is extracted ' + 'into {!r} directory.').format(src, curdir) + print(msg) + else: + parser.exit(1, '{!r} is not a tar archive.\n'.format(src)) + + elif args.create is not None: + tar_name = args.create.pop(0) + _, ext = os.path.splitext(tar_name) + compressions = { + # gz + '.gz': 'gz', + '.tgz': 'gz', + # xz + '.xz': 'xz', + '.txz': 'xz', + # bz2 + '.bz2': 'bz2', + '.tbz': 'bz2', + '.tbz2': 'bz2', + '.tb2': 'bz2', + } + tar_mode = 'w:' + compressions[ext] if ext in compressions else 'w' + tar_files = args.create + + with TarFile.open(tar_name, tar_mode) as tf: + for file_name in tar_files: + tf.add(file_name) + + if args.verbose: + print('{!r} file created.'.format(tar_name)) + +if __name__ == '__main__': + main() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/telnetlib.py b/physworld_p1_20261018/envs/p1/lib/python3.11/telnetlib.py new file mode 100644 index 0000000000000000000000000000000000000000..62d636129853ad14bf63371f54d70bb06455f636 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/telnetlib.py @@ -0,0 +1,679 @@ +r"""TELNET client class. + +Based on RFC 854: TELNET Protocol Specification, by J. Postel and +J. Reynolds + +Example: + +>>> from telnetlib import Telnet +>>> tn = Telnet('www.python.org', 79) # connect to finger port +>>> tn.write(b'guido\r\n') +>>> print(tn.read_all()) +Login Name TTY Idle When Where +guido Guido van Rossum pts/2 snag.cnri.reston.. + +>>> + +Note that read_all() won't read until eof -- it just reads some data +-- but it guarantees to read at least one byte unless EOF is hit. + +It is possible to pass a Telnet object to a selector in order to wait until +more data is available. Note that in this case, read_eager() may return b'' +even if there was data on the socket, because the protocol negotiation may have +eaten the data. This is why EOFError is needed in some cases to distinguish +between "no data" and "connection closed" (since the socket also appears ready +for reading when it is closed). + +To do: +- option negotiation +- timeout should be intrinsic to the connection object instead of an + option on one of the read calls only + +""" + + +# Imported modules +import sys +import socket +import selectors +from time import monotonic as _time +import warnings + +warnings._deprecated(__name__, remove=(3, 13)) + +__all__ = ["Telnet"] + +# Tunable parameters +DEBUGLEVEL = 0 + +# Telnet protocol defaults +TELNET_PORT = 23 + +# Telnet protocol characters (don't change) +IAC = bytes([255]) # "Interpret As Command" +DONT = bytes([254]) +DO = bytes([253]) +WONT = bytes([252]) +WILL = bytes([251]) +theNULL = bytes([0]) + +SE = bytes([240]) # Subnegotiation End +NOP = bytes([241]) # No Operation +DM = bytes([242]) # Data Mark +BRK = bytes([243]) # Break +IP = bytes([244]) # Interrupt process +AO = bytes([245]) # Abort output +AYT = bytes([246]) # Are You There +EC = bytes([247]) # Erase Character +EL = bytes([248]) # Erase Line +GA = bytes([249]) # Go Ahead +SB = bytes([250]) # Subnegotiation Begin + + +# Telnet protocol options code (don't change) +# These ones all come from arpa/telnet.h +BINARY = bytes([0]) # 8-bit data path +ECHO = bytes([1]) # echo +RCP = bytes([2]) # prepare to reconnect +SGA = bytes([3]) # suppress go ahead +NAMS = bytes([4]) # approximate message size +STATUS = bytes([5]) # give status +TM = bytes([6]) # timing mark +RCTE = bytes([7]) # remote controlled transmission and echo +NAOL = bytes([8]) # negotiate about output line width +NAOP = bytes([9]) # negotiate about output page size +NAOCRD = bytes([10]) # negotiate about CR disposition +NAOHTS = bytes([11]) # negotiate about horizontal tabstops +NAOHTD = bytes([12]) # negotiate about horizontal tab disposition +NAOFFD = bytes([13]) # negotiate about formfeed disposition +NAOVTS = bytes([14]) # negotiate about vertical tab stops +NAOVTD = bytes([15]) # negotiate about vertical tab disposition +NAOLFD = bytes([16]) # negotiate about output LF disposition +XASCII = bytes([17]) # extended ascii character set +LOGOUT = bytes([18]) # force logout +BM = bytes([19]) # byte macro +DET = bytes([20]) # data entry terminal +SUPDUP = bytes([21]) # supdup protocol +SUPDUPOUTPUT = bytes([22]) # supdup output +SNDLOC = bytes([23]) # send location +TTYPE = bytes([24]) # terminal type +EOR = bytes([25]) # end or record +TUID = bytes([26]) # TACACS user identification +OUTMRK = bytes([27]) # output marking +TTYLOC = bytes([28]) # terminal location number +VT3270REGIME = bytes([29]) # 3270 regime +X3PAD = bytes([30]) # X.3 PAD +NAWS = bytes([31]) # window size +TSPEED = bytes([32]) # terminal speed +LFLOW = bytes([33]) # remote flow control +LINEMODE = bytes([34]) # Linemode option +XDISPLOC = bytes([35]) # X Display Location +OLD_ENVIRON = bytes([36]) # Old - Environment variables +AUTHENTICATION = bytes([37]) # Authenticate +ENCRYPT = bytes([38]) # Encryption option +NEW_ENVIRON = bytes([39]) # New - Environment variables +# the following ones come from +# http://www.iana.org/assignments/telnet-options +# Unfortunately, that document does not assign identifiers +# to all of them, so we are making them up +TN3270E = bytes([40]) # TN3270E +XAUTH = bytes([41]) # XAUTH +CHARSET = bytes([42]) # CHARSET +RSP = bytes([43]) # Telnet Remote Serial Port +COM_PORT_OPTION = bytes([44]) # Com Port Control Option +SUPPRESS_LOCAL_ECHO = bytes([45]) # Telnet Suppress Local Echo +TLS = bytes([46]) # Telnet Start TLS +KERMIT = bytes([47]) # KERMIT +SEND_URL = bytes([48]) # SEND-URL +FORWARD_X = bytes([49]) # FORWARD_X +PRAGMA_LOGON = bytes([138]) # TELOPT PRAGMA LOGON +SSPI_LOGON = bytes([139]) # TELOPT SSPI LOGON +PRAGMA_HEARTBEAT = bytes([140]) # TELOPT PRAGMA HEARTBEAT +EXOPL = bytes([255]) # Extended-Options-List +NOOPT = bytes([0]) + + +# poll/select have the advantage of not requiring any extra file descriptor, +# contrarily to epoll/kqueue (also, they require a single syscall). +if hasattr(selectors, 'PollSelector'): + _TelnetSelector = selectors.PollSelector +else: + _TelnetSelector = selectors.SelectSelector + + +class Telnet: + + """Telnet interface class. + + An instance of this class represents a connection to a telnet + server. The instance is initially not connected; the open() + method must be used to establish a connection. Alternatively, the + host name and optional port number can be passed to the + constructor, too. + + Don't try to reopen an already connected instance. + + This class has many read_*() methods. Note that some of them + raise EOFError when the end of the connection is read, because + they can return an empty string for other reasons. See the + individual doc strings. + + read_until(expected, [timeout]) + Read until the expected string has been seen, or a timeout is + hit (default is no timeout); may block. + + read_all() + Read all data until EOF; may block. + + read_some() + Read at least one byte or EOF; may block. + + read_very_eager() + Read all data available already queued or on the socket, + without blocking. + + read_eager() + Read either data already queued or some data available on the + socket, without blocking. + + read_lazy() + Read all data in the raw queue (processing it first), without + doing any socket I/O. + + read_very_lazy() + Reads all data in the cooked queue, without doing any socket + I/O. + + read_sb_data() + Reads available data between SB ... SE sequence. Don't block. + + set_option_negotiation_callback(callback) + Each time a telnet option is read on the input flow, this callback + (if set) is called with the following parameters : + callback(telnet socket, command, option) + option will be chr(0) when there is no option. + No other action is done afterwards by telnetlib. + + """ + + def __init__(self, host=None, port=0, + timeout=socket._GLOBAL_DEFAULT_TIMEOUT): + """Constructor. + + When called without arguments, create an unconnected instance. + With a hostname argument, it connects the instance; port number + and timeout are optional. + """ + self.debuglevel = DEBUGLEVEL + self.host = host + self.port = port + self.timeout = timeout + self.sock = None + self.rawq = b'' + self.irawq = 0 + self.cookedq = b'' + self.eof = 0 + self.iacseq = b'' # Buffer for IAC sequence. + self.sb = 0 # flag for SB and SE sequence. + self.sbdataq = b'' + self.option_callback = None + if host is not None: + self.open(host, port, timeout) + + def open(self, host, port=0, timeout=socket._GLOBAL_DEFAULT_TIMEOUT): + """Connect to a host. + + The optional second argument is the port number, which + defaults to the standard telnet port (23). + + Don't try to reopen an already connected instance. + """ + self.eof = 0 + if not port: + port = TELNET_PORT + self.host = host + self.port = port + self.timeout = timeout + sys.audit("telnetlib.Telnet.open", self, host, port) + self.sock = socket.create_connection((host, port), timeout) + + def __del__(self): + """Destructor -- close the connection.""" + self.close() + + def msg(self, msg, *args): + """Print a debug message, when the debug level is > 0. + + If extra arguments are present, they are substituted in the + message using the standard string formatting operator. + + """ + if self.debuglevel > 0: + print('Telnet(%s,%s):' % (self.host, self.port), end=' ') + if args: + print(msg % args) + else: + print(msg) + + def set_debuglevel(self, debuglevel): + """Set the debug level. + + The higher it is, the more debug output you get (on sys.stdout). + + """ + self.debuglevel = debuglevel + + def close(self): + """Close the connection.""" + sock = self.sock + self.sock = None + self.eof = True + self.iacseq = b'' + self.sb = 0 + if sock: + sock.close() + + def get_socket(self): + """Return the socket object used internally.""" + return self.sock + + def fileno(self): + """Return the fileno() of the socket object used internally.""" + return self.sock.fileno() + + def write(self, buffer): + """Write a string to the socket, doubling any IAC characters. + + Can block if the connection is blocked. May raise + OSError if the connection is closed. + + """ + if IAC in buffer: + buffer = buffer.replace(IAC, IAC+IAC) + sys.audit("telnetlib.Telnet.write", self, buffer) + self.msg("send %r", buffer) + self.sock.sendall(buffer) + + def read_until(self, match, timeout=None): + """Read until a given string is encountered or until timeout. + + When no match is found, return whatever is available instead, + possibly the empty string. Raise EOFError if the connection + is closed and no cooked data is available. + + """ + n = len(match) + self.process_rawq() + i = self.cookedq.find(match) + if i >= 0: + i = i+n + buf = self.cookedq[:i] + self.cookedq = self.cookedq[i:] + return buf + if timeout is not None: + deadline = _time() + timeout + with _TelnetSelector() as selector: + selector.register(self, selectors.EVENT_READ) + while not self.eof: + if selector.select(timeout): + i = max(0, len(self.cookedq)-n) + self.fill_rawq() + self.process_rawq() + i = self.cookedq.find(match, i) + if i >= 0: + i = i+n + buf = self.cookedq[:i] + self.cookedq = self.cookedq[i:] + return buf + if timeout is not None: + timeout = deadline - _time() + if timeout < 0: + break + return self.read_very_lazy() + + def read_all(self): + """Read all data until EOF; block until connection closed.""" + self.process_rawq() + while not self.eof: + self.fill_rawq() + self.process_rawq() + buf = self.cookedq + self.cookedq = b'' + return buf + + def read_some(self): + """Read at least one byte of cooked data unless EOF is hit. + + Return b'' if EOF is hit. Block if no data is immediately + available. + + """ + self.process_rawq() + while not self.cookedq and not self.eof: + self.fill_rawq() + self.process_rawq() + buf = self.cookedq + self.cookedq = b'' + return buf + + def read_very_eager(self): + """Read everything that's possible without blocking in I/O (eager). + + Raise EOFError if connection closed and no cooked data + available. Return b'' if no cooked data available otherwise. + Don't block unless in the midst of an IAC sequence. + + """ + self.process_rawq() + while not self.eof and self.sock_avail(): + self.fill_rawq() + self.process_rawq() + return self.read_very_lazy() + + def read_eager(self): + """Read readily available data. + + Raise EOFError if connection closed and no cooked data + available. Return b'' if no cooked data available otherwise. + Don't block unless in the midst of an IAC sequence. + + """ + self.process_rawq() + while not self.cookedq and not self.eof and self.sock_avail(): + self.fill_rawq() + self.process_rawq() + return self.read_very_lazy() + + def read_lazy(self): + """Process and return data that's already in the queues (lazy). + + Raise EOFError if connection closed and no data available. + Return b'' if no cooked data available otherwise. Don't block + unless in the midst of an IAC sequence. + + """ + self.process_rawq() + return self.read_very_lazy() + + def read_very_lazy(self): + """Return any data available in the cooked queue (very lazy). + + Raise EOFError if connection closed and no data available. + Return b'' if no cooked data available otherwise. Don't block. + + """ + buf = self.cookedq + self.cookedq = b'' + if not buf and self.eof and not self.rawq: + raise EOFError('telnet connection closed') + return buf + + def read_sb_data(self): + """Return any data available in the SB ... SE queue. + + Return b'' if no SB ... SE available. Should only be called + after seeing a SB or SE command. When a new SB command is + found, old unread SB data will be discarded. Don't block. + + """ + buf = self.sbdataq + self.sbdataq = b'' + return buf + + def set_option_negotiation_callback(self, callback): + """Provide a callback function called after each receipt of a telnet option.""" + self.option_callback = callback + + def process_rawq(self): + """Transfer from raw queue to cooked queue. + + Set self.eof when connection is closed. Don't block unless in + the midst of an IAC sequence. + + """ + buf = [b'', b''] + try: + while self.rawq: + c = self.rawq_getchar() + if not self.iacseq: + if c == theNULL: + continue + if c == b"\021": + continue + if c != IAC: + buf[self.sb] = buf[self.sb] + c + continue + else: + self.iacseq += c + elif len(self.iacseq) == 1: + # 'IAC: IAC CMD [OPTION only for WILL/WONT/DO/DONT]' + if c in (DO, DONT, WILL, WONT): + self.iacseq += c + continue + + self.iacseq = b'' + if c == IAC: + buf[self.sb] = buf[self.sb] + c + else: + if c == SB: # SB ... SE start. + self.sb = 1 + self.sbdataq = b'' + elif c == SE: + self.sb = 0 + self.sbdataq = self.sbdataq + buf[1] + buf[1] = b'' + if self.option_callback: + # Callback is supposed to look into + # the sbdataq + self.option_callback(self.sock, c, NOOPT) + else: + # We can't offer automatic processing of + # suboptions. Alas, we should not get any + # unless we did a WILL/DO before. + self.msg('IAC %d not recognized' % ord(c)) + elif len(self.iacseq) == 2: + cmd = self.iacseq[1:2] + self.iacseq = b'' + opt = c + if cmd in (DO, DONT): + self.msg('IAC %s %d', + cmd == DO and 'DO' or 'DONT', ord(opt)) + if self.option_callback: + self.option_callback(self.sock, cmd, opt) + else: + self.sock.sendall(IAC + WONT + opt) + elif cmd in (WILL, WONT): + self.msg('IAC %s %d', + cmd == WILL and 'WILL' or 'WONT', ord(opt)) + if self.option_callback: + self.option_callback(self.sock, cmd, opt) + else: + self.sock.sendall(IAC + DONT + opt) + except EOFError: # raised by self.rawq_getchar() + self.iacseq = b'' # Reset on EOF + self.sb = 0 + self.cookedq = self.cookedq + buf[0] + self.sbdataq = self.sbdataq + buf[1] + + def rawq_getchar(self): + """Get next char from raw queue. + + Block if no data is immediately available. Raise EOFError + when connection is closed. + + """ + if not self.rawq: + self.fill_rawq() + if self.eof: + raise EOFError + c = self.rawq[self.irawq:self.irawq+1] + self.irawq = self.irawq + 1 + if self.irawq >= len(self.rawq): + self.rawq = b'' + self.irawq = 0 + return c + + def fill_rawq(self): + """Fill raw queue from exactly one recv() system call. + + Block if no data is immediately available. Set self.eof when + connection is closed. + + """ + if self.irawq >= len(self.rawq): + self.rawq = b'' + self.irawq = 0 + # The buffer size should be fairly small so as to avoid quadratic + # behavior in process_rawq() above + buf = self.sock.recv(50) + self.msg("recv %r", buf) + self.eof = (not buf) + self.rawq = self.rawq + buf + + def sock_avail(self): + """Test whether data is available on the socket.""" + with _TelnetSelector() as selector: + selector.register(self, selectors.EVENT_READ) + return bool(selector.select(0)) + + def interact(self): + """Interaction function, emulates a very dumb telnet client.""" + if sys.platform == "win32": + self.mt_interact() + return + with _TelnetSelector() as selector: + selector.register(self, selectors.EVENT_READ) + selector.register(sys.stdin, selectors.EVENT_READ) + + while True: + for key, events in selector.select(): + if key.fileobj is self: + try: + text = self.read_eager() + except EOFError: + print('*** Connection closed by remote host ***') + return + if text: + sys.stdout.write(text.decode('ascii')) + sys.stdout.flush() + elif key.fileobj is sys.stdin: + line = sys.stdin.readline().encode('ascii') + if not line: + return + self.write(line) + + def mt_interact(self): + """Multithreaded version of interact().""" + import _thread + _thread.start_new_thread(self.listener, ()) + while 1: + line = sys.stdin.readline() + if not line: + break + self.write(line.encode('ascii')) + + def listener(self): + """Helper for mt_interact() -- this executes in the other thread.""" + while 1: + try: + data = self.read_eager() + except EOFError: + print('*** Connection closed by remote host ***') + return + if data: + sys.stdout.write(data.decode('ascii')) + else: + sys.stdout.flush() + + def expect(self, list, timeout=None): + """Read until one from a list of a regular expressions matches. + + The first argument is a list of regular expressions, either + compiled (re.Pattern instances) or uncompiled (strings). + The optional second argument is a timeout, in seconds; default + is no timeout. + + Return a tuple of three items: the index in the list of the + first regular expression that matches; the re.Match object + returned; and the text read up till and including the match. + + If EOF is read and no text was read, raise EOFError. + Otherwise, when nothing matches, return (-1, None, text) where + text is the text received so far (may be the empty string if a + timeout happened). + + If a regular expression ends with a greedy match (e.g. '.*') + or if more than one expression can match the same input, the + results are undeterministic, and may depend on the I/O timing. + + """ + re = None + list = list[:] + indices = range(len(list)) + for i in indices: + if not hasattr(list[i], "search"): + if not re: import re + list[i] = re.compile(list[i]) + if timeout is not None: + deadline = _time() + timeout + with _TelnetSelector() as selector: + selector.register(self, selectors.EVENT_READ) + while not self.eof: + self.process_rawq() + for i in indices: + m = list[i].search(self.cookedq) + if m: + e = m.end() + text = self.cookedq[:e] + self.cookedq = self.cookedq[e:] + return (i, m, text) + if timeout is not None: + ready = selector.select(timeout) + timeout = deadline - _time() + if not ready: + if timeout < 0: + break + else: + continue + self.fill_rawq() + text = self.read_very_lazy() + if not text and self.eof: + raise EOFError + return (-1, None, text) + + def __enter__(self): + return self + + def __exit__(self, type, value, traceback): + self.close() + + +def test(): + """Test program for telnetlib. + + Usage: python telnetlib.py [-d] ... [host [port]] + + Default host is localhost; default port is 23. + + """ + debuglevel = 0 + while sys.argv[1:] and sys.argv[1] == '-d': + debuglevel = debuglevel+1 + del sys.argv[1] + host = 'localhost' + if sys.argv[1:]: + host = sys.argv[1] + port = 0 + if sys.argv[2:]: + portstr = sys.argv[2] + try: + port = int(portstr) + except ValueError: + port = socket.getservbyname(portstr, 'tcp') + with Telnet() as tn: + tn.set_debuglevel(debuglevel) + tn.open(host, port, timeout=0.5) + tn.interact() + +if __name__ == '__main__': + test() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tempfile.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tempfile.py new file mode 100644 index 0000000000000000000000000000000000000000..abb5f45103f459134f6283866bf3c441781e2f75 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tempfile.py @@ -0,0 +1,949 @@ +"""Temporary files. + +This module provides generic, low- and high-level interfaces for +creating temporary files and directories. All of the interfaces +provided by this module can be used without fear of race conditions +except for 'mktemp'. 'mktemp' is subject to race conditions and +should not be used; it is provided for backward compatibility only. + +The default path names are returned as str. If you supply bytes as +input, all return values will be in bytes. Ex: + + >>> tempfile.mkstemp() + (4, '/tmp/tmptpu9nin8') + >>> tempfile.mkdtemp(suffix=b'') + b'/tmp/tmppbi8f0hy' + +This module also provides some data items to the user: + + TMP_MAX - maximum number of names that will be tried before + giving up. + tempdir - If this is set to a string before the first use of + any routine from this module, it will be considered as + another candidate location to store temporary files. +""" + +__all__ = [ + "NamedTemporaryFile", "TemporaryFile", # high level safe interfaces + "SpooledTemporaryFile", "TemporaryDirectory", + "mkstemp", "mkdtemp", # low level safe interfaces + "mktemp", # deprecated unsafe interface + "TMP_MAX", "gettempprefix", # constants + "tempdir", "gettempdir", + "gettempprefixb", "gettempdirb", + ] + + +# Imports. + +import functools as _functools +import warnings as _warnings +import io as _io +import os as _os +import shutil as _shutil +import stat as _stat +import errno as _errno +from random import Random as _Random +import sys as _sys +import types as _types +import weakref as _weakref +import _thread +_allocate_lock = _thread.allocate_lock + +_text_openflags = _os.O_RDWR | _os.O_CREAT | _os.O_EXCL +if hasattr(_os, 'O_NOFOLLOW'): + _text_openflags |= _os.O_NOFOLLOW + +_bin_openflags = _text_openflags +if hasattr(_os, 'O_BINARY'): + _bin_openflags |= _os.O_BINARY + +if hasattr(_os, 'TMP_MAX'): + TMP_MAX = _os.TMP_MAX +else: + TMP_MAX = 10000 + +# This variable _was_ unused for legacy reasons, see issue 10354. +# But as of 3.5 we actually use it at runtime so changing it would +# have a possibly desirable side effect... But we do not want to support +# that as an API. It is undocumented on purpose. Do not depend on this. +template = "tmp" + +# Internal routines. + +_once_lock = _allocate_lock() + + +def _exists(fn): + try: + _os.lstat(fn) + except OSError: + return False + else: + return True + + +def _infer_return_type(*args): + """Look at the type of all args and divine their implied return type.""" + return_type = None + for arg in args: + if arg is None: + continue + + if isinstance(arg, _os.PathLike): + arg = _os.fspath(arg) + + if isinstance(arg, bytes): + if return_type is str: + raise TypeError("Can't mix bytes and non-bytes in " + "path components.") + return_type = bytes + else: + if return_type is bytes: + raise TypeError("Can't mix bytes and non-bytes in " + "path components.") + return_type = str + if return_type is None: + if tempdir is None or isinstance(tempdir, str): + return str # tempfile APIs return a str by default. + else: + # we could check for bytes but it'll fail later on anyway + return bytes + return return_type + + +def _sanitize_params(prefix, suffix, dir): + """Common parameter processing for most APIs in this module.""" + output_type = _infer_return_type(prefix, suffix, dir) + if suffix is None: + suffix = output_type() + if prefix is None: + if output_type is str: + prefix = template + else: + prefix = _os.fsencode(template) + if dir is None: + if output_type is str: + dir = gettempdir() + else: + dir = gettempdirb() + return prefix, suffix, dir, output_type + + +class _RandomNameSequence: + """An instance of _RandomNameSequence generates an endless + sequence of unpredictable strings which can safely be incorporated + into file names. Each string is eight characters long. Multiple + threads can safely use the same instance at the same time. + + _RandomNameSequence is an iterator.""" + + characters = "abcdefghijklmnopqrstuvwxyz0123456789_" + + @property + def rng(self): + cur_pid = _os.getpid() + if cur_pid != getattr(self, '_rng_pid', None): + self._rng = _Random() + self._rng_pid = cur_pid + return self._rng + + def __iter__(self): + return self + + def __next__(self): + return ''.join(self.rng.choices(self.characters, k=8)) + +def _candidate_tempdir_list(): + """Generate a list of candidate temporary directories which + _get_default_tempdir will try.""" + + dirlist = [] + + # First, try the environment. + for envname in 'TMPDIR', 'TEMP', 'TMP': + dirname = _os.getenv(envname) + if dirname: dirlist.append(dirname) + + # Failing that, try OS-specific locations. + if _os.name == 'nt': + dirlist.extend([ _os.path.expanduser(r'~\AppData\Local\Temp'), + _os.path.expandvars(r'%SYSTEMROOT%\Temp'), + r'c:\temp', r'c:\tmp', r'\temp', r'\tmp' ]) + else: + dirlist.extend([ '/tmp', '/var/tmp', '/usr/tmp' ]) + + # As a last resort, the current directory. + try: + dirlist.append(_os.getcwd()) + except (AttributeError, OSError): + dirlist.append(_os.curdir) + + return dirlist + +def _get_default_tempdir(): + """Calculate the default directory to use for temporary files. + This routine should be called exactly once. + + We determine whether or not a candidate temp dir is usable by + trying to create and write to a file in that directory. If this + is successful, the test file is deleted. To prevent denial of + service, the name of the test file must be randomized.""" + + namer = _RandomNameSequence() + dirlist = _candidate_tempdir_list() + + for dir in dirlist: + if dir != _os.curdir: + dir = _os.path.abspath(dir) + # Try only a few names per directory. + for seq in range(100): + name = next(namer) + filename = _os.path.join(dir, name) + try: + fd = _os.open(filename, _bin_openflags, 0o600) + try: + try: + _os.write(fd, b'blat') + finally: + _os.close(fd) + finally: + _os.unlink(filename) + return dir + except FileExistsError: + pass + except PermissionError: + # This exception is thrown when a directory with the chosen name + # already exists on windows. + if (_os.name == 'nt' and _os.path.isdir(dir) and + _os.access(dir, _os.W_OK)): + continue + break # no point trying more names in this directory + except OSError: + break # no point trying more names in this directory + raise FileNotFoundError(_errno.ENOENT, + "No usable temporary directory found in %s" % + dirlist) + +_name_sequence = None + +def _get_candidate_names(): + """Common setup sequence for all user-callable interfaces.""" + + global _name_sequence + if _name_sequence is None: + _once_lock.acquire() + try: + if _name_sequence is None: + _name_sequence = _RandomNameSequence() + finally: + _once_lock.release() + return _name_sequence + + +def _mkstemp_inner(dir, pre, suf, flags, output_type): + """Code common to mkstemp, TemporaryFile, and NamedTemporaryFile.""" + + dir = _os.path.abspath(dir) + names = _get_candidate_names() + if output_type is bytes: + names = map(_os.fsencode, names) + + for seq in range(TMP_MAX): + name = next(names) + file = _os.path.join(dir, pre + name + suf) + _sys.audit("tempfile.mkstemp", file) + try: + fd = _os.open(file, flags, 0o600) + except FileExistsError: + continue # try again + except PermissionError: + # This exception is thrown when a directory with the chosen name + # already exists on windows. + if (_os.name == 'nt' and _os.path.isdir(dir) and + _os.access(dir, _os.W_OK)): + continue + else: + raise + return fd, file + + raise FileExistsError(_errno.EEXIST, + "No usable temporary file name found") + +def _dont_follow_symlinks(func, path, *args): + # Pass follow_symlinks=False, unless not supported on this platform. + if func in _os.supports_follow_symlinks: + func(path, *args, follow_symlinks=False) + elif _os.name == 'nt' or not _os.path.islink(path): + func(path, *args) + +def _resetperms(path): + try: + chflags = _os.chflags + except AttributeError: + pass + else: + _dont_follow_symlinks(chflags, path, 0) + _dont_follow_symlinks(_os.chmod, path, 0o700) + + +# User visible interfaces. + +def gettempprefix(): + """The default prefix for temporary directories as string.""" + return _os.fsdecode(template) + +def gettempprefixb(): + """The default prefix for temporary directories as bytes.""" + return _os.fsencode(template) + +tempdir = None + +def _gettempdir(): + """Private accessor for tempfile.tempdir.""" + global tempdir + if tempdir is None: + _once_lock.acquire() + try: + if tempdir is None: + tempdir = _get_default_tempdir() + finally: + _once_lock.release() + return tempdir + +def gettempdir(): + """Returns tempfile.tempdir as str.""" + return _os.fsdecode(_gettempdir()) + +def gettempdirb(): + """Returns tempfile.tempdir as bytes.""" + return _os.fsencode(_gettempdir()) + +def mkstemp(suffix=None, prefix=None, dir=None, text=False): + """User-callable function to create and return a unique temporary + file. The return value is a pair (fd, name) where fd is the + file descriptor returned by os.open, and name is the filename. + + If 'suffix' is not None, the file name will end with that suffix, + otherwise there will be no suffix. + + If 'prefix' is not None, the file name will begin with that prefix, + otherwise a default prefix is used. + + If 'dir' is not None, the file will be created in that directory, + otherwise a default directory is used. + + If 'text' is specified and true, the file is opened in text + mode. Else (the default) the file is opened in binary mode. + + If any of 'suffix', 'prefix' and 'dir' are not None, they must be the + same type. If they are bytes, the returned name will be bytes; str + otherwise. + + The file is readable and writable only by the creating user ID. + If the operating system uses permission bits to indicate whether a + file is executable, the file is executable by no one. The file + descriptor is not inherited by children of this process. + + Caller is responsible for deleting the file when done with it. + """ + + prefix, suffix, dir, output_type = _sanitize_params(prefix, suffix, dir) + + if text: + flags = _text_openflags + else: + flags = _bin_openflags + + return _mkstemp_inner(dir, prefix, suffix, flags, output_type) + + +def mkdtemp(suffix=None, prefix=None, dir=None): + """User-callable function to create and return a unique temporary + directory. The return value is the pathname of the directory. + + Arguments are as for mkstemp, except that the 'text' argument is + not accepted. + + The directory is readable, writable, and searchable only by the + creating user. + + Caller is responsible for deleting the directory when done with it. + """ + + prefix, suffix, dir, output_type = _sanitize_params(prefix, suffix, dir) + + names = _get_candidate_names() + if output_type is bytes: + names = map(_os.fsencode, names) + + for seq in range(TMP_MAX): + name = next(names) + file = _os.path.join(dir, prefix + name + suffix) + _sys.audit("tempfile.mkdtemp", file) + try: + _os.mkdir(file, 0o700) + except FileExistsError: + continue # try again + except PermissionError: + # This exception is thrown when a directory with the chosen name + # already exists on windows. + if (_os.name == 'nt' and _os.path.isdir(dir) and + _os.access(dir, _os.W_OK)): + continue + else: + raise + return file + + raise FileExistsError(_errno.EEXIST, + "No usable temporary directory name found") + +def mktemp(suffix="", prefix=template, dir=None): + """User-callable function to return a unique temporary file name. The + file is not created. + + Arguments are similar to mkstemp, except that the 'text' argument is + not accepted, and suffix=None, prefix=None and bytes file names are not + supported. + + THIS FUNCTION IS UNSAFE AND SHOULD NOT BE USED. The file name may + refer to a file that did not exist at some point, but by the time + you get around to creating it, someone else may have beaten you to + the punch. + """ + +## from warnings import warn as _warn +## _warn("mktemp is a potential security risk to your program", +## RuntimeWarning, stacklevel=2) + + if dir is None: + dir = gettempdir() + + names = _get_candidate_names() + for seq in range(TMP_MAX): + name = next(names) + file = _os.path.join(dir, prefix + name + suffix) + if not _exists(file): + return file + + raise FileExistsError(_errno.EEXIST, + "No usable temporary filename found") + + +class _TemporaryFileCloser: + """A separate object allowing proper closing of a temporary file's + underlying file object, without adding a __del__ method to the + temporary file.""" + + file = None # Set here since __del__ checks it + close_called = False + + def __init__(self, file, name, delete=True): + self.file = file + self.name = name + self.delete = delete + + # NT provides delete-on-close as a primitive, so we don't need + # the wrapper to do anything special. We still use it so that + # file.name is useful (i.e. not "(fdopen)") with NamedTemporaryFile. + if _os.name != 'nt': + # Cache the unlinker so we don't get spurious errors at + # shutdown when the module-level "os" is None'd out. Note + # that this must be referenced as self.unlink, because the + # name TemporaryFileWrapper may also get None'd out before + # __del__ is called. + + def close(self, unlink=_os.unlink): + if not self.close_called and self.file is not None: + self.close_called = True + try: + self.file.close() + finally: + if self.delete: + unlink(self.name) + + # Need to ensure the file is deleted on __del__ + def __del__(self): + self.close() + + else: + def close(self): + if not self.close_called: + self.close_called = True + self.file.close() + + +class _TemporaryFileWrapper: + """Temporary file wrapper + + This class provides a wrapper around files opened for + temporary use. In particular, it seeks to automatically + remove the file when it is no longer needed. + """ + + def __init__(self, file, name, delete=True): + self.file = file + self.name = name + self.delete = delete + self._closer = _TemporaryFileCloser(file, name, delete) + + def __getattr__(self, name): + # Attribute lookups are delegated to the underlying file + # and cached for non-numeric results + # (i.e. methods are cached, closed and friends are not) + file = self.__dict__['file'] + a = getattr(file, name) + if hasattr(a, '__call__'): + func = a + @_functools.wraps(func) + def func_wrapper(*args, **kwargs): + return func(*args, **kwargs) + # Avoid closing the file as long as the wrapper is alive, + # see issue #18879. + func_wrapper._closer = self._closer + a = func_wrapper + if not isinstance(a, int): + setattr(self, name, a) + return a + + # The underlying __enter__ method returns the wrong object + # (self.file) so override it to return the wrapper + def __enter__(self): + self.file.__enter__() + return self + + # Need to trap __exit__ as well to ensure the file gets + # deleted when used in a with statement + def __exit__(self, exc, value, tb): + result = self.file.__exit__(exc, value, tb) + self.close() + return result + + def close(self): + """ + Close the temporary file, possibly deleting it. + """ + self._closer.close() + + # iter() doesn't use __getattr__ to find the __iter__ method + def __iter__(self): + # Don't return iter(self.file), but yield from it to avoid closing + # file as long as it's being used as iterator (see issue #23700). We + # can't use 'yield from' here because iter(file) returns the file + # object itself, which has a close method, and thus the file would get + # closed when the generator is finalized, due to PEP380 semantics. + for line in self.file: + yield line + + +def NamedTemporaryFile(mode='w+b', buffering=-1, encoding=None, + newline=None, suffix=None, prefix=None, + dir=None, delete=True, *, errors=None): + """Create and return a temporary file. + Arguments: + 'prefix', 'suffix', 'dir' -- as for mkstemp. + 'mode' -- the mode argument to io.open (default "w+b"). + 'buffering' -- the buffer size argument to io.open (default -1). + 'encoding' -- the encoding argument to io.open (default None) + 'newline' -- the newline argument to io.open (default None) + 'delete' -- whether the file is deleted on close (default True). + 'errors' -- the errors argument to io.open (default None) + The file is created as mkstemp() would do it. + + Returns an object with a file-like interface; the name of the file + is accessible as its 'name' attribute. The file will be automatically + deleted when it is closed unless the 'delete' argument is set to False. + + On POSIX, NamedTemporaryFiles cannot be automatically deleted if + the creating process is terminated abruptly with a SIGKILL signal. + Windows can delete the file even in this case. + """ + + prefix, suffix, dir, output_type = _sanitize_params(prefix, suffix, dir) + + flags = _bin_openflags + + # Setting O_TEMPORARY in the flags causes the OS to delete + # the file when it is closed. This is only supported by Windows. + if _os.name == 'nt' and delete: + flags |= _os.O_TEMPORARY + + if "b" not in mode: + encoding = _io.text_encoding(encoding) + + name = None + def opener(*args): + nonlocal name + fd, name = _mkstemp_inner(dir, prefix, suffix, flags, output_type) + return fd + try: + file = _io.open(dir, mode, buffering=buffering, + newline=newline, encoding=encoding, errors=errors, + opener=opener) + try: + raw = getattr(file, 'buffer', file) + raw = getattr(raw, 'raw', raw) + raw.name = name + return _TemporaryFileWrapper(file, name, delete) + except: + file.close() + raise + except: + if name is not None and not (_os.name == 'nt' and delete): + _os.unlink(name) + raise + +if _os.name != 'posix' or _sys.platform == 'cygwin': + # On non-POSIX and Cygwin systems, assume that we cannot unlink a file + # while it is open. + TemporaryFile = NamedTemporaryFile + +else: + # Is the O_TMPFILE flag available and does it work? + # The flag is set to False if os.open(dir, os.O_TMPFILE) raises an + # IsADirectoryError exception + _O_TMPFILE_WORKS = hasattr(_os, 'O_TMPFILE') + + def TemporaryFile(mode='w+b', buffering=-1, encoding=None, + newline=None, suffix=None, prefix=None, + dir=None, *, errors=None): + """Create and return a temporary file. + Arguments: + 'prefix', 'suffix', 'dir' -- as for mkstemp. + 'mode' -- the mode argument to io.open (default "w+b"). + 'buffering' -- the buffer size argument to io.open (default -1). + 'encoding' -- the encoding argument to io.open (default None) + 'newline' -- the newline argument to io.open (default None) + 'errors' -- the errors argument to io.open (default None) + The file is created as mkstemp() would do it. + + Returns an object with a file-like interface. The file has no + name, and will cease to exist when it is closed. + """ + global _O_TMPFILE_WORKS + + if "b" not in mode: + encoding = _io.text_encoding(encoding) + + prefix, suffix, dir, output_type = _sanitize_params(prefix, suffix, dir) + + flags = _bin_openflags + if _O_TMPFILE_WORKS: + fd = None + def opener(*args): + nonlocal fd + flags2 = (flags | _os.O_TMPFILE) & ~_os.O_CREAT + fd = _os.open(dir, flags2, 0o600) + return fd + try: + file = _io.open(dir, mode, buffering=buffering, + newline=newline, encoding=encoding, + errors=errors, opener=opener) + raw = getattr(file, 'buffer', file) + raw = getattr(raw, 'raw', raw) + raw.name = fd + return file + except IsADirectoryError: + # Linux kernel older than 3.11 ignores the O_TMPFILE flag: + # O_TMPFILE is read as O_DIRECTORY. Trying to open a directory + # with O_RDWR|O_DIRECTORY fails with IsADirectoryError, a + # directory cannot be open to write. Set flag to False to not + # try again. + _O_TMPFILE_WORKS = False + except OSError: + # The filesystem of the directory does not support O_TMPFILE. + # For example, OSError(95, 'Operation not supported'). + # + # On Linux kernel older than 3.11, trying to open a regular + # file (or a symbolic link to a regular file) with O_TMPFILE + # fails with NotADirectoryError, because O_TMPFILE is read as + # O_DIRECTORY. + pass + # Fallback to _mkstemp_inner(). + + fd = None + def opener(*args): + nonlocal fd + fd, name = _mkstemp_inner(dir, prefix, suffix, flags, output_type) + try: + _os.unlink(name) + except BaseException as e: + _os.close(fd) + raise + return fd + file = _io.open(dir, mode, buffering=buffering, + newline=newline, encoding=encoding, errors=errors, + opener=opener) + raw = getattr(file, 'buffer', file) + raw = getattr(raw, 'raw', raw) + raw.name = fd + return file + +class SpooledTemporaryFile(_io.IOBase): + """Temporary file wrapper, specialized to switch from BytesIO + or StringIO to a real file when it exceeds a certain size or + when a fileno is needed. + """ + _rolled = False + + def __init__(self, max_size=0, mode='w+b', buffering=-1, + encoding=None, newline=None, + suffix=None, prefix=None, dir=None, *, errors=None): + if 'b' in mode: + self._file = _io.BytesIO() + else: + encoding = _io.text_encoding(encoding) + self._file = _io.TextIOWrapper(_io.BytesIO(), + encoding=encoding, errors=errors, + newline=newline) + self._max_size = max_size + self._rolled = False + self._TemporaryFileArgs = {'mode': mode, 'buffering': buffering, + 'suffix': suffix, 'prefix': prefix, + 'encoding': encoding, 'newline': newline, + 'dir': dir, 'errors': errors} + + __class_getitem__ = classmethod(_types.GenericAlias) + + def _check(self, file): + if self._rolled: return + max_size = self._max_size + if max_size and file.tell() > max_size: + self.rollover() + + def rollover(self): + if self._rolled: return + file = self._file + newfile = self._file = TemporaryFile(**self._TemporaryFileArgs) + del self._TemporaryFileArgs + + pos = file.tell() + if hasattr(newfile, 'buffer'): + newfile.buffer.write(file.detach().getvalue()) + else: + newfile.write(file.getvalue()) + newfile.seek(pos, 0) + + self._rolled = True + + # The method caching trick from NamedTemporaryFile + # won't work here, because _file may change from a + # BytesIO/StringIO instance to a real file. So we list + # all the methods directly. + + # Context management protocol + def __enter__(self): + if self._file.closed: + raise ValueError("Cannot enter context with closed file") + return self + + def __exit__(self, exc, value, tb): + self._file.close() + + # file protocol + def __iter__(self): + return self._file.__iter__() + + def __del__(self): + if not self.closed: + _warnings.warn( + "Unclosed file {!r}".format(self), + ResourceWarning, + stacklevel=2, + source=self + ) + self.close() + + def close(self): + self._file.close() + + @property + def closed(self): + return self._file.closed + + @property + def encoding(self): + return self._file.encoding + + @property + def errors(self): + return self._file.errors + + def fileno(self): + self.rollover() + return self._file.fileno() + + def flush(self): + self._file.flush() + + def isatty(self): + return self._file.isatty() + + @property + def mode(self): + try: + return self._file.mode + except AttributeError: + return self._TemporaryFileArgs['mode'] + + @property + def name(self): + try: + return self._file.name + except AttributeError: + return None + + @property + def newlines(self): + return self._file.newlines + + def readable(self): + return self._file.readable() + + def read(self, *args): + return self._file.read(*args) + + def read1(self, *args): + return self._file.read1(*args) + + def readinto(self, b): + return self._file.readinto(b) + + def readinto1(self, b): + return self._file.readinto1(b) + + def readline(self, *args): + return self._file.readline(*args) + + def readlines(self, *args): + return self._file.readlines(*args) + + def seekable(self): + return self._file.seekable() + + def seek(self, *args): + return self._file.seek(*args) + + def tell(self): + return self._file.tell() + + def truncate(self, size=None): + if size is None: + return self._file.truncate() + else: + if size > self._max_size: + self.rollover() + return self._file.truncate(size) + + def writable(self): + return self._file.writable() + + def write(self, s): + file = self._file + rv = file.write(s) + self._check(file) + return rv + + def writelines(self, iterable): + file = self._file + rv = file.writelines(iterable) + self._check(file) + return rv + + def detach(self): + return self._file.detach() + + +class TemporaryDirectory: + """Create and return a temporary directory. This has the same + behavior as mkdtemp but can be used as a context manager. For + example: + + with TemporaryDirectory() as tmpdir: + ... + + Upon exiting the context, the directory and everything contained + in it are removed. + """ + + def __init__(self, suffix=None, prefix=None, dir=None, + ignore_cleanup_errors=False): + self.name = mkdtemp(suffix, prefix, dir) + self._ignore_cleanup_errors = ignore_cleanup_errors + self._finalizer = _weakref.finalize( + self, self._cleanup, self.name, + warn_message="Implicitly cleaning up {!r}".format(self), + ignore_errors=self._ignore_cleanup_errors) + + @classmethod + def _rmtree(cls, name, ignore_errors=False, repeated=False): + def onerror(func, path, exc_info): + if issubclass(exc_info[0], PermissionError): + if repeated and path == name: + if ignore_errors: + return + raise + + try: + if path != name: + _resetperms(_os.path.dirname(path)) + _resetperms(path) + + try: + _os.unlink(path) + except IsADirectoryError: + cls._rmtree(path, ignore_errors=ignore_errors) + except PermissionError: + # The PermissionError handler was originally added for + # FreeBSD in directories, but it seems that it is raised + # on Windows too. + # bpo-43153: Calling _rmtree again may + # raise NotADirectoryError and mask the PermissionError. + # So we must re-raise the current PermissionError if + # path is not a directory. + try: + st = _os.lstat(path) + except OSError: + if ignore_errors: + return + raise + if (_stat.S_ISLNK(st.st_mode) or + not _stat.S_ISDIR(st.st_mode) or + (hasattr(st, 'st_file_attributes') and + st.st_file_attributes & _stat.FILE_ATTRIBUTE_REPARSE_POINT and + st.st_reparse_tag == _stat.IO_REPARSE_TAG_MOUNT_POINT) + ): + if ignore_errors: + return + raise + cls._rmtree(path, ignore_errors=ignore_errors, + repeated=(path == name)) + except FileNotFoundError: + pass + elif issubclass(exc_info[0], FileNotFoundError): + pass + else: + if not ignore_errors: + raise + + _shutil.rmtree(name, onerror=onerror) + + @classmethod + def _cleanup(cls, name, warn_message, ignore_errors=False): + cls._rmtree(name, ignore_errors=ignore_errors) + _warnings.warn(warn_message, ResourceWarning) + + def __repr__(self): + return "<{} {!r}>".format(self.__class__.__name__, self.name) + + def __enter__(self): + return self.name + + def __exit__(self, exc, value, tb): + self.cleanup() + + def cleanup(self): + if self._finalizer.detach() or _os.path.exists(self.name): + self._rmtree(self.name, ignore_errors=self._ignore_cleanup_errors) + + __class_getitem__ = classmethod(_types.GenericAlias) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/test/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b93054b3ecf3a5af96f4772e7208e7a18b5dd4a4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/test/__init__.py @@ -0,0 +1 @@ +# Dummy file to make this directory a package. diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/test/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..617cf4a7d69f1a974cf3f58ee102046544870883 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/test/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/__pycache__/test_script_helper.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/test/__pycache__/test_script_helper.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4a539b5c928832885c41c118d51215504ac64557 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/test/__pycache__/test_script_helper.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/__pycache__/test_support.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/test/__pycache__/test_support.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..392eb5ad499647c27b709b971cf5106c0d1e2ec8 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/test/__pycache__/test_support.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9270f3f8d622b50aeb9939034807ecd4cc9604c2 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__init__.py @@ -0,0 +1,2291 @@ +"""Supporting definitions for the Python regression tests.""" + +if __name__ != 'test.support': + raise ImportError('support must be imported from the test package') + +import contextlib +import dataclasses +import functools +import os +import re +import stat +import sys +import sysconfig +import time +import types +import unittest +import warnings + + +try: + from _testcapi import unicode_legacy_string +except ImportError: + unicode_legacy_string = None + +__all__ = [ + # globals + "PIPE_MAX_SIZE", "verbose", "max_memuse", "use_resources", "failfast", + # exceptions + "Error", "TestFailed", "TestDidNotRun", "ResourceDenied", + # io + "record_original_stdout", "get_original_stdout", "captured_stdout", + "captured_stdin", "captured_stderr", + # unittest + "is_resource_enabled", "requires", "requires_freebsd_version", + "requires_linux_version", "requires_mac_ver", + "check_syntax_error", + "requires_gzip", "requires_bz2", "requires_lzma", + "bigmemtest", "bigaddrspacetest", "cpython_only", "get_attribute", + "requires_IEEE_754", "requires_zlib", + "has_fork_support", "requires_fork", + "has_subprocess_support", "requires_subprocess", + "has_socket_support", "requires_working_socket", + "anticipate_failure", "load_package_tests", "detect_api_mismatch", + "check__all__", "skip_if_buggy_ucrt_strfptime", + "check_disallow_instantiation", "check_sanitizer", "skip_if_sanitizer", + # sys + "MS_WINDOWS", "is_jython", "is_android", "is_emscripten", "is_wasi", + "check_impl_detail", "unix_shell", "setswitchinterval", + # network + "open_urlresource", + # processes + "reap_children", + # miscellaneous + "run_with_locale", "swap_item", "findfile", "infinite_recursion", + "swap_attr", "Matcher", "set_memlimit", "SuppressCrashReport", "sortdict", + "run_with_tz", "PGO", "missing_compiler_executable", + "ALWAYS_EQ", "NEVER_EQ", "LARGEST", "SMALLEST", + "LOOPBACK_TIMEOUT", "INTERNET_TIMEOUT", "SHORT_TIMEOUT", "LONG_TIMEOUT", + "skip_on_s390x", + ] + + +# Timeout in seconds for tests using a network server listening on the network +# local loopback interface like 127.0.0.1. +# +# The timeout is long enough to prevent test failure: it takes into account +# that the client and the server can run in different threads or even different +# processes. +# +# The timeout should be long enough for connect(), recv() and send() methods +# of socket.socket. +LOOPBACK_TIMEOUT = 10.0 + +# Timeout in seconds for network requests going to the internet. The timeout is +# short enough to prevent a test to wait for too long if the internet request +# is blocked for whatever reason. +# +# Usually, a timeout using INTERNET_TIMEOUT should not mark a test as failed, +# but skip the test instead: see transient_internet(). +INTERNET_TIMEOUT = 60.0 + +# Timeout in seconds to mark a test as failed if the test takes "too long". +# +# The timeout value depends on the regrtest --timeout command line option. +# +# If a test using SHORT_TIMEOUT starts to fail randomly on slow buildbots, use +# LONG_TIMEOUT instead. +SHORT_TIMEOUT = 30.0 + +# Timeout in seconds to detect when a test hangs. +# +# It is long enough to reduce the risk of test failure on the slowest Python +# buildbots. It should not be used to mark a test as failed if the test takes +# "too long". The timeout value depends on the regrtest --timeout command line +# option. +LONG_TIMEOUT = 5 * 60.0 + +# TEST_HOME_DIR refers to the top level directory of the "test" package +# that contains Python's regression test suite +TEST_SUPPORT_DIR = os.path.dirname(os.path.abspath(__file__)) +TEST_HOME_DIR = os.path.dirname(TEST_SUPPORT_DIR) +STDLIB_DIR = os.path.dirname(TEST_HOME_DIR) +REPO_ROOT = os.path.dirname(STDLIB_DIR) + + +class Error(Exception): + """Base class for regression test exceptions.""" + +class TestFailed(Error): + """Test failed.""" + def __init__(self, msg, *args, stats=None): + self.msg = msg + self.stats = stats + super().__init__(msg, *args) + + def __str__(self): + return self.msg + +class TestFailedWithDetails(TestFailed): + """Test failed.""" + def __init__(self, msg, errors, failures, stats): + self.errors = errors + self.failures = failures + super().__init__(msg, errors, failures, stats=stats) + +class TestDidNotRun(Error): + """Test did not run any subtests.""" + +class ResourceDenied(unittest.SkipTest): + """Test skipped because it requested a disallowed resource. + + This is raised when a test calls requires() for a resource that + has not be enabled. It is used to distinguish between expected + and unexpected skips. + """ + +def anticipate_failure(condition): + """Decorator to mark a test that is known to be broken in some cases + + Any use of this decorator should have a comment identifying the + associated tracker issue. + """ + if condition: + return unittest.expectedFailure + return lambda f: f + +def load_package_tests(pkg_dir, loader, standard_tests, pattern): + """Generic load_tests implementation for simple test packages. + + Most packages can implement load_tests using this function as follows: + + def load_tests(*args): + return load_package_tests(os.path.dirname(__file__), *args) + """ + if pattern is None: + pattern = "test*" + top_dir = STDLIB_DIR + package_tests = loader.discover(start_dir=pkg_dir, + top_level_dir=top_dir, + pattern=pattern) + standard_tests.addTests(package_tests) + return standard_tests + + +def get_attribute(obj, name): + """Get an attribute, raising SkipTest if AttributeError is raised.""" + try: + attribute = getattr(obj, name) + except AttributeError: + raise unittest.SkipTest("object %r has no attribute %r" % (obj, name)) + else: + return attribute + +verbose = 1 # Flag set to 0 by regrtest.py +use_resources = None # Flag set to [] by regrtest.py +max_memuse = 0 # Disable bigmem tests (they will still be run with + # small sizes, to make sure they work.) +real_max_memuse = 0 +junit_xml_list = None # list of testsuite XML elements +failfast = False + +# _original_stdout is meant to hold stdout at the time regrtest began. +# This may be "the real" stdout, or IDLE's emulation of stdout, or whatever. +# The point is to have some flavor of stdout the user can actually see. +_original_stdout = None +def record_original_stdout(stdout): + global _original_stdout + _original_stdout = stdout + +def get_original_stdout(): + return _original_stdout or sys.stdout + + +def _force_run(path, func, *args): + try: + return func(*args) + except FileNotFoundError as err: + # chmod() won't fix a missing file. + if verbose >= 2: + print('%s: %s' % (err.__class__.__name__, err)) + raise + except OSError as err: + if verbose >= 2: + print('%s: %s' % (err.__class__.__name__, err)) + print('re-run %s%r' % (func.__name__, args)) + os.chmod(path, stat.S_IRWXU) + return func(*args) + + +# Check whether a gui is actually available +def _is_gui_available(): + if hasattr(_is_gui_available, 'result'): + return _is_gui_available.result + import platform + reason = None + if sys.platform.startswith('win') and platform.win32_is_iot(): + reason = "gui is not available on Windows IoT Core" + elif sys.platform.startswith('win'): + # if Python is running as a service (such as the buildbot service), + # gui interaction may be disallowed + import ctypes + import ctypes.wintypes + UOI_FLAGS = 1 + WSF_VISIBLE = 0x0001 + class USEROBJECTFLAGS(ctypes.Structure): + _fields_ = [("fInherit", ctypes.wintypes.BOOL), + ("fReserved", ctypes.wintypes.BOOL), + ("dwFlags", ctypes.wintypes.DWORD)] + dll = ctypes.windll.user32 + h = dll.GetProcessWindowStation() + if not h: + raise ctypes.WinError() + uof = USEROBJECTFLAGS() + needed = ctypes.wintypes.DWORD() + res = dll.GetUserObjectInformationW(h, + UOI_FLAGS, + ctypes.byref(uof), + ctypes.sizeof(uof), + ctypes.byref(needed)) + if not res: + raise ctypes.WinError() + if not bool(uof.dwFlags & WSF_VISIBLE): + reason = "gui not available (WSF_VISIBLE flag not set)" + elif sys.platform == 'darwin': + # The Aqua Tk implementations on OS X can abort the process if + # being called in an environment where a window server connection + # cannot be made, for instance when invoked by a buildbot or ssh + # process not running under the same user id as the current console + # user. To avoid that, raise an exception if the window manager + # connection is not available. + from ctypes import cdll, c_int, pointer, Structure + from ctypes.util import find_library + + app_services = cdll.LoadLibrary(find_library("ApplicationServices")) + + if app_services.CGMainDisplayID() == 0: + reason = "gui tests cannot run without OS X window manager" + else: + class ProcessSerialNumber(Structure): + _fields_ = [("highLongOfPSN", c_int), + ("lowLongOfPSN", c_int)] + psn = ProcessSerialNumber() + psn_p = pointer(psn) + if ( (app_services.GetCurrentProcess(psn_p) < 0) or + (app_services.SetFrontProcess(psn_p) < 0) ): + reason = "cannot run without OS X gui process" + + # check on every platform whether tkinter can actually do anything + if not reason: + try: + from tkinter import Tk + root = Tk() + root.withdraw() + root.update() + root.destroy() + except Exception as e: + err_string = str(e) + if len(err_string) > 50: + err_string = err_string[:50] + ' [...]' + reason = 'Tk unavailable due to {}: {}'.format(type(e).__name__, + err_string) + + _is_gui_available.reason = reason + _is_gui_available.result = not reason + + return _is_gui_available.result + +def is_resource_enabled(resource): + """Test whether a resource is enabled. + + Known resources are set by regrtest.py. If not running under regrtest.py, + all resources are assumed enabled unless use_resources has been set. + """ + return use_resources is None or resource in use_resources + +def requires(resource, msg=None): + """Raise ResourceDenied if the specified resource is not available.""" + if not is_resource_enabled(resource): + if msg is None: + msg = "Use of the %r resource not enabled" % resource + raise ResourceDenied(msg) + if resource in {"network", "urlfetch"} and not has_socket_support: + raise ResourceDenied("No socket support") + if resource == 'gui' and not _is_gui_available(): + raise ResourceDenied(_is_gui_available.reason) + +def _get_kernel_version(sysname="Linux"): + import platform + if platform.system() != sysname: + return None + version_txt = platform.release().split('-', 1)[0] + try: + return tuple(map(int, version_txt.split('.'))) + except ValueError: + return None + +def _requires_unix_version(sysname, min_version): + """Decorator raising SkipTest if the OS is `sysname` and the version is less + than `min_version`. + + For example, @_requires_unix_version('FreeBSD', (7, 2)) raises SkipTest if + the FreeBSD version is less than 7.2. + """ + import platform + min_version_txt = '.'.join(map(str, min_version)) + version_txt = platform.release().split('-', 1)[0] + if platform.system() == sysname: + try: + version = tuple(map(int, version_txt.split('.'))) + except ValueError: + skip = False + else: + skip = version < min_version + else: + skip = False + + return unittest.skipIf( + skip, + f"{sysname} version {min_version_txt} or higher required, not " + f"{version_txt}" + ) + + +def requires_freebsd_version(*min_version): + """Decorator raising SkipTest if the OS is FreeBSD and the FreeBSD version is + less than `min_version`. + + For example, @requires_freebsd_version(7, 2) raises SkipTest if the FreeBSD + version is less than 7.2. + """ + return _requires_unix_version('FreeBSD', min_version) + +def requires_linux_version(*min_version): + """Decorator raising SkipTest if the OS is Linux and the Linux version is + less than `min_version`. + + For example, @requires_linux_version(2, 6, 32) raises SkipTest if the Linux + version is less than 2.6.32. + """ + return _requires_unix_version('Linux', min_version) + +def requires_mac_ver(*min_version): + """Decorator raising SkipTest if the OS is Mac OS X and the OS X + version if less than min_version. + + For example, @requires_mac_ver(10, 5) raises SkipTest if the OS X version + is lesser than 10.5. + """ + def decorator(func): + @functools.wraps(func) + def wrapper(*args, **kw): + if sys.platform == 'darwin': + import platform + version_txt = platform.mac_ver()[0] + try: + version = tuple(map(int, version_txt.split('.'))) + except ValueError: + pass + else: + if version < min_version: + min_version_txt = '.'.join(map(str, min_version)) + raise unittest.SkipTest( + "Mac OS X %s or higher required, not %s" + % (min_version_txt, version_txt)) + return func(*args, **kw) + wrapper.min_version = min_version + return wrapper + return decorator + + +def skip_if_buildbot(reason=None): + """Decorator raising SkipTest if running on a buildbot.""" + import getpass + if not reason: + reason = 'not suitable for buildbots' + try: + isbuildbot = getpass.getuser().lower() == 'buildbot' + except (KeyError, EnvironmentError) as err: + warnings.warn(f'getpass.getuser() failed {err}.', RuntimeWarning) + isbuildbot = False + return unittest.skipIf(isbuildbot, reason) + +def check_sanitizer(*, address=False, memory=False, ub=False): + """Returns True if Python is compiled with sanitizer support""" + if not (address or memory or ub): + raise ValueError('At least one of address, memory, or ub must be True') + + + cflags = sysconfig.get_config_var('CFLAGS') or '' + config_args = sysconfig.get_config_var('CONFIG_ARGS') or '' + memory_sanitizer = ( + '-fsanitize=memory' in cflags or + '--with-memory-sanitizer' in config_args + ) + address_sanitizer = ( + '-fsanitize=address' in cflags or + '--with-address-sanitizer' in config_args + ) + ub_sanitizer = ( + '-fsanitize=undefined' in cflags or + '--with-undefined-behavior-sanitizer' in config_args + ) + return ( + (memory and memory_sanitizer) or + (address and address_sanitizer) or + (ub and ub_sanitizer) + ) + + +def skip_if_sanitizer(reason=None, *, address=False, memory=False, ub=False): + """Decorator raising SkipTest if running with a sanitizer active.""" + if not reason: + reason = 'not working with sanitizers active' + skip = check_sanitizer(address=address, memory=memory, ub=ub) + return unittest.skipIf(skip, reason) + +# gh-89363: True if fork() can hang if Python is built with Address Sanitizer +# (ASAN): libasan race condition, dead lock in pthread_create(). +HAVE_ASAN_FORK_BUG = check_sanitizer(address=True) + + +def set_sanitizer_env_var(env, option): + for name in ('ASAN_OPTIONS', 'MSAN_OPTIONS', 'UBSAN_OPTIONS'): + if name in env: + env[name] += f':{option}' + else: + env[name] = option + + +def system_must_validate_cert(f): + """Skip the test on TLS certificate validation failures.""" + @functools.wraps(f) + def dec(*args, **kwargs): + try: + f(*args, **kwargs) + except OSError as e: + if "CERTIFICATE_VERIFY_FAILED" in str(e): + raise unittest.SkipTest("system does not contain " + "necessary certificates") + raise + return dec + +# A constant likely larger than the underlying OS pipe buffer size, to +# make writes blocking. +# Windows limit seems to be around 512 B, and many Unix kernels have a +# 64 KiB pipe buffer size or 16 * PAGE_SIZE: take a few megs to be sure. +# (see issue #17835 for a discussion of this number). +PIPE_MAX_SIZE = 4 * 1024 * 1024 + 1 + +# A constant likely larger than the underlying OS socket buffer size, to make +# writes blocking. +# The socket buffer sizes can usually be tuned system-wide (e.g. through sysctl +# on Linux), or on a per-socket basis (SO_SNDBUF/SO_RCVBUF). See issue #18643 +# for a discussion of this number. +SOCK_MAX_SIZE = 16 * 1024 * 1024 + 1 + +# decorator for skipping tests on non-IEEE 754 platforms +requires_IEEE_754 = unittest.skipUnless( + float.__getformat__("double").startswith("IEEE"), + "test requires IEEE 754 doubles") + +def requires_zlib(reason='requires zlib'): + try: + import zlib + except ImportError: + zlib = None + return unittest.skipUnless(zlib, reason) + +def requires_gzip(reason='requires gzip'): + try: + import gzip + except ImportError: + gzip = None + return unittest.skipUnless(gzip, reason) + +def requires_bz2(reason='requires bz2'): + try: + import bz2 + except ImportError: + bz2 = None + return unittest.skipUnless(bz2, reason) + +def requires_lzma(reason='requires lzma'): + try: + import lzma + except ImportError: + lzma = None + return unittest.skipUnless(lzma, reason) + +def has_no_debug_ranges(): + try: + import _testinternalcapi + except ImportError: + raise unittest.SkipTest("_testinternalcapi required") + config = _testinternalcapi.get_config() + return not bool(config['code_debug_ranges']) + +def requires_debug_ranges(reason='requires co_positions / debug_ranges'): + return unittest.skipIf(has_no_debug_ranges(), reason) + +requires_legacy_unicode_capi = unittest.skipUnless(unicode_legacy_string, + 'requires legacy Unicode C API') + +MS_WINDOWS = (sys.platform == 'win32') + +is_jython = sys.platform.startswith('java') + +is_android = hasattr(sys, 'getandroidapilevel') + +if sys.platform not in ('win32', 'vxworks'): + unix_shell = '/system/bin/sh' if is_android else '/bin/sh' +else: + unix_shell = None + +# wasm32-emscripten and -wasi are POSIX-like but do not +# have subprocess or fork support. +is_emscripten = sys.platform == "emscripten" +is_wasi = sys.platform == "wasi" + +has_fork_support = hasattr(os, "fork") and not is_emscripten and not is_wasi + +def requires_fork(): + return unittest.skipUnless(has_fork_support, "requires working os.fork()") + +has_subprocess_support = not is_emscripten and not is_wasi + +def requires_subprocess(): + """Used for subprocess, os.spawn calls, fd inheritance""" + return unittest.skipUnless(has_subprocess_support, "requires subprocess support") + +# Emscripten's socket emulation and WASI sockets have limitations. +has_socket_support = not is_emscripten and not is_wasi + +def requires_working_socket(*, module=False): + """Skip tests or modules that require working sockets + + Can be used as a function/class decorator or to skip an entire module. + """ + msg = "requires socket support" + if module: + if not has_socket_support: + raise unittest.SkipTest(msg) + else: + return unittest.skipUnless(has_socket_support, msg) + +# Does strftime() support glibc extension like '%4Y'? +has_strftime_extensions = False +if sys.platform != "win32": + # bpo-47037: Windows debug builds crash with "Debug Assertion Failed" + try: + has_strftime_extensions = time.strftime("%4Y") != "%4Y" + except ValueError: + pass + +# Define the URL of a dedicated HTTP server for the network tests. +# The URL must use clear-text HTTP: no redirection to encrypted HTTPS. +TEST_HTTP_URL = "http://www.pythontest.net" + +# Set by libregrtest/main.py so we can skip tests that are not +# useful for PGO +PGO = False + +# Set by libregrtest/main.py if we are running the extended (time consuming) +# PGO task. If this is True, PGO is also True. +PGO_EXTENDED = False + +# TEST_DATA_DIR is used as a target download location for remote resources +TEST_DATA_DIR = os.path.join(TEST_HOME_DIR, "data") + + +def darwin_malloc_err_warning(test_name): + """Assure user that loud errors generated by macOS libc's malloc are + expected.""" + if sys.platform != 'darwin': + return + + import shutil + msg = ' NOTICE ' + detail = (f'{test_name} may generate "malloc can\'t allocate region"\n' + 'warnings on macOS systems. This behavior is known. Do not\n' + 'report a bug unless tests are also failing. See bpo-40928.') + + padding, _ = shutil.get_terminal_size() + print(msg.center(padding, '-')) + print(detail) + print('-' * padding) + + +def findfile(filename, subdir=None): + """Try to find a file on sys.path or in the test directory. If it is not + found the argument passed to the function is returned (this does not + necessarily signal failure; could still be the legitimate path). + + Setting *subdir* indicates a relative path to use to find the file + rather than looking directly in the path directories. + """ + if os.path.isabs(filename): + return filename + if subdir is not None: + filename = os.path.join(subdir, filename) + path = [TEST_HOME_DIR] + sys.path + for dn in path: + fn = os.path.join(dn, filename) + if os.path.exists(fn): return fn + return filename + + +def sortdict(dict): + "Like repr(dict), but in sorted order." + items = sorted(dict.items()) + reprpairs = ["%r: %r" % pair for pair in items] + withcommas = ", ".join(reprpairs) + return "{%s}" % withcommas + +def check_syntax_error(testcase, statement, errtext='', *, lineno=None, offset=None): + with testcase.assertRaisesRegex(SyntaxError, errtext) as cm: + compile(statement, '', 'exec') + err = cm.exception + testcase.assertIsNotNone(err.lineno) + if lineno is not None: + testcase.assertEqual(err.lineno, lineno) + testcase.assertIsNotNone(err.offset) + if offset is not None: + testcase.assertEqual(err.offset, offset) + + +def open_urlresource(url, *args, **kw): + import urllib.request, urllib.parse + from .os_helper import unlink + try: + import gzip + except ImportError: + gzip = None + + check = kw.pop('check', None) + + filename = urllib.parse.urlparse(url)[2].split('/')[-1] # '/': it's URL! + + fn = os.path.join(TEST_DATA_DIR, filename) + + def check_valid_file(fn): + f = open(fn, *args, **kw) + if check is None: + return f + elif check(f): + f.seek(0) + return f + f.close() + + if os.path.exists(fn): + f = check_valid_file(fn) + if f is not None: + return f + unlink(fn) + + # Verify the requirement before downloading the file + requires('urlfetch') + + if verbose: + print('\tfetching %s ...' % url, file=get_original_stdout()) + opener = urllib.request.build_opener() + if gzip: + opener.addheaders.append(('Accept-Encoding', 'gzip')) + f = opener.open(url, timeout=INTERNET_TIMEOUT) + if gzip and f.headers.get('Content-Encoding') == 'gzip': + f = gzip.GzipFile(fileobj=f) + try: + with open(fn, "wb") as out: + s = f.read() + while s: + out.write(s) + s = f.read() + finally: + f.close() + + f = check_valid_file(fn) + if f is not None: + return f + raise TestFailed('invalid resource %r' % fn) + + +@contextlib.contextmanager +def captured_output(stream_name): + """Return a context manager used by captured_stdout/stdin/stderr + that temporarily replaces the sys stream *stream_name* with a StringIO.""" + import io + orig_stdout = getattr(sys, stream_name) + setattr(sys, stream_name, io.StringIO()) + try: + yield getattr(sys, stream_name) + finally: + setattr(sys, stream_name, orig_stdout) + +def captured_stdout(): + """Capture the output of sys.stdout: + + with captured_stdout() as stdout: + print("hello") + self.assertEqual(stdout.getvalue(), "hello\\n") + """ + return captured_output("stdout") + +def captured_stderr(): + """Capture the output of sys.stderr: + + with captured_stderr() as stderr: + print("hello", file=sys.stderr) + self.assertEqual(stderr.getvalue(), "hello\\n") + """ + return captured_output("stderr") + +def captured_stdin(): + """Capture the input to sys.stdin: + + with captured_stdin() as stdin: + stdin.write('hello\\n') + stdin.seek(0) + # call test code that consumes from sys.stdin + captured = input() + self.assertEqual(captured, "hello") + """ + return captured_output("stdin") + + +def gc_collect(): + """Force as many objects as possible to be collected. + + In non-CPython implementations of Python, this is needed because timely + deallocation is not guaranteed by the garbage collector. (Even in CPython + this can be the case in case of reference cycles.) This means that __del__ + methods may be called later than expected and weakrefs may remain alive for + longer than expected. This function tries its best to force all garbage + objects to disappear. + """ + import gc + gc.collect() + if is_jython: + time.sleep(0.1) + gc.collect() + gc.collect() + +@contextlib.contextmanager +def disable_gc(): + import gc + have_gc = gc.isenabled() + gc.disable() + try: + yield + finally: + if have_gc: + gc.enable() + + +def python_is_optimized(): + """Find if Python was built with optimizations.""" + cflags = sysconfig.get_config_var('PY_CFLAGS') or '' + final_opt = "" + for opt in cflags.split(): + if opt.startswith('-O'): + final_opt = opt + if sysconfig.get_config_var("CC") == "gcc": + non_opts = ('', '-O0', '-Og') + else: + non_opts = ('', '-O0') + return final_opt not in non_opts + + +def check_cflags_pgo(): + # Check if Python was built with ./configure --enable-optimizations: + # with Profile Guided Optimization (PGO). + cflags_nodist = sysconfig.get_config_var('PY_CFLAGS_NODIST') or '' + pgo_options = [ + # GCC + '-fprofile-use', + # clang: -fprofile-instr-use=code.profclangd + '-fprofile-instr-use', + # ICC + "-prof-use", + ] + PGO_PROF_USE_FLAG = sysconfig.get_config_var('PGO_PROF_USE_FLAG') + if PGO_PROF_USE_FLAG: + pgo_options.append(PGO_PROF_USE_FLAG) + return any(option in cflags_nodist for option in pgo_options) + + +_header = 'nP' +_align = '0n' +if hasattr(sys, "getobjects"): + _header = '2P' + _header + _align = '0P' +_vheader = _header + 'n' + +def calcobjsize(fmt): + import struct + return struct.calcsize(_header + fmt + _align) + +def calcvobjsize(fmt): + import struct + return struct.calcsize(_vheader + fmt + _align) + + +_TPFLAGS_HAVE_GC = 1<<14 +_TPFLAGS_HEAPTYPE = 1<<9 + +def check_sizeof(test, o, size): + try: + import _testinternalcapi + except ImportError: + raise unittest.SkipTest("_testinternalcapi required") + result = sys.getsizeof(o) + # add GC header size + if ((type(o) == type) and (o.__flags__ & _TPFLAGS_HEAPTYPE) or\ + ((type(o) != type) and (type(o).__flags__ & _TPFLAGS_HAVE_GC))): + size += _testinternalcapi.SIZEOF_PYGC_HEAD + msg = 'wrong size for %s: got %d, expected %d' \ + % (type(o), result, size) + test.assertEqual(result, size, msg) + +def subTests(arg_names, arg_values, /, *, _do_cleanups=False): + """Run multiple subtests with different parameters. + """ + single_param = False + if isinstance(arg_names, str): + arg_names = arg_names.replace(',',' ').split() + if len(arg_names) == 1: + single_param = True + arg_values = tuple(arg_values) + def decorator(func): + if isinstance(func, type): + raise TypeError('subTests() can only decorate methods, not classes') + @functools.wraps(func) + def wrapper(self, /, *args, **kwargs): + for values in arg_values: + if single_param: + values = (values,) + subtest_kwargs = dict(zip(arg_names, values)) + with self.subTest(**subtest_kwargs): + func(self, *args, **kwargs, **subtest_kwargs) + if _do_cleanups: + self.doCleanups() + return wrapper + return decorator + +#======================================================================= +# Decorator for running a function in a different locale, correctly resetting +# it afterwards. + +@contextlib.contextmanager +def run_with_locale(catstr, *locales): + try: + import locale + category = getattr(locale, catstr) + orig_locale = locale.setlocale(category) + except AttributeError: + # if the test author gives us an invalid category string + raise + except: + # cannot retrieve original locale, so do nothing + locale = orig_locale = None + else: + for loc in locales: + try: + locale.setlocale(category, loc) + break + except: + pass + + try: + yield + finally: + if locale and orig_locale: + locale.setlocale(category, orig_locale) + +#======================================================================= +# Decorator for running a function in a specific timezone, correctly +# resetting it afterwards. + +def run_with_tz(tz): + def decorator(func): + def inner(*args, **kwds): + try: + tzset = time.tzset + except AttributeError: + raise unittest.SkipTest("tzset required") + if 'TZ' in os.environ: + orig_tz = os.environ['TZ'] + else: + orig_tz = None + os.environ['TZ'] = tz + tzset() + + # now run the function, resetting the tz on exceptions + try: + return func(*args, **kwds) + finally: + if orig_tz is None: + del os.environ['TZ'] + else: + os.environ['TZ'] = orig_tz + time.tzset() + + inner.__name__ = func.__name__ + inner.__doc__ = func.__doc__ + return inner + return decorator + +#======================================================================= +# Big-memory-test support. Separate from 'resources' because memory use +# should be configurable. + +# Some handy shorthands. Note that these are used for byte-limits as well +# as size-limits, in the various bigmem tests +_1M = 1024*1024 +_1G = 1024 * _1M +_2G = 2 * _1G +_4G = 4 * _1G + +MAX_Py_ssize_t = sys.maxsize + +def _parse_memlimit(limit: str) -> int: + sizes = { + 'k': 1024, + 'm': _1M, + 'g': _1G, + 't': 1024*_1G, + } + m = re.match(r'(\d+(?:\.\d+)?) (K|M|G|T)b?$', limit, + re.IGNORECASE | re.VERBOSE) + if m is None: + raise ValueError(f'Invalid memory limit: {limit!r}') + return int(float(m.group(1)) * sizes[m.group(2).lower()]) + +def set_memlimit(limit: str) -> None: + global max_memuse + global real_max_memuse + memlimit = _parse_memlimit(limit) + if memlimit < _2G - 1: + raise ValueError('Memory limit {limit!r} too low to be useful') + + real_max_memuse = memlimit + memlimit = min(memlimit, MAX_Py_ssize_t) + max_memuse = memlimit + + +class _MemoryWatchdog: + """An object which periodically watches the process' memory consumption + and prints it out. + """ + + def __init__(self): + self.procfile = '/proc/{pid}/statm'.format(pid=os.getpid()) + self.started = False + + def start(self): + import warnings + try: + f = open(self.procfile, 'r') + except OSError as e: + warnings.warn('/proc not available for stats: {}'.format(e), + RuntimeWarning) + sys.stderr.flush() + return + + import subprocess + with f: + watchdog_script = findfile("memory_watchdog.py") + self.mem_watchdog = subprocess.Popen([sys.executable, watchdog_script], + stdin=f, + stderr=subprocess.DEVNULL) + self.started = True + + def stop(self): + if self.started: + self.mem_watchdog.terminate() + self.mem_watchdog.wait() + + +def bigmemtest(size, memuse, dry_run=True): + """Decorator for bigmem tests. + + 'size' is a requested size for the test (in arbitrary, test-interpreted + units.) 'memuse' is the number of bytes per unit for the test, or a good + estimate of it. For example, a test that needs two byte buffers, of 4 GiB + each, could be decorated with @bigmemtest(size=_4G, memuse=2). + + The 'size' argument is normally passed to the decorated test method as an + extra argument. If 'dry_run' is true, the value passed to the test method + may be less than the requested value. If 'dry_run' is false, it means the + test doesn't support dummy runs when -M is not specified. + """ + def decorator(f): + def wrapper(self): + size = wrapper.size + memuse = wrapper.memuse + if not real_max_memuse: + maxsize = 5147 + else: + maxsize = size + + if ((real_max_memuse or not dry_run) + and real_max_memuse < maxsize * memuse): + raise unittest.SkipTest( + "not enough memory: %.1fG minimum needed" + % (size * memuse / (1024 ** 3))) + + if real_max_memuse and verbose: + print() + print(" ... expected peak memory use: {peak:.1f}G" + .format(peak=size * memuse / (1024 ** 3))) + watchdog = _MemoryWatchdog() + watchdog.start() + else: + watchdog = None + + try: + return f(self, maxsize) + finally: + if watchdog: + watchdog.stop() + + wrapper.size = size + wrapper.memuse = memuse + return wrapper + return decorator + +def bigaddrspacetest(f): + """Decorator for tests that fill the address space.""" + def wrapper(self): + if max_memuse < MAX_Py_ssize_t: + if MAX_Py_ssize_t >= 2**63 - 1 and max_memuse >= 2**31: + raise unittest.SkipTest( + "not enough memory: try a 32-bit build instead") + else: + raise unittest.SkipTest( + "not enough memory: %.1fG minimum needed" + % (MAX_Py_ssize_t / (1024 ** 3))) + else: + return f(self) + return wrapper + +#======================================================================= +# unittest integration. + +def _id(obj): + return obj + +def requires_resource(resource): + if resource == 'gui' and not _is_gui_available(): + return unittest.skip(_is_gui_available.reason) + if is_resource_enabled(resource): + return _id + else: + return unittest.skip("resource {0!r} is not enabled".format(resource)) + +def cpython_only(test): + """ + Decorator for tests only applicable on CPython. + """ + return impl_detail(cpython=True)(test) + +def impl_detail(msg=None, **guards): + if check_impl_detail(**guards): + return _id + if msg is None: + guardnames, default = _parse_guards(guards) + if default: + msg = "implementation detail not available on {0}" + else: + msg = "implementation detail specific to {0}" + guardnames = sorted(guardnames.keys()) + msg = msg.format(' or '.join(guardnames)) + return unittest.skip(msg) + +def _parse_guards(guards): + # Returns a tuple ({platform_name: run_me}, default_value) + if not guards: + return ({'cpython': True}, False) + is_true = list(guards.values())[0] + assert list(guards.values()) == [is_true] * len(guards) # all True or all False + return (guards, not is_true) + +# Use the following check to guard CPython's implementation-specific tests -- +# or to run them only on the implementation(s) guarded by the arguments. +def check_impl_detail(**guards): + """This function returns True or False depending on the host platform. + Examples: + if check_impl_detail(): # only on CPython (default) + if check_impl_detail(jython=True): # only on Jython + if check_impl_detail(cpython=False): # everywhere except on CPython + """ + guards, default = _parse_guards(guards) + return guards.get(sys.implementation.name, default) + + +def no_tracing(func): + """Decorator to temporarily turn off tracing for the duration of a test.""" + if not hasattr(sys, 'gettrace'): + return func + else: + @functools.wraps(func) + def wrapper(*args, **kwargs): + original_trace = sys.gettrace() + try: + sys.settrace(None) + return func(*args, **kwargs) + finally: + sys.settrace(original_trace) + return wrapper + + +def refcount_test(test): + """Decorator for tests which involve reference counting. + + To start, the decorator does not run the test if is not run by CPython. + After that, any trace function is unset during the test to prevent + unexpected refcounts caused by the trace function. + + """ + return no_tracing(cpython_only(test)) + + +#======================================================================= +# Check for the presence of docstrings. + +# Rather than trying to enumerate all the cases where docstrings may be +# disabled, we just check for that directly + +def _check_docstrings(): + """Just used to check if docstrings are enabled""" + +MISSING_C_DOCSTRINGS = (check_impl_detail() and + sys.platform != 'win32' and + not sysconfig.get_config_var('WITH_DOC_STRINGS')) + +HAVE_DOCSTRINGS = (_check_docstrings.__doc__ is not None and + not MISSING_C_DOCSTRINGS) + +requires_docstrings = unittest.skipUnless(HAVE_DOCSTRINGS, + "test requires docstrings") + + +#======================================================================= +# Support for saving and restoring the imported modules. + +def flush_std_streams(): + if sys.stdout is not None: + sys.stdout.flush() + if sys.stderr is not None: + sys.stderr.flush() + + +def print_warning(msg): + # bpo-45410: Explicitly flush stdout to keep logs in order + flush_std_streams() + stream = print_warning.orig_stderr + for line in msg.splitlines(): + print(f"Warning -- {line}", file=stream) + stream.flush() + +# bpo-39983: Store the original sys.stderr at Python startup to be able to +# log warnings even if sys.stderr is captured temporarily by a test. +print_warning.orig_stderr = sys.stderr + + +# Flag used by saved_test_environment of test.libregrtest.save_env, +# to check if a test modified the environment. The flag should be set to False +# before running a new test. +# +# For example, threading_helper.threading_cleanup() sets the flag is the function fails +# to cleanup threads. +environment_altered = False + +def reap_children(): + """Use this function at the end of test_main() whenever sub-processes + are started. This will help ensure that no extra children (zombies) + stick around to hog resources and create problems when looking + for refleaks. + """ + global environment_altered + + # Need os.waitpid(-1, os.WNOHANG): Windows is not supported + if not (hasattr(os, 'waitpid') and hasattr(os, 'WNOHANG')): + return + elif not has_subprocess_support: + return + + # Reap all our dead child processes so we don't leave zombies around. + # These hog resources and might be causing some of the buildbots to die. + while True: + try: + # Read the exit status of any child process which already completed + pid, status = os.waitpid(-1, os.WNOHANG) + except OSError: + break + + if pid == 0: + break + + print_warning(f"reap_children() reaped child process {pid}") + environment_altered = True + + +@contextlib.contextmanager +def swap_attr(obj, attr, new_val): + """Temporary swap out an attribute with a new object. + + Usage: + with swap_attr(obj, "attr", 5): + ... + + This will set obj.attr to 5 for the duration of the with: block, + restoring the old value at the end of the block. If `attr` doesn't + exist on `obj`, it will be created and then deleted at the end of the + block. + + The old value (or None if it doesn't exist) will be assigned to the + target of the "as" clause, if there is one. + """ + if hasattr(obj, attr): + real_val = getattr(obj, attr) + setattr(obj, attr, new_val) + try: + yield real_val + finally: + setattr(obj, attr, real_val) + else: + setattr(obj, attr, new_val) + try: + yield + finally: + if hasattr(obj, attr): + delattr(obj, attr) + +@contextlib.contextmanager +def swap_item(obj, item, new_val): + """Temporary swap out an item with a new object. + + Usage: + with swap_item(obj, "item", 5): + ... + + This will set obj["item"] to 5 for the duration of the with: block, + restoring the old value at the end of the block. If `item` doesn't + exist on `obj`, it will be created and then deleted at the end of the + block. + + The old value (or None if it doesn't exist) will be assigned to the + target of the "as" clause, if there is one. + """ + if item in obj: + real_val = obj[item] + obj[item] = new_val + try: + yield real_val + finally: + obj[item] = real_val + else: + obj[item] = new_val + try: + yield + finally: + if item in obj: + del obj[item] + +def args_from_interpreter_flags(): + """Return a list of command-line arguments reproducing the current + settings in sys.flags and sys.warnoptions.""" + import subprocess + return subprocess._args_from_interpreter_flags() + +def optim_args_from_interpreter_flags(): + """Return a list of command-line arguments reproducing the current + optimization settings in sys.flags.""" + import subprocess + return subprocess._optim_args_from_interpreter_flags() + + +class Matcher(object): + + _partial_matches = ('msg', 'message') + + def matches(self, d, **kwargs): + """ + Try to match a single dict with the supplied arguments. + + Keys whose values are strings and which are in self._partial_matches + will be checked for partial (i.e. substring) matches. You can extend + this scheme to (for example) do regular expression matching, etc. + """ + result = True + for k in kwargs: + v = kwargs[k] + dv = d.get(k) + if not self.match_value(k, dv, v): + result = False + break + return result + + def match_value(self, k, dv, v): + """ + Try to match a single stored value (dv) with a supplied value (v). + """ + if type(v) != type(dv): + result = False + elif type(dv) is not str or k not in self._partial_matches: + result = (v == dv) + else: + result = dv.find(v) >= 0 + return result + + +_buggy_ucrt = None +def skip_if_buggy_ucrt_strfptime(test): + """ + Skip decorator for tests that use buggy strptime/strftime + + If the UCRT bugs are present time.localtime().tm_zone will be + an empty string, otherwise we assume the UCRT bugs are fixed + + See bpo-37552 [Windows] strptime/strftime return invalid + results with UCRT version 17763.615 + """ + import locale + global _buggy_ucrt + if _buggy_ucrt is None: + if(sys.platform == 'win32' and + locale.getencoding() == 'cp65001' and + time.localtime().tm_zone == ''): + _buggy_ucrt = True + else: + _buggy_ucrt = False + return unittest.skip("buggy MSVC UCRT strptime/strftime")(test) if _buggy_ucrt else test + +class PythonSymlink: + """Creates a symlink for the current Python executable""" + def __init__(self, link=None): + from .os_helper import TESTFN + + self.link = link or os.path.abspath(TESTFN) + self._linked = [] + self.real = os.path.realpath(sys.executable) + self._also_link = [] + + self._env = None + + self._platform_specific() + + if sys.platform == "win32": + def _platform_specific(self): + import glob + import _winapi + + if os.path.lexists(self.real) and not os.path.exists(self.real): + # App symlink appears to not exist, but we want the + # real executable here anyway + self.real = _winapi.GetModuleFileName(0) + + dll = _winapi.GetModuleFileName(sys.dllhandle) + src_dir = os.path.dirname(dll) + dest_dir = os.path.dirname(self.link) + self._also_link.append(( + dll, + os.path.join(dest_dir, os.path.basename(dll)) + )) + for runtime in glob.glob(os.path.join(glob.escape(src_dir), "vcruntime*.dll")): + self._also_link.append(( + runtime, + os.path.join(dest_dir, os.path.basename(runtime)) + )) + + self._env = {k.upper(): os.getenv(k) for k in os.environ} + self._env["PYTHONHOME"] = os.path.dirname(self.real) + if sysconfig.is_python_build(): + self._env["PYTHONPATH"] = STDLIB_DIR + else: + def _platform_specific(self): + pass + + def __enter__(self): + os.symlink(self.real, self.link) + self._linked.append(self.link) + for real, link in self._also_link: + os.symlink(real, link) + self._linked.append(link) + return self + + def __exit__(self, exc_type, exc_value, exc_tb): + for link in self._linked: + try: + os.remove(link) + except IOError as ex: + if verbose: + print("failed to clean up {}: {}".format(link, ex)) + + def _call(self, python, args, env, returncode): + import subprocess + cmd = [python, *args] + p = subprocess.Popen(cmd, stdout=subprocess.PIPE, + stderr=subprocess.PIPE, env=env) + r = p.communicate() + if p.returncode != returncode: + if verbose: + print(repr(r[0])) + print(repr(r[1]), file=sys.stderr) + raise RuntimeError( + 'unexpected return code: {0} (0x{0:08X})'.format(p.returncode)) + return r + + def call_real(self, *args, returncode=0): + return self._call(self.real, args, None, returncode) + + def call_link(self, *args, returncode=0): + return self._call(self.link, args, self._env, returncode) + + +def skip_if_pgo_task(test): + """Skip decorator for tests not run in (non-extended) PGO task""" + ok = not PGO or PGO_EXTENDED + msg = "Not run for (non-extended) PGO task" + return test if ok else unittest.skip(msg)(test) + + +def detect_api_mismatch(ref_api, other_api, *, ignore=()): + """Returns the set of items in ref_api not in other_api, except for a + defined list of items to be ignored in this check. + + By default this skips private attributes beginning with '_' but + includes all magic methods, i.e. those starting and ending in '__'. + """ + missing_items = set(dir(ref_api)) - set(dir(other_api)) + if ignore: + missing_items -= set(ignore) + missing_items = set(m for m in missing_items + if not m.startswith('_') or m.endswith('__')) + return missing_items + + +def check__all__(test_case, module, name_of_module=None, extra=(), + not_exported=()): + """Assert that the __all__ variable of 'module' contains all public names. + + The module's public names (its API) are detected automatically based on + whether they match the public name convention and were defined in + 'module'. + + The 'name_of_module' argument can specify (as a string or tuple thereof) + what module(s) an API could be defined in in order to be detected as a + public API. One case for this is when 'module' imports part of its public + API from other modules, possibly a C backend (like 'csv' and its '_csv'). + + The 'extra' argument can be a set of names that wouldn't otherwise be + automatically detected as "public", like objects without a proper + '__module__' attribute. If provided, it will be added to the + automatically detected ones. + + The 'not_exported' argument can be a set of names that must not be treated + as part of the public API even though their names indicate otherwise. + + Usage: + import bar + import foo + import unittest + from test import support + + class MiscTestCase(unittest.TestCase): + def test__all__(self): + support.check__all__(self, foo) + + class OtherTestCase(unittest.TestCase): + def test__all__(self): + extra = {'BAR_CONST', 'FOO_CONST'} + not_exported = {'baz'} # Undocumented name. + # bar imports part of its API from _bar. + support.check__all__(self, bar, ('bar', '_bar'), + extra=extra, not_exported=not_exported) + + """ + + if name_of_module is None: + name_of_module = (module.__name__, ) + elif isinstance(name_of_module, str): + name_of_module = (name_of_module, ) + + expected = set(extra) + + for name in dir(module): + if name.startswith('_') or name in not_exported: + continue + obj = getattr(module, name) + if (getattr(obj, '__module__', None) in name_of_module or + (not hasattr(obj, '__module__') and + not isinstance(obj, types.ModuleType))): + expected.add(name) + test_case.assertCountEqual(module.__all__, expected) + + +def suppress_msvcrt_asserts(verbose=False): + try: + import msvcrt + except ImportError: + return + + msvcrt.SetErrorMode(msvcrt.SEM_FAILCRITICALERRORS + | msvcrt.SEM_NOALIGNMENTFAULTEXCEPT + | msvcrt.SEM_NOGPFAULTERRORBOX + | msvcrt.SEM_NOOPENFILEERRORBOX) + + # CrtSetReportMode() is only available in debug build + if hasattr(msvcrt, 'CrtSetReportMode'): + for m in [msvcrt.CRT_WARN, msvcrt.CRT_ERROR, msvcrt.CRT_ASSERT]: + if verbose: + msvcrt.CrtSetReportMode(m, msvcrt.CRTDBG_MODE_FILE) + msvcrt.CrtSetReportFile(m, msvcrt.CRTDBG_FILE_STDERR) + else: + msvcrt.CrtSetReportMode(m, 0) + + +class SuppressCrashReport: + """Try to prevent a crash report from popping up. + + On Windows, don't display the Windows Error Reporting dialog. On UNIX, + disable the creation of coredump file. + """ + old_value = None + old_modes = None + + def __enter__(self): + """On Windows, disable Windows Error Reporting dialogs using + SetErrorMode() and CrtSetReportMode(). + + On UNIX, try to save the previous core file size limit, then set + soft limit to 0. + """ + if sys.platform.startswith('win'): + # see http://msdn.microsoft.com/en-us/library/windows/desktop/ms680621.aspx + try: + import msvcrt + except ImportError: + return + + self.old_value = msvcrt.GetErrorMode() + + msvcrt.SetErrorMode(self.old_value | msvcrt.SEM_NOGPFAULTERRORBOX) + + # bpo-23314: Suppress assert dialogs in debug builds. + # CrtSetReportMode() is only available in debug build. + if hasattr(msvcrt, 'CrtSetReportMode'): + self.old_modes = {} + for report_type in [msvcrt.CRT_WARN, + msvcrt.CRT_ERROR, + msvcrt.CRT_ASSERT]: + old_mode = msvcrt.CrtSetReportMode(report_type, + msvcrt.CRTDBG_MODE_FILE) + old_file = msvcrt.CrtSetReportFile(report_type, + msvcrt.CRTDBG_FILE_STDERR) + self.old_modes[report_type] = old_mode, old_file + + else: + try: + import resource + self.resource = resource + except ImportError: + self.resource = None + if self.resource is not None: + try: + self.old_value = self.resource.getrlimit(self.resource.RLIMIT_CORE) + self.resource.setrlimit(self.resource.RLIMIT_CORE, + (0, self.old_value[1])) + except (ValueError, OSError): + pass + + if sys.platform == 'darwin': + import subprocess + # Check if the 'Crash Reporter' on OSX was configured + # in 'Developer' mode and warn that it will get triggered + # when it is. + # + # This assumes that this context manager is used in tests + # that might trigger the next manager. + cmd = ['/usr/bin/defaults', 'read', + 'com.apple.CrashReporter', 'DialogType'] + proc = subprocess.Popen(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE) + with proc: + stdout = proc.communicate()[0] + if stdout.strip() == b'developer': + print("this test triggers the Crash Reporter, " + "that is intentional", end='', flush=True) + + return self + + def __exit__(self, *ignore_exc): + """Restore Windows ErrorMode or core file behavior to initial value.""" + if self.old_value is None: + return + + if sys.platform.startswith('win'): + import msvcrt + msvcrt.SetErrorMode(self.old_value) + + if self.old_modes: + for report_type, (old_mode, old_file) in self.old_modes.items(): + msvcrt.CrtSetReportMode(report_type, old_mode) + msvcrt.CrtSetReportFile(report_type, old_file) + else: + if self.resource is not None: + try: + self.resource.setrlimit(self.resource.RLIMIT_CORE, self.old_value) + except (ValueError, OSError): + pass + + +def patch(test_instance, object_to_patch, attr_name, new_value): + """Override 'object_to_patch'.'attr_name' with 'new_value'. + + Also, add a cleanup procedure to 'test_instance' to restore + 'object_to_patch' value for 'attr_name'. + The 'attr_name' should be a valid attribute for 'object_to_patch'. + + """ + # check that 'attr_name' is a real attribute for 'object_to_patch' + # will raise AttributeError if it does not exist + getattr(object_to_patch, attr_name) + + # keep a copy of the old value + attr_is_local = False + try: + old_value = object_to_patch.__dict__[attr_name] + except (AttributeError, KeyError): + old_value = getattr(object_to_patch, attr_name, None) + else: + attr_is_local = True + + # restore the value when the test is done + def cleanup(): + if attr_is_local: + setattr(object_to_patch, attr_name, old_value) + else: + delattr(object_to_patch, attr_name) + + test_instance.addCleanup(cleanup) + + # actually override the attribute + setattr(object_to_patch, attr_name, new_value) + + +@contextlib.contextmanager +def patch_list(orig): + """Like unittest.mock.patch.dict, but for lists.""" + try: + saved = orig[:] + yield + finally: + orig[:] = saved + + +def run_in_subinterp(code): + """ + Run code in a subinterpreter. Raise unittest.SkipTest if the tracemalloc + module is enabled. + """ + # Issue #10915, #15751: PyGILState_*() functions don't work with + # sub-interpreters, the tracemalloc module uses these functions internally + try: + import tracemalloc + except ImportError: + pass + else: + if tracemalloc.is_tracing(): + raise unittest.SkipTest("run_in_subinterp() cannot be used " + "if tracemalloc module is tracing " + "memory allocations") + import _testcapi + return _testcapi.run_in_subinterp(code) + + +def check_free_after_iterating(test, iter, cls, args=()): + class A(cls): + def __del__(self): + nonlocal done + done = True + try: + next(it) + except StopIteration: + pass + + done = False + it = iter(A(*args)) + # Issue 26494: Shouldn't crash + test.assertRaises(StopIteration, next, it) + # The sequence should be deallocated just after the end of iterating + gc_collect() + test.assertTrue(done) + + +def missing_compiler_executable(cmd_names=[]): + """Check if the compiler components used to build the interpreter exist. + + Check for the existence of the compiler executables whose names are listed + in 'cmd_names' or all the compiler executables when 'cmd_names' is empty + and return the first missing executable or None when none is found + missing. + + """ + # TODO (PEP 632): alternate check without using distutils + from distutils import ccompiler, sysconfig, spawn, errors + compiler = ccompiler.new_compiler() + sysconfig.customize_compiler(compiler) + if compiler.compiler_type == "msvc": + # MSVC has no executables, so check whether initialization succeeds + try: + compiler.initialize() + except errors.DistutilsPlatformError: + return "msvc" + for name in compiler.executables: + if cmd_names and name not in cmd_names: + continue + cmd = getattr(compiler, name) + if cmd_names: + assert cmd is not None, \ + "the '%s' executable is not configured" % name + elif not cmd: + continue + if spawn.find_executable(cmd[0]) is None: + return cmd[0] + + +_is_android_emulator = None +def setswitchinterval(interval): + # Setting a very low gil interval on the Android emulator causes python + # to hang (issue #26939). + minimum_interval = 1e-5 + if is_android and interval < minimum_interval: + global _is_android_emulator + if _is_android_emulator is None: + import subprocess + _is_android_emulator = (subprocess.check_output( + ['getprop', 'ro.kernel.qemu']).strip() == b'1') + if _is_android_emulator: + interval = minimum_interval + return sys.setswitchinterval(interval) + + +@contextlib.contextmanager +def disable_faulthandler(): + import faulthandler + + # use sys.__stderr__ instead of sys.stderr, since regrtest replaces + # sys.stderr with a StringIO which has no file descriptor when a test + # is run with -W/--verbose3. + fd = sys.__stderr__.fileno() + + is_enabled = faulthandler.is_enabled() + try: + faulthandler.disable() + yield + finally: + if is_enabled: + faulthandler.enable(file=fd, all_threads=True) + + +class SaveSignals: + """ + Save and restore signal handlers. + + This class is only able to save/restore signal handlers registered + by the Python signal module: see bpo-13285 for "external" signal + handlers. + """ + + def __init__(self): + import signal + self.signal = signal + self.signals = signal.valid_signals() + # SIGKILL and SIGSTOP signals cannot be ignored nor caught + for signame in ('SIGKILL', 'SIGSTOP'): + try: + signum = getattr(signal, signame) + except AttributeError: + continue + self.signals.remove(signum) + self.handlers = {} + + def save(self): + for signum in self.signals: + handler = self.signal.getsignal(signum) + if handler is None: + # getsignal() returns None if a signal handler was not + # registered by the Python signal module, + # and the handler is not SIG_DFL nor SIG_IGN. + # + # Ignore the signal: we cannot restore the handler. + continue + self.handlers[signum] = handler + + def restore(self): + for signum, handler in self.handlers.items(): + self.signal.signal(signum, handler) + + +def with_pymalloc(): + import _testcapi + return _testcapi.WITH_PYMALLOC + + +class _ALWAYS_EQ: + """ + Object that is equal to anything. + """ + def __eq__(self, other): + return True + def __ne__(self, other): + return False + +ALWAYS_EQ = _ALWAYS_EQ() + +class _NEVER_EQ: + """ + Object that is not equal to anything. + """ + def __eq__(self, other): + return False + def __ne__(self, other): + return True + def __hash__(self): + return 1 + +NEVER_EQ = _NEVER_EQ() + +@functools.total_ordering +class _LARGEST: + """ + Object that is greater than anything (except itself). + """ + def __eq__(self, other): + return isinstance(other, _LARGEST) + def __lt__(self, other): + return False + +LARGEST = _LARGEST() + +@functools.total_ordering +class _SMALLEST: + """ + Object that is less than anything (except itself). + """ + def __eq__(self, other): + return isinstance(other, _SMALLEST) + def __gt__(self, other): + return False + +SMALLEST = _SMALLEST() + +def maybe_get_event_loop_policy(): + """Return the global event loop policy if one is set, else return None.""" + import asyncio.events + return asyncio.events._event_loop_policy + +# Helpers for testing hashing. +NHASHBITS = sys.hash_info.width # number of bits in hash() result +assert NHASHBITS in (32, 64) + +# Return mean and sdev of number of collisions when tossing nballs balls +# uniformly at random into nbins bins. By definition, the number of +# collisions is the number of balls minus the number of occupied bins at +# the end. +def collision_stats(nbins, nballs): + n, k = nbins, nballs + # prob a bin empty after k trials = (1 - 1/n)**k + # mean # empty is then n * (1 - 1/n)**k + # so mean # occupied is n - n * (1 - 1/n)**k + # so collisions = k - (n - n*(1 - 1/n)**k) + # + # For the variance: + # n*(n-1)*(1-2/n)**k + meanempty - meanempty**2 = + # n*(n-1)*(1-2/n)**k + meanempty * (1 - meanempty) + # + # Massive cancellation occurs, and, e.g., for a 64-bit hash code + # 1-1/2**64 rounds uselessly to 1.0. Rather than make heroic (and + # error-prone) efforts to rework the naive formulas to avoid those, + # we use the `decimal` module to get plenty of extra precision. + # + # Note: the exact values are straightforward to compute with + # rationals, but in context that's unbearably slow, requiring + # multi-million bit arithmetic. + import decimal + with decimal.localcontext() as ctx: + bits = n.bit_length() * 2 # bits in n**2 + # At least that many bits will likely cancel out. + # Use that many decimal digits instead. + ctx.prec = max(bits, 30) + dn = decimal.Decimal(n) + p1empty = ((dn - 1) / dn) ** k + meanempty = n * p1empty + occupied = n - meanempty + collisions = k - occupied + var = dn*(dn-1)*((dn-2)/dn)**k + meanempty * (1 - meanempty) + return float(collisions), float(var.sqrt()) + + +class catch_unraisable_exception: + """ + Context manager catching unraisable exception using sys.unraisablehook. + + Storing the exception value (cm.unraisable.exc_value) creates a reference + cycle. The reference cycle is broken explicitly when the context manager + exits. + + Storing the object (cm.unraisable.object) can resurrect it if it is set to + an object which is being finalized. Exiting the context manager clears the + stored object. + + Usage: + + with support.catch_unraisable_exception() as cm: + # code creating an "unraisable exception" + ... + + # check the unraisable exception: use cm.unraisable + ... + + # cm.unraisable attribute no longer exists at this point + # (to break a reference cycle) + """ + + def __init__(self): + self.unraisable = None + self._old_hook = None + + def _hook(self, unraisable): + # Storing unraisable.object can resurrect an object which is being + # finalized. Storing unraisable.exc_value creates a reference cycle. + self.unraisable = unraisable + + def __enter__(self): + self._old_hook = sys.unraisablehook + sys.unraisablehook = self._hook + return self + + def __exit__(self, *exc_info): + sys.unraisablehook = self._old_hook + del self.unraisable + + +def wait_process(pid, *, exitcode, timeout=None): + """ + Wait until process pid completes and check that the process exit code is + exitcode. + + Raise an AssertionError if the process exit code is not equal to exitcode. + + If the process runs longer than timeout seconds (LONG_TIMEOUT by default), + kill the process (if signal.SIGKILL is available) and raise an + AssertionError. The timeout feature is not available on Windows. + """ + if os.name != "nt": + import signal + + if timeout is None: + timeout = LONG_TIMEOUT + + start_time = time.monotonic() + for _ in sleeping_retry(timeout, error=False): + pid2, status = os.waitpid(pid, os.WNOHANG) + if pid2 != 0: + break + # rety: the process is still running + else: + try: + os.kill(pid, signal.SIGKILL) + os.waitpid(pid, 0) + except OSError: + # Ignore errors like ChildProcessError or PermissionError + pass + + dt = time.monotonic() - start_time + raise AssertionError(f"process {pid} is still running " + f"after {dt:.1f} seconds") + else: + # Windows implementation: don't support timeout :-( + pid2, status = os.waitpid(pid, 0) + + exitcode2 = os.waitstatus_to_exitcode(status) + if exitcode2 != exitcode: + raise AssertionError(f"process {pid} exited with code {exitcode2}, " + f"but exit code {exitcode} is expected") + + # sanity check: it should not fail in practice + if pid2 != pid: + raise AssertionError(f"pid {pid2} != pid {pid}") + +def skip_if_broken_multiprocessing_synchronize(): + """ + Skip tests if the multiprocessing.synchronize module is missing, if there + is no available semaphore implementation, or if creating a lock raises an + OSError (on Linux only). + """ + from .import_helper import import_module + + # Skip tests if the _multiprocessing extension is missing. + import_module('_multiprocessing') + + # Skip tests if there is no available semaphore implementation: + # multiprocessing.synchronize requires _multiprocessing.SemLock. + synchronize = import_module('multiprocessing.synchronize') + + if sys.platform == "linux": + try: + # bpo-38377: On Linux, creating a semaphore fails with OSError + # if the current user does not have the permission to create + # a file in /dev/shm/ directory. + synchronize.Lock(ctx=None) + except OSError as exc: + raise unittest.SkipTest(f"broken multiprocessing SemLock: {exc!r}") + + +def check_disallow_instantiation(testcase, tp, *args, **kwds): + """ + Check that given type cannot be instantiated using *args and **kwds. + + See bpo-43916: Add Py_TPFLAGS_DISALLOW_INSTANTIATION type flag. + """ + mod = tp.__module__ + name = tp.__name__ + if mod != 'builtins': + qualname = f"{mod}.{name}" + else: + qualname = f"{name}" + msg = f"cannot create '{re.escape(qualname)}' instances" + testcase.assertRaisesRegex(TypeError, msg, tp, *args, **kwds) + +def get_recursion_depth(): + """Get the recursion depth of the caller function. + + In the __main__ module, at the module level, it should be 1. + """ + try: + import _testinternalcapi + depth = _testinternalcapi.get_recursion_depth() + except (ImportError, RecursionError) as exc: + # sys._getframe() + frame.f_back implementation. + try: + depth = 0 + frame = sys._getframe() + while frame is not None: + depth += 1 + frame = frame.f_back + finally: + # Break any reference cycles. + frame = None + + # Ignore get_recursion_depth() frame. + return max(depth - 1, 1) + +def get_recursion_available(): + """Get the number of available frames before RecursionError. + + It depends on the current recursion depth of the caller function and + sys.getrecursionlimit(). + """ + limit = sys.getrecursionlimit() + depth = get_recursion_depth() + + try: + from _testcapi import USE_STACKCHECK + except ImportError: + USE_STACKCHECK = False + + if USE_STACKCHECK: + return max(limit - depth - 1, 0) + else: + return limit - depth + +@contextlib.contextmanager +def set_recursion_limit(limit): + """Temporarily change the recursion limit.""" + original_limit = sys.getrecursionlimit() + try: + sys.setrecursionlimit(limit) + yield + finally: + sys.setrecursionlimit(original_limit) + +def infinite_recursion(max_depth=100): + """Set a lower limit for tests that interact with infinite recursions + (e.g test_ast.ASTHelpers_Test.test_recursion_direct) since on some + debug windows builds, due to not enough functions being inlined the + stack size might not handle the default recursion limit (1000). See + bpo-11105 for details.""" + if max_depth < 4: + raise ValueError("max_depth must be at least 4, got {max_depth}") + depth = get_recursion_depth() + depth = max(depth - 1, 1) # Ignore infinite_recursion() frame. + limit = depth + max_depth + return set_recursion_limit(limit) + +def ignore_deprecations_from(module: str, *, like: str) -> object: + token = object() + warnings.filterwarnings( + "ignore", + category=DeprecationWarning, + module=module, + message=like + fr"(?#support{id(token)})", + ) + return token + +def clear_ignored_deprecations(*tokens: object) -> None: + if not tokens: + raise ValueError("Provide token or tokens returned by ignore_deprecations_from") + + new_filters = [] + endswith = tuple(rf"(?#support{id(token)})" for token in tokens) + for action, message, category, module, lineno in warnings.filters: + if action == "ignore" and category is DeprecationWarning: + if isinstance(message, re.Pattern): + msg = message.pattern + else: + msg = message or "" + if msg.endswith(endswith): + continue + new_filters.append((action, message, category, module, lineno)) + if warnings.filters != new_filters: + warnings.filters[:] = new_filters + warnings._filters_mutated() + + +# Skip a test if venv with pip is known to not work. +def requires_venv_with_pip(): + # ensurepip requires zlib to open ZIP archives (.whl binary wheel packages) + try: + import zlib + except ImportError: + return unittest.skipIf(True, "venv: ensurepip requires zlib") + + # bpo-26610: pip/pep425tags.py requires ctypes. + # gh-92820: setuptools/windows_support.py uses ctypes (setuptools 58.1). + try: + import ctypes + except ImportError: + ctypes = None + return unittest.skipUnless(ctypes, 'venv: pip requires ctypes') + + +# True if Python is built with the Py_DEBUG macro defined: if +# Python is built in debug mode (./configure --with-pydebug). +Py_DEBUG = hasattr(sys, 'gettotalrefcount') + + +def busy_retry(timeout, err_msg=None, /, *, error=True): + """ + Run the loop body until "break" stops the loop. + + After *timeout* seconds, raise an AssertionError if *error* is true, + or just stop if *error is false. + + Example: + + for _ in support.busy_retry(support.SHORT_TIMEOUT): + if check(): + break + + Example of error=False usage: + + for _ in support.busy_retry(support.SHORT_TIMEOUT, error=False): + if check(): + break + else: + raise RuntimeError('my custom error') + + """ + if timeout <= 0: + raise ValueError("timeout must be greater than zero") + + start_time = time.monotonic() + deadline = start_time + timeout + + while True: + yield + + if time.monotonic() >= deadline: + break + + if error: + dt = time.monotonic() - start_time + msg = f"timeout ({dt:.1f} seconds)" + if err_msg: + msg = f"{msg}: {err_msg}" + raise AssertionError(msg) + + +def sleeping_retry(timeout, err_msg=None, /, + *, init_delay=0.010, max_delay=1.0, error=True): + """ + Wait strategy that applies exponential backoff. + + Run the loop body until "break" stops the loop. Sleep at each loop + iteration, but not at the first iteration. The sleep delay is doubled at + each iteration (up to *max_delay* seconds). + + See busy_retry() documentation for the parameters usage. + + Example raising an exception after SHORT_TIMEOUT seconds: + + for _ in support.sleeping_retry(support.SHORT_TIMEOUT): + if check(): + break + + Example of error=False usage: + + for _ in support.sleeping_retry(support.SHORT_TIMEOUT, error=False): + if check(): + break + else: + raise RuntimeError('my custom error') + """ + + delay = init_delay + for _ in busy_retry(timeout, err_msg, error=error): + yield + + time.sleep(delay) + delay = min(delay * 2, max_delay) + + +@contextlib.contextmanager +def adjust_int_max_str_digits(max_digits): + """Temporarily change the integer string conversion length limit.""" + current = sys.get_int_max_str_digits() + try: + sys.set_int_max_str_digits(max_digits) + yield + finally: + sys.set_int_max_str_digits(current) + +_BASE_COPY_SRC_DIR_IGNORED_NAMES = frozenset({ + # SRC_DIR/.git + '.git', + # ignore all __pycache__/ sub-directories + '__pycache__', +}) + +# Ignore function for shutil.copytree() to copy the Python source code. +def copy_python_src_ignore(path, names): + ignored = _BASE_COPY_SRC_DIR_IGNORED_NAMES + if os.path.basename(path) == 'Doc': + ignored |= { + # SRC_DIR/Doc/build/ + 'build', + # SRC_DIR/Doc/venv/ + 'venv', + } + + # check if we are at the root of the source code + elif 'Modules' in names: + ignored |= { + # SRC_DIR/build/ + 'build', + } + return ignored + +#Windows doesn't have os.uname() but it doesn't support s390x. +skip_on_s390x = unittest.skipIf(hasattr(os, 'uname') and os.uname().machine == 's390x', + 'skipped on s390x') + + +def control_characters_c0() -> list[str]: + """Returns a list of C0 control characters as strings. + C0 control characters defined as the byte range 0x00-0x1F, and 0x7F. + """ + return [chr(c) for c in range(0x00, 0x20)] + ["\x7F"] diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..710a33ea3e19825c61269d530bdf1dd069ba3fc3 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/__init__.cpython-311.pyc @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:65ca54e9f0fc47c892b6eb3f207e8da542de60a87a8c640b979cd78b60cc521e +size 103342 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/bytecode_helper.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/bytecode_helper.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b049c807e1b6ab3995eabc7b6e98c29332446690 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/bytecode_helper.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/hashlib_helper.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/hashlib_helper.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..84044c2d6df3159ba13d3d4345b1f7b025e451db Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/hashlib_helper.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/import_helper.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/import_helper.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f35d4c611fa64a161417dd6d7a45d0705ef9070e Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/import_helper.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/interpreters.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/interpreters.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1b9f0759aed0a9579bff7d2ee8cc8033632006bc Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/interpreters.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/logging_helper.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/logging_helper.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc31c2986a099fd602bdc00806bda305fa005805 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/logging_helper.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/os_helper.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/os_helper.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6bd60a0a8c261179027156c4a234c90b013cbc2b Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/os_helper.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/pty_helper.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/pty_helper.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..249145e370e3b22645970a3e5181cd48b868c0fb Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/pty_helper.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/script_helper.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/script_helper.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d809bbff8b2e93f32d4ed2e1e642a3382077453f Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/script_helper.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/socket_helper.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/socket_helper.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6519db5657a12f414845bf7115f7b91903ee3343 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/socket_helper.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/threading_helper.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/threading_helper.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dde3f43256474394ad861e0737c53e866917f0c9 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/threading_helper.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/warnings_helper.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/warnings_helper.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7bb66f32d1201acc80283478b99b628fe07ff030 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/warnings_helper.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/bytecode_helper.py b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/bytecode_helper.py new file mode 100644 index 0000000000000000000000000000000000000000..471d4a68f915aab082591921ebdc3fcfb0996426 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/bytecode_helper.py @@ -0,0 +1,42 @@ +"""bytecode_helper - support tools for testing correct bytecode generation""" + +import unittest +import dis +import io + +_UNSPECIFIED = object() + +class BytecodeTestCase(unittest.TestCase): + """Custom assertion methods for inspecting bytecode.""" + + def get_disassembly_as_string(self, co): + s = io.StringIO() + dis.dis(co, file=s) + return s.getvalue() + + def assertInBytecode(self, x, opname, argval=_UNSPECIFIED): + """Returns instr if opname is found, otherwise throws AssertionError""" + for instr in dis.get_instructions(x): + if instr.opname == opname: + if argval is _UNSPECIFIED or instr.argval == argval: + return instr + disassembly = self.get_disassembly_as_string(x) + if argval is _UNSPECIFIED: + msg = '%s not found in bytecode:\n%s' % (opname, disassembly) + else: + msg = '(%s,%r) not found in bytecode:\n%s' + msg = msg % (opname, argval, disassembly) + self.fail(msg) + + def assertNotInBytecode(self, x, opname, argval=_UNSPECIFIED): + """Throws AssertionError if opname is found""" + for instr in dis.get_instructions(x): + if instr.opname == opname: + disassembly = self.get_disassembly_as_string(x) + if argval is _UNSPECIFIED: + msg = '%s occurs in bytecode:\n%s' % (opname, disassembly) + self.fail(msg) + elif instr.argval == argval: + msg = '(%s,%r) occurs in bytecode:\n%s' + msg = msg % (opname, argval, disassembly) + self.fail(msg) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/hashlib_helper.py b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/hashlib_helper.py new file mode 100644 index 0000000000000000000000000000000000000000..a4e6c92203ab5004d564d47bf7437f07e7a5813f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/hashlib_helper.py @@ -0,0 +1,51 @@ +import functools +import hashlib +import unittest + +try: + import _hashlib +except ImportError: + _hashlib = None + + +def requires_hashdigest(digestname, openssl=None, usedforsecurity=True): + """Decorator raising SkipTest if a hashing algorithm is not available + + The hashing algorithm could be missing or blocked by a strict crypto + policy. + + If 'openssl' is True, then the decorator checks that OpenSSL provides + the algorithm. Otherwise the check falls back to built-in + implementations. The usedforsecurity flag is passed to the constructor. + + ValueError: [digital envelope routines: EVP_DigestInit_ex] disabled for FIPS + ValueError: unsupported hash type md4 + """ + def decorator(func_or_class): + if isinstance(func_or_class, type): + setUpClass = func_or_class.__dict__.get('setUpClass') + if setUpClass is None: + def setUpClass(cls): + super(func_or_class, cls).setUpClass() + setUpClass.__qualname__ = func_or_class.__qualname__ + '.setUpClass' + setUpClass.__module__ = func_or_class.__module__ + else: + setUpClass = setUpClass.__func__ + setUpClass = classmethod(decorator(setUpClass)) + func_or_class.setUpClass = setUpClass + return func_or_class + + @functools.wraps(func_or_class) + def wrapper(*args, **kwargs): + try: + if openssl and _hashlib is not None: + _hashlib.new(digestname, usedforsecurity=usedforsecurity) + else: + hashlib.new(digestname, usedforsecurity=usedforsecurity) + except ValueError: + raise unittest.SkipTest( + f"hash digest '{digestname}' is not available." + ) + return func_or_class(*args, **kwargs) + return wrapper + return decorator diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/import_helper.py b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/import_helper.py new file mode 100644 index 0000000000000000000000000000000000000000..8519194381a6ad75de371791a0e086095e9781ae --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/import_helper.py @@ -0,0 +1,291 @@ +import contextlib +import _imp +import importlib +import importlib.util +import os +import shutil +import sys +import unittest +import warnings + +from .os_helper import unlink, temp_dir + + +@contextlib.contextmanager +def _ignore_deprecated_imports(ignore=True): + """Context manager to suppress package and module deprecation + warnings when importing them. + + If ignore is False, this context manager has no effect. + """ + if ignore: + with warnings.catch_warnings(): + warnings.filterwarnings("ignore", ".+ (module|package)", + DeprecationWarning) + yield + else: + yield + + +def unload(name): + try: + del sys.modules[name] + except KeyError: + pass + + +def forget(modname): + """'Forget' a module was ever imported. + + This removes the module from sys.modules and deletes any PEP 3147/488 or + legacy .pyc files. + """ + unload(modname) + for dirname in sys.path: + source = os.path.join(dirname, modname + '.py') + # It doesn't matter if they exist or not, unlink all possible + # combinations of PEP 3147/488 and legacy pyc files. + unlink(source + 'c') + for opt in ('', 1, 2): + unlink(importlib.util.cache_from_source(source, optimization=opt)) + + +def make_legacy_pyc(source): + """Move a PEP 3147/488 pyc file to its legacy pyc location. + + :param source: The file system path to the source file. The source file + does not need to exist, however the PEP 3147/488 pyc file must exist. + :return: The file system path to the legacy pyc file. + """ + pyc_file = importlib.util.cache_from_source(source) + up_one = os.path.dirname(os.path.abspath(source)) + legacy_pyc = os.path.join(up_one, source + 'c') + shutil.move(pyc_file, legacy_pyc) + return legacy_pyc + + +def import_module(name, deprecated=False, *, required_on=()): + """Import and return the module to be tested, raising SkipTest if + it is not available. + + If deprecated is True, any module or package deprecation messages + will be suppressed. If a module is required on a platform but optional for + others, set required_on to an iterable of platform prefixes which will be + compared against sys.platform. + """ + with _ignore_deprecated_imports(deprecated): + try: + return importlib.import_module(name) + except ImportError as msg: + if sys.platform.startswith(tuple(required_on)): + raise + raise unittest.SkipTest(str(msg)) + + +def _save_and_remove_modules(names): + orig_modules = {} + prefixes = tuple(name + '.' for name in names) + for modname in list(sys.modules): + if modname in names or modname.startswith(prefixes): + orig_modules[modname] = sys.modules.pop(modname) + return orig_modules + + +@contextlib.contextmanager +def frozen_modules(enabled=True): + """Force frozen modules to be used (or not). + + This only applies to modules that haven't been imported yet. + Also, some essential modules will always be imported frozen. + """ + _imp._override_frozen_modules_for_tests(1 if enabled else -1) + try: + yield + finally: + _imp._override_frozen_modules_for_tests(0) + + +def import_fresh_module(name, fresh=(), blocked=(), *, + deprecated=False, + usefrozen=False, + ): + """Import and return a module, deliberately bypassing sys.modules. + + This function imports and returns a fresh copy of the named Python module + by removing the named module from sys.modules before doing the import. + Note that unlike reload, the original module is not affected by + this operation. + + *fresh* is an iterable of additional module names that are also removed + from the sys.modules cache before doing the import. If one of these + modules can't be imported, None is returned. + + *blocked* is an iterable of module names that are replaced with None + in the module cache during the import to ensure that attempts to import + them raise ImportError. + + The named module and any modules named in the *fresh* and *blocked* + parameters are saved before starting the import and then reinserted into + sys.modules when the fresh import is complete. + + Module and package deprecation messages are suppressed during this import + if *deprecated* is True. + + This function will raise ImportError if the named module cannot be + imported. + + If "usefrozen" is False (the default) then the frozen importer is + disabled (except for essential modules like importlib._bootstrap). + """ + # NOTE: test_heapq, test_json and test_warnings include extra sanity checks + # to make sure that this utility function is working as expected + with _ignore_deprecated_imports(deprecated): + # Keep track of modules saved for later restoration as well + # as those which just need a blocking entry removed + fresh = list(fresh) + blocked = list(blocked) + names = {name, *fresh, *blocked} + orig_modules = _save_and_remove_modules(names) + for modname in blocked: + sys.modules[modname] = None + + try: + with frozen_modules(usefrozen): + # Return None when one of the "fresh" modules can not be imported. + try: + for modname in fresh: + __import__(modname) + except ImportError: + return None + return importlib.import_module(name) + finally: + _save_and_remove_modules(names) + sys.modules.update(orig_modules) + + +class CleanImport(object): + """Context manager to force import to return a new module reference. + + This is useful for testing module-level behaviours, such as + the emission of a DeprecationWarning on import. + + Use like this: + + with CleanImport("foo"): + importlib.import_module("foo") # new reference + + If "usefrozen" is False (the default) then the frozen importer is + disabled (except for essential modules like importlib._bootstrap). + """ + + def __init__(self, *module_names, usefrozen=False): + self.original_modules = sys.modules.copy() + for module_name in module_names: + if module_name in sys.modules: + module = sys.modules[module_name] + # It is possible that module_name is just an alias for + # another module (e.g. stub for modules renamed in 3.x). + # In that case, we also need delete the real module to clear + # the import cache. + if module.__name__ != module_name: + del sys.modules[module.__name__] + del sys.modules[module_name] + self._frozen_modules = frozen_modules(usefrozen) + + def __enter__(self): + self._frozen_modules.__enter__() + return self + + def __exit__(self, *ignore_exc): + sys.modules.update(self.original_modules) + self._frozen_modules.__exit__(*ignore_exc) + + +class DirsOnSysPath(object): + """Context manager to temporarily add directories to sys.path. + + This makes a copy of sys.path, appends any directories given + as positional arguments, then reverts sys.path to the copied + settings when the context ends. + + Note that *all* sys.path modifications in the body of the + context manager, including replacement of the object, + will be reverted at the end of the block. + """ + + def __init__(self, *paths): + self.original_value = sys.path[:] + self.original_object = sys.path + sys.path.extend(paths) + + def __enter__(self): + return self + + def __exit__(self, *ignore_exc): + sys.path = self.original_object + sys.path[:] = self.original_value + + +def modules_setup(): + return sys.modules.copy(), + + +def modules_cleanup(oldmodules): + # Encoders/decoders are registered permanently within the internal + # codec cache. If we destroy the corresponding modules their + # globals will be set to None which will trip up the cached functions. + encodings = [(k, v) for k, v in sys.modules.items() + if k.startswith('encodings.')] + sys.modules.clear() + sys.modules.update(encodings) + # XXX: This kind of problem can affect more than just encodings. + # In particular extension modules (such as _ssl) don't cope + # with reloading properly. Really, test modules should be cleaning + # out the test specific modules they know they added (ala test_runpy) + # rather than relying on this function (as test_importhooks and test_pkg + # do currently). Implicitly imported *real* modules should be left alone + # (see issue 10556). + sys.modules.update(oldmodules) + + +@contextlib.contextmanager +def isolated_modules(): + """ + Save modules on entry and cleanup on exit. + """ + (saved,) = modules_setup() + try: + yield + finally: + modules_cleanup(saved) + + +def mock_register_at_fork(func): + # bpo-30599: Mock os.register_at_fork() when importing the random module, + # since this function doesn't allow to unregister callbacks and would leak + # memory. + from unittest import mock + return mock.patch('os.register_at_fork', create=True)(func) + + +@contextlib.contextmanager +def ready_to_import(name=None, source=""): + from test.support import script_helper + + # 1. Sets up a temporary directory and removes it afterwards + # 2. Creates the module file + # 3. Temporarily clears the module from sys.modules (if any) + # 4. Reverts or removes the module when cleaning up + name = name or "spam" + with temp_dir() as tempdir: + path = script_helper.make_script(tempdir, name, source) + old_module = sys.modules.pop(name, None) + try: + sys.path.insert(0, tempdir) + yield name, path + sys.path.remove(tempdir) + finally: + if old_module is not None: + sys.modules[name] = old_module + else: + sys.modules.pop(name, None) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/interpreters.py b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/interpreters.py new file mode 100644 index 0000000000000000000000000000000000000000..2935708f9df1a5fd6b83e82418c6ec1471fb8832 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/interpreters.py @@ -0,0 +1,197 @@ +"""Subinterpreters High Level Module.""" + +import time +import _xxsubinterpreters as _interpreters + +# aliases: +from _xxsubinterpreters import ( + ChannelError, ChannelNotFoundError, ChannelEmptyError, + is_shareable, +) + + +__all__ = [ + 'Interpreter', 'get_current', 'get_main', 'create', 'list_all', + 'SendChannel', 'RecvChannel', + 'create_channel', 'list_all_channels', 'is_shareable', + 'ChannelError', 'ChannelNotFoundError', + 'ChannelEmptyError', + ] + + +def create(*, isolated=True): + """Return a new (idle) Python interpreter.""" + id = _interpreters.create(isolated=isolated) + return Interpreter(id, isolated=isolated) + + +def list_all(): + """Return all existing interpreters.""" + return [Interpreter(id) for id in _interpreters.list_all()] + + +def get_current(): + """Return the currently running interpreter.""" + id = _interpreters.get_current() + return Interpreter(id) + + +def get_main(): + """Return the main interpreter.""" + id = _interpreters.get_main() + return Interpreter(id) + + +class Interpreter: + """A single Python interpreter.""" + + def __init__(self, id, *, isolated=None): + if not isinstance(id, (int, _interpreters.InterpreterID)): + raise TypeError(f'id must be an int, got {id!r}') + self._id = id + self._isolated = isolated + + def __repr__(self): + data = dict(id=int(self._id), isolated=self._isolated) + kwargs = (f'{k}={v!r}' for k, v in data.items()) + return f'{type(self).__name__}({", ".join(kwargs)})' + + def __hash__(self): + return hash(self._id) + + def __eq__(self, other): + if not isinstance(other, Interpreter): + return NotImplemented + else: + return other._id == self._id + + @property + def id(self): + return self._id + + @property + def isolated(self): + if self._isolated is None: + # XXX The low-level function has not been added yet. + # See bpo-.... + self._isolated = _interpreters.is_isolated(self._id) + return self._isolated + + def is_running(self): + """Return whether or not the identified interpreter is running.""" + return _interpreters.is_running(self._id) + + def close(self): + """Finalize and destroy the interpreter. + + Attempting to destroy the current interpreter results + in a RuntimeError. + """ + return _interpreters.destroy(self._id) + + def run(self, src_str, /, *, channels=None): + """Run the given source code in the interpreter. + + This blocks the current Python thread until done. + """ + _interpreters.run_string(self._id, src_str, channels) + + +def create_channel(): + """Return (recv, send) for a new cross-interpreter channel. + + The channel may be used to pass data safely between interpreters. + """ + cid = _interpreters.channel_create() + recv, send = RecvChannel(cid), SendChannel(cid) + return recv, send + + +def list_all_channels(): + """Return a list of (recv, send) for all open channels.""" + return [(RecvChannel(cid), SendChannel(cid)) + for cid in _interpreters.channel_list_all()] + + +class _ChannelEnd: + """The base class for RecvChannel and SendChannel.""" + + def __init__(self, id): + if not isinstance(id, (int, _interpreters.ChannelID)): + raise TypeError(f'id must be an int, got {id!r}') + self._id = id + + def __repr__(self): + return f'{type(self).__name__}(id={int(self._id)})' + + def __hash__(self): + return hash(self._id) + + def __eq__(self, other): + if isinstance(self, RecvChannel): + if not isinstance(other, RecvChannel): + return NotImplemented + elif not isinstance(other, SendChannel): + return NotImplemented + return other._id == self._id + + @property + def id(self): + return self._id + + +_NOT_SET = object() + + +class RecvChannel(_ChannelEnd): + """The receiving end of a cross-interpreter channel.""" + + def recv(self, *, _sentinel=object(), _delay=10 / 1000): # 10 milliseconds + """Return the next object from the channel. + + This blocks until an object has been sent, if none have been + sent already. + """ + obj = _interpreters.channel_recv(self._id, _sentinel) + while obj is _sentinel: + time.sleep(_delay) + obj = _interpreters.channel_recv(self._id, _sentinel) + return obj + + def recv_nowait(self, default=_NOT_SET): + """Return the next object from the channel. + + If none have been sent then return the default if one + is provided or fail with ChannelEmptyError. Otherwise this + is the same as recv(). + """ + if default is _NOT_SET: + return _interpreters.channel_recv(self._id) + else: + return _interpreters.channel_recv(self._id, default) + + +class SendChannel(_ChannelEnd): + """The sending end of a cross-interpreter channel.""" + + def send(self, obj): + """Send the object (i.e. its data) to the channel's receiving end. + + This blocks until the object is received. + """ + _interpreters.channel_send(self._id, obj) + # XXX We are missing a low-level channel_send_wait(). + # See bpo-32604 and gh-19829. + # Until that shows up we fake it: + time.sleep(2) + + def send_nowait(self, obj): + """Send the object to the channel's receiving end. + + If the object is immediately received then return True + (else False). Otherwise this is the same as send(). + """ + # XXX Note that at the moment channel_send() only ever returns + # None. This should be fixed when channel_send_wait() is added. + # See bpo-32604 and gh-19829. + return _interpreters.channel_send(self._id, obj) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/logging_helper.py b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/logging_helper.py new file mode 100644 index 0000000000000000000000000000000000000000..12fcca4f0f08d9b445ac84f6a1920c8bcb3badf4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/logging_helper.py @@ -0,0 +1,29 @@ +import logging.handlers + +class TestHandler(logging.handlers.BufferingHandler): + def __init__(self, matcher): + # BufferingHandler takes a "capacity" argument + # so as to know when to flush. As we're overriding + # shouldFlush anyway, we can set a capacity of zero. + # You can call flush() manually to clear out the + # buffer. + logging.handlers.BufferingHandler.__init__(self, 0) + self.matcher = matcher + + def shouldFlush(self): + return False + + def emit(self, record): + self.format(record) + self.buffer.append(record.__dict__) + + def matches(self, **kwargs): + """ + Look for a saved dict whose keys/values match the supplied arguments. + """ + result = False + for d in self.buffer: + if self.matcher.matches(d, **kwargs): + result = True + break + return result diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/os_helper.py b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/os_helper.py new file mode 100644 index 0000000000000000000000000000000000000000..b7fc0c30864c4cf8a45c41f42b22c811ee675904 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/os_helper.py @@ -0,0 +1,747 @@ +import collections.abc +import contextlib +import errno +import os +import re +import stat +import sys +import time +import unittest +import warnings + +from test import support + + +# Filename used for testing +if os.name == 'java': + # Jython disallows @ in module names + TESTFN_ASCII = '$test' +else: + TESTFN_ASCII = '@test' + +# Disambiguate TESTFN for parallel testing, while letting it remain a valid +# module name. +TESTFN_ASCII = "{}_{}_tmp".format(TESTFN_ASCII, os.getpid()) + +# TESTFN_UNICODE is a non-ascii filename +TESTFN_UNICODE = TESTFN_ASCII + "-\xe0\xf2\u0258\u0141\u011f" +if sys.platform == 'darwin': + # In Mac OS X's VFS API file names are, by definition, canonically + # decomposed Unicode, encoded using UTF-8. See QA1173: + # http://developer.apple.com/mac/library/qa/qa2001/qa1173.html + import unicodedata + TESTFN_UNICODE = unicodedata.normalize('NFD', TESTFN_UNICODE) + +# TESTFN_UNENCODABLE is a filename (str type) that should *not* be able to be +# encoded by the filesystem encoding (in strict mode). It can be None if we +# cannot generate such filename. +TESTFN_UNENCODABLE = None +if os.name == 'nt': + # skip win32s (0) or Windows 9x/ME (1) + if sys.getwindowsversion().platform >= 2: + # Different kinds of characters from various languages to minimize the + # probability that the whole name is encodable to MBCS (issue #9819) + TESTFN_UNENCODABLE = TESTFN_ASCII + "-\u5171\u0141\u2661\u0363\uDC80" + try: + TESTFN_UNENCODABLE.encode(sys.getfilesystemencoding()) + except UnicodeEncodeError: + pass + else: + print('WARNING: The filename %r CAN be encoded by the filesystem ' + 'encoding (%s). Unicode filename tests may not be effective' + % (TESTFN_UNENCODABLE, sys.getfilesystemencoding())) + TESTFN_UNENCODABLE = None +# macOS and Emscripten deny unencodable filenames (invalid utf-8) +elif sys.platform not in {'darwin', 'emscripten', 'wasi'}: + try: + # ascii and utf-8 cannot encode the byte 0xff + b'\xff'.decode(sys.getfilesystemencoding()) + except UnicodeDecodeError: + # 0xff will be encoded using the surrogate character u+DCFF + TESTFN_UNENCODABLE = TESTFN_ASCII \ + + b'-\xff'.decode(sys.getfilesystemencoding(), 'surrogateescape') + else: + # File system encoding (eg. ISO-8859-* encodings) can encode + # the byte 0xff. Skip some unicode filename tests. + pass + +# FS_NONASCII: non-ASCII character encodable by os.fsencode(), +# or an empty string if there is no such character. +FS_NONASCII = '' +for character in ( + # First try printable and common characters to have a readable filename. + # For each character, the encoding list are just example of encodings able + # to encode the character (the list is not exhaustive). + + # U+00E6 (Latin Small Letter Ae): cp1252, iso-8859-1 + '\u00E6', + # U+0130 (Latin Capital Letter I With Dot Above): cp1254, iso8859_3 + '\u0130', + # U+0141 (Latin Capital Letter L With Stroke): cp1250, cp1257 + '\u0141', + # U+03C6 (Greek Small Letter Phi): cp1253 + '\u03C6', + # U+041A (Cyrillic Capital Letter Ka): cp1251 + '\u041A', + # U+05D0 (Hebrew Letter Alef): Encodable to cp424 + '\u05D0', + # U+060C (Arabic Comma): cp864, cp1006, iso8859_6, mac_arabic + '\u060C', + # U+062A (Arabic Letter Teh): cp720 + '\u062A', + # U+0E01 (Thai Character Ko Kai): cp874 + '\u0E01', + + # Then try more "special" characters. "special" because they may be + # interpreted or displayed differently depending on the exact locale + # encoding and the font. + + # U+00A0 (No-Break Space) + '\u00A0', + # U+20AC (Euro Sign) + '\u20AC', +): + try: + # If Python is set up to use the legacy 'mbcs' in Windows, + # 'replace' error mode is used, and encode() returns b'?' + # for characters missing in the ANSI codepage + if os.fsdecode(os.fsencode(character)) != character: + raise UnicodeError + except UnicodeError: + pass + else: + FS_NONASCII = character + break + +# Save the initial cwd +SAVEDCWD = os.getcwd() + +# TESTFN_UNDECODABLE is a filename (bytes type) that should *not* be able to be +# decoded from the filesystem encoding (in strict mode). It can be None if we +# cannot generate such filename (ex: the latin1 encoding can decode any byte +# sequence). On UNIX, TESTFN_UNDECODABLE can be decoded by os.fsdecode() thanks +# to the surrogateescape error handler (PEP 383), but not from the filesystem +# encoding in strict mode. +TESTFN_UNDECODABLE = None +for name in ( + # b'\xff' is not decodable by os.fsdecode() with code page 932. Windows + # accepts it to create a file or a directory, or don't accept to enter to + # such directory (when the bytes name is used). So test b'\xe7' first: + # it is not decodable from cp932. + b'\xe7w\xf0', + # undecodable from ASCII, UTF-8 + b'\xff', + # undecodable from iso8859-3, iso8859-6, iso8859-7, cp424, iso8859-8, cp856 + # and cp857 + b'\xae\xd5' + # undecodable from UTF-8 (UNIX and Mac OS X) + b'\xed\xb2\x80', b'\xed\xb4\x80', + # undecodable from shift_jis, cp869, cp874, cp932, cp1250, cp1251, cp1252, + # cp1253, cp1254, cp1255, cp1257, cp1258 + b'\x81\x98', +): + try: + name.decode(sys.getfilesystemencoding()) + except UnicodeDecodeError: + TESTFN_UNDECODABLE = os.fsencode(TESTFN_ASCII) + name + break + +if FS_NONASCII: + TESTFN_NONASCII = TESTFN_ASCII + FS_NONASCII +else: + TESTFN_NONASCII = None +TESTFN = TESTFN_NONASCII or TESTFN_ASCII + + +def make_bad_fd(): + """ + Create an invalid file descriptor by opening and closing a file and return + its fd. + """ + file = open(TESTFN, "wb") + try: + return file.fileno() + finally: + file.close() + unlink(TESTFN) + + +_can_symlink = None + + +def can_symlink(): + global _can_symlink + if _can_symlink is not None: + return _can_symlink + # WASI / wasmtime prevents symlinks with absolute paths, see man + # openat2(2) RESOLVE_BENEATH. Almost all symlink tests use absolute + # paths. Skip symlink tests on WASI for now. + src = os.path.abspath(TESTFN) + symlink_path = src + "can_symlink" + try: + os.symlink(src, symlink_path) + can = True + except (OSError, NotImplementedError, AttributeError): + can = False + else: + os.remove(symlink_path) + _can_symlink = can + return can + + +def skip_unless_symlink(test): + """Skip decorator for tests that require functional symlink""" + ok = can_symlink() + msg = "Requires functional symlink implementation" + return test if ok else unittest.skip(msg)(test) + + +_can_hardlink = None + +def can_hardlink(): + global _can_hardlink + if _can_hardlink is None: + # Android blocks hard links using SELinux + # (https://stackoverflow.com/q/32365690). + _can_hardlink = hasattr(os, "link") and not support.is_android + return _can_hardlink + + +def skip_unless_hardlink(test): + ok = can_hardlink() + msg = "requires hardlink support" + return test if ok else unittest.skip(msg)(test) + + +_can_xattr = None + + +def can_xattr(): + import tempfile + global _can_xattr + if _can_xattr is not None: + return _can_xattr + if not hasattr(os, "setxattr"): + can = False + else: + import platform + tmp_dir = tempfile.mkdtemp() + tmp_fp, tmp_name = tempfile.mkstemp(dir=tmp_dir) + try: + with open(TESTFN, "wb") as fp: + try: + # TESTFN & tempfile may use different file systems with + # different capabilities + os.setxattr(tmp_fp, b"user.test", b"") + os.setxattr(tmp_name, b"trusted.foo", b"42") + os.setxattr(fp.fileno(), b"user.test", b"") + # Kernels < 2.6.39 don't respect setxattr flags. + kernel_version = platform.release() + m = re.match(r"2.6.(\d{1,2})", kernel_version) + can = m is None or int(m.group(1)) >= 39 + except OSError: + can = False + finally: + unlink(TESTFN) + unlink(tmp_name) + rmdir(tmp_dir) + _can_xattr = can + return can + + +def skip_unless_xattr(test): + """Skip decorator for tests that require functional extended attributes""" + ok = can_xattr() + msg = "no non-broken extended attribute support" + return test if ok else unittest.skip(msg)(test) + + +_can_chmod = None + +def can_chmod(): + global _can_chmod + if _can_chmod is not None: + return _can_chmod + if not hasattr(os, "chmod"): + _can_chmod = False + return _can_chmod + try: + with open(TESTFN, "wb") as f: + try: + os.chmod(TESTFN, 0o555) + mode1 = os.stat(TESTFN).st_mode + os.chmod(TESTFN, 0o777) + mode2 = os.stat(TESTFN).st_mode + except OSError as e: + can = False + else: + can = stat.S_IMODE(mode1) != stat.S_IMODE(mode2) + finally: + unlink(TESTFN) + _can_chmod = can + return can + + +def skip_unless_working_chmod(test): + """Skip tests that require working os.chmod() + + WASI SDK 15.0 cannot change file mode bits. + """ + ok = can_chmod() + msg = "requires working os.chmod()" + return test if ok else unittest.skip(msg)(test) + + +# Check whether the current effective user has the capability to override +# DAC (discretionary access control). Typically user root is able to +# bypass file read, write, and execute permission checks. The capability +# is independent of the effective user. See capabilities(7). +_can_dac_override = None + +def can_dac_override(): + global _can_dac_override + + if not can_chmod(): + _can_dac_override = False + if _can_dac_override is not None: + return _can_dac_override + + try: + with open(TESTFN, "wb") as f: + os.chmod(TESTFN, 0o400) + try: + with open(TESTFN, "wb"): + pass + except OSError: + _can_dac_override = False + else: + _can_dac_override = True + finally: + try: + os.chmod(TESTFN, 0o700) + except OSError: + pass + unlink(TESTFN) + + return _can_dac_override + + +def skip_if_dac_override(test): + ok = not can_dac_override() + msg = "incompatible with CAP_DAC_OVERRIDE" + return test if ok else unittest.skip(msg)(test) + + +def skip_unless_dac_override(test): + ok = can_dac_override() + msg = "requires CAP_DAC_OVERRIDE" + return test if ok else unittest.skip(msg)(test) + + +def unlink(filename): + try: + _unlink(filename) + except (FileNotFoundError, NotADirectoryError): + pass + + +if sys.platform.startswith("win"): + def _waitfor(func, pathname, waitall=False): + # Perform the operation + func(pathname) + # Now setup the wait loop + if waitall: + dirname = pathname + else: + dirname, name = os.path.split(pathname) + dirname = dirname or '.' + # Check for `pathname` to be removed from the filesystem. + # The exponential backoff of the timeout amounts to a total + # of ~1 second after which the deletion is probably an error + # anyway. + # Testing on an i7@4.3GHz shows that usually only 1 iteration is + # required when contention occurs. + timeout = 0.001 + while timeout < 1.0: + # Note we are only testing for the existence of the file(s) in + # the contents of the directory regardless of any security or + # access rights. If we have made it this far, we have sufficient + # permissions to do that much using Python's equivalent of the + # Windows API FindFirstFile. + # Other Windows APIs can fail or give incorrect results when + # dealing with files that are pending deletion. + L = os.listdir(dirname) + if not (L if waitall else name in L): + return + # Increase the timeout and try again + time.sleep(timeout) + timeout *= 2 + warnings.warn('tests may fail, delete still pending for ' + pathname, + RuntimeWarning, stacklevel=4) + + def _unlink(filename): + _waitfor(os.unlink, filename) + + def _rmdir(dirname): + _waitfor(os.rmdir, dirname) + + def _rmtree(path): + from test.support import _force_run + + def _rmtree_inner(path): + for name in _force_run(path, os.listdir, path): + fullname = os.path.join(path, name) + try: + mode = os.lstat(fullname).st_mode + except OSError as exc: + print("support.rmtree(): os.lstat(%r) failed with %s" + % (fullname, exc), + file=sys.__stderr__) + mode = 0 + if stat.S_ISDIR(mode): + _waitfor(_rmtree_inner, fullname, waitall=True) + _force_run(fullname, os.rmdir, fullname) + else: + _force_run(fullname, os.unlink, fullname) + _waitfor(_rmtree_inner, path, waitall=True) + _waitfor(lambda p: _force_run(p, os.rmdir, p), path) + + def _longpath(path): + try: + import ctypes + except ImportError: + # No ctypes means we can't expands paths. + pass + else: + buffer = ctypes.create_unicode_buffer(len(path) * 2) + length = ctypes.windll.kernel32.GetLongPathNameW(path, buffer, + len(buffer)) + if length: + return buffer[:length] + return path +else: + _unlink = os.unlink + _rmdir = os.rmdir + + def _rmtree(path): + import shutil + try: + shutil.rmtree(path) + return + except OSError: + pass + + def _rmtree_inner(path): + from test.support import _force_run + for name in _force_run(path, os.listdir, path): + fullname = os.path.join(path, name) + try: + mode = os.lstat(fullname).st_mode + except OSError: + mode = 0 + if stat.S_ISDIR(mode): + _rmtree_inner(fullname) + _force_run(path, os.rmdir, fullname) + else: + _force_run(path, os.unlink, fullname) + _rmtree_inner(path) + os.rmdir(path) + + def _longpath(path): + return path + + +def rmdir(dirname): + try: + _rmdir(dirname) + except FileNotFoundError: + pass + + +def rmtree(path): + try: + _rmtree(path) + except FileNotFoundError: + pass + + +@contextlib.contextmanager +def temp_dir(path=None, quiet=False): + """Return a context manager that creates a temporary directory. + + Arguments: + + path: the directory to create temporarily. If omitted or None, + defaults to creating a temporary directory using tempfile.mkdtemp. + + quiet: if False (the default), the context manager raises an exception + on error. Otherwise, if the path is specified and cannot be + created, only a warning is issued. + + """ + import tempfile + dir_created = False + if path is None: + path = tempfile.mkdtemp() + dir_created = True + path = os.path.realpath(path) + else: + try: + os.mkdir(path) + dir_created = True + except OSError as exc: + if not quiet: + raise + warnings.warn(f'tests may fail, unable to create ' + f'temporary directory {path!r}: {exc}', + RuntimeWarning, stacklevel=3) + if dir_created: + pid = os.getpid() + try: + yield path + finally: + # In case the process forks, let only the parent remove the + # directory. The child has a different process id. (bpo-30028) + if dir_created and pid == os.getpid(): + rmtree(path) + + +@contextlib.contextmanager +def change_cwd(path, quiet=False): + """Return a context manager that changes the current working directory. + + Arguments: + + path: the directory to use as the temporary current working directory. + + quiet: if False (the default), the context manager raises an exception + on error. Otherwise, it issues only a warning and keeps the current + working directory the same. + + """ + saved_dir = os.getcwd() + try: + os.chdir(os.path.realpath(path)) + except OSError as exc: + if not quiet: + raise + warnings.warn(f'tests may fail, unable to change the current working ' + f'directory to {path!r}: {exc}', + RuntimeWarning, stacklevel=3) + try: + yield os.getcwd() + finally: + os.chdir(saved_dir) + + +@contextlib.contextmanager +def temp_cwd(name='tempcwd', quiet=False): + """ + Context manager that temporarily creates and changes the CWD. + + The function temporarily changes the current working directory + after creating a temporary directory in the current directory with + name *name*. If *name* is None, the temporary directory is + created using tempfile.mkdtemp. + + If *quiet* is False (default) and it is not possible to + create or change the CWD, an error is raised. If *quiet* is True, + only a warning is raised and the original CWD is used. + + """ + with temp_dir(path=name, quiet=quiet) as temp_path: + with change_cwd(temp_path, quiet=quiet) as cwd_dir: + yield cwd_dir + + +def create_empty_file(filename): + """Create an empty file. If the file already exists, truncate it.""" + fd = os.open(filename, os.O_WRONLY | os.O_CREAT | os.O_TRUNC) + os.close(fd) + + +@contextlib.contextmanager +def open_dir_fd(path): + """Open a file descriptor to a directory.""" + assert os.path.isdir(path) + flags = os.O_RDONLY + if hasattr(os, "O_DIRECTORY"): + flags |= os.O_DIRECTORY + dir_fd = os.open(path, flags) + try: + yield dir_fd + finally: + os.close(dir_fd) + + +def fs_is_case_insensitive(directory): + """Detects if the file system for the specified directory + is case-insensitive.""" + import tempfile + with tempfile.NamedTemporaryFile(dir=directory) as base: + base_path = base.name + case_path = base_path.upper() + if case_path == base_path: + case_path = base_path.lower() + try: + return os.path.samefile(base_path, case_path) + except FileNotFoundError: + return False + + +class FakePath: + """Simple implementation of the path protocol. + """ + def __init__(self, path): + self.path = path + + def __repr__(self): + return f'' + + def __fspath__(self): + if (isinstance(self.path, BaseException) or + isinstance(self.path, type) and + issubclass(self.path, BaseException)): + raise self.path + else: + return self.path + + +def fd_count(): + """Count the number of open file descriptors. + """ + if sys.platform.startswith(('linux', 'freebsd', 'emscripten')): + fd_path = "/proc/self/fd" + elif sys.platform == "darwin": + fd_path = "/dev/fd" + else: + fd_path = None + + if fd_path is not None: + try: + names = os.listdir(fd_path) + # Subtract one because listdir() internally opens a file + # descriptor to list the content of the directory. + return len(names) - 1 + except FileNotFoundError: + pass + + MAXFD = 256 + if hasattr(os, 'sysconf'): + try: + MAXFD = os.sysconf("SC_OPEN_MAX") + except OSError: + pass + + old_modes = None + if sys.platform == 'win32': + # bpo-25306, bpo-31009: Call CrtSetReportMode() to not kill the process + # on invalid file descriptor if Python is compiled in debug mode + try: + import msvcrt + msvcrt.CrtSetReportMode + except (AttributeError, ImportError): + # no msvcrt or a release build + pass + else: + old_modes = {} + for report_type in (msvcrt.CRT_WARN, + msvcrt.CRT_ERROR, + msvcrt.CRT_ASSERT): + old_modes[report_type] = msvcrt.CrtSetReportMode(report_type, + 0) + + try: + count = 0 + for fd in range(MAXFD): + try: + # Prefer dup() over fstat(). fstat() can require input/output + # whereas dup() doesn't. + fd2 = os.dup(fd) + except OSError as e: + if e.errno != errno.EBADF: + raise + else: + os.close(fd2) + count += 1 + finally: + if old_modes is not None: + for report_type in (msvcrt.CRT_WARN, + msvcrt.CRT_ERROR, + msvcrt.CRT_ASSERT): + msvcrt.CrtSetReportMode(report_type, old_modes[report_type]) + + return count + + +if hasattr(os, "umask"): + @contextlib.contextmanager + def temp_umask(umask): + """Context manager that temporarily sets the process umask.""" + oldmask = os.umask(umask) + try: + yield + finally: + os.umask(oldmask) +else: + @contextlib.contextmanager + def temp_umask(umask): + """no-op on platforms without umask()""" + yield + + +class EnvironmentVarGuard(collections.abc.MutableMapping): + + """Class to help protect the environment variable properly. Can be used as + a context manager.""" + + def __init__(self): + self._environ = os.environ + self._changed = {} + + def __getitem__(self, envvar): + return self._environ[envvar] + + def __setitem__(self, envvar, value): + # Remember the initial value on the first access + if envvar not in self._changed: + self._changed[envvar] = self._environ.get(envvar) + self._environ[envvar] = value + + def __delitem__(self, envvar): + # Remember the initial value on the first access + if envvar not in self._changed: + self._changed[envvar] = self._environ.get(envvar) + if envvar in self._environ: + del self._environ[envvar] + + def keys(self): + return self._environ.keys() + + def __iter__(self): + return iter(self._environ) + + def __len__(self): + return len(self._environ) + + def set(self, envvar, value): + self[envvar] = value + + def unset(self, envvar): + del self[envvar] + + def copy(self): + # We do what os.environ.copy() does. + return dict(self) + + def __enter__(self): + return self + + def __exit__(self, *ignore_exc): + for (k, v) in self._changed.items(): + if v is None: + if k in self._environ: + del self._environ[k] + else: + self._environ[k] = v + os.environ = self._environ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/pty_helper.py b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/pty_helper.py new file mode 100644 index 0000000000000000000000000000000000000000..6587fd40333c5124eb58c803e753505cb128673b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/pty_helper.py @@ -0,0 +1,80 @@ +""" +Helper to run a script in a pseudo-terminal. +""" +import os +import selectors +import subprocess +import sys +from contextlib import ExitStack +from errno import EIO + +from test.support.import_helper import import_module + +def run_pty(script, input=b"dummy input\r", env=None): + pty = import_module('pty') + output = bytearray() + [master, slave] = pty.openpty() + args = (sys.executable, '-c', script) + proc = subprocess.Popen(args, stdin=slave, stdout=slave, stderr=slave, env=env) + os.close(slave) + with ExitStack() as cleanup: + cleanup.enter_context(proc) + def terminate(proc): + try: + proc.terminate() + except ProcessLookupError: + # Workaround for Open/Net BSD bug (Issue 16762) + pass + cleanup.callback(terminate, proc) + cleanup.callback(os.close, master) + # Avoid using DefaultSelector and PollSelector. Kqueue() does not + # work with pseudo-terminals on OS X < 10.9 (Issue 20365) and Open + # BSD (Issue 20667). Poll() does not work with OS X 10.6 or 10.4 + # either (Issue 20472). Hopefully the file descriptor is low enough + # to use with select(). + sel = cleanup.enter_context(selectors.SelectSelector()) + sel.register(master, selectors.EVENT_READ | selectors.EVENT_WRITE) + os.set_blocking(master, False) + while True: + for [_, events] in sel.select(): + if events & selectors.EVENT_READ: + try: + chunk = os.read(master, 0x10000) + except OSError as err: + # Linux raises EIO when slave is closed (Issue 5380) + if err.errno != EIO: + raise + chunk = b"" + if not chunk: + return output + output.extend(chunk) + if events & selectors.EVENT_WRITE: + try: + input = input[os.write(master, input):] + except OSError as err: + # Apparently EIO means the slave was closed + if err.errno != EIO: + raise + input = b"" # Stop writing + if not input: + sel.modify(master, selectors.EVENT_READ) + + +###################################################################### +## Fake stdin (for testing interactive debugging) +###################################################################### + +class FakeInput: + """ + A fake input stream for pdb's interactive debugger. Whenever a + line is read, print it (to simulate the user typing it), and then + return it. The set of lines to return is specified in the + constructor; they should not have trailing newlines. + """ + def __init__(self, lines): + self.lines = lines + + def readline(self): + line = self.lines.pop(0) + print(line) + return line + '\n' diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/script_helper.py b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/script_helper.py new file mode 100644 index 0000000000000000000000000000000000000000..c2b43f4060eb5522e93a25d753de070acf9f9120 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/script_helper.py @@ -0,0 +1,302 @@ +# Common utility functions used by various script execution tests +# e.g. test_cmd_line, test_cmd_line_script and test_runpy + +import collections +import importlib +import sys +import os +import os.path +import subprocess +import py_compile +import zipfile + +from importlib.util import source_from_cache +from test import support +from test.support.import_helper import make_legacy_pyc + + +# Cached result of the expensive test performed in the function below. +__cached_interp_requires_environment = None + + +def interpreter_requires_environment(): + """ + Returns True if our sys.executable interpreter requires environment + variables in order to be able to run at all. + + This is designed to be used with @unittest.skipIf() to annotate tests + that need to use an assert_python*() function to launch an isolated + mode (-I) or no environment mode (-E) sub-interpreter process. + + A normal build & test does not run into this situation but it can happen + when trying to run the standard library test suite from an interpreter that + doesn't have an obvious home with Python's current home finding logic. + + Setting PYTHONHOME is one way to get most of the testsuite to run in that + situation. PYTHONPATH or PYTHONUSERSITE are other common environment + variables that might impact whether or not the interpreter can start. + """ + global __cached_interp_requires_environment + if __cached_interp_requires_environment is None: + # If PYTHONHOME is set, assume that we need it + if 'PYTHONHOME' in os.environ: + __cached_interp_requires_environment = True + return True + # cannot run subprocess, assume we don't need it + if not support.has_subprocess_support: + __cached_interp_requires_environment = False + return False + + # Try running an interpreter with -E to see if it works or not. + try: + subprocess.check_call([sys.executable, '-E', + '-c', 'import sys; sys.exit(0)']) + except subprocess.CalledProcessError: + __cached_interp_requires_environment = True + else: + __cached_interp_requires_environment = False + + return __cached_interp_requires_environment + + +class _PythonRunResult(collections.namedtuple("_PythonRunResult", + ("rc", "out", "err"))): + """Helper for reporting Python subprocess run results""" + def fail(self, cmd_line): + """Provide helpful details about failed subcommand runs""" + # Limit to 80 lines to ASCII characters + maxlen = 80 * 100 + out, err = self.out, self.err + if len(out) > maxlen: + out = b'(... truncated stdout ...)' + out[-maxlen:] + if len(err) > maxlen: + err = b'(... truncated stderr ...)' + err[-maxlen:] + out = out.decode('ascii', 'replace').rstrip() + err = err.decode('ascii', 'replace').rstrip() + raise AssertionError("Process return code is %d\n" + "command line: %r\n" + "\n" + "stdout:\n" + "---\n" + "%s\n" + "---\n" + "\n" + "stderr:\n" + "---\n" + "%s\n" + "---" + % (self.rc, cmd_line, + out, + err)) + + +# Executing the interpreter in a subprocess +@support.requires_subprocess() +def run_python_until_end(*args, **env_vars): + env_required = interpreter_requires_environment() + cwd = env_vars.pop('__cwd', None) + if '__isolated' in env_vars: + isolated = env_vars.pop('__isolated') + else: + isolated = not env_vars and not env_required + cmd_line = [sys.executable, '-X', 'faulthandler'] + if isolated: + # isolated mode: ignore Python environment variables, ignore user + # site-packages, and don't add the current directory to sys.path + cmd_line.append('-I') + elif not env_vars and not env_required: + # ignore Python environment variables + cmd_line.append('-E') + + # But a special flag that can be set to override -- in this case, the + # caller is responsible to pass the full environment. + if env_vars.pop('__cleanenv', None): + env = {} + if sys.platform == 'win32': + # Windows requires at least the SYSTEMROOT environment variable to + # start Python. + env['SYSTEMROOT'] = os.environ['SYSTEMROOT'] + + # Other interesting environment variables, not copied currently: + # COMSPEC, HOME, PATH, TEMP, TMPDIR, TMP. + else: + # Need to preserve the original environment, for in-place testing of + # shared library builds. + env = os.environ.copy() + + # set TERM='' unless the TERM environment variable is passed explicitly + # see issues #11390 and #18300 + if 'TERM' not in env_vars: + env['TERM'] = '' + + env.update(env_vars) + cmd_line.extend(args) + proc = subprocess.Popen(cmd_line, stdin=subprocess.PIPE, + stdout=subprocess.PIPE, stderr=subprocess.PIPE, + env=env, cwd=cwd) + with proc: + try: + out, err = proc.communicate() + finally: + proc.kill() + subprocess._cleanup() + rc = proc.returncode + return _PythonRunResult(rc, out, err), cmd_line + + +@support.requires_subprocess() +def _assert_python(expected_success, /, *args, **env_vars): + res, cmd_line = run_python_until_end(*args, **env_vars) + if (res.rc and expected_success) or (not res.rc and not expected_success): + res.fail(cmd_line) + return res + + +def assert_python_ok(*args, **env_vars): + """ + Assert that running the interpreter with `args` and optional environment + variables `env_vars` succeeds (rc == 0) and return a (return code, stdout, + stderr) tuple. + + If the __cleanenv keyword is set, env_vars is used as a fresh environment. + + Python is started in isolated mode (command line option -I), + except if the __isolated keyword is set to False. + """ + return _assert_python(True, *args, **env_vars) + + +def assert_python_failure(*args, **env_vars): + """ + Assert that running the interpreter with `args` and optional environment + variables `env_vars` fails (rc != 0) and return a (return code, stdout, + stderr) tuple. + + See assert_python_ok() for more options. + """ + return _assert_python(False, *args, **env_vars) + + +@support.requires_subprocess() +def spawn_python(*args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, **kw): + """Run a Python subprocess with the given arguments. + + kw is extra keyword args to pass to subprocess.Popen. Returns a Popen + object. + """ + cmd_line = [sys.executable] + if not interpreter_requires_environment(): + cmd_line.append('-E') + cmd_line.extend(args) + # Under Fedora (?), GNU readline can output junk on stderr when initialized, + # depending on the TERM setting. Setting TERM=vt100 is supposed to disable + # that. References: + # - http://reinout.vanrees.org/weblog/2009/08/14/readline-invisible-character-hack.html + # - http://stackoverflow.com/questions/15760712/python-readline-module-prints-escape-character-during-import + # - http://lists.gnu.org/archive/html/bug-readline/2007-08/msg00004.html + env = kw.setdefault('env', dict(os.environ)) + env['TERM'] = 'vt100' + return subprocess.Popen(cmd_line, stdin=subprocess.PIPE, + stdout=stdout, stderr=stderr, + **kw) + + +def kill_python(p): + """Run the given Popen process until completion and return stdout.""" + p.stdin.close() + data = p.stdout.read() + p.stdout.close() + # try to cleanup the child so we don't appear to leak when running + # with regrtest -R. + p.wait() + subprocess._cleanup() + return data + + +def make_script(script_dir, script_basename, source, omit_suffix=False): + script_filename = script_basename + if not omit_suffix: + script_filename += os.extsep + 'py' + script_name = os.path.join(script_dir, script_filename) + # The script should be encoded to UTF-8, the default string encoding + with open(script_name, 'w', encoding='utf-8') as script_file: + script_file.write(source) + importlib.invalidate_caches() + return script_name + + +def make_zip_script(zip_dir, zip_basename, script_name, name_in_zip=None): + zip_filename = zip_basename+os.extsep+'zip' + zip_name = os.path.join(zip_dir, zip_filename) + with zipfile.ZipFile(zip_name, 'w') as zip_file: + if name_in_zip is None: + parts = script_name.split(os.sep) + if len(parts) >= 2 and parts[-2] == '__pycache__': + legacy_pyc = make_legacy_pyc(source_from_cache(script_name)) + name_in_zip = os.path.basename(legacy_pyc) + script_name = legacy_pyc + else: + name_in_zip = os.path.basename(script_name) + zip_file.write(script_name, name_in_zip) + #if test.support.verbose: + # with zipfile.ZipFile(zip_name, 'r') as zip_file: + # print 'Contents of %r:' % zip_name + # zip_file.printdir() + return zip_name, os.path.join(zip_name, name_in_zip) + + +def make_pkg(pkg_dir, init_source=''): + os.mkdir(pkg_dir) + make_script(pkg_dir, '__init__', init_source) + + +def make_zip_pkg(zip_dir, zip_basename, pkg_name, script_basename, + source, depth=1, compiled=False): + unlink = [] + init_name = make_script(zip_dir, '__init__', '') + unlink.append(init_name) + init_basename = os.path.basename(init_name) + script_name = make_script(zip_dir, script_basename, source) + unlink.append(script_name) + if compiled: + init_name = py_compile.compile(init_name, doraise=True) + script_name = py_compile.compile(script_name, doraise=True) + unlink.extend((init_name, script_name)) + pkg_names = [os.sep.join([pkg_name]*i) for i in range(1, depth+1)] + script_name_in_zip = os.path.join(pkg_names[-1], os.path.basename(script_name)) + zip_filename = zip_basename+os.extsep+'zip' + zip_name = os.path.join(zip_dir, zip_filename) + with zipfile.ZipFile(zip_name, 'w') as zip_file: + for name in pkg_names: + init_name_in_zip = os.path.join(name, init_basename) + zip_file.write(init_name, init_name_in_zip) + zip_file.write(script_name, script_name_in_zip) + for name in unlink: + os.unlink(name) + #if test.support.verbose: + # with zipfile.ZipFile(zip_name, 'r') as zip_file: + # print 'Contents of %r:' % zip_name + # zip_file.printdir() + return zip_name, os.path.join(zip_name, script_name_in_zip) + + +@support.requires_subprocess() +def run_test_script(script): + # use -u to try to get the full output if the test hangs or crash + if support.verbose: + def title(text): + return f"===== {text} ======" + + name = f"script {os.path.basename(script)}" + print() + print(title(name), flush=True) + # In verbose mode, the child process inherit stdout and stdout, + # to see output in realtime and reduce the risk of losing output. + args = [sys.executable, "-E", "-X", "faulthandler", "-u", script, "-v"] + proc = subprocess.run(args) + print(title(f"{name} completed: exit code {proc.returncode}"), + flush=True) + if proc.returncode: + raise AssertionError(f"{name} failed") + else: + assert_python_ok("-u", script, "-v") diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/socket_helper.py b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/socket_helper.py new file mode 100644 index 0000000000000000000000000000000000000000..ec6d1dee4e9d81611c4c50c27497f47ce387ca1c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/socket_helper.py @@ -0,0 +1,332 @@ +import contextlib +import errno +import socket +import subprocess +import sys +import unittest + +from .. import support +from . import warnings_helper + +HOST = "localhost" +HOSTv4 = "127.0.0.1" +HOSTv6 = "::1" + +# WASI SDK 15.0 does not provide gethostname, stub raises OSError ENOTSUP. +has_gethostname = not support.is_wasi + + +def find_unused_port(family=socket.AF_INET, socktype=socket.SOCK_STREAM): + """Returns an unused port that should be suitable for binding. This is + achieved by creating a temporary socket with the same family and type as + the 'sock' parameter (default is AF_INET, SOCK_STREAM), and binding it to + the specified host address (defaults to 0.0.0.0) with the port set to 0, + eliciting an unused ephemeral port from the OS. The temporary socket is + then closed and deleted, and the ephemeral port is returned. + + Either this method or bind_port() should be used for any tests where a + server socket needs to be bound to a particular port for the duration of + the test. Which one to use depends on whether the calling code is creating + a python socket, or if an unused port needs to be provided in a constructor + or passed to an external program (i.e. the -accept argument to openssl's + s_server mode). Always prefer bind_port() over find_unused_port() where + possible. Hard coded ports should *NEVER* be used. As soon as a server + socket is bound to a hard coded port, the ability to run multiple instances + of the test simultaneously on the same host is compromised, which makes the + test a ticking time bomb in a buildbot environment. On Unix buildbots, this + may simply manifest as a failed test, which can be recovered from without + intervention in most cases, but on Windows, the entire python process can + completely and utterly wedge, requiring someone to log in to the buildbot + and manually kill the affected process. + + (This is easy to reproduce on Windows, unfortunately, and can be traced to + the SO_REUSEADDR socket option having different semantics on Windows versus + Unix/Linux. On Unix, you can't have two AF_INET SOCK_STREAM sockets bind, + listen and then accept connections on identical host/ports. An EADDRINUSE + OSError will be raised at some point (depending on the platform and + the order bind and listen were called on each socket). + + However, on Windows, if SO_REUSEADDR is set on the sockets, no EADDRINUSE + will ever be raised when attempting to bind two identical host/ports. When + accept() is called on each socket, the second caller's process will steal + the port from the first caller, leaving them both in an awkwardly wedged + state where they'll no longer respond to any signals or graceful kills, and + must be forcibly killed via OpenProcess()/TerminateProcess(). + + The solution on Windows is to use the SO_EXCLUSIVEADDRUSE socket option + instead of SO_REUSEADDR, which effectively affords the same semantics as + SO_REUSEADDR on Unix. Given the propensity of Unix developers in the Open + Source world compared to Windows ones, this is a common mistake. A quick + look over OpenSSL's 0.9.8g source shows that they use SO_REUSEADDR when + openssl.exe is called with the 's_server' option, for example. See + http://bugs.python.org/issue2550 for more info. The following site also + has a very thorough description about the implications of both REUSEADDR + and EXCLUSIVEADDRUSE on Windows: + https://learn.microsoft.com/windows/win32/winsock/using-so-reuseaddr-and-so-exclusiveaddruse + + XXX: although this approach is a vast improvement on previous attempts to + elicit unused ports, it rests heavily on the assumption that the ephemeral + port returned to us by the OS won't immediately be dished back out to some + other process when we close and delete our temporary socket but before our + calling code has a chance to bind the returned port. We can deal with this + issue if/when we come across it. + """ + + with socket.socket(family, socktype) as tempsock: + port = bind_port(tempsock) + del tempsock + return port + +def bind_port(sock, host=HOST): + """Bind the socket to a free port and return the port number. Relies on + ephemeral ports in order to ensure we are using an unbound port. This is + important as many tests may be running simultaneously, especially in a + buildbot environment. This method raises an exception if the sock.family + is AF_INET and sock.type is SOCK_STREAM, *and* the socket has SO_REUSEADDR + or SO_REUSEPORT set on it. Tests should *never* set these socket options + for TCP/IP sockets. The only case for setting these options is testing + multicasting via multiple UDP sockets. + + Additionally, if the SO_EXCLUSIVEADDRUSE socket option is available (i.e. + on Windows), it will be set on the socket. This will prevent anyone else + from bind()'ing to our host/port for the duration of the test. + """ + + if sock.family == socket.AF_INET and sock.type == socket.SOCK_STREAM: + if hasattr(socket, 'SO_REUSEADDR'): + if sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) == 1: + raise support.TestFailed("tests should never set the " + "SO_REUSEADDR socket option on " + "TCP/IP sockets!") + if hasattr(socket, 'SO_REUSEPORT'): + try: + if sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT) == 1: + raise support.TestFailed("tests should never set the " + "SO_REUSEPORT socket option on " + "TCP/IP sockets!") + except OSError: + # Python's socket module was compiled using modern headers + # thus defining SO_REUSEPORT but this process is running + # under an older kernel that does not support SO_REUSEPORT. + pass + if hasattr(socket, 'SO_EXCLUSIVEADDRUSE'): + sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1) + + sock.bind((host, 0)) + port = sock.getsockname()[1] + return port + +def bind_unix_socket(sock, addr): + """Bind a unix socket, raising SkipTest if PermissionError is raised.""" + assert sock.family == socket.AF_UNIX + try: + sock.bind(addr) + except PermissionError: + sock.close() + raise unittest.SkipTest('cannot bind AF_UNIX sockets') + +def _is_ipv6_enabled(): + """Check whether IPv6 is enabled on this host.""" + if socket.has_ipv6: + sock = None + try: + sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM) + sock.bind((HOSTv6, 0)) + return True + except OSError: + pass + finally: + if sock: + sock.close() + return False + +IPV6_ENABLED = _is_ipv6_enabled() + + +_bind_nix_socket_error = None +def skip_unless_bind_unix_socket(test): + """Decorator for tests requiring a functional bind() for unix sockets.""" + if not hasattr(socket, 'AF_UNIX'): + return unittest.skip('No UNIX Sockets')(test) + global _bind_nix_socket_error + if _bind_nix_socket_error is None: + from .os_helper import TESTFN, unlink + path = TESTFN + "can_bind_unix_socket" + with socket.socket(socket.AF_UNIX) as sock: + try: + sock.bind(path) + _bind_nix_socket_error = False + except OSError as e: + _bind_nix_socket_error = e + finally: + unlink(path) + if _bind_nix_socket_error: + msg = 'Requires a functional unix bind(): %s' % _bind_nix_socket_error + return unittest.skip(msg)(test) + else: + return test + + +def get_socket_conn_refused_errs(): + """ + Get the different socket error numbers ('errno') which can be received + when a connection is refused. + """ + errors = [errno.ECONNREFUSED] + if hasattr(errno, 'ENETUNREACH'): + # On Solaris, ENETUNREACH is returned sometimes instead of ECONNREFUSED + errors.append(errno.ENETUNREACH) + if hasattr(errno, 'EADDRNOTAVAIL'): + # bpo-31910: socket.create_connection() fails randomly + # with EADDRNOTAVAIL on Travis CI + errors.append(errno.EADDRNOTAVAIL) + if hasattr(errno, 'EHOSTUNREACH'): + # bpo-37583: The destination host cannot be reached + errors.append(errno.EHOSTUNREACH) + if not IPV6_ENABLED: + errors.append(errno.EAFNOSUPPORT) + return errors + + +_NOT_SET = object() + +@contextlib.contextmanager +def transient_internet(resource_name, *, timeout=_NOT_SET, errnos=()): + """Return a context manager that raises ResourceDenied when various issues + with the internet connection manifest themselves as exceptions.""" + nntplib = warnings_helper.import_deprecated("nntplib") + import urllib.error + if timeout is _NOT_SET: + timeout = support.INTERNET_TIMEOUT + + default_errnos = [ + ('ECONNREFUSED', 111), + ('ECONNRESET', 104), + ('EHOSTUNREACH', 113), + ('ENETUNREACH', 101), + ('ETIMEDOUT', 110), + # socket.create_connection() fails randomly with + # EADDRNOTAVAIL on Travis CI. + ('EADDRNOTAVAIL', 99), + ] + default_gai_errnos = [ + ('EAI_AGAIN', -3), + ('EAI_FAIL', -4), + ('EAI_NONAME', -2), + ('EAI_NODATA', -5), + # Encountered when trying to resolve IPv6-only hostnames + ('WSANO_DATA', 11004), + ] + + denied = support.ResourceDenied("Resource %r is not available" % resource_name) + captured_errnos = errnos + gai_errnos = [] + if not captured_errnos: + captured_errnos = [getattr(errno, name, num) + for (name, num) in default_errnos] + gai_errnos = [getattr(socket, name, num) + for (name, num) in default_gai_errnos] + + def filter_error(err): + n = getattr(err, 'errno', None) + if (isinstance(err, TimeoutError) or + (isinstance(err, socket.gaierror) and n in gai_errnos) or + (isinstance(err, urllib.error.HTTPError) and + 500 <= err.code <= 599) or + (isinstance(err, urllib.error.URLError) and + (("ConnectionRefusedError" in err.reason) or + ("TimeoutError" in err.reason) or + ("EOFError" in err.reason))) or + n in captured_errnos): + if not support.verbose: + sys.stderr.write(denied.args[0] + "\n") + raise denied from err + + old_timeout = socket.getdefaulttimeout() + try: + if timeout is not None: + socket.setdefaulttimeout(timeout) + yield + except nntplib.NNTPTemporaryError as err: + if support.verbose: + sys.stderr.write(denied.args[0] + "\n") + raise denied from err + except OSError as err: + # urllib can wrap original socket errors multiple times (!), we must + # unwrap to get at the original error. + while True: + a = err.args + if len(a) >= 1 and isinstance(a[0], OSError): + err = a[0] + # The error can also be wrapped as args[1]: + # except socket.error as msg: + # raise OSError('socket error', msg) from msg + elif len(a) >= 2 and isinstance(a[1], OSError): + err = a[1] + else: + break + filter_error(err) + raise + # XXX should we catch generic exceptions and look for their + # __cause__ or __context__? + finally: + socket.setdefaulttimeout(old_timeout) + + +# consider that sysctl values should not change while tests are running +_sysctl_cache = {} + +def _get_sysctl(name): + """Get a sysctl value as an integer.""" + try: + return _sysctl_cache[name] + except KeyError: + pass + + # At least Linux and FreeBSD support the "-n" option + cmd = ['sysctl', '-n', name] + proc = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + text=True) + if proc.returncode: + support.print_warning(f"{' '.join(cmd)!r} command failed with " + f"exit code {proc.returncode}") + # cache the error to only log the warning once + _sysctl_cache[name] = None + return None + output = proc.stdout + + # Parse '0\n' to get '0' + try: + value = int(output.strip()) + except Exception as exc: + support.print_warning(f"Failed to parse {' '.join(cmd)!r} " + f"command output {output!r}: {exc!r}") + # cache the error to only log the warning once + _sysctl_cache[name] = None + return None + + _sysctl_cache[name] = value + return value + + +def tcp_blackhole(): + if not sys.platform.startswith('freebsd'): + return False + + # gh-109015: test if FreeBSD TCP blackhole is enabled + value = _get_sysctl('net.inet.tcp.blackhole') + if value is None: + # don't skip if we fail to get the sysctl value + return False + return (value != 0) + + +def skip_if_tcp_blackhole(test): + """Decorator skipping test if TCP blackhole is enabled.""" + skip_if = unittest.skipIf( + tcp_blackhole(), + "TCP blackhole is enabled (sysctl net.inet.tcp.blackhole)" + ) + return skip_if(test) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/threading_helper.py b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/threading_helper.py new file mode 100644 index 0000000000000000000000000000000000000000..6815ab36ec7a9f7bca6b8a1eb8894f71e3b8943b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/threading_helper.py @@ -0,0 +1,245 @@ +import _thread +import contextlib +import functools +import sys +import threading +import time +import unittest + +from test import support + + +#======================================================================= +# Threading support to prevent reporting refleaks when running regrtest.py -R + +# NOTE: we use thread._count() rather than threading.enumerate() (or the +# moral equivalent thereof) because a threading.Thread object is still alive +# until its __bootstrap() method has returned, even after it has been +# unregistered from the threading module. +# thread._count(), on the other hand, only gets decremented *after* the +# __bootstrap() method has returned, which gives us reliable reference counts +# at the end of a test run. + + +def threading_setup(): + return _thread._count(), len(threading._dangling) + + +def threading_cleanup(*original_values): + orig_count, orig_ndangling = original_values + + timeout = 1.0 + for _ in support.sleeping_retry(timeout, error=False): + # Copy the thread list to get a consistent output. threading._dangling + # is a WeakSet, its value changes when it's read. + dangling_threads = list(threading._dangling) + count = _thread._count() + + if count <= orig_count: + return + + # Timeout! + support.environment_altered = True + support.print_warning( + f"threading_cleanup() failed to clean up threads " + f"in {timeout:.1f} seconds\n" + f" before: thread count={orig_count}, dangling={orig_ndangling}\n" + f" after: thread count={count}, dangling={len(dangling_threads)}") + for thread in dangling_threads: + support.print_warning(f"Dangling thread: {thread!r}") + + # The warning happens when a test spawns threads and some of these threads + # are still running after the test completes. To fix this warning, join + # threads explicitly to wait until they complete. + # + # To make the warning more likely, reduce the timeout. + + +def reap_threads(func): + """Use this function when threads are being used. This will + ensure that the threads are cleaned up even when the test fails. + """ + @functools.wraps(func) + def decorator(*args): + key = threading_setup() + try: + return func(*args) + finally: + threading_cleanup(*key) + return decorator + + +@contextlib.contextmanager +def wait_threads_exit(timeout=None): + """ + bpo-31234: Context manager to wait until all threads created in the with + statement exit. + + Use _thread.count() to check if threads exited. Indirectly, wait until + threads exit the internal t_bootstrap() C function of the _thread module. + + threading_setup() and threading_cleanup() are designed to emit a warning + if a test leaves running threads in the background. This context manager + is designed to cleanup threads started by the _thread.start_new_thread() + which doesn't allow to wait for thread exit, whereas thread.Thread has a + join() method. + """ + if timeout is None: + timeout = support.SHORT_TIMEOUT + old_count = _thread._count() + try: + yield + finally: + start_time = time.monotonic() + for _ in support.sleeping_retry(timeout, error=False): + support.gc_collect() + count = _thread._count() + if count <= old_count: + break + else: + dt = time.monotonic() - start_time + msg = (f"wait_threads() failed to cleanup {count - old_count} " + f"threads after {dt:.1f} seconds " + f"(count: {count}, old count: {old_count})") + raise AssertionError(msg) + + +def join_thread(thread, timeout=None): + """Join a thread. Raise an AssertionError if the thread is still alive + after timeout seconds. + """ + if timeout is None: + timeout = support.SHORT_TIMEOUT + thread.join(timeout) + if thread.is_alive(): + msg = f"failed to join the thread in {timeout:.1f} seconds" + raise AssertionError(msg) + + +@contextlib.contextmanager +def start_threads(threads, unlock=None): + import faulthandler + threads = list(threads) + started = [] + try: + try: + for t in threads: + t.start() + started.append(t) + except: + if support.verbose: + print("Can't start %d threads, only %d threads started" % + (len(threads), len(started))) + raise + yield + finally: + try: + if unlock: + unlock() + endtime = time.monotonic() + for timeout in range(1, 16): + endtime += 60 + for t in started: + t.join(max(endtime - time.monotonic(), 0.01)) + started = [t for t in started if t.is_alive()] + if not started: + break + if support.verbose: + print('Unable to join %d threads during a period of ' + '%d minutes' % (len(started), timeout)) + finally: + started = [t for t in started if t.is_alive()] + if started: + faulthandler.dump_traceback(sys.stdout) + raise AssertionError('Unable to join %d threads' % len(started)) + + +class catch_threading_exception: + """ + Context manager catching threading.Thread exception using + threading.excepthook. + + Attributes set when an exception is caught: + + * exc_type + * exc_value + * exc_traceback + * thread + + See threading.excepthook() documentation for these attributes. + + These attributes are deleted at the context manager exit. + + Usage: + + with threading_helper.catch_threading_exception() as cm: + # code spawning a thread which raises an exception + ... + + # check the thread exception, use cm attributes: + # exc_type, exc_value, exc_traceback, thread + ... + + # exc_type, exc_value, exc_traceback, thread attributes of cm no longer + # exists at this point + # (to avoid reference cycles) + """ + + def __init__(self): + self.exc_type = None + self.exc_value = None + self.exc_traceback = None + self.thread = None + self._old_hook = None + + def _hook(self, args): + self.exc_type = args.exc_type + self.exc_value = args.exc_value + self.exc_traceback = args.exc_traceback + self.thread = args.thread + + def __enter__(self): + self._old_hook = threading.excepthook + threading.excepthook = self._hook + return self + + def __exit__(self, *exc_info): + threading.excepthook = self._old_hook + del self.exc_type + del self.exc_value + del self.exc_traceback + del self.thread + + +def _can_start_thread() -> bool: + """Detect whether Python can start new threads. + + Some WebAssembly platforms do not provide a working pthread + implementation. Thread support is stubbed and any attempt + to create a new thread fails. + + - wasm32-wasi does not have threading. + - wasm32-emscripten can be compiled with or without pthread + support (-s USE_PTHREADS / __EMSCRIPTEN_PTHREADS__). + """ + if sys.platform == "emscripten": + return sys._emscripten_info.pthreads + elif sys.platform == "wasi": + return False + else: + # assume all other platforms have working thread support. + return True + +can_start_thread = _can_start_thread() + +def requires_working_threading(*, module=False): + """Skip tests or modules that require working threading. + + Can be used as a function/class decorator or to skip an entire module. + """ + msg = "requires threading support" + if module: + if not can_start_thread: + raise unittest.SkipTest(msg) + else: + return unittest.skipUnless(can_start_thread, msg) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/warnings_helper.py b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/warnings_helper.py new file mode 100644 index 0000000000000000000000000000000000000000..c1bf05623006784d4d09345a2017bcade20c8d29 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/test/support/warnings_helper.py @@ -0,0 +1,207 @@ +import contextlib +import functools +import importlib +import re +import sys +import warnings + + +def import_deprecated(name): + """Import *name* while suppressing DeprecationWarning.""" + with warnings.catch_warnings(): + warnings.simplefilter('ignore', category=DeprecationWarning) + return importlib.import_module(name) + + +def check_syntax_warning(testcase, statement, errtext='', + *, lineno=1, offset=None): + # Test also that a warning is emitted only once. + from test.support import check_syntax_error + with warnings.catch_warnings(record=True) as warns: + warnings.simplefilter('always', SyntaxWarning) + compile(statement, '', 'exec') + testcase.assertEqual(len(warns), 1, warns) + + warn, = warns + testcase.assertTrue(issubclass(warn.category, SyntaxWarning), + warn.category) + if errtext: + testcase.assertRegex(str(warn.message), errtext) + testcase.assertEqual(warn.filename, '') + testcase.assertIsNotNone(warn.lineno) + if lineno is not None: + testcase.assertEqual(warn.lineno, lineno) + + # SyntaxWarning should be converted to SyntaxError when raised, + # since the latter contains more information and provides better + # error report. + with warnings.catch_warnings(record=True) as warns: + warnings.simplefilter('error', SyntaxWarning) + check_syntax_error(testcase, statement, errtext, + lineno=lineno, offset=offset) + # No warnings are leaked when a SyntaxError is raised. + testcase.assertEqual(warns, []) + + +def ignore_warnings(*, category): + """Decorator to suppress warnings. + + Use of context managers to hide warnings make diffs + more noisy and tools like 'git blame' less useful. + """ + def decorator(test): + @functools.wraps(test) + def wrapper(self, *args, **kwargs): + with warnings.catch_warnings(): + warnings.simplefilter('ignore', category=category) + return test(self, *args, **kwargs) + return wrapper + return decorator + + +class WarningsRecorder(object): + """Convenience wrapper for the warnings list returned on + entry to the warnings.catch_warnings() context manager. + """ + def __init__(self, warnings_list): + self._warnings = warnings_list + self._last = 0 + + def __getattr__(self, attr): + if len(self._warnings) > self._last: + return getattr(self._warnings[-1], attr) + elif attr in warnings.WarningMessage._WARNING_DETAILS: + return None + raise AttributeError("%r has no attribute %r" % (self, attr)) + + @property + def warnings(self): + return self._warnings[self._last:] + + def reset(self): + self._last = len(self._warnings) + + +@contextlib.contextmanager +def check_warnings(*filters, **kwargs): + """Context manager to silence warnings. + + Accept 2-tuples as positional arguments: + ("message regexp", WarningCategory) + + Optional argument: + - if 'quiet' is True, it does not fail if a filter catches nothing + (default True without argument, + default False if some filters are defined) + + Without argument, it defaults to: + check_warnings(("", Warning), quiet=True) + """ + quiet = kwargs.get('quiet') + if not filters: + filters = (("", Warning),) + # Preserve backward compatibility + if quiet is None: + quiet = True + return _filterwarnings(filters, quiet) + + +@contextlib.contextmanager +def check_no_warnings(testcase, message='', category=Warning, force_gc=False): + """Context manager to check that no warnings are emitted. + + This context manager enables a given warning within its scope + and checks that no warnings are emitted even with that warning + enabled. + + If force_gc is True, a garbage collection is attempted before checking + for warnings. This may help to catch warnings emitted when objects + are deleted, such as ResourceWarning. + + Other keyword arguments are passed to warnings.filterwarnings(). + """ + from test.support import gc_collect + with warnings.catch_warnings(record=True) as warns: + warnings.filterwarnings('always', + message=message, + category=category) + yield + if force_gc: + gc_collect() + testcase.assertEqual(warns, []) + + +@contextlib.contextmanager +def check_no_resource_warning(testcase): + """Context manager to check that no ResourceWarning is emitted. + + Usage: + + with check_no_resource_warning(self): + f = open(...) + ... + del f + + You must remove the object which may emit ResourceWarning before + the end of the context manager. + """ + with check_no_warnings(testcase, category=ResourceWarning, force_gc=True): + yield + + +def _filterwarnings(filters, quiet=False): + """Catch the warnings, then check if all the expected + warnings have been raised and re-raise unexpected warnings. + If 'quiet' is True, only re-raise the unexpected warnings. + """ + # Clear the warning registry of the calling module + # in order to re-raise the warnings. + frame = sys._getframe(2) + registry = frame.f_globals.get('__warningregistry__') + if registry: + registry.clear() + with warnings.catch_warnings(record=True) as w: + # Set filter "always" to record all warnings. Because + # test_warnings swap the module, we need to look up in + # the sys.modules dictionary. + sys.modules['warnings'].simplefilter("always") + yield WarningsRecorder(w) + # Filter the recorded warnings + reraise = list(w) + missing = [] + for msg, cat in filters: + seen = False + for w in reraise[:]: + warning = w.message + # Filter out the matching messages + if (re.match(msg, str(warning), re.I) and + issubclass(warning.__class__, cat)): + seen = True + reraise.remove(w) + if not seen and not quiet: + # This filter caught nothing + missing.append((msg, cat.__name__)) + if reraise: + raise AssertionError("unhandled warning %s" % reraise[0]) + if missing: + raise AssertionError("filter (%r, %s) did not catch any warning" % + missing[0]) + + +@contextlib.contextmanager +def save_restore_warnings_filters(): + old_filters = warnings.filters[:] + try: + yield + finally: + warnings.filters[:] = old_filters + + +def _warn_about_deprecation(): + warnings.warn( + "This is used in test_support test to ensure" + " support.ignore_deprecations_from() works as expected." + " You should not be seeing this.", + DeprecationWarning, + stacklevel=0, + ) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/test_script_helper.py b/physworld_p1_20261018/envs/p1/lib/python3.11/test/test_script_helper.py new file mode 100644 index 0000000000000000000000000000000000000000..f7871fd3b77c02d11444e6f921aa9995c544ee5e --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/test/test_script_helper.py @@ -0,0 +1,126 @@ +"""Unittests for test.support.script_helper. Who tests the test helper?""" + +import subprocess +import sys +import os +from test.support import script_helper, requires_subprocess +import unittest +from unittest import mock + + +class TestScriptHelper(unittest.TestCase): + + def test_assert_python_ok(self): + t = script_helper.assert_python_ok('-c', 'import sys; sys.exit(0)') + self.assertEqual(0, t[0], 'return code was not 0') + + def test_assert_python_failure(self): + # I didn't import the sys module so this child will fail. + rc, out, err = script_helper.assert_python_failure('-c', 'sys.exit(0)') + self.assertNotEqual(0, rc, 'return code should not be 0') + + def test_assert_python_ok_raises(self): + # I didn't import the sys module so this child will fail. + with self.assertRaises(AssertionError) as error_context: + script_helper.assert_python_ok('-c', 'sys.exit(0)') + error_msg = str(error_context.exception) + self.assertIn('command line:', error_msg) + self.assertIn('sys.exit(0)', error_msg, msg='unexpected command line') + + def test_assert_python_failure_raises(self): + with self.assertRaises(AssertionError) as error_context: + script_helper.assert_python_failure('-c', 'import sys; sys.exit(0)') + error_msg = str(error_context.exception) + self.assertIn('Process return code is 0\n', error_msg) + self.assertIn('import sys; sys.exit(0)', error_msg, + msg='unexpected command line.') + + @mock.patch('subprocess.Popen') + def test_assert_python_isolated_when_env_not_required(self, mock_popen): + with mock.patch.object(script_helper, + 'interpreter_requires_environment', + return_value=False) as mock_ire_func: + mock_popen.side_effect = RuntimeError('bail out of unittest') + try: + script_helper._assert_python(True, '-c', 'None') + except RuntimeError as err: + self.assertEqual('bail out of unittest', err.args[0]) + self.assertEqual(1, mock_popen.call_count) + self.assertEqual(1, mock_ire_func.call_count) + popen_command = mock_popen.call_args[0][0] + self.assertEqual(sys.executable, popen_command[0]) + self.assertIn('None', popen_command) + self.assertIn('-I', popen_command) + self.assertNotIn('-E', popen_command) # -I overrides this + + @mock.patch('subprocess.Popen') + def test_assert_python_not_isolated_when_env_is_required(self, mock_popen): + """Ensure that -I is not passed when the environment is required.""" + with mock.patch.object(script_helper, + 'interpreter_requires_environment', + return_value=True) as mock_ire_func: + mock_popen.side_effect = RuntimeError('bail out of unittest') + try: + script_helper._assert_python(True, '-c', 'None') + except RuntimeError as err: + self.assertEqual('bail out of unittest', err.args[0]) + popen_command = mock_popen.call_args[0][0] + self.assertNotIn('-I', popen_command) + self.assertNotIn('-E', popen_command) + + +@requires_subprocess() +class TestScriptHelperEnvironment(unittest.TestCase): + """Code coverage for interpreter_requires_environment().""" + + def setUp(self): + self.assertTrue( + hasattr(script_helper, '__cached_interp_requires_environment')) + # Reset the private cached state. + script_helper.__dict__['__cached_interp_requires_environment'] = None + + def tearDown(self): + # Reset the private cached state. + script_helper.__dict__['__cached_interp_requires_environment'] = None + + @mock.patch('subprocess.check_call') + def test_interpreter_requires_environment_true(self, mock_check_call): + with mock.patch.dict(os.environ): + os.environ.pop('PYTHONHOME', None) + mock_check_call.side_effect = subprocess.CalledProcessError('', '') + self.assertTrue(script_helper.interpreter_requires_environment()) + self.assertTrue(script_helper.interpreter_requires_environment()) + self.assertEqual(1, mock_check_call.call_count) + + @mock.patch('subprocess.check_call') + def test_interpreter_requires_environment_false(self, mock_check_call): + with mock.patch.dict(os.environ): + os.environ.pop('PYTHONHOME', None) + # The mocked subprocess.check_call fakes a no-error process. + script_helper.interpreter_requires_environment() + self.assertFalse(script_helper.interpreter_requires_environment()) + self.assertEqual(1, mock_check_call.call_count) + + @mock.patch('subprocess.check_call') + def test_interpreter_requires_environment_details(self, mock_check_call): + with mock.patch.dict(os.environ): + os.environ.pop('PYTHONHOME', None) + script_helper.interpreter_requires_environment() + self.assertFalse(script_helper.interpreter_requires_environment()) + self.assertFalse(script_helper.interpreter_requires_environment()) + self.assertEqual(1, mock_check_call.call_count) + check_call_command = mock_check_call.call_args[0][0] + self.assertEqual(sys.executable, check_call_command[0]) + self.assertIn('-E', check_call_command) + + @mock.patch('subprocess.check_call') + def test_interpreter_requires_environment_with_pythonhome(self, mock_check_call): + with mock.patch.dict(os.environ): + os.environ['PYTHONHOME'] = 'MockedHome' + self.assertTrue(script_helper.interpreter_requires_environment()) + self.assertTrue(script_helper.interpreter_requires_environment()) + self.assertEqual(0, mock_check_call.call_count) + + +if __name__ == '__main__': + unittest.main() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/test/test_support.py b/physworld_p1_20261018/envs/p1/lib/python3.11/test/test_support.py new file mode 100644 index 0000000000000000000000000000000000000000..147ae5771751299afa5426478499df27a3e3abbf --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/test/test_support.py @@ -0,0 +1,772 @@ +import errno +import importlib +import io +import os +import shutil +import socket +import stat +import subprocess +import sys +import sysconfig +import tempfile +import textwrap +import unittest +import warnings + +from test import support +from test.support import import_helper +from test.support import os_helper +from test.support import script_helper +from test.support import socket_helper +from test.support import warnings_helper + +TESTFN = os_helper.TESTFN + + +class TestSupport(unittest.TestCase): + @classmethod + def setUpClass(cls): + orig_filter_len = len(warnings.filters) + cls._warnings_helper_token = support.ignore_deprecations_from( + "test.support.warnings_helper", like=".*used in test_support.*" + ) + cls._test_support_token = support.ignore_deprecations_from( + __name__, like=".*You should NOT be seeing this.*" + ) + assert len(warnings.filters) == orig_filter_len + 2 + + @classmethod + def tearDownClass(cls): + orig_filter_len = len(warnings.filters) + support.clear_ignored_deprecations( + cls._warnings_helper_token, + cls._test_support_token, + ) + assert len(warnings.filters) == orig_filter_len - 2 + + def test_ignored_deprecations_are_silent(self): + """Test support.ignore_deprecations_from() silences warnings""" + with warnings.catch_warnings(record=True) as warning_objs: + warnings_helper._warn_about_deprecation() + warnings.warn("You should NOT be seeing this.", DeprecationWarning) + messages = [str(w.message) for w in warning_objs] + self.assertEqual(len(messages), 0, messages) + + def test_import_module(self): + import_helper.import_module("ftplib") + self.assertRaises(unittest.SkipTest, + import_helper.import_module, "foo") + + def test_import_fresh_module(self): + import_helper.import_fresh_module("ftplib") + + def test_get_attribute(self): + self.assertEqual(support.get_attribute(self, "test_get_attribute"), + self.test_get_attribute) + self.assertRaises(unittest.SkipTest, support.get_attribute, self, "foo") + + @unittest.skip("failing buildbots") + def test_get_original_stdout(self): + self.assertEqual(support.get_original_stdout(), sys.stdout) + + def test_unload(self): + import sched + self.assertIn("sched", sys.modules) + import_helper.unload("sched") + self.assertNotIn("sched", sys.modules) + + def test_unlink(self): + with open(TESTFN, "w", encoding="utf-8") as f: + pass + os_helper.unlink(TESTFN) + self.assertFalse(os.path.exists(TESTFN)) + os_helper.unlink(TESTFN) + + def test_rmtree(self): + dirpath = os_helper.TESTFN + 'd' + subdirpath = os.path.join(dirpath, 'subdir') + os.mkdir(dirpath) + os.mkdir(subdirpath) + os_helper.rmtree(dirpath) + self.assertFalse(os.path.exists(dirpath)) + with support.swap_attr(support, 'verbose', 0): + os_helper.rmtree(dirpath) + + os.mkdir(dirpath) + os.mkdir(subdirpath) + os.chmod(dirpath, stat.S_IRUSR|stat.S_IXUSR) + with support.swap_attr(support, 'verbose', 0): + os_helper.rmtree(dirpath) + self.assertFalse(os.path.exists(dirpath)) + + os.mkdir(dirpath) + os.mkdir(subdirpath) + os.chmod(dirpath, 0) + with support.swap_attr(support, 'verbose', 0): + os_helper.rmtree(dirpath) + self.assertFalse(os.path.exists(dirpath)) + + def test_forget(self): + mod_filename = TESTFN + '.py' + with open(mod_filename, 'w', encoding="utf-8") as f: + print('foo = 1', file=f) + sys.path.insert(0, os.curdir) + importlib.invalidate_caches() + try: + mod = __import__(TESTFN) + self.assertIn(TESTFN, sys.modules) + + import_helper.forget(TESTFN) + self.assertNotIn(TESTFN, sys.modules) + finally: + del sys.path[0] + os_helper.unlink(mod_filename) + os_helper.rmtree('__pycache__') + + @support.requires_working_socket() + def test_HOST(self): + s = socket.create_server((socket_helper.HOST, 0)) + s.close() + + @support.requires_working_socket() + def test_find_unused_port(self): + port = socket_helper.find_unused_port() + s = socket.create_server((socket_helper.HOST, port)) + s.close() + + @support.requires_working_socket() + def test_bind_port(self): + s = socket.socket() + socket_helper.bind_port(s) + s.listen() + s.close() + + # Tests for temp_dir() + + def test_temp_dir(self): + """Test that temp_dir() creates and destroys its directory.""" + parent_dir = tempfile.mkdtemp() + parent_dir = os.path.realpath(parent_dir) + + try: + path = os.path.join(parent_dir, 'temp') + self.assertFalse(os.path.isdir(path)) + with os_helper.temp_dir(path) as temp_path: + self.assertEqual(temp_path, path) + self.assertTrue(os.path.isdir(path)) + self.assertFalse(os.path.isdir(path)) + finally: + os_helper.rmtree(parent_dir) + + def test_temp_dir__path_none(self): + """Test passing no path.""" + with os_helper.temp_dir() as temp_path: + self.assertTrue(os.path.isdir(temp_path)) + self.assertFalse(os.path.isdir(temp_path)) + + def test_temp_dir__existing_dir__quiet_default(self): + """Test passing a directory that already exists.""" + def call_temp_dir(path): + with os_helper.temp_dir(path) as temp_path: + raise Exception("should not get here") + + path = tempfile.mkdtemp() + path = os.path.realpath(path) + try: + self.assertTrue(os.path.isdir(path)) + self.assertRaises(FileExistsError, call_temp_dir, path) + # Make sure temp_dir did not delete the original directory. + self.assertTrue(os.path.isdir(path)) + finally: + shutil.rmtree(path) + + def test_temp_dir__existing_dir__quiet_true(self): + """Test passing a directory that already exists with quiet=True.""" + path = tempfile.mkdtemp() + path = os.path.realpath(path) + + try: + with warnings_helper.check_warnings() as recorder: + with os_helper.temp_dir(path, quiet=True) as temp_path: + self.assertEqual(path, temp_path) + warnings = [str(w.message) for w in recorder.warnings] + # Make sure temp_dir did not delete the original directory. + self.assertTrue(os.path.isdir(path)) + finally: + shutil.rmtree(path) + + self.assertEqual(len(warnings), 1, warnings) + warn = warnings[0] + self.assertTrue(warn.startswith(f'tests may fail, unable to create ' + f'temporary directory {path!r}: '), + warn) + + @support.requires_fork() + def test_temp_dir__forked_child(self): + """Test that a forked child process does not remove the directory.""" + # See bpo-30028 for details. + # Run the test as an external script, because it uses fork. + script_helper.assert_python_ok("-c", textwrap.dedent(""" + import os + from test import support + from test.support import os_helper + with os_helper.temp_cwd() as temp_path: + pid = os.fork() + if pid != 0: + # parent process + + # wait for the child to terminate + support.wait_process(pid, exitcode=0) + + # Make sure that temp_path is still present. When the child + # process leaves the 'temp_cwd'-context, the __exit__()- + # method of the context must not remove the temporary + # directory. + if not os.path.isdir(temp_path): + raise AssertionError("Child removed temp_path.") + """)) + + # Tests for change_cwd() + + def test_change_cwd(self): + original_cwd = os.getcwd() + + with os_helper.temp_dir() as temp_path: + with os_helper.change_cwd(temp_path) as new_cwd: + self.assertEqual(new_cwd, temp_path) + self.assertEqual(os.getcwd(), new_cwd) + + self.assertEqual(os.getcwd(), original_cwd) + + def test_change_cwd__non_existent_dir(self): + """Test passing a non-existent directory.""" + original_cwd = os.getcwd() + + def call_change_cwd(path): + with os_helper.change_cwd(path) as new_cwd: + raise Exception("should not get here") + + with os_helper.temp_dir() as parent_dir: + non_existent_dir = os.path.join(parent_dir, 'does_not_exist') + self.assertRaises(FileNotFoundError, call_change_cwd, + non_existent_dir) + + self.assertEqual(os.getcwd(), original_cwd) + + def test_change_cwd__non_existent_dir__quiet_true(self): + """Test passing a non-existent directory with quiet=True.""" + original_cwd = os.getcwd() + + with os_helper.temp_dir() as parent_dir: + bad_dir = os.path.join(parent_dir, 'does_not_exist') + with warnings_helper.check_warnings() as recorder: + with os_helper.change_cwd(bad_dir, quiet=True) as new_cwd: + self.assertEqual(new_cwd, original_cwd) + self.assertEqual(os.getcwd(), new_cwd) + warnings = [str(w.message) for w in recorder.warnings] + + self.assertEqual(len(warnings), 1, warnings) + warn = warnings[0] + self.assertTrue(warn.startswith(f'tests may fail, unable to change ' + f'the current working directory ' + f'to {bad_dir!r}: '), + warn) + + # Tests for change_cwd() + + def test_change_cwd__chdir_warning(self): + """Check the warning message when os.chdir() fails.""" + path = TESTFN + '_does_not_exist' + with warnings_helper.check_warnings() as recorder: + with os_helper.change_cwd(path=path, quiet=True): + pass + messages = [str(w.message) for w in recorder.warnings] + + self.assertEqual(len(messages), 1, messages) + msg = messages[0] + self.assertTrue(msg.startswith(f'tests may fail, unable to change ' + f'the current working directory ' + f'to {path!r}: '), + msg) + + # Tests for temp_cwd() + + def test_temp_cwd(self): + here = os.getcwd() + with os_helper.temp_cwd(name=TESTFN): + self.assertEqual(os.path.basename(os.getcwd()), TESTFN) + self.assertFalse(os.path.exists(TESTFN)) + self.assertEqual(os.getcwd(), here) + + + def test_temp_cwd__name_none(self): + """Test passing None to temp_cwd().""" + original_cwd = os.getcwd() + with os_helper.temp_cwd(name=None) as new_cwd: + self.assertNotEqual(new_cwd, original_cwd) + self.assertTrue(os.path.isdir(new_cwd)) + self.assertEqual(os.getcwd(), new_cwd) + self.assertEqual(os.getcwd(), original_cwd) + + def test_sortdict(self): + self.assertEqual(support.sortdict({3:3, 2:2, 1:1}), "{1: 1, 2: 2, 3: 3}") + + def test_make_bad_fd(self): + fd = os_helper.make_bad_fd() + with self.assertRaises(OSError) as cm: + os.write(fd, b"foo") + self.assertEqual(cm.exception.errno, errno.EBADF) + + def test_check_syntax_error(self): + support.check_syntax_error(self, "def class", lineno=1, offset=5) + with self.assertRaises(AssertionError): + support.check_syntax_error(self, "x=1") + + def test_CleanImport(self): + import importlib + with import_helper.CleanImport("pprint"): + importlib.import_module("pprint") + + def test_DirsOnSysPath(self): + with import_helper.DirsOnSysPath('foo', 'bar'): + self.assertIn("foo", sys.path) + self.assertIn("bar", sys.path) + self.assertNotIn("foo", sys.path) + self.assertNotIn("bar", sys.path) + + def test_captured_stdout(self): + with support.captured_stdout() as stdout: + print("hello") + self.assertEqual(stdout.getvalue(), "hello\n") + + def test_captured_stderr(self): + with support.captured_stderr() as stderr: + print("hello", file=sys.stderr) + self.assertEqual(stderr.getvalue(), "hello\n") + + def test_captured_stdin(self): + with support.captured_stdin() as stdin: + stdin.write('hello\n') + stdin.seek(0) + # call test code that consumes from sys.stdin + captured = input() + self.assertEqual(captured, "hello") + + def test_gc_collect(self): + support.gc_collect() + + def test_python_is_optimized(self): + self.assertIsInstance(support.python_is_optimized(), bool) + + def test_swap_attr(self): + class Obj: + pass + obj = Obj() + obj.x = 1 + with support.swap_attr(obj, "x", 5) as x: + self.assertEqual(obj.x, 5) + self.assertEqual(x, 1) + self.assertEqual(obj.x, 1) + with support.swap_attr(obj, "y", 5) as y: + self.assertEqual(obj.y, 5) + self.assertIsNone(y) + self.assertFalse(hasattr(obj, 'y')) + with support.swap_attr(obj, "y", 5): + del obj.y + self.assertFalse(hasattr(obj, 'y')) + + def test_swap_item(self): + D = {"x":1} + with support.swap_item(D, "x", 5) as x: + self.assertEqual(D["x"], 5) + self.assertEqual(x, 1) + self.assertEqual(D["x"], 1) + with support.swap_item(D, "y", 5) as y: + self.assertEqual(D["y"], 5) + self.assertIsNone(y) + self.assertNotIn("y", D) + with support.swap_item(D, "y", 5): + del D["y"] + self.assertNotIn("y", D) + + class RefClass: + attribute1 = None + attribute2 = None + _hidden_attribute1 = None + __magic_1__ = None + + class OtherClass: + attribute2 = None + attribute3 = None + __magic_1__ = None + __magic_2__ = None + + def test_detect_api_mismatch(self): + missing_items = support.detect_api_mismatch(self.RefClass, + self.OtherClass) + self.assertEqual({'attribute1'}, missing_items) + + missing_items = support.detect_api_mismatch(self.OtherClass, + self.RefClass) + self.assertEqual({'attribute3', '__magic_2__'}, missing_items) + + def test_detect_api_mismatch__ignore(self): + ignore = ['attribute1', 'attribute3', '__magic_2__', 'not_in_either'] + + missing_items = support.detect_api_mismatch( + self.RefClass, self.OtherClass, ignore=ignore) + self.assertEqual(set(), missing_items) + + missing_items = support.detect_api_mismatch( + self.OtherClass, self.RefClass, ignore=ignore) + self.assertEqual(set(), missing_items) + + def test_check__all__(self): + extra = {'tempdir'} + not_exported = {'template'} + support.check__all__(self, + tempfile, + extra=extra, + not_exported=not_exported) + + extra = { + 'TextTestResult', + 'findTestCases', + 'getTestCaseNames', + 'installHandler', + 'makeSuite', + } + not_exported = {'load_tests', "TestProgram", "BaseTestSuite"} + support.check__all__(self, + unittest, + ("unittest.result", "unittest.case", + "unittest.suite", "unittest.loader", + "unittest.main", "unittest.runner", + "unittest.signals", "unittest.async_case"), + extra=extra, + not_exported=not_exported) + + self.assertRaises(AssertionError, support.check__all__, self, unittest) + + @unittest.skipUnless(hasattr(os, 'waitpid') and hasattr(os, 'WNOHANG'), + 'need os.waitpid() and os.WNOHANG') + @support.requires_fork() + def test_reap_children(self): + # Make sure that there is no other pending child process + support.reap_children() + + # Create a child process + pid = os.fork() + if pid == 0: + # child process: do nothing, just exit + os._exit(0) + + was_altered = support.environment_altered + try: + support.environment_altered = False + stderr = io.StringIO() + + for _ in support.sleeping_retry(support.SHORT_TIMEOUT): + with support.swap_attr(support.print_warning, 'orig_stderr', stderr): + support.reap_children() + + # Use environment_altered to check if reap_children() found + # the child process + if support.environment_altered: + break + + msg = "Warning -- reap_children() reaped child process %s" % pid + self.assertIn(msg, stderr.getvalue()) + self.assertTrue(support.environment_altered) + finally: + support.environment_altered = was_altered + + # Just in case, check again that there is no other + # pending child process + support.reap_children() + + @support.requires_subprocess() + def check_options(self, args, func, expected=None): + code = f'from test.support import {func}; print(repr({func}()))' + cmd = [sys.executable, *args, '-c', code] + env = {key: value for key, value in os.environ.items() + if not key.startswith('PYTHON')} + proc = subprocess.run(cmd, + stdout=subprocess.PIPE, + stderr=subprocess.DEVNULL, + universal_newlines=True, + env=env) + if expected is None: + expected = args + self.assertEqual(proc.stdout.rstrip(), repr(expected)) + self.assertEqual(proc.returncode, 0) + + @support.requires_resource('cpu') + def test_args_from_interpreter_flags(self): + # Test test.support.args_from_interpreter_flags() + for opts in ( + # no option + [], + # single option + ['-B'], + ['-s'], + ['-S'], + ['-E'], + ['-v'], + ['-b'], + ['-P'], + ['-q'], + ['-I'], + # same option multiple times + ['-bb'], + ['-vvv'], + # -W options + ['-Wignore'], + # -X options + ['-X', 'dev'], + ['-Wignore', '-X', 'dev'], + ['-X', 'faulthandler'], + ['-X', 'importtime'], + ['-X', 'showrefcount'], + ['-X', 'tracemalloc'], + ['-X', 'tracemalloc=3'], + ): + with self.subTest(opts=opts): + self.check_options(opts, 'args_from_interpreter_flags') + + self.check_options(['-I', '-E', '-s', '-P'], + 'args_from_interpreter_flags', + ['-I']) + + def test_optim_args_from_interpreter_flags(self): + # Test test.support.optim_args_from_interpreter_flags() + for opts in ( + # no option + [], + ['-O'], + ['-OO'], + ['-OOOO'], + ): + with self.subTest(opts=opts): + self.check_options(opts, 'optim_args_from_interpreter_flags') + + @unittest.skipIf(support.is_emscripten, "Unstable in Emscripten") + @unittest.skipIf(support.is_wasi, "Unavailable on WASI") + def test_fd_count(self): + # We cannot test the absolute value of fd_count(): on old Linux + # kernel or glibc versions, os.urandom() keeps a FD open on + # /dev/urandom device and Python has 4 FD opens instead of 3. + # Test is unstable on Emscripten. The platform starts and stops + # background threads that use pipes and epoll fds. + start = os_helper.fd_count() + fd = os.open(__file__, os.O_RDONLY) + try: + more = os_helper.fd_count() + finally: + os.close(fd) + self.assertEqual(more - start, 1) + + def check_print_warning(self, msg, expected): + stderr = io.StringIO() + with support.swap_attr(support.print_warning, 'orig_stderr', stderr): + support.print_warning(msg) + self.assertEqual(stderr.getvalue(), expected) + + def test_print_warning(self): + self.check_print_warning("msg", + "Warning -- msg\n") + self.check_print_warning("a\nb", + 'Warning -- a\nWarning -- b\n') + + def test_has_strftime_extensions(self): + if support.is_emscripten or sys.platform == "win32": + self.assertFalse(support.has_strftime_extensions) + else: + self.assertTrue(support.has_strftime_extensions) + + def test_get_recursion_depth(self): + # test support.get_recursion_depth() + code = textwrap.dedent(""" + from test import support + import sys + try: + from _testcapi import USE_STACKCHECK + except ImportError: + USE_STACKCHECK = False + + def check(cond): + if not cond: + raise AssertionError("test failed") + + # depth 1 + check(support.get_recursion_depth() == 1) + + # depth 2 + def test_func(): + check(support.get_recursion_depth() == 2) + test_func() + + def test_recursive(depth, limit): + if depth >= limit: + # cannot call get_recursion_depth() at this depth, + # it can raise RecursionError + return + get_depth = support.get_recursion_depth() + print(f"test_recursive: {depth}/{limit}: " + f"get_recursion_depth() says {get_depth}") + check(get_depth == depth) + test_recursive(depth + 1, limit) + + if USE_STACKCHECK: + # f-string consumes 2 frames and -1 for USE_STACKCHECK + IGNORE = 3 + else: + # f-string consumes 2 frames + IGNORE = 2 + + # depth up to 25 + with support.infinite_recursion(max_depth=25): + limit = sys.getrecursionlimit() + print(f"test with sys.getrecursionlimit()={limit}") + test_recursive(2, limit - IGNORE) + + # depth up to 500 + with support.infinite_recursion(max_depth=500): + limit = sys.getrecursionlimit() + print(f"test with sys.getrecursionlimit()={limit}") + test_recursive(2, limit - IGNORE) + """) + script_helper.assert_python_ok("-c", code) + + def test_recursion(self): + # Test infinite_recursion() and get_recursion_available() functions. + def recursive_function(depth): + if depth: + recursive_function(depth - 1) + + for max_depth in (5, 25, 250): + with support.infinite_recursion(max_depth): + available = support.get_recursion_available() + + # Recursion up to 'available' additional frames should be OK. + recursive_function(available) + + # Recursion up to 'available+1' additional frames must raise + # RecursionError. Avoid self.assertRaises(RecursionError) which + # can consume more than 3 frames and so raises RecursionError. + try: + recursive_function(available + 1) + except RecursionError: + pass + else: + self.fail("RecursionError was not raised") + + # Test the bare minimumum: max_depth=4 + with support.infinite_recursion(4): + try: + recursive_function(4) + except RecursionError: + pass + else: + self.fail("RecursionError was not raised") + + def test_parse_memlimit(self): + parse = support._parse_memlimit + KiB = 1024 + MiB = KiB * 1024 + GiB = MiB * 1024 + TiB = GiB * 1024 + self.assertEqual(parse('0k'), 0) + self.assertEqual(parse('3k'), 3 * KiB) + self.assertEqual(parse('2.4m'), int(2.4 * MiB)) + self.assertEqual(parse('4g'), int(4 * GiB)) + self.assertEqual(parse('1t'), TiB) + + for limit in ('', '3', '3.5.10k', '10x'): + with self.subTest(limit=limit): + with self.assertRaises(ValueError): + parse(limit) + + def test_set_memlimit(self): + _4GiB = 4 * 1024 ** 3 + TiB = 1024 ** 4 + old_max_memuse = support.max_memuse + old_real_max_memuse = support.real_max_memuse + try: + if sys.maxsize > 2**32: + support.set_memlimit('4g') + self.assertEqual(support.max_memuse, _4GiB) + self.assertEqual(support.real_max_memuse, _4GiB) + + big = 2**100 // TiB + support.set_memlimit(f'{big}t') + self.assertEqual(support.max_memuse, sys.maxsize) + self.assertEqual(support.real_max_memuse, big * TiB) + else: + support.set_memlimit('4g') + self.assertEqual(support.max_memuse, sys.maxsize) + self.assertEqual(support.real_max_memuse, _4GiB) + finally: + support.max_memuse = old_max_memuse + support.real_max_memuse = old_real_max_memuse + + def test_copy_python_src_ignore(self): + # Get source directory + src_dir = sysconfig.get_config_var('abs_srcdir') + if not src_dir: + src_dir = sysconfig.get_config_var('srcdir') + src_dir = os.path.abspath(src_dir) + + # Check that the source code is available + if not os.path.exists(src_dir): + self.skipTest(f"cannot access Python source code directory:" + f" {src_dir!r}") + # Check that the landmark copy_python_src_ignore() expects is available + # (Previously we looked for 'Lib\os.py', which is always present on Windows.) + landmark = os.path.join(src_dir, 'Modules') + if not os.path.exists(landmark): + self.skipTest(f"cannot access Python source code directory:" + f" {landmark!r} landmark is missing") + + # Test support.copy_python_src_ignore() + + # Source code directory + ignored = {'.git', '__pycache__'} + names = os.listdir(src_dir) + self.assertEqual(support.copy_python_src_ignore(src_dir, names), + ignored | {'build'}) + + # Doc/ directory + path = os.path.join(src_dir, 'Doc') + self.assertEqual(support.copy_python_src_ignore(path, os.listdir(path)), + ignored | {'build', 'venv'}) + + # Another directory + path = os.path.join(src_dir, 'Objects') + self.assertEqual(support.copy_python_src_ignore(path, os.listdir(path)), + ignored) + + # XXX -follows a list of untested API + # make_legacy_pyc + # is_resource_enabled + # requires + # fcmp + # umaks + # findfile + # check_warnings + # EnvironmentVarGuard + # transient_internet + # run_with_locale + # bigmemtest + # precisionbigmemtest + # bigaddrspacetest + # requires_resource + # threading_cleanup + # reap_threads + # can_symlink + # skip_unless_symlink + # SuppressCrashReport + + +if __name__ == '__main__': + unittest.main() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/textwrap.py b/physworld_p1_20261018/envs/p1/lib/python3.11/textwrap.py new file mode 100644 index 0000000000000000000000000000000000000000..98bedd27ea3a11995e2bf81a115df999767dc134 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/textwrap.py @@ -0,0 +1,491 @@ +"""Text wrapping and filling. +""" + +# Copyright (C) 1999-2001 Gregory P. Ward. +# Copyright (C) 2002, 2003 Python Software Foundation. +# Written by Greg Ward + +import re + +__all__ = ['TextWrapper', 'wrap', 'fill', 'dedent', 'indent', 'shorten'] + +# Hardcode the recognized whitespace characters to the US-ASCII +# whitespace characters. The main reason for doing this is that +# some Unicode spaces (like \u00a0) are non-breaking whitespaces. +_whitespace = '\t\n\x0b\x0c\r ' + +class TextWrapper: + """ + Object for wrapping/filling text. The public interface consists of + the wrap() and fill() methods; the other methods are just there for + subclasses to override in order to tweak the default behaviour. + If you want to completely replace the main wrapping algorithm, + you'll probably have to override _wrap_chunks(). + + Several instance attributes control various aspects of wrapping: + width (default: 70) + the maximum width of wrapped lines (unless break_long_words + is false) + initial_indent (default: "") + string that will be prepended to the first line of wrapped + output. Counts towards the line's width. + subsequent_indent (default: "") + string that will be prepended to all lines save the first + of wrapped output; also counts towards each line's width. + expand_tabs (default: true) + Expand tabs in input text to spaces before further processing. + Each tab will become 0 .. 'tabsize' spaces, depending on its position + in its line. If false, each tab is treated as a single character. + tabsize (default: 8) + Expand tabs in input text to 0 .. 'tabsize' spaces, unless + 'expand_tabs' is false. + replace_whitespace (default: true) + Replace all whitespace characters in the input text by spaces + after tab expansion. Note that if expand_tabs is false and + replace_whitespace is true, every tab will be converted to a + single space! + fix_sentence_endings (default: false) + Ensure that sentence-ending punctuation is always followed + by two spaces. Off by default because the algorithm is + (unavoidably) imperfect. + break_long_words (default: true) + Break words longer than 'width'. If false, those words will not + be broken, and some lines might be longer than 'width'. + break_on_hyphens (default: true) + Allow breaking hyphenated words. If true, wrapping will occur + preferably on whitespaces and right after hyphens part of + compound words. + drop_whitespace (default: true) + Drop leading and trailing whitespace from lines. + max_lines (default: None) + Truncate wrapped lines. + placeholder (default: ' [...]') + Append to the last line of truncated text. + """ + + unicode_whitespace_trans = dict.fromkeys(map(ord, _whitespace), ord(' ')) + + # This funky little regex is just the trick for splitting + # text up into word-wrappable chunks. E.g. + # "Hello there -- you goof-ball, use the -b option!" + # splits into + # Hello/ /there/ /--/ /you/ /goof-/ball,/ /use/ /the/ /-b/ /option! + # (after stripping out empty strings). + word_punct = r'[\w!"\'&.,?]' + letter = r'[^\d\W]' + whitespace = r'[%s]' % re.escape(_whitespace) + nowhitespace = '[^' + whitespace[1:] + wordsep_re = re.compile(r''' + ( # any whitespace + %(ws)s+ + | # em-dash between words + (?<=%(wp)s) -{2,} (?=\w) + | # word, possibly hyphenated + %(nws)s+? (?: + # hyphenated word + -(?: (?<=%(lt)s{2}-) | (?<=%(lt)s-%(lt)s-)) + (?= %(lt)s -? %(lt)s) + | # end of word + (?=%(ws)s|\Z) + | # em-dash + (?<=%(wp)s) (?=-{2,}\w) + ) + )''' % {'wp': word_punct, 'lt': letter, + 'ws': whitespace, 'nws': nowhitespace}, + re.VERBOSE) + del word_punct, letter, nowhitespace + + # This less funky little regex just split on recognized spaces. E.g. + # "Hello there -- you goof-ball, use the -b option!" + # splits into + # Hello/ /there/ /--/ /you/ /goof-ball,/ /use/ /the/ /-b/ /option!/ + wordsep_simple_re = re.compile(r'(%s+)' % whitespace) + del whitespace + + # XXX this is not locale- or charset-aware -- string.lowercase + # is US-ASCII only (and therefore English-only) + sentence_end_re = re.compile(r'[a-z]' # lowercase letter + r'[\.\!\?]' # sentence-ending punct. + r'[\"\']?' # optional end-of-quote + r'\Z') # end of chunk + + def __init__(self, + width=70, + initial_indent="", + subsequent_indent="", + expand_tabs=True, + replace_whitespace=True, + fix_sentence_endings=False, + break_long_words=True, + drop_whitespace=True, + break_on_hyphens=True, + tabsize=8, + *, + max_lines=None, + placeholder=' [...]'): + self.width = width + self.initial_indent = initial_indent + self.subsequent_indent = subsequent_indent + self.expand_tabs = expand_tabs + self.replace_whitespace = replace_whitespace + self.fix_sentence_endings = fix_sentence_endings + self.break_long_words = break_long_words + self.drop_whitespace = drop_whitespace + self.break_on_hyphens = break_on_hyphens + self.tabsize = tabsize + self.max_lines = max_lines + self.placeholder = placeholder + + + # -- Private methods ----------------------------------------------- + # (possibly useful for subclasses to override) + + def _munge_whitespace(self, text): + """_munge_whitespace(text : string) -> string + + Munge whitespace in text: expand tabs and convert all other + whitespace characters to spaces. Eg. " foo\\tbar\\n\\nbaz" + becomes " foo bar baz". + """ + if self.expand_tabs: + text = text.expandtabs(self.tabsize) + if self.replace_whitespace: + text = text.translate(self.unicode_whitespace_trans) + return text + + + def _split(self, text): + """_split(text : string) -> [string] + + Split the text to wrap into indivisible chunks. Chunks are + not quite the same as words; see _wrap_chunks() for full + details. As an example, the text + Look, goof-ball -- use the -b option! + breaks into the following chunks: + 'Look,', ' ', 'goof-', 'ball', ' ', '--', ' ', + 'use', ' ', 'the', ' ', '-b', ' ', 'option!' + if break_on_hyphens is True, or in: + 'Look,', ' ', 'goof-ball', ' ', '--', ' ', + 'use', ' ', 'the', ' ', '-b', ' ', option!' + otherwise. + """ + if self.break_on_hyphens is True: + chunks = self.wordsep_re.split(text) + else: + chunks = self.wordsep_simple_re.split(text) + chunks = [c for c in chunks if c] + return chunks + + def _fix_sentence_endings(self, chunks): + """_fix_sentence_endings(chunks : [string]) + + Correct for sentence endings buried in 'chunks'. Eg. when the + original text contains "... foo.\\nBar ...", munge_whitespace() + and split() will convert that to [..., "foo.", " ", "Bar", ...] + which has one too few spaces; this method simply changes the one + space to two. + """ + i = 0 + patsearch = self.sentence_end_re.search + while i < len(chunks)-1: + if chunks[i+1] == " " and patsearch(chunks[i]): + chunks[i+1] = " " + i += 2 + else: + i += 1 + + def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width): + """_handle_long_word(chunks : [string], + cur_line : [string], + cur_len : int, width : int) + + Handle a chunk of text (most likely a word, not whitespace) that + is too long to fit in any line. + """ + # Figure out when indent is larger than the specified width, and make + # sure at least one character is stripped off on every pass + if width < 1: + space_left = 1 + else: + space_left = width - cur_len + + # If we're allowed to break long words, then do so: put as much + # of the next chunk onto the current line as will fit. + if self.break_long_words: + end = space_left + chunk = reversed_chunks[-1] + if self.break_on_hyphens and len(chunk) > space_left: + # break after last hyphen, but only if there are + # non-hyphens before it + hyphen = chunk.rfind('-', 0, space_left) + if hyphen > 0 and any(c != '-' for c in chunk[:hyphen]): + end = hyphen + 1 + cur_line.append(chunk[:end]) + reversed_chunks[-1] = chunk[end:] + + # Otherwise, we have to preserve the long word intact. Only add + # it to the current line if there's nothing already there -- + # that minimizes how much we violate the width constraint. + elif not cur_line: + cur_line.append(reversed_chunks.pop()) + + # If we're not allowed to break long words, and there's already + # text on the current line, do nothing. Next time through the + # main loop of _wrap_chunks(), we'll wind up here again, but + # cur_len will be zero, so the next line will be entirely + # devoted to the long word that we can't handle right now. + + def _wrap_chunks(self, chunks): + """_wrap_chunks(chunks : [string]) -> [string] + + Wrap a sequence of text chunks and return a list of lines of + length 'self.width' or less. (If 'break_long_words' is false, + some lines may be longer than this.) Chunks correspond roughly + to words and the whitespace between them: each chunk is + indivisible (modulo 'break_long_words'), but a line break can + come between any two chunks. Chunks should not have internal + whitespace; ie. a chunk is either all whitespace or a "word". + Whitespace chunks will be removed from the beginning and end of + lines, but apart from that whitespace is preserved. + """ + lines = [] + if self.width <= 0: + raise ValueError("invalid width %r (must be > 0)" % self.width) + if self.max_lines is not None: + if self.max_lines > 1: + indent = self.subsequent_indent + else: + indent = self.initial_indent + if len(indent) + len(self.placeholder.lstrip()) > self.width: + raise ValueError("placeholder too large for max width") + + # Arrange in reverse order so items can be efficiently popped + # from a stack of chucks. + chunks.reverse() + + while chunks: + + # Start the list of chunks that will make up the current line. + # cur_len is just the length of all the chunks in cur_line. + cur_line = [] + cur_len = 0 + + # Figure out which static string will prefix this line. + if lines: + indent = self.subsequent_indent + else: + indent = self.initial_indent + + # Maximum width for this line. + width = self.width - len(indent) + + # First chunk on line is whitespace -- drop it, unless this + # is the very beginning of the text (ie. no lines started yet). + if self.drop_whitespace and chunks[-1].strip() == '' and lines: + del chunks[-1] + + while chunks: + l = len(chunks[-1]) + + # Can at least squeeze this chunk onto the current line. + if cur_len + l <= width: + cur_line.append(chunks.pop()) + cur_len += l + + # Nope, this line is full. + else: + break + + # The current line is full, and the next chunk is too big to + # fit on *any* line (not just this one). + if chunks and len(chunks[-1]) > width: + self._handle_long_word(chunks, cur_line, cur_len, width) + cur_len = sum(map(len, cur_line)) + + # If the last chunk on this line is all whitespace, drop it. + if self.drop_whitespace and cur_line and cur_line[-1].strip() == '': + cur_len -= len(cur_line[-1]) + del cur_line[-1] + + if cur_line: + if (self.max_lines is None or + len(lines) + 1 < self.max_lines or + (not chunks or + self.drop_whitespace and + len(chunks) == 1 and + not chunks[0].strip()) and cur_len <= width): + # Convert current line back to a string and store it in + # list of all lines (return value). + lines.append(indent + ''.join(cur_line)) + else: + while cur_line: + if (cur_line[-1].strip() and + cur_len + len(self.placeholder) <= width): + cur_line.append(self.placeholder) + lines.append(indent + ''.join(cur_line)) + break + cur_len -= len(cur_line[-1]) + del cur_line[-1] + else: + if lines: + prev_line = lines[-1].rstrip() + if (len(prev_line) + len(self.placeholder) <= + self.width): + lines[-1] = prev_line + self.placeholder + break + lines.append(indent + self.placeholder.lstrip()) + break + + return lines + + def _split_chunks(self, text): + text = self._munge_whitespace(text) + return self._split(text) + + # -- Public interface ---------------------------------------------- + + def wrap(self, text): + """wrap(text : string) -> [string] + + Reformat the single paragraph in 'text' so it fits in lines of + no more than 'self.width' columns, and return a list of wrapped + lines. Tabs in 'text' are expanded with string.expandtabs(), + and all other whitespace characters (including newline) are + converted to space. + """ + chunks = self._split_chunks(text) + if self.fix_sentence_endings: + self._fix_sentence_endings(chunks) + return self._wrap_chunks(chunks) + + def fill(self, text): + """fill(text : string) -> string + + Reformat the single paragraph in 'text' to fit in lines of no + more than 'self.width' columns, and return a new string + containing the entire wrapped paragraph. + """ + return "\n".join(self.wrap(text)) + + +# -- Convenience interface --------------------------------------------- + +def wrap(text, width=70, **kwargs): + """Wrap a single paragraph of text, returning a list of wrapped lines. + + Reformat the single paragraph in 'text' so it fits in lines of no + more than 'width' columns, and return a list of wrapped lines. By + default, tabs in 'text' are expanded with string.expandtabs(), and + all other whitespace characters (including newline) are converted to + space. See TextWrapper class for available keyword args to customize + wrapping behaviour. + """ + w = TextWrapper(width=width, **kwargs) + return w.wrap(text) + +def fill(text, width=70, **kwargs): + """Fill a single paragraph of text, returning a new string. + + Reformat the single paragraph in 'text' to fit in lines of no more + than 'width' columns, and return a new string containing the entire + wrapped paragraph. As with wrap(), tabs are expanded and other + whitespace characters converted to space. See TextWrapper class for + available keyword args to customize wrapping behaviour. + """ + w = TextWrapper(width=width, **kwargs) + return w.fill(text) + +def shorten(text, width, **kwargs): + """Collapse and truncate the given text to fit in the given width. + + The text first has its whitespace collapsed. If it then fits in + the *width*, it is returned as is. Otherwise, as many words + as possible are joined and then the placeholder is appended:: + + >>> textwrap.shorten("Hello world!", width=12) + 'Hello world!' + >>> textwrap.shorten("Hello world!", width=11) + 'Hello [...]' + """ + w = TextWrapper(width=width, max_lines=1, **kwargs) + return w.fill(' '.join(text.strip().split())) + + +# -- Loosely related functionality ------------------------------------- + +_whitespace_only_re = re.compile('^[ \t]+$', re.MULTILINE) +_leading_whitespace_re = re.compile('(^[ \t]*)(?:[^ \t\n])', re.MULTILINE) + +def dedent(text): + """Remove any common leading whitespace from every line in `text`. + + This can be used to make triple-quoted strings line up with the left + edge of the display, while still presenting them in the source code + in indented form. + + Note that tabs and spaces are both treated as whitespace, but they + are not equal: the lines " hello" and "\\thello" are + considered to have no common leading whitespace. + + Entirely blank lines are normalized to a newline character. + """ + # Look for the longest leading string of spaces and tabs common to + # all lines. + margin = None + text = _whitespace_only_re.sub('', text) + indents = _leading_whitespace_re.findall(text) + for indent in indents: + if margin is None: + margin = indent + + # Current line more deeply indented than previous winner: + # no change (previous winner is still on top). + elif indent.startswith(margin): + pass + + # Current line consistent with and no deeper than previous winner: + # it's the new winner. + elif margin.startswith(indent): + margin = indent + + # Find the largest common whitespace between current line and previous + # winner. + else: + for i, (x, y) in enumerate(zip(margin, indent)): + if x != y: + margin = margin[:i] + break + + # sanity check (testing/debugging only) + if 0 and margin: + for line in text.split("\n"): + assert not line or line.startswith(margin), \ + "line = %r, margin = %r" % (line, margin) + + if margin: + text = re.sub(r'(?m)^' + margin, '', text) + return text + + +def indent(text, prefix, predicate=None): + """Adds 'prefix' to the beginning of selected lines in 'text'. + + If 'predicate' is provided, 'prefix' will only be added to the lines + where 'predicate(line)' is True. If 'predicate' is not provided, + it will default to adding 'prefix' to all non-empty lines that do not + consist solely of whitespace characters. + """ + if predicate is None: + def predicate(line): + return line.strip() + + def prefixed_lines(): + for line in text.splitlines(True): + yield (prefix + line if predicate(line) else line) + return ''.join(prefixed_lines()) + + +if __name__ == "__main__": + #print dedent("\tfoo\n\tbar") + #print dedent(" \thello there\n \t how are you?") + print(dedent("Hello there.\n This is indented.")) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/this.py b/physworld_p1_20261018/envs/p1/lib/python3.11/this.py new file mode 100644 index 0000000000000000000000000000000000000000..e68dd3ff39b04ff857420b98889bee590b344024 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/this.py @@ -0,0 +1,28 @@ +s = """Gur Mra bs Clguba, ol Gvz Crgref + +Ornhgvshy vf orggre guna htyl. +Rkcyvpvg vf orggre guna vzcyvpvg. +Fvzcyr vf orggre guna pbzcyrk. +Pbzcyrk vf orggre guna pbzcyvpngrq. +Syng vf orggre guna arfgrq. +Fcnefr vf orggre guna qrafr. +Ernqnovyvgl pbhagf. +Fcrpvny pnfrf nera'g fcrpvny rabhtu gb oernx gur ehyrf. +Nygubhtu cenpgvpnyvgl orngf chevgl. +Reebef fubhyq arire cnff fvyragyl. +Hayrff rkcyvpvgyl fvyraprq. +Va gur snpr bs nzovthvgl, ershfr gur grzcgngvba gb thrff. +Gurer fubhyq or bar-- naq cersrenoyl bayl bar --boivbhf jnl gb qb vg. +Nygubhtu gung jnl znl abg or boivbhf ng svefg hayrff lbh'er Qhgpu. +Abj vf orggre guna arire. +Nygubhtu arire vf bsgra orggre guna *evtug* abj. +Vs gur vzcyrzragngvba vf uneq gb rkcynva, vg'f n onq vqrn. +Vs gur vzcyrzragngvba vf rnfl gb rkcynva, vg znl or n tbbq vqrn. +Anzrfcnprf ner bar ubaxvat terng vqrn -- yrg'f qb zber bs gubfr!""" + +d = {} +for c in (65, 97): + for i in range(26): + d[chr(i+c)] = chr((i+13) % 26 + c) + +print("".join([d.get(c, c) for c in s])) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/threading.py b/physworld_p1_20261018/envs/p1/lib/python3.11/threading.py new file mode 100644 index 0000000000000000000000000000000000000000..29b8ec74651d0e92b66f436aaf644a17d773b01a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/threading.py @@ -0,0 +1,1673 @@ +"""Thread module emulating a subset of Java's threading model.""" + +import os as _os +import sys as _sys +import _thread +import functools + +from time import monotonic as _time +from _weakrefset import WeakSet +from itertools import islice as _islice, count as _count +try: + from _collections import deque as _deque +except ImportError: + from collections import deque as _deque + +# Note regarding PEP 8 compliant names +# This threading model was originally inspired by Java, and inherited +# the convention of camelCase function and method names from that +# language. Those original names are not in any imminent danger of +# being deprecated (even for Py3k),so this module provides them as an +# alias for the PEP 8 compliant names +# Note that using the new PEP 8 compliant names facilitates substitution +# with the multiprocessing module, which doesn't provide the old +# Java inspired names. + +__all__ = ['get_ident', 'active_count', 'Condition', 'current_thread', + 'enumerate', 'main_thread', 'TIMEOUT_MAX', + 'Event', 'Lock', 'RLock', 'Semaphore', 'BoundedSemaphore', 'Thread', + 'Barrier', 'BrokenBarrierError', 'Timer', 'ThreadError', + 'setprofile', 'settrace', 'local', 'stack_size', + 'excepthook', 'ExceptHookArgs', 'gettrace', 'getprofile'] + +# Rename some stuff so "from threading import *" is safe +_start_new_thread = _thread.start_new_thread +_allocate_lock = _thread.allocate_lock +_set_sentinel = _thread._set_sentinel +get_ident = _thread.get_ident +try: + get_native_id = _thread.get_native_id + _HAVE_THREAD_NATIVE_ID = True + __all__.append('get_native_id') +except AttributeError: + _HAVE_THREAD_NATIVE_ID = False +ThreadError = _thread.error +try: + _CRLock = _thread.RLock +except AttributeError: + _CRLock = None +TIMEOUT_MAX = _thread.TIMEOUT_MAX +del _thread + + +# Support for profile and trace hooks + +_profile_hook = None +_trace_hook = None + +def setprofile(func): + """Set a profile function for all threads started from the threading module. + + The func will be passed to sys.setprofile() for each thread, before its + run() method is called. + + """ + global _profile_hook + _profile_hook = func + +def getprofile(): + """Get the profiler function as set by threading.setprofile().""" + return _profile_hook + +def settrace(func): + """Set a trace function for all threads started from the threading module. + + The func will be passed to sys.settrace() for each thread, before its run() + method is called. + + """ + global _trace_hook + _trace_hook = func + +def gettrace(): + """Get the trace function as set by threading.settrace().""" + return _trace_hook + +# Synchronization classes + +Lock = _allocate_lock + +def RLock(*args, **kwargs): + """Factory function that returns a new reentrant lock. + + A reentrant lock must be released by the thread that acquired it. Once a + thread has acquired a reentrant lock, the same thread may acquire it again + without blocking; the thread must release it once for each time it has + acquired it. + + """ + if _CRLock is None: + return _PyRLock(*args, **kwargs) + return _CRLock(*args, **kwargs) + +class _RLock: + """This class implements reentrant lock objects. + + A reentrant lock must be released by the thread that acquired it. Once a + thread has acquired a reentrant lock, the same thread may acquire it + again without blocking; the thread must release it once for each time it + has acquired it. + + """ + + def __init__(self): + self._block = _allocate_lock() + self._owner = None + self._count = 0 + + def __repr__(self): + owner = self._owner + try: + owner = _active[owner].name + except KeyError: + pass + return "<%s %s.%s object owner=%r count=%d at %s>" % ( + "locked" if self._block.locked() else "unlocked", + self.__class__.__module__, + self.__class__.__qualname__, + owner, + self._count, + hex(id(self)) + ) + + def _at_fork_reinit(self): + self._block._at_fork_reinit() + self._owner = None + self._count = 0 + + def acquire(self, blocking=True, timeout=-1): + """Acquire a lock, blocking or non-blocking. + + When invoked without arguments: if this thread already owns the lock, + increment the recursion level by one, and return immediately. Otherwise, + if another thread owns the lock, block until the lock is unlocked. Once + the lock is unlocked (not owned by any thread), then grab ownership, set + the recursion level to one, and return. If more than one thread is + blocked waiting until the lock is unlocked, only one at a time will be + able to grab ownership of the lock. There is no return value in this + case. + + When invoked with the blocking argument set to true, do the same thing + as when called without arguments, and return true. + + When invoked with the blocking argument set to false, do not block. If a + call without an argument would block, return false immediately; + otherwise, do the same thing as when called without arguments, and + return true. + + When invoked with the floating-point timeout argument set to a positive + value, block for at most the number of seconds specified by timeout + and as long as the lock cannot be acquired. Return true if the lock has + been acquired, false if the timeout has elapsed. + + """ + me = get_ident() + if self._owner == me: + self._count += 1 + return 1 + rc = self._block.acquire(blocking, timeout) + if rc: + self._owner = me + self._count = 1 + return rc + + __enter__ = acquire + + def release(self): + """Release a lock, decrementing the recursion level. + + If after the decrement it is zero, reset the lock to unlocked (not owned + by any thread), and if any other threads are blocked waiting for the + lock to become unlocked, allow exactly one of them to proceed. If after + the decrement the recursion level is still nonzero, the lock remains + locked and owned by the calling thread. + + Only call this method when the calling thread owns the lock. A + RuntimeError is raised if this method is called when the lock is + unlocked. + + There is no return value. + + """ + if self._owner != get_ident(): + raise RuntimeError("cannot release un-acquired lock") + self._count = count = self._count - 1 + if not count: + self._owner = None + self._block.release() + + def __exit__(self, t, v, tb): + self.release() + + # Internal methods used by condition variables + + def _acquire_restore(self, state): + self._block.acquire() + self._count, self._owner = state + + def _release_save(self): + if self._count == 0: + raise RuntimeError("cannot release un-acquired lock") + count = self._count + self._count = 0 + owner = self._owner + self._owner = None + self._block.release() + return (count, owner) + + def _is_owned(self): + return self._owner == get_ident() + + # Internal method used for reentrancy checks + + def _recursion_count(self): + if self._owner != get_ident(): + return 0 + return self._count + +_PyRLock = _RLock + + +class Condition: + """Class that implements a condition variable. + + A condition variable allows one or more threads to wait until they are + notified by another thread. + + If the lock argument is given and not None, it must be a Lock or RLock + object, and it is used as the underlying lock. Otherwise, a new RLock object + is created and used as the underlying lock. + + """ + + def __init__(self, lock=None): + if lock is None: + lock = RLock() + self._lock = lock + # Export the lock's acquire() and release() methods + self.acquire = lock.acquire + self.release = lock.release + # If the lock defines _release_save() and/or _acquire_restore(), + # these override the default implementations (which just call + # release() and acquire() on the lock). Ditto for _is_owned(). + try: + self._release_save = lock._release_save + except AttributeError: + pass + try: + self._acquire_restore = lock._acquire_restore + except AttributeError: + pass + try: + self._is_owned = lock._is_owned + except AttributeError: + pass + self._waiters = _deque() + + def _at_fork_reinit(self): + self._lock._at_fork_reinit() + self._waiters.clear() + + def __enter__(self): + return self._lock.__enter__() + + def __exit__(self, *args): + return self._lock.__exit__(*args) + + def __repr__(self): + return "" % (self._lock, len(self._waiters)) + + def _release_save(self): + self._lock.release() # No state to save + + def _acquire_restore(self, x): + self._lock.acquire() # Ignore saved state + + def _is_owned(self): + # Return True if lock is owned by current_thread. + # This method is called only if _lock doesn't have _is_owned(). + if self._lock.acquire(False): + self._lock.release() + return False + else: + return True + + def wait(self, timeout=None): + """Wait until notified or until a timeout occurs. + + If the calling thread has not acquired the lock when this method is + called, a RuntimeError is raised. + + This method releases the underlying lock, and then blocks until it is + awakened by a notify() or notify_all() call for the same condition + variable in another thread, or until the optional timeout occurs. Once + awakened or timed out, it re-acquires the lock and returns. + + When the timeout argument is present and not None, it should be a + floating point number specifying a timeout for the operation in seconds + (or fractions thereof). + + When the underlying lock is an RLock, it is not released using its + release() method, since this may not actually unlock the lock when it + was acquired multiple times recursively. Instead, an internal interface + of the RLock class is used, which really unlocks it even when it has + been recursively acquired several times. Another internal interface is + then used to restore the recursion level when the lock is reacquired. + + """ + if not self._is_owned(): + raise RuntimeError("cannot wait on un-acquired lock") + waiter = _allocate_lock() + waiter.acquire() + self._waiters.append(waiter) + saved_state = self._release_save() + gotit = False + try: # restore state no matter what (e.g., KeyboardInterrupt) + if timeout is None: + waiter.acquire() + gotit = True + else: + if timeout > 0: + gotit = waiter.acquire(True, timeout) + else: + gotit = waiter.acquire(False) + return gotit + finally: + self._acquire_restore(saved_state) + if not gotit: + try: + self._waiters.remove(waiter) + except ValueError: + pass + + def wait_for(self, predicate, timeout=None): + """Wait until a condition evaluates to True. + + predicate should be a callable which result will be interpreted as a + boolean value. A timeout may be provided giving the maximum time to + wait. + + """ + endtime = None + waittime = timeout + result = predicate() + while not result: + if waittime is not None: + if endtime is None: + endtime = _time() + waittime + else: + waittime = endtime - _time() + if waittime <= 0: + break + self.wait(waittime) + result = predicate() + return result + + def notify(self, n=1): + """Wake up one or more threads waiting on this condition, if any. + + If the calling thread has not acquired the lock when this method is + called, a RuntimeError is raised. + + This method wakes up at most n of the threads waiting for the condition + variable; it is a no-op if no threads are waiting. + + """ + if not self._is_owned(): + raise RuntimeError("cannot notify on un-acquired lock") + waiters = self._waiters + while waiters and n > 0: + waiter = waiters[0] + try: + waiter.release() + except RuntimeError: + # gh-92530: The previous call of notify() released the lock, + # but was interrupted before removing it from the queue. + # It can happen if a signal handler raises an exception, + # like CTRL+C which raises KeyboardInterrupt. + pass + else: + n -= 1 + try: + waiters.remove(waiter) + except ValueError: + pass + + def notify_all(self): + """Wake up all threads waiting on this condition. + + If the calling thread has not acquired the lock when this method + is called, a RuntimeError is raised. + + """ + self.notify(len(self._waiters)) + + def notifyAll(self): + """Wake up all threads waiting on this condition. + + This method is deprecated, use notify_all() instead. + + """ + import warnings + warnings.warn('notifyAll() is deprecated, use notify_all() instead', + DeprecationWarning, stacklevel=2) + self.notify_all() + + +class Semaphore: + """This class implements semaphore objects. + + Semaphores manage a counter representing the number of release() calls minus + the number of acquire() calls, plus an initial value. The acquire() method + blocks if necessary until it can return without making the counter + negative. If not given, value defaults to 1. + + """ + + # After Tim Peters' semaphore class, but not quite the same (no maximum) + + def __init__(self, value=1): + if value < 0: + raise ValueError("semaphore initial value must be >= 0") + self._cond = Condition(Lock()) + self._value = value + + def __repr__(self): + cls = self.__class__ + return (f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}:" + f" value={self._value}>") + + def acquire(self, blocking=True, timeout=None): + """Acquire a semaphore, decrementing the internal counter by one. + + When invoked without arguments: if the internal counter is larger than + zero on entry, decrement it by one and return immediately. If it is zero + on entry, block, waiting until some other thread has called release() to + make it larger than zero. This is done with proper interlocking so that + if multiple acquire() calls are blocked, release() will wake exactly one + of them up. The implementation may pick one at random, so the order in + which blocked threads are awakened should not be relied on. There is no + return value in this case. + + When invoked with blocking set to true, do the same thing as when called + without arguments, and return true. + + When invoked with blocking set to false, do not block. If a call without + an argument would block, return false immediately; otherwise, do the + same thing as when called without arguments, and return true. + + When invoked with a timeout other than None, it will block for at + most timeout seconds. If acquire does not complete successfully in + that interval, return false. Return true otherwise. + + """ + if not blocking and timeout is not None: + raise ValueError("can't specify timeout for non-blocking acquire") + rc = False + endtime = None + with self._cond: + while self._value == 0: + if not blocking: + break + if timeout is not None: + if endtime is None: + endtime = _time() + timeout + else: + timeout = endtime - _time() + if timeout <= 0: + break + self._cond.wait(timeout) + else: + self._value -= 1 + rc = True + return rc + + __enter__ = acquire + + def release(self, n=1): + """Release a semaphore, incrementing the internal counter by one or more. + + When the counter is zero on entry and another thread is waiting for it + to become larger than zero again, wake up that thread. + + """ + if n < 1: + raise ValueError('n must be one or more') + with self._cond: + self._value += n + for i in range(n): + self._cond.notify() + + def __exit__(self, t, v, tb): + self.release() + + +class BoundedSemaphore(Semaphore): + """Implements a bounded semaphore. + + A bounded semaphore checks to make sure its current value doesn't exceed its + initial value. If it does, ValueError is raised. In most situations + semaphores are used to guard resources with limited capacity. + + If the semaphore is released too many times it's a sign of a bug. If not + given, value defaults to 1. + + Like regular semaphores, bounded semaphores manage a counter representing + the number of release() calls minus the number of acquire() calls, plus an + initial value. The acquire() method blocks if necessary until it can return + without making the counter negative. If not given, value defaults to 1. + + """ + + def __init__(self, value=1): + Semaphore.__init__(self, value) + self._initial_value = value + + def __repr__(self): + cls = self.__class__ + return (f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}:" + f" value={self._value}/{self._initial_value}>") + + def release(self, n=1): + """Release a semaphore, incrementing the internal counter by one or more. + + When the counter is zero on entry and another thread is waiting for it + to become larger than zero again, wake up that thread. + + If the number of releases exceeds the number of acquires, + raise a ValueError. + + """ + if n < 1: + raise ValueError('n must be one or more') + with self._cond: + if self._value + n > self._initial_value: + raise ValueError("Semaphore released too many times") + self._value += n + for i in range(n): + self._cond.notify() + + +class Event: + """Class implementing event objects. + + Events manage a flag that can be set to true with the set() method and reset + to false with the clear() method. The wait() method blocks until the flag is + true. The flag is initially false. + + """ + + # After Tim Peters' event class (without is_posted()) + + def __init__(self): + self._cond = Condition(Lock()) + self._flag = False + + def __repr__(self): + cls = self.__class__ + status = 'set' if self._flag else 'unset' + return f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}: {status}>" + + def _at_fork_reinit(self): + # Private method called by Thread._reset_internal_locks() + self._cond._at_fork_reinit() + + def is_set(self): + """Return true if and only if the internal flag is true.""" + return self._flag + + def isSet(self): + """Return true if and only if the internal flag is true. + + This method is deprecated, use is_set() instead. + + """ + import warnings + warnings.warn('isSet() is deprecated, use is_set() instead', + DeprecationWarning, stacklevel=2) + return self.is_set() + + def set(self): + """Set the internal flag to true. + + All threads waiting for it to become true are awakened. Threads + that call wait() once the flag is true will not block at all. + + """ + with self._cond: + self._flag = True + self._cond.notify_all() + + def clear(self): + """Reset the internal flag to false. + + Subsequently, threads calling wait() will block until set() is called to + set the internal flag to true again. + + """ + with self._cond: + self._flag = False + + def wait(self, timeout=None): + """Block until the internal flag is true. + + If the internal flag is true on entry, return immediately. Otherwise, + block until another thread calls set() to set the flag to true, or until + the optional timeout occurs. + + When the timeout argument is present and not None, it should be a + floating point number specifying a timeout for the operation in seconds + (or fractions thereof). + + This method returns the internal flag on exit, so it will always return + True except if a timeout is given and the operation times out. + + """ + with self._cond: + signaled = self._flag + if not signaled: + signaled = self._cond.wait(timeout) + return signaled + + +# A barrier class. Inspired in part by the pthread_barrier_* api and +# the CyclicBarrier class from Java. See +# http://sourceware.org/pthreads-win32/manual/pthread_barrier_init.html and +# http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/ +# CyclicBarrier.html +# for information. +# We maintain two main states, 'filling' and 'draining' enabling the barrier +# to be cyclic. Threads are not allowed into it until it has fully drained +# since the previous cycle. In addition, a 'resetting' state exists which is +# similar to 'draining' except that threads leave with a BrokenBarrierError, +# and a 'broken' state in which all threads get the exception. +class Barrier: + """Implements a Barrier. + + Useful for synchronizing a fixed number of threads at known synchronization + points. Threads block on 'wait()' and are simultaneously awoken once they + have all made that call. + + """ + + def __init__(self, parties, action=None, timeout=None): + """Create a barrier, initialised to 'parties' threads. + + 'action' is a callable which, when supplied, will be called by one of + the threads after they have all entered the barrier and just prior to + releasing them all. If a 'timeout' is provided, it is used as the + default for all subsequent 'wait()' calls. + + """ + self._cond = Condition(Lock()) + self._action = action + self._timeout = timeout + self._parties = parties + self._state = 0 # 0 filling, 1 draining, -1 resetting, -2 broken + self._count = 0 + + def __repr__(self): + cls = self.__class__ + if self.broken: + return f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}: broken>" + return (f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}:" + f" waiters={self.n_waiting}/{self.parties}>") + + def wait(self, timeout=None): + """Wait for the barrier. + + When the specified number of threads have started waiting, they are all + simultaneously awoken. If an 'action' was provided for the barrier, one + of the threads will have executed that callback prior to returning. + Returns an individual index number from 0 to 'parties-1'. + + """ + if timeout is None: + timeout = self._timeout + with self._cond: + self._enter() # Block while the barrier drains. + index = self._count + self._count += 1 + try: + if index + 1 == self._parties: + # We release the barrier + self._release() + else: + # We wait until someone releases us + self._wait(timeout) + return index + finally: + self._count -= 1 + # Wake up any threads waiting for barrier to drain. + self._exit() + + # Block until the barrier is ready for us, or raise an exception + # if it is broken. + def _enter(self): + while self._state in (-1, 1): + # It is draining or resetting, wait until done + self._cond.wait() + #see if the barrier is in a broken state + if self._state < 0: + raise BrokenBarrierError + assert self._state == 0 + + # Optionally run the 'action' and release the threads waiting + # in the barrier. + def _release(self): + try: + if self._action: + self._action() + # enter draining state + self._state = 1 + self._cond.notify_all() + except: + #an exception during the _action handler. Break and reraise + self._break() + raise + + # Wait in the barrier until we are released. Raise an exception + # if the barrier is reset or broken. + def _wait(self, timeout): + if not self._cond.wait_for(lambda : self._state != 0, timeout): + #timed out. Break the barrier + self._break() + raise BrokenBarrierError + if self._state < 0: + raise BrokenBarrierError + assert self._state == 1 + + # If we are the last thread to exit the barrier, signal any threads + # waiting for the barrier to drain. + def _exit(self): + if self._count == 0: + if self._state in (-1, 1): + #resetting or draining + self._state = 0 + self._cond.notify_all() + + def reset(self): + """Reset the barrier to the initial state. + + Any threads currently waiting will get the BrokenBarrier exception + raised. + + """ + with self._cond: + if self._count > 0: + if self._state == 0: + #reset the barrier, waking up threads + self._state = -1 + elif self._state == -2: + #was broken, set it to reset state + #which clears when the last thread exits + self._state = -1 + else: + self._state = 0 + self._cond.notify_all() + + def abort(self): + """Place the barrier into a 'broken' state. + + Useful in case of error. Any currently waiting threads and threads + attempting to 'wait()' will have BrokenBarrierError raised. + + """ + with self._cond: + self._break() + + def _break(self): + # An internal error was detected. The barrier is set to + # a broken state all parties awakened. + self._state = -2 + self._cond.notify_all() + + @property + def parties(self): + """Return the number of threads required to trip the barrier.""" + return self._parties + + @property + def n_waiting(self): + """Return the number of threads currently waiting at the barrier.""" + # We don't need synchronization here since this is an ephemeral result + # anyway. It returns the correct value in the steady state. + if self._state == 0: + return self._count + return 0 + + @property + def broken(self): + """Return True if the barrier is in a broken state.""" + return self._state == -2 + +# exception raised by the Barrier class +class BrokenBarrierError(RuntimeError): + pass + + +# Helper to generate new thread names +_counter = _count(1).__next__ +def _newname(name_template): + return name_template % _counter() + +# Active thread administration. +# +# bpo-44422: Use a reentrant lock to allow reentrant calls to functions like +# threading.enumerate(). +_active_limbo_lock = RLock() +_active = {} # maps thread id to Thread object +_limbo = {} +_dangling = WeakSet() + +# Set of Thread._tstate_lock locks of non-daemon threads used by _shutdown() +# to wait until all Python thread states get deleted: +# see Thread._set_tstate_lock(). +_shutdown_locks_lock = _allocate_lock() +_shutdown_locks = set() + +def _maintain_shutdown_locks(): + """ + Drop any shutdown locks that don't correspond to running threads anymore. + + Calling this from time to time avoids an ever-growing _shutdown_locks + set when Thread objects are not joined explicitly. See bpo-37788. + + This must be called with _shutdown_locks_lock acquired. + """ + # If a lock was released, the corresponding thread has exited + to_remove = [lock for lock in _shutdown_locks if not lock.locked()] + _shutdown_locks.difference_update(to_remove) + + +# Main class for threads + +class Thread: + """A class that represents a thread of control. + + This class can be safely subclassed in a limited fashion. There are two ways + to specify the activity: by passing a callable object to the constructor, or + by overriding the run() method in a subclass. + + """ + + _initialized = False + + def __init__(self, group=None, target=None, name=None, + args=(), kwargs=None, *, daemon=None): + """This constructor should always be called with keyword arguments. Arguments are: + + *group* should be None; reserved for future extension when a ThreadGroup + class is implemented. + + *target* is the callable object to be invoked by the run() + method. Defaults to None, meaning nothing is called. + + *name* is the thread name. By default, a unique name is constructed of + the form "Thread-N" where N is a small decimal number. + + *args* is a list or tuple of arguments for the target invocation. Defaults to (). + + *kwargs* is a dictionary of keyword arguments for the target + invocation. Defaults to {}. + + If a subclass overrides the constructor, it must make sure to invoke + the base class constructor (Thread.__init__()) before doing anything + else to the thread. + + """ + assert group is None, "group argument must be None for now" + if kwargs is None: + kwargs = {} + if name: + name = str(name) + else: + name = _newname("Thread-%d") + if target is not None: + try: + target_name = target.__name__ + name += f" ({target_name})" + except AttributeError: + pass + + self._target = target + self._name = name + self._args = args + self._kwargs = kwargs + if daemon is not None: + self._daemonic = daemon + else: + self._daemonic = current_thread().daemon + self._ident = None + if _HAVE_THREAD_NATIVE_ID: + self._native_id = None + self._tstate_lock = None + self._started = Event() + self._is_stopped = False + self._initialized = True + # Copy of sys.stderr used by self._invoke_excepthook() + self._stderr = _sys.stderr + self._invoke_excepthook = _make_invoke_excepthook() + # For debugging and _after_fork() + _dangling.add(self) + + def _reset_internal_locks(self, is_alive): + # private! Called by _after_fork() to reset our internal locks as + # they may be in an invalid state leading to a deadlock or crash. + self._started._at_fork_reinit() + if is_alive: + # bpo-42350: If the fork happens when the thread is already stopped + # (ex: after threading._shutdown() has been called), _tstate_lock + # is None. Do nothing in this case. + if self._tstate_lock is not None: + self._tstate_lock._at_fork_reinit() + self._tstate_lock.acquire() + else: + # The thread isn't alive after fork: it doesn't have a tstate + # anymore. + self._is_stopped = True + self._tstate_lock = None + + def __repr__(self): + assert self._initialized, "Thread.__init__() was not called" + status = "initial" + if self._started.is_set(): + status = "started" + self.is_alive() # easy way to get ._is_stopped set when appropriate + if self._is_stopped: + status = "stopped" + if self._daemonic: + status += " daemon" + if self._ident is not None: + status += " %s" % self._ident + return "<%s(%s, %s)>" % (self.__class__.__name__, self._name, status) + + def start(self): + """Start the thread's activity. + + It must be called at most once per thread object. It arranges for the + object's run() method to be invoked in a separate thread of control. + + This method will raise a RuntimeError if called more than once on the + same thread object. + + """ + if not self._initialized: + raise RuntimeError("thread.__init__() not called") + + if self._started.is_set(): + raise RuntimeError("threads can only be started once") + + with _active_limbo_lock: + _limbo[self] = self + try: + _start_new_thread(self._bootstrap, ()) + except Exception: + with _active_limbo_lock: + del _limbo[self] + raise + self._started.wait() + + def run(self): + """Method representing the thread's activity. + + You may override this method in a subclass. The standard run() method + invokes the callable object passed to the object's constructor as the + target argument, if any, with sequential and keyword arguments taken + from the args and kwargs arguments, respectively. + + """ + try: + if self._target is not None: + self._target(*self._args, **self._kwargs) + finally: + # Avoid a refcycle if the thread is running a function with + # an argument that has a member that points to the thread. + del self._target, self._args, self._kwargs + + def _bootstrap(self): + # Wrapper around the real bootstrap code that ignores + # exceptions during interpreter cleanup. Those typically + # happen when a daemon thread wakes up at an unfortunate + # moment, finds the world around it destroyed, and raises some + # random exception *** while trying to report the exception in + # _bootstrap_inner() below ***. Those random exceptions + # don't help anybody, and they confuse users, so we suppress + # them. We suppress them only when it appears that the world + # indeed has already been destroyed, so that exceptions in + # _bootstrap_inner() during normal business hours are properly + # reported. Also, we only suppress them for daemonic threads; + # if a non-daemonic encounters this, something else is wrong. + try: + self._bootstrap_inner() + except: + if self._daemonic and _sys is None: + return + raise + + def _set_ident(self): + self._ident = get_ident() + + if _HAVE_THREAD_NATIVE_ID: + def _set_native_id(self): + self._native_id = get_native_id() + + def _set_tstate_lock(self): + """ + Set a lock object which will be released by the interpreter when + the underlying thread state (see pystate.h) gets deleted. + """ + self._tstate_lock = _set_sentinel() + self._tstate_lock.acquire() + + if not self.daemon: + with _shutdown_locks_lock: + _maintain_shutdown_locks() + _shutdown_locks.add(self._tstate_lock) + + def _bootstrap_inner(self): + try: + self._set_ident() + self._set_tstate_lock() + if _HAVE_THREAD_NATIVE_ID: + self._set_native_id() + self._started.set() + with _active_limbo_lock: + _active[self._ident] = self + del _limbo[self] + + if _trace_hook: + _sys.settrace(_trace_hook) + if _profile_hook: + _sys.setprofile(_profile_hook) + + try: + self.run() + except: + self._invoke_excepthook(self) + finally: + self._delete() + + def _stop(self): + # After calling ._stop(), .is_alive() returns False and .join() returns + # immediately. ._tstate_lock must be released before calling ._stop(). + # + # Normal case: C code at the end of the thread's life + # (release_sentinel in _threadmodule.c) releases ._tstate_lock, and + # that's detected by our ._wait_for_tstate_lock(), called by .join() + # and .is_alive(). Any number of threads _may_ call ._stop() + # simultaneously (for example, if multiple threads are blocked in + # .join() calls), and they're not serialized. That's harmless - + # they'll just make redundant rebindings of ._is_stopped and + # ._tstate_lock. Obscure: we rebind ._tstate_lock last so that the + # "assert self._is_stopped" in ._wait_for_tstate_lock() always works + # (the assert is executed only if ._tstate_lock is None). + # + # Special case: _main_thread releases ._tstate_lock via this + # module's _shutdown() function. + lock = self._tstate_lock + if lock is not None: + assert not lock.locked() + self._is_stopped = True + self._tstate_lock = None + if not self.daemon: + with _shutdown_locks_lock: + # Remove our lock and other released locks from _shutdown_locks + _maintain_shutdown_locks() + + def _delete(self): + "Remove current thread from the dict of currently running threads." + with _active_limbo_lock: + del _active[get_ident()] + # There must not be any python code between the previous line + # and after the lock is released. Otherwise a tracing function + # could try to acquire the lock again in the same thread, (in + # current_thread()), and would block. + + def join(self, timeout=None): + """Wait until the thread terminates. + + This blocks the calling thread until the thread whose join() method is + called terminates -- either normally or through an unhandled exception + or until the optional timeout occurs. + + When the timeout argument is present and not None, it should be a + floating point number specifying a timeout for the operation in seconds + (or fractions thereof). As join() always returns None, you must call + is_alive() after join() to decide whether a timeout happened -- if the + thread is still alive, the join() call timed out. + + When the timeout argument is not present or None, the operation will + block until the thread terminates. + + A thread can be join()ed many times. + + join() raises a RuntimeError if an attempt is made to join the current + thread as that would cause a deadlock. It is also an error to join() a + thread before it has been started and attempts to do so raises the same + exception. + + """ + if not self._initialized: + raise RuntimeError("Thread.__init__() not called") + if not self._started.is_set(): + raise RuntimeError("cannot join thread before it is started") + if self is current_thread(): + raise RuntimeError("cannot join current thread") + + if timeout is None: + self._wait_for_tstate_lock() + else: + # the behavior of a negative timeout isn't documented, but + # historically .join(timeout=x) for x<0 has acted as if timeout=0 + self._wait_for_tstate_lock(timeout=max(timeout, 0)) + + def _wait_for_tstate_lock(self, block=True, timeout=-1): + # Issue #18808: wait for the thread state to be gone. + # At the end of the thread's life, after all knowledge of the thread + # is removed from C data structures, C code releases our _tstate_lock. + # This method passes its arguments to _tstate_lock.acquire(). + # If the lock is acquired, the C code is done, and self._stop() is + # called. That sets ._is_stopped to True, and ._tstate_lock to None. + lock = self._tstate_lock + if lock is None: + # already determined that the C code is done + assert self._is_stopped + return + + try: + if lock.acquire(block, timeout): + lock.release() + self._stop() + except: + if lock.locked(): + # bpo-45274: lock.acquire() acquired the lock, but the function + # was interrupted with an exception before reaching the + # lock.release(). It can happen if a signal handler raises an + # exception, like CTRL+C which raises KeyboardInterrupt. + lock.release() + self._stop() + raise + + @property + def name(self): + """A string used for identification purposes only. + + It has no semantics. Multiple threads may be given the same name. The + initial name is set by the constructor. + + """ + assert self._initialized, "Thread.__init__() not called" + return self._name + + @name.setter + def name(self, name): + assert self._initialized, "Thread.__init__() not called" + self._name = str(name) + + @property + def ident(self): + """Thread identifier of this thread or None if it has not been started. + + This is a nonzero integer. See the get_ident() function. Thread + identifiers may be recycled when a thread exits and another thread is + created. The identifier is available even after the thread has exited. + + """ + assert self._initialized, "Thread.__init__() not called" + return self._ident + + if _HAVE_THREAD_NATIVE_ID: + @property + def native_id(self): + """Native integral thread ID of this thread, or None if it has not been started. + + This is a non-negative integer. See the get_native_id() function. + This represents the Thread ID as reported by the kernel. + + """ + assert self._initialized, "Thread.__init__() not called" + return self._native_id + + def is_alive(self): + """Return whether the thread is alive. + + This method returns True just before the run() method starts until just + after the run() method terminates. See also the module function + enumerate(). + + """ + assert self._initialized, "Thread.__init__() not called" + if self._is_stopped or not self._started.is_set(): + return False + self._wait_for_tstate_lock(False) + return not self._is_stopped + + @property + def daemon(self): + """A boolean value indicating whether this thread is a daemon thread. + + This must be set before start() is called, otherwise RuntimeError is + raised. Its initial value is inherited from the creating thread; the + main thread is not a daemon thread and therefore all threads created in + the main thread default to daemon = False. + + The entire Python program exits when only daemon threads are left. + + """ + assert self._initialized, "Thread.__init__() not called" + return self._daemonic + + @daemon.setter + def daemon(self, daemonic): + if not self._initialized: + raise RuntimeError("Thread.__init__() not called") + if self._started.is_set(): + raise RuntimeError("cannot set daemon status of active thread") + self._daemonic = daemonic + + def isDaemon(self): + """Return whether this thread is a daemon. + + This method is deprecated, use the daemon attribute instead. + + """ + import warnings + warnings.warn('isDaemon() is deprecated, get the daemon attribute instead', + DeprecationWarning, stacklevel=2) + return self.daemon + + def setDaemon(self, daemonic): + """Set whether this thread is a daemon. + + This method is deprecated, use the .daemon property instead. + + """ + import warnings + warnings.warn('setDaemon() is deprecated, set the daemon attribute instead', + DeprecationWarning, stacklevel=2) + self.daemon = daemonic + + def getName(self): + """Return a string used for identification purposes only. + + This method is deprecated, use the name attribute instead. + + """ + import warnings + warnings.warn('getName() is deprecated, get the name attribute instead', + DeprecationWarning, stacklevel=2) + return self.name + + def setName(self, name): + """Set the name string for this thread. + + This method is deprecated, use the name attribute instead. + + """ + import warnings + warnings.warn('setName() is deprecated, set the name attribute instead', + DeprecationWarning, stacklevel=2) + self.name = name + + +try: + from _thread import (_excepthook as excepthook, + _ExceptHookArgs as ExceptHookArgs) +except ImportError: + # Simple Python implementation if _thread._excepthook() is not available + from traceback import print_exception as _print_exception + from collections import namedtuple + + _ExceptHookArgs = namedtuple( + 'ExceptHookArgs', + 'exc_type exc_value exc_traceback thread') + + def ExceptHookArgs(args): + return _ExceptHookArgs(*args) + + def excepthook(args, /): + """ + Handle uncaught Thread.run() exception. + """ + if args.exc_type == SystemExit: + # silently ignore SystemExit + return + + if _sys is not None and _sys.stderr is not None: + stderr = _sys.stderr + elif args.thread is not None: + stderr = args.thread._stderr + if stderr is None: + # do nothing if sys.stderr is None and sys.stderr was None + # when the thread was created + return + else: + # do nothing if sys.stderr is None and args.thread is None + return + + if args.thread is not None: + name = args.thread.name + else: + name = get_ident() + print(f"Exception in thread {name}:", + file=stderr, flush=True) + _print_exception(args.exc_type, args.exc_value, args.exc_traceback, + file=stderr) + stderr.flush() + + +# Original value of threading.excepthook +__excepthook__ = excepthook + + +def _make_invoke_excepthook(): + # Create a local namespace to ensure that variables remain alive + # when _invoke_excepthook() is called, even if it is called late during + # Python shutdown. It is mostly needed for daemon threads. + + old_excepthook = excepthook + old_sys_excepthook = _sys.excepthook + if old_excepthook is None: + raise RuntimeError("threading.excepthook is None") + if old_sys_excepthook is None: + raise RuntimeError("sys.excepthook is None") + + sys_exc_info = _sys.exc_info + local_print = print + local_sys = _sys + + def invoke_excepthook(thread): + global excepthook + try: + hook = excepthook + if hook is None: + hook = old_excepthook + + args = ExceptHookArgs([*sys_exc_info(), thread]) + + hook(args) + except Exception as exc: + exc.__suppress_context__ = True + del exc + + if local_sys is not None and local_sys.stderr is not None: + stderr = local_sys.stderr + else: + stderr = thread._stderr + + local_print("Exception in threading.excepthook:", + file=stderr, flush=True) + + if local_sys is not None and local_sys.excepthook is not None: + sys_excepthook = local_sys.excepthook + else: + sys_excepthook = old_sys_excepthook + + sys_excepthook(*sys_exc_info()) + finally: + # Break reference cycle (exception stored in a variable) + args = None + + return invoke_excepthook + + +# The timer class was contributed by Itamar Shtull-Trauring + +class Timer(Thread): + """Call a function after a specified number of seconds: + + t = Timer(30.0, f, args=None, kwargs=None) + t.start() + t.cancel() # stop the timer's action if it's still waiting + + """ + + def __init__(self, interval, function, args=None, kwargs=None): + Thread.__init__(self) + self.interval = interval + self.function = function + self.args = args if args is not None else [] + self.kwargs = kwargs if kwargs is not None else {} + self.finished = Event() + + def cancel(self): + """Stop the timer if it hasn't finished yet.""" + self.finished.set() + + def run(self): + self.finished.wait(self.interval) + if not self.finished.is_set(): + self.function(*self.args, **self.kwargs) + self.finished.set() + + +# Special thread class to represent the main thread + +class _MainThread(Thread): + + def __init__(self): + Thread.__init__(self, name="MainThread", daemon=False) + self._set_tstate_lock() + self._started.set() + self._set_ident() + if _HAVE_THREAD_NATIVE_ID: + self._set_native_id() + with _active_limbo_lock: + _active[self._ident] = self + + +# Dummy thread class to represent threads not started here. +# These aren't garbage collected when they die, nor can they be waited for. +# If they invoke anything in threading.py that calls current_thread(), they +# leave an entry in the _active dict forever after. +# Their purpose is to return *something* from current_thread(). +# They are marked as daemon threads so we won't wait for them +# when we exit (conform previous semantics). + +class _DummyThread(Thread): + + def __init__(self): + Thread.__init__(self, name=_newname("Dummy-%d"), daemon=True) + + self._started.set() + self._set_ident() + if _HAVE_THREAD_NATIVE_ID: + self._set_native_id() + with _active_limbo_lock: + _active[self._ident] = self + + def _stop(self): + pass + + def is_alive(self): + assert not self._is_stopped and self._started.is_set() + return True + + def join(self, timeout=None): + assert False, "cannot join a dummy thread" + + +# Global API functions + +def current_thread(): + """Return the current Thread object, corresponding to the caller's thread of control. + + If the caller's thread of control was not created through the threading + module, a dummy thread object with limited functionality is returned. + + """ + try: + return _active[get_ident()] + except KeyError: + return _DummyThread() + +def currentThread(): + """Return the current Thread object, corresponding to the caller's thread of control. + + This function is deprecated, use current_thread() instead. + + """ + import warnings + warnings.warn('currentThread() is deprecated, use current_thread() instead', + DeprecationWarning, stacklevel=2) + return current_thread() + +def active_count(): + """Return the number of Thread objects currently alive. + + The returned count is equal to the length of the list returned by + enumerate(). + + """ + with _active_limbo_lock: + return len(_active) + len(_limbo) + +def activeCount(): + """Return the number of Thread objects currently alive. + + This function is deprecated, use active_count() instead. + + """ + import warnings + warnings.warn('activeCount() is deprecated, use active_count() instead', + DeprecationWarning, stacklevel=2) + return active_count() + +def _enumerate(): + # Same as enumerate(), but without the lock. Internal use only. + return list(_active.values()) + list(_limbo.values()) + +def enumerate(): + """Return a list of all Thread objects currently alive. + + The list includes daemonic threads, dummy thread objects created by + current_thread(), and the main thread. It excludes terminated threads and + threads that have not yet been started. + + """ + with _active_limbo_lock: + return list(_active.values()) + list(_limbo.values()) + + +_threading_atexits = [] +_SHUTTING_DOWN = False + +def _register_atexit(func, *arg, **kwargs): + """CPython internal: register *func* to be called before joining threads. + + The registered *func* is called with its arguments just before all + non-daemon threads are joined in `_shutdown()`. It provides a similar + purpose to `atexit.register()`, but its functions are called prior to + threading shutdown instead of interpreter shutdown. + + For similarity to atexit, the registered functions are called in reverse. + """ + if _SHUTTING_DOWN: + raise RuntimeError("can't register atexit after shutdown") + + call = functools.partial(func, *arg, **kwargs) + _threading_atexits.append(call) + + +from _thread import stack_size + +# Create the main thread object, +# and make it available for the interpreter +# (Py_Main) as threading._shutdown. + +_main_thread = _MainThread() + +def _shutdown(): + """ + Wait until the Python thread state of all non-daemon threads get deleted. + """ + # Obscure: other threads may be waiting to join _main_thread. That's + # dubious, but some code does it. We can't wait for C code to release + # the main thread's tstate_lock - that won't happen until the interpreter + # is nearly dead. So we release it here. Note that just calling _stop() + # isn't enough: other threads may already be waiting on _tstate_lock. + if _main_thread._is_stopped: + # _shutdown() was already called + return + + global _SHUTTING_DOWN + _SHUTTING_DOWN = True + + # Call registered threading atexit functions before threads are joined. + # Order is reversed, similar to atexit. + for atexit_call in reversed(_threading_atexits): + atexit_call() + + # Main thread + if _main_thread.ident == get_ident(): + tlock = _main_thread._tstate_lock + # The main thread isn't finished yet, so its thread state lock can't + # have been released. + assert tlock is not None + assert tlock.locked() + tlock.release() + _main_thread._stop() + else: + # bpo-1596321: _shutdown() must be called in the main thread. + # If the threading module was not imported by the main thread, + # _main_thread is the thread which imported the threading module. + # In this case, ignore _main_thread, similar behavior than for threads + # spawned by C libraries or using _thread.start_new_thread(). + pass + + # Join all non-deamon threads + while True: + with _shutdown_locks_lock: + locks = list(_shutdown_locks) + _shutdown_locks.clear() + + if not locks: + break + + for lock in locks: + # mimic Thread.join() + lock.acquire() + lock.release() + + # new threads can be spawned while we were waiting for the other + # threads to complete + + +def main_thread(): + """Return the main thread object. + + In normal conditions, the main thread is the thread from which the + Python interpreter was started. + """ + return _main_thread + +# get thread-local implementation, either from the thread +# module, or from the python fallback + +try: + from _thread import _local as local +except ImportError: + from _threading_local import local + + +def _after_fork(): + """ + Cleanup threading module state that should not exist after a fork. + """ + # Reset _active_limbo_lock, in case we forked while the lock was held + # by another (non-forked) thread. http://bugs.python.org/issue874900 + global _active_limbo_lock, _main_thread + global _shutdown_locks_lock, _shutdown_locks + _active_limbo_lock = RLock() + + # fork() only copied the current thread; clear references to others. + new_active = {} + + try: + current = _active[get_ident()] + except KeyError: + # fork() was called in a thread which was not spawned + # by threading.Thread. For example, a thread spawned + # by thread.start_new_thread(). + current = _MainThread() + + _main_thread = current + + # reset _shutdown() locks: threads re-register their _tstate_lock below + _shutdown_locks_lock = _allocate_lock() + _shutdown_locks = set() + + with _active_limbo_lock: + # Dangling thread instances must still have their locks reset, + # because someone may join() them. + threads = set(_enumerate()) + threads.update(_dangling) + for thread in threads: + # Any lock/condition variable may be currently locked or in an + # invalid state, so we reinitialize them. + if thread is current: + # There is only one active thread. We reset the ident to + # its new value since it can have changed. + thread._reset_internal_locks(True) + ident = get_ident() + if isinstance(thread, _DummyThread): + thread.__class__ = _MainThread + thread._name = 'MainThread' + thread._daemonic = False + thread._set_tstate_lock() + thread._ident = ident + new_active[ident] = thread + else: + # All the others are already stopped. + thread._reset_internal_locks(False) + thread._stop() + + _limbo.clear() + _active.clear() + _active.update(new_active) + assert len(_active) == 1 + + +if hasattr(_os, "register_at_fork"): + _os.register_at_fork(after_in_child=_after_fork) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/timeit.py b/physworld_p1_20261018/envs/p1/lib/python3.11/timeit.py new file mode 100644 index 0000000000000000000000000000000000000000..3250563f4222ddfd49b4ccc3b16c30ab3628f62c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/timeit.py @@ -0,0 +1,382 @@ +#! /usr/bin/env python3 + +"""Tool for measuring execution time of small code snippets. + +This module avoids a number of common traps for measuring execution +times. See also Tim Peters' introduction to the Algorithms chapter in +the Python Cookbook, published by O'Reilly. + +Library usage: see the Timer class. + +Command line usage: + python timeit.py [-n N] [-r N] [-s S] [-p] [-h] [--] [statement] + +Options: + -n/--number N: how many times to execute 'statement' (default: see below) + -r/--repeat N: how many times to repeat the timer (default 5) + -s/--setup S: statement to be executed once initially (default 'pass'). + Execution time of this setup statement is NOT timed. + -p/--process: use time.process_time() (default is time.perf_counter()) + -v/--verbose: print raw timing results; repeat for more digits precision + -u/--unit: set the output time unit (nsec, usec, msec, or sec) + -h/--help: print this usage message and exit + --: separate options from statement, use when statement starts with - + statement: statement to be timed (default 'pass') + +A multi-line statement may be given by specifying each line as a +separate argument; indented lines are possible by enclosing an +argument in quotes and using leading spaces. Multiple -s options are +treated similarly. + +If -n is not given, a suitable number of loops is calculated by trying +increasing numbers from the sequence 1, 2, 5, 10, 20, 50, ... until the +total time is at least 0.2 seconds. + +Note: there is a certain baseline overhead associated with executing a +pass statement. It differs between versions. The code here doesn't try +to hide it, but you should be aware of it. The baseline overhead can be +measured by invoking the program without arguments. + +Classes: + + Timer + +Functions: + + timeit(string, string) -> float + repeat(string, string) -> list + default_timer() -> float + +""" + +import gc +import itertools +import sys +import time + +__all__ = ["Timer", "timeit", "repeat", "default_timer"] + +dummy_src_name = "" +default_number = 1000000 +default_repeat = 5 +default_timer = time.perf_counter + +_globals = globals + +# Don't change the indentation of the template; the reindent() calls +# in Timer.__init__() depend on setup being indented 4 spaces and stmt +# being indented 8 spaces. +template = """ +def inner(_it, _timer{init}): + {setup} + _t0 = _timer() + for _i in _it: + {stmt} + pass + _t1 = _timer() + return _t1 - _t0 +""" + + +def reindent(src, indent): + """Helper to reindent a multi-line statement.""" + return src.replace("\n", "\n" + " " * indent) + + +class Timer: + """Class for timing execution speed of small code snippets. + + The constructor takes a statement to be timed, an additional + statement used for setup, and a timer function. Both statements + default to 'pass'; the timer function is platform-dependent (see + module doc string). If 'globals' is specified, the code will be + executed within that namespace (as opposed to inside timeit's + namespace). + + To measure the execution time of the first statement, use the + timeit() method. The repeat() method is a convenience to call + timeit() multiple times and return a list of results. + + The statements may contain newlines, as long as they don't contain + multi-line string literals. + """ + + def __init__(self, stmt="pass", setup="pass", timer=default_timer, + globals=None): + """Constructor. See class doc string.""" + self.timer = timer + local_ns = {} + global_ns = _globals() if globals is None else globals + init = '' + if isinstance(setup, str): + # Check that the code can be compiled outside a function + compile(setup, dummy_src_name, "exec") + stmtprefix = setup + '\n' + setup = reindent(setup, 4) + elif callable(setup): + local_ns['_setup'] = setup + init += ', _setup=_setup' + stmtprefix = '' + setup = '_setup()' + else: + raise ValueError("setup is neither a string nor callable") + if isinstance(stmt, str): + # Check that the code can be compiled outside a function + compile(stmtprefix + stmt, dummy_src_name, "exec") + stmt = reindent(stmt, 8) + elif callable(stmt): + local_ns['_stmt'] = stmt + init += ', _stmt=_stmt' + stmt = '_stmt()' + else: + raise ValueError("stmt is neither a string nor callable") + src = template.format(stmt=stmt, setup=setup, init=init) + self.src = src # Save for traceback display + code = compile(src, dummy_src_name, "exec") + exec(code, global_ns, local_ns) + self.inner = local_ns["inner"] + + def print_exc(self, file=None): + """Helper to print a traceback from the timed code. + + Typical use: + + t = Timer(...) # outside the try/except + try: + t.timeit(...) # or t.repeat(...) + except: + t.print_exc() + + The advantage over the standard traceback is that source lines + in the compiled template will be displayed. + + The optional file argument directs where the traceback is + sent; it defaults to sys.stderr. + """ + import linecache, traceback + if self.src is not None: + linecache.cache[dummy_src_name] = (len(self.src), + None, + self.src.split("\n"), + dummy_src_name) + # else the source is already stored somewhere else + + traceback.print_exc(file=file) + + def timeit(self, number=default_number): + """Time 'number' executions of the main statement. + + To be precise, this executes the setup statement once, and + then returns the time it takes to execute the main statement + a number of times, as float seconds if using the default timer. The + argument is the number of times through the loop, defaulting + to one million. The main statement, the setup statement and + the timer function to be used are passed to the constructor. + """ + it = itertools.repeat(None, number) + gcold = gc.isenabled() + gc.disable() + try: + timing = self.inner(it, self.timer) + finally: + if gcold: + gc.enable() + return timing + + def repeat(self, repeat=default_repeat, number=default_number): + """Call timeit() a few times. + + This is a convenience function that calls the timeit() + repeatedly, returning a list of results. The first argument + specifies how many times to call timeit(), defaulting to 5; + the second argument specifies the timer argument, defaulting + to one million. + + Note: it's tempting to calculate mean and standard deviation + from the result vector and report these. However, this is not + very useful. In a typical case, the lowest value gives a + lower bound for how fast your machine can run the given code + snippet; higher values in the result vector are typically not + caused by variability in Python's speed, but by other + processes interfering with your timing accuracy. So the min() + of the result is probably the only number you should be + interested in. After that, you should look at the entire + vector and apply common sense rather than statistics. + """ + r = [] + for i in range(repeat): + t = self.timeit(number) + r.append(t) + return r + + def autorange(self, callback=None): + """Return the number of loops and time taken so that total time >= 0.2. + + Calls the timeit method with increasing numbers from the sequence + 1, 2, 5, 10, 20, 50, ... until the time taken is at least 0.2 + second. Returns (number, time_taken). + + If *callback* is given and is not None, it will be called after + each trial with two arguments: ``callback(number, time_taken)``. + """ + i = 1 + while True: + for j in 1, 2, 5: + number = i * j + time_taken = self.timeit(number) + if callback: + callback(number, time_taken) + if time_taken >= 0.2: + return (number, time_taken) + i *= 10 + + +def timeit(stmt="pass", setup="pass", timer=default_timer, + number=default_number, globals=None): + """Convenience function to create Timer object and call timeit method.""" + return Timer(stmt, setup, timer, globals).timeit(number) + + +def repeat(stmt="pass", setup="pass", timer=default_timer, + repeat=default_repeat, number=default_number, globals=None): + """Convenience function to create Timer object and call repeat method.""" + return Timer(stmt, setup, timer, globals).repeat(repeat, number) + + +def main(args=None, *, _wrap_timer=None): + """Main program, used when run as a script. + + The optional 'args' argument specifies the command line to be parsed, + defaulting to sys.argv[1:]. + + The return value is an exit code to be passed to sys.exit(); it + may be None to indicate success. + + When an exception happens during timing, a traceback is printed to + stderr and the return value is 1. Exceptions at other times + (including the template compilation) are not caught. + + '_wrap_timer' is an internal interface used for unit testing. If it + is not None, it must be a callable that accepts a timer function + and returns another timer function (used for unit testing). + """ + if args is None: + args = sys.argv[1:] + import getopt + try: + opts, args = getopt.getopt(args, "n:u:s:r:tcpvh", + ["number=", "setup=", "repeat=", + "time", "clock", "process", + "verbose", "unit=", "help"]) + except getopt.error as err: + print(err) + print("use -h/--help for command line help") + return 2 + + timer = default_timer + stmt = "\n".join(args) or "pass" + number = 0 # auto-determine + setup = [] + repeat = default_repeat + verbose = 0 + time_unit = None + units = {"nsec": 1e-9, "usec": 1e-6, "msec": 1e-3, "sec": 1.0} + precision = 3 + for o, a in opts: + if o in ("-n", "--number"): + number = int(a) + if o in ("-s", "--setup"): + setup.append(a) + if o in ("-u", "--unit"): + if a in units: + time_unit = a + else: + print("Unrecognized unit. Please select nsec, usec, msec, or sec.", + file=sys.stderr) + return 2 + if o in ("-r", "--repeat"): + repeat = int(a) + if repeat <= 0: + repeat = 1 + if o in ("-p", "--process"): + timer = time.process_time + if o in ("-v", "--verbose"): + if verbose: + precision += 1 + verbose += 1 + if o in ("-h", "--help"): + print(__doc__, end=' ') + return 0 + setup = "\n".join(setup) or "pass" + + # Include the current directory, so that local imports work (sys.path + # contains the directory of this script, rather than the current + # directory) + import os + sys.path.insert(0, os.curdir) + if _wrap_timer is not None: + timer = _wrap_timer(timer) + + t = Timer(stmt, setup, timer) + if number == 0: + # determine number so that 0.2 <= total time < 2.0 + callback = None + if verbose: + def callback(number, time_taken): + msg = "{num} loop{s} -> {secs:.{prec}g} secs" + plural = (number != 1) + print(msg.format(num=number, s='s' if plural else '', + secs=time_taken, prec=precision)) + try: + number, _ = t.autorange(callback) + except: + t.print_exc() + return 1 + + if verbose: + print() + + try: + raw_timings = t.repeat(repeat, number) + except: + t.print_exc() + return 1 + + def format_time(dt): + unit = time_unit + + if unit is not None: + scale = units[unit] + else: + scales = [(scale, unit) for unit, scale in units.items()] + scales.sort(reverse=True) + for scale, unit in scales: + if dt >= scale: + break + + return "%.*g %s" % (precision, dt / scale, unit) + + if verbose: + print("raw times: %s" % ", ".join(map(format_time, raw_timings))) + print() + timings = [dt / number for dt in raw_timings] + + best = min(timings) + print("%d loop%s, best of %d: %s per loop" + % (number, 's' if number != 1 else '', + repeat, format_time(best))) + + best = min(timings) + worst = max(timings) + if worst >= best * 4: + import warnings + warnings.warn_explicit("The test results are likely unreliable. " + "The worst time (%s) was more than four times " + "slower than the best time (%s)." + % (format_time(worst), format_time(best)), + UserWarning, '', 0) + return None + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..254f63f7dd6561768969b1ee03bfbaf2d6a2b6f4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__init__.py @@ -0,0 +1,4668 @@ +"""Wrapper functions for Tcl/Tk. + +Tkinter provides classes which allow the display, positioning and +control of widgets. Toplevel widgets are Tk and Toplevel. Other +widgets are Frame, Label, Entry, Text, Canvas, Button, Radiobutton, +Checkbutton, Scale, Listbox, Scrollbar, OptionMenu, Spinbox +LabelFrame and PanedWindow. + +Properties of the widgets are specified with keyword arguments. +Keyword arguments have the same name as the corresponding resource +under Tk. + +Widgets are positioned with one of the geometry managers Place, Pack +or Grid. These managers can be called with methods place, pack, grid +available in every Widget. + +Actions are bound to events by resources (e.g. keyword argument +command) or with the method bind. + +Example (Hello, World): +import tkinter +from tkinter.constants import * +tk = tkinter.Tk() +frame = tkinter.Frame(tk, relief=RIDGE, borderwidth=2) +frame.pack(fill=BOTH,expand=1) +label = tkinter.Label(frame, text="Hello, World") +label.pack(fill=X, expand=1) +button = tkinter.Button(frame,text="Exit",command=tk.destroy) +button.pack(side=BOTTOM) +tk.mainloop() +""" + +import collections +import enum +import sys +import types + +import _tkinter # If this fails your Python may not be configured for Tk +TclError = _tkinter.TclError +from tkinter.constants import * +import re + +wantobjects = 1 + +TkVersion = float(_tkinter.TK_VERSION) +TclVersion = float(_tkinter.TCL_VERSION) + +READABLE = _tkinter.READABLE +WRITABLE = _tkinter.WRITABLE +EXCEPTION = _tkinter.EXCEPTION + + +_magic_re = re.compile(r'([\\{}])') +_space_re = re.compile(r'([\s])', re.ASCII) + + +def _join(value): + """Internal function.""" + return ' '.join(map(_stringify, value)) + + +def _stringify(value): + """Internal function.""" + if isinstance(value, (list, tuple)): + if len(value) == 1: + value = _stringify(value[0]) + if _magic_re.search(value): + value = '{%s}' % value + else: + value = '{%s}' % _join(value) + else: + value = str(value) + if not value: + value = '{}' + elif _magic_re.search(value): + # add '\' before special characters and spaces + value = _magic_re.sub(r'\\\1', value) + value = value.replace('\n', r'\n') + value = _space_re.sub(r'\\\1', value) + if value[0] == '"': + value = '\\' + value + elif value[0] == '"' or _space_re.search(value): + value = '{%s}' % value + return value + + +def _flatten(seq): + """Internal function.""" + res = () + for item in seq: + if isinstance(item, (tuple, list)): + res = res + _flatten(item) + elif item is not None: + res = res + (item,) + return res + + +try: _flatten = _tkinter._flatten +except AttributeError: pass + + +def _cnfmerge(cnfs): + """Internal function.""" + if isinstance(cnfs, dict): + return cnfs + elif isinstance(cnfs, (type(None), str)): + return cnfs + else: + cnf = {} + for c in _flatten(cnfs): + try: + cnf.update(c) + except (AttributeError, TypeError) as msg: + print("_cnfmerge: fallback due to:", msg) + for k, v in c.items(): + cnf[k] = v + return cnf + + +try: _cnfmerge = _tkinter._cnfmerge +except AttributeError: pass + + +def _splitdict(tk, v, cut_minus=True, conv=None): + """Return a properly formatted dict built from Tcl list pairs. + + If cut_minus is True, the supposed '-' prefix will be removed from + keys. If conv is specified, it is used to convert values. + + Tcl list is expected to contain an even number of elements. + """ + t = tk.splitlist(v) + if len(t) % 2: + raise RuntimeError('Tcl list representing a dict is expected ' + 'to contain an even number of elements') + it = iter(t) + dict = {} + for key, value in zip(it, it): + key = str(key) + if cut_minus and key[0] == '-': + key = key[1:] + if conv: + value = conv(value) + dict[key] = value + return dict + +class _VersionInfoType(collections.namedtuple('_VersionInfoType', + ('major', 'minor', 'micro', 'releaselevel', 'serial'))): + def __str__(self): + if self.releaselevel == 'final': + return f'{self.major}.{self.minor}.{self.micro}' + else: + return f'{self.major}.{self.minor}{self.releaselevel[0]}{self.serial}' + +def _parse_version(version): + import re + m = re.fullmatch(r'(\d+)\.(\d+)([ab.])(\d+)', version) + major, minor, releaselevel, serial = m.groups() + major, minor, serial = int(major), int(minor), int(serial) + if releaselevel == '.': + micro = serial + serial = 0 + releaselevel = 'final' + else: + micro = 0 + releaselevel = {'a': 'alpha', 'b': 'beta'}[releaselevel] + return _VersionInfoType(major, minor, micro, releaselevel, serial) + + +@enum._simple_enum(enum.StrEnum) +class EventType: + KeyPress = '2' + Key = KeyPress + KeyRelease = '3' + ButtonPress = '4' + Button = ButtonPress + ButtonRelease = '5' + Motion = '6' + Enter = '7' + Leave = '8' + FocusIn = '9' + FocusOut = '10' + Keymap = '11' # undocumented + Expose = '12' + GraphicsExpose = '13' # undocumented + NoExpose = '14' # undocumented + Visibility = '15' + Create = '16' + Destroy = '17' + Unmap = '18' + Map = '19' + MapRequest = '20' + Reparent = '21' + Configure = '22' + ConfigureRequest = '23' + Gravity = '24' + ResizeRequest = '25' + Circulate = '26' + CirculateRequest = '27' + Property = '28' + SelectionClear = '29' # undocumented + SelectionRequest = '30' # undocumented + Selection = '31' # undocumented + Colormap = '32' + ClientMessage = '33' # undocumented + Mapping = '34' # undocumented + VirtualEvent = '35' # undocumented + Activate = '36' + Deactivate = '37' + MouseWheel = '38' + + +class Event: + """Container for the properties of an event. + + Instances of this type are generated if one of the following events occurs: + + KeyPress, KeyRelease - for keyboard events + ButtonPress, ButtonRelease, Motion, Enter, Leave, MouseWheel - for mouse events + Visibility, Unmap, Map, Expose, FocusIn, FocusOut, Circulate, + Colormap, Gravity, Reparent, Property, Destroy, Activate, + Deactivate - for window events. + + If a callback function for one of these events is registered + using bind, bind_all, bind_class, or tag_bind, the callback is + called with an Event as first argument. It will have the + following attributes (in braces are the event types for which + the attribute is valid): + + serial - serial number of event + num - mouse button pressed (ButtonPress, ButtonRelease) + focus - whether the window has the focus (Enter, Leave) + height - height of the exposed window (Configure, Expose) + width - width of the exposed window (Configure, Expose) + keycode - keycode of the pressed key (KeyPress, KeyRelease) + state - state of the event as a number (ButtonPress, ButtonRelease, + Enter, KeyPress, KeyRelease, + Leave, Motion) + state - state as a string (Visibility) + time - when the event occurred + x - x-position of the mouse + y - y-position of the mouse + x_root - x-position of the mouse on the screen + (ButtonPress, ButtonRelease, KeyPress, KeyRelease, Motion) + y_root - y-position of the mouse on the screen + (ButtonPress, ButtonRelease, KeyPress, KeyRelease, Motion) + char - pressed character (KeyPress, KeyRelease) + send_event - see X/Windows documentation + keysym - keysym of the event as a string (KeyPress, KeyRelease) + keysym_num - keysym of the event as a number (KeyPress, KeyRelease) + type - type of the event as a number + widget - widget in which the event occurred + delta - delta of wheel movement (MouseWheel) + """ + + def __repr__(self): + attrs = {k: v for k, v in self.__dict__.items() if v != '??'} + if not self.char: + del attrs['char'] + elif self.char != '??': + attrs['char'] = repr(self.char) + if not getattr(self, 'send_event', True): + del attrs['send_event'] + if self.state == 0: + del attrs['state'] + elif isinstance(self.state, int): + state = self.state + mods = ('Shift', 'Lock', 'Control', + 'Mod1', 'Mod2', 'Mod3', 'Mod4', 'Mod5', + 'Button1', 'Button2', 'Button3', 'Button4', 'Button5') + s = [] + for i, n in enumerate(mods): + if state & (1 << i): + s.append(n) + state = state & ~((1<< len(mods)) - 1) + if state or not s: + s.append(hex(state)) + attrs['state'] = '|'.join(s) + if self.delta == 0: + del attrs['delta'] + # widget usually is known + # serial and time are not very interesting + # keysym_num duplicates keysym + # x_root and y_root mostly duplicate x and y + keys = ('send_event', + 'state', 'keysym', 'keycode', 'char', + 'num', 'delta', 'focus', + 'x', 'y', 'width', 'height') + return '<%s event%s>' % ( + getattr(self.type, 'name', self.type), + ''.join(' %s=%s' % (k, attrs[k]) for k in keys if k in attrs) + ) + + +_support_default_root = True +_default_root = None + + +def NoDefaultRoot(): + """Inhibit setting of default root window. + + Call this function to inhibit that the first instance of + Tk is used for windows without an explicit parent window. + """ + global _support_default_root, _default_root + _support_default_root = False + # Delete, so any use of _default_root will immediately raise an exception. + # Rebind before deletion, so repeated calls will not fail. + _default_root = None + del _default_root + + +def _get_default_root(what=None): + if not _support_default_root: + raise RuntimeError("No master specified and tkinter is " + "configured to not support default root") + if _default_root is None: + if what: + raise RuntimeError(f"Too early to {what}: no default root window") + root = Tk() + assert _default_root is root + return _default_root + + +def _get_temp_root(): + global _support_default_root + if not _support_default_root: + raise RuntimeError("No master specified and tkinter is " + "configured to not support default root") + root = _default_root + if root is None: + assert _support_default_root + _support_default_root = False + root = Tk() + _support_default_root = True + assert _default_root is None + root.withdraw() + root._temporary = True + return root + + +def _destroy_temp_root(master): + if getattr(master, '_temporary', False): + try: + master.destroy() + except TclError: + pass + + +def _tkerror(err): + """Internal function.""" + pass + + +def _exit(code=0): + """Internal function. Calling it will raise the exception SystemExit.""" + try: + code = int(code) + except ValueError: + pass + raise SystemExit(code) + + +_varnum = 0 + + +class Variable: + """Class to define value holders for e.g. buttons. + + Subclasses StringVar, IntVar, DoubleVar, BooleanVar are specializations + that constrain the type of the value returned from get().""" + _default = "" + _tk = None + _tclCommands = None + + def __init__(self, master=None, value=None, name=None): + """Construct a variable + + MASTER can be given as master widget. + VALUE is an optional value (defaults to "") + NAME is an optional Tcl name (defaults to PY_VARnum). + + If NAME matches an existing variable and VALUE is omitted + then the existing value is retained. + """ + # check for type of NAME parameter to override weird error message + # raised from Modules/_tkinter.c:SetVar like: + # TypeError: setvar() takes exactly 3 arguments (2 given) + if name is not None and not isinstance(name, str): + raise TypeError("name must be a string") + global _varnum + if master is None: + master = _get_default_root('create variable') + self._root = master._root() + self._tk = master.tk + if name: + self._name = name + else: + self._name = 'PY_VAR' + repr(_varnum) + _varnum += 1 + if value is not None: + self.initialize(value) + elif not self._tk.getboolean(self._tk.call("info", "exists", self._name)): + self.initialize(self._default) + + def __del__(self): + """Unset the variable in Tcl.""" + if self._tk is None: + return + if self._tk.getboolean(self._tk.call("info", "exists", self._name)): + self._tk.globalunsetvar(self._name) + if self._tclCommands is not None: + for name in self._tclCommands: + #print '- Tkinter: deleted command', name + self._tk.deletecommand(name) + self._tclCommands = None + + def __str__(self): + """Return the name of the variable in Tcl.""" + return self._name + + def set(self, value): + """Set the variable to VALUE.""" + return self._tk.globalsetvar(self._name, value) + + initialize = set + + def get(self): + """Return value of variable.""" + return self._tk.globalgetvar(self._name) + + def _register(self, callback): + f = CallWrapper(callback, None, self._root).__call__ + cbname = repr(id(f)) + try: + callback = callback.__func__ + except AttributeError: + pass + try: + cbname = cbname + callback.__name__ + except AttributeError: + pass + self._tk.createcommand(cbname, f) + if self._tclCommands is None: + self._tclCommands = [] + self._tclCommands.append(cbname) + return cbname + + def trace_add(self, mode, callback): + """Define a trace callback for the variable. + + Mode is one of "read", "write", "unset", or a list or tuple of + such strings. + Callback must be a function which is called when the variable is + read, written or unset. + + Return the name of the callback. + """ + cbname = self._register(callback) + self._tk.call('trace', 'add', 'variable', + self._name, mode, (cbname,)) + return cbname + + def trace_remove(self, mode, cbname): + """Delete the trace callback for a variable. + + Mode is one of "read", "write", "unset" or a list or tuple of + such strings. Must be same as were specified in trace_add(). + cbname is the name of the callback returned from trace_add(). + """ + self._tk.call('trace', 'remove', 'variable', + self._name, mode, cbname) + for m, ca in self.trace_info(): + if self._tk.splitlist(ca)[0] == cbname: + break + else: + self._tk.deletecommand(cbname) + try: + self._tclCommands.remove(cbname) + except ValueError: + pass + + def trace_info(self): + """Return all trace callback information.""" + splitlist = self._tk.splitlist + return [(splitlist(k), v) for k, v in map(splitlist, + splitlist(self._tk.call('trace', 'info', 'variable', self._name)))] + + def trace_variable(self, mode, callback): + """Define a trace callback for the variable. + + MODE is one of "r", "w", "u" for read, write, undefine. + CALLBACK must be a function which is called when + the variable is read, written or undefined. + + Return the name of the callback. + + This deprecated method wraps a deprecated Tcl method that will + likely be removed in the future. Use trace_add() instead. + """ + # TODO: Add deprecation warning + cbname = self._register(callback) + self._tk.call("trace", "variable", self._name, mode, cbname) + return cbname + + trace = trace_variable + + def trace_vdelete(self, mode, cbname): + """Delete the trace callback for a variable. + + MODE is one of "r", "w", "u" for read, write, undefine. + CBNAME is the name of the callback returned from trace_variable or trace. + + This deprecated method wraps a deprecated Tcl method that will + likely be removed in the future. Use trace_remove() instead. + """ + # TODO: Add deprecation warning + self._tk.call("trace", "vdelete", self._name, mode, cbname) + cbname = self._tk.splitlist(cbname)[0] + for m, ca in self.trace_info(): + if self._tk.splitlist(ca)[0] == cbname: + break + else: + self._tk.deletecommand(cbname) + try: + self._tclCommands.remove(cbname) + except ValueError: + pass + + def trace_vinfo(self): + """Return all trace callback information. + + This deprecated method wraps a deprecated Tcl method that will + likely be removed in the future. Use trace_info() instead. + """ + # TODO: Add deprecation warning + return [self._tk.splitlist(x) for x in self._tk.splitlist( + self._tk.call("trace", "vinfo", self._name))] + + def __eq__(self, other): + if not isinstance(other, Variable): + return NotImplemented + return (self._name == other._name + and self.__class__.__name__ == other.__class__.__name__ + and self._tk == other._tk) + + +class StringVar(Variable): + """Value holder for strings variables.""" + _default = "" + + def __init__(self, master=None, value=None, name=None): + """Construct a string variable. + + MASTER can be given as master widget. + VALUE is an optional value (defaults to "") + NAME is an optional Tcl name (defaults to PY_VARnum). + + If NAME matches an existing variable and VALUE is omitted + then the existing value is retained. + """ + Variable.__init__(self, master, value, name) + + def get(self): + """Return value of variable as string.""" + value = self._tk.globalgetvar(self._name) + if isinstance(value, str): + return value + return str(value) + + +class IntVar(Variable): + """Value holder for integer variables.""" + _default = 0 + + def __init__(self, master=None, value=None, name=None): + """Construct an integer variable. + + MASTER can be given as master widget. + VALUE is an optional value (defaults to 0) + NAME is an optional Tcl name (defaults to PY_VARnum). + + If NAME matches an existing variable and VALUE is omitted + then the existing value is retained. + """ + Variable.__init__(self, master, value, name) + + def get(self): + """Return the value of the variable as an integer.""" + value = self._tk.globalgetvar(self._name) + try: + return self._tk.getint(value) + except (TypeError, TclError): + return int(self._tk.getdouble(value)) + + +class DoubleVar(Variable): + """Value holder for float variables.""" + _default = 0.0 + + def __init__(self, master=None, value=None, name=None): + """Construct a float variable. + + MASTER can be given as master widget. + VALUE is an optional value (defaults to 0.0) + NAME is an optional Tcl name (defaults to PY_VARnum). + + If NAME matches an existing variable and VALUE is omitted + then the existing value is retained. + """ + Variable.__init__(self, master, value, name) + + def get(self): + """Return the value of the variable as a float.""" + return self._tk.getdouble(self._tk.globalgetvar(self._name)) + + +class BooleanVar(Variable): + """Value holder for boolean variables.""" + _default = False + + def __init__(self, master=None, value=None, name=None): + """Construct a boolean variable. + + MASTER can be given as master widget. + VALUE is an optional value (defaults to False) + NAME is an optional Tcl name (defaults to PY_VARnum). + + If NAME matches an existing variable and VALUE is omitted + then the existing value is retained. + """ + Variable.__init__(self, master, value, name) + + def set(self, value): + """Set the variable to VALUE.""" + return self._tk.globalsetvar(self._name, self._tk.getboolean(value)) + + initialize = set + + def get(self): + """Return the value of the variable as a bool.""" + try: + return self._tk.getboolean(self._tk.globalgetvar(self._name)) + except TclError: + raise ValueError("invalid literal for getboolean()") + + +def mainloop(n=0): + """Run the main loop of Tcl.""" + _get_default_root('run the main loop').tk.mainloop(n) + + +getint = int + +getdouble = float + + +def getboolean(s): + """Convert Tcl object to True or False.""" + try: + return _get_default_root('use getboolean()').tk.getboolean(s) + except TclError: + raise ValueError("invalid literal for getboolean()") + + +# Methods defined on both toplevel and interior widgets + +class Misc: + """Internal class. + + Base class which defines methods common for interior widgets.""" + + # used for generating child widget names + _last_child_ids = None + + # XXX font command? + _tclCommands = None + + def destroy(self): + """Internal function. + + Delete all Tcl commands created for + this widget in the Tcl interpreter.""" + if self._tclCommands is not None: + for name in self._tclCommands: + #print '- Tkinter: deleted command', name + self.tk.deletecommand(name) + self._tclCommands = None + + def deletecommand(self, name): + """Internal function. + + Delete the Tcl command provided in NAME.""" + #print '- Tkinter: deleted command', name + self.tk.deletecommand(name) + try: + self._tclCommands.remove(name) + except ValueError: + pass + + def tk_strictMotif(self, boolean=None): + """Set Tcl internal variable, whether the look and feel + should adhere to Motif. + + A parameter of 1 means adhere to Motif (e.g. no color + change if mouse passes over slider). + Returns the set value.""" + return self.tk.getboolean(self.tk.call( + 'set', 'tk_strictMotif', boolean)) + + def tk_bisque(self): + """Change the color scheme to light brown as used in Tk 3.6 and before.""" + self.tk.call('tk_bisque') + + def tk_setPalette(self, *args, **kw): + """Set a new color scheme for all widget elements. + + A single color as argument will cause that all colors of Tk + widget elements are derived from this. + Alternatively several keyword parameters and its associated + colors can be given. The following keywords are valid: + activeBackground, foreground, selectColor, + activeForeground, highlightBackground, selectBackground, + background, highlightColor, selectForeground, + disabledForeground, insertBackground, troughColor.""" + self.tk.call(('tk_setPalette',) + + _flatten(args) + _flatten(list(kw.items()))) + + def wait_variable(self, name='PY_VAR'): + """Wait until the variable is modified. + + A parameter of type IntVar, StringVar, DoubleVar or + BooleanVar must be given.""" + self.tk.call('tkwait', 'variable', name) + waitvar = wait_variable # XXX b/w compat + + def wait_window(self, window=None): + """Wait until a WIDGET is destroyed. + + If no parameter is given self is used.""" + if window is None: + window = self + self.tk.call('tkwait', 'window', window._w) + + def wait_visibility(self, window=None): + """Wait until the visibility of a WIDGET changes + (e.g. it appears). + + If no parameter is given self is used.""" + if window is None: + window = self + self.tk.call('tkwait', 'visibility', window._w) + + def setvar(self, name='PY_VAR', value='1'): + """Set Tcl variable NAME to VALUE.""" + self.tk.setvar(name, value) + + def getvar(self, name='PY_VAR'): + """Return value of Tcl variable NAME.""" + return self.tk.getvar(name) + + def getint(self, s): + try: + return self.tk.getint(s) + except TclError as exc: + raise ValueError(str(exc)) + + def getdouble(self, s): + try: + return self.tk.getdouble(s) + except TclError as exc: + raise ValueError(str(exc)) + + def getboolean(self, s): + """Return a boolean value for Tcl boolean values true and false given as parameter.""" + try: + return self.tk.getboolean(s) + except TclError: + raise ValueError("invalid literal for getboolean()") + + def focus_set(self): + """Direct input focus to this widget. + + If the application currently does not have the focus + this widget will get the focus if the application gets + the focus through the window manager.""" + self.tk.call('focus', self._w) + focus = focus_set # XXX b/w compat? + + def focus_force(self): + """Direct input focus to this widget even if the + application does not have the focus. Use with + caution!""" + self.tk.call('focus', '-force', self._w) + + def focus_get(self): + """Return the widget which has currently the focus in the + application. + + Use focus_displayof to allow working with several + displays. Return None if application does not have + the focus.""" + name = self.tk.call('focus') + if name == 'none' or not name: return None + return self._nametowidget(name) + + def focus_displayof(self): + """Return the widget which has currently the focus on the + display where this widget is located. + + Return None if the application does not have the focus.""" + name = self.tk.call('focus', '-displayof', self._w) + if name == 'none' or not name: return None + return self._nametowidget(name) + + def focus_lastfor(self): + """Return the widget which would have the focus if top level + for this widget gets the focus from the window manager.""" + name = self.tk.call('focus', '-lastfor', self._w) + if name == 'none' or not name: return None + return self._nametowidget(name) + + def tk_focusFollowsMouse(self): + """The widget under mouse will get automatically focus. Can not + be disabled easily.""" + self.tk.call('tk_focusFollowsMouse') + + def tk_focusNext(self): + """Return the next widget in the focus order which follows + widget which has currently the focus. + + The focus order first goes to the next child, then to + the children of the child recursively and then to the + next sibling which is higher in the stacking order. A + widget is omitted if it has the takefocus resource set + to 0.""" + name = self.tk.call('tk_focusNext', self._w) + if not name: return None + return self._nametowidget(name) + + def tk_focusPrev(self): + """Return previous widget in the focus order. See tk_focusNext for details.""" + name = self.tk.call('tk_focusPrev', self._w) + if not name: return None + return self._nametowidget(name) + + def after(self, ms, func=None, *args): + """Call function once after given time. + + MS specifies the time in milliseconds. FUNC gives the + function which shall be called. Additional parameters + are given as parameters to the function call. Return + identifier to cancel scheduling with after_cancel.""" + if func is None: + # I'd rather use time.sleep(ms*0.001) + self.tk.call('after', ms) + return None + else: + def callit(): + try: + func(*args) + finally: + try: + self.deletecommand(name) + except TclError: + pass + try: + callit.__name__ = func.__name__ + except AttributeError: + # Required for callable classes (bpo-44404) + callit.__name__ = type(func).__name__ + name = self._register(callit) + return self.tk.call('after', ms, name) + + def after_idle(self, func, *args): + """Call FUNC once if the Tcl main loop has no event to + process. + + Return an identifier to cancel the scheduling with + after_cancel.""" + return self.after('idle', func, *args) + + def after_cancel(self, id): + """Cancel scheduling of function identified with ID. + + Identifier returned by after or after_idle must be + given as first parameter. + """ + if not id: + raise ValueError('id must be a valid identifier returned from ' + 'after or after_idle') + try: + data = self.tk.call('after', 'info', id) + script = self.tk.splitlist(data)[0] + self.deletecommand(script) + except TclError: + pass + self.tk.call('after', 'cancel', id) + + def bell(self, displayof=0): + """Ring a display's bell.""" + self.tk.call(('bell',) + self._displayof(displayof)) + + # Clipboard handling: + def clipboard_get(self, **kw): + """Retrieve data from the clipboard on window's display. + + The window keyword defaults to the root window of the Tkinter + application. + + The type keyword specifies the form in which the data is + to be returned and should be an atom name such as STRING + or FILE_NAME. Type defaults to STRING, except on X11, where the default + is to try UTF8_STRING and fall back to STRING. + + This command is equivalent to: + + selection_get(CLIPBOARD) + """ + if 'type' not in kw and self._windowingsystem == 'x11': + try: + kw['type'] = 'UTF8_STRING' + return self.tk.call(('clipboard', 'get') + self._options(kw)) + except TclError: + del kw['type'] + return self.tk.call(('clipboard', 'get') + self._options(kw)) + + def clipboard_clear(self, **kw): + """Clear the data in the Tk clipboard. + + A widget specified for the optional displayof keyword + argument specifies the target display.""" + if 'displayof' not in kw: kw['displayof'] = self._w + self.tk.call(('clipboard', 'clear') + self._options(kw)) + + def clipboard_append(self, string, **kw): + """Append STRING to the Tk clipboard. + + A widget specified at the optional displayof keyword + argument specifies the target display. The clipboard + can be retrieved with selection_get.""" + if 'displayof' not in kw: kw['displayof'] = self._w + self.tk.call(('clipboard', 'append') + self._options(kw) + + ('--', string)) + # XXX grab current w/o window argument + + def grab_current(self): + """Return widget which has currently the grab in this application + or None.""" + name = self.tk.call('grab', 'current', self._w) + if not name: return None + return self._nametowidget(name) + + def grab_release(self): + """Release grab for this widget if currently set.""" + self.tk.call('grab', 'release', self._w) + + def grab_set(self): + """Set grab for this widget. + + A grab directs all events to this and descendant + widgets in the application.""" + self.tk.call('grab', 'set', self._w) + + def grab_set_global(self): + """Set global grab for this widget. + + A global grab directs all events to this and + descendant widgets on the display. Use with caution - + other applications do not get events anymore.""" + self.tk.call('grab', 'set', '-global', self._w) + + def grab_status(self): + """Return None, "local" or "global" if this widget has + no, a local or a global grab.""" + status = self.tk.call('grab', 'status', self._w) + if status == 'none': status = None + return status + + def option_add(self, pattern, value, priority = None): + """Set a VALUE (second parameter) for an option + PATTERN (first parameter). + + An optional third parameter gives the numeric priority + (defaults to 80).""" + self.tk.call('option', 'add', pattern, value, priority) + + def option_clear(self): + """Clear the option database. + + It will be reloaded if option_add is called.""" + self.tk.call('option', 'clear') + + def option_get(self, name, className): + """Return the value for an option NAME for this widget + with CLASSNAME. + + Values with higher priority override lower values.""" + return self.tk.call('option', 'get', self._w, name, className) + + def option_readfile(self, fileName, priority = None): + """Read file FILENAME into the option database. + + An optional second parameter gives the numeric + priority.""" + self.tk.call('option', 'readfile', fileName, priority) + + def selection_clear(self, **kw): + """Clear the current X selection.""" + if 'displayof' not in kw: kw['displayof'] = self._w + self.tk.call(('selection', 'clear') + self._options(kw)) + + def selection_get(self, **kw): + """Return the contents of the current X selection. + + A keyword parameter selection specifies the name of + the selection and defaults to PRIMARY. A keyword + parameter displayof specifies a widget on the display + to use. A keyword parameter type specifies the form of data to be + fetched, defaulting to STRING except on X11, where UTF8_STRING is tried + before STRING.""" + if 'displayof' not in kw: kw['displayof'] = self._w + if 'type' not in kw and self._windowingsystem == 'x11': + try: + kw['type'] = 'UTF8_STRING' + return self.tk.call(('selection', 'get') + self._options(kw)) + except TclError: + del kw['type'] + return self.tk.call(('selection', 'get') + self._options(kw)) + + def selection_handle(self, command, **kw): + """Specify a function COMMAND to call if the X + selection owned by this widget is queried by another + application. + + This function must return the contents of the + selection. The function will be called with the + arguments OFFSET and LENGTH which allows the chunking + of very long selections. The following keyword + parameters can be provided: + selection - name of the selection (default PRIMARY), + type - type of the selection (e.g. STRING, FILE_NAME).""" + name = self._register(command) + self.tk.call(('selection', 'handle') + self._options(kw) + + (self._w, name)) + + def selection_own(self, **kw): + """Become owner of X selection. + + A keyword parameter selection specifies the name of + the selection (default PRIMARY).""" + self.tk.call(('selection', 'own') + + self._options(kw) + (self._w,)) + + def selection_own_get(self, **kw): + """Return owner of X selection. + + The following keyword parameter can + be provided: + selection - name of the selection (default PRIMARY), + type - type of the selection (e.g. STRING, FILE_NAME).""" + if 'displayof' not in kw: kw['displayof'] = self._w + name = self.tk.call(('selection', 'own') + self._options(kw)) + if not name: return None + return self._nametowidget(name) + + def send(self, interp, cmd, *args): + """Send Tcl command CMD to different interpreter INTERP to be executed.""" + return self.tk.call(('send', interp, cmd) + args) + + def lower(self, belowThis=None): + """Lower this widget in the stacking order.""" + self.tk.call('lower', self._w, belowThis) + + def tkraise(self, aboveThis=None): + """Raise this widget in the stacking order.""" + self.tk.call('raise', self._w, aboveThis) + + lift = tkraise + + def info_patchlevel(self): + """Returns the exact version of the Tcl library.""" + patchlevel = self.tk.call('info', 'patchlevel') + return _parse_version(patchlevel) + + def winfo_atom(self, name, displayof=0): + """Return integer which represents atom NAME.""" + args = ('winfo', 'atom') + self._displayof(displayof) + (name,) + return self.tk.getint(self.tk.call(args)) + + def winfo_atomname(self, id, displayof=0): + """Return name of atom with identifier ID.""" + args = ('winfo', 'atomname') \ + + self._displayof(displayof) + (id,) + return self.tk.call(args) + + def winfo_cells(self): + """Return number of cells in the colormap for this widget.""" + return self.tk.getint( + self.tk.call('winfo', 'cells', self._w)) + + def winfo_children(self): + """Return a list of all widgets which are children of this widget.""" + result = [] + for child in self.tk.splitlist( + self.tk.call('winfo', 'children', self._w)): + try: + # Tcl sometimes returns extra windows, e.g. for + # menus; those need to be skipped + result.append(self._nametowidget(child)) + except KeyError: + pass + return result + + def winfo_class(self): + """Return window class name of this widget.""" + return self.tk.call('winfo', 'class', self._w) + + def winfo_colormapfull(self): + """Return True if at the last color request the colormap was full.""" + return self.tk.getboolean( + self.tk.call('winfo', 'colormapfull', self._w)) + + def winfo_containing(self, rootX, rootY, displayof=0): + """Return the widget which is at the root coordinates ROOTX, ROOTY.""" + args = ('winfo', 'containing') \ + + self._displayof(displayof) + (rootX, rootY) + name = self.tk.call(args) + if not name: return None + return self._nametowidget(name) + + def winfo_depth(self): + """Return the number of bits per pixel.""" + return self.tk.getint(self.tk.call('winfo', 'depth', self._w)) + + def winfo_exists(self): + """Return true if this widget exists.""" + return self.tk.getint( + self.tk.call('winfo', 'exists', self._w)) + + def winfo_fpixels(self, number): + """Return the number of pixels for the given distance NUMBER + (e.g. "3c") as float.""" + return self.tk.getdouble(self.tk.call( + 'winfo', 'fpixels', self._w, number)) + + def winfo_geometry(self): + """Return geometry string for this widget in the form "widthxheight+X+Y".""" + return self.tk.call('winfo', 'geometry', self._w) + + def winfo_height(self): + """Return height of this widget.""" + return self.tk.getint( + self.tk.call('winfo', 'height', self._w)) + + def winfo_id(self): + """Return identifier ID for this widget.""" + return int(self.tk.call('winfo', 'id', self._w), 0) + + def winfo_interps(self, displayof=0): + """Return the name of all Tcl interpreters for this display.""" + args = ('winfo', 'interps') + self._displayof(displayof) + return self.tk.splitlist(self.tk.call(args)) + + def winfo_ismapped(self): + """Return true if this widget is mapped.""" + return self.tk.getint( + self.tk.call('winfo', 'ismapped', self._w)) + + def winfo_manager(self): + """Return the window manager name for this widget.""" + return self.tk.call('winfo', 'manager', self._w) + + def winfo_name(self): + """Return the name of this widget.""" + return self.tk.call('winfo', 'name', self._w) + + def winfo_parent(self): + """Return the name of the parent of this widget.""" + return self.tk.call('winfo', 'parent', self._w) + + def winfo_pathname(self, id, displayof=0): + """Return the pathname of the widget given by ID.""" + if isinstance(id, int): + id = hex(id) + args = ('winfo', 'pathname') \ + + self._displayof(displayof) + (id,) + return self.tk.call(args) + + def winfo_pixels(self, number): + """Rounded integer value of winfo_fpixels.""" + return self.tk.getint( + self.tk.call('winfo', 'pixels', self._w, number)) + + def winfo_pointerx(self): + """Return the x coordinate of the pointer on the root window.""" + return self.tk.getint( + self.tk.call('winfo', 'pointerx', self._w)) + + def winfo_pointerxy(self): + """Return a tuple of x and y coordinates of the pointer on the root window.""" + return self._getints( + self.tk.call('winfo', 'pointerxy', self._w)) + + def winfo_pointery(self): + """Return the y coordinate of the pointer on the root window.""" + return self.tk.getint( + self.tk.call('winfo', 'pointery', self._w)) + + def winfo_reqheight(self): + """Return requested height of this widget.""" + return self.tk.getint( + self.tk.call('winfo', 'reqheight', self._w)) + + def winfo_reqwidth(self): + """Return requested width of this widget.""" + return self.tk.getint( + self.tk.call('winfo', 'reqwidth', self._w)) + + def winfo_rgb(self, color): + """Return a tuple of integer RGB values in range(65536) for color in this widget.""" + return self._getints( + self.tk.call('winfo', 'rgb', self._w, color)) + + def winfo_rootx(self): + """Return x coordinate of upper left corner of this widget on the + root window.""" + return self.tk.getint( + self.tk.call('winfo', 'rootx', self._w)) + + def winfo_rooty(self): + """Return y coordinate of upper left corner of this widget on the + root window.""" + return self.tk.getint( + self.tk.call('winfo', 'rooty', self._w)) + + def winfo_screen(self): + """Return the screen name of this widget.""" + return self.tk.call('winfo', 'screen', self._w) + + def winfo_screencells(self): + """Return the number of the cells in the colormap of the screen + of this widget.""" + return self.tk.getint( + self.tk.call('winfo', 'screencells', self._w)) + + def winfo_screendepth(self): + """Return the number of bits per pixel of the root window of the + screen of this widget.""" + return self.tk.getint( + self.tk.call('winfo', 'screendepth', self._w)) + + def winfo_screenheight(self): + """Return the number of pixels of the height of the screen of this widget + in pixel.""" + return self.tk.getint( + self.tk.call('winfo', 'screenheight', self._w)) + + def winfo_screenmmheight(self): + """Return the number of pixels of the height of the screen of + this widget in mm.""" + return self.tk.getint( + self.tk.call('winfo', 'screenmmheight', self._w)) + + def winfo_screenmmwidth(self): + """Return the number of pixels of the width of the screen of + this widget in mm.""" + return self.tk.getint( + self.tk.call('winfo', 'screenmmwidth', self._w)) + + def winfo_screenvisual(self): + """Return one of the strings directcolor, grayscale, pseudocolor, + staticcolor, staticgray, or truecolor for the default + colormodel of this screen.""" + return self.tk.call('winfo', 'screenvisual', self._w) + + def winfo_screenwidth(self): + """Return the number of pixels of the width of the screen of + this widget in pixel.""" + return self.tk.getint( + self.tk.call('winfo', 'screenwidth', self._w)) + + def winfo_server(self): + """Return information of the X-Server of the screen of this widget in + the form "XmajorRminor vendor vendorVersion".""" + return self.tk.call('winfo', 'server', self._w) + + def winfo_toplevel(self): + """Return the toplevel widget of this widget.""" + return self._nametowidget(self.tk.call( + 'winfo', 'toplevel', self._w)) + + def winfo_viewable(self): + """Return true if the widget and all its higher ancestors are mapped.""" + return self.tk.getint( + self.tk.call('winfo', 'viewable', self._w)) + + def winfo_visual(self): + """Return one of the strings directcolor, grayscale, pseudocolor, + staticcolor, staticgray, or truecolor for the + colormodel of this widget.""" + return self.tk.call('winfo', 'visual', self._w) + + def winfo_visualid(self): + """Return the X identifier for the visual for this widget.""" + return self.tk.call('winfo', 'visualid', self._w) + + def winfo_visualsavailable(self, includeids=False): + """Return a list of all visuals available for the screen + of this widget. + + Each item in the list consists of a visual name (see winfo_visual), a + depth and if includeids is true is given also the X identifier.""" + data = self.tk.call('winfo', 'visualsavailable', self._w, + 'includeids' if includeids else None) + data = [self.tk.splitlist(x) for x in self.tk.splitlist(data)] + return [self.__winfo_parseitem(x) for x in data] + + def __winfo_parseitem(self, t): + """Internal function.""" + return t[:1] + tuple(map(self.__winfo_getint, t[1:])) + + def __winfo_getint(self, x): + """Internal function.""" + return int(x, 0) + + def winfo_vrootheight(self): + """Return the height of the virtual root window associated with this + widget in pixels. If there is no virtual root window return the + height of the screen.""" + return self.tk.getint( + self.tk.call('winfo', 'vrootheight', self._w)) + + def winfo_vrootwidth(self): + """Return the width of the virtual root window associated with this + widget in pixel. If there is no virtual root window return the + width of the screen.""" + return self.tk.getint( + self.tk.call('winfo', 'vrootwidth', self._w)) + + def winfo_vrootx(self): + """Return the x offset of the virtual root relative to the root + window of the screen of this widget.""" + return self.tk.getint( + self.tk.call('winfo', 'vrootx', self._w)) + + def winfo_vrooty(self): + """Return the y offset of the virtual root relative to the root + window of the screen of this widget.""" + return self.tk.getint( + self.tk.call('winfo', 'vrooty', self._w)) + + def winfo_width(self): + """Return the width of this widget.""" + return self.tk.getint( + self.tk.call('winfo', 'width', self._w)) + + def winfo_x(self): + """Return the x coordinate of the upper left corner of this widget + in the parent.""" + return self.tk.getint( + self.tk.call('winfo', 'x', self._w)) + + def winfo_y(self): + """Return the y coordinate of the upper left corner of this widget + in the parent.""" + return self.tk.getint( + self.tk.call('winfo', 'y', self._w)) + + def update(self): + """Enter event loop until all pending events have been processed by Tcl.""" + self.tk.call('update') + + def update_idletasks(self): + """Enter event loop until all idle callbacks have been called. This + will update the display of windows but not process events caused by + the user.""" + self.tk.call('update', 'idletasks') + + def bindtags(self, tagList=None): + """Set or get the list of bindtags for this widget. + + With no argument return the list of all bindtags associated with + this widget. With a list of strings as argument the bindtags are + set to this list. The bindtags determine in which order events are + processed (see bind).""" + if tagList is None: + return self.tk.splitlist( + self.tk.call('bindtags', self._w)) + else: + self.tk.call('bindtags', self._w, tagList) + + def _bind(self, what, sequence, func, add, needcleanup=1): + """Internal function.""" + if isinstance(func, str): + self.tk.call(what + (sequence, func)) + elif func: + funcid = self._register(func, self._substitute, + needcleanup) + cmd = ('%sif {"[%s %s]" == "break"} break\n' + % + (add and '+' or '', + funcid, self._subst_format_str)) + self.tk.call(what + (sequence, cmd)) + return funcid + elif sequence: + return self.tk.call(what + (sequence,)) + else: + return self.tk.splitlist(self.tk.call(what)) + + def bind(self, sequence=None, func=None, add=None): + """Bind to this widget at event SEQUENCE a call to function FUNC. + + SEQUENCE is a string of concatenated event + patterns. An event pattern is of the form + where MODIFIER is one + of Control, Mod2, M2, Shift, Mod3, M3, Lock, Mod4, M4, + Button1, B1, Mod5, M5 Button2, B2, Meta, M, Button3, + B3, Alt, Button4, B4, Double, Button5, B5 Triple, + Mod1, M1. TYPE is one of Activate, Enter, Map, + ButtonPress, Button, Expose, Motion, ButtonRelease + FocusIn, MouseWheel, Circulate, FocusOut, Property, + Colormap, Gravity Reparent, Configure, KeyPress, Key, + Unmap, Deactivate, KeyRelease Visibility, Destroy, + Leave and DETAIL is the button number for ButtonPress, + ButtonRelease and DETAIL is the Keysym for KeyPress and + KeyRelease. Examples are + for pressing Control and mouse button 1 or + for pressing A and the Alt key (KeyPress can be omitted). + An event pattern can also be a virtual event of the form + <> where AString can be arbitrary. This + event can be generated by event_generate. + If events are concatenated they must appear shortly + after each other. + + FUNC will be called if the event sequence occurs with an + instance of Event as argument. If the return value of FUNC is + "break" no further bound function is invoked. + + An additional boolean parameter ADD specifies whether FUNC will + be called additionally to the other bound function or whether + it will replace the previous function. + + Bind will return an identifier to allow deletion of the bound function with + unbind without memory leak. + + If FUNC or SEQUENCE is omitted the bound function or list + of bound events are returned.""" + + return self._bind(('bind', self._w), sequence, func, add) + + def unbind(self, sequence, funcid=None): + """Unbind for this widget the event SEQUENCE. + + If FUNCID is given, only unbind the function identified with FUNCID + and also delete the corresponding Tcl command. + + Otherwise destroy the current binding for SEQUENCE, leaving SEQUENCE + unbound. + """ + self._unbind(('bind', self._w, sequence), funcid) + + def _unbind(self, what, funcid=None): + if funcid is None: + self.tk.call(*what, '') + else: + lines = self.tk.call(what).split('\n') + prefix = f'if {{"[{funcid} ' + keep = '\n'.join(line for line in lines + if not line.startswith(prefix)) + if not keep.strip(): + keep = '' + self.tk.call(*what, keep) + self.deletecommand(funcid) + + def bind_all(self, sequence=None, func=None, add=None): + """Bind to all widgets at an event SEQUENCE a call to function FUNC. + An additional boolean parameter ADD specifies whether FUNC will + be called additionally to the other bound function or whether + it will replace the previous function. See bind for the return value.""" + return self._root()._bind(('bind', 'all'), sequence, func, add, True) + + def unbind_all(self, sequence): + """Unbind for all widgets for event SEQUENCE all functions.""" + self._root()._unbind(('bind', 'all', sequence)) + + def bind_class(self, className, sequence=None, func=None, add=None): + """Bind to widgets with bindtag CLASSNAME at event + SEQUENCE a call of function FUNC. An additional + boolean parameter ADD specifies whether FUNC will be + called additionally to the other bound function or + whether it will replace the previous function. See bind for + the return value.""" + + return self._root()._bind(('bind', className), sequence, func, add, True) + + def unbind_class(self, className, sequence): + """Unbind for all widgets with bindtag CLASSNAME for event SEQUENCE + all functions.""" + self._root()._unbind(('bind', className, sequence)) + + def mainloop(self, n=0): + """Call the mainloop of Tk.""" + self.tk.mainloop(n) + + def quit(self): + """Quit the Tcl interpreter. All widgets will be destroyed.""" + self.tk.quit() + + def _getints(self, string): + """Internal function.""" + if string: + return tuple(map(self.tk.getint, self.tk.splitlist(string))) + + def _getdoubles(self, string): + """Internal function.""" + if string: + return tuple(map(self.tk.getdouble, self.tk.splitlist(string))) + + def _getboolean(self, string): + """Internal function.""" + if string: + return self.tk.getboolean(string) + + def _displayof(self, displayof): + """Internal function.""" + if displayof: + return ('-displayof', displayof) + if displayof is None: + return ('-displayof', self._w) + return () + + @property + def _windowingsystem(self): + """Internal function.""" + try: + return self._root()._windowingsystem_cached + except AttributeError: + ws = self._root()._windowingsystem_cached = \ + self.tk.call('tk', 'windowingsystem') + return ws + + def _options(self, cnf, kw = None): + """Internal function.""" + if kw: + cnf = _cnfmerge((cnf, kw)) + else: + cnf = _cnfmerge(cnf) + res = () + for k, v in cnf.items(): + if v is not None: + if k[-1] == '_': k = k[:-1] + if callable(v): + v = self._register(v) + elif isinstance(v, (tuple, list)): + nv = [] + for item in v: + if isinstance(item, int): + nv.append(str(item)) + elif isinstance(item, str): + nv.append(_stringify(item)) + else: + break + else: + v = ' '.join(nv) + res = res + ('-'+k, v) + return res + + def nametowidget(self, name): + """Return the Tkinter instance of a widget identified by + its Tcl name NAME.""" + name = str(name).split('.') + w = self + + if not name[0]: + w = w._root() + name = name[1:] + + for n in name: + if not n: + break + w = w.children[n] + + return w + + _nametowidget = nametowidget + + def _register(self, func, subst=None, needcleanup=1): + """Return a newly created Tcl function. If this + function is called, the Python function FUNC will + be executed. An optional function SUBST can + be given which will be executed before FUNC.""" + f = CallWrapper(func, subst, self).__call__ + name = repr(id(f)) + try: + func = func.__func__ + except AttributeError: + pass + try: + name = name + func.__name__ + except AttributeError: + pass + self.tk.createcommand(name, f) + if needcleanup: + if self._tclCommands is None: + self._tclCommands = [] + self._tclCommands.append(name) + return name + + register = _register + + def _root(self): + """Internal function.""" + w = self + while w.master is not None: w = w.master + return w + _subst_format = ('%#', '%b', '%f', '%h', '%k', + '%s', '%t', '%w', '%x', '%y', + '%A', '%E', '%K', '%N', '%W', '%T', '%X', '%Y', '%D') + _subst_format_str = " ".join(_subst_format) + + def _substitute(self, *args): + """Internal function.""" + if len(args) != len(self._subst_format): return args + getboolean = self.tk.getboolean + + getint = self.tk.getint + def getint_event(s): + """Tk changed behavior in 8.4.2, returning "??" rather more often.""" + try: + return getint(s) + except (ValueError, TclError): + return s + + nsign, b, f, h, k, s, t, w, x, y, A, E, K, N, W, T, X, Y, D = args + # Missing: (a, c, d, m, o, v, B, R) + e = Event() + # serial field: valid for all events + # number of button: ButtonPress and ButtonRelease events only + # height field: Configure, ConfigureRequest, Create, + # ResizeRequest, and Expose events only + # keycode field: KeyPress and KeyRelease events only + # time field: "valid for events that contain a time field" + # width field: Configure, ConfigureRequest, Create, ResizeRequest, + # and Expose events only + # x field: "valid for events that contain an x field" + # y field: "valid for events that contain a y field" + # keysym as decimal: KeyPress and KeyRelease events only + # x_root, y_root fields: ButtonPress, ButtonRelease, KeyPress, + # KeyRelease, and Motion events + e.serial = getint(nsign) + e.num = getint_event(b) + try: e.focus = getboolean(f) + except TclError: pass + e.height = getint_event(h) + e.keycode = getint_event(k) + e.state = getint_event(s) + e.time = getint_event(t) + e.width = getint_event(w) + e.x = getint_event(x) + e.y = getint_event(y) + e.char = A + try: e.send_event = getboolean(E) + except TclError: pass + e.keysym = K + e.keysym_num = getint_event(N) + try: + e.type = EventType(T) + except ValueError: + e.type = T + try: + e.widget = self._nametowidget(W) + except KeyError: + e.widget = W + e.x_root = getint_event(X) + e.y_root = getint_event(Y) + try: + e.delta = getint(D) + except (ValueError, TclError): + e.delta = 0 + return (e,) + + def _report_exception(self): + """Internal function.""" + exc, val, tb = sys.exc_info() + root = self._root() + root.report_callback_exception(exc, val, tb) + + def _getconfigure(self, *args): + """Call Tcl configure command and return the result as a dict.""" + cnf = {} + for x in self.tk.splitlist(self.tk.call(*args)): + x = self.tk.splitlist(x) + cnf[x[0][1:]] = (x[0][1:],) + x[1:] + return cnf + + def _getconfigure1(self, *args): + x = self.tk.splitlist(self.tk.call(*args)) + return (x[0][1:],) + x[1:] + + def _configure(self, cmd, cnf, kw): + """Internal function.""" + if kw: + cnf = _cnfmerge((cnf, kw)) + elif cnf: + cnf = _cnfmerge(cnf) + if cnf is None: + return self._getconfigure(_flatten((self._w, cmd))) + if isinstance(cnf, str): + return self._getconfigure1(_flatten((self._w, cmd, '-'+cnf))) + self.tk.call(_flatten((self._w, cmd)) + self._options(cnf)) + # These used to be defined in Widget: + + def configure(self, cnf=None, **kw): + """Configure resources of a widget. + + The values for resources are specified as keyword + arguments. To get an overview about + the allowed keyword arguments call the method keys. + """ + return self._configure('configure', cnf, kw) + + config = configure + + def cget(self, key): + """Return the resource value for a KEY given as string.""" + return self.tk.call(self._w, 'cget', '-' + key) + + __getitem__ = cget + + def __setitem__(self, key, value): + self.configure({key: value}) + + def keys(self): + """Return a list of all resource names of this widget.""" + splitlist = self.tk.splitlist + return [splitlist(x)[0][1:] for x in + splitlist(self.tk.call(self._w, 'configure'))] + + def __str__(self): + """Return the window path name of this widget.""" + return self._w + + def __repr__(self): + return '<%s.%s object %s>' % ( + self.__class__.__module__, self.__class__.__qualname__, self._w) + + # Pack methods that apply to the master + _noarg_ = ['_noarg_'] + + def pack_propagate(self, flag=_noarg_): + """Set or get the status for propagation of geometry information. + + A boolean argument specifies whether the geometry information + of the slaves will determine the size of this widget. If no argument + is given the current setting will be returned. + """ + if flag is Misc._noarg_: + return self._getboolean(self.tk.call( + 'pack', 'propagate', self._w)) + else: + self.tk.call('pack', 'propagate', self._w, flag) + + propagate = pack_propagate + + def pack_slaves(self): + """Return a list of all slaves of this widget + in its packing order.""" + return [self._nametowidget(x) for x in + self.tk.splitlist( + self.tk.call('pack', 'slaves', self._w))] + + slaves = pack_slaves + + # Place method that applies to the master + def place_slaves(self): + """Return a list of all slaves of this widget + in its packing order.""" + return [self._nametowidget(x) for x in + self.tk.splitlist( + self.tk.call( + 'place', 'slaves', self._w))] + + # Grid methods that apply to the master + + def grid_anchor(self, anchor=None): # new in Tk 8.5 + """The anchor value controls how to place the grid within the + master when no row/column has any weight. + + The default anchor is nw.""" + self.tk.call('grid', 'anchor', self._w, anchor) + + anchor = grid_anchor + + def grid_bbox(self, column=None, row=None, col2=None, row2=None): + """Return a tuple of integer coordinates for the bounding + box of this widget controlled by the geometry manager grid. + + If COLUMN, ROW is given the bounding box applies from + the cell with row and column 0 to the specified + cell. If COL2 and ROW2 are given the bounding box + starts at that cell. + + The returned integers specify the offset of the upper left + corner in the master widget and the width and height. + """ + args = ('grid', 'bbox', self._w) + if column is not None and row is not None: + args = args + (column, row) + if col2 is not None and row2 is not None: + args = args + (col2, row2) + return self._getints(self.tk.call(*args)) or None + + bbox = grid_bbox + + def _gridconvvalue(self, value): + if isinstance(value, (str, _tkinter.Tcl_Obj)): + try: + svalue = str(value) + if not svalue: + return None + elif '.' in svalue: + return self.tk.getdouble(svalue) + else: + return self.tk.getint(svalue) + except (ValueError, TclError): + pass + return value + + def _grid_configure(self, command, index, cnf, kw): + """Internal function.""" + if isinstance(cnf, str) and not kw: + if cnf[-1:] == '_': + cnf = cnf[:-1] + if cnf[:1] != '-': + cnf = '-'+cnf + options = (cnf,) + else: + options = self._options(cnf, kw) + if not options: + return _splitdict( + self.tk, + self.tk.call('grid', command, self._w, index), + conv=self._gridconvvalue) + res = self.tk.call( + ('grid', command, self._w, index) + + options) + if len(options) == 1: + return self._gridconvvalue(res) + + def grid_columnconfigure(self, index, cnf={}, **kw): + """Configure column INDEX of a grid. + + Valid resources are minsize (minimum size of the column), + weight (how much does additional space propagate to this column) + and pad (how much space to let additionally).""" + return self._grid_configure('columnconfigure', index, cnf, kw) + + columnconfigure = grid_columnconfigure + + def grid_location(self, x, y): + """Return a tuple of column and row which identify the cell + at which the pixel at position X and Y inside the master + widget is located.""" + return self._getints( + self.tk.call( + 'grid', 'location', self._w, x, y)) or None + + def grid_propagate(self, flag=_noarg_): + """Set or get the status for propagation of geometry information. + + A boolean argument specifies whether the geometry information + of the slaves will determine the size of this widget. If no argument + is given, the current setting will be returned. + """ + if flag is Misc._noarg_: + return self._getboolean(self.tk.call( + 'grid', 'propagate', self._w)) + else: + self.tk.call('grid', 'propagate', self._w, flag) + + def grid_rowconfigure(self, index, cnf={}, **kw): + """Configure row INDEX of a grid. + + Valid resources are minsize (minimum size of the row), + weight (how much does additional space propagate to this row) + and pad (how much space to let additionally).""" + return self._grid_configure('rowconfigure', index, cnf, kw) + + rowconfigure = grid_rowconfigure + + def grid_size(self): + """Return a tuple of the number of column and rows in the grid.""" + return self._getints( + self.tk.call('grid', 'size', self._w)) or None + + size = grid_size + + def grid_slaves(self, row=None, column=None): + """Return a list of all slaves of this widget + in its packing order.""" + args = () + if row is not None: + args = args + ('-row', row) + if column is not None: + args = args + ('-column', column) + return [self._nametowidget(x) for x in + self.tk.splitlist(self.tk.call( + ('grid', 'slaves', self._w) + args))] + + # Support for the "event" command, new in Tk 4.2. + # By Case Roole. + + def event_add(self, virtual, *sequences): + """Bind a virtual event VIRTUAL (of the form <>) + to an event SEQUENCE such that the virtual event is triggered + whenever SEQUENCE occurs.""" + args = ('event', 'add', virtual) + sequences + self.tk.call(args) + + def event_delete(self, virtual, *sequences): + """Unbind a virtual event VIRTUAL from SEQUENCE.""" + args = ('event', 'delete', virtual) + sequences + self.tk.call(args) + + def event_generate(self, sequence, **kw): + """Generate an event SEQUENCE. Additional + keyword arguments specify parameter of the event + (e.g. x, y, rootx, rooty).""" + args = ('event', 'generate', self._w, sequence) + for k, v in kw.items(): + args = args + ('-%s' % k, str(v)) + self.tk.call(args) + + def event_info(self, virtual=None): + """Return a list of all virtual events or the information + about the SEQUENCE bound to the virtual event VIRTUAL.""" + return self.tk.splitlist( + self.tk.call('event', 'info', virtual)) + + # Image related commands + + def image_names(self): + """Return a list of all existing image names.""" + return self.tk.splitlist(self.tk.call('image', 'names')) + + def image_types(self): + """Return a list of all available image types (e.g. photo bitmap).""" + return self.tk.splitlist(self.tk.call('image', 'types')) + + +class CallWrapper: + """Internal class. Stores function to call when some user + defined Tcl function is called e.g. after an event occurred.""" + + def __init__(self, func, subst, widget): + """Store FUNC, SUBST and WIDGET as members.""" + self.func = func + self.subst = subst + self.widget = widget + + def __call__(self, *args): + """Apply first function SUBST to arguments, than FUNC.""" + try: + if self.subst: + args = self.subst(*args) + return self.func(*args) + except SystemExit: + raise + except: + self.widget._report_exception() + + +class XView: + """Mix-in class for querying and changing the horizontal position + of a widget's window.""" + + def xview(self, *args): + """Query and change the horizontal position of the view.""" + res = self.tk.call(self._w, 'xview', *args) + if not args: + return self._getdoubles(res) + + def xview_moveto(self, fraction): + """Adjusts the view in the window so that FRACTION of the + total width of the canvas is off-screen to the left.""" + self.tk.call(self._w, 'xview', 'moveto', fraction) + + def xview_scroll(self, number, what): + """Shift the x-view according to NUMBER which is measured in "units" + or "pages" (WHAT).""" + self.tk.call(self._w, 'xview', 'scroll', number, what) + + +class YView: + """Mix-in class for querying and changing the vertical position + of a widget's window.""" + + def yview(self, *args): + """Query and change the vertical position of the view.""" + res = self.tk.call(self._w, 'yview', *args) + if not args: + return self._getdoubles(res) + + def yview_moveto(self, fraction): + """Adjusts the view in the window so that FRACTION of the + total height of the canvas is off-screen to the top.""" + self.tk.call(self._w, 'yview', 'moveto', fraction) + + def yview_scroll(self, number, what): + """Shift the y-view according to NUMBER which is measured in + "units" or "pages" (WHAT).""" + self.tk.call(self._w, 'yview', 'scroll', number, what) + + +class Wm: + """Provides functions for the communication with the window manager.""" + + def wm_aspect(self, + minNumer=None, minDenom=None, + maxNumer=None, maxDenom=None): + """Instruct the window manager to set the aspect ratio (width/height) + of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple + of the actual values if no argument is given.""" + return self._getints( + self.tk.call('wm', 'aspect', self._w, + minNumer, minDenom, + maxNumer, maxDenom)) + + aspect = wm_aspect + + def wm_attributes(self, *args): + """This subcommand returns or sets platform specific attributes + + The first form returns a list of the platform specific flags and + their values. The second form returns the value for the specific + option. The third form sets one or more of the values. The values + are as follows: + + On Windows, -disabled gets or sets whether the window is in a + disabled state. -toolwindow gets or sets the style of the window + to toolwindow (as defined in the MSDN). -topmost gets or sets + whether this is a topmost window (displays above all other + windows). + + On Macintosh, XXXXX + + On Unix, there are currently no special attribute values. + """ + args = ('wm', 'attributes', self._w) + args + return self.tk.call(args) + + attributes = wm_attributes + + def wm_client(self, name=None): + """Store NAME in WM_CLIENT_MACHINE property of this widget. Return + current value.""" + return self.tk.call('wm', 'client', self._w, name) + + client = wm_client + + def wm_colormapwindows(self, *wlist): + """Store list of window names (WLIST) into WM_COLORMAPWINDOWS property + of this widget. This list contains windows whose colormaps differ from their + parents. Return current list of widgets if WLIST is empty.""" + if len(wlist) > 1: + wlist = (wlist,) # Tk needs a list of windows here + args = ('wm', 'colormapwindows', self._w) + wlist + if wlist: + self.tk.call(args) + else: + return [self._nametowidget(x) + for x in self.tk.splitlist(self.tk.call(args))] + + colormapwindows = wm_colormapwindows + + def wm_command(self, value=None): + """Store VALUE in WM_COMMAND property. It is the command + which shall be used to invoke the application. Return current + command if VALUE is None.""" + return self.tk.call('wm', 'command', self._w, value) + + command = wm_command + + def wm_deiconify(self): + """Deiconify this widget. If it was never mapped it will not be mapped. + On Windows it will raise this widget and give it the focus.""" + return self.tk.call('wm', 'deiconify', self._w) + + deiconify = wm_deiconify + + def wm_focusmodel(self, model=None): + """Set focus model to MODEL. "active" means that this widget will claim + the focus itself, "passive" means that the window manager shall give + the focus. Return current focus model if MODEL is None.""" + return self.tk.call('wm', 'focusmodel', self._w, model) + + focusmodel = wm_focusmodel + + def wm_forget(self, window): # new in Tk 8.5 + """The window will be unmapped from the screen and will no longer + be managed by wm. toplevel windows will be treated like frame + windows once they are no longer managed by wm, however, the menu + option configuration will be remembered and the menus will return + once the widget is managed again.""" + self.tk.call('wm', 'forget', window) + + forget = wm_forget + + def wm_frame(self): + """Return identifier for decorative frame of this widget if present.""" + return self.tk.call('wm', 'frame', self._w) + + frame = wm_frame + + def wm_geometry(self, newGeometry=None): + """Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return + current value if None is given.""" + return self.tk.call('wm', 'geometry', self._w, newGeometry) + + geometry = wm_geometry + + def wm_grid(self, + baseWidth=None, baseHeight=None, + widthInc=None, heightInc=None): + """Instruct the window manager that this widget shall only be + resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and + height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the + number of grid units requested in Tk_GeometryRequest.""" + return self._getints(self.tk.call( + 'wm', 'grid', self._w, + baseWidth, baseHeight, widthInc, heightInc)) + + grid = wm_grid + + def wm_group(self, pathName=None): + """Set the group leader widgets for related widgets to PATHNAME. Return + the group leader of this widget if None is given.""" + return self.tk.call('wm', 'group', self._w, pathName) + + group = wm_group + + def wm_iconbitmap(self, bitmap=None, default=None): + """Set bitmap for the iconified widget to BITMAP. Return + the bitmap if None is given. + + Under Windows, the DEFAULT parameter can be used to set the icon + for the widget and any descendants that don't have an icon set + explicitly. DEFAULT can be the relative path to a .ico file + (example: root.iconbitmap(default='myicon.ico') ). See Tk + documentation for more information.""" + if default: + return self.tk.call('wm', 'iconbitmap', self._w, '-default', default) + else: + return self.tk.call('wm', 'iconbitmap', self._w, bitmap) + + iconbitmap = wm_iconbitmap + + def wm_iconify(self): + """Display widget as icon.""" + return self.tk.call('wm', 'iconify', self._w) + + iconify = wm_iconify + + def wm_iconmask(self, bitmap=None): + """Set mask for the icon bitmap of this widget. Return the + mask if None is given.""" + return self.tk.call('wm', 'iconmask', self._w, bitmap) + + iconmask = wm_iconmask + + def wm_iconname(self, newName=None): + """Set the name of the icon for this widget. Return the name if + None is given.""" + return self.tk.call('wm', 'iconname', self._w, newName) + + iconname = wm_iconname + + def wm_iconphoto(self, default=False, *args): # new in Tk 8.5 + """Sets the titlebar icon for this window based on the named photo + images passed through args. If default is True, this is applied to + all future created toplevels as well. + + The data in the images is taken as a snapshot at the time of + invocation. If the images are later changed, this is not reflected + to the titlebar icons. Multiple images are accepted to allow + different images sizes to be provided. The window manager may scale + provided icons to an appropriate size. + + On Windows, the images are packed into a Windows icon structure. + This will override an icon specified to wm_iconbitmap, and vice + versa. + + On X, the images are arranged into the _NET_WM_ICON X property, + which most modern window managers support. An icon specified by + wm_iconbitmap may exist simultaneously. + + On Macintosh, this currently does nothing.""" + if default: + self.tk.call('wm', 'iconphoto', self._w, "-default", *args) + else: + self.tk.call('wm', 'iconphoto', self._w, *args) + + iconphoto = wm_iconphoto + + def wm_iconposition(self, x=None, y=None): + """Set the position of the icon of this widget to X and Y. Return + a tuple of the current values of X and X if None is given.""" + return self._getints(self.tk.call( + 'wm', 'iconposition', self._w, x, y)) + + iconposition = wm_iconposition + + def wm_iconwindow(self, pathName=None): + """Set widget PATHNAME to be displayed instead of icon. Return the current + value if None is given.""" + return self.tk.call('wm', 'iconwindow', self._w, pathName) + + iconwindow = wm_iconwindow + + def wm_manage(self, widget): # new in Tk 8.5 + """The widget specified will become a stand alone top-level window. + The window will be decorated with the window managers title bar, + etc.""" + self.tk.call('wm', 'manage', widget) + + manage = wm_manage + + def wm_maxsize(self, width=None, height=None): + """Set max WIDTH and HEIGHT for this widget. If the window is gridded + the values are given in grid units. Return the current values if None + is given.""" + return self._getints(self.tk.call( + 'wm', 'maxsize', self._w, width, height)) + + maxsize = wm_maxsize + + def wm_minsize(self, width=None, height=None): + """Set min WIDTH and HEIGHT for this widget. If the window is gridded + the values are given in grid units. Return the current values if None + is given.""" + return self._getints(self.tk.call( + 'wm', 'minsize', self._w, width, height)) + + minsize = wm_minsize + + def wm_overrideredirect(self, boolean=None): + """Instruct the window manager to ignore this widget + if BOOLEAN is given with 1. Return the current value if None + is given.""" + return self._getboolean(self.tk.call( + 'wm', 'overrideredirect', self._w, boolean)) + + overrideredirect = wm_overrideredirect + + def wm_positionfrom(self, who=None): + """Instruct the window manager that the position of this widget shall + be defined by the user if WHO is "user", and by its own policy if WHO is + "program".""" + return self.tk.call('wm', 'positionfrom', self._w, who) + + positionfrom = wm_positionfrom + + def wm_protocol(self, name=None, func=None): + """Bind function FUNC to command NAME for this widget. + Return the function bound to NAME if None is given. NAME could be + e.g. "WM_SAVE_YOURSELF" or "WM_DELETE_WINDOW".""" + if callable(func): + command = self._register(func) + else: + command = func + return self.tk.call( + 'wm', 'protocol', self._w, name, command) + + protocol = wm_protocol + + def wm_resizable(self, width=None, height=None): + """Instruct the window manager whether this width can be resized + in WIDTH or HEIGHT. Both values are boolean values.""" + return self.tk.call('wm', 'resizable', self._w, width, height) + + resizable = wm_resizable + + def wm_sizefrom(self, who=None): + """Instruct the window manager that the size of this widget shall + be defined by the user if WHO is "user", and by its own policy if WHO is + "program".""" + return self.tk.call('wm', 'sizefrom', self._w, who) + + sizefrom = wm_sizefrom + + def wm_state(self, newstate=None): + """Query or set the state of this widget as one of normal, icon, + iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only).""" + return self.tk.call('wm', 'state', self._w, newstate) + + state = wm_state + + def wm_title(self, string=None): + """Set the title of this widget.""" + return self.tk.call('wm', 'title', self._w, string) + + title = wm_title + + def wm_transient(self, master=None): + """Instruct the window manager that this widget is transient + with regard to widget MASTER.""" + return self.tk.call('wm', 'transient', self._w, master) + + transient = wm_transient + + def wm_withdraw(self): + """Withdraw this widget from the screen such that it is unmapped + and forgotten by the window manager. Re-draw it with wm_deiconify.""" + return self.tk.call('wm', 'withdraw', self._w) + + withdraw = wm_withdraw + + +class Tk(Misc, Wm): + """Toplevel widget of Tk which represents mostly the main window + of an application. It has an associated Tcl interpreter.""" + _w = '.' + + def __init__(self, screenName=None, baseName=None, className='Tk', + useTk=True, sync=False, use=None): + """Return a new top level widget on screen SCREENNAME. A new Tcl interpreter will + be created. BASENAME will be used for the identification of the profile file (see + readprofile). + It is constructed from sys.argv[0] without extensions if None is given. CLASSNAME + is the name of the widget class.""" + self.master = None + self.children = {} + self._tkloaded = False + # to avoid recursions in the getattr code in case of failure, we + # ensure that self.tk is always _something_. + self.tk = None + if baseName is None: + import os + baseName = os.path.basename(sys.argv[0]) + baseName, ext = os.path.splitext(baseName) + if ext not in ('.py', '.pyc'): + baseName = baseName + ext + interactive = False + self.tk = _tkinter.create(screenName, baseName, className, interactive, wantobjects, useTk, sync, use) + if useTk: + self._loadtk() + if not sys.flags.ignore_environment: + # Issue #16248: Honor the -E flag to avoid code injection. + self.readprofile(baseName, className) + + def loadtk(self): + if not self._tkloaded: + self.tk.loadtk() + self._loadtk() + + def _loadtk(self): + self._tkloaded = True + global _default_root + # Version sanity checks + tk_version = self.tk.getvar('tk_version') + if tk_version != _tkinter.TK_VERSION: + raise RuntimeError("tk.h version (%s) doesn't match libtk.a version (%s)" + % (_tkinter.TK_VERSION, tk_version)) + # Under unknown circumstances, tcl_version gets coerced to float + tcl_version = str(self.tk.getvar('tcl_version')) + if tcl_version != _tkinter.TCL_VERSION: + raise RuntimeError("tcl.h version (%s) doesn't match libtcl.a version (%s)" \ + % (_tkinter.TCL_VERSION, tcl_version)) + # Create and register the tkerror and exit commands + # We need to inline parts of _register here, _ register + # would register differently-named commands. + if self._tclCommands is None: + self._tclCommands = [] + self.tk.createcommand('tkerror', _tkerror) + self.tk.createcommand('exit', _exit) + self._tclCommands.append('tkerror') + self._tclCommands.append('exit') + if _support_default_root and _default_root is None: + _default_root = self + self.protocol("WM_DELETE_WINDOW", self.destroy) + + def destroy(self): + """Destroy this and all descendants widgets. This will + end the application of this Tcl interpreter.""" + for c in list(self.children.values()): c.destroy() + self.tk.call('destroy', self._w) + Misc.destroy(self) + global _default_root + if _support_default_root and _default_root is self: + _default_root = None + + def readprofile(self, baseName, className): + """Internal function. It reads .BASENAME.tcl and .CLASSNAME.tcl into + the Tcl Interpreter and calls exec on the contents of .BASENAME.py and + .CLASSNAME.py if such a file exists in the home directory.""" + import os + if 'HOME' in os.environ: home = os.environ['HOME'] + else: home = os.curdir + class_tcl = os.path.join(home, '.%s.tcl' % className) + class_py = os.path.join(home, '.%s.py' % className) + base_tcl = os.path.join(home, '.%s.tcl' % baseName) + base_py = os.path.join(home, '.%s.py' % baseName) + dir = {'self': self} + exec('from tkinter import *', dir) + if os.path.isfile(class_tcl): + self.tk.call('source', class_tcl) + if os.path.isfile(class_py): + exec(open(class_py).read(), dir) + if os.path.isfile(base_tcl): + self.tk.call('source', base_tcl) + if os.path.isfile(base_py): + exec(open(base_py).read(), dir) + + def report_callback_exception(self, exc, val, tb): + """Report callback exception on sys.stderr. + + Applications may want to override this internal function, and + should when sys.stderr is None.""" + import traceback + print("Exception in Tkinter callback", file=sys.stderr) + sys.last_type = exc + sys.last_value = val + sys.last_traceback = tb + traceback.print_exception(exc, val, tb) + + def __getattr__(self, attr): + "Delegate attribute access to the interpreter object" + return getattr(self.tk, attr) + +# Ideally, the classes Pack, Place and Grid disappear, the +# pack/place/grid methods are defined on the Widget class, and +# everybody uses w.pack_whatever(...) instead of Pack.whatever(w, +# ...), with pack(), place() and grid() being short for +# pack_configure(), place_configure() and grid_columnconfigure(), and +# forget() being short for pack_forget(). As a practical matter, I'm +# afraid that there is too much code out there that may be using the +# Pack, Place or Grid class, so I leave them intact -- but only as +# backwards compatibility features. Also note that those methods that +# take a master as argument (e.g. pack_propagate) have been moved to +# the Misc class (which now incorporates all methods common between +# toplevel and interior widgets). Again, for compatibility, these are +# copied into the Pack, Place or Grid class. + + +def Tcl(screenName=None, baseName=None, className='Tk', useTk=False): + return Tk(screenName, baseName, className, useTk) + + +class Pack: + """Geometry manager Pack. + + Base class to use the methods pack_* in every widget.""" + + def pack_configure(self, cnf={}, **kw): + """Pack a widget in the parent widget. Use as options: + after=widget - pack it after you have packed widget + anchor=NSEW (or subset) - position widget according to + given direction + before=widget - pack it before you will pack widget + expand=bool - expand widget if parent size grows + fill=NONE or X or Y or BOTH - fill widget if widget grows + in=master - use master to contain this widget + in_=master - see 'in' option description + ipadx=amount - add internal padding in x direction + ipady=amount - add internal padding in y direction + padx=amount - add padding in x direction + pady=amount - add padding in y direction + side=TOP or BOTTOM or LEFT or RIGHT - where to add this widget. + """ + self.tk.call( + ('pack', 'configure', self._w) + + self._options(cnf, kw)) + + pack = configure = config = pack_configure + + def pack_forget(self): + """Unmap this widget and do not use it for the packing order.""" + self.tk.call('pack', 'forget', self._w) + + forget = pack_forget + + def pack_info(self): + """Return information about the packing options + for this widget.""" + d = _splitdict(self.tk, self.tk.call('pack', 'info', self._w)) + if 'in' in d: + d['in'] = self.nametowidget(d['in']) + return d + + info = pack_info + propagate = pack_propagate = Misc.pack_propagate + slaves = pack_slaves = Misc.pack_slaves + + +class Place: + """Geometry manager Place. + + Base class to use the methods place_* in every widget.""" + + def place_configure(self, cnf={}, **kw): + """Place a widget in the parent widget. Use as options: + in=master - master relative to which the widget is placed + in_=master - see 'in' option description + x=amount - locate anchor of this widget at position x of master + y=amount - locate anchor of this widget at position y of master + relx=amount - locate anchor of this widget between 0.0 and 1.0 + relative to width of master (1.0 is right edge) + rely=amount - locate anchor of this widget between 0.0 and 1.0 + relative to height of master (1.0 is bottom edge) + anchor=NSEW (or subset) - position anchor according to given direction + width=amount - width of this widget in pixel + height=amount - height of this widget in pixel + relwidth=amount - width of this widget between 0.0 and 1.0 + relative to width of master (1.0 is the same width + as the master) + relheight=amount - height of this widget between 0.0 and 1.0 + relative to height of master (1.0 is the same + height as the master) + bordermode="inside" or "outside" - whether to take border width of + master widget into account + """ + self.tk.call( + ('place', 'configure', self._w) + + self._options(cnf, kw)) + + place = configure = config = place_configure + + def place_forget(self): + """Unmap this widget.""" + self.tk.call('place', 'forget', self._w) + + forget = place_forget + + def place_info(self): + """Return information about the placing options + for this widget.""" + d = _splitdict(self.tk, self.tk.call('place', 'info', self._w)) + if 'in' in d: + d['in'] = self.nametowidget(d['in']) + return d + + info = place_info + slaves = place_slaves = Misc.place_slaves + + +class Grid: + """Geometry manager Grid. + + Base class to use the methods grid_* in every widget.""" + # Thanks to Masazumi Yoshikawa (yosikawa@isi.edu) + + def grid_configure(self, cnf={}, **kw): + """Position a widget in the parent widget in a grid. Use as options: + column=number - use cell identified with given column (starting with 0) + columnspan=number - this widget will span several columns + in=master - use master to contain this widget + in_=master - see 'in' option description + ipadx=amount - add internal padding in x direction + ipady=amount - add internal padding in y direction + padx=amount - add padding in x direction + pady=amount - add padding in y direction + row=number - use cell identified with given row (starting with 0) + rowspan=number - this widget will span several rows + sticky=NSEW - if cell is larger on which sides will this + widget stick to the cell boundary + """ + self.tk.call( + ('grid', 'configure', self._w) + + self._options(cnf, kw)) + + grid = configure = config = grid_configure + bbox = grid_bbox = Misc.grid_bbox + columnconfigure = grid_columnconfigure = Misc.grid_columnconfigure + + def grid_forget(self): + """Unmap this widget.""" + self.tk.call('grid', 'forget', self._w) + + forget = grid_forget + + def grid_remove(self): + """Unmap this widget but remember the grid options.""" + self.tk.call('grid', 'remove', self._w) + + def grid_info(self): + """Return information about the options + for positioning this widget in a grid.""" + d = _splitdict(self.tk, self.tk.call('grid', 'info', self._w)) + if 'in' in d: + d['in'] = self.nametowidget(d['in']) + return d + + info = grid_info + location = grid_location = Misc.grid_location + propagate = grid_propagate = Misc.grid_propagate + rowconfigure = grid_rowconfigure = Misc.grid_rowconfigure + size = grid_size = Misc.grid_size + slaves = grid_slaves = Misc.grid_slaves + + +class BaseWidget(Misc): + """Internal class.""" + + def _setup(self, master, cnf): + """Internal function. Sets up information about children.""" + if master is None: + master = _get_default_root() + self.master = master + self.tk = master.tk + name = None + if 'name' in cnf: + name = cnf['name'] + del cnf['name'] + if not name: + name = self.__class__.__name__.lower() + if master._last_child_ids is None: + master._last_child_ids = {} + count = master._last_child_ids.get(name, 0) + 1 + master._last_child_ids[name] = count + if count == 1: + name = '!%s' % (name,) + else: + name = '!%s%d' % (name, count) + self._name = name + if master._w=='.': + self._w = '.' + name + else: + self._w = master._w + '.' + name + self.children = {} + if self._name in self.master.children: + self.master.children[self._name].destroy() + self.master.children[self._name] = self + + def __init__(self, master, widgetName, cnf={}, kw={}, extra=()): + """Construct a widget with the parent widget MASTER, a name WIDGETNAME + and appropriate options.""" + if kw: + cnf = _cnfmerge((cnf, kw)) + self.widgetName = widgetName + self._setup(master, cnf) + if self._tclCommands is None: + self._tclCommands = [] + classes = [(k, v) for k, v in cnf.items() if isinstance(k, type)] + for k, v in classes: + del cnf[k] + self.tk.call( + (widgetName, self._w) + extra + self._options(cnf)) + for k, v in classes: + k.configure(self, v) + + def destroy(self): + """Destroy this and all descendants widgets.""" + for c in list(self.children.values()): c.destroy() + self.tk.call('destroy', self._w) + if self._name in self.master.children: + del self.master.children[self._name] + Misc.destroy(self) + + def _do(self, name, args=()): + # XXX Obsolete -- better use self.tk.call directly! + return self.tk.call((self._w, name) + args) + + +class Widget(BaseWidget, Pack, Place, Grid): + """Internal class. + + Base class for a widget which can be positioned with the geometry managers + Pack, Place or Grid.""" + pass + + +class Toplevel(BaseWidget, Wm): + """Toplevel widget, e.g. for dialogs.""" + + def __init__(self, master=None, cnf={}, **kw): + """Construct a toplevel widget with the parent MASTER. + + Valid resource names: background, bd, bg, borderwidth, class, + colormap, container, cursor, height, highlightbackground, + highlightcolor, highlightthickness, menu, relief, screen, takefocus, + use, visual, width.""" + if kw: + cnf = _cnfmerge((cnf, kw)) + extra = () + for wmkey in ['screen', 'class_', 'class', 'visual', + 'colormap']: + if wmkey in cnf: + val = cnf[wmkey] + # TBD: a hack needed because some keys + # are not valid as keyword arguments + if wmkey[-1] == '_': opt = '-'+wmkey[:-1] + else: opt = '-'+wmkey + extra = extra + (opt, val) + del cnf[wmkey] + BaseWidget.__init__(self, master, 'toplevel', cnf, {}, extra) + root = self._root() + self.iconname(root.iconname()) + self.title(root.title()) + self.protocol("WM_DELETE_WINDOW", self.destroy) + + +class Button(Widget): + """Button widget.""" + + def __init__(self, master=None, cnf={}, **kw): + """Construct a button widget with the parent MASTER. + + STANDARD OPTIONS + + activebackground, activeforeground, anchor, + background, bitmap, borderwidth, cursor, + disabledforeground, font, foreground + highlightbackground, highlightcolor, + highlightthickness, image, justify, + padx, pady, relief, repeatdelay, + repeatinterval, takefocus, text, + textvariable, underline, wraplength + + WIDGET-SPECIFIC OPTIONS + + command, compound, default, height, + overrelief, state, width + """ + Widget.__init__(self, master, 'button', cnf, kw) + + def flash(self): + """Flash the button. + + This is accomplished by redisplaying + the button several times, alternating between active and + normal colors. At the end of the flash the button is left + in the same normal/active state as when the command was + invoked. This command is ignored if the button's state is + disabled. + """ + self.tk.call(self._w, 'flash') + + def invoke(self): + """Invoke the command associated with the button. + + The return value is the return value from the command, + or an empty string if there is no command associated with + the button. This command is ignored if the button's state + is disabled. + """ + return self.tk.call(self._w, 'invoke') + + +class Canvas(Widget, XView, YView): + """Canvas widget to display graphical elements like lines or text.""" + + def __init__(self, master=None, cnf={}, **kw): + """Construct a canvas widget with the parent MASTER. + + Valid resource names: background, bd, bg, borderwidth, closeenough, + confine, cursor, height, highlightbackground, highlightcolor, + highlightthickness, insertbackground, insertborderwidth, + insertofftime, insertontime, insertwidth, offset, relief, + scrollregion, selectbackground, selectborderwidth, selectforeground, + state, takefocus, width, xscrollcommand, xscrollincrement, + yscrollcommand, yscrollincrement.""" + Widget.__init__(self, master, 'canvas', cnf, kw) + + def addtag(self, *args): + """Internal function.""" + self.tk.call((self._w, 'addtag') + args) + + def addtag_above(self, newtag, tagOrId): + """Add tag NEWTAG to all items above TAGORID.""" + self.addtag(newtag, 'above', tagOrId) + + def addtag_all(self, newtag): + """Add tag NEWTAG to all items.""" + self.addtag(newtag, 'all') + + def addtag_below(self, newtag, tagOrId): + """Add tag NEWTAG to all items below TAGORID.""" + self.addtag(newtag, 'below', tagOrId) + + def addtag_closest(self, newtag, x, y, halo=None, start=None): + """Add tag NEWTAG to item which is closest to pixel at X, Y. + If several match take the top-most. + All items closer than HALO are considered overlapping (all are + closest). If START is specified the next below this tag is taken.""" + self.addtag(newtag, 'closest', x, y, halo, start) + + def addtag_enclosed(self, newtag, x1, y1, x2, y2): + """Add tag NEWTAG to all items in the rectangle defined + by X1,Y1,X2,Y2.""" + self.addtag(newtag, 'enclosed', x1, y1, x2, y2) + + def addtag_overlapping(self, newtag, x1, y1, x2, y2): + """Add tag NEWTAG to all items which overlap the rectangle + defined by X1,Y1,X2,Y2.""" + self.addtag(newtag, 'overlapping', x1, y1, x2, y2) + + def addtag_withtag(self, newtag, tagOrId): + """Add tag NEWTAG to all items with TAGORID.""" + self.addtag(newtag, 'withtag', tagOrId) + + def bbox(self, *args): + """Return a tuple of X1,Y1,X2,Y2 coordinates for a rectangle + which encloses all items with tags specified as arguments.""" + return self._getints( + self.tk.call((self._w, 'bbox') + args)) or None + + def tag_unbind(self, tagOrId, sequence, funcid=None): + """Unbind for all items with TAGORID for event SEQUENCE the + function identified with FUNCID.""" + self._unbind((self._w, 'bind', tagOrId, sequence), funcid) + + def tag_bind(self, tagOrId, sequence=None, func=None, add=None): + """Bind to all items with TAGORID at event SEQUENCE a call to function FUNC. + + An additional boolean parameter ADD specifies whether FUNC will be + called additionally to the other bound function or whether it will + replace the previous function. See bind for the return value.""" + return self._bind((self._w, 'bind', tagOrId), + sequence, func, add) + + def canvasx(self, screenx, gridspacing=None): + """Return the canvas x coordinate of pixel position SCREENX rounded + to nearest multiple of GRIDSPACING units.""" + return self.tk.getdouble(self.tk.call( + self._w, 'canvasx', screenx, gridspacing)) + + def canvasy(self, screeny, gridspacing=None): + """Return the canvas y coordinate of pixel position SCREENY rounded + to nearest multiple of GRIDSPACING units.""" + return self.tk.getdouble(self.tk.call( + self._w, 'canvasy', screeny, gridspacing)) + + def coords(self, *args): + """Return a list of coordinates for the item given in ARGS.""" + # XXX Should use _flatten on args + return [self.tk.getdouble(x) for x in + self.tk.splitlist( + self.tk.call((self._w, 'coords') + args))] + + def _create(self, itemType, args, kw): # Args: (val, val, ..., cnf={}) + """Internal function.""" + args = _flatten(args) + cnf = args[-1] + if isinstance(cnf, (dict, tuple)): + args = args[:-1] + else: + cnf = {} + return self.tk.getint(self.tk.call( + self._w, 'create', itemType, + *(args + self._options(cnf, kw)))) + + def create_arc(self, *args, **kw): + """Create arc shaped region with coordinates x1,y1,x2,y2.""" + return self._create('arc', args, kw) + + def create_bitmap(self, *args, **kw): + """Create bitmap with coordinates x1,y1.""" + return self._create('bitmap', args, kw) + + def create_image(self, *args, **kw): + """Create image item with coordinates x1,y1.""" + return self._create('image', args, kw) + + def create_line(self, *args, **kw): + """Create line with coordinates x1,y1,...,xn,yn.""" + return self._create('line', args, kw) + + def create_oval(self, *args, **kw): + """Create oval with coordinates x1,y1,x2,y2.""" + return self._create('oval', args, kw) + + def create_polygon(self, *args, **kw): + """Create polygon with coordinates x1,y1,...,xn,yn.""" + return self._create('polygon', args, kw) + + def create_rectangle(self, *args, **kw): + """Create rectangle with coordinates x1,y1,x2,y2.""" + return self._create('rectangle', args, kw) + + def create_text(self, *args, **kw): + """Create text with coordinates x1,y1.""" + return self._create('text', args, kw) + + def create_window(self, *args, **kw): + """Create window with coordinates x1,y1,x2,y2.""" + return self._create('window', args, kw) + + def dchars(self, *args): + """Delete characters of text items identified by tag or id in ARGS (possibly + several times) from FIRST to LAST character (including).""" + self.tk.call((self._w, 'dchars') + args) + + def delete(self, *args): + """Delete items identified by all tag or ids contained in ARGS.""" + self.tk.call((self._w, 'delete') + args) + + def dtag(self, *args): + """Delete tag or id given as last arguments in ARGS from items + identified by first argument in ARGS.""" + self.tk.call((self._w, 'dtag') + args) + + def find(self, *args): + """Internal function.""" + return self._getints( + self.tk.call((self._w, 'find') + args)) or () + + def find_above(self, tagOrId): + """Return items above TAGORID.""" + return self.find('above', tagOrId) + + def find_all(self): + """Return all items.""" + return self.find('all') + + def find_below(self, tagOrId): + """Return all items below TAGORID.""" + return self.find('below', tagOrId) + + def find_closest(self, x, y, halo=None, start=None): + """Return item which is closest to pixel at X, Y. + If several match take the top-most. + All items closer than HALO are considered overlapping (all are + closest). If START is specified the next below this tag is taken.""" + return self.find('closest', x, y, halo, start) + + def find_enclosed(self, x1, y1, x2, y2): + """Return all items in rectangle defined + by X1,Y1,X2,Y2.""" + return self.find('enclosed', x1, y1, x2, y2) + + def find_overlapping(self, x1, y1, x2, y2): + """Return all items which overlap the rectangle + defined by X1,Y1,X2,Y2.""" + return self.find('overlapping', x1, y1, x2, y2) + + def find_withtag(self, tagOrId): + """Return all items with TAGORID.""" + return self.find('withtag', tagOrId) + + def focus(self, *args): + """Set focus to the first item specified in ARGS.""" + return self.tk.call((self._w, 'focus') + args) + + def gettags(self, *args): + """Return tags associated with the first item specified in ARGS.""" + return self.tk.splitlist( + self.tk.call((self._w, 'gettags') + args)) + + def icursor(self, *args): + """Set cursor at position POS in the item identified by TAGORID. + In ARGS TAGORID must be first.""" + self.tk.call((self._w, 'icursor') + args) + + def index(self, *args): + """Return position of cursor as integer in item specified in ARGS.""" + return self.tk.getint(self.tk.call((self._w, 'index') + args)) + + def insert(self, *args): + """Insert TEXT in item TAGORID at position POS. ARGS must + be TAGORID POS TEXT.""" + self.tk.call((self._w, 'insert') + args) + + def itemcget(self, tagOrId, option): + """Return the resource value for an OPTION for item TAGORID.""" + return self.tk.call( + (self._w, 'itemcget') + (tagOrId, '-'+option)) + + def itemconfigure(self, tagOrId, cnf=None, **kw): + """Configure resources of an item TAGORID. + + The values for resources are specified as keyword + arguments. To get an overview about + the allowed keyword arguments call the method without arguments. + """ + return self._configure(('itemconfigure', tagOrId), cnf, kw) + + itemconfig = itemconfigure + + # lower, tkraise/lift hide Misc.lower, Misc.tkraise/lift, + # so the preferred name for them is tag_lower, tag_raise + # (similar to tag_bind, and similar to the Text widget); + # unfortunately can't delete the old ones yet (maybe in 1.6) + def tag_lower(self, *args): + """Lower an item TAGORID given in ARGS + (optional below another item).""" + self.tk.call((self._w, 'lower') + args) + + lower = tag_lower + + def move(self, *args): + """Move an item TAGORID given in ARGS.""" + self.tk.call((self._w, 'move') + args) + + def moveto(self, tagOrId, x='', y=''): + """Move the items given by TAGORID in the canvas coordinate + space so that the first coordinate pair of the bottommost + item with tag TAGORID is located at position (X,Y). + X and Y may be the empty string, in which case the + corresponding coordinate will be unchanged. All items matching + TAGORID remain in the same positions relative to each other.""" + self.tk.call(self._w, 'moveto', tagOrId, x, y) + + def postscript(self, cnf={}, **kw): + """Print the contents of the canvas to a postscript + file. Valid options: colormap, colormode, file, fontmap, + height, pageanchor, pageheight, pagewidth, pagex, pagey, + rotate, width, x, y.""" + return self.tk.call((self._w, 'postscript') + + self._options(cnf, kw)) + + def tag_raise(self, *args): + """Raise an item TAGORID given in ARGS + (optional above another item).""" + self.tk.call((self._w, 'raise') + args) + + lift = tkraise = tag_raise + + def scale(self, *args): + """Scale item TAGORID with XORIGIN, YORIGIN, XSCALE, YSCALE.""" + self.tk.call((self._w, 'scale') + args) + + def scan_mark(self, x, y): + """Remember the current X, Y coordinates.""" + self.tk.call(self._w, 'scan', 'mark', x, y) + + def scan_dragto(self, x, y, gain=10): + """Adjust the view of the canvas to GAIN times the + difference between X and Y and the coordinates given in + scan_mark.""" + self.tk.call(self._w, 'scan', 'dragto', x, y, gain) + + def select_adjust(self, tagOrId, index): + """Adjust the end of the selection near the cursor of an item TAGORID to index.""" + self.tk.call(self._w, 'select', 'adjust', tagOrId, index) + + def select_clear(self): + """Clear the selection if it is in this widget.""" + self.tk.call(self._w, 'select', 'clear') + + def select_from(self, tagOrId, index): + """Set the fixed end of a selection in item TAGORID to INDEX.""" + self.tk.call(self._w, 'select', 'from', tagOrId, index) + + def select_item(self): + """Return the item which has the selection.""" + return self.tk.call(self._w, 'select', 'item') or None + + def select_to(self, tagOrId, index): + """Set the variable end of a selection in item TAGORID to INDEX.""" + self.tk.call(self._w, 'select', 'to', tagOrId, index) + + def type(self, tagOrId): + """Return the type of the item TAGORID.""" + return self.tk.call(self._w, 'type', tagOrId) or None + + +_checkbutton_count = 0 + +class Checkbutton(Widget): + """Checkbutton widget which is either in on- or off-state.""" + + def __init__(self, master=None, cnf={}, **kw): + """Construct a checkbutton widget with the parent MASTER. + + Valid resource names: activebackground, activeforeground, anchor, + background, bd, bg, bitmap, borderwidth, command, cursor, + disabledforeground, fg, font, foreground, height, + highlightbackground, highlightcolor, highlightthickness, image, + indicatoron, justify, offvalue, onvalue, padx, pady, relief, + selectcolor, selectimage, state, takefocus, text, textvariable, + underline, variable, width, wraplength.""" + Widget.__init__(self, master, 'checkbutton', cnf, kw) + + def _setup(self, master, cnf): + # Because Checkbutton defaults to a variable with the same name as + # the widget, Checkbutton default names must be globally unique, + # not just unique within the parent widget. + if not cnf.get('name'): + global _checkbutton_count + name = self.__class__.__name__.lower() + _checkbutton_count += 1 + # To avoid collisions with ttk.Checkbutton, use the different + # name template. + cnf['name'] = f'!{name}-{_checkbutton_count}' + super()._setup(master, cnf) + + def deselect(self): + """Put the button in off-state.""" + self.tk.call(self._w, 'deselect') + + def flash(self): + """Flash the button.""" + self.tk.call(self._w, 'flash') + + def invoke(self): + """Toggle the button and invoke a command if given as resource.""" + return self.tk.call(self._w, 'invoke') + + def select(self): + """Put the button in on-state.""" + self.tk.call(self._w, 'select') + + def toggle(self): + """Toggle the button.""" + self.tk.call(self._w, 'toggle') + + +class Entry(Widget, XView): + """Entry widget which allows displaying simple text.""" + + def __init__(self, master=None, cnf={}, **kw): + """Construct an entry widget with the parent MASTER. + + Valid resource names: background, bd, bg, borderwidth, cursor, + exportselection, fg, font, foreground, highlightbackground, + highlightcolor, highlightthickness, insertbackground, + insertborderwidth, insertofftime, insertontime, insertwidth, + invalidcommand, invcmd, justify, relief, selectbackground, + selectborderwidth, selectforeground, show, state, takefocus, + textvariable, validate, validatecommand, vcmd, width, + xscrollcommand.""" + Widget.__init__(self, master, 'entry', cnf, kw) + + def delete(self, first, last=None): + """Delete text from FIRST to LAST (not included).""" + self.tk.call(self._w, 'delete', first, last) + + def get(self): + """Return the text.""" + return self.tk.call(self._w, 'get') + + def icursor(self, index): + """Insert cursor at INDEX.""" + self.tk.call(self._w, 'icursor', index) + + def index(self, index): + """Return position of cursor.""" + return self.tk.getint(self.tk.call( + self._w, 'index', index)) + + def insert(self, index, string): + """Insert STRING at INDEX.""" + self.tk.call(self._w, 'insert', index, string) + + def scan_mark(self, x): + """Remember the current X, Y coordinates.""" + self.tk.call(self._w, 'scan', 'mark', x) + + def scan_dragto(self, x): + """Adjust the view of the canvas to 10 times the + difference between X and Y and the coordinates given in + scan_mark.""" + self.tk.call(self._w, 'scan', 'dragto', x) + + def selection_adjust(self, index): + """Adjust the end of the selection near the cursor to INDEX.""" + self.tk.call(self._w, 'selection', 'adjust', index) + + select_adjust = selection_adjust + + def selection_clear(self): + """Clear the selection if it is in this widget.""" + self.tk.call(self._w, 'selection', 'clear') + + select_clear = selection_clear + + def selection_from(self, index): + """Set the fixed end of a selection to INDEX.""" + self.tk.call(self._w, 'selection', 'from', index) + + select_from = selection_from + + def selection_present(self): + """Return True if there are characters selected in the entry, False + otherwise.""" + return self.tk.getboolean( + self.tk.call(self._w, 'selection', 'present')) + + select_present = selection_present + + def selection_range(self, start, end): + """Set the selection from START to END (not included).""" + self.tk.call(self._w, 'selection', 'range', start, end) + + select_range = selection_range + + def selection_to(self, index): + """Set the variable end of a selection to INDEX.""" + self.tk.call(self._w, 'selection', 'to', index) + + select_to = selection_to + + +class Frame(Widget): + """Frame widget which may contain other widgets and can have a 3D border.""" + + def __init__(self, master=None, cnf={}, **kw): + """Construct a frame widget with the parent MASTER. + + Valid resource names: background, bd, bg, borderwidth, class, + colormap, container, cursor, height, highlightbackground, + highlightcolor, highlightthickness, relief, takefocus, visual, width.""" + cnf = _cnfmerge((cnf, kw)) + extra = () + if 'class_' in cnf: + extra = ('-class', cnf['class_']) + del cnf['class_'] + elif 'class' in cnf: + extra = ('-class', cnf['class']) + del cnf['class'] + Widget.__init__(self, master, 'frame', cnf, {}, extra) + + +class Label(Widget): + """Label widget which can display text and bitmaps.""" + + def __init__(self, master=None, cnf={}, **kw): + """Construct a label widget with the parent MASTER. + + STANDARD OPTIONS + + activebackground, activeforeground, anchor, + background, bitmap, borderwidth, cursor, + disabledforeground, font, foreground, + highlightbackground, highlightcolor, + highlightthickness, image, justify, + padx, pady, relief, takefocus, text, + textvariable, underline, wraplength + + WIDGET-SPECIFIC OPTIONS + + height, state, width + + """ + Widget.__init__(self, master, 'label', cnf, kw) + + +class Listbox(Widget, XView, YView): + """Listbox widget which can display a list of strings.""" + + def __init__(self, master=None, cnf={}, **kw): + """Construct a listbox widget with the parent MASTER. + + Valid resource names: background, bd, bg, borderwidth, cursor, + exportselection, fg, font, foreground, height, highlightbackground, + highlightcolor, highlightthickness, relief, selectbackground, + selectborderwidth, selectforeground, selectmode, setgrid, takefocus, + width, xscrollcommand, yscrollcommand, listvariable.""" + Widget.__init__(self, master, 'listbox', cnf, kw) + + def activate(self, index): + """Activate item identified by INDEX.""" + self.tk.call(self._w, 'activate', index) + + def bbox(self, index): + """Return a tuple of X1,Y1,X2,Y2 coordinates for a rectangle + which encloses the item identified by the given index.""" + return self._getints(self.tk.call(self._w, 'bbox', index)) or None + + def curselection(self): + """Return the indices of currently selected item.""" + return self._getints(self.tk.call(self._w, 'curselection')) or () + + def delete(self, first, last=None): + """Delete items from FIRST to LAST (included).""" + self.tk.call(self._w, 'delete', first, last) + + def get(self, first, last=None): + """Get list of items from FIRST to LAST (included).""" + if last is not None: + return self.tk.splitlist(self.tk.call( + self._w, 'get', first, last)) + else: + return self.tk.call(self._w, 'get', first) + + def index(self, index): + """Return index of item identified with INDEX.""" + i = self.tk.call(self._w, 'index', index) + if i == 'none': return None + return self.tk.getint(i) + + def insert(self, index, *elements): + """Insert ELEMENTS at INDEX.""" + self.tk.call((self._w, 'insert', index) + elements) + + def nearest(self, y): + """Get index of item which is nearest to y coordinate Y.""" + return self.tk.getint(self.tk.call( + self._w, 'nearest', y)) + + def scan_mark(self, x, y): + """Remember the current X, Y coordinates.""" + self.tk.call(self._w, 'scan', 'mark', x, y) + + def scan_dragto(self, x, y): + """Adjust the view of the listbox to 10 times the + difference between X and Y and the coordinates given in + scan_mark.""" + self.tk.call(self._w, 'scan', 'dragto', x, y) + + def see(self, index): + """Scroll such that INDEX is visible.""" + self.tk.call(self._w, 'see', index) + + def selection_anchor(self, index): + """Set the fixed end oft the selection to INDEX.""" + self.tk.call(self._w, 'selection', 'anchor', index) + + select_anchor = selection_anchor + + def selection_clear(self, first, last=None): + """Clear the selection from FIRST to LAST (included).""" + self.tk.call(self._w, + 'selection', 'clear', first, last) + + select_clear = selection_clear + + def selection_includes(self, index): + """Return True if INDEX is part of the selection.""" + return self.tk.getboolean(self.tk.call( + self._w, 'selection', 'includes', index)) + + select_includes = selection_includes + + def selection_set(self, first, last=None): + """Set the selection from FIRST to LAST (included) without + changing the currently selected elements.""" + self.tk.call(self._w, 'selection', 'set', first, last) + + select_set = selection_set + + def size(self): + """Return the number of elements in the listbox.""" + return self.tk.getint(self.tk.call(self._w, 'size')) + + def itemcget(self, index, option): + """Return the resource value for an ITEM and an OPTION.""" + return self.tk.call( + (self._w, 'itemcget') + (index, '-'+option)) + + def itemconfigure(self, index, cnf=None, **kw): + """Configure resources of an ITEM. + + The values for resources are specified as keyword arguments. + To get an overview about the allowed keyword arguments + call the method without arguments. + Valid resource names: background, bg, foreground, fg, + selectbackground, selectforeground.""" + return self._configure(('itemconfigure', index), cnf, kw) + + itemconfig = itemconfigure + + +class Menu(Widget): + """Menu widget which allows displaying menu bars, pull-down menus and pop-up menus.""" + + def __init__(self, master=None, cnf={}, **kw): + """Construct menu widget with the parent MASTER. + + Valid resource names: activebackground, activeborderwidth, + activeforeground, background, bd, bg, borderwidth, cursor, + disabledforeground, fg, font, foreground, postcommand, relief, + selectcolor, takefocus, tearoff, tearoffcommand, title, type.""" + Widget.__init__(self, master, 'menu', cnf, kw) + + def tk_popup(self, x, y, entry=""): + """Post the menu at position X,Y with entry ENTRY.""" + self.tk.call('tk_popup', self._w, x, y, entry) + + def activate(self, index): + """Activate entry at INDEX.""" + self.tk.call(self._w, 'activate', index) + + def add(self, itemType, cnf={}, **kw): + """Internal function.""" + self.tk.call((self._w, 'add', itemType) + + self._options(cnf, kw)) + + def add_cascade(self, cnf={}, **kw): + """Add hierarchical menu item.""" + self.add('cascade', cnf or kw) + + def add_checkbutton(self, cnf={}, **kw): + """Add checkbutton menu item.""" + self.add('checkbutton', cnf or kw) + + def add_command(self, cnf={}, **kw): + """Add command menu item.""" + self.add('command', cnf or kw) + + def add_radiobutton(self, cnf={}, **kw): + """Add radio menu item.""" + self.add('radiobutton', cnf or kw) + + def add_separator(self, cnf={}, **kw): + """Add separator.""" + self.add('separator', cnf or kw) + + def insert(self, index, itemType, cnf={}, **kw): + """Internal function.""" + self.tk.call((self._w, 'insert', index, itemType) + + self._options(cnf, kw)) + + def insert_cascade(self, index, cnf={}, **kw): + """Add hierarchical menu item at INDEX.""" + self.insert(index, 'cascade', cnf or kw) + + def insert_checkbutton(self, index, cnf={}, **kw): + """Add checkbutton menu item at INDEX.""" + self.insert(index, 'checkbutton', cnf or kw) + + def insert_command(self, index, cnf={}, **kw): + """Add command menu item at INDEX.""" + self.insert(index, 'command', cnf or kw) + + def insert_radiobutton(self, index, cnf={}, **kw): + """Add radio menu item at INDEX.""" + self.insert(index, 'radiobutton', cnf or kw) + + def insert_separator(self, index, cnf={}, **kw): + """Add separator at INDEX.""" + self.insert(index, 'separator', cnf or kw) + + def delete(self, index1, index2=None): + """Delete menu items between INDEX1 and INDEX2 (included).""" + if index2 is None: + index2 = index1 + + num_index1, num_index2 = self.index(index1), self.index(index2) + if (num_index1 is None) or (num_index2 is None): + num_index1, num_index2 = 0, -1 + + for i in range(num_index1, num_index2 + 1): + if 'command' in self.entryconfig(i): + c = str(self.entrycget(i, 'command')) + if c: + self.deletecommand(c) + self.tk.call(self._w, 'delete', index1, index2) + + def entrycget(self, index, option): + """Return the resource value of a menu item for OPTION at INDEX.""" + return self.tk.call(self._w, 'entrycget', index, '-' + option) + + def entryconfigure(self, index, cnf=None, **kw): + """Configure a menu item at INDEX.""" + return self._configure(('entryconfigure', index), cnf, kw) + + entryconfig = entryconfigure + + def index(self, index): + """Return the index of a menu item identified by INDEX.""" + i = self.tk.call(self._w, 'index', index) + return None if i in ('', 'none') else self.tk.getint(i) # GH-103685. + + def invoke(self, index): + """Invoke a menu item identified by INDEX and execute + the associated command.""" + return self.tk.call(self._w, 'invoke', index) + + def post(self, x, y): + """Display a menu at position X,Y.""" + self.tk.call(self._w, 'post', x, y) + + def type(self, index): + """Return the type of the menu item at INDEX.""" + return self.tk.call(self._w, 'type', index) + + def unpost(self): + """Unmap a menu.""" + self.tk.call(self._w, 'unpost') + + def xposition(self, index): # new in Tk 8.5 + """Return the x-position of the leftmost pixel of the menu item + at INDEX.""" + return self.tk.getint(self.tk.call(self._w, 'xposition', index)) + + def yposition(self, index): + """Return the y-position of the topmost pixel of the menu item at INDEX.""" + return self.tk.getint(self.tk.call( + self._w, 'yposition', index)) + + +class Menubutton(Widget): + """Menubutton widget, obsolete since Tk8.0.""" + + def __init__(self, master=None, cnf={}, **kw): + Widget.__init__(self, master, 'menubutton', cnf, kw) + + +class Message(Widget): + """Message widget to display multiline text. Obsolete since Label does it too.""" + + def __init__(self, master=None, cnf={}, **kw): + Widget.__init__(self, master, 'message', cnf, kw) + + +class Radiobutton(Widget): + """Radiobutton widget which shows only one of several buttons in on-state.""" + + def __init__(self, master=None, cnf={}, **kw): + """Construct a radiobutton widget with the parent MASTER. + + Valid resource names: activebackground, activeforeground, anchor, + background, bd, bg, bitmap, borderwidth, command, cursor, + disabledforeground, fg, font, foreground, height, + highlightbackground, highlightcolor, highlightthickness, image, + indicatoron, justify, padx, pady, relief, selectcolor, selectimage, + state, takefocus, text, textvariable, underline, value, variable, + width, wraplength.""" + Widget.__init__(self, master, 'radiobutton', cnf, kw) + + def deselect(self): + """Put the button in off-state.""" + + self.tk.call(self._w, 'deselect') + + def flash(self): + """Flash the button.""" + self.tk.call(self._w, 'flash') + + def invoke(self): + """Toggle the button and invoke a command if given as resource.""" + return self.tk.call(self._w, 'invoke') + + def select(self): + """Put the button in on-state.""" + self.tk.call(self._w, 'select') + + +class Scale(Widget): + """Scale widget which can display a numerical scale.""" + + def __init__(self, master=None, cnf={}, **kw): + """Construct a scale widget with the parent MASTER. + + Valid resource names: activebackground, background, bigincrement, bd, + bg, borderwidth, command, cursor, digits, fg, font, foreground, from, + highlightbackground, highlightcolor, highlightthickness, label, + length, orient, relief, repeatdelay, repeatinterval, resolution, + showvalue, sliderlength, sliderrelief, state, takefocus, + tickinterval, to, troughcolor, variable, width.""" + Widget.__init__(self, master, 'scale', cnf, kw) + + def get(self): + """Get the current value as integer or float.""" + value = self.tk.call(self._w, 'get') + try: + return self.tk.getint(value) + except (ValueError, TypeError, TclError): + return self.tk.getdouble(value) + + def set(self, value): + """Set the value to VALUE.""" + self.tk.call(self._w, 'set', value) + + def coords(self, value=None): + """Return a tuple (X,Y) of the point along the centerline of the + trough that corresponds to VALUE or the current value if None is + given.""" + + return self._getints(self.tk.call(self._w, 'coords', value)) + + def identify(self, x, y): + """Return where the point X,Y lies. Valid return values are "slider", + "though1" and "though2".""" + return self.tk.call(self._w, 'identify', x, y) + + +class Scrollbar(Widget): + """Scrollbar widget which displays a slider at a certain position.""" + + def __init__(self, master=None, cnf={}, **kw): + """Construct a scrollbar widget with the parent MASTER. + + Valid resource names: activebackground, activerelief, + background, bd, bg, borderwidth, command, cursor, + elementborderwidth, highlightbackground, + highlightcolor, highlightthickness, jump, orient, + relief, repeatdelay, repeatinterval, takefocus, + troughcolor, width.""" + Widget.__init__(self, master, 'scrollbar', cnf, kw) + + def activate(self, index=None): + """Marks the element indicated by index as active. + The only index values understood by this method are "arrow1", + "slider", or "arrow2". If any other value is specified then no + element of the scrollbar will be active. If index is not specified, + the method returns the name of the element that is currently active, + or None if no element is active.""" + return self.tk.call(self._w, 'activate', index) or None + + def delta(self, deltax, deltay): + """Return the fractional change of the scrollbar setting if it + would be moved by DELTAX or DELTAY pixels.""" + return self.tk.getdouble( + self.tk.call(self._w, 'delta', deltax, deltay)) + + def fraction(self, x, y): + """Return the fractional value which corresponds to a slider + position of X,Y.""" + return self.tk.getdouble(self.tk.call(self._w, 'fraction', x, y)) + + def identify(self, x, y): + """Return the element under position X,Y as one of + "arrow1","slider","arrow2" or "".""" + return self.tk.call(self._w, 'identify', x, y) + + def get(self): + """Return the current fractional values (upper and lower end) + of the slider position.""" + return self._getdoubles(self.tk.call(self._w, 'get')) + + def set(self, first, last): + """Set the fractional values of the slider position (upper and + lower ends as value between 0 and 1).""" + self.tk.call(self._w, 'set', first, last) + + +class Text(Widget, XView, YView): + """Text widget which can display text in various forms.""" + + def __init__(self, master=None, cnf={}, **kw): + """Construct a text widget with the parent MASTER. + + STANDARD OPTIONS + + background, borderwidth, cursor, + exportselection, font, foreground, + highlightbackground, highlightcolor, + highlightthickness, insertbackground, + insertborderwidth, insertofftime, + insertontime, insertwidth, padx, pady, + relief, selectbackground, + selectborderwidth, selectforeground, + setgrid, takefocus, + xscrollcommand, yscrollcommand, + + WIDGET-SPECIFIC OPTIONS + + autoseparators, height, maxundo, + spacing1, spacing2, spacing3, + state, tabs, undo, width, wrap, + + """ + Widget.__init__(self, master, 'text', cnf, kw) + + def bbox(self, index): + """Return a tuple of (x,y,width,height) which gives the bounding + box of the visible part of the character at the given index.""" + return self._getints( + self.tk.call(self._w, 'bbox', index)) or None + + def compare(self, index1, op, index2): + """Return whether between index INDEX1 and index INDEX2 the + relation OP is satisfied. OP is one of <, <=, ==, >=, >, or !=.""" + return self.tk.getboolean(self.tk.call( + self._w, 'compare', index1, op, index2)) + + def count(self, index1, index2, *args): # new in Tk 8.5 + """Counts the number of relevant things between the two indices. + If index1 is after index2, the result will be a negative number + (and this holds for each of the possible options). + + The actual items which are counted depends on the options given by + args. The result is a list of integers, one for the result of each + counting option given. Valid counting options are "chars", + "displaychars", "displayindices", "displaylines", "indices", + "lines", "xpixels" and "ypixels". There is an additional possible + option "update", which if given then all subsequent options ensure + that any possible out of date information is recalculated.""" + args = ['-%s' % arg for arg in args] + args += [index1, index2] + res = self.tk.call(self._w, 'count', *args) or None + if res is not None and len(args) <= 3: + return (res, ) + else: + return res + + def debug(self, boolean=None): + """Turn on the internal consistency checks of the B-Tree inside the text + widget according to BOOLEAN.""" + if boolean is None: + return self.tk.getboolean(self.tk.call(self._w, 'debug')) + self.tk.call(self._w, 'debug', boolean) + + def delete(self, index1, index2=None): + """Delete the characters between INDEX1 and INDEX2 (not included).""" + self.tk.call(self._w, 'delete', index1, index2) + + def dlineinfo(self, index): + """Return tuple (x,y,width,height,baseline) giving the bounding box + and baseline position of the visible part of the line containing + the character at INDEX.""" + return self._getints(self.tk.call(self._w, 'dlineinfo', index)) + + def dump(self, index1, index2=None, command=None, **kw): + """Return the contents of the widget between index1 and index2. + + The type of contents returned in filtered based on the keyword + parameters; if 'all', 'image', 'mark', 'tag', 'text', or 'window' are + given and true, then the corresponding items are returned. The result + is a list of triples of the form (key, value, index). If none of the + keywords are true then 'all' is used by default. + + If the 'command' argument is given, it is called once for each element + of the list of triples, with the values of each triple serving as the + arguments to the function. In this case the list is not returned.""" + args = [] + func_name = None + result = None + if not command: + # Never call the dump command without the -command flag, since the + # output could involve Tcl quoting and would be a pain to parse + # right. Instead just set the command to build a list of triples + # as if we had done the parsing. + result = [] + def append_triple(key, value, index, result=result): + result.append((key, value, index)) + command = append_triple + try: + if not isinstance(command, str): + func_name = command = self._register(command) + args += ["-command", command] + for key in kw: + if kw[key]: args.append("-" + key) + args.append(index1) + if index2: + args.append(index2) + self.tk.call(self._w, "dump", *args) + return result + finally: + if func_name: + self.deletecommand(func_name) + + ## new in tk8.4 + def edit(self, *args): + """Internal method + + This method controls the undo mechanism and + the modified flag. The exact behavior of the + command depends on the option argument that + follows the edit argument. The following forms + of the command are currently supported: + + edit_modified, edit_redo, edit_reset, edit_separator + and edit_undo + + """ + return self.tk.call(self._w, 'edit', *args) + + def edit_modified(self, arg=None): + """Get or Set the modified flag + + If arg is not specified, returns the modified + flag of the widget. The insert, delete, edit undo and + edit redo commands or the user can set or clear the + modified flag. If boolean is specified, sets the + modified flag of the widget to arg. + """ + return self.edit("modified", arg) + + def edit_redo(self): + """Redo the last undone edit + + When the undo option is true, reapplies the last + undone edits provided no other edits were done since + then. Generates an error when the redo stack is empty. + Does nothing when the undo option is false. + """ + return self.edit("redo") + + def edit_reset(self): + """Clears the undo and redo stacks + """ + return self.edit("reset") + + def edit_separator(self): + """Inserts a separator (boundary) on the undo stack. + + Does nothing when the undo option is false + """ + return self.edit("separator") + + def edit_undo(self): + """Undoes the last edit action + + If the undo option is true. An edit action is defined + as all the insert and delete commands that are recorded + on the undo stack in between two separators. Generates + an error when the undo stack is empty. Does nothing + when the undo option is false + """ + return self.edit("undo") + + def get(self, index1, index2=None): + """Return the text from INDEX1 to INDEX2 (not included).""" + return self.tk.call(self._w, 'get', index1, index2) + # (Image commands are new in 8.0) + + def image_cget(self, index, option): + """Return the value of OPTION of an embedded image at INDEX.""" + if option[:1] != "-": + option = "-" + option + if option[-1:] == "_": + option = option[:-1] + return self.tk.call(self._w, "image", "cget", index, option) + + def image_configure(self, index, cnf=None, **kw): + """Configure an embedded image at INDEX.""" + return self._configure(('image', 'configure', index), cnf, kw) + + def image_create(self, index, cnf={}, **kw): + """Create an embedded image at INDEX.""" + return self.tk.call( + self._w, "image", "create", index, + *self._options(cnf, kw)) + + def image_names(self): + """Return all names of embedded images in this widget.""" + return self.tk.call(self._w, "image", "names") + + def index(self, index): + """Return the index in the form line.char for INDEX.""" + return str(self.tk.call(self._w, 'index', index)) + + def insert(self, index, chars, *args): + """Insert CHARS before the characters at INDEX. An additional + tag can be given in ARGS. Additional CHARS and tags can follow in ARGS.""" + self.tk.call((self._w, 'insert', index, chars) + args) + + def mark_gravity(self, markName, direction=None): + """Change the gravity of a mark MARKNAME to DIRECTION (LEFT or RIGHT). + Return the current value if None is given for DIRECTION.""" + return self.tk.call( + (self._w, 'mark', 'gravity', markName, direction)) + + def mark_names(self): + """Return all mark names.""" + return self.tk.splitlist(self.tk.call( + self._w, 'mark', 'names')) + + def mark_set(self, markName, index): + """Set mark MARKNAME before the character at INDEX.""" + self.tk.call(self._w, 'mark', 'set', markName, index) + + def mark_unset(self, *markNames): + """Delete all marks in MARKNAMES.""" + self.tk.call((self._w, 'mark', 'unset') + markNames) + + def mark_next(self, index): + """Return the name of the next mark after INDEX.""" + return self.tk.call(self._w, 'mark', 'next', index) or None + + def mark_previous(self, index): + """Return the name of the previous mark before INDEX.""" + return self.tk.call(self._w, 'mark', 'previous', index) or None + + def peer_create(self, newPathName, cnf={}, **kw): # new in Tk 8.5 + """Creates a peer text widget with the given newPathName, and any + optional standard configuration options. By default the peer will + have the same start and end line as the parent widget, but + these can be overridden with the standard configuration options.""" + self.tk.call(self._w, 'peer', 'create', newPathName, + *self._options(cnf, kw)) + + def peer_names(self): # new in Tk 8.5 + """Returns a list of peers of this widget (this does not include + the widget itself).""" + return self.tk.splitlist(self.tk.call(self._w, 'peer', 'names')) + + def replace(self, index1, index2, chars, *args): # new in Tk 8.5 + """Replaces the range of characters between index1 and index2 with + the given characters and tags specified by args. + + See the method insert for some more information about args, and the + method delete for information about the indices.""" + self.tk.call(self._w, 'replace', index1, index2, chars, *args) + + def scan_mark(self, x, y): + """Remember the current X, Y coordinates.""" + self.tk.call(self._w, 'scan', 'mark', x, y) + + def scan_dragto(self, x, y): + """Adjust the view of the text to 10 times the + difference between X and Y and the coordinates given in + scan_mark.""" + self.tk.call(self._w, 'scan', 'dragto', x, y) + + def search(self, pattern, index, stopindex=None, + forwards=None, backwards=None, exact=None, + regexp=None, nocase=None, count=None, elide=None): + """Search PATTERN beginning from INDEX until STOPINDEX. + Return the index of the first character of a match or an + empty string.""" + args = [self._w, 'search'] + if forwards: args.append('-forwards') + if backwards: args.append('-backwards') + if exact: args.append('-exact') + if regexp: args.append('-regexp') + if nocase: args.append('-nocase') + if elide: args.append('-elide') + if count: args.append('-count'); args.append(count) + if pattern and pattern[0] == '-': args.append('--') + args.append(pattern) + args.append(index) + if stopindex: args.append(stopindex) + return str(self.tk.call(tuple(args))) + + def see(self, index): + """Scroll such that the character at INDEX is visible.""" + self.tk.call(self._w, 'see', index) + + def tag_add(self, tagName, index1, *args): + """Add tag TAGNAME to all characters between INDEX1 and index2 in ARGS. + Additional pairs of indices may follow in ARGS.""" + self.tk.call( + (self._w, 'tag', 'add', tagName, index1) + args) + + def tag_unbind(self, tagName, sequence, funcid=None): + """Unbind for all characters with TAGNAME for event SEQUENCE the + function identified with FUNCID.""" + return self._unbind((self._w, 'tag', 'bind', tagName, sequence), funcid) + + def tag_bind(self, tagName, sequence, func, add=None): + """Bind to all characters with TAGNAME at event SEQUENCE a call to function FUNC. + + An additional boolean parameter ADD specifies whether FUNC will be + called additionally to the other bound function or whether it will + replace the previous function. See bind for the return value.""" + return self._bind((self._w, 'tag', 'bind', tagName), + sequence, func, add) + + def _tag_bind(self, tagName, sequence=None, func=None, add=None): + # For tests only + return self._bind((self._w, 'tag', 'bind', tagName), + sequence, func, add) + + def tag_cget(self, tagName, option): + """Return the value of OPTION for tag TAGNAME.""" + if option[:1] != '-': + option = '-' + option + if option[-1:] == '_': + option = option[:-1] + return self.tk.call(self._w, 'tag', 'cget', tagName, option) + + def tag_configure(self, tagName, cnf=None, **kw): + """Configure a tag TAGNAME.""" + return self._configure(('tag', 'configure', tagName), cnf, kw) + + tag_config = tag_configure + + def tag_delete(self, *tagNames): + """Delete all tags in TAGNAMES.""" + self.tk.call((self._w, 'tag', 'delete') + tagNames) + + def tag_lower(self, tagName, belowThis=None): + """Change the priority of tag TAGNAME such that it is lower + than the priority of BELOWTHIS.""" + self.tk.call(self._w, 'tag', 'lower', tagName, belowThis) + + def tag_names(self, index=None): + """Return a list of all tag names.""" + return self.tk.splitlist( + self.tk.call(self._w, 'tag', 'names', index)) + + def tag_nextrange(self, tagName, index1, index2=None): + """Return a list of start and end index for the first sequence of + characters between INDEX1 and INDEX2 which all have tag TAGNAME. + The text is searched forward from INDEX1.""" + return self.tk.splitlist(self.tk.call( + self._w, 'tag', 'nextrange', tagName, index1, index2)) + + def tag_prevrange(self, tagName, index1, index2=None): + """Return a list of start and end index for the first sequence of + characters between INDEX1 and INDEX2 which all have tag TAGNAME. + The text is searched backwards from INDEX1.""" + return self.tk.splitlist(self.tk.call( + self._w, 'tag', 'prevrange', tagName, index1, index2)) + + def tag_raise(self, tagName, aboveThis=None): + """Change the priority of tag TAGNAME such that it is higher + than the priority of ABOVETHIS.""" + self.tk.call( + self._w, 'tag', 'raise', tagName, aboveThis) + + def tag_ranges(self, tagName): + """Return a list of ranges of text which have tag TAGNAME.""" + return self.tk.splitlist(self.tk.call( + self._w, 'tag', 'ranges', tagName)) + + def tag_remove(self, tagName, index1, index2=None): + """Remove tag TAGNAME from all characters between INDEX1 and INDEX2.""" + self.tk.call( + self._w, 'tag', 'remove', tagName, index1, index2) + + def window_cget(self, index, option): + """Return the value of OPTION of an embedded window at INDEX.""" + if option[:1] != '-': + option = '-' + option + if option[-1:] == '_': + option = option[:-1] + return self.tk.call(self._w, 'window', 'cget', index, option) + + def window_configure(self, index, cnf=None, **kw): + """Configure an embedded window at INDEX.""" + return self._configure(('window', 'configure', index), cnf, kw) + + window_config = window_configure + + def window_create(self, index, cnf={}, **kw): + """Create a window at INDEX.""" + self.tk.call( + (self._w, 'window', 'create', index) + + self._options(cnf, kw)) + + def window_names(self): + """Return all names of embedded windows in this widget.""" + return self.tk.splitlist( + self.tk.call(self._w, 'window', 'names')) + + def yview_pickplace(self, *what): + """Obsolete function, use see.""" + self.tk.call((self._w, 'yview', '-pickplace') + what) + + +class _setit: + """Internal class. It wraps the command in the widget OptionMenu.""" + + def __init__(self, var, value, callback=None): + self.__value = value + self.__var = var + self.__callback = callback + + def __call__(self, *args): + self.__var.set(self.__value) + if self.__callback is not None: + self.__callback(self.__value, *args) + + +class OptionMenu(Menubutton): + """OptionMenu which allows the user to select a value from a menu.""" + + def __init__(self, master, variable, value, *values, **kwargs): + """Construct an optionmenu widget with the parent MASTER, with + the resource textvariable set to VARIABLE, the initially selected + value VALUE, the other menu values VALUES and an additional + keyword argument command.""" + kw = {"borderwidth": 2, "textvariable": variable, + "indicatoron": 1, "relief": RAISED, "anchor": "c", + "highlightthickness": 2} + Widget.__init__(self, master, "menubutton", kw) + self.widgetName = 'tk_optionMenu' + menu = self.__menu = Menu(self, name="menu", tearoff=0) + self.menuname = menu._w + # 'command' is the only supported keyword + callback = kwargs.get('command') + if 'command' in kwargs: + del kwargs['command'] + if kwargs: + raise TclError('unknown option -'+next(iter(kwargs))) + menu.add_command(label=value, + command=_setit(variable, value, callback)) + for v in values: + menu.add_command(label=v, + command=_setit(variable, v, callback)) + self["menu"] = menu + + def __getitem__(self, name): + if name == 'menu': + return self.__menu + return Widget.__getitem__(self, name) + + def destroy(self): + """Destroy this widget and the associated menu.""" + Menubutton.destroy(self) + self.__menu = None + + +class Image: + """Base class for images.""" + _last_id = 0 + + def __init__(self, imgtype, name=None, cnf={}, master=None, **kw): + self.name = None + if master is None: + master = _get_default_root('create image') + self.tk = getattr(master, 'tk', master) + if not name: + Image._last_id += 1 + name = "pyimage%r" % (Image._last_id,) # tk itself would use image + if kw and cnf: cnf = _cnfmerge((cnf, kw)) + elif kw: cnf = kw + options = () + for k, v in cnf.items(): + options = options + ('-'+k, v) + self.tk.call(('image', 'create', imgtype, name,) + options) + self.name = name + + def __str__(self): return self.name + + def __del__(self): + if self.name: + try: + self.tk.call('image', 'delete', self.name) + except TclError: + # May happen if the root was destroyed + pass + + def __setitem__(self, key, value): + self.tk.call(self.name, 'configure', '-'+key, value) + + def __getitem__(self, key): + return self.tk.call(self.name, 'configure', '-'+key) + + def configure(self, **kw): + """Configure the image.""" + res = () + for k, v in _cnfmerge(kw).items(): + if v is not None: + if k[-1] == '_': k = k[:-1] + res = res + ('-'+k, v) + self.tk.call((self.name, 'config') + res) + + config = configure + + def height(self): + """Return the height of the image.""" + return self.tk.getint( + self.tk.call('image', 'height', self.name)) + + def type(self): + """Return the type of the image, e.g. "photo" or "bitmap".""" + return self.tk.call('image', 'type', self.name) + + def width(self): + """Return the width of the image.""" + return self.tk.getint( + self.tk.call('image', 'width', self.name)) + + +class PhotoImage(Image): + """Widget which can display images in PGM, PPM, GIF, PNG format.""" + + def __init__(self, name=None, cnf={}, master=None, **kw): + """Create an image with NAME. + + Valid resource names: data, format, file, gamma, height, palette, + width.""" + Image.__init__(self, 'photo', name, cnf, master, **kw) + + def blank(self): + """Display a transparent image.""" + self.tk.call(self.name, 'blank') + + def cget(self, option): + """Return the value of OPTION.""" + return self.tk.call(self.name, 'cget', '-' + option) + # XXX config + + def __getitem__(self, key): + return self.tk.call(self.name, 'cget', '-' + key) + # XXX copy -from, -to, ...? + + def copy(self): + """Return a new PhotoImage with the same image as this widget.""" + destImage = PhotoImage(master=self.tk) + self.tk.call(destImage, 'copy', self.name) + return destImage + + def zoom(self, x, y=''): + """Return a new PhotoImage with the same image as this widget + but zoom it with a factor of x in the X direction and y in the Y + direction. If y is not given, the default value is the same as x. + """ + destImage = PhotoImage(master=self.tk) + if y=='': y=x + self.tk.call(destImage, 'copy', self.name, '-zoom',x,y) + return destImage + + def subsample(self, x, y=''): + """Return a new PhotoImage based on the same image as this widget + but use only every Xth or Yth pixel. If y is not given, the + default value is the same as x. + """ + destImage = PhotoImage(master=self.tk) + if y=='': y=x + self.tk.call(destImage, 'copy', self.name, '-subsample',x,y) + return destImage + + def get(self, x, y): + """Return the color (red, green, blue) of the pixel at X,Y.""" + return self.tk.call(self.name, 'get', x, y) + + def put(self, data, to=None): + """Put row formatted colors to image starting from + position TO, e.g. image.put("{red green} {blue yellow}", to=(4,6))""" + args = (self.name, 'put', data) + if to: + if to[0] == '-to': + to = to[1:] + args = args + ('-to',) + tuple(to) + self.tk.call(args) + # XXX read + + def write(self, filename, format=None, from_coords=None): + """Write image to file FILENAME in FORMAT starting from + position FROM_COORDS.""" + args = (self.name, 'write', filename) + if format: + args = args + ('-format', format) + if from_coords: + args = args + ('-from',) + tuple(from_coords) + self.tk.call(args) + + def transparency_get(self, x, y): + """Return True if the pixel at x,y is transparent.""" + return self.tk.getboolean(self.tk.call( + self.name, 'transparency', 'get', x, y)) + + def transparency_set(self, x, y, boolean): + """Set the transparency of the pixel at x,y.""" + self.tk.call(self.name, 'transparency', 'set', x, y, boolean) + + +class BitmapImage(Image): + """Widget which can display images in XBM format.""" + + def __init__(self, name=None, cnf={}, master=None, **kw): + """Create a bitmap with NAME. + + Valid resource names: background, data, file, foreground, maskdata, maskfile.""" + Image.__init__(self, 'bitmap', name, cnf, master, **kw) + + +def image_names(): + tk = _get_default_root('use image_names()').tk + return tk.splitlist(tk.call('image', 'names')) + + +def image_types(): + tk = _get_default_root('use image_types()').tk + return tk.splitlist(tk.call('image', 'types')) + + +class Spinbox(Widget, XView): + """spinbox widget.""" + + def __init__(self, master=None, cnf={}, **kw): + """Construct a spinbox widget with the parent MASTER. + + STANDARD OPTIONS + + activebackground, background, borderwidth, + cursor, exportselection, font, foreground, + highlightbackground, highlightcolor, + highlightthickness, insertbackground, + insertborderwidth, insertofftime, + insertontime, insertwidth, justify, relief, + repeatdelay, repeatinterval, + selectbackground, selectborderwidth + selectforeground, takefocus, textvariable + xscrollcommand. + + WIDGET-SPECIFIC OPTIONS + + buttonbackground, buttoncursor, + buttondownrelief, buttonuprelief, + command, disabledbackground, + disabledforeground, format, from, + invalidcommand, increment, + readonlybackground, state, to, + validate, validatecommand values, + width, wrap, + """ + Widget.__init__(self, master, 'spinbox', cnf, kw) + + def bbox(self, index): + """Return a tuple of X1,Y1,X2,Y2 coordinates for a + rectangle which encloses the character given by index. + + The first two elements of the list give the x and y + coordinates of the upper-left corner of the screen + area covered by the character (in pixels relative + to the widget) and the last two elements give the + width and height of the character, in pixels. The + bounding box may refer to a region outside the + visible area of the window. + """ + return self._getints(self.tk.call(self._w, 'bbox', index)) or None + + def delete(self, first, last=None): + """Delete one or more elements of the spinbox. + + First is the index of the first character to delete, + and last is the index of the character just after + the last one to delete. If last isn't specified it + defaults to first+1, i.e. a single character is + deleted. This command returns an empty string. + """ + return self.tk.call(self._w, 'delete', first, last) + + def get(self): + """Returns the spinbox's string""" + return self.tk.call(self._w, 'get') + + def icursor(self, index): + """Alter the position of the insertion cursor. + + The insertion cursor will be displayed just before + the character given by index. Returns an empty string + """ + return self.tk.call(self._w, 'icursor', index) + + def identify(self, x, y): + """Returns the name of the widget at position x, y + + Return value is one of: none, buttondown, buttonup, entry + """ + return self.tk.call(self._w, 'identify', x, y) + + def index(self, index): + """Returns the numerical index corresponding to index + """ + return self.tk.call(self._w, 'index', index) + + def insert(self, index, s): + """Insert string s at index + + Returns an empty string. + """ + return self.tk.call(self._w, 'insert', index, s) + + def invoke(self, element): + """Causes the specified element to be invoked + + The element could be buttondown or buttonup + triggering the action associated with it. + """ + return self.tk.call(self._w, 'invoke', element) + + def scan(self, *args): + """Internal function.""" + return self._getints( + self.tk.call((self._w, 'scan') + args)) or () + + def scan_mark(self, x): + """Records x and the current view in the spinbox window; + + used in conjunction with later scan dragto commands. + Typically this command is associated with a mouse button + press in the widget. It returns an empty string. + """ + return self.scan("mark", x) + + def scan_dragto(self, x): + """Compute the difference between the given x argument + and the x argument to the last scan mark command + + It then adjusts the view left or right by 10 times the + difference in x-coordinates. This command is typically + associated with mouse motion events in the widget, to + produce the effect of dragging the spinbox at high speed + through the window. The return value is an empty string. + """ + return self.scan("dragto", x) + + def selection(self, *args): + """Internal function.""" + return self._getints( + self.tk.call((self._w, 'selection') + args)) or () + + def selection_adjust(self, index): + """Locate the end of the selection nearest to the character + given by index, + + Then adjust that end of the selection to be at index + (i.e including but not going beyond index). The other + end of the selection is made the anchor point for future + select to commands. If the selection isn't currently in + the spinbox, then a new selection is created to include + the characters between index and the most recent selection + anchor point, inclusive. + """ + return self.selection("adjust", index) + + def selection_clear(self): + """Clear the selection + + If the selection isn't in this widget then the + command has no effect. + """ + return self.selection("clear") + + def selection_element(self, element=None): + """Sets or gets the currently selected element. + + If a spinbutton element is specified, it will be + displayed depressed. + """ + return self.tk.call(self._w, 'selection', 'element', element) + + def selection_from(self, index): + """Set the fixed end of a selection to INDEX.""" + self.selection('from', index) + + def selection_present(self): + """Return True if there are characters selected in the spinbox, False + otherwise.""" + return self.tk.getboolean( + self.tk.call(self._w, 'selection', 'present')) + + def selection_range(self, start, end): + """Set the selection from START to END (not included).""" + self.selection('range', start, end) + + def selection_to(self, index): + """Set the variable end of a selection to INDEX.""" + self.selection('to', index) + +########################################################################### + + +class LabelFrame(Widget): + """labelframe widget.""" + + def __init__(self, master=None, cnf={}, **kw): + """Construct a labelframe widget with the parent MASTER. + + STANDARD OPTIONS + + borderwidth, cursor, font, foreground, + highlightbackground, highlightcolor, + highlightthickness, padx, pady, relief, + takefocus, text + + WIDGET-SPECIFIC OPTIONS + + background, class, colormap, container, + height, labelanchor, labelwidget, + visual, width + """ + Widget.__init__(self, master, 'labelframe', cnf, kw) + +######################################################################## + + +class PanedWindow(Widget): + """panedwindow widget.""" + + def __init__(self, master=None, cnf={}, **kw): + """Construct a panedwindow widget with the parent MASTER. + + STANDARD OPTIONS + + background, borderwidth, cursor, height, + orient, relief, width + + WIDGET-SPECIFIC OPTIONS + + handlepad, handlesize, opaqueresize, + sashcursor, sashpad, sashrelief, + sashwidth, showhandle, + """ + Widget.__init__(self, master, 'panedwindow', cnf, kw) + + def add(self, child, **kw): + """Add a child widget to the panedwindow in a new pane. + + The child argument is the name of the child widget + followed by pairs of arguments that specify how to + manage the windows. The possible options and values + are the ones accepted by the paneconfigure method. + """ + self.tk.call((self._w, 'add', child) + self._options(kw)) + + def remove(self, child): + """Remove the pane containing child from the panedwindow + + All geometry management options for child will be forgotten. + """ + self.tk.call(self._w, 'forget', child) + + forget = remove + + def identify(self, x, y): + """Identify the panedwindow component at point x, y + + If the point is over a sash or a sash handle, the result + is a two element list containing the index of the sash or + handle, and a word indicating whether it is over a sash + or a handle, such as {0 sash} or {2 handle}. If the point + is over any other part of the panedwindow, the result is + an empty list. + """ + return self.tk.call(self._w, 'identify', x, y) + + def proxy(self, *args): + """Internal function.""" + return self._getints( + self.tk.call((self._w, 'proxy') + args)) or () + + def proxy_coord(self): + """Return the x and y pair of the most recent proxy location + """ + return self.proxy("coord") + + def proxy_forget(self): + """Remove the proxy from the display. + """ + return self.proxy("forget") + + def proxy_place(self, x, y): + """Place the proxy at the given x and y coordinates. + """ + return self.proxy("place", x, y) + + def sash(self, *args): + """Internal function.""" + return self._getints( + self.tk.call((self._w, 'sash') + args)) or () + + def sash_coord(self, index): + """Return the current x and y pair for the sash given by index. + + Index must be an integer between 0 and 1 less than the + number of panes in the panedwindow. The coordinates given are + those of the top left corner of the region containing the sash. + pathName sash dragto index x y This command computes the + difference between the given coordinates and the coordinates + given to the last sash coord command for the given sash. It then + moves that sash the computed difference. The return value is the + empty string. + """ + return self.sash("coord", index) + + def sash_mark(self, index): + """Records x and y for the sash given by index; + + Used in conjunction with later dragto commands to move the sash. + """ + return self.sash("mark", index) + + def sash_place(self, index, x, y): + """Place the sash given by index at the given coordinates + """ + return self.sash("place", index, x, y) + + def panecget(self, child, option): + """Query a management option for window. + + Option may be any value allowed by the paneconfigure subcommand + """ + return self.tk.call( + (self._w, 'panecget') + (child, '-'+option)) + + def paneconfigure(self, tagOrId, cnf=None, **kw): + """Query or modify the management options for window. + + If no option is specified, returns a list describing all + of the available options for pathName. If option is + specified with no value, then the command returns a list + describing the one named option (this list will be identical + to the corresponding sublist of the value returned if no + option is specified). If one or more option-value pairs are + specified, then the command modifies the given widget + option(s) to have the given value(s); in this case the + command returns an empty string. The following options + are supported: + + after window + Insert the window after the window specified. window + should be the name of a window already managed by pathName. + before window + Insert the window before the window specified. window + should be the name of a window already managed by pathName. + height size + Specify a height for the window. The height will be the + outer dimension of the window including its border, if + any. If size is an empty string, or if -height is not + specified, then the height requested internally by the + window will be used initially; the height may later be + adjusted by the movement of sashes in the panedwindow. + Size may be any value accepted by Tk_GetPixels. + minsize n + Specifies that the size of the window cannot be made + less than n. This constraint only affects the size of + the widget in the paned dimension -- the x dimension + for horizontal panedwindows, the y dimension for + vertical panedwindows. May be any value accepted by + Tk_GetPixels. + padx n + Specifies a non-negative value indicating how much + extra space to leave on each side of the window in + the X-direction. The value may have any of the forms + accepted by Tk_GetPixels. + pady n + Specifies a non-negative value indicating how much + extra space to leave on each side of the window in + the Y-direction. The value may have any of the forms + accepted by Tk_GetPixels. + sticky style + If a window's pane is larger than the requested + dimensions of the window, this option may be used + to position (or stretch) the window within its pane. + Style is a string that contains zero or more of the + characters n, s, e or w. The string can optionally + contains spaces or commas, but they are ignored. Each + letter refers to a side (north, south, east, or west) + that the window will "stick" to. If both n and s + (or e and w) are specified, the window will be + stretched to fill the entire height (or width) of + its cavity. + width size + Specify a width for the window. The width will be + the outer dimension of the window including its + border, if any. If size is an empty string, or + if -width is not specified, then the width requested + internally by the window will be used initially; the + width may later be adjusted by the movement of sashes + in the panedwindow. Size may be any value accepted by + Tk_GetPixels. + + """ + if cnf is None and not kw: + return self._getconfigure(self._w, 'paneconfigure', tagOrId) + if isinstance(cnf, str) and not kw: + return self._getconfigure1( + self._w, 'paneconfigure', tagOrId, '-'+cnf) + self.tk.call((self._w, 'paneconfigure', tagOrId) + + self._options(cnf, kw)) + + paneconfig = paneconfigure + + def panes(self): + """Returns an ordered list of the child panes.""" + return self.tk.splitlist(self.tk.call(self._w, 'panes')) + +# Test: + + +def _test(): + root = Tk() + text = "This is Tcl/Tk %s" % root.globalgetvar('tk_patchLevel') + text += "\nThis should be a cedilla: \xe7" + label = Label(root, text=text) + label.pack() + test = Button(root, text="Click me!", + command=lambda root=root: root.test.configure( + text="[%s]" % root.test['text'])) + test.pack() + root.test = test + quit = Button(root, text="QUIT", command=root.destroy) + quit.pack() + # The following three commands are needed so the window pops + # up on top on Windows... + root.iconify() + root.update() + root.deiconify() + root.mainloop() + + +__all__ = [name for name, obj in globals().items() + if not name.startswith('_') and not isinstance(obj, types.ModuleType) + and name not in {'wantobjects'}] + +if __name__ == '__main__': + _test() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__main__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..757880d439c02c359378c42becaf243c60484cb3 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__main__.py @@ -0,0 +1,7 @@ +"""Main entry point""" + +import sys +if sys.argv[0].endswith("__main__.py"): + sys.argv[0] = "python -m tkinter" +from . import _test as main +main() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..69888e21efb0f1f33672bc86db2abb43e24491a0 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/__init__.cpython-311.pyc @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:09a7096996fa70a5cf4b891daeb3aafc8a5234fe8e37a8f0cb0b86f84efb7f37 +size 259607 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/__main__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/__main__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a16d00111a5e79ab7104c11826878aa8c0af0c8 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/__main__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/colorchooser.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/colorchooser.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2d353a3e0c38dc3e830bfaf553971a558c57b305 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/colorchooser.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/commondialog.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/commondialog.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..095b40ff4087fc16a957f8ed2066623e5dc37f26 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/commondialog.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/constants.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/constants.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f251f9da5418317ea31f4e022415d33ad397a53c Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/constants.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/dialog.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/dialog.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d101c293403b2b282654aef00c484350c6ef850f Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/dialog.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/dnd.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/dnd.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d8d7a44be493122d9f47bfbc4ce837d47335bf21 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/dnd.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/filedialog.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/filedialog.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ba90f394c885863e33f848f0973bd4d56e682dbb Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/filedialog.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/font.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/font.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..db7547df65555b0ec8e55ac34244ec3b9e8c50dc Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/font.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/messagebox.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/messagebox.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bd68966077bd40fb510f4946e545b9b38d14106a Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/messagebox.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/scrolledtext.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/scrolledtext.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f39f3d3bbc8661f98214348ce1826d54b4aedaa3 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/scrolledtext.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/simpledialog.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/simpledialog.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cf85d6991a74f98767e279610cf09f3ab4ffc822 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/simpledialog.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/tix.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/tix.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03f47aa4aa27fa069258575a41cd58baf8b4185f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/tix.cpython-311.pyc @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:529ff9a09b3fb99cd60c8a73c4a939e99d724a3e73b7723dd4da500ea519c205 +size 120032 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/ttk.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/ttk.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..02d693363aa1ccbdd349ce75489dcbde03d7c5c9 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/ttk.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/colorchooser.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/colorchooser.py new file mode 100644 index 0000000000000000000000000000000000000000..e2fb69dba927633e614d9438a20ecee6de6b7260 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/colorchooser.py @@ -0,0 +1,86 @@ +# tk common color chooser dialogue +# +# this module provides an interface to the native color dialogue +# available in Tk 4.2 and newer. +# +# written by Fredrik Lundh, May 1997 +# +# fixed initialcolor handling in August 1998 +# + + +from tkinter.commondialog import Dialog + +__all__ = ["Chooser", "askcolor"] + + +class Chooser(Dialog): + """Create a dialog for the tk_chooseColor command. + + Args: + master: The master widget for this dialog. If not provided, + defaults to options['parent'] (if defined). + options: Dictionary of options for the tk_chooseColor call. + initialcolor: Specifies the selected color when the + dialog is first displayed. This can be a tk color + string or a 3-tuple of ints in the range (0, 255) + for an RGB triplet. + parent: The parent window of the color dialog. The + color dialog is displayed on top of this. + title: A string for the title of the dialog box. + """ + + command = "tk_chooseColor" + + def _fixoptions(self): + """Ensure initialcolor is a tk color string. + + Convert initialcolor from a RGB triplet to a color string. + """ + try: + color = self.options["initialcolor"] + if isinstance(color, tuple): + # Assume an RGB triplet. + self.options["initialcolor"] = "#%02x%02x%02x" % color + except KeyError: + pass + + def _fixresult(self, widget, result): + """Adjust result returned from call to tk_chooseColor. + + Return both an RGB tuple of ints in the range (0, 255) and the + tk color string in the form #rrggbb. + """ + # Result can be many things: an empty tuple, an empty string, or + # a _tkinter.Tcl_Obj, so this somewhat weird check handles that. + if not result or not str(result): + return None, None # canceled + + # To simplify application code, the color chooser returns + # an RGB tuple together with the Tk color string. + r, g, b = widget.winfo_rgb(result) + return (r//256, g//256, b//256), str(result) + + +# +# convenience stuff + +def askcolor(color=None, **options): + """Display dialog window for selection of a color. + + Convenience wrapper for the Chooser class. Displays the color + chooser dialog with color as the initial value. + """ + + if color: + options = options.copy() + options["initialcolor"] = color + + return Chooser(**options).show() + + +# -------------------------------------------------------------------- +# test stuff + +if __name__ == "__main__": + print("color", askcolor()) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/commondialog.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/commondialog.py new file mode 100644 index 0000000000000000000000000000000000000000..e595c99defb9910fd67f1d8636d6a4aeb0f6a908 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/commondialog.py @@ -0,0 +1,53 @@ +# base class for tk common dialogues +# +# this module provides a base class for accessing the common +# dialogues available in Tk 4.2 and newer. use filedialog, +# colorchooser, and messagebox to access the individual +# dialogs. +# +# written by Fredrik Lundh, May 1997 +# + +__all__ = ["Dialog"] + +from tkinter import Frame, _get_temp_root, _destroy_temp_root + + +class Dialog: + + command = None + + def __init__(self, master=None, **options): + if master is None: + master = options.get('parent') + self.master = master + self.options = options + + def _fixoptions(self): + pass # hook + + def _fixresult(self, widget, result): + return result # hook + + def show(self, **options): + + # update instance options + for k, v in options.items(): + self.options[k] = v + + self._fixoptions() + + master = self.master + if master is None: + master = _get_temp_root() + try: + self._test_callback(master) # The function below is replaced for some tests. + s = master.tk.call(self.command, *master._options(self.options)) + s = self._fixresult(master, s) + finally: + _destroy_temp_root(master) + + return s + + def _test_callback(self, master): + pass diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/constants.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/constants.py new file mode 100644 index 0000000000000000000000000000000000000000..63eee33d24d6c7e2a3bfb504999a74ec34b53d07 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/constants.py @@ -0,0 +1,110 @@ +# Symbolic constants for Tk + +# Booleans +NO=FALSE=OFF=0 +YES=TRUE=ON=1 + +# -anchor and -sticky +N='n' +S='s' +W='w' +E='e' +NW='nw' +SW='sw' +NE='ne' +SE='se' +NS='ns' +EW='ew' +NSEW='nsew' +CENTER='center' + +# -fill +NONE='none' +X='x' +Y='y' +BOTH='both' + +# -side +LEFT='left' +TOP='top' +RIGHT='right' +BOTTOM='bottom' + +# -relief +RAISED='raised' +SUNKEN='sunken' +FLAT='flat' +RIDGE='ridge' +GROOVE='groove' +SOLID = 'solid' + +# -orient +HORIZONTAL='horizontal' +VERTICAL='vertical' + +# -tabs +NUMERIC='numeric' + +# -wrap +CHAR='char' +WORD='word' + +# -align +BASELINE='baseline' + +# -bordermode +INSIDE='inside' +OUTSIDE='outside' + +# Special tags, marks and insert positions +SEL='sel' +SEL_FIRST='sel.first' +SEL_LAST='sel.last' +END='end' +INSERT='insert' +CURRENT='current' +ANCHOR='anchor' +ALL='all' # e.g. Canvas.delete(ALL) + +# Text widget and button states +NORMAL='normal' +DISABLED='disabled' +ACTIVE='active' +# Canvas state +HIDDEN='hidden' + +# Menu item types +CASCADE='cascade' +CHECKBUTTON='checkbutton' +COMMAND='command' +RADIOBUTTON='radiobutton' +SEPARATOR='separator' + +# Selection modes for list boxes +SINGLE='single' +BROWSE='browse' +MULTIPLE='multiple' +EXTENDED='extended' + +# Activestyle for list boxes +# NONE='none' is also valid +DOTBOX='dotbox' +UNDERLINE='underline' + +# Various canvas styles +PIESLICE='pieslice' +CHORD='chord' +ARC='arc' +FIRST='first' +LAST='last' +BUTT='butt' +PROJECTING='projecting' +ROUND='round' +BEVEL='bevel' +MITER='miter' + +# Arguments to xview/yview +MOVETO='moveto' +SCROLL='scroll' +UNITS='units' +PAGES='pages' diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/dialog.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/dialog.py new file mode 100644 index 0000000000000000000000000000000000000000..36ae6c277cb66ac86a48f42d07ce4c08dce10738 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/dialog.py @@ -0,0 +1,49 @@ +# dialog.py -- Tkinter interface to the tk_dialog script. + +from tkinter import _cnfmerge, Widget, TclError, Button, Pack + +__all__ = ["Dialog"] + +DIALOG_ICON = 'questhead' + + +class Dialog(Widget): + def __init__(self, master=None, cnf={}, **kw): + cnf = _cnfmerge((cnf, kw)) + self.widgetName = '__dialog__' + self._setup(master, cnf) + self.num = self.tk.getint( + self.tk.call( + 'tk_dialog', self._w, + cnf['title'], cnf['text'], + cnf['bitmap'], cnf['default'], + *cnf['strings'])) + try: Widget.destroy(self) + except TclError: pass + + def destroy(self): pass + + +def _test(): + d = Dialog(None, {'title': 'File Modified', + 'text': + 'File "Python.h" has been modified' + ' since the last time it was saved.' + ' Do you want to save it before' + ' exiting the application.', + 'bitmap': DIALOG_ICON, + 'default': 0, + 'strings': ('Save File', + 'Discard Changes', + 'Return to Editor')}) + print(d.num) + + +if __name__ == '__main__': + t = Button(None, {'text': 'Test', + 'command': _test, + Pack: {}}) + q = Button(None, {'text': 'Quit', + 'command': t.quit, + Pack: {}}) + t.mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/dnd.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/dnd.py new file mode 100644 index 0000000000000000000000000000000000000000..acec61ba71f1c9f58597de27ee292176a6a23a1e --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/dnd.py @@ -0,0 +1,324 @@ +"""Drag-and-drop support for Tkinter. + +This is very preliminary. I currently only support dnd *within* one +application, between different windows (or within the same window). + +I am trying to make this as generic as possible -- not dependent on +the use of a particular widget or icon type, etc. I also hope that +this will work with Pmw. + +To enable an object to be dragged, you must create an event binding +for it that starts the drag-and-drop process. Typically, you should +bind to a callback function that you write. The function +should call Tkdnd.dnd_start(source, event), where 'source' is the +object to be dragged, and 'event' is the event that invoked the call +(the argument to your callback function). Even though this is a class +instantiation, the returned instance should not be stored -- it will +be kept alive automatically for the duration of the drag-and-drop. + +When a drag-and-drop is already in process for the Tk interpreter, the +call is *ignored*; this normally averts starting multiple simultaneous +dnd processes, e.g. because different button callbacks all +dnd_start(). + +The object is *not* necessarily a widget -- it can be any +application-specific object that is meaningful to potential +drag-and-drop targets. + +Potential drag-and-drop targets are discovered as follows. Whenever +the mouse moves, and at the start and end of a drag-and-drop move, the +Tk widget directly under the mouse is inspected. This is the target +widget (not to be confused with the target object, yet to be +determined). If there is no target widget, there is no dnd target +object. If there is a target widget, and it has an attribute +dnd_accept, this should be a function (or any callable object). The +function is called as dnd_accept(source, event), where 'source' is the +object being dragged (the object passed to dnd_start() above), and +'event' is the most recent event object (generally a event; +it can also be or ). If the dnd_accept() +function returns something other than None, this is the new dnd target +object. If dnd_accept() returns None, or if the target widget has no +dnd_accept attribute, the target widget's parent is considered as the +target widget, and the search for a target object is repeated from +there. If necessary, the search is repeated all the way up to the +root widget. If none of the target widgets can produce a target +object, there is no target object (the target object is None). + +The target object thus produced, if any, is called the new target +object. It is compared with the old target object (or None, if there +was no old target widget). There are several cases ('source' is the +source object, and 'event' is the most recent event object): + +- Both the old and new target objects are None. Nothing happens. + +- The old and new target objects are the same object. Its method +dnd_motion(source, event) is called. + +- The old target object was None, and the new target object is not +None. The new target object's method dnd_enter(source, event) is +called. + +- The new target object is None, and the old target object is not +None. The old target object's method dnd_leave(source, event) is +called. + +- The old and new target objects differ and neither is None. The old +target object's method dnd_leave(source, event), and then the new +target object's method dnd_enter(source, event) is called. + +Once this is done, the new target object replaces the old one, and the +Tk mainloop proceeds. The return value of the methods mentioned above +is ignored; if they raise an exception, the normal exception handling +mechanisms take over. + +The drag-and-drop processes can end in two ways: a final target object +is selected, or no final target object is selected. When a final +target object is selected, it will always have been notified of the +potential drop by a call to its dnd_enter() method, as described +above, and possibly one or more calls to its dnd_motion() method; its +dnd_leave() method has not been called since the last call to +dnd_enter(). The target is notified of the drop by a call to its +method dnd_commit(source, event). + +If no final target object is selected, and there was an old target +object, its dnd_leave(source, event) method is called to complete the +dnd sequence. + +Finally, the source object is notified that the drag-and-drop process +is over, by a call to source.dnd_end(target, event), specifying either +the selected target object, or None if no target object was selected. +The source object can use this to implement the commit action; this is +sometimes simpler than to do it in the target's dnd_commit(). The +target's dnd_commit() method could then simply be aliased to +dnd_leave(). + +At any time during a dnd sequence, the application can cancel the +sequence by calling the cancel() method on the object returned by +dnd_start(). This will call dnd_leave() if a target is currently +active; it will never call dnd_commit(). + +""" + +import tkinter + +__all__ = ["dnd_start", "DndHandler"] + + +# The factory function + +def dnd_start(source, event): + h = DndHandler(source, event) + if h.root is not None: + return h + else: + return None + + +# The class that does the work + +class DndHandler: + + root = None + + def __init__(self, source, event): + if event.num > 5: + return + root = event.widget._root() + try: + root.__dnd + return # Don't start recursive dnd + except AttributeError: + root.__dnd = self + self.root = root + self.source = source + self.target = None + self.initial_button = button = event.num + self.initial_widget = widget = event.widget + self.release_pattern = "" % (button, button) + self.save_cursor = widget['cursor'] or "" + widget.bind(self.release_pattern, self.on_release) + widget.bind("", self.on_motion) + widget['cursor'] = "hand2" + + def __del__(self): + root = self.root + self.root = None + if root is not None: + try: + del root.__dnd + except AttributeError: + pass + + def on_motion(self, event): + x, y = event.x_root, event.y_root + target_widget = self.initial_widget.winfo_containing(x, y) + source = self.source + new_target = None + while target_widget is not None: + try: + attr = target_widget.dnd_accept + except AttributeError: + pass + else: + new_target = attr(source, event) + if new_target is not None: + break + target_widget = target_widget.master + old_target = self.target + if old_target is new_target: + if old_target is not None: + old_target.dnd_motion(source, event) + else: + if old_target is not None: + self.target = None + old_target.dnd_leave(source, event) + if new_target is not None: + new_target.dnd_enter(source, event) + self.target = new_target + + def on_release(self, event): + self.finish(event, 1) + + def cancel(self, event=None): + self.finish(event, 0) + + def finish(self, event, commit=0): + target = self.target + source = self.source + widget = self.initial_widget + root = self.root + try: + del root.__dnd + self.initial_widget.unbind(self.release_pattern) + self.initial_widget.unbind("") + widget['cursor'] = self.save_cursor + self.target = self.source = self.initial_widget = self.root = None + if target is not None: + if commit: + target.dnd_commit(source, event) + else: + target.dnd_leave(source, event) + finally: + source.dnd_end(target, event) + + +# ---------------------------------------------------------------------- +# The rest is here for testing and demonstration purposes only! + +class Icon: + + def __init__(self, name): + self.name = name + self.canvas = self.label = self.id = None + + def attach(self, canvas, x=10, y=10): + if canvas is self.canvas: + self.canvas.coords(self.id, x, y) + return + if self.canvas is not None: + self.detach() + if canvas is None: + return + label = tkinter.Label(canvas, text=self.name, + borderwidth=2, relief="raised") + id = canvas.create_window(x, y, window=label, anchor="nw") + self.canvas = canvas + self.label = label + self.id = id + label.bind("", self.press) + + def detach(self): + canvas = self.canvas + if canvas is None: + return + id = self.id + label = self.label + self.canvas = self.label = self.id = None + canvas.delete(id) + label.destroy() + + def press(self, event): + if dnd_start(self, event): + # where the pointer is relative to the label widget: + self.x_off = event.x + self.y_off = event.y + # where the widget is relative to the canvas: + self.x_orig, self.y_orig = self.canvas.coords(self.id) + + def move(self, event): + x, y = self.where(self.canvas, event) + self.canvas.coords(self.id, x, y) + + def putback(self): + self.canvas.coords(self.id, self.x_orig, self.y_orig) + + def where(self, canvas, event): + # where the corner of the canvas is relative to the screen: + x_org = canvas.winfo_rootx() + y_org = canvas.winfo_rooty() + # where the pointer is relative to the canvas widget: + x = event.x_root - x_org + y = event.y_root - y_org + # compensate for initial pointer offset + return x - self.x_off, y - self.y_off + + def dnd_end(self, target, event): + pass + + +class Tester: + + def __init__(self, root): + self.top = tkinter.Toplevel(root) + self.canvas = tkinter.Canvas(self.top, width=100, height=100) + self.canvas.pack(fill="both", expand=1) + self.canvas.dnd_accept = self.dnd_accept + + def dnd_accept(self, source, event): + return self + + def dnd_enter(self, source, event): + self.canvas.focus_set() # Show highlight border + x, y = source.where(self.canvas, event) + x1, y1, x2, y2 = source.canvas.bbox(source.id) + dx, dy = x2-x1, y2-y1 + self.dndid = self.canvas.create_rectangle(x, y, x+dx, y+dy) + self.dnd_motion(source, event) + + def dnd_motion(self, source, event): + x, y = source.where(self.canvas, event) + x1, y1, x2, y2 = self.canvas.bbox(self.dndid) + self.canvas.move(self.dndid, x-x1, y-y1) + + def dnd_leave(self, source, event): + self.top.focus_set() # Hide highlight border + self.canvas.delete(self.dndid) + self.dndid = None + + def dnd_commit(self, source, event): + self.dnd_leave(source, event) + x, y = source.where(self.canvas, event) + source.attach(self.canvas, x, y) + + +def test(): + root = tkinter.Tk() + root.geometry("+1+1") + tkinter.Button(command=root.quit, text="Quit").pack() + t1 = Tester(root) + t1.top.geometry("+1+60") + t2 = Tester(root) + t2.top.geometry("+120+60") + t3 = Tester(root) + t3.top.geometry("+240+60") + i1 = Icon("ICON1") + i2 = Icon("ICON2") + i3 = Icon("ICON3") + i1.attach(t1.canvas) + i2.attach(t2.canvas) + i3.attach(t3.canvas) + root.mainloop() + + +if __name__ == '__main__': + test() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/filedialog.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/filedialog.py new file mode 100644 index 0000000000000000000000000000000000000000..600d0bd49fe2cf6095511a889db6477ad3bfa321 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/filedialog.py @@ -0,0 +1,493 @@ +"""File selection dialog classes. + +Classes: + +- FileDialog +- LoadFileDialog +- SaveFileDialog + +This module also presents tk common file dialogues, it provides interfaces +to the native file dialogues available in Tk 4.2 and newer, and the +directory dialogue available in Tk 8.3 and newer. +These interfaces were written by Fredrik Lundh, May 1997. +""" +__all__ = ["FileDialog", "LoadFileDialog", "SaveFileDialog", + "Open", "SaveAs", "Directory", + "askopenfilename", "asksaveasfilename", "askopenfilenames", + "askopenfile", "askopenfiles", "asksaveasfile", "askdirectory"] + +import fnmatch +import os +from tkinter import ( + Frame, LEFT, YES, BOTTOM, Entry, TOP, Button, Tk, X, + Toplevel, RIGHT, Y, END, Listbox, BOTH, Scrollbar, +) +from tkinter.dialog import Dialog +from tkinter import commondialog +from tkinter.simpledialog import _setup_dialog + + +dialogstates = {} + + +class FileDialog: + + """Standard file selection dialog -- no checks on selected file. + + Usage: + + d = FileDialog(master) + fname = d.go(dir_or_file, pattern, default, key) + if fname is None: ...canceled... + else: ...open file... + + All arguments to go() are optional. + + The 'key' argument specifies a key in the global dictionary + 'dialogstates', which keeps track of the values for the directory + and pattern arguments, overriding the values passed in (it does + not keep track of the default argument!). If no key is specified, + the dialog keeps no memory of previous state. Note that memory is + kept even when the dialog is canceled. (All this emulates the + behavior of the Macintosh file selection dialogs.) + + """ + + title = "File Selection Dialog" + + def __init__(self, master, title=None): + if title is None: title = self.title + self.master = master + self.directory = None + + self.top = Toplevel(master) + self.top.title(title) + self.top.iconname(title) + _setup_dialog(self.top) + + self.botframe = Frame(self.top) + self.botframe.pack(side=BOTTOM, fill=X) + + self.selection = Entry(self.top) + self.selection.pack(side=BOTTOM, fill=X) + self.selection.bind('', self.ok_event) + + self.filter = Entry(self.top) + self.filter.pack(side=TOP, fill=X) + self.filter.bind('', self.filter_command) + + self.midframe = Frame(self.top) + self.midframe.pack(expand=YES, fill=BOTH) + + self.filesbar = Scrollbar(self.midframe) + self.filesbar.pack(side=RIGHT, fill=Y) + self.files = Listbox(self.midframe, exportselection=0, + yscrollcommand=(self.filesbar, 'set')) + self.files.pack(side=RIGHT, expand=YES, fill=BOTH) + btags = self.files.bindtags() + self.files.bindtags(btags[1:] + btags[:1]) + self.files.bind('', self.files_select_event) + self.files.bind('', self.files_double_event) + self.filesbar.config(command=(self.files, 'yview')) + + self.dirsbar = Scrollbar(self.midframe) + self.dirsbar.pack(side=LEFT, fill=Y) + self.dirs = Listbox(self.midframe, exportselection=0, + yscrollcommand=(self.dirsbar, 'set')) + self.dirs.pack(side=LEFT, expand=YES, fill=BOTH) + self.dirsbar.config(command=(self.dirs, 'yview')) + btags = self.dirs.bindtags() + self.dirs.bindtags(btags[1:] + btags[:1]) + self.dirs.bind('', self.dirs_select_event) + self.dirs.bind('', self.dirs_double_event) + + self.ok_button = Button(self.botframe, + text="OK", + command=self.ok_command) + self.ok_button.pack(side=LEFT) + self.filter_button = Button(self.botframe, + text="Filter", + command=self.filter_command) + self.filter_button.pack(side=LEFT, expand=YES) + self.cancel_button = Button(self.botframe, + text="Cancel", + command=self.cancel_command) + self.cancel_button.pack(side=RIGHT) + + self.top.protocol('WM_DELETE_WINDOW', self.cancel_command) + # XXX Are the following okay for a general audience? + self.top.bind('', self.cancel_command) + self.top.bind('', self.cancel_command) + + def go(self, dir_or_file=os.curdir, pattern="*", default="", key=None): + if key and key in dialogstates: + self.directory, pattern = dialogstates[key] + else: + dir_or_file = os.path.expanduser(dir_or_file) + if os.path.isdir(dir_or_file): + self.directory = dir_or_file + else: + self.directory, default = os.path.split(dir_or_file) + self.set_filter(self.directory, pattern) + self.set_selection(default) + self.filter_command() + self.selection.focus_set() + self.top.wait_visibility() # window needs to be visible for the grab + self.top.grab_set() + self.how = None + self.master.mainloop() # Exited by self.quit(how) + if key: + directory, pattern = self.get_filter() + if self.how: + directory = os.path.dirname(self.how) + dialogstates[key] = directory, pattern + self.top.destroy() + return self.how + + def quit(self, how=None): + self.how = how + self.master.quit() # Exit mainloop() + + def dirs_double_event(self, event): + self.filter_command() + + def dirs_select_event(self, event): + dir, pat = self.get_filter() + subdir = self.dirs.get('active') + dir = os.path.normpath(os.path.join(self.directory, subdir)) + self.set_filter(dir, pat) + + def files_double_event(self, event): + self.ok_command() + + def files_select_event(self, event): + file = self.files.get('active') + self.set_selection(file) + + def ok_event(self, event): + self.ok_command() + + def ok_command(self): + self.quit(self.get_selection()) + + def filter_command(self, event=None): + dir, pat = self.get_filter() + try: + names = os.listdir(dir) + except OSError: + self.master.bell() + return + self.directory = dir + self.set_filter(dir, pat) + names.sort() + subdirs = [os.pardir] + matchingfiles = [] + for name in names: + fullname = os.path.join(dir, name) + if os.path.isdir(fullname): + subdirs.append(name) + elif fnmatch.fnmatch(name, pat): + matchingfiles.append(name) + self.dirs.delete(0, END) + for name in subdirs: + self.dirs.insert(END, name) + self.files.delete(0, END) + for name in matchingfiles: + self.files.insert(END, name) + head, tail = os.path.split(self.get_selection()) + if tail == os.curdir: tail = '' + self.set_selection(tail) + + def get_filter(self): + filter = self.filter.get() + filter = os.path.expanduser(filter) + if filter[-1:] == os.sep or os.path.isdir(filter): + filter = os.path.join(filter, "*") + return os.path.split(filter) + + def get_selection(self): + file = self.selection.get() + file = os.path.expanduser(file) + return file + + def cancel_command(self, event=None): + self.quit() + + def set_filter(self, dir, pat): + if not os.path.isabs(dir): + try: + pwd = os.getcwd() + except OSError: + pwd = None + if pwd: + dir = os.path.join(pwd, dir) + dir = os.path.normpath(dir) + self.filter.delete(0, END) + self.filter.insert(END, os.path.join(dir or os.curdir, pat or "*")) + + def set_selection(self, file): + self.selection.delete(0, END) + self.selection.insert(END, os.path.join(self.directory, file)) + + +class LoadFileDialog(FileDialog): + + """File selection dialog which checks that the file exists.""" + + title = "Load File Selection Dialog" + + def ok_command(self): + file = self.get_selection() + if not os.path.isfile(file): + self.master.bell() + else: + self.quit(file) + + +class SaveFileDialog(FileDialog): + + """File selection dialog which checks that the file may be created.""" + + title = "Save File Selection Dialog" + + def ok_command(self): + file = self.get_selection() + if os.path.exists(file): + if os.path.isdir(file): + self.master.bell() + return + d = Dialog(self.top, + title="Overwrite Existing File Question", + text="Overwrite existing file %r?" % (file,), + bitmap='questhead', + default=1, + strings=("Yes", "Cancel")) + if d.num != 0: + return + else: + head, tail = os.path.split(file) + if not os.path.isdir(head): + self.master.bell() + return + self.quit(file) + + +# For the following classes and modules: +# +# options (all have default values): +# +# - defaultextension: added to filename if not explicitly given +# +# - filetypes: sequence of (label, pattern) tuples. the same pattern +# may occur with several patterns. use "*" as pattern to indicate +# all files. +# +# - initialdir: initial directory. preserved by dialog instance. +# +# - initialfile: initial file (ignored by the open dialog). preserved +# by dialog instance. +# +# - parent: which window to place the dialog on top of +# +# - title: dialog title +# +# - multiple: if true user may select more than one file +# +# options for the directory chooser: +# +# - initialdir, parent, title: see above +# +# - mustexist: if true, user must pick an existing directory +# + + +class _Dialog(commondialog.Dialog): + + def _fixoptions(self): + try: + # make sure "filetypes" is a tuple + self.options["filetypes"] = tuple(self.options["filetypes"]) + except KeyError: + pass + + def _fixresult(self, widget, result): + if result: + # keep directory and filename until next time + # convert Tcl path objects to strings + try: + result = result.string + except AttributeError: + # it already is a string + pass + path, file = os.path.split(result) + self.options["initialdir"] = path + self.options["initialfile"] = file + self.filename = result # compatibility + return result + + +# +# file dialogs + +class Open(_Dialog): + "Ask for a filename to open" + + command = "tk_getOpenFile" + + def _fixresult(self, widget, result): + if isinstance(result, tuple): + # multiple results: + result = tuple([getattr(r, "string", r) for r in result]) + if result: + path, file = os.path.split(result[0]) + self.options["initialdir"] = path + # don't set initialfile or filename, as we have multiple of these + return result + if not widget.tk.wantobjects() and "multiple" in self.options: + # Need to split result explicitly + return self._fixresult(widget, widget.tk.splitlist(result)) + return _Dialog._fixresult(self, widget, result) + + +class SaveAs(_Dialog): + "Ask for a filename to save as" + + command = "tk_getSaveFile" + + +# the directory dialog has its own _fix routines. +class Directory(commondialog.Dialog): + "Ask for a directory" + + command = "tk_chooseDirectory" + + def _fixresult(self, widget, result): + if result: + # convert Tcl path objects to strings + try: + result = result.string + except AttributeError: + # it already is a string + pass + # keep directory until next time + self.options["initialdir"] = result + self.directory = result # compatibility + return result + +# +# convenience stuff + + +def askopenfilename(**options): + "Ask for a filename to open" + + return Open(**options).show() + + +def asksaveasfilename(**options): + "Ask for a filename to save as" + + return SaveAs(**options).show() + + +def askopenfilenames(**options): + """Ask for multiple filenames to open + + Returns a list of filenames or empty list if + cancel button selected + """ + options["multiple"]=1 + return Open(**options).show() + +# FIXME: are the following perhaps a bit too convenient? + + +def askopenfile(mode = "r", **options): + "Ask for a filename to open, and returned the opened file" + + filename = Open(**options).show() + if filename: + return open(filename, mode) + return None + + +def askopenfiles(mode = "r", **options): + """Ask for multiple filenames and return the open file + objects + + returns a list of open file objects or an empty list if + cancel selected + """ + + files = askopenfilenames(**options) + if files: + ofiles=[] + for filename in files: + ofiles.append(open(filename, mode)) + files=ofiles + return files + + +def asksaveasfile(mode = "w", **options): + "Ask for a filename to save as, and returned the opened file" + + filename = SaveAs(**options).show() + if filename: + return open(filename, mode) + return None + + +def askdirectory (**options): + "Ask for a directory, and return the file name" + return Directory(**options).show() + + +# -------------------------------------------------------------------- +# test stuff + +def test(): + """Simple test program.""" + root = Tk() + root.withdraw() + fd = LoadFileDialog(root) + loadfile = fd.go(key="test") + fd = SaveFileDialog(root) + savefile = fd.go(key="test") + print(loadfile, savefile) + + # Since the file name may contain non-ASCII characters, we need + # to find an encoding that likely supports the file name, and + # displays correctly on the terminal. + + # Start off with UTF-8 + enc = "utf-8" + import sys + + # See whether CODESET is defined + try: + import locale + locale.setlocale(locale.LC_ALL,'') + enc = locale.nl_langinfo(locale.CODESET) + except (ImportError, AttributeError): + pass + + # dialog for opening files + + openfilename=askopenfilename(filetypes=[("all files", "*")]) + try: + fp=open(openfilename,"r") + fp.close() + except: + print("Could not open File: ") + print(sys.exc_info()[1]) + + print("open", openfilename.encode(enc)) + + # dialog for saving files + + saveasfilename=asksaveasfilename() + print("saveas", saveasfilename.encode(enc)) + + +if __name__ == '__main__': + test() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/font.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/font.py new file mode 100644 index 0000000000000000000000000000000000000000..3e24e28ef58cde90dafe78016ce38867a008b450 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/font.py @@ -0,0 +1,239 @@ +# Tkinter font wrapper +# +# written by Fredrik Lundh, February 1998 +# + +import itertools +import tkinter + +__version__ = "0.9" +__all__ = ["NORMAL", "ROMAN", "BOLD", "ITALIC", + "nametofont", "Font", "families", "names"] + +# weight/slant +NORMAL = "normal" +ROMAN = "roman" +BOLD = "bold" +ITALIC = "italic" + + +def nametofont(name, root=None): + """Given the name of a tk named font, returns a Font representation. + """ + return Font(name=name, exists=True, root=root) + + +class Font: + """Represents a named font. + + Constructor options are: + + font -- font specifier (name, system font, or (family, size, style)-tuple) + name -- name to use for this font configuration (defaults to a unique name) + exists -- does a named font by this name already exist? + Creates a new named font if False, points to the existing font if True. + Raises _tkinter.TclError if the assertion is false. + + the following are ignored if font is specified: + + family -- font 'family', e.g. Courier, Times, Helvetica + size -- font size in points + weight -- font thickness: NORMAL, BOLD + slant -- font slant: ROMAN, ITALIC + underline -- font underlining: false (0), true (1) + overstrike -- font strikeout: false (0), true (1) + + """ + + counter = itertools.count(1) + + def _set(self, kw): + options = [] + for k, v in kw.items(): + options.append("-"+k) + options.append(str(v)) + return tuple(options) + + def _get(self, args): + options = [] + for k in args: + options.append("-"+k) + return tuple(options) + + def _mkdict(self, args): + options = {} + for i in range(0, len(args), 2): + options[args[i][1:]] = args[i+1] + return options + + def __init__(self, root=None, font=None, name=None, exists=False, + **options): + if root is None: + root = tkinter._get_default_root('use font') + tk = getattr(root, 'tk', root) + if font: + # get actual settings corresponding to the given font + font = tk.splitlist(tk.call("font", "actual", font)) + else: + font = self._set(options) + if not name: + name = "font" + str(next(self.counter)) + self.name = name + + if exists: + self.delete_font = False + # confirm font exists + if self.name not in tk.splitlist(tk.call("font", "names")): + raise tkinter._tkinter.TclError( + "named font %s does not already exist" % (self.name,)) + # if font config info supplied, apply it + if font: + tk.call("font", "configure", self.name, *font) + else: + # create new font (raises TclError if the font exists) + tk.call("font", "create", self.name, *font) + self.delete_font = True + self._tk = tk + self._split = tk.splitlist + self._call = tk.call + + def __str__(self): + return self.name + + def __repr__(self): + return f"<{self.__class__.__module__}.{self.__class__.__qualname__}" \ + f" object {self.name!r}>" + + def __eq__(self, other): + if not isinstance(other, Font): + return NotImplemented + return self.name == other.name and self._tk == other._tk + + def __getitem__(self, key): + return self.cget(key) + + def __setitem__(self, key, value): + self.configure(**{key: value}) + + def __del__(self): + try: + if self.delete_font: + self._call("font", "delete", self.name) + except Exception: + pass + + def copy(self): + "Return a distinct copy of the current font" + return Font(self._tk, **self.actual()) + + def actual(self, option=None, displayof=None): + "Return actual font attributes" + args = () + if displayof: + args = ('-displayof', displayof) + if option: + args = args + ('-' + option, ) + return self._call("font", "actual", self.name, *args) + else: + return self._mkdict( + self._split(self._call("font", "actual", self.name, *args))) + + def cget(self, option): + "Get font attribute" + return self._call("font", "config", self.name, "-"+option) + + def config(self, **options): + "Modify font attributes" + if options: + self._call("font", "config", self.name, + *self._set(options)) + else: + return self._mkdict( + self._split(self._call("font", "config", self.name))) + + configure = config + + def measure(self, text, displayof=None): + "Return text width" + args = (text,) + if displayof: + args = ('-displayof', displayof, text) + return self._tk.getint(self._call("font", "measure", self.name, *args)) + + def metrics(self, *options, **kw): + """Return font metrics. + + For best performance, create a dummy widget + using this font before calling this method.""" + args = () + displayof = kw.pop('displayof', None) + if displayof: + args = ('-displayof', displayof) + if options: + args = args + self._get(options) + return self._tk.getint( + self._call("font", "metrics", self.name, *args)) + else: + res = self._split(self._call("font", "metrics", self.name, *args)) + options = {} + for i in range(0, len(res), 2): + options[res[i][1:]] = self._tk.getint(res[i+1]) + return options + + +def families(root=None, displayof=None): + "Get font families (as a tuple)" + if root is None: + root = tkinter._get_default_root('use font.families()') + args = () + if displayof: + args = ('-displayof', displayof) + return root.tk.splitlist(root.tk.call("font", "families", *args)) + + +def names(root=None): + "Get names of defined fonts (as a tuple)" + if root is None: + root = tkinter._get_default_root('use font.names()') + return root.tk.splitlist(root.tk.call("font", "names")) + + +# -------------------------------------------------------------------- +# test stuff + +if __name__ == "__main__": + + root = tkinter.Tk() + + # create a font + f = Font(family="times", size=30, weight=NORMAL) + + print(f.actual()) + print(f.actual("family")) + print(f.actual("weight")) + + print(f.config()) + print(f.cget("family")) + print(f.cget("weight")) + + print(names()) + + print(f.measure("hello"), f.metrics("linespace")) + + print(f.metrics(displayof=root)) + + f = Font(font=("Courier", 20, "bold")) + print(f.measure("hello"), f.metrics("linespace", displayof=root)) + + w = tkinter.Label(root, text="Hello, world", font=f) + w.pack() + + w = tkinter.Button(root, text="Quit!", command=root.destroy) + w.pack() + + fb = Font(font=w["font"]).copy() + fb.config(weight=BOLD) + + w.config(font=fb) + + tkinter.mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/messagebox.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/messagebox.py new file mode 100644 index 0000000000000000000000000000000000000000..5f0343b660c68c5a884f38ca78291caf14936231 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/messagebox.py @@ -0,0 +1,146 @@ +# tk common message boxes +# +# this module provides an interface to the native message boxes +# available in Tk 4.2 and newer. +# +# written by Fredrik Lundh, May 1997 +# + +# +# options (all have default values): +# +# - default: which button to make default (one of the reply codes) +# +# - icon: which icon to display (see below) +# +# - message: the message to display +# +# - parent: which window to place the dialog on top of +# +# - title: dialog title +# +# - type: dialog type; that is, which buttons to display (see below) +# + +from tkinter.commondialog import Dialog + +__all__ = ["showinfo", "showwarning", "showerror", + "askquestion", "askokcancel", "askyesno", + "askyesnocancel", "askretrycancel"] + +# +# constants + +# icons +ERROR = "error" +INFO = "info" +QUESTION = "question" +WARNING = "warning" + +# types +ABORTRETRYIGNORE = "abortretryignore" +OK = "ok" +OKCANCEL = "okcancel" +RETRYCANCEL = "retrycancel" +YESNO = "yesno" +YESNOCANCEL = "yesnocancel" + +# replies +ABORT = "abort" +RETRY = "retry" +IGNORE = "ignore" +OK = "ok" +CANCEL = "cancel" +YES = "yes" +NO = "no" + + +# +# message dialog class + +class Message(Dialog): + "A message box" + + command = "tk_messageBox" + + +# +# convenience stuff + +# Rename _icon and _type options to allow overriding them in options +def _show(title=None, message=None, _icon=None, _type=None, **options): + if _icon and "icon" not in options: options["icon"] = _icon + if _type and "type" not in options: options["type"] = _type + if title: options["title"] = title + if message: options["message"] = message + res = Message(**options).show() + # In some Tcl installations, yes/no is converted into a boolean. + if isinstance(res, bool): + if res: + return YES + return NO + # In others we get a Tcl_Obj. + return str(res) + + +def showinfo(title=None, message=None, **options): + "Show an info message" + return _show(title, message, INFO, OK, **options) + + +def showwarning(title=None, message=None, **options): + "Show a warning message" + return _show(title, message, WARNING, OK, **options) + + +def showerror(title=None, message=None, **options): + "Show an error message" + return _show(title, message, ERROR, OK, **options) + + +def askquestion(title=None, message=None, **options): + "Ask a question" + return _show(title, message, QUESTION, YESNO, **options) + + +def askokcancel(title=None, message=None, **options): + "Ask if operation should proceed; return true if the answer is ok" + s = _show(title, message, QUESTION, OKCANCEL, **options) + return s == OK + + +def askyesno(title=None, message=None, **options): + "Ask a question; return true if the answer is yes" + s = _show(title, message, QUESTION, YESNO, **options) + return s == YES + + +def askyesnocancel(title=None, message=None, **options): + "Ask a question; return true if the answer is yes, None if cancelled." + s = _show(title, message, QUESTION, YESNOCANCEL, **options) + # s might be a Tcl index object, so convert it to a string + s = str(s) + if s == CANCEL: + return None + return s == YES + + +def askretrycancel(title=None, message=None, **options): + "Ask if operation should be retried; return true if the answer is yes" + s = _show(title, message, WARNING, RETRYCANCEL, **options) + return s == RETRY + + +# -------------------------------------------------------------------- +# test stuff + +if __name__ == "__main__": + + print("info", showinfo("Spam", "Egg Information")) + print("warning", showwarning("Spam", "Egg Warning")) + print("error", showerror("Spam", "Egg Alert")) + print("question", askquestion("Spam", "Question?")) + print("proceed", askokcancel("Spam", "Proceed?")) + print("yes/no", askyesno("Spam", "Got it?")) + print("yes/no/cancel", askyesnocancel("Spam", "Want it?")) + print("try again", askretrycancel("Spam", "Try again?")) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/scrolledtext.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/scrolledtext.py new file mode 100644 index 0000000000000000000000000000000000000000..4f9a8815b6184b2209305c91a1402267f78e81a6 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/scrolledtext.py @@ -0,0 +1,56 @@ +"""A ScrolledText widget feels like a text widget but also has a +vertical scroll bar on its right. (Later, options may be added to +add a horizontal bar as well, to make the bars disappear +automatically when not needed, to move them to the other side of the +window, etc.) + +Configuration options are passed to the Text widget. +A Frame widget is inserted between the master and the text, to hold +the Scrollbar widget. +Most methods calls are inherited from the Text widget; Pack, Grid and +Place methods are redirected to the Frame widget however. +""" + +from tkinter import Frame, Text, Scrollbar, Pack, Grid, Place +from tkinter.constants import RIGHT, LEFT, Y, BOTH + +__all__ = ['ScrolledText'] + + +class ScrolledText(Text): + def __init__(self, master=None, **kw): + self.frame = Frame(master) + self.vbar = Scrollbar(self.frame) + self.vbar.pack(side=RIGHT, fill=Y) + + kw.update({'yscrollcommand': self.vbar.set}) + Text.__init__(self, self.frame, **kw) + self.pack(side=LEFT, fill=BOTH, expand=True) + self.vbar['command'] = self.yview + + # Copy geometry methods of self.frame without overriding Text + # methods -- hack! + text_meths = vars(Text).keys() + methods = vars(Pack).keys() | vars(Grid).keys() | vars(Place).keys() + methods = methods.difference(text_meths) + + for m in methods: + if m[0] != '_' and m != 'config' and m != 'configure': + setattr(self, m, getattr(self.frame, m)) + + def __str__(self): + return str(self.frame) + + +def example(): + from tkinter.constants import END + + stext = ScrolledText(bg='white', height=10) + stext.insert(END, __doc__) + stext.pack(fill=BOTH, side=LEFT, expand=True) + stext.focus_set() + stext.mainloop() + + +if __name__ == "__main__": + example() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/simpledialog.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/simpledialog.py new file mode 100644 index 0000000000000000000000000000000000000000..538bbfc318d704419884abdfe251872cf075ad33 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/simpledialog.py @@ -0,0 +1,441 @@ +# +# An Introduction to Tkinter +# +# Copyright (c) 1997 by Fredrik Lundh +# +# This copyright applies to Dialog, askinteger, askfloat and asktring +# +# fredrik@pythonware.com +# http://www.pythonware.com +# +"""This modules handles dialog boxes. + +It contains the following public symbols: + +SimpleDialog -- A simple but flexible modal dialog box + +Dialog -- a base class for dialogs + +askinteger -- get an integer from the user + +askfloat -- get a float from the user + +askstring -- get a string from the user +""" + +from tkinter import * +from tkinter import _get_temp_root, _destroy_temp_root +from tkinter import messagebox + + +class SimpleDialog: + + def __init__(self, master, + text='', buttons=[], default=None, cancel=None, + title=None, class_=None): + if class_: + self.root = Toplevel(master, class_=class_) + else: + self.root = Toplevel(master) + if title: + self.root.title(title) + self.root.iconname(title) + + _setup_dialog(self.root) + + self.message = Message(self.root, text=text, aspect=400) + self.message.pack(expand=1, fill=BOTH) + self.frame = Frame(self.root) + self.frame.pack() + self.num = default + self.cancel = cancel + self.default = default + self.root.bind('', self.return_event) + for num in range(len(buttons)): + s = buttons[num] + b = Button(self.frame, text=s, + command=(lambda self=self, num=num: self.done(num))) + if num == default: + b.config(relief=RIDGE, borderwidth=8) + b.pack(side=LEFT, fill=BOTH, expand=1) + self.root.protocol('WM_DELETE_WINDOW', self.wm_delete_window) + self.root.transient(master) + _place_window(self.root, master) + + def go(self): + self.root.wait_visibility() + self.root.grab_set() + self.root.mainloop() + self.root.destroy() + return self.num + + def return_event(self, event): + if self.default is None: + self.root.bell() + else: + self.done(self.default) + + def wm_delete_window(self): + if self.cancel is None: + self.root.bell() + else: + self.done(self.cancel) + + def done(self, num): + self.num = num + self.root.quit() + + +class Dialog(Toplevel): + + '''Class to open dialogs. + + This class is intended as a base class for custom dialogs + ''' + + def __init__(self, parent, title = None): + '''Initialize a dialog. + + Arguments: + + parent -- a parent window (the application window) + + title -- the dialog title + ''' + master = parent + if master is None: + master = _get_temp_root() + + Toplevel.__init__(self, master) + + self.withdraw() # remain invisible for now + # If the parent is not viewable, don't + # make the child transient, or else it + # would be opened withdrawn + if parent is not None and parent.winfo_viewable(): + self.transient(parent) + + if title: + self.title(title) + + _setup_dialog(self) + + self.parent = parent + + self.result = None + + body = Frame(self) + self.initial_focus = self.body(body) + body.pack(padx=5, pady=5) + + self.buttonbox() + + if self.initial_focus is None: + self.initial_focus = self + + self.protocol("WM_DELETE_WINDOW", self.cancel) + + _place_window(self, parent) + + self.initial_focus.focus_set() + + # wait for window to appear on screen before calling grab_set + self.wait_visibility() + self.grab_set() + self.wait_window(self) + + def destroy(self): + '''Destroy the window''' + self.initial_focus = None + Toplevel.destroy(self) + _destroy_temp_root(self.master) + + # + # construction hooks + + def body(self, master): + '''create dialog body. + + return widget that should have initial focus. + This method should be overridden, and is called + by the __init__ method. + ''' + pass + + def buttonbox(self): + '''add standard button box. + + override if you do not want the standard buttons + ''' + + box = Frame(self) + + w = Button(box, text="OK", width=10, command=self.ok, default=ACTIVE) + w.pack(side=LEFT, padx=5, pady=5) + w = Button(box, text="Cancel", width=10, command=self.cancel) + w.pack(side=LEFT, padx=5, pady=5) + + self.bind("", self.ok) + self.bind("", self.cancel) + + box.pack() + + # + # standard button semantics + + def ok(self, event=None): + + if not self.validate(): + self.initial_focus.focus_set() # put focus back + return + + self.withdraw() + self.update_idletasks() + + try: + self.apply() + finally: + self.cancel() + + def cancel(self, event=None): + + # put focus back to the parent window + if self.parent is not None: + self.parent.focus_set() + self.destroy() + + # + # command hooks + + def validate(self): + '''validate the data + + This method is called automatically to validate the data before the + dialog is destroyed. By default, it always validates OK. + ''' + + return 1 # override + + def apply(self): + '''process the data + + This method is called automatically to process the data, *after* + the dialog is destroyed. By default, it does nothing. + ''' + + pass # override + + +# Place a toplevel window at the center of parent or screen +# It is a Python implementation of ::tk::PlaceWindow. +def _place_window(w, parent=None): + w.wm_withdraw() # Remain invisible while we figure out the geometry + w.update_idletasks() # Actualize geometry information + + minwidth = w.winfo_reqwidth() + minheight = w.winfo_reqheight() + maxwidth = w.winfo_vrootwidth() + maxheight = w.winfo_vrootheight() + if parent is not None and parent.winfo_ismapped(): + x = parent.winfo_rootx() + (parent.winfo_width() - minwidth) // 2 + y = parent.winfo_rooty() + (parent.winfo_height() - minheight) // 2 + vrootx = w.winfo_vrootx() + vrooty = w.winfo_vrooty() + x = min(x, vrootx + maxwidth - minwidth) + x = max(x, vrootx) + y = min(y, vrooty + maxheight - minheight) + y = max(y, vrooty) + if w._windowingsystem == 'aqua': + # Avoid the native menu bar which sits on top of everything. + y = max(y, 22) + else: + x = (w.winfo_screenwidth() - minwidth) // 2 + y = (w.winfo_screenheight() - minheight) // 2 + + w.wm_maxsize(maxwidth, maxheight) + w.wm_geometry('+%d+%d' % (x, y)) + w.wm_deiconify() # Become visible at the desired location + + +def _setup_dialog(w): + if w._windowingsystem == "aqua": + w.tk.call("::tk::unsupported::MacWindowStyle", "style", + w, "moveableModal", "") + elif w._windowingsystem == "x11": + w.wm_attributes("-type", "dialog") + +# -------------------------------------------------------------------- +# convenience dialogues + +class _QueryDialog(Dialog): + + def __init__(self, title, prompt, + initialvalue=None, + minvalue = None, maxvalue = None, + parent = None): + + self.prompt = prompt + self.minvalue = minvalue + self.maxvalue = maxvalue + + self.initialvalue = initialvalue + + Dialog.__init__(self, parent, title) + + def destroy(self): + self.entry = None + Dialog.destroy(self) + + def body(self, master): + + w = Label(master, text=self.prompt, justify=LEFT) + w.grid(row=0, padx=5, sticky=W) + + self.entry = Entry(master, name="entry") + self.entry.grid(row=1, padx=5, sticky=W+E) + + if self.initialvalue is not None: + self.entry.insert(0, self.initialvalue) + self.entry.select_range(0, END) + + return self.entry + + def validate(self): + try: + result = self.getresult() + except ValueError: + messagebox.showwarning( + "Illegal value", + self.errormessage + "\nPlease try again", + parent = self + ) + return 0 + + if self.minvalue is not None and result < self.minvalue: + messagebox.showwarning( + "Too small", + "The allowed minimum value is %s. " + "Please try again." % self.minvalue, + parent = self + ) + return 0 + + if self.maxvalue is not None and result > self.maxvalue: + messagebox.showwarning( + "Too large", + "The allowed maximum value is %s. " + "Please try again." % self.maxvalue, + parent = self + ) + return 0 + + self.result = result + + return 1 + + +class _QueryInteger(_QueryDialog): + errormessage = "Not an integer." + + def getresult(self): + return self.getint(self.entry.get()) + + +def askinteger(title, prompt, **kw): + '''get an integer from the user + + Arguments: + + title -- the dialog title + prompt -- the label text + **kw -- see SimpleDialog class + + Return value is an integer + ''' + d = _QueryInteger(title, prompt, **kw) + return d.result + + +class _QueryFloat(_QueryDialog): + errormessage = "Not a floating point value." + + def getresult(self): + return self.getdouble(self.entry.get()) + + +def askfloat(title, prompt, **kw): + '''get a float from the user + + Arguments: + + title -- the dialog title + prompt -- the label text + **kw -- see SimpleDialog class + + Return value is a float + ''' + d = _QueryFloat(title, prompt, **kw) + return d.result + + +class _QueryString(_QueryDialog): + def __init__(self, *args, **kw): + if "show" in kw: + self.__show = kw["show"] + del kw["show"] + else: + self.__show = None + _QueryDialog.__init__(self, *args, **kw) + + def body(self, master): + entry = _QueryDialog.body(self, master) + if self.__show is not None: + entry.configure(show=self.__show) + return entry + + def getresult(self): + return self.entry.get() + + +def askstring(title, prompt, **kw): + '''get a string from the user + + Arguments: + + title -- the dialog title + prompt -- the label text + **kw -- see SimpleDialog class + + Return value is a string + ''' + d = _QueryString(title, prompt, **kw) + return d.result + + +if __name__ == '__main__': + + def test(): + root = Tk() + def doit(root=root): + d = SimpleDialog(root, + text="This is a test dialog. " + "Would this have been an actual dialog, " + "the buttons below would have been glowing " + "in soft pink light.\n" + "Do you believe this?", + buttons=["Yes", "No", "Cancel"], + default=0, + cancel=2, + title="Test Dialog") + print(d.go()) + print(askinteger("Spam", "Egg count", initialvalue=12*12)) + print(askfloat("Spam", "Egg weight\n(in tons)", minvalue=1, + maxvalue=100)) + print(askstring("Spam", "Egg label")) + t = Button(root, text='Test', command=doit) + t.pack() + q = Button(root, text='Quit', command=t.quit) + q.pack() + t.mainloop() + + test() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/tix.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/tix.py new file mode 100644 index 0000000000000000000000000000000000000000..ce218265d4a824c717565e4390387c97c0f1519b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/tix.py @@ -0,0 +1,1948 @@ +# Tix.py -- Tix widget wrappers. +# +# For Tix, see http://tix.sourceforge.net +# +# - Sudhir Shenoy (sshenoy@gol.com), Dec. 1995. +# based on an idea of Jean-Marc Lugrin (lugrin@ms.com) +# +# NOTE: In order to minimize changes to Tkinter.py, some of the code here +# (TixWidget.__init__) has been taken from Tkinter (Widget.__init__) +# and will break if there are major changes in Tkinter. +# +# The Tix widgets are represented by a class hierarchy in python with proper +# inheritance of base classes. +# +# As a result after creating a 'w = StdButtonBox', I can write +# w.ok['text'] = 'Who Cares' +# or w.ok['bg'] = w['bg'] +# or even w.ok.invoke() +# etc. +# +# Compare the demo tixwidgets.py to the original Tcl program and you will +# appreciate the advantages. +# +# NOTE: This module is deprecated since Python 3.6. + +import os +import warnings +import tkinter +from tkinter import * +from tkinter import _cnfmerge + +warnings.warn( + 'The Tix Tk extension is unmaintained, and the tkinter.tix wrapper module' + ' is deprecated in favor of tkinter.ttk', + DeprecationWarning, + stacklevel=2, + ) + +# Some more constants (for consistency with Tkinter) +WINDOW = 'window' +TEXT = 'text' +STATUS = 'status' +IMMEDIATE = 'immediate' +IMAGE = 'image' +IMAGETEXT = 'imagetext' +BALLOON = 'balloon' +AUTO = 'auto' +ACROSSTOP = 'acrosstop' + +# A few useful constants for the Grid widget +ASCII = 'ascii' +CELL = 'cell' +COLUMN = 'column' +DECREASING = 'decreasing' +INCREASING = 'increasing' +INTEGER = 'integer' +MAIN = 'main' +MAX = 'max' +REAL = 'real' +ROW = 'row' +S_REGION = 's-region' +X_REGION = 'x-region' +Y_REGION = 'y-region' + +# Some constants used by Tkinter dooneevent() +TCL_DONT_WAIT = 1 << 1 +TCL_WINDOW_EVENTS = 1 << 2 +TCL_FILE_EVENTS = 1 << 3 +TCL_TIMER_EVENTS = 1 << 4 +TCL_IDLE_EVENTS = 1 << 5 +TCL_ALL_EVENTS = 0 + +# BEWARE - this is implemented by copying some code from the Widget class +# in Tkinter (to override Widget initialization) and is therefore +# liable to break. + +# Could probably add this to Tkinter.Misc +class tixCommand: + """The tix commands provide access to miscellaneous elements + of Tix's internal state and the Tix application context. + Most of the information manipulated by these commands pertains + to the application as a whole, or to a screen or + display, rather than to a particular window. + + This is a mixin class, assumed to be mixed to Tkinter.Tk + that supports the self.tk.call method. + """ + + def tix_addbitmapdir(self, directory): + """Tix maintains a list of directories under which + the tix_getimage and tix_getbitmap commands will + search for image files. The standard bitmap directory + is $TIX_LIBRARY/bitmaps. The addbitmapdir command + adds directory into this list. By using this + command, the image files of an applications can + also be located using the tix_getimage or tix_getbitmap + command. + """ + return self.tk.call('tix', 'addbitmapdir', directory) + + def tix_cget(self, option): + """Returns the current value of the configuration + option given by option. Option may be any of the + options described in the CONFIGURATION OPTIONS section. + """ + return self.tk.call('tix', 'cget', option) + + def tix_configure(self, cnf=None, **kw): + """Query or modify the configuration options of the Tix application + context. If no option is specified, returns a dictionary all of the + available options. If option is specified with no value, then the + command returns a list describing the one named option (this list + will be identical to the corresponding sublist of the value + returned if no option is specified). If one or more option-value + pairs are specified, then the command modifies the given option(s) + to have the given value(s); in this case the command returns an + empty string. Option may be any of the configuration options. + """ + # Copied from Tkinter.py + if kw: + cnf = _cnfmerge((cnf, kw)) + elif cnf: + cnf = _cnfmerge(cnf) + if cnf is None: + return self._getconfigure('tix', 'configure') + if isinstance(cnf, str): + return self._getconfigure1('tix', 'configure', '-'+cnf) + return self.tk.call(('tix', 'configure') + self._options(cnf)) + + def tix_filedialog(self, dlgclass=None): + """Returns the file selection dialog that may be shared among + different calls from this application. This command will create a + file selection dialog widget when it is called the first time. This + dialog will be returned by all subsequent calls to tix_filedialog. + An optional dlgclass parameter can be passed to specified what type + of file selection dialog widget is desired. Possible options are + tix FileSelectDialog or tixExFileSelectDialog. + """ + if dlgclass is not None: + return self.tk.call('tix', 'filedialog', dlgclass) + else: + return self.tk.call('tix', 'filedialog') + + def tix_getbitmap(self, name): + """Locates a bitmap file of the name name.xpm or name in one of the + bitmap directories (see the tix_addbitmapdir command above). By + using tix_getbitmap, you can avoid hard coding the pathnames of the + bitmap files in your application. When successful, it returns the + complete pathname of the bitmap file, prefixed with the character + '@'. The returned value can be used to configure the -bitmap + option of the TK and Tix widgets. + """ + return self.tk.call('tix', 'getbitmap', name) + + def tix_getimage(self, name): + """Locates an image file of the name name.xpm, name.xbm or name.ppm + in one of the bitmap directories (see the addbitmapdir command + above). If more than one file with the same name (but different + extensions) exist, then the image type is chosen according to the + depth of the X display: xbm images are chosen on monochrome + displays and color images are chosen on color displays. By using + tix_ getimage, you can avoid hard coding the pathnames of the + image files in your application. When successful, this command + returns the name of the newly created image, which can be used to + configure the -image option of the Tk and Tix widgets. + """ + return self.tk.call('tix', 'getimage', name) + + def tix_option_get(self, name): + """Gets the options maintained by the Tix + scheme mechanism. Available options include: + + active_bg active_fg bg + bold_font dark1_bg dark1_fg + dark2_bg dark2_fg disabled_fg + fg fixed_font font + inactive_bg inactive_fg input1_bg + input2_bg italic_font light1_bg + light1_fg light2_bg light2_fg + menu_font output1_bg output2_bg + select_bg select_fg selector + """ + # could use self.tk.globalgetvar('tixOption', name) + return self.tk.call('tix', 'option', 'get', name) + + def tix_resetoptions(self, newScheme, newFontSet, newScmPrio=None): + """Resets the scheme and fontset of the Tix application to + newScheme and newFontSet, respectively. This affects only those + widgets created after this call. Therefore, it is best to call the + resetoptions command before the creation of any widgets in a Tix + application. + + The optional parameter newScmPrio can be given to reset the + priority level of the Tk options set by the Tix schemes. + + Because of the way Tk handles the X option database, after Tix has + been has imported and inited, it is not possible to reset the color + schemes and font sets using the tix config command. Instead, the + tix_resetoptions command must be used. + """ + if newScmPrio is not None: + return self.tk.call('tix', 'resetoptions', newScheme, newFontSet, newScmPrio) + else: + return self.tk.call('tix', 'resetoptions', newScheme, newFontSet) + +class Tk(tkinter.Tk, tixCommand): + """Toplevel widget of Tix which represents mostly the main window + of an application. It has an associated Tcl interpreter.""" + def __init__(self, screenName=None, baseName=None, className='Tix'): + tkinter.Tk.__init__(self, screenName, baseName, className) + tixlib = os.environ.get('TIX_LIBRARY') + self.tk.eval('global auto_path; lappend auto_path [file dir [info nameof]]') + if tixlib is not None: + self.tk.eval('global auto_path; lappend auto_path {%s}' % tixlib) + self.tk.eval('global tcl_pkgPath; lappend tcl_pkgPath {%s}' % tixlib) + # Load Tix - this should work dynamically or statically + # If it's static, tcl/tix8.1/pkgIndex.tcl should have + # 'load {} Tix' + # If it's dynamic under Unix, tcl/tix8.1/pkgIndex.tcl should have + # 'load libtix8.1.8.3.so Tix' + self.tk.eval('package require Tix') + + def destroy(self): + # For safety, remove the delete_window binding before destroy + self.protocol("WM_DELETE_WINDOW", "") + tkinter.Tk.destroy(self) + +# The Tix 'tixForm' geometry manager +class Form: + """The Tix Form geometry manager + + Widgets can be arranged by specifying attachments to other widgets. + See Tix documentation for complete details""" + + def config(self, cnf={}, **kw): + self.tk.call('tixForm', self._w, *self._options(cnf, kw)) + + form = config + + def __setitem__(self, key, value): + Form.form(self, {key: value}) + + def check(self): + return self.tk.call('tixForm', 'check', self._w) + + def forget(self): + self.tk.call('tixForm', 'forget', self._w) + + def grid(self, xsize=0, ysize=0): + if (not xsize) and (not ysize): + x = self.tk.call('tixForm', 'grid', self._w) + y = self.tk.splitlist(x) + z = () + for x in y: + z = z + (self.tk.getint(x),) + return z + return self.tk.call('tixForm', 'grid', self._w, xsize, ysize) + + def info(self, option=None): + if not option: + return self.tk.call('tixForm', 'info', self._w) + if option[0] != '-': + option = '-' + option + return self.tk.call('tixForm', 'info', self._w, option) + + def slaves(self): + return [self._nametowidget(x) for x in + self.tk.splitlist( + self.tk.call( + 'tixForm', 'slaves', self._w))] + + + +tkinter.Widget.__bases__ = tkinter.Widget.__bases__ + (Form,) + +class TixWidget(tkinter.Widget): + """A TixWidget class is used to package all (or most) Tix widgets. + + Widget initialization is extended in two ways: + 1) It is possible to give a list of options which must be part of + the creation command (so called Tix 'static' options). These cannot be + given as a 'config' command later. + 2) It is possible to give the name of an existing TK widget. These are + child widgets created automatically by a Tix mega-widget. The Tk call + to create these widgets is therefore bypassed in TixWidget.__init__ + + Both options are for use by subclasses only. + """ + def __init__ (self, master=None, widgetName=None, + static_options=None, cnf={}, kw={}): + # Merge keywords and dictionary arguments + if kw: + cnf = _cnfmerge((cnf, kw)) + else: + cnf = _cnfmerge(cnf) + + # Move static options into extra. static_options must be + # a list of keywords (or None). + extra=() + + # 'options' is always a static option + if static_options: + static_options.append('options') + else: + static_options = ['options'] + + for k,v in list(cnf.items()): + if k in static_options: + extra = extra + ('-' + k, v) + del cnf[k] + + self.widgetName = widgetName + self._setup(master, cnf) + + # If widgetName is None, this is a dummy creation call where the + # corresponding Tk widget has already been created by Tix + if widgetName: + self.tk.call(widgetName, self._w, *extra) + + # Non-static options - to be done via a 'config' command + if cnf: + Widget.config(self, cnf) + + # Dictionary to hold subwidget names for easier access. We can't + # use the children list because the public Tix names may not be the + # same as the pathname component + self.subwidget_list = {} + + # We set up an attribute access function so that it is possible to + # do w.ok['text'] = 'Hello' rather than w.subwidget('ok')['text'] = 'Hello' + # when w is a StdButtonBox. + # We can even do w.ok.invoke() because w.ok is subclassed from the + # Button class if you go through the proper constructors + def __getattr__(self, name): + if name in self.subwidget_list: + return self.subwidget_list[name] + raise AttributeError(name) + + def set_silent(self, value): + """Set a variable without calling its action routine""" + self.tk.call('tixSetSilent', self._w, value) + + def subwidget(self, name): + """Return the named subwidget (which must have been created by + the sub-class).""" + n = self._subwidget_name(name) + if not n: + raise TclError("Subwidget " + name + " not child of " + self._name) + # Remove header of name and leading dot + n = n[len(self._w)+1:] + return self._nametowidget(n) + + def subwidgets_all(self): + """Return all subwidgets.""" + names = self._subwidget_names() + if not names: + return [] + retlist = [] + for name in names: + name = name[len(self._w)+1:] + try: + retlist.append(self._nametowidget(name)) + except: + # some of the widgets are unknown e.g. border in LabelFrame + pass + return retlist + + def _subwidget_name(self,name): + """Get a subwidget name (returns a String, not a Widget !)""" + try: + return self.tk.call(self._w, 'subwidget', name) + except TclError: + return None + + def _subwidget_names(self): + """Return the name of all subwidgets.""" + try: + x = self.tk.call(self._w, 'subwidgets', '-all') + return self.tk.splitlist(x) + except TclError: + return None + + def config_all(self, option, value): + """Set configuration options for all subwidgets (and self).""" + if option == '': + return + elif not isinstance(option, str): + option = repr(option) + if not isinstance(value, str): + value = repr(value) + names = self._subwidget_names() + for name in names: + self.tk.call(name, 'configure', '-' + option, value) + # These are missing from Tkinter + def image_create(self, imgtype, cnf={}, master=None, **kw): + if master is None: + master = self + if kw and cnf: cnf = _cnfmerge((cnf, kw)) + elif kw: cnf = kw + options = () + for k, v in cnf.items(): + if callable(v): + v = self._register(v) + options = options + ('-'+k, v) + return master.tk.call(('image', 'create', imgtype,) + options) + def image_delete(self, imgname): + try: + self.tk.call('image', 'delete', imgname) + except TclError: + # May happen if the root was destroyed + pass + +# Subwidgets are child widgets created automatically by mega-widgets. +# In python, we have to create these subwidgets manually to mirror their +# existence in Tk/Tix. +class TixSubWidget(TixWidget): + """Subwidget class. + + This is used to mirror child widgets automatically created + by Tix/Tk as part of a mega-widget in Python (which is not informed + of this)""" + + def __init__(self, master, name, + destroy_physically=1, check_intermediate=1): + if check_intermediate: + path = master._subwidget_name(name) + try: + path = path[len(master._w)+1:] + plist = path.split('.') + except: + plist = [] + + if not check_intermediate: + # immediate descendant + TixWidget.__init__(self, master, None, None, {'name' : name}) + else: + # Ensure that the intermediate widgets exist + parent = master + for i in range(len(plist) - 1): + n = '.'.join(plist[:i+1]) + try: + w = master._nametowidget(n) + parent = w + except KeyError: + # Create the intermediate widget + parent = TixSubWidget(parent, plist[i], + destroy_physically=0, + check_intermediate=0) + # The Tk widget name is in plist, not in name + if plist: + name = plist[-1] + TixWidget.__init__(self, parent, None, None, {'name' : name}) + self.destroy_physically = destroy_physically + + def destroy(self): + # For some widgets e.g., a NoteBook, when we call destructors, + # we must be careful not to destroy the frame widget since this + # also destroys the parent NoteBook thus leading to an exception + # in Tkinter when it finally calls Tcl to destroy the NoteBook + for c in list(self.children.values()): c.destroy() + if self._name in self.master.children: + del self.master.children[self._name] + if self._name in self.master.subwidget_list: + del self.master.subwidget_list[self._name] + if self.destroy_physically: + # This is bypassed only for a few widgets + self.tk.call('destroy', self._w) + + +# Useful class to create a display style - later shared by many items. +# Contributed by Steffen Kremser +class DisplayStyle: + """DisplayStyle - handle configuration options shared by + (multiple) Display Items""" + + def __init__(self, itemtype, cnf={}, *, master=None, **kw): + if master is None: + if 'refwindow' in kw: + master = kw['refwindow'] + elif 'refwindow' in cnf: + master = cnf['refwindow'] + else: + master = tkinter._get_default_root('create display style') + self.tk = master.tk + self.stylename = self.tk.call('tixDisplayStyle', itemtype, + *self._options(cnf,kw) ) + + def __str__(self): + return self.stylename + + def _options(self, cnf, kw): + if kw and cnf: + cnf = _cnfmerge((cnf, kw)) + elif kw: + cnf = kw + opts = () + for k, v in cnf.items(): + opts = opts + ('-'+k, v) + return opts + + def delete(self): + self.tk.call(self.stylename, 'delete') + + def __setitem__(self,key,value): + self.tk.call(self.stylename, 'configure', '-%s'%key, value) + + def config(self, cnf={}, **kw): + return self._getconfigure( + self.stylename, 'configure', *self._options(cnf,kw)) + + def __getitem__(self,key): + return self.tk.call(self.stylename, 'cget', '-%s'%key) + + +###################################################### +### The Tix Widget classes - in alphabetical order ### +###################################################### + +class Balloon(TixWidget): + """Balloon help widget. + + Subwidget Class + --------- ----- + label Label + message Message""" + + # FIXME: It should inherit -superclass tixShell + def __init__(self, master=None, cnf={}, **kw): + # static seem to be -installcolormap -initwait -statusbar -cursor + static = ['options', 'installcolormap', 'initwait', 'statusbar', + 'cursor'] + TixWidget.__init__(self, master, 'tixBalloon', static, cnf, kw) + self.subwidget_list['label'] = _dummyLabel(self, 'label', + destroy_physically=0) + self.subwidget_list['message'] = _dummyLabel(self, 'message', + destroy_physically=0) + + def bind_widget(self, widget, cnf={}, **kw): + """Bind balloon widget to another. + One balloon widget may be bound to several widgets at the same time""" + self.tk.call(self._w, 'bind', widget._w, *self._options(cnf, kw)) + + def unbind_widget(self, widget): + self.tk.call(self._w, 'unbind', widget._w) + +class ButtonBox(TixWidget): + """ButtonBox - A container for pushbuttons. + Subwidgets are the buttons added with the add method. + """ + def __init__(self, master=None, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixButtonBox', + ['orientation', 'options'], cnf, kw) + + def add(self, name, cnf={}, **kw): + """Add a button with given name to box.""" + + btn = self.tk.call(self._w, 'add', name, *self._options(cnf, kw)) + self.subwidget_list[name] = _dummyButton(self, name) + return btn + + def invoke(self, name): + if name in self.subwidget_list: + self.tk.call(self._w, 'invoke', name) + +class ComboBox(TixWidget): + """ComboBox - an Entry field with a dropdown menu. The user can select a + choice by either typing in the entry subwidget or selecting from the + listbox subwidget. + + Subwidget Class + --------- ----- + entry Entry + arrow Button + slistbox ScrolledListBox + tick Button + cross Button : present if created with the fancy option""" + + # FIXME: It should inherit -superclass tixLabelWidget + def __init__ (self, master=None, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixComboBox', + ['editable', 'dropdown', 'fancy', 'options'], + cnf, kw) + self.subwidget_list['label'] = _dummyLabel(self, 'label') + self.subwidget_list['entry'] = _dummyEntry(self, 'entry') + self.subwidget_list['arrow'] = _dummyButton(self, 'arrow') + self.subwidget_list['slistbox'] = _dummyScrolledListBox(self, + 'slistbox') + try: + self.subwidget_list['tick'] = _dummyButton(self, 'tick') + self.subwidget_list['cross'] = _dummyButton(self, 'cross') + except TypeError: + # unavailable when -fancy not specified + pass + + # align + + def add_history(self, str): + self.tk.call(self._w, 'addhistory', str) + + def append_history(self, str): + self.tk.call(self._w, 'appendhistory', str) + + def insert(self, index, str): + self.tk.call(self._w, 'insert', index, str) + + def pick(self, index): + self.tk.call(self._w, 'pick', index) + +class Control(TixWidget): + """Control - An entry field with value change arrows. The user can + adjust the value by pressing the two arrow buttons or by entering + the value directly into the entry. The new value will be checked + against the user-defined upper and lower limits. + + Subwidget Class + --------- ----- + incr Button + decr Button + entry Entry + label Label""" + + # FIXME: It should inherit -superclass tixLabelWidget + def __init__ (self, master=None, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixControl', ['options'], cnf, kw) + self.subwidget_list['incr'] = _dummyButton(self, 'incr') + self.subwidget_list['decr'] = _dummyButton(self, 'decr') + self.subwidget_list['label'] = _dummyLabel(self, 'label') + self.subwidget_list['entry'] = _dummyEntry(self, 'entry') + + def decrement(self): + self.tk.call(self._w, 'decr') + + def increment(self): + self.tk.call(self._w, 'incr') + + def invoke(self): + self.tk.call(self._w, 'invoke') + + def update(self): + self.tk.call(self._w, 'update') + +class DirList(TixWidget): + """DirList - displays a list view of a directory, its previous + directories and its sub-directories. The user can choose one of + the directories displayed in the list or change to another directory. + + Subwidget Class + --------- ----- + hlist HList + hsb Scrollbar + vsb Scrollbar""" + + # FIXME: It should inherit -superclass tixScrolledHList + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixDirList', ['options'], cnf, kw) + self.subwidget_list['hlist'] = _dummyHList(self, 'hlist') + self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') + self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') + + def chdir(self, dir): + self.tk.call(self._w, 'chdir', dir) + +class DirTree(TixWidget): + """DirTree - Directory Listing in a hierarchical view. + Displays a tree view of a directory, its previous directories and its + sub-directories. The user can choose one of the directories displayed + in the list or change to another directory. + + Subwidget Class + --------- ----- + hlist HList + hsb Scrollbar + vsb Scrollbar""" + + # FIXME: It should inherit -superclass tixScrolledHList + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixDirTree', ['options'], cnf, kw) + self.subwidget_list['hlist'] = _dummyHList(self, 'hlist') + self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') + self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') + + def chdir(self, dir): + self.tk.call(self._w, 'chdir', dir) + +class DirSelectBox(TixWidget): + """DirSelectBox - Motif style file select box. + It is generally used for + the user to choose a file. FileSelectBox stores the files mostly + recently selected into a ComboBox widget so that they can be quickly + selected again. + + Subwidget Class + --------- ----- + selection ComboBox + filter ComboBox + dirlist ScrolledListBox + filelist ScrolledListBox""" + + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixDirSelectBox', ['options'], cnf, kw) + self.subwidget_list['dirlist'] = _dummyDirList(self, 'dirlist') + self.subwidget_list['dircbx'] = _dummyFileComboBox(self, 'dircbx') + +class ExFileSelectBox(TixWidget): + """ExFileSelectBox - MS Windows style file select box. + It provides a convenient method for the user to select files. + + Subwidget Class + --------- ----- + cancel Button + ok Button + hidden Checkbutton + types ComboBox + dir ComboBox + file ComboBox + dirlist ScrolledListBox + filelist ScrolledListBox""" + + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixExFileSelectBox', ['options'], cnf, kw) + self.subwidget_list['cancel'] = _dummyButton(self, 'cancel') + self.subwidget_list['ok'] = _dummyButton(self, 'ok') + self.subwidget_list['hidden'] = _dummyCheckbutton(self, 'hidden') + self.subwidget_list['types'] = _dummyComboBox(self, 'types') + self.subwidget_list['dir'] = _dummyComboBox(self, 'dir') + self.subwidget_list['dirlist'] = _dummyDirList(self, 'dirlist') + self.subwidget_list['file'] = _dummyComboBox(self, 'file') + self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist') + + def filter(self): + self.tk.call(self._w, 'filter') + + def invoke(self): + self.tk.call(self._w, 'invoke') + + +# Should inherit from a Dialog class +class DirSelectDialog(TixWidget): + """The DirSelectDialog widget presents the directories in the file + system in a dialog window. The user can use this dialog window to + navigate through the file system to select the desired directory. + + Subwidgets Class + ---------- ----- + dirbox DirSelectDialog""" + + # FIXME: It should inherit -superclass tixDialogShell + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixDirSelectDialog', + ['options'], cnf, kw) + self.subwidget_list['dirbox'] = _dummyDirSelectBox(self, 'dirbox') + # cancel and ok buttons are missing + + def popup(self): + self.tk.call(self._w, 'popup') + + def popdown(self): + self.tk.call(self._w, 'popdown') + + +# Should inherit from a Dialog class +class ExFileSelectDialog(TixWidget): + """ExFileSelectDialog - MS Windows style file select dialog. + It provides a convenient method for the user to select files. + + Subwidgets Class + ---------- ----- + fsbox ExFileSelectBox""" + + # FIXME: It should inherit -superclass tixDialogShell + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixExFileSelectDialog', + ['options'], cnf, kw) + self.subwidget_list['fsbox'] = _dummyExFileSelectBox(self, 'fsbox') + + def popup(self): + self.tk.call(self._w, 'popup') + + def popdown(self): + self.tk.call(self._w, 'popdown') + +class FileSelectBox(TixWidget): + """ExFileSelectBox - Motif style file select box. + It is generally used for + the user to choose a file. FileSelectBox stores the files mostly + recently selected into a ComboBox widget so that they can be quickly + selected again. + + Subwidget Class + --------- ----- + selection ComboBox + filter ComboBox + dirlist ScrolledListBox + filelist ScrolledListBox""" + + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixFileSelectBox', ['options'], cnf, kw) + self.subwidget_list['dirlist'] = _dummyScrolledListBox(self, 'dirlist') + self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist') + self.subwidget_list['filter'] = _dummyComboBox(self, 'filter') + self.subwidget_list['selection'] = _dummyComboBox(self, 'selection') + + def apply_filter(self): # name of subwidget is same as command + self.tk.call(self._w, 'filter') + + def invoke(self): + self.tk.call(self._w, 'invoke') + +# Should inherit from a Dialog class +class FileSelectDialog(TixWidget): + """FileSelectDialog - Motif style file select dialog. + + Subwidgets Class + ---------- ----- + btns StdButtonBox + fsbox FileSelectBox""" + + # FIXME: It should inherit -superclass tixStdDialogShell + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixFileSelectDialog', + ['options'], cnf, kw) + self.subwidget_list['btns'] = _dummyStdButtonBox(self, 'btns') + self.subwidget_list['fsbox'] = _dummyFileSelectBox(self, 'fsbox') + + def popup(self): + self.tk.call(self._w, 'popup') + + def popdown(self): + self.tk.call(self._w, 'popdown') + +class FileEntry(TixWidget): + """FileEntry - Entry field with button that invokes a FileSelectDialog. + The user can type in the filename manually. Alternatively, the user can + press the button widget that sits next to the entry, which will bring + up a file selection dialog. + + Subwidgets Class + ---------- ----- + button Button + entry Entry""" + + # FIXME: It should inherit -superclass tixLabelWidget + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixFileEntry', + ['dialogtype', 'options'], cnf, kw) + self.subwidget_list['button'] = _dummyButton(self, 'button') + self.subwidget_list['entry'] = _dummyEntry(self, 'entry') + + def invoke(self): + self.tk.call(self._w, 'invoke') + + def file_dialog(self): + # FIXME: return python object + pass + +class HList(TixWidget, XView, YView): + """HList - Hierarchy display widget can be used to display any data + that have a hierarchical structure, for example, file system directory + trees. The list entries are indented and connected by branch lines + according to their places in the hierarchy. + + Subwidgets - None""" + + def __init__ (self,master=None,cnf={}, **kw): + TixWidget.__init__(self, master, 'tixHList', + ['columns', 'options'], cnf, kw) + + def add(self, entry, cnf={}, **kw): + return self.tk.call(self._w, 'add', entry, *self._options(cnf, kw)) + + def add_child(self, parent=None, cnf={}, **kw): + if parent is None: + parent = '' + return self.tk.call( + self._w, 'addchild', parent, *self._options(cnf, kw)) + + def anchor_set(self, entry): + self.tk.call(self._w, 'anchor', 'set', entry) + + def anchor_clear(self): + self.tk.call(self._w, 'anchor', 'clear') + + def column_width(self, col=0, width=None, chars=None): + if not chars: + return self.tk.call(self._w, 'column', 'width', col, width) + else: + return self.tk.call(self._w, 'column', 'width', col, + '-char', chars) + + def delete_all(self): + self.tk.call(self._w, 'delete', 'all') + + def delete_entry(self, entry): + self.tk.call(self._w, 'delete', 'entry', entry) + + def delete_offsprings(self, entry): + self.tk.call(self._w, 'delete', 'offsprings', entry) + + def delete_siblings(self, entry): + self.tk.call(self._w, 'delete', 'siblings', entry) + + def dragsite_set(self, index): + self.tk.call(self._w, 'dragsite', 'set', index) + + def dragsite_clear(self): + self.tk.call(self._w, 'dragsite', 'clear') + + def dropsite_set(self, index): + self.tk.call(self._w, 'dropsite', 'set', index) + + def dropsite_clear(self): + self.tk.call(self._w, 'dropsite', 'clear') + + def header_create(self, col, cnf={}, **kw): + self.tk.call(self._w, 'header', 'create', col, *self._options(cnf, kw)) + + def header_configure(self, col, cnf={}, **kw): + if cnf is None: + return self._getconfigure(self._w, 'header', 'configure', col) + self.tk.call(self._w, 'header', 'configure', col, + *self._options(cnf, kw)) + + def header_cget(self, col, opt): + return self.tk.call(self._w, 'header', 'cget', col, opt) + + def header_exists(self, col): + # A workaround to Tix library bug (issue #25464). + # The documented command is "exists", but only erroneous "exist" is + # accepted. + return self.tk.getboolean(self.tk.call(self._w, 'header', 'exist', col)) + header_exist = header_exists + + def header_delete(self, col): + self.tk.call(self._w, 'header', 'delete', col) + + def header_size(self, col): + return self.tk.call(self._w, 'header', 'size', col) + + def hide_entry(self, entry): + self.tk.call(self._w, 'hide', 'entry', entry) + + def indicator_create(self, entry, cnf={}, **kw): + self.tk.call( + self._w, 'indicator', 'create', entry, *self._options(cnf, kw)) + + def indicator_configure(self, entry, cnf={}, **kw): + if cnf is None: + return self._getconfigure( + self._w, 'indicator', 'configure', entry) + self.tk.call( + self._w, 'indicator', 'configure', entry, *self._options(cnf, kw)) + + def indicator_cget(self, entry, opt): + return self.tk.call(self._w, 'indicator', 'cget', entry, opt) + + def indicator_exists(self, entry): + return self.tk.call (self._w, 'indicator', 'exists', entry) + + def indicator_delete(self, entry): + self.tk.call(self._w, 'indicator', 'delete', entry) + + def indicator_size(self, entry): + return self.tk.call(self._w, 'indicator', 'size', entry) + + def info_anchor(self): + return self.tk.call(self._w, 'info', 'anchor') + + def info_bbox(self, entry): + return self._getints( + self.tk.call(self._w, 'info', 'bbox', entry)) or None + + def info_children(self, entry=None): + c = self.tk.call(self._w, 'info', 'children', entry) + return self.tk.splitlist(c) + + def info_data(self, entry): + return self.tk.call(self._w, 'info', 'data', entry) + + def info_dragsite(self): + return self.tk.call(self._w, 'info', 'dragsite') + + def info_dropsite(self): + return self.tk.call(self._w, 'info', 'dropsite') + + def info_exists(self, entry): + return self.tk.call(self._w, 'info', 'exists', entry) + + def info_hidden(self, entry): + return self.tk.call(self._w, 'info', 'hidden', entry) + + def info_next(self, entry): + return self.tk.call(self._w, 'info', 'next', entry) + + def info_parent(self, entry): + return self.tk.call(self._w, 'info', 'parent', entry) + + def info_prev(self, entry): + return self.tk.call(self._w, 'info', 'prev', entry) + + def info_selection(self): + c = self.tk.call(self._w, 'info', 'selection') + return self.tk.splitlist(c) + + def item_cget(self, entry, col, opt): + return self.tk.call(self._w, 'item', 'cget', entry, col, opt) + + def item_configure(self, entry, col, cnf={}, **kw): + if cnf is None: + return self._getconfigure(self._w, 'item', 'configure', entry, col) + self.tk.call(self._w, 'item', 'configure', entry, col, + *self._options(cnf, kw)) + + def item_create(self, entry, col, cnf={}, **kw): + self.tk.call( + self._w, 'item', 'create', entry, col, *self._options(cnf, kw)) + + def item_exists(self, entry, col): + return self.tk.call(self._w, 'item', 'exists', entry, col) + + def item_delete(self, entry, col): + self.tk.call(self._w, 'item', 'delete', entry, col) + + def entrycget(self, entry, opt): + return self.tk.call(self._w, 'entrycget', entry, opt) + + def entryconfigure(self, entry, cnf={}, **kw): + if cnf is None: + return self._getconfigure(self._w, 'entryconfigure', entry) + self.tk.call(self._w, 'entryconfigure', entry, + *self._options(cnf, kw)) + + def nearest(self, y): + return self.tk.call(self._w, 'nearest', y) + + def see(self, entry): + self.tk.call(self._w, 'see', entry) + + def selection_clear(self, cnf={}, **kw): + self.tk.call(self._w, 'selection', 'clear', *self._options(cnf, kw)) + + def selection_includes(self, entry): + return self.tk.call(self._w, 'selection', 'includes', entry) + + def selection_set(self, first, last=None): + self.tk.call(self._w, 'selection', 'set', first, last) + + def show_entry(self, entry): + return self.tk.call(self._w, 'show', 'entry', entry) + +class InputOnly(TixWidget): + """InputOnly - Invisible widget. Unix only. + + Subwidgets - None""" + + def __init__ (self,master=None,cnf={}, **kw): + TixWidget.__init__(self, master, 'tixInputOnly', None, cnf, kw) + +class LabelEntry(TixWidget): + """LabelEntry - Entry field with label. Packages an entry widget + and a label into one mega widget. It can be used to simplify the creation + of ``entry-form'' type of interface. + + Subwidgets Class + ---------- ----- + label Label + entry Entry""" + + def __init__ (self,master=None,cnf={}, **kw): + TixWidget.__init__(self, master, 'tixLabelEntry', + ['labelside','options'], cnf, kw) + self.subwidget_list['label'] = _dummyLabel(self, 'label') + self.subwidget_list['entry'] = _dummyEntry(self, 'entry') + +class LabelFrame(TixWidget): + """LabelFrame - Labelled Frame container. Packages a frame widget + and a label into one mega widget. To create widgets inside a + LabelFrame widget, one creates the new widgets relative to the + frame subwidget and manage them inside the frame subwidget. + + Subwidgets Class + ---------- ----- + label Label + frame Frame""" + + def __init__ (self,master=None,cnf={}, **kw): + TixWidget.__init__(self, master, 'tixLabelFrame', + ['labelside','options'], cnf, kw) + self.subwidget_list['label'] = _dummyLabel(self, 'label') + self.subwidget_list['frame'] = _dummyFrame(self, 'frame') + + +class ListNoteBook(TixWidget): + """A ListNoteBook widget is very similar to the TixNoteBook widget: + it can be used to display many windows in a limited space using a + notebook metaphor. The notebook is divided into a stack of pages + (windows). At one time only one of these pages can be shown. + The user can navigate through these pages by + choosing the name of the desired page in the hlist subwidget.""" + + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixListNoteBook', ['options'], cnf, kw) + # Is this necessary? It's not an exposed subwidget in Tix. + self.subwidget_list['pane'] = _dummyPanedWindow(self, 'pane', + destroy_physically=0) + self.subwidget_list['hlist'] = _dummyHList(self, 'hlist') + self.subwidget_list['shlist'] = _dummyScrolledHList(self, 'shlist') + + def add(self, name, cnf={}, **kw): + self.tk.call(self._w, 'add', name, *self._options(cnf, kw)) + self.subwidget_list[name] = TixSubWidget(self, name) + return self.subwidget_list[name] + + def page(self, name): + return self.subwidget(name) + + def pages(self): + # Can't call subwidgets_all directly because we don't want .nbframe + names = self.tk.splitlist(self.tk.call(self._w, 'pages')) + ret = [] + for x in names: + ret.append(self.subwidget(x)) + return ret + + def raise_page(self, name): # raise is a python keyword + self.tk.call(self._w, 'raise', name) + +class Meter(TixWidget): + """The Meter widget can be used to show the progress of a background + job which may take a long time to execute. + """ + + def __init__(self, master=None, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixMeter', + ['options'], cnf, kw) + +class NoteBook(TixWidget): + """NoteBook - Multi-page container widget (tabbed notebook metaphor). + + Subwidgets Class + ---------- ----- + nbframe NoteBookFrame + page widgets added dynamically with the add method""" + + def __init__ (self,master=None,cnf={}, **kw): + TixWidget.__init__(self,master,'tixNoteBook', ['options'], cnf, kw) + self.subwidget_list['nbframe'] = TixSubWidget(self, 'nbframe', + destroy_physically=0) + + def add(self, name, cnf={}, **kw): + self.tk.call(self._w, 'add', name, *self._options(cnf, kw)) + self.subwidget_list[name] = TixSubWidget(self, name) + return self.subwidget_list[name] + + def delete(self, name): + self.tk.call(self._w, 'delete', name) + self.subwidget_list[name].destroy() + del self.subwidget_list[name] + + def page(self, name): + return self.subwidget(name) + + def pages(self): + # Can't call subwidgets_all directly because we don't want .nbframe + names = self.tk.splitlist(self.tk.call(self._w, 'pages')) + ret = [] + for x in names: + ret.append(self.subwidget(x)) + return ret + + def raise_page(self, name): # raise is a python keyword + self.tk.call(self._w, 'raise', name) + + def raised(self): + return self.tk.call(self._w, 'raised') + +class NoteBookFrame(TixWidget): + # FIXME: This is dangerous to expose to be called on its own. + pass + +class OptionMenu(TixWidget): + """OptionMenu - creates a menu button of options. + + Subwidget Class + --------- ----- + menubutton Menubutton + menu Menu""" + + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixOptionMenu', ['options'], cnf, kw) + self.subwidget_list['menubutton'] = _dummyMenubutton(self, 'menubutton') + self.subwidget_list['menu'] = _dummyMenu(self, 'menu') + + def add_command(self, name, cnf={}, **kw): + self.tk.call(self._w, 'add', 'command', name, *self._options(cnf, kw)) + + def add_separator(self, name, cnf={}, **kw): + self.tk.call(self._w, 'add', 'separator', name, *self._options(cnf, kw)) + + def delete(self, name): + self.tk.call(self._w, 'delete', name) + + def disable(self, name): + self.tk.call(self._w, 'disable', name) + + def enable(self, name): + self.tk.call(self._w, 'enable', name) + +class PanedWindow(TixWidget): + """PanedWindow - Multi-pane container widget + allows the user to interactively manipulate the sizes of several + panes. The panes can be arranged either vertically or horizontally.The + user changes the sizes of the panes by dragging the resize handle + between two panes. + + Subwidgets Class + ---------- ----- + g/p widgets added dynamically with the add method.""" + + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixPanedWindow', ['orientation', 'options'], cnf, kw) + + # add delete forget panecget paneconfigure panes setsize + def add(self, name, cnf={}, **kw): + self.tk.call(self._w, 'add', name, *self._options(cnf, kw)) + self.subwidget_list[name] = TixSubWidget(self, name, + check_intermediate=0) + return self.subwidget_list[name] + + def delete(self, name): + self.tk.call(self._w, 'delete', name) + self.subwidget_list[name].destroy() + del self.subwidget_list[name] + + def forget(self, name): + self.tk.call(self._w, 'forget', name) + + def panecget(self, entry, opt): + return self.tk.call(self._w, 'panecget', entry, opt) + + def paneconfigure(self, entry, cnf={}, **kw): + if cnf is None: + return self._getconfigure(self._w, 'paneconfigure', entry) + self.tk.call(self._w, 'paneconfigure', entry, *self._options(cnf, kw)) + + def panes(self): + names = self.tk.splitlist(self.tk.call(self._w, 'panes')) + return [self.subwidget(x) for x in names] + +class PopupMenu(TixWidget): + """PopupMenu widget can be used as a replacement of the tk_popup command. + The advantage of the Tix PopupMenu widget is it requires less application + code to manipulate. + + + Subwidgets Class + ---------- ----- + menubutton Menubutton + menu Menu""" + + # FIXME: It should inherit -superclass tixShell + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixPopupMenu', ['options'], cnf, kw) + self.subwidget_list['menubutton'] = _dummyMenubutton(self, 'menubutton') + self.subwidget_list['menu'] = _dummyMenu(self, 'menu') + + def bind_widget(self, widget): + self.tk.call(self._w, 'bind', widget._w) + + def unbind_widget(self, widget): + self.tk.call(self._w, 'unbind', widget._w) + + def post_widget(self, widget, x, y): + self.tk.call(self._w, 'post', widget._w, x, y) + +class ResizeHandle(TixWidget): + """Internal widget to draw resize handles on Scrolled widgets.""" + def __init__(self, master, cnf={}, **kw): + # There seems to be a Tix bug rejecting the configure method + # Let's try making the flags -static + flags = ['options', 'command', 'cursorfg', 'cursorbg', + 'handlesize', 'hintcolor', 'hintwidth', + 'x', 'y'] + # In fact, x y height width are configurable + TixWidget.__init__(self, master, 'tixResizeHandle', + flags, cnf, kw) + + def attach_widget(self, widget): + self.tk.call(self._w, 'attachwidget', widget._w) + + def detach_widget(self, widget): + self.tk.call(self._w, 'detachwidget', widget._w) + + def hide(self, widget): + self.tk.call(self._w, 'hide', widget._w) + + def show(self, widget): + self.tk.call(self._w, 'show', widget._w) + +class ScrolledHList(TixWidget): + """ScrolledHList - HList with automatic scrollbars.""" + + # FIXME: It should inherit -superclass tixScrolledWidget + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixScrolledHList', ['options'], + cnf, kw) + self.subwidget_list['hlist'] = _dummyHList(self, 'hlist') + self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') + self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') + +class ScrolledListBox(TixWidget): + """ScrolledListBox - Listbox with automatic scrollbars.""" + + # FIXME: It should inherit -superclass tixScrolledWidget + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixScrolledListBox', ['options'], cnf, kw) + self.subwidget_list['listbox'] = _dummyListbox(self, 'listbox') + self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') + self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') + +class ScrolledText(TixWidget): + """ScrolledText - Text with automatic scrollbars.""" + + # FIXME: It should inherit -superclass tixScrolledWidget + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixScrolledText', ['options'], cnf, kw) + self.subwidget_list['text'] = _dummyText(self, 'text') + self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') + self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') + +class ScrolledTList(TixWidget): + """ScrolledTList - TList with automatic scrollbars.""" + + # FIXME: It should inherit -superclass tixScrolledWidget + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixScrolledTList', ['options'], + cnf, kw) + self.subwidget_list['tlist'] = _dummyTList(self, 'tlist') + self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') + self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') + +class ScrolledWindow(TixWidget): + """ScrolledWindow - Window with automatic scrollbars.""" + + # FIXME: It should inherit -superclass tixScrolledWidget + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixScrolledWindow', ['options'], cnf, kw) + self.subwidget_list['window'] = _dummyFrame(self, 'window') + self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') + self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') + +class Select(TixWidget): + """Select - Container of button subwidgets. It can be used to provide + radio-box or check-box style of selection options for the user. + + Subwidgets are buttons added dynamically using the add method.""" + + # FIXME: It should inherit -superclass tixLabelWidget + def __init__(self, master, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixSelect', + ['allowzero', 'radio', 'orientation', 'labelside', + 'options'], + cnf, kw) + self.subwidget_list['label'] = _dummyLabel(self, 'label') + + def add(self, name, cnf={}, **kw): + self.tk.call(self._w, 'add', name, *self._options(cnf, kw)) + self.subwidget_list[name] = _dummyButton(self, name) + return self.subwidget_list[name] + + def invoke(self, name): + self.tk.call(self._w, 'invoke', name) + +class Shell(TixWidget): + """Toplevel window. + + Subwidgets - None""" + + def __init__ (self,master=None,cnf={}, **kw): + TixWidget.__init__(self, master, 'tixShell', ['options', 'title'], cnf, kw) + +class DialogShell(TixWidget): + """Toplevel window, with popup popdown and center methods. + It tells the window manager that it is a dialog window and should be + treated specially. The exact treatment depends on the treatment of + the window manager. + + Subwidgets - None""" + + # FIXME: It should inherit from Shell + def __init__ (self,master=None,cnf={}, **kw): + TixWidget.__init__(self, master, + 'tixDialogShell', + ['options', 'title', 'mapped', + 'minheight', 'minwidth', + 'parent', 'transient'], cnf, kw) + + def popdown(self): + self.tk.call(self._w, 'popdown') + + def popup(self): + self.tk.call(self._w, 'popup') + + def center(self): + self.tk.call(self._w, 'center') + +class StdButtonBox(TixWidget): + """StdButtonBox - Standard Button Box (OK, Apply, Cancel and Help) """ + + def __init__(self, master=None, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixStdButtonBox', + ['orientation', 'options'], cnf, kw) + self.subwidget_list['ok'] = _dummyButton(self, 'ok') + self.subwidget_list['apply'] = _dummyButton(self, 'apply') + self.subwidget_list['cancel'] = _dummyButton(self, 'cancel') + self.subwidget_list['help'] = _dummyButton(self, 'help') + + def invoke(self, name): + if name in self.subwidget_list: + self.tk.call(self._w, 'invoke', name) + +class TList(TixWidget, XView, YView): + """TList - Hierarchy display widget which can be + used to display data in a tabular format. The list entries of a TList + widget are similar to the entries in the Tk listbox widget. The main + differences are (1) the TList widget can display the list entries in a + two dimensional format and (2) you can use graphical images as well as + multiple colors and fonts for the list entries. + + Subwidgets - None""" + + def __init__ (self,master=None,cnf={}, **kw): + TixWidget.__init__(self, master, 'tixTList', ['options'], cnf, kw) + + def active_set(self, index): + self.tk.call(self._w, 'active', 'set', index) + + def active_clear(self): + self.tk.call(self._w, 'active', 'clear') + + def anchor_set(self, index): + self.tk.call(self._w, 'anchor', 'set', index) + + def anchor_clear(self): + self.tk.call(self._w, 'anchor', 'clear') + + def delete(self, from_, to=None): + self.tk.call(self._w, 'delete', from_, to) + + def dragsite_set(self, index): + self.tk.call(self._w, 'dragsite', 'set', index) + + def dragsite_clear(self): + self.tk.call(self._w, 'dragsite', 'clear') + + def dropsite_set(self, index): + self.tk.call(self._w, 'dropsite', 'set', index) + + def dropsite_clear(self): + self.tk.call(self._w, 'dropsite', 'clear') + + def insert(self, index, cnf={}, **kw): + self.tk.call(self._w, 'insert', index, *self._options(cnf, kw)) + + def info_active(self): + return self.tk.call(self._w, 'info', 'active') + + def info_anchor(self): + return self.tk.call(self._w, 'info', 'anchor') + + def info_down(self, index): + return self.tk.call(self._w, 'info', 'down', index) + + def info_left(self, index): + return self.tk.call(self._w, 'info', 'left', index) + + def info_right(self, index): + return self.tk.call(self._w, 'info', 'right', index) + + def info_selection(self): + c = self.tk.call(self._w, 'info', 'selection') + return self.tk.splitlist(c) + + def info_size(self): + return self.tk.call(self._w, 'info', 'size') + + def info_up(self, index): + return self.tk.call(self._w, 'info', 'up', index) + + def nearest(self, x, y): + return self.tk.call(self._w, 'nearest', x, y) + + def see(self, index): + self.tk.call(self._w, 'see', index) + + def selection_clear(self, cnf={}, **kw): + self.tk.call(self._w, 'selection', 'clear', *self._options(cnf, kw)) + + def selection_includes(self, index): + return self.tk.call(self._w, 'selection', 'includes', index) + + def selection_set(self, first, last=None): + self.tk.call(self._w, 'selection', 'set', first, last) + +class Tree(TixWidget): + """Tree - The tixTree widget can be used to display hierarchical + data in a tree form. The user can adjust + the view of the tree by opening or closing parts of the tree.""" + + # FIXME: It should inherit -superclass tixScrolledWidget + def __init__(self, master=None, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixTree', + ['options'], cnf, kw) + self.subwidget_list['hlist'] = _dummyHList(self, 'hlist') + self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') + self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') + + def autosetmode(self): + '''This command calls the setmode method for all the entries in this + Tree widget: if an entry has no child entries, its mode is set to + none. Otherwise, if the entry has any hidden child entries, its mode is + set to open; otherwise its mode is set to close.''' + self.tk.call(self._w, 'autosetmode') + + def close(self, entrypath): + '''Close the entry given by entryPath if its mode is close.''' + self.tk.call(self._w, 'close', entrypath) + + def getmode(self, entrypath): + '''Returns the current mode of the entry given by entryPath.''' + return self.tk.call(self._w, 'getmode', entrypath) + + def open(self, entrypath): + '''Open the entry given by entryPath if its mode is open.''' + self.tk.call(self._w, 'open', entrypath) + + def setmode(self, entrypath, mode='none'): + '''This command is used to indicate whether the entry given by + entryPath has children entries and whether the children are visible. mode + must be one of open, close or none. If mode is set to open, a (+) + indicator is drawn next the entry. If mode is set to close, a (-) + indicator is drawn next the entry. If mode is set to none, no + indicators will be drawn for this entry. The default mode is none. The + open mode indicates the entry has hidden children and this entry can be + opened by the user. The close mode indicates that all the children of the + entry are now visible and the entry can be closed by the user.''' + self.tk.call(self._w, 'setmode', entrypath, mode) + + +# Could try subclassing Tree for CheckList - would need another arg to init +class CheckList(TixWidget): + """The CheckList widget + displays a list of items to be selected by the user. CheckList acts + similarly to the Tk checkbutton or radiobutton widgets, except it is + capable of handling many more items than checkbuttons or radiobuttons. + """ + # FIXME: It should inherit -superclass tixTree + def __init__(self, master=None, cnf={}, **kw): + TixWidget.__init__(self, master, 'tixCheckList', + ['options', 'radio'], cnf, kw) + self.subwidget_list['hlist'] = _dummyHList(self, 'hlist') + self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') + self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') + + def autosetmode(self): + '''This command calls the setmode method for all the entries in this + Tree widget: if an entry has no child entries, its mode is set to + none. Otherwise, if the entry has any hidden child entries, its mode is + set to open; otherwise its mode is set to close.''' + self.tk.call(self._w, 'autosetmode') + + def close(self, entrypath): + '''Close the entry given by entryPath if its mode is close.''' + self.tk.call(self._w, 'close', entrypath) + + def getmode(self, entrypath): + '''Returns the current mode of the entry given by entryPath.''' + return self.tk.call(self._w, 'getmode', entrypath) + + def open(self, entrypath): + '''Open the entry given by entryPath if its mode is open.''' + self.tk.call(self._w, 'open', entrypath) + + def getselection(self, mode='on'): + '''Returns a list of items whose status matches status. If status is + not specified, the list of items in the "on" status will be returned. + Mode can be on, off, default''' + return self.tk.splitlist(self.tk.call(self._w, 'getselection', mode)) + + def getstatus(self, entrypath): + '''Returns the current status of entryPath.''' + return self.tk.call(self._w, 'getstatus', entrypath) + + def setstatus(self, entrypath, mode='on'): + '''Sets the status of entryPath to be status. A bitmap will be + displayed next to the entry its status is on, off or default.''' + self.tk.call(self._w, 'setstatus', entrypath, mode) + + +########################################################################### +### The subclassing below is used to instantiate the subwidgets in each ### +### mega widget. This allows us to access their methods directly. ### +########################################################################### + +class _dummyButton(Button, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + +class _dummyCheckbutton(Checkbutton, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + +class _dummyEntry(Entry, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + +class _dummyFrame(Frame, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + +class _dummyLabel(Label, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + +class _dummyListbox(Listbox, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + +class _dummyMenu(Menu, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + +class _dummyMenubutton(Menubutton, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + +class _dummyScrollbar(Scrollbar, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + +class _dummyText(Text, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + +class _dummyScrolledListBox(ScrolledListBox, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + self.subwidget_list['listbox'] = _dummyListbox(self, 'listbox') + self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') + self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') + +class _dummyHList(HList, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + +class _dummyScrolledHList(ScrolledHList, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + self.subwidget_list['hlist'] = _dummyHList(self, 'hlist') + self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') + self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') + +class _dummyTList(TList, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + +class _dummyComboBox(ComboBox, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, ['fancy',destroy_physically]) + self.subwidget_list['label'] = _dummyLabel(self, 'label') + self.subwidget_list['entry'] = _dummyEntry(self, 'entry') + self.subwidget_list['arrow'] = _dummyButton(self, 'arrow') + + self.subwidget_list['slistbox'] = _dummyScrolledListBox(self, + 'slistbox') + try: + self.subwidget_list['tick'] = _dummyButton(self, 'tick') + #cross Button : present if created with the fancy option + self.subwidget_list['cross'] = _dummyButton(self, 'cross') + except TypeError: + # unavailable when -fancy not specified + pass + +class _dummyDirList(DirList, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + self.subwidget_list['hlist'] = _dummyHList(self, 'hlist') + self.subwidget_list['vsb'] = _dummyScrollbar(self, 'vsb') + self.subwidget_list['hsb'] = _dummyScrollbar(self, 'hsb') + +class _dummyDirSelectBox(DirSelectBox, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + self.subwidget_list['dirlist'] = _dummyDirList(self, 'dirlist') + self.subwidget_list['dircbx'] = _dummyFileComboBox(self, 'dircbx') + +class _dummyExFileSelectBox(ExFileSelectBox, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + self.subwidget_list['cancel'] = _dummyButton(self, 'cancel') + self.subwidget_list['ok'] = _dummyButton(self, 'ok') + self.subwidget_list['hidden'] = _dummyCheckbutton(self, 'hidden') + self.subwidget_list['types'] = _dummyComboBox(self, 'types') + self.subwidget_list['dir'] = _dummyComboBox(self, 'dir') + self.subwidget_list['dirlist'] = _dummyScrolledListBox(self, 'dirlist') + self.subwidget_list['file'] = _dummyComboBox(self, 'file') + self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist') + +class _dummyFileSelectBox(FileSelectBox, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + self.subwidget_list['dirlist'] = _dummyScrolledListBox(self, 'dirlist') + self.subwidget_list['filelist'] = _dummyScrolledListBox(self, 'filelist') + self.subwidget_list['filter'] = _dummyComboBox(self, 'filter') + self.subwidget_list['selection'] = _dummyComboBox(self, 'selection') + +class _dummyFileComboBox(ComboBox, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + self.subwidget_list['dircbx'] = _dummyComboBox(self, 'dircbx') + +class _dummyStdButtonBox(StdButtonBox, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + self.subwidget_list['ok'] = _dummyButton(self, 'ok') + self.subwidget_list['apply'] = _dummyButton(self, 'apply') + self.subwidget_list['cancel'] = _dummyButton(self, 'cancel') + self.subwidget_list['help'] = _dummyButton(self, 'help') + +class _dummyNoteBookFrame(NoteBookFrame, TixSubWidget): + def __init__(self, master, name, destroy_physically=0): + TixSubWidget.__init__(self, master, name, destroy_physically) + +class _dummyPanedWindow(PanedWindow, TixSubWidget): + def __init__(self, master, name, destroy_physically=1): + TixSubWidget.__init__(self, master, name, destroy_physically) + +######################## +### Utility Routines ### +######################## + +#mike Should tixDestroy be exposed as a wrapper? - but not for widgets. + +def OptionName(widget): + '''Returns the qualified path name for the widget. Normally used to set + default options for subwidgets. See tixwidgets.py''' + return widget.tk.call('tixOptionName', widget._w) + +# Called with a dictionary argument of the form +# {'*.c':'C source files', '*.txt':'Text Files', '*':'All files'} +# returns a string which can be used to configure the fsbox file types +# in an ExFileSelectBox. i.e., +# '{{*} {* - All files}} {{*.c} {*.c - C source files}} {{*.txt} {*.txt - Text Files}}' +def FileTypeList(dict): + s = '' + for type in dict.keys(): + s = s + '{{' + type + '} {' + type + ' - ' + dict[type] + '}} ' + return s + +# Still to be done: +# tixIconView +class CObjView(TixWidget): + """This file implements the Canvas Object View widget. This is a base + class of IconView. It implements automatic placement/adjustment of the + scrollbars according to the canvas objects inside the canvas subwidget. + The scrollbars are adjusted so that the canvas is just large enough + to see all the objects. + """ + # FIXME: It should inherit -superclass tixScrolledWidget + pass + + +class Grid(TixWidget, XView, YView): + '''The Tix Grid command creates a new window and makes it into a + tixGrid widget. Additional options, may be specified on the command + line or in the option database to configure aspects such as its cursor + and relief. + + A Grid widget displays its contents in a two dimensional grid of cells. + Each cell may contain one Tix display item, which may be in text, + graphics or other formats. See the DisplayStyle class for more information + about Tix display items. Individual cells, or groups of cells, can be + formatted with a wide range of attributes, such as its color, relief and + border. + + Subwidgets - None''' + # valid specific resources as of Tk 8.4 + # editdonecmd, editnotifycmd, floatingcols, floatingrows, formatcmd, + # highlightbackground, highlightcolor, leftmargin, itemtype, selectmode, + # selectunit, topmargin, + def __init__(self, master=None, cnf={}, **kw): + static= [] + self.cnf= cnf + TixWidget.__init__(self, master, 'tixGrid', static, cnf, kw) + + # valid options as of Tk 8.4 + # anchor, bdtype, cget, configure, delete, dragsite, dropsite, entrycget, + # edit, entryconfigure, format, geometryinfo, info, index, move, nearest, + # selection, set, size, unset, xview, yview + def anchor_clear(self): + """Removes the selection anchor.""" + self.tk.call(self, 'anchor', 'clear') + + def anchor_get(self): + "Get the (x,y) coordinate of the current anchor cell" + return self._getints(self.tk.call(self, 'anchor', 'get')) + + def anchor_set(self, x, y): + """Set the selection anchor to the cell at (x, y).""" + self.tk.call(self, 'anchor', 'set', x, y) + + def delete_row(self, from_, to=None): + """Delete rows between from_ and to inclusive. + If to is not provided, delete only row at from_""" + if to is None: + self.tk.call(self, 'delete', 'row', from_) + else: + self.tk.call(self, 'delete', 'row', from_, to) + + def delete_column(self, from_, to=None): + """Delete columns between from_ and to inclusive. + If to is not provided, delete only column at from_""" + if to is None: + self.tk.call(self, 'delete', 'column', from_) + else: + self.tk.call(self, 'delete', 'column', from_, to) + + def edit_apply(self): + """If any cell is being edited, de-highlight the cell and applies + the changes.""" + self.tk.call(self, 'edit', 'apply') + + def edit_set(self, x, y): + """Highlights the cell at (x, y) for editing, if the -editnotify + command returns True for this cell.""" + self.tk.call(self, 'edit', 'set', x, y) + + def entrycget(self, x, y, option): + "Get the option value for cell at (x,y)" + if option and option[0] != '-': + option = '-' + option + return self.tk.call(self, 'entrycget', x, y, option) + + def entryconfigure(self, x, y, cnf=None, **kw): + return self._configure(('entryconfigure', x, y), cnf, kw) + + # def format + # def index + + def info_exists(self, x, y): + "Return True if display item exists at (x,y)" + return self._getboolean(self.tk.call(self, 'info', 'exists', x, y)) + + def info_bbox(self, x, y): + # This seems to always return '', at least for 'text' displayitems + return self.tk.call(self, 'info', 'bbox', x, y) + + def move_column(self, from_, to, offset): + """Moves the range of columns from position FROM through TO by + the distance indicated by OFFSET. For example, move_column(2, 4, 1) + moves the columns 2,3,4 to columns 3,4,5.""" + self.tk.call(self, 'move', 'column', from_, to, offset) + + def move_row(self, from_, to, offset): + """Moves the range of rows from position FROM through TO by + the distance indicated by OFFSET. + For example, move_row(2, 4, 1) moves the rows 2,3,4 to rows 3,4,5.""" + self.tk.call(self, 'move', 'row', from_, to, offset) + + def nearest(self, x, y): + "Return coordinate of cell nearest pixel coordinate (x,y)" + return self._getints(self.tk.call(self, 'nearest', x, y)) + + # def selection adjust + # def selection clear + # def selection includes + # def selection set + # def selection toggle + + def set(self, x, y, itemtype=None, **kw): + args= self._options(self.cnf, kw) + if itemtype is not None: + args= ('-itemtype', itemtype) + args + self.tk.call(self, 'set', x, y, *args) + + def size_column(self, index, **kw): + """Queries or sets the size of the column given by + INDEX. INDEX may be any non-negative + integer that gives the position of a given column. + INDEX can also be the string "default"; in this case, this command + queries or sets the default size of all columns. + When no option-value pair is given, this command returns a tuple + containing the current size setting of the given column. When + option-value pairs are given, the corresponding options of the + size setting of the given column are changed. Options may be one + of the following: + pad0 pixels + Specifies the paddings to the left of a column. + pad1 pixels + Specifies the paddings to the right of a column. + size val + Specifies the width of a column. Val may be: + "auto" -- the width of the column is set to the + width of the widest cell in the column; + a valid Tk screen distance unit; + or a real number following by the word chars + (e.g. 3.4chars) that sets the width of the column to the + given number of characters.""" + return self.tk.splitlist(self.tk.call(self._w, 'size', 'column', index, + *self._options({}, kw))) + + def size_row(self, index, **kw): + """Queries or sets the size of the row given by + INDEX. INDEX may be any non-negative + integer that gives the position of a given row . + INDEX can also be the string "default"; in this case, this command + queries or sets the default size of all rows. + When no option-value pair is given, this command returns a list con- + taining the current size setting of the given row . When option-value + pairs are given, the corresponding options of the size setting of the + given row are changed. Options may be one of the following: + pad0 pixels + Specifies the paddings to the top of a row. + pad1 pixels + Specifies the paddings to the bottom of a row. + size val + Specifies the height of a row. Val may be: + "auto" -- the height of the row is set to the + height of the highest cell in the row; + a valid Tk screen distance unit; + or a real number following by the word chars + (e.g. 3.4chars) that sets the height of the row to the + given number of characters.""" + return self.tk.splitlist(self.tk.call( + self, 'size', 'row', index, *self._options({}, kw))) + + def unset(self, x, y): + """Clears the cell at (x, y) by removing its display item.""" + self.tk.call(self._w, 'unset', x, y) + + +class ScrolledGrid(Grid): + '''Scrolled Grid widgets''' + + # FIXME: It should inherit -superclass tixScrolledWidget + def __init__(self, master=None, cnf={}, **kw): + static= [] + self.cnf= cnf + TixWidget.__init__(self, master, 'tixScrolledGrid', static, cnf, kw) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/ttk.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/ttk.py new file mode 100644 index 0000000000000000000000000000000000000000..efeabb7a92c62708a63cc4b9a72a8e8070e468ba --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/ttk.py @@ -0,0 +1,1637 @@ +"""Ttk wrapper. + +This module provides classes to allow using Tk themed widget set. + +Ttk is based on a revised and enhanced version of +TIP #48 (http://tip.tcl.tk/48) specified style engine. + +Its basic idea is to separate, to the extent possible, the code +implementing a widget's behavior from the code implementing its +appearance. Widget class bindings are primarily responsible for +maintaining the widget state and invoking callbacks, all aspects +of the widgets appearance lies at Themes. +""" + +__version__ = "0.3.1" + +__author__ = "Guilherme Polo " + +__all__ = ["Button", "Checkbutton", "Combobox", "Entry", "Frame", "Label", + "Labelframe", "LabelFrame", "Menubutton", "Notebook", "Panedwindow", + "PanedWindow", "Progressbar", "Radiobutton", "Scale", "Scrollbar", + "Separator", "Sizegrip", "Spinbox", "Style", "Treeview", + # Extensions + "LabeledScale", "OptionMenu", + # functions + "tclobjs_to_py", "setup_master"] + +import tkinter +from tkinter import _flatten, _join, _stringify, _splitdict + + +def _format_optvalue(value, script=False): + """Internal function.""" + if script: + # if caller passes a Tcl script to tk.call, all the values need to + # be grouped into words (arguments to a command in Tcl dialect) + value = _stringify(value) + elif isinstance(value, (list, tuple)): + value = _join(value) + return value + +def _format_optdict(optdict, script=False, ignore=None): + """Formats optdict to a tuple to pass it to tk.call. + + E.g. (script=False): + {'foreground': 'blue', 'padding': [1, 2, 3, 4]} returns: + ('-foreground', 'blue', '-padding', '1 2 3 4')""" + + opts = [] + for opt, value in optdict.items(): + if not ignore or opt not in ignore: + opts.append("-%s" % opt) + if value is not None: + opts.append(_format_optvalue(value, script)) + + return _flatten(opts) + +def _mapdict_values(items): + # each value in mapdict is expected to be a sequence, where each item + # is another sequence containing a state (or several) and a value + # E.g. (script=False): + # [('active', 'selected', 'grey'), ('focus', [1, 2, 3, 4])] + # returns: + # ['active selected', 'grey', 'focus', [1, 2, 3, 4]] + opt_val = [] + for *state, val in items: + if len(state) == 1: + # if it is empty (something that evaluates to False), then + # format it to Tcl code to denote the "normal" state + state = state[0] or '' + else: + # group multiple states + state = ' '.join(state) # raise TypeError if not str + opt_val.append(state) + if val is not None: + opt_val.append(val) + return opt_val + +def _format_mapdict(mapdict, script=False): + """Formats mapdict to pass it to tk.call. + + E.g. (script=False): + {'expand': [('active', 'selected', 'grey'), ('focus', [1, 2, 3, 4])]} + + returns: + + ('-expand', '{active selected} grey focus {1, 2, 3, 4}')""" + + opts = [] + for opt, value in mapdict.items(): + opts.extend(("-%s" % opt, + _format_optvalue(_mapdict_values(value), script))) + + return _flatten(opts) + +def _format_elemcreate(etype, script=False, *args, **kw): + """Formats args and kw according to the given element factory etype.""" + spec = None + opts = () + if etype in ("image", "vsapi"): + if etype == "image": # define an element based on an image + # first arg should be the default image name + iname = args[0] + # next args, if any, are statespec/value pairs which is almost + # a mapdict, but we just need the value + imagespec = _join(_mapdict_values(args[1:])) + spec = "%s %s" % (iname, imagespec) + + else: + # define an element whose visual appearance is drawn using the + # Microsoft Visual Styles API which is responsible for the + # themed styles on Windows XP and Vista. + # Availability: Tk 8.6, Windows XP and Vista. + class_name, part_id = args[:2] + statemap = _join(_mapdict_values(args[2:])) + spec = "%s %s %s" % (class_name, part_id, statemap) + + opts = _format_optdict(kw, script) + + elif etype == "from": # clone an element + # it expects a themename and optionally an element to clone from, + # otherwise it will clone {} (empty element) + spec = args[0] # theme name + if len(args) > 1: # elementfrom specified + opts = (_format_optvalue(args[1], script),) + + if script: + spec = '{%s}' % spec + opts = ' '.join(opts) + + return spec, opts + +def _format_layoutlist(layout, indent=0, indent_size=2): + """Formats a layout list so we can pass the result to ttk::style + layout and ttk::style settings. Note that the layout doesn't have to + be a list necessarily. + + E.g.: + [("Menubutton.background", None), + ("Menubutton.button", {"children": + [("Menubutton.focus", {"children": + [("Menubutton.padding", {"children": + [("Menubutton.label", {"side": "left", "expand": 1})] + })] + })] + }), + ("Menubutton.indicator", {"side": "right"}) + ] + + returns: + + Menubutton.background + Menubutton.button -children { + Menubutton.focus -children { + Menubutton.padding -children { + Menubutton.label -side left -expand 1 + } + } + } + Menubutton.indicator -side right""" + script = [] + + for layout_elem in layout: + elem, opts = layout_elem + opts = opts or {} + fopts = ' '.join(_format_optdict(opts, True, ("children",))) + head = "%s%s%s" % (' ' * indent, elem, (" %s" % fopts) if fopts else '') + + if "children" in opts: + script.append(head + " -children {") + indent += indent_size + newscript, indent = _format_layoutlist(opts['children'], indent, + indent_size) + script.append(newscript) + indent -= indent_size + script.append('%s}' % (' ' * indent)) + else: + script.append(head) + + return '\n'.join(script), indent + +def _script_from_settings(settings): + """Returns an appropriate script, based on settings, according to + theme_settings definition to be used by theme_settings and + theme_create.""" + script = [] + # a script will be generated according to settings passed, which + # will then be evaluated by Tcl + for name, opts in settings.items(): + # will format specific keys according to Tcl code + if opts.get('configure'): # format 'configure' + s = ' '.join(_format_optdict(opts['configure'], True)) + script.append("ttk::style configure %s %s;" % (name, s)) + + if opts.get('map'): # format 'map' + s = ' '.join(_format_mapdict(opts['map'], True)) + script.append("ttk::style map %s %s;" % (name, s)) + + if 'layout' in opts: # format 'layout' which may be empty + if not opts['layout']: + s = 'null' # could be any other word, but this one makes sense + else: + s, _ = _format_layoutlist(opts['layout']) + script.append("ttk::style layout %s {\n%s\n}" % (name, s)) + + if opts.get('element create'): # format 'element create' + eopts = opts['element create'] + etype = eopts[0] + + # find where args end, and where kwargs start + argc = 1 # etype was the first one + while argc < len(eopts) and not hasattr(eopts[argc], 'items'): + argc += 1 + + elemargs = eopts[1:argc] + elemkw = eopts[argc] if argc < len(eopts) and eopts[argc] else {} + spec, opts = _format_elemcreate(etype, True, *elemargs, **elemkw) + + script.append("ttk::style element create %s %s %s %s" % ( + name, etype, spec, opts)) + + return '\n'.join(script) + +def _list_from_statespec(stuple): + """Construct a list from the given statespec tuple according to the + accepted statespec accepted by _format_mapdict.""" + if isinstance(stuple, str): + return stuple + result = [] + it = iter(stuple) + for state, val in zip(it, it): + if hasattr(state, 'typename'): # this is a Tcl object + state = str(state).split() + elif isinstance(state, str): + state = state.split() + elif not isinstance(state, (tuple, list)): + state = (state,) + if hasattr(val, 'typename'): + val = str(val) + result.append((*state, val)) + + return result + +def _list_from_layouttuple(tk, ltuple): + """Construct a list from the tuple returned by ttk::layout, this is + somewhat the reverse of _format_layoutlist.""" + ltuple = tk.splitlist(ltuple) + res = [] + + indx = 0 + while indx < len(ltuple): + name = ltuple[indx] + opts = {} + res.append((name, opts)) + indx += 1 + + while indx < len(ltuple): # grab name's options + opt, val = ltuple[indx:indx + 2] + if not opt.startswith('-'): # found next name + break + + opt = opt[1:] # remove the '-' from the option + indx += 2 + + if opt == 'children': + val = _list_from_layouttuple(tk, val) + + opts[opt] = val + + return res + +def _val_or_dict(tk, options, *args): + """Format options then call Tk command with args and options and return + the appropriate result. + + If no option is specified, a dict is returned. If an option is + specified with the None value, the value for that option is returned. + Otherwise, the function just sets the passed options and the caller + shouldn't be expecting a return value anyway.""" + options = _format_optdict(options) + res = tk.call(*(args + options)) + + if len(options) % 2: # option specified without a value, return its value + return res + + return _splitdict(tk, res, conv=_tclobj_to_py) + +def _convert_stringval(value): + """Converts a value to, hopefully, a more appropriate Python object.""" + value = str(value) + try: + value = int(value) + except (ValueError, TypeError): + pass + + return value + +def _to_number(x): + if isinstance(x, str): + if '.' in x: + x = float(x) + else: + x = int(x) + return x + +def _tclobj_to_py(val): + """Return value converted from Tcl object to Python object.""" + if val and hasattr(val, '__len__') and not isinstance(val, str): + if getattr(val[0], 'typename', None) == 'StateSpec': + val = _list_from_statespec(val) + else: + val = list(map(_convert_stringval, val)) + + elif hasattr(val, 'typename'): # some other (single) Tcl object + val = _convert_stringval(val) + + return val + +def tclobjs_to_py(adict): + """Returns adict with its values converted from Tcl objects to Python + objects.""" + for opt, val in adict.items(): + adict[opt] = _tclobj_to_py(val) + + return adict + +def setup_master(master=None): + """If master is not None, itself is returned. If master is None, + the default master is returned if there is one, otherwise a new + master is created and returned. + + If it is not allowed to use the default root and master is None, + RuntimeError is raised.""" + if master is None: + master = tkinter._get_default_root() + return master + + +class Style(object): + """Manipulate style database.""" + + _name = "ttk::style" + + def __init__(self, master=None): + master = setup_master(master) + self.master = master + self.tk = self.master.tk + + + def configure(self, style, query_opt=None, **kw): + """Query or sets the default value of the specified option(s) in + style. + + Each key in kw is an option and each value is either a string or + a sequence identifying the value for that option.""" + if query_opt is not None: + kw[query_opt] = None + result = _val_or_dict(self.tk, kw, self._name, "configure", style) + if result or query_opt: + return result + + + def map(self, style, query_opt=None, **kw): + """Query or sets dynamic values of the specified option(s) in + style. + + Each key in kw is an option and each value should be a list or a + tuple (usually) containing statespecs grouped in tuples, or list, + or something else of your preference. A statespec is compound of + one or more states and then a value.""" + if query_opt is not None: + result = self.tk.call(self._name, "map", style, '-%s' % query_opt) + return _list_from_statespec(self.tk.splitlist(result)) + + result = self.tk.call(self._name, "map", style, *_format_mapdict(kw)) + return {k: _list_from_statespec(self.tk.splitlist(v)) + for k, v in _splitdict(self.tk, result).items()} + + + def lookup(self, style, option, state=None, default=None): + """Returns the value specified for option in style. + + If state is specified it is expected to be a sequence of one + or more states. If the default argument is set, it is used as + a fallback value in case no specification for option is found.""" + state = ' '.join(state) if state else '' + + return self.tk.call(self._name, "lookup", style, '-%s' % option, + state, default) + + + def layout(self, style, layoutspec=None): + """Define the widget layout for given style. If layoutspec is + omitted, return the layout specification for given style. + + layoutspec is expected to be a list or an object different than + None that evaluates to False if you want to "turn off" that style. + If it is a list (or tuple, or something else), each item should be + a tuple where the first item is the layout name and the second item + should have the format described below: + + LAYOUTS + + A layout can contain the value None, if takes no options, or + a dict of options specifying how to arrange the element. + The layout mechanism uses a simplified version of the pack + geometry manager: given an initial cavity, each element is + allocated a parcel. Valid options/values are: + + side: whichside + Specifies which side of the cavity to place the + element; one of top, right, bottom or left. If + omitted, the element occupies the entire cavity. + + sticky: nswe + Specifies where the element is placed inside its + allocated parcel. + + children: [sublayout... ] + Specifies a list of elements to place inside the + element. Each element is a tuple (or other sequence) + where the first item is the layout name, and the other + is a LAYOUT.""" + lspec = None + if layoutspec: + lspec = _format_layoutlist(layoutspec)[0] + elif layoutspec is not None: # will disable the layout ({}, '', etc) + lspec = "null" # could be any other word, but this may make sense + # when calling layout(style) later + + return _list_from_layouttuple(self.tk, + self.tk.call(self._name, "layout", style, lspec)) + + + def element_create(self, elementname, etype, *args, **kw): + """Create a new element in the current theme of given etype.""" + spec, opts = _format_elemcreate(etype, False, *args, **kw) + self.tk.call(self._name, "element", "create", elementname, etype, + spec, *opts) + + + def element_names(self): + """Returns the list of elements defined in the current theme.""" + return tuple(n.lstrip('-') for n in self.tk.splitlist( + self.tk.call(self._name, "element", "names"))) + + + def element_options(self, elementname): + """Return the list of elementname's options.""" + return tuple(o.lstrip('-') for o in self.tk.splitlist( + self.tk.call(self._name, "element", "options", elementname))) + + + def theme_create(self, themename, parent=None, settings=None): + """Creates a new theme. + + It is an error if themename already exists. If parent is + specified, the new theme will inherit styles, elements and + layouts from the specified parent theme. If settings are present, + they are expected to have the same syntax used for theme_settings.""" + script = _script_from_settings(settings) if settings else '' + + if parent: + self.tk.call(self._name, "theme", "create", themename, + "-parent", parent, "-settings", script) + else: + self.tk.call(self._name, "theme", "create", themename, + "-settings", script) + + + def theme_settings(self, themename, settings): + """Temporarily sets the current theme to themename, apply specified + settings and then restore the previous theme. + + Each key in settings is a style and each value may contain the + keys 'configure', 'map', 'layout' and 'element create' and they + are expected to have the same format as specified by the methods + configure, map, layout and element_create respectively.""" + script = _script_from_settings(settings) + self.tk.call(self._name, "theme", "settings", themename, script) + + + def theme_names(self): + """Returns a list of all known themes.""" + return self.tk.splitlist(self.tk.call(self._name, "theme", "names")) + + + def theme_use(self, themename=None): + """If themename is None, returns the theme in use, otherwise, set + the current theme to themename, refreshes all widgets and emits + a <> event.""" + if themename is None: + # Starting on Tk 8.6, checking this global is no longer needed + # since it allows doing self.tk.call(self._name, "theme", "use") + return self.tk.eval("return $ttk::currentTheme") + + # using "ttk::setTheme" instead of "ttk::style theme use" causes + # the variable currentTheme to be updated, also, ttk::setTheme calls + # "ttk::style theme use" in order to change theme. + self.tk.call("ttk::setTheme", themename) + + +class Widget(tkinter.Widget): + """Base class for Tk themed widgets.""" + + def __init__(self, master, widgetname, kw=None): + """Constructs a Ttk Widget with the parent master. + + STANDARD OPTIONS + + class, cursor, takefocus, style + + SCROLLABLE WIDGET OPTIONS + + xscrollcommand, yscrollcommand + + LABEL WIDGET OPTIONS + + text, textvariable, underline, image, compound, width + + WIDGET STATES + + active, disabled, focus, pressed, selected, background, + readonly, alternate, invalid + """ + master = setup_master(master) + tkinter.Widget.__init__(self, master, widgetname, kw=kw) + + + def identify(self, x, y): + """Returns the name of the element at position x, y, or the empty + string if the point does not lie within any element. + + x and y are pixel coordinates relative to the widget.""" + return self.tk.call(self._w, "identify", x, y) + + + def instate(self, statespec, callback=None, *args, **kw): + """Test the widget's state. + + If callback is not specified, returns True if the widget state + matches statespec and False otherwise. If callback is specified, + then it will be invoked with *args, **kw if the widget state + matches statespec. statespec is expected to be a sequence.""" + ret = self.tk.getboolean( + self.tk.call(self._w, "instate", ' '.join(statespec))) + if ret and callback is not None: + return callback(*args, **kw) + + return ret + + + def state(self, statespec=None): + """Modify or inquire widget state. + + Widget state is returned if statespec is None, otherwise it is + set according to the statespec flags and then a new state spec + is returned indicating which flags were changed. statespec is + expected to be a sequence.""" + if statespec is not None: + statespec = ' '.join(statespec) + + return self.tk.splitlist(str(self.tk.call(self._w, "state", statespec))) + + +class Button(Widget): + """Ttk Button widget, displays a textual label and/or image, and + evaluates a command when pressed.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Button widget with the parent master. + + STANDARD OPTIONS + + class, compound, cursor, image, state, style, takefocus, + text, textvariable, underline, width + + WIDGET-SPECIFIC OPTIONS + + command, default, width + """ + Widget.__init__(self, master, "ttk::button", kw) + + + def invoke(self): + """Invokes the command associated with the button.""" + return self.tk.call(self._w, "invoke") + + +class Checkbutton(Widget): + """Ttk Checkbutton widget which is either in on- or off-state.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Checkbutton widget with the parent master. + + STANDARD OPTIONS + + class, compound, cursor, image, state, style, takefocus, + text, textvariable, underline, width + + WIDGET-SPECIFIC OPTIONS + + command, offvalue, onvalue, variable + """ + Widget.__init__(self, master, "ttk::checkbutton", kw) + + + def invoke(self): + """Toggles between the selected and deselected states and + invokes the associated command. If the widget is currently + selected, sets the option variable to the offvalue option + and deselects the widget; otherwise, sets the option variable + to the option onvalue. + + Returns the result of the associated command.""" + return self.tk.call(self._w, "invoke") + + +class Entry(Widget, tkinter.Entry): + """Ttk Entry widget displays a one-line text string and allows that + string to be edited by the user.""" + + def __init__(self, master=None, widget=None, **kw): + """Constructs a Ttk Entry widget with the parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus, xscrollcommand + + WIDGET-SPECIFIC OPTIONS + + exportselection, invalidcommand, justify, show, state, + textvariable, validate, validatecommand, width + + VALIDATION MODES + + none, key, focus, focusin, focusout, all + """ + Widget.__init__(self, master, widget or "ttk::entry", kw) + + + def bbox(self, index): + """Return a tuple of (x, y, width, height) which describes the + bounding box of the character given by index.""" + return self._getints(self.tk.call(self._w, "bbox", index)) + + + def identify(self, x, y): + """Returns the name of the element at position x, y, or the + empty string if the coordinates are outside the window.""" + return self.tk.call(self._w, "identify", x, y) + + + def validate(self): + """Force revalidation, independent of the conditions specified + by the validate option. Returns False if validation fails, True + if it succeeds. Sets or clears the invalid state accordingly.""" + return self.tk.getboolean(self.tk.call(self._w, "validate")) + + +class Combobox(Entry): + """Ttk Combobox widget combines a text field with a pop-down list of + values.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Combobox widget with the parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + + exportselection, justify, height, postcommand, state, + textvariable, values, width + """ + Entry.__init__(self, master, "ttk::combobox", **kw) + + + def current(self, newindex=None): + """If newindex is supplied, sets the combobox value to the + element at position newindex in the list of values. Otherwise, + returns the index of the current value in the list of values + or -1 if the current value does not appear in the list.""" + if newindex is None: + return self.tk.getint(self.tk.call(self._w, "current")) + return self.tk.call(self._w, "current", newindex) + + + def set(self, value): + """Sets the value of the combobox to value.""" + self.tk.call(self._w, "set", value) + + +class Frame(Widget): + """Ttk Frame widget is a container, used to group other widgets + together.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Frame with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + + borderwidth, relief, padding, width, height + """ + Widget.__init__(self, master, "ttk::frame", kw) + + +class Label(Widget): + """Ttk Label widget displays a textual label and/or image.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Label with parent master. + + STANDARD OPTIONS + + class, compound, cursor, image, style, takefocus, text, + textvariable, underline, width + + WIDGET-SPECIFIC OPTIONS + + anchor, background, font, foreground, justify, padding, + relief, text, wraplength + """ + Widget.__init__(self, master, "ttk::label", kw) + + +class Labelframe(Widget): + """Ttk Labelframe widget is a container used to group other widgets + together. It has an optional label, which may be a plain text string + or another widget.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Labelframe with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + labelanchor, text, underline, padding, labelwidget, width, + height + """ + Widget.__init__(self, master, "ttk::labelframe", kw) + +LabelFrame = Labelframe # tkinter name compatibility + + +class Menubutton(Widget): + """Ttk Menubutton widget displays a textual label and/or image, and + displays a menu when pressed.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Menubutton with parent master. + + STANDARD OPTIONS + + class, compound, cursor, image, state, style, takefocus, + text, textvariable, underline, width + + WIDGET-SPECIFIC OPTIONS + + direction, menu + """ + Widget.__init__(self, master, "ttk::menubutton", kw) + + +class Notebook(Widget): + """Ttk Notebook widget manages a collection of windows and displays + a single one at a time. Each child window is associated with a tab, + which the user may select to change the currently-displayed window.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Notebook with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + + height, padding, width + + TAB OPTIONS + + state, sticky, padding, text, image, compound, underline + + TAB IDENTIFIERS (tab_id) + + The tab_id argument found in several methods may take any of + the following forms: + + * An integer between zero and the number of tabs + * The name of a child window + * A positional specification of the form "@x,y", which + defines the tab + * The string "current", which identifies the + currently-selected tab + * The string "end", which returns the number of tabs (only + valid for method index) + """ + Widget.__init__(self, master, "ttk::notebook", kw) + + + def add(self, child, **kw): + """Adds a new tab to the notebook. + + If window is currently managed by the notebook but hidden, it is + restored to its previous position.""" + self.tk.call(self._w, "add", child, *(_format_optdict(kw))) + + + def forget(self, tab_id): + """Removes the tab specified by tab_id, unmaps and unmanages the + associated window.""" + self.tk.call(self._w, "forget", tab_id) + + + def hide(self, tab_id): + """Hides the tab specified by tab_id. + + The tab will not be displayed, but the associated window remains + managed by the notebook and its configuration remembered. Hidden + tabs may be restored with the add command.""" + self.tk.call(self._w, "hide", tab_id) + + + def identify(self, x, y): + """Returns the name of the tab element at position x, y, or the + empty string if none.""" + return self.tk.call(self._w, "identify", x, y) + + + def index(self, tab_id): + """Returns the numeric index of the tab specified by tab_id, or + the total number of tabs if tab_id is the string "end".""" + return self.tk.getint(self.tk.call(self._w, "index", tab_id)) + + + def insert(self, pos, child, **kw): + """Inserts a pane at the specified position. + + pos is either the string end, an integer index, or the name of + a managed child. If child is already managed by the notebook, + moves it to the specified position.""" + self.tk.call(self._w, "insert", pos, child, *(_format_optdict(kw))) + + + def select(self, tab_id=None): + """Selects the specified tab. + + The associated child window will be displayed, and the + previously-selected window (if different) is unmapped. If tab_id + is omitted, returns the widget name of the currently selected + pane.""" + return self.tk.call(self._w, "select", tab_id) + + + def tab(self, tab_id, option=None, **kw): + """Query or modify the options of the specific tab_id. + + If kw is not given, returns a dict of the tab option values. If option + is specified, returns the value of that option. Otherwise, sets the + options to the corresponding values.""" + if option is not None: + kw[option] = None + return _val_or_dict(self.tk, kw, self._w, "tab", tab_id) + + + def tabs(self): + """Returns a list of windows managed by the notebook.""" + return self.tk.splitlist(self.tk.call(self._w, "tabs") or ()) + + + def enable_traversal(self): + """Enable keyboard traversal for a toplevel window containing + this notebook. + + This will extend the bindings for the toplevel window containing + this notebook as follows: + + Control-Tab: selects the tab following the currently selected + one + + Shift-Control-Tab: selects the tab preceding the currently + selected one + + Alt-K: where K is the mnemonic (underlined) character of any + tab, will select that tab. + + Multiple notebooks in a single toplevel may be enabled for + traversal, including nested notebooks. However, notebook traversal + only works properly if all panes are direct children of the + notebook.""" + # The only, and good, difference I see is about mnemonics, which works + # after calling this method. Control-Tab and Shift-Control-Tab always + # works (here at least). + self.tk.call("ttk::notebook::enableTraversal", self._w) + + +class Panedwindow(Widget, tkinter.PanedWindow): + """Ttk Panedwindow widget displays a number of subwindows, stacked + either vertically or horizontally.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Panedwindow with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + + orient, width, height + + PANE OPTIONS + + weight + """ + Widget.__init__(self, master, "ttk::panedwindow", kw) + + + forget = tkinter.PanedWindow.forget # overrides Pack.forget + + + def insert(self, pos, child, **kw): + """Inserts a pane at the specified positions. + + pos is either the string end, and integer index, or the name + of a child. If child is already managed by the paned window, + moves it to the specified position.""" + self.tk.call(self._w, "insert", pos, child, *(_format_optdict(kw))) + + + def pane(self, pane, option=None, **kw): + """Query or modify the options of the specified pane. + + pane is either an integer index or the name of a managed subwindow. + If kw is not given, returns a dict of the pane option values. If + option is specified then the value for that option is returned. + Otherwise, sets the options to the corresponding values.""" + if option is not None: + kw[option] = None + return _val_or_dict(self.tk, kw, self._w, "pane", pane) + + + def sashpos(self, index, newpos=None): + """If newpos is specified, sets the position of sash number index. + + May adjust the positions of adjacent sashes to ensure that + positions are monotonically increasing. Sash positions are further + constrained to be between 0 and the total size of the widget. + + Returns the new position of sash number index.""" + return self.tk.getint(self.tk.call(self._w, "sashpos", index, newpos)) + +PanedWindow = Panedwindow # tkinter name compatibility + + +class Progressbar(Widget): + """Ttk Progressbar widget shows the status of a long-running + operation. They can operate in two modes: determinate mode shows the + amount completed relative to the total amount of work to be done, and + indeterminate mode provides an animated display to let the user know + that something is happening.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Progressbar with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + + orient, length, mode, maximum, value, variable, phase + """ + Widget.__init__(self, master, "ttk::progressbar", kw) + + + def start(self, interval=None): + """Begin autoincrement mode: schedules a recurring timer event + that calls method step every interval milliseconds. + + interval defaults to 50 milliseconds (20 steps/second) if omitted.""" + self.tk.call(self._w, "start", interval) + + + def step(self, amount=None): + """Increments the value option by amount. + + amount defaults to 1.0 if omitted.""" + self.tk.call(self._w, "step", amount) + + + def stop(self): + """Stop autoincrement mode: cancels any recurring timer event + initiated by start.""" + self.tk.call(self._w, "stop") + + +class Radiobutton(Widget): + """Ttk Radiobutton widgets are used in groups to show or change a + set of mutually-exclusive options.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Radiobutton with parent master. + + STANDARD OPTIONS + + class, compound, cursor, image, state, style, takefocus, + text, textvariable, underline, width + + WIDGET-SPECIFIC OPTIONS + + command, value, variable + """ + Widget.__init__(self, master, "ttk::radiobutton", kw) + + + def invoke(self): + """Sets the option variable to the option value, selects the + widget, and invokes the associated command. + + Returns the result of the command, or an empty string if + no command is specified.""" + return self.tk.call(self._w, "invoke") + + +class Scale(Widget, tkinter.Scale): + """Ttk Scale widget is typically used to control the numeric value of + a linked variable that varies uniformly over some range.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Scale with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + + command, from, length, orient, to, value, variable + """ + Widget.__init__(self, master, "ttk::scale", kw) + + + def configure(self, cnf=None, **kw): + """Modify or query scale options. + + Setting a value for any of the "from", "from_" or "to" options + generates a <> event.""" + retval = Widget.configure(self, cnf, **kw) + if not isinstance(cnf, (type(None), str)): + kw.update(cnf) + if any(['from' in kw, 'from_' in kw, 'to' in kw]): + self.event_generate('<>') + return retval + + + def get(self, x=None, y=None): + """Get the current value of the value option, or the value + corresponding to the coordinates x, y if they are specified. + + x and y are pixel coordinates relative to the scale widget + origin.""" + return self.tk.call(self._w, 'get', x, y) + + +class Scrollbar(Widget, tkinter.Scrollbar): + """Ttk Scrollbar controls the viewport of a scrollable widget.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Scrollbar with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + + command, orient + """ + Widget.__init__(self, master, "ttk::scrollbar", kw) + + +class Separator(Widget): + """Ttk Separator widget displays a horizontal or vertical separator + bar.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Separator with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus + + WIDGET-SPECIFIC OPTIONS + + orient + """ + Widget.__init__(self, master, "ttk::separator", kw) + + +class Sizegrip(Widget): + """Ttk Sizegrip allows the user to resize the containing toplevel + window by pressing and dragging the grip.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Sizegrip with parent master. + + STANDARD OPTIONS + + class, cursor, state, style, takefocus + """ + Widget.__init__(self, master, "ttk::sizegrip", kw) + + +class Spinbox(Entry): + """Ttk Spinbox is an Entry with increment and decrement arrows + + It is commonly used for number entry or to select from a list of + string values. + """ + + def __init__(self, master=None, **kw): + """Construct a Ttk Spinbox widget with the parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus, validate, + validatecommand, xscrollcommand, invalidcommand + + WIDGET-SPECIFIC OPTIONS + + to, from_, increment, values, wrap, format, command + """ + Entry.__init__(self, master, "ttk::spinbox", **kw) + + + def set(self, value): + """Sets the value of the Spinbox to value.""" + self.tk.call(self._w, "set", value) + + +class Treeview(Widget, tkinter.XView, tkinter.YView): + """Ttk Treeview widget displays a hierarchical collection of items. + + Each item has a textual label, an optional image, and an optional list + of data values. The data values are displayed in successive columns + after the tree label.""" + + def __init__(self, master=None, **kw): + """Construct a Ttk Treeview with parent master. + + STANDARD OPTIONS + + class, cursor, style, takefocus, xscrollcommand, + yscrollcommand + + WIDGET-SPECIFIC OPTIONS + + columns, displaycolumns, height, padding, selectmode, show + + ITEM OPTIONS + + text, image, values, open, tags + + TAG OPTIONS + + foreground, background, font, image + """ + Widget.__init__(self, master, "ttk::treeview", kw) + + + def bbox(self, item, column=None): + """Returns the bounding box (relative to the treeview widget's + window) of the specified item in the form x y width height. + + If column is specified, returns the bounding box of that cell. + If the item is not visible (i.e., if it is a descendant of a + closed item or is scrolled offscreen), returns an empty string.""" + return self._getints(self.tk.call(self._w, "bbox", item, column)) or '' + + + def get_children(self, item=None): + """Returns a tuple of children belonging to item. + + If item is not specified, returns root children.""" + return self.tk.splitlist( + self.tk.call(self._w, "children", item or '') or ()) + + + def set_children(self, item, *newchildren): + """Replaces item's child with newchildren. + + Children present in item that are not present in newchildren + are detached from tree. No items in newchildren may be an + ancestor of item.""" + self.tk.call(self._w, "children", item, newchildren) + + + def column(self, column, option=None, **kw): + """Query or modify the options for the specified column. + + If kw is not given, returns a dict of the column option values. If + option is specified then the value for that option is returned. + Otherwise, sets the options to the corresponding values.""" + if option is not None: + kw[option] = None + return _val_or_dict(self.tk, kw, self._w, "column", column) + + + def delete(self, *items): + """Delete all specified items and all their descendants. The root + item may not be deleted.""" + self.tk.call(self._w, "delete", items) + + + def detach(self, *items): + """Unlinks all of the specified items from the tree. + + The items and all of their descendants are still present, and may + be reinserted at another point in the tree, but will not be + displayed. The root item may not be detached.""" + self.tk.call(self._w, "detach", items) + + + def exists(self, item): + """Returns True if the specified item is present in the tree, + False otherwise.""" + return self.tk.getboolean(self.tk.call(self._w, "exists", item)) + + + def focus(self, item=None): + """If item is specified, sets the focus item to item. Otherwise, + returns the current focus item, or '' if there is none.""" + return self.tk.call(self._w, "focus", item) + + + def heading(self, column, option=None, **kw): + """Query or modify the heading options for the specified column. + + If kw is not given, returns a dict of the heading option values. If + option is specified then the value for that option is returned. + Otherwise, sets the options to the corresponding values. + + Valid options/values are: + text: text + The text to display in the column heading + image: image_name + Specifies an image to display to the right of the column + heading + anchor: anchor + Specifies how the heading text should be aligned. One of + the standard Tk anchor values + command: callback + A callback to be invoked when the heading label is + pressed. + + To configure the tree column heading, call this with column = "#0" """ + cmd = kw.get('command') + if cmd and not isinstance(cmd, str): + # callback not registered yet, do it now + kw['command'] = self.master.register(cmd, self._substitute) + + if option is not None: + kw[option] = None + + return _val_or_dict(self.tk, kw, self._w, 'heading', column) + + + def identify(self, component, x, y): + """Returns a description of the specified component under the + point given by x and y, or the empty string if no such component + is present at that position.""" + return self.tk.call(self._w, "identify", component, x, y) + + + def identify_row(self, y): + """Returns the item ID of the item at position y.""" + return self.identify("row", 0, y) + + + def identify_column(self, x): + """Returns the data column identifier of the cell at position x. + + The tree column has ID #0.""" + return self.identify("column", x, 0) + + + def identify_region(self, x, y): + """Returns one of: + + heading: Tree heading area. + separator: Space between two columns headings; + tree: The tree area. + cell: A data cell. + + * Availability: Tk 8.6""" + return self.identify("region", x, y) + + + def identify_element(self, x, y): + """Returns the element at position x, y. + + * Availability: Tk 8.6""" + return self.identify("element", x, y) + + + def index(self, item): + """Returns the integer index of item within its parent's list + of children.""" + return self.tk.getint(self.tk.call(self._w, "index", item)) + + + def insert(self, parent, index, iid=None, **kw): + """Creates a new item and return the item identifier of the newly + created item. + + parent is the item ID of the parent item, or the empty string + to create a new top-level item. index is an integer, or the value + end, specifying where in the list of parent's children to insert + the new item. If index is less than or equal to zero, the new node + is inserted at the beginning, if index is greater than or equal to + the current number of children, it is inserted at the end. If iid + is specified, it is used as the item identifier, iid must not + already exist in the tree. Otherwise, a new unique identifier + is generated.""" + opts = _format_optdict(kw) + if iid is not None: + res = self.tk.call(self._w, "insert", parent, index, + "-id", iid, *opts) + else: + res = self.tk.call(self._w, "insert", parent, index, *opts) + + return res + + + def item(self, item, option=None, **kw): + """Query or modify the options for the specified item. + + If no options are given, a dict with options/values for the item + is returned. If option is specified then the value for that option + is returned. Otherwise, sets the options to the corresponding + values as given by kw.""" + if option is not None: + kw[option] = None + return _val_or_dict(self.tk, kw, self._w, "item", item) + + + def move(self, item, parent, index): + """Moves item to position index in parent's list of children. + + It is illegal to move an item under one of its descendants. If + index is less than or equal to zero, item is moved to the + beginning, if greater than or equal to the number of children, + it is moved to the end. If item was detached it is reattached.""" + self.tk.call(self._w, "move", item, parent, index) + + reattach = move # A sensible method name for reattaching detached items + + + def next(self, item): + """Returns the identifier of item's next sibling, or '' if item + is the last child of its parent.""" + return self.tk.call(self._w, "next", item) + + + def parent(self, item): + """Returns the ID of the parent of item, or '' if item is at the + top level of the hierarchy.""" + return self.tk.call(self._w, "parent", item) + + + def prev(self, item): + """Returns the identifier of item's previous sibling, or '' if + item is the first child of its parent.""" + return self.tk.call(self._w, "prev", item) + + + def see(self, item): + """Ensure that item is visible. + + Sets all of item's ancestors open option to True, and scrolls + the widget if necessary so that item is within the visible + portion of the tree.""" + self.tk.call(self._w, "see", item) + + + def selection(self): + """Returns the tuple of selected items.""" + return self.tk.splitlist(self.tk.call(self._w, "selection")) + + + def _selection(self, selop, items): + if len(items) == 1 and isinstance(items[0], (tuple, list)): + items = items[0] + + self.tk.call(self._w, "selection", selop, items) + + + def selection_set(self, *items): + """The specified items becomes the new selection.""" + self._selection("set", items) + + + def selection_add(self, *items): + """Add all of the specified items to the selection.""" + self._selection("add", items) + + + def selection_remove(self, *items): + """Remove all of the specified items from the selection.""" + self._selection("remove", items) + + + def selection_toggle(self, *items): + """Toggle the selection state of each specified item.""" + self._selection("toggle", items) + + + def set(self, item, column=None, value=None): + """Query or set the value of given item. + + With one argument, return a dictionary of column/value pairs + for the specified item. With two arguments, return the current + value of the specified column. With three arguments, set the + value of given column in given item to the specified value.""" + res = self.tk.call(self._w, "set", item, column, value) + if column is None and value is None: + return _splitdict(self.tk, res, + cut_minus=False, conv=_tclobj_to_py) + else: + return res + + + def tag_bind(self, tagname, sequence=None, callback=None): + """Bind a callback for the given event sequence to the tag tagname. + When an event is delivered to an item, the callbacks for each + of the item's tags option are called.""" + self._bind((self._w, "tag", "bind", tagname), sequence, callback, add=0) + + + def tag_configure(self, tagname, option=None, **kw): + """Query or modify the options for the specified tagname. + + If kw is not given, returns a dict of the option settings for tagname. + If option is specified, returns the value for that option for the + specified tagname. Otherwise, sets the options to the corresponding + values for the given tagname.""" + if option is not None: + kw[option] = None + return _val_or_dict(self.tk, kw, self._w, "tag", "configure", + tagname) + + + def tag_has(self, tagname, item=None): + """If item is specified, returns 1 or 0 depending on whether the + specified item has the given tagname. Otherwise, returns a list of + all items which have the specified tag. + + * Availability: Tk 8.6""" + if item is None: + return self.tk.splitlist( + self.tk.call(self._w, "tag", "has", tagname)) + else: + return self.tk.getboolean( + self.tk.call(self._w, "tag", "has", tagname, item)) + + +# Extensions + +class LabeledScale(Frame): + """A Ttk Scale widget with a Ttk Label widget indicating its + current value. + + The Ttk Scale can be accessed through instance.scale, and Ttk Label + can be accessed through instance.label""" + + def __init__(self, master=None, variable=None, from_=0, to=10, **kw): + """Construct a horizontal LabeledScale with parent master, a + variable to be associated with the Ttk Scale widget and its range. + If variable is not specified, a tkinter.IntVar is created. + + WIDGET-SPECIFIC OPTIONS + + compound: 'top' or 'bottom' + Specifies how to display the label relative to the scale. + Defaults to 'top'. + """ + self._label_top = kw.pop('compound', 'top') == 'top' + + Frame.__init__(self, master, **kw) + self._variable = variable or tkinter.IntVar(master) + self._variable.set(from_) + self._last_valid = from_ + + self.label = Label(self) + self.scale = Scale(self, variable=self._variable, from_=from_, to=to) + self.scale.bind('<>', self._adjust) + + # position scale and label according to the compound option + scale_side = 'bottom' if self._label_top else 'top' + label_side = 'top' if scale_side == 'bottom' else 'bottom' + self.scale.pack(side=scale_side, fill='x') + # Dummy required to make frame correct height + dummy = Label(self) + dummy.pack(side=label_side) + dummy.lower() + self.label.place(anchor='n' if label_side == 'top' else 's') + + # update the label as scale or variable changes + self.__tracecb = self._variable.trace_variable('w', self._adjust) + self.bind('', self._adjust) + self.bind('', self._adjust) + + + def destroy(self): + """Destroy this widget and possibly its associated variable.""" + try: + self._variable.trace_vdelete('w', self.__tracecb) + except AttributeError: + pass + else: + del self._variable + super().destroy() + self.label = None + self.scale = None + + + def _adjust(self, *args): + """Adjust the label position according to the scale.""" + def adjust_label(): + self.update_idletasks() # "force" scale redraw + + x, y = self.scale.coords() + if self._label_top: + y = self.scale.winfo_y() - self.label.winfo_reqheight() + else: + y = self.scale.winfo_reqheight() + self.label.winfo_reqheight() + + self.label.place_configure(x=x, y=y) + + from_ = _to_number(self.scale['from']) + to = _to_number(self.scale['to']) + if to < from_: + from_, to = to, from_ + newval = self._variable.get() + if not from_ <= newval <= to: + # value outside range, set value back to the last valid one + self.value = self._last_valid + return + + self._last_valid = newval + self.label['text'] = newval + self.after_idle(adjust_label) + + @property + def value(self): + """Return current scale value.""" + return self._variable.get() + + @value.setter + def value(self, val): + """Set new scale value.""" + self._variable.set(val) + + +class OptionMenu(Menubutton): + """Themed OptionMenu, based after tkinter's OptionMenu, which allows + the user to select a value from a menu.""" + + def __init__(self, master, variable, default=None, *values, **kwargs): + """Construct a themed OptionMenu widget with master as the parent, + the resource textvariable set to variable, the initially selected + value specified by the default parameter, the menu values given by + *values and additional keywords. + + WIDGET-SPECIFIC OPTIONS + + style: stylename + Menubutton style. + direction: 'above', 'below', 'left', 'right', or 'flush' + Menubutton direction. + command: callback + A callback that will be invoked after selecting an item. + """ + kw = {'textvariable': variable, 'style': kwargs.pop('style', None), + 'direction': kwargs.pop('direction', None)} + Menubutton.__init__(self, master, **kw) + self['menu'] = tkinter.Menu(self, tearoff=False) + + self._variable = variable + self._callback = kwargs.pop('command', None) + if kwargs: + raise tkinter.TclError('unknown option -%s' % ( + next(iter(kwargs.keys())))) + + self.set_menu(default, *values) + + + def __getitem__(self, item): + if item == 'menu': + return self.nametowidget(Menubutton.__getitem__(self, item)) + + return Menubutton.__getitem__(self, item) + + + def set_menu(self, default=None, *values): + """Build a new menu of radiobuttons with *values and optionally + a default value.""" + menu = self['menu'] + menu.delete(0, 'end') + for val in values: + menu.add_radiobutton(label=val, + command=( + None if self._callback is None + else lambda val=val: self._callback(val) + ), + variable=self._variable) + + if default: + self._variable.set(default) + + + def destroy(self): + """Destroy this widget and its associated variable.""" + try: + del self._variable + except AttributeError: + pass + super().destroy() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/token.py b/physworld_p1_20261018/envs/p1/lib/python3.11/token.py new file mode 100644 index 0000000000000000000000000000000000000000..9d0c0bf0fb0368e15170336a0c60b17f5fa4da40 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/token.py @@ -0,0 +1,137 @@ +"""Token constants.""" +# Auto-generated by Tools/scripts/generate_token.py + +__all__ = ['tok_name', 'ISTERMINAL', 'ISNONTERMINAL', 'ISEOF'] + +ENDMARKER = 0 +NAME = 1 +NUMBER = 2 +STRING = 3 +NEWLINE = 4 +INDENT = 5 +DEDENT = 6 +LPAR = 7 +RPAR = 8 +LSQB = 9 +RSQB = 10 +COLON = 11 +COMMA = 12 +SEMI = 13 +PLUS = 14 +MINUS = 15 +STAR = 16 +SLASH = 17 +VBAR = 18 +AMPER = 19 +LESS = 20 +GREATER = 21 +EQUAL = 22 +DOT = 23 +PERCENT = 24 +LBRACE = 25 +RBRACE = 26 +EQEQUAL = 27 +NOTEQUAL = 28 +LESSEQUAL = 29 +GREATEREQUAL = 30 +TILDE = 31 +CIRCUMFLEX = 32 +LEFTSHIFT = 33 +RIGHTSHIFT = 34 +DOUBLESTAR = 35 +PLUSEQUAL = 36 +MINEQUAL = 37 +STAREQUAL = 38 +SLASHEQUAL = 39 +PERCENTEQUAL = 40 +AMPEREQUAL = 41 +VBAREQUAL = 42 +CIRCUMFLEXEQUAL = 43 +LEFTSHIFTEQUAL = 44 +RIGHTSHIFTEQUAL = 45 +DOUBLESTAREQUAL = 46 +DOUBLESLASH = 47 +DOUBLESLASHEQUAL = 48 +AT = 49 +ATEQUAL = 50 +RARROW = 51 +ELLIPSIS = 52 +COLONEQUAL = 53 +OP = 54 +AWAIT = 55 +ASYNC = 56 +TYPE_IGNORE = 57 +TYPE_COMMENT = 58 +SOFT_KEYWORD = 59 +# These aren't used by the C tokenizer but are needed for tokenize.py +ERRORTOKEN = 60 +COMMENT = 61 +NL = 62 +ENCODING = 63 +N_TOKENS = 64 +# Special definitions for cooperation with parser +NT_OFFSET = 256 + +tok_name = {value: name + for name, value in globals().items() + if isinstance(value, int) and not name.startswith('_')} +__all__.extend(tok_name.values()) + +EXACT_TOKEN_TYPES = { + '!=': NOTEQUAL, + '%': PERCENT, + '%=': PERCENTEQUAL, + '&': AMPER, + '&=': AMPEREQUAL, + '(': LPAR, + ')': RPAR, + '*': STAR, + '**': DOUBLESTAR, + '**=': DOUBLESTAREQUAL, + '*=': STAREQUAL, + '+': PLUS, + '+=': PLUSEQUAL, + ',': COMMA, + '-': MINUS, + '-=': MINEQUAL, + '->': RARROW, + '.': DOT, + '...': ELLIPSIS, + '/': SLASH, + '//': DOUBLESLASH, + '//=': DOUBLESLASHEQUAL, + '/=': SLASHEQUAL, + ':': COLON, + ':=': COLONEQUAL, + ';': SEMI, + '<': LESS, + '<<': LEFTSHIFT, + '<<=': LEFTSHIFTEQUAL, + '<=': LESSEQUAL, + '=': EQUAL, + '==': EQEQUAL, + '>': GREATER, + '>=': GREATEREQUAL, + '>>': RIGHTSHIFT, + '>>=': RIGHTSHIFTEQUAL, + '@': AT, + '@=': ATEQUAL, + '[': LSQB, + ']': RSQB, + '^': CIRCUMFLEX, + '^=': CIRCUMFLEXEQUAL, + '{': LBRACE, + '|': VBAR, + '|=': VBAREQUAL, + '}': RBRACE, + '~': TILDE, +} + +def ISTERMINAL(x): + return x < NT_OFFSET + +def ISNONTERMINAL(x): + return x >= NT_OFFSET + +def ISEOF(x): + return x == ENDMARKER diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tokenize.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tokenize.py new file mode 100644 index 0000000000000000000000000000000000000000..46d2224f5cc0833e4b38819d0255367bb3625ac4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tokenize.py @@ -0,0 +1,694 @@ +"""Tokenization help for Python programs. + +tokenize(readline) is a generator that breaks a stream of bytes into +Python tokens. It decodes the bytes according to PEP-0263 for +determining source file encoding. + +It accepts a readline-like method which is called repeatedly to get the +next line of input (or b"" for EOF). It generates 5-tuples with these +members: + + the token type (see token.py) + the token (a string) + the starting (row, column) indices of the token (a 2-tuple of ints) + the ending (row, column) indices of the token (a 2-tuple of ints) + the original line (string) + +It is designed to match the working of the Python tokenizer exactly, except +that it produces COMMENT tokens for comments and gives type OP for all +operators. Additionally, all token lists start with an ENCODING token +which tells you which encoding was used to decode the bytes stream. +""" + +__author__ = 'Ka-Ping Yee ' +__credits__ = ('GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, ' + 'Skip Montanaro, Raymond Hettinger, Trent Nelson, ' + 'Michael Foord') +from builtins import open as _builtin_open +from codecs import lookup, BOM_UTF8 +import collections +import functools +from io import TextIOWrapper +import itertools as _itertools +import re +import sys +from token import * +from token import EXACT_TOKEN_TYPES + +cookie_re = re.compile(r'^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)', re.ASCII) +blank_re = re.compile(br'^[ \t\f]*(?:[#\r\n]|$)', re.ASCII) + +import token +__all__ = token.__all__ + ["tokenize", "generate_tokens", "detect_encoding", + "untokenize", "TokenInfo"] +del token + +class TokenInfo(collections.namedtuple('TokenInfo', 'type string start end line')): + def __repr__(self): + annotated_type = '%d (%s)' % (self.type, tok_name[self.type]) + return ('TokenInfo(type=%s, string=%r, start=%r, end=%r, line=%r)' % + self._replace(type=annotated_type)) + + @property + def exact_type(self): + if self.type == OP and self.string in EXACT_TOKEN_TYPES: + return EXACT_TOKEN_TYPES[self.string] + else: + return self.type + +def group(*choices): return '(' + '|'.join(choices) + ')' +def any(*choices): return group(*choices) + '*' +def maybe(*choices): return group(*choices) + '?' + +# Note: we use unicode matching for names ("\w") but ascii matching for +# number literals. +Whitespace = r'[ \f\t]*' +Comment = r'#[^\r\n]*' +Ignore = Whitespace + any(r'\\\r?\n' + Whitespace) + maybe(Comment) +Name = r'\w+' + +Hexnumber = r'0[xX](?:_?[0-9a-fA-F])+' +Binnumber = r'0[bB](?:_?[01])+' +Octnumber = r'0[oO](?:_?[0-7])+' +Decnumber = r'(?:0(?:_?0)*|[1-9](?:_?[0-9])*)' +Intnumber = group(Hexnumber, Binnumber, Octnumber, Decnumber) +Exponent = r'[eE][-+]?[0-9](?:_?[0-9])*' +Pointfloat = group(r'[0-9](?:_?[0-9])*\.(?:[0-9](?:_?[0-9])*)?', + r'\.[0-9](?:_?[0-9])*') + maybe(Exponent) +Expfloat = r'[0-9](?:_?[0-9])*' + Exponent +Floatnumber = group(Pointfloat, Expfloat) +Imagnumber = group(r'[0-9](?:_?[0-9])*[jJ]', Floatnumber + r'[jJ]') +Number = group(Imagnumber, Floatnumber, Intnumber) + +# Return the empty string, plus all of the valid string prefixes. +def _all_string_prefixes(): + # The valid string prefixes. Only contain the lower case versions, + # and don't contain any permutations (include 'fr', but not + # 'rf'). The various permutations will be generated. + _valid_string_prefixes = ['b', 'r', 'u', 'f', 'br', 'fr'] + # if we add binary f-strings, add: ['fb', 'fbr'] + result = {''} + for prefix in _valid_string_prefixes: + for t in _itertools.permutations(prefix): + # create a list with upper and lower versions of each + # character + for u in _itertools.product(*[(c, c.upper()) for c in t]): + result.add(''.join(u)) + return result + +@functools.lru_cache +def _compile(expr): + return re.compile(expr, re.UNICODE) + +# Note that since _all_string_prefixes includes the empty string, +# StringPrefix can be the empty string (making it optional). +StringPrefix = group(*_all_string_prefixes()) + +# Tail end of ' string. +Single = r"[^'\\]*(?:\\.[^'\\]*)*'" +# Tail end of " string. +Double = r'[^"\\]*(?:\\.[^"\\]*)*"' +# Tail end of ''' string. +Single3 = r"[^'\\]*(?:(?:\\.|'(?!''))[^'\\]*)*'''" +# Tail end of """ string. +Double3 = r'[^"\\]*(?:(?:\\.|"(?!""))[^"\\]*)*"""' +Triple = group(StringPrefix + "'''", StringPrefix + '"""') +# Single-line ' or " string. +String = group(StringPrefix + r"'[^\n'\\]*(?:\\.[^\n'\\]*)*'", + StringPrefix + r'"[^\n"\\]*(?:\\.[^\n"\\]*)*"') + +# Sorting in reverse order puts the long operators before their prefixes. +# Otherwise if = came before ==, == would get recognized as two instances +# of =. +Special = group(*map(re.escape, sorted(EXACT_TOKEN_TYPES, reverse=True))) +Funny = group(r'\r?\n', Special) + +PlainToken = group(Number, Funny, String, Name) +Token = Ignore + PlainToken + +# First (or only) line of ' or " string. +ContStr = group(StringPrefix + r"'[^\n'\\]*(?:\\.[^\n'\\]*)*" + + group("'", r'\\\r?\n'), + StringPrefix + r'"[^\n"\\]*(?:\\.[^\n"\\]*)*' + + group('"', r'\\\r?\n')) +PseudoExtras = group(r'\\\r?\n|\Z', Comment, Triple) +PseudoToken = Whitespace + group(PseudoExtras, Number, Funny, ContStr, Name) + +# For a given string prefix plus quotes, endpats maps it to a regex +# to match the remainder of that string. _prefix can be empty, for +# a normal single or triple quoted string (with no prefix). +endpats = {} +for _prefix in _all_string_prefixes(): + endpats[_prefix + "'"] = Single + endpats[_prefix + '"'] = Double + endpats[_prefix + "'''"] = Single3 + endpats[_prefix + '"""'] = Double3 +del _prefix + +# A set of all of the single and triple quoted string prefixes, +# including the opening quotes. +single_quoted = set() +triple_quoted = set() +for t in _all_string_prefixes(): + for u in (t + '"', t + "'"): + single_quoted.add(u) + for u in (t + '"""', t + "'''"): + triple_quoted.add(u) +del t, u + +tabsize = 8 + +class TokenError(Exception): pass + +class StopTokenizing(Exception): pass + + +class Untokenizer: + + def __init__(self): + self.tokens = [] + self.prev_row = 1 + self.prev_col = 0 + self.encoding = None + + def add_whitespace(self, start): + row, col = start + if row < self.prev_row or row == self.prev_row and col < self.prev_col: + raise ValueError("start ({},{}) precedes previous end ({},{})" + .format(row, col, self.prev_row, self.prev_col)) + row_offset = row - self.prev_row + if row_offset: + self.tokens.append("\\\n" * row_offset) + self.prev_col = 0 + col_offset = col - self.prev_col + if col_offset: + self.tokens.append(" " * col_offset) + + def untokenize(self, iterable): + it = iter(iterable) + indents = [] + startline = False + for t in it: + if len(t) == 2: + self.compat(t, it) + break + tok_type, token, start, end, line = t + if tok_type == ENCODING: + self.encoding = token + continue + if tok_type == ENDMARKER: + break + if tok_type == INDENT: + indents.append(token) + continue + elif tok_type == DEDENT: + indents.pop() + self.prev_row, self.prev_col = end + continue + elif tok_type in (NEWLINE, NL): + startline = True + elif startline and indents: + indent = indents[-1] + if start[1] >= len(indent): + self.tokens.append(indent) + self.prev_col = len(indent) + startline = False + self.add_whitespace(start) + self.tokens.append(token) + self.prev_row, self.prev_col = end + if tok_type in (NEWLINE, NL): + self.prev_row += 1 + self.prev_col = 0 + return "".join(self.tokens) + + def compat(self, token, iterable): + indents = [] + toks_append = self.tokens.append + startline = token[0] in (NEWLINE, NL) + prevstring = False + + for tok in _itertools.chain([token], iterable): + toknum, tokval = tok[:2] + if toknum == ENCODING: + self.encoding = tokval + continue + + if toknum in (NAME, NUMBER): + tokval += ' ' + + # Insert a space between two consecutive strings + if toknum == STRING: + if prevstring: + tokval = ' ' + tokval + prevstring = True + else: + prevstring = False + + if toknum == INDENT: + indents.append(tokval) + continue + elif toknum == DEDENT: + indents.pop() + continue + elif toknum in (NEWLINE, NL): + startline = True + elif startline and indents: + toks_append(indents[-1]) + startline = False + toks_append(tokval) + + +def untokenize(iterable): + """Transform tokens back into Python source code. + It returns a bytes object, encoded using the ENCODING + token, which is the first token sequence output by tokenize. + + Each element returned by the iterable must be a token sequence + with at least two elements, a token number and token value. If + only two tokens are passed, the resulting output is poor. + + Round-trip invariant for full input: + Untokenized source will match input source exactly + + Round-trip invariant for limited input: + # Output bytes will tokenize back to the input + t1 = [tok[:2] for tok in tokenize(f.readline)] + newcode = untokenize(t1) + readline = BytesIO(newcode).readline + t2 = [tok[:2] for tok in tokenize(readline)] + assert t1 == t2 + """ + ut = Untokenizer() + out = ut.untokenize(iterable) + if ut.encoding is not None: + out = out.encode(ut.encoding) + return out + + +def _get_normal_name(orig_enc): + """Imitates get_normal_name in tokenizer.c.""" + # Only care about the first 12 characters. + enc = orig_enc[:12].lower().replace("_", "-") + if enc == "utf-8" or enc.startswith("utf-8-"): + return "utf-8" + if enc in ("latin-1", "iso-8859-1", "iso-latin-1") or \ + enc.startswith(("latin-1-", "iso-8859-1-", "iso-latin-1-")): + return "iso-8859-1" + return orig_enc + +def detect_encoding(readline): + """ + The detect_encoding() function is used to detect the encoding that should + be used to decode a Python source file. It requires one argument, readline, + in the same way as the tokenize() generator. + + It will call readline a maximum of twice, and return the encoding used + (as a string) and a list of any lines (left as bytes) it has read in. + + It detects the encoding from the presence of a utf-8 bom or an encoding + cookie as specified in pep-0263. If both a bom and a cookie are present, + but disagree, a SyntaxError will be raised. If the encoding cookie is an + invalid charset, raise a SyntaxError. Note that if a utf-8 bom is found, + 'utf-8-sig' is returned. + + If no encoding is specified, then the default of 'utf-8' will be returned. + """ + try: + filename = readline.__self__.name + except AttributeError: + filename = None + bom_found = False + encoding = None + default = 'utf-8' + def read_or_stop(): + try: + return readline() + except StopIteration: + return b'' + + def find_cookie(line): + try: + # Decode as UTF-8. Either the line is an encoding declaration, + # in which case it should be pure ASCII, or it must be UTF-8 + # per default encoding. + line_string = line.decode('utf-8') + except UnicodeDecodeError: + msg = "invalid or missing encoding declaration" + if filename is not None: + msg = '{} for {!r}'.format(msg, filename) + raise SyntaxError(msg) + + match = cookie_re.match(line_string) + if not match: + return None + encoding = _get_normal_name(match.group(1)) + try: + codec = lookup(encoding) + except LookupError: + # This behaviour mimics the Python interpreter + if filename is None: + msg = "unknown encoding: " + encoding + else: + msg = "unknown encoding for {!r}: {}".format(filename, + encoding) + raise SyntaxError(msg) + + if bom_found: + if encoding != 'utf-8': + # This behaviour mimics the Python interpreter + if filename is None: + msg = 'encoding problem: utf-8' + else: + msg = 'encoding problem for {!r}: utf-8'.format(filename) + raise SyntaxError(msg) + encoding += '-sig' + return encoding + + first = read_or_stop() + if first.startswith(BOM_UTF8): + bom_found = True + first = first[3:] + default = 'utf-8-sig' + if not first: + return default, [] + + encoding = find_cookie(first) + if encoding: + return encoding, [first] + if not blank_re.match(first): + return default, [first] + + second = read_or_stop() + if not second: + return default, [first] + + encoding = find_cookie(second) + if encoding: + return encoding, [first, second] + + return default, [first, second] + + +def open(filename): + """Open a file in read only mode using the encoding detected by + detect_encoding(). + """ + buffer = _builtin_open(filename, 'rb') + try: + encoding, lines = detect_encoding(buffer.readline) + buffer.seek(0) + text = TextIOWrapper(buffer, encoding, line_buffering=True) + text.mode = 'r' + return text + except: + buffer.close() + raise + + +def tokenize(readline): + """ + The tokenize() generator requires one argument, readline, which + must be a callable object which provides the same interface as the + readline() method of built-in file objects. Each call to the function + should return one line of input as bytes. Alternatively, readline + can be a callable function terminating with StopIteration: + readline = open(myfile, 'rb').__next__ # Example of alternate readline + + The generator produces 5-tuples with these members: the token type; the + token string; a 2-tuple (srow, scol) of ints specifying the row and + column where the token begins in the source; a 2-tuple (erow, ecol) of + ints specifying the row and column where the token ends in the source; + and the line on which the token was found. The line passed is the + physical line. + + The first token sequence will always be an ENCODING token + which tells you which encoding was used to decode the bytes stream. + """ + encoding, consumed = detect_encoding(readline) + empty = _itertools.repeat(b"") + rl_gen = _itertools.chain(consumed, iter(readline, b""), empty) + return _tokenize(rl_gen.__next__, encoding) + + +def _tokenize(readline, encoding): + lnum = parenlev = continued = 0 + numchars = '0123456789' + contstr, needcont = '', 0 + contline = None + indents = [0] + + if encoding is not None: + if encoding == "utf-8-sig": + # BOM will already have been stripped. + encoding = "utf-8" + yield TokenInfo(ENCODING, encoding, (0, 0), (0, 0), '') + last_line = b'' + line = b'' + while True: # loop over lines in stream + try: + # We capture the value of the line variable here because + # readline uses the empty string '' to signal end of input, + # hence `line` itself will always be overwritten at the end + # of this loop. + last_line = line + line = readline() + except StopIteration: + line = b'' + + if encoding is not None: + line = line.decode(encoding) + lnum += 1 + pos, max = 0, len(line) + + if contstr: # continued string + if not line: + raise TokenError("EOF in multi-line string", strstart) + endmatch = endprog.match(line) + if endmatch: + pos = end = endmatch.end(0) + yield TokenInfo(STRING, contstr + line[:end], + strstart, (lnum, end), contline + line) + contstr, needcont = '', 0 + contline = None + elif needcont and line[-2:] != '\\\n' and line[-3:] != '\\\r\n': + yield TokenInfo(ERRORTOKEN, contstr + line, + strstart, (lnum, len(line)), contline) + contstr = '' + contline = None + continue + else: + contstr = contstr + line + contline = contline + line + continue + + elif parenlev == 0 and not continued: # new statement + if not line: break + column = 0 + while pos < max: # measure leading whitespace + if line[pos] == ' ': + column += 1 + elif line[pos] == '\t': + column = (column//tabsize + 1)*tabsize + elif line[pos] == '\f': + column = 0 + else: + break + pos += 1 + if pos == max: + break + + if line[pos] in '#\r\n': # skip comments or blank lines + if line[pos] == '#': + comment_token = line[pos:].rstrip('\r\n') + yield TokenInfo(COMMENT, comment_token, + (lnum, pos), (lnum, pos + len(comment_token)), line) + pos += len(comment_token) + + yield TokenInfo(NL, line[pos:], + (lnum, pos), (lnum, len(line)), line) + continue + + if column > indents[-1]: # count indents or dedents + indents.append(column) + yield TokenInfo(INDENT, line[:pos], (lnum, 0), (lnum, pos), line) + while column < indents[-1]: + if column not in indents: + raise IndentationError( + "unindent does not match any outer indentation level", + ("", lnum, pos, line)) + indents = indents[:-1] + + yield TokenInfo(DEDENT, '', (lnum, pos), (lnum, pos), line) + + else: # continued statement + if not line: + raise TokenError("EOF in multi-line statement", (lnum, 0)) + continued = 0 + + while pos < max: + pseudomatch = _compile(PseudoToken).match(line, pos) + if pseudomatch: # scan for tokens + start, end = pseudomatch.span(1) + spos, epos, pos = (lnum, start), (lnum, end), end + if start == end: + continue + token, initial = line[start:end], line[start] + + if (initial in numchars or # ordinary number + (initial == '.' and token != '.' and token != '...')): + yield TokenInfo(NUMBER, token, spos, epos, line) + elif initial in '\r\n': + if parenlev > 0: + yield TokenInfo(NL, token, spos, epos, line) + else: + yield TokenInfo(NEWLINE, token, spos, epos, line) + + elif initial == '#': + assert not token.endswith("\n") + yield TokenInfo(COMMENT, token, spos, epos, line) + + elif token in triple_quoted: + endprog = _compile(endpats[token]) + endmatch = endprog.match(line, pos) + if endmatch: # all on one line + pos = endmatch.end(0) + token = line[start:pos] + yield TokenInfo(STRING, token, spos, (lnum, pos), line) + else: + strstart = (lnum, start) # multiple lines + contstr = line[start:] + contline = line + break + + # Check up to the first 3 chars of the token to see if + # they're in the single_quoted set. If so, they start + # a string. + # We're using the first 3, because we're looking for + # "rb'" (for example) at the start of the token. If + # we switch to longer prefixes, this needs to be + # adjusted. + # Note that initial == token[:1]. + # Also note that single quote checking must come after + # triple quote checking (above). + elif (initial in single_quoted or + token[:2] in single_quoted or + token[:3] in single_quoted): + if token[-1] == '\n': # continued string + strstart = (lnum, start) + # Again, using the first 3 chars of the + # token. This is looking for the matching end + # regex for the correct type of quote + # character. So it's really looking for + # endpats["'"] or endpats['"'], by trying to + # skip string prefix characters, if any. + endprog = _compile(endpats.get(initial) or + endpats.get(token[1]) or + endpats.get(token[2])) + contstr, needcont = line[start:], 1 + contline = line + break + else: # ordinary string + yield TokenInfo(STRING, token, spos, epos, line) + + elif initial.isidentifier(): # ordinary name + yield TokenInfo(NAME, token, spos, epos, line) + elif initial == '\\': # continued stmt + continued = 1 + else: + if initial in '([{': + parenlev += 1 + elif initial in ')]}': + parenlev -= 1 + yield TokenInfo(OP, token, spos, epos, line) + else: + yield TokenInfo(ERRORTOKEN, line[pos], + (lnum, pos), (lnum, pos+1), line) + pos += 1 + + # Add an implicit NEWLINE if the input doesn't end in one + if last_line and last_line[-1] not in '\r\n' and not last_line.strip().startswith("#"): + yield TokenInfo(NEWLINE, '', (lnum - 1, len(last_line)), (lnum - 1, len(last_line) + 1), '') + for indent in indents[1:]: # pop remaining indent levels + yield TokenInfo(DEDENT, '', (lnum, 0), (lnum, 0), '') + yield TokenInfo(ENDMARKER, '', (lnum, 0), (lnum, 0), '') + + +def generate_tokens(readline): + """Tokenize a source reading Python code as unicode strings. + + This has the same API as tokenize(), except that it expects the *readline* + callable to return str objects instead of bytes. + """ + return _tokenize(readline, None) + +def main(): + import argparse + + # Helper error handling routines + def perror(message): + sys.stderr.write(message) + sys.stderr.write('\n') + + def error(message, filename=None, location=None): + if location: + args = (filename,) + location + (message,) + perror("%s:%d:%d: error: %s" % args) + elif filename: + perror("%s: error: %s" % (filename, message)) + else: + perror("error: %s" % message) + sys.exit(1) + + # Parse the arguments and options + parser = argparse.ArgumentParser(prog='python -m tokenize') + parser.add_argument(dest='filename', nargs='?', + metavar='filename.py', + help='the file to tokenize; defaults to stdin') + parser.add_argument('-e', '--exact', dest='exact', action='store_true', + help='display token names using the exact type') + args = parser.parse_args() + + try: + # Tokenize the input + if args.filename: + filename = args.filename + with _builtin_open(filename, 'rb') as f: + tokens = list(tokenize(f.readline)) + else: + filename = "" + tokens = _tokenize(sys.stdin.readline, None) + + # Output the tokenization + for token in tokens: + token_type = token.type + if args.exact: + token_type = token.exact_type + token_range = "%d,%d-%d,%d:" % (token.start + token.end) + print("%-20s%-15s%-15r" % + (token_range, tok_name[token_type], token.string)) + except IndentationError as err: + line, column = err.args[1][1:3] + error(err.args[0], filename, (line, column)) + except TokenError as err: + line, column = err.args[1] + error(err.args[0], filename, (line, column)) + except SyntaxError as err: + error(err, filename) + except OSError as err: + error(err) + except KeyboardInterrupt: + print("interrupted\n") + except Exception as err: + perror("unexpected error: %s" % err) + raise + +def _generate_tokens_from_c_tokenizer(source): + """Tokenize a source reading Python code as unicode strings using the internal C tokenizer""" + import _tokenize as c_tokenizer + for info in c_tokenizer.TokenizerIter(source): + tok, type, lineno, end_lineno, col_off, end_col_off, line = info + yield TokenInfo(type, tok, (lineno, col_off), (end_lineno, end_col_off), line) + + +if __name__ == "__main__": + main() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ef91cb9d25dd794b2668b9557adca0601b5069f4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/__init__.py @@ -0,0 +1,10 @@ +# SPDX-License-Identifier: MIT +# SPDX-FileCopyrightText: 2021 Taneli Hukkinen +# Licensed to PSF under a Contributor Agreement. + +__all__ = ("loads", "load", "TOMLDecodeError") + +from ._parser import TOMLDecodeError, load, loads + +# Pretend this exception was created here. +TOMLDecodeError.__module__ = __name__ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af87da798674f323292ba4335bc0bde03fc4cbc5 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/__pycache__/_parser.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/__pycache__/_parser.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1a9861797fb9ef9571662f078acbbcc5d13ff7dc Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/__pycache__/_parser.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/__pycache__/_re.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/__pycache__/_re.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7632bf534133310c9042f8597b997cc3be7ec7ec Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/__pycache__/_re.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/__pycache__/_types.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/__pycache__/_types.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0fafc1cfc319bd1c987440abdfec6edf144c10cf Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/__pycache__/_types.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/_parser.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/_parser.py new file mode 100644 index 0000000000000000000000000000000000000000..710ad10c02427001e608f2d4dc9bf0b04174e117 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/_parser.py @@ -0,0 +1,703 @@ +# SPDX-License-Identifier: MIT +# SPDX-FileCopyrightText: 2021 Taneli Hukkinen +# Licensed to PSF under a Contributor Agreement. + +from __future__ import annotations + +from collections.abc import Iterable +import string +import sys +from types import MappingProxyType +from typing import Any, BinaryIO, NamedTuple + +from ._re import ( + RE_DATETIME, + RE_LOCALTIME, + RE_NUMBER, + match_to_datetime, + match_to_localtime, + match_to_number, +) +from ._types import Key, ParseFloat, Pos + +# Pathologically excessive number of parts in a key runs into quadratic +# behavior (e.g. in Flags.is_). +# Even if keys aren't currently parsed using recursion, they name a +# recursive structure, so it makes sense to limit it using getrecursionlimit() +# and RecursionError. +MAX_KEY_PARTS = sys.getrecursionlimit() + +ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127)) + +# Neither of these sets include quotation mark or backslash. They are +# currently handled as separate cases in the parser functions. +ILLEGAL_BASIC_STR_CHARS = ASCII_CTRL - frozenset("\t") +ILLEGAL_MULTILINE_BASIC_STR_CHARS = ASCII_CTRL - frozenset("\t\n") + +ILLEGAL_LITERAL_STR_CHARS = ILLEGAL_BASIC_STR_CHARS +ILLEGAL_MULTILINE_LITERAL_STR_CHARS = ILLEGAL_MULTILINE_BASIC_STR_CHARS + +ILLEGAL_COMMENT_CHARS = ILLEGAL_BASIC_STR_CHARS + +TOML_WS = frozenset(" \t") +TOML_WS_AND_NEWLINE = TOML_WS | frozenset("\n") +BARE_KEY_CHARS = frozenset(string.ascii_letters + string.digits + "-_") +KEY_INITIAL_CHARS = BARE_KEY_CHARS | frozenset("\"'") +HEXDIGIT_CHARS = frozenset(string.hexdigits) + +BASIC_STR_ESCAPE_REPLACEMENTS = MappingProxyType( + { + "\\b": "\u0008", # backspace + "\\t": "\u0009", # tab + "\\n": "\u000A", # linefeed + "\\f": "\u000C", # form feed + "\\r": "\u000D", # carriage return + '\\"': "\u0022", # quote + "\\\\": "\u005C", # backslash + } +) + + +class TOMLDecodeError(ValueError): + """An error raised if a document is not valid TOML.""" + + +def load(fp: BinaryIO, /, *, parse_float: ParseFloat = float) -> dict[str, Any]: + """Parse TOML from a binary file object.""" + b = fp.read() + try: + s = b.decode() + except AttributeError: + raise TypeError( + "File must be opened in binary mode, e.g. use `open('foo.toml', 'rb')`" + ) from None + return loads(s, parse_float=parse_float) + + +def loads(s: str, /, *, parse_float: ParseFloat = float) -> dict[str, Any]: # noqa: C901 + """Parse TOML from a string.""" + + # The spec allows converting "\r\n" to "\n", even in string + # literals. Let's do so to simplify parsing. + src = s.replace("\r\n", "\n") + pos = 0 + out = Output(NestedDict(), Flags()) + header: Key = () + parse_float = make_safe_parse_float(parse_float) + + # Parse one statement at a time + # (typically means one line in TOML source) + while True: + # 1. Skip line leading whitespace + pos = skip_chars(src, pos, TOML_WS) + + # 2. Parse rules. Expect one of the following: + # - end of file + # - end of line + # - comment + # - key/value pair + # - append dict to list (and move to its namespace) + # - create dict (and move to its namespace) + # Skip trailing whitespace when applicable. + try: + char = src[pos] + except IndexError: + break + if char == "\n": + pos += 1 + continue + if char in KEY_INITIAL_CHARS: + pos = key_value_rule(src, pos, out, header, parse_float) + pos = skip_chars(src, pos, TOML_WS) + elif char == "[": + try: + second_char: str | None = src[pos + 1] + except IndexError: + second_char = None + out.flags.finalize_pending() + if second_char == "[": + pos, header = create_list_rule(src, pos, out) + else: + pos, header = create_dict_rule(src, pos, out) + pos = skip_chars(src, pos, TOML_WS) + elif char != "#": + raise suffixed_err(src, pos, "Invalid statement") + + # 3. Skip comment + pos = skip_comment(src, pos) + + # 4. Expect end of line or end of file + try: + char = src[pos] + except IndexError: + break + if char != "\n": + raise suffixed_err( + src, pos, "Expected newline or end of document after a statement" + ) + pos += 1 + + return out.data.dict + + +class Flags: + """Flags that map to parsed keys/namespaces.""" + + # Marks an immutable namespace (inline array or inline table). + FROZEN = 0 + # Marks a nest that has been explicitly created and can no longer + # be opened using the "[table]" syntax. + EXPLICIT_NEST = 1 + + def __init__(self) -> None: + self._flags: dict[str, dict] = {} + self._pending_flags: set[tuple[Key, int]] = set() + + def add_pending(self, key: Key, flag: int) -> None: + self._pending_flags.add((key, flag)) + + def finalize_pending(self) -> None: + for key, flag in self._pending_flags: + self.set(key, flag, recursive=False) + self._pending_flags.clear() + + def unset_all(self, key: Key) -> None: + cont = self._flags + for k in key[:-1]: + if k not in cont: + return + cont = cont[k]["nested"] + cont.pop(key[-1], None) + + def set(self, key: Key, flag: int, *, recursive: bool) -> None: # noqa: A003 + cont = self._flags + key_parent, key_stem = key[:-1], key[-1] + for k in key_parent: + if k not in cont: + cont[k] = {"flags": set(), "recursive_flags": set(), "nested": {}} + cont = cont[k]["nested"] + if key_stem not in cont: + cont[key_stem] = {"flags": set(), "recursive_flags": set(), "nested": {}} + cont[key_stem]["recursive_flags" if recursive else "flags"].add(flag) + + def is_(self, key: Key, flag: int) -> bool: + if not key: + return False # document root has no flags + cont = self._flags + for k in key[:-1]: + if k not in cont: + return False + inner_cont = cont[k] + if flag in inner_cont["recursive_flags"]: + return True + cont = inner_cont["nested"] + key_stem = key[-1] + if key_stem in cont: + cont = cont[key_stem] + return flag in cont["flags"] or flag in cont["recursive_flags"] + return False + + +class NestedDict: + def __init__(self) -> None: + # The parsed content of the TOML document + self.dict: dict[str, Any] = {} + + def get_or_create_nest( + self, + key: Key, + *, + access_lists: bool = True, + ) -> dict: + cont: Any = self.dict + for k in key: + if k not in cont: + cont[k] = {} + cont = cont[k] + if access_lists and isinstance(cont, list): + cont = cont[-1] + if not isinstance(cont, dict): + raise KeyError("There is no nest behind this key") + return cont + + def append_nest_to_list(self, key: Key) -> None: + cont = self.get_or_create_nest(key[:-1]) + last_key = key[-1] + if last_key in cont: + list_ = cont[last_key] + if not isinstance(list_, list): + raise KeyError("An object other than list found behind this key") + list_.append({}) + else: + cont[last_key] = [{}] + + +class Output(NamedTuple): + data: NestedDict + flags: Flags + + +def skip_chars(src: str, pos: Pos, chars: Iterable[str]) -> Pos: + try: + while src[pos] in chars: + pos += 1 + except IndexError: + pass + return pos + + +def skip_until( + src: str, + pos: Pos, + expect: str, + *, + error_on: frozenset[str], + error_on_eof: bool, +) -> Pos: + try: + new_pos = src.index(expect, pos) + except ValueError: + new_pos = len(src) + if error_on_eof: + raise suffixed_err(src, new_pos, f"Expected {expect!r}") from None + + if not error_on.isdisjoint(src[pos:new_pos]): + while src[pos] not in error_on: + pos += 1 + raise suffixed_err(src, pos, f"Found invalid character {src[pos]!r}") + return new_pos + + +def skip_comment(src: str, pos: Pos) -> Pos: + try: + char: str | None = src[pos] + except IndexError: + char = None + if char == "#": + return skip_until( + src, pos + 1, "\n", error_on=ILLEGAL_COMMENT_CHARS, error_on_eof=False + ) + return pos + + +def skip_comments_and_array_ws(src: str, pos: Pos) -> Pos: + while True: + pos_before_skip = pos + pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE) + pos = skip_comment(src, pos) + if pos == pos_before_skip: + return pos + + +def create_dict_rule(src: str, pos: Pos, out: Output) -> tuple[Pos, Key]: + pos += 1 # Skip "[" + pos = skip_chars(src, pos, TOML_WS) + pos, key = parse_key(src, pos) + + if out.flags.is_(key, Flags.EXPLICIT_NEST) or out.flags.is_(key, Flags.FROZEN): + raise suffixed_err(src, pos, f"Cannot declare {key} twice") + out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False) + try: + out.data.get_or_create_nest(key) + except KeyError: + raise suffixed_err(src, pos, "Cannot overwrite a value") from None + + if not src.startswith("]", pos): + raise suffixed_err(src, pos, "Expected ']' at the end of a table declaration") + return pos + 1, key + + +def create_list_rule(src: str, pos: Pos, out: Output) -> tuple[Pos, Key]: + pos += 2 # Skip "[[" + pos = skip_chars(src, pos, TOML_WS) + pos, key = parse_key(src, pos) + + if out.flags.is_(key, Flags.FROZEN): + raise suffixed_err(src, pos, f"Cannot mutate immutable namespace {key}") + # Free the namespace now that it points to another empty list item... + out.flags.unset_all(key) + # ...but this key precisely is still prohibited from table declaration + out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False) + try: + out.data.append_nest_to_list(key) + except KeyError: + raise suffixed_err(src, pos, "Cannot overwrite a value") from None + + if not src.startswith("]]", pos): + raise suffixed_err(src, pos, "Expected ']]' at the end of an array declaration") + return pos + 2, key + + +def key_value_rule( + src: str, pos: Pos, out: Output, header: Key, parse_float: ParseFloat +) -> Pos: + pos, key, value = parse_key_value_pair(src, pos, parse_float) + key_parent, key_stem = key[:-1], key[-1] + abs_key_parent = header + key_parent + + relative_path_cont_keys = (header + key[:i] for i in range(1, len(key))) + for cont_key in relative_path_cont_keys: + # Check that dotted key syntax does not redefine an existing table + if out.flags.is_(cont_key, Flags.EXPLICIT_NEST): + raise suffixed_err(src, pos, f"Cannot redefine namespace {cont_key}") + # Containers in the relative path can't be opened with the table syntax or + # dotted key/value syntax in following table sections. + out.flags.add_pending(cont_key, Flags.EXPLICIT_NEST) + + if out.flags.is_(abs_key_parent, Flags.FROZEN): + raise suffixed_err( + src, pos, f"Cannot mutate immutable namespace {abs_key_parent}" + ) + + try: + nest = out.data.get_or_create_nest(abs_key_parent) + except KeyError: + raise suffixed_err(src, pos, "Cannot overwrite a value") from None + if key_stem in nest: + raise suffixed_err(src, pos, "Cannot overwrite a value") + # Mark inline table and array namespaces recursively immutable + if isinstance(value, (dict, list)): + out.flags.set(header + key, Flags.FROZEN, recursive=True) + nest[key_stem] = value + return pos + + +def parse_key_value_pair( + src: str, pos: Pos, parse_float: ParseFloat +) -> tuple[Pos, Key, Any]: + pos, key = parse_key(src, pos) + try: + char: str | None = src[pos] + except IndexError: + char = None + if char != "=": + raise suffixed_err(src, pos, "Expected '=' after a key in a key/value pair") + pos += 1 + pos = skip_chars(src, pos, TOML_WS) + pos, value = parse_value(src, pos, parse_float) + return pos, key, value + + +def parse_key(src: str, pos: Pos) -> tuple[Pos, Key]: + pos, key_part = parse_key_part(src, pos) + key: Key = (key_part,) + pos = skip_chars(src, pos, TOML_WS) + while True: + try: + char: str | None = src[pos] + except IndexError: + char = None + if char != ".": + return pos, key + pos += 1 + pos = skip_chars(src, pos, TOML_WS) + pos, key_part = parse_key_part(src, pos) + key += (key_part,) + if len(key) > MAX_KEY_PARTS: + raise RecursionError( + f"TOML key has more than the allowed {MAX_KEY_PARTS} parts" + ) + pos = skip_chars(src, pos, TOML_WS) + + +def parse_key_part(src: str, pos: Pos) -> tuple[Pos, str]: + try: + char: str | None = src[pos] + except IndexError: + char = None + if char in BARE_KEY_CHARS: + start_pos = pos + pos = skip_chars(src, pos, BARE_KEY_CHARS) + return pos, src[start_pos:pos] + if char == "'": + return parse_literal_str(src, pos) + if char == '"': + return parse_one_line_basic_str(src, pos) + raise suffixed_err(src, pos, "Invalid initial character for a key part") + + +def parse_one_line_basic_str(src: str, pos: Pos) -> tuple[Pos, str]: + pos += 1 + return parse_basic_str(src, pos, multiline=False) + + +def parse_array(src: str, pos: Pos, parse_float: ParseFloat) -> tuple[Pos, list]: + pos += 1 + array: list = [] + + pos = skip_comments_and_array_ws(src, pos) + if src.startswith("]", pos): + return pos + 1, array + while True: + pos, val = parse_value(src, pos, parse_float) + array.append(val) + pos = skip_comments_and_array_ws(src, pos) + + c = src[pos : pos + 1] + if c == "]": + return pos + 1, array + if c != ",": + raise suffixed_err(src, pos, "Unclosed array") + pos += 1 + + pos = skip_comments_and_array_ws(src, pos) + if src.startswith("]", pos): + return pos + 1, array + + +def parse_inline_table(src: str, pos: Pos, parse_float: ParseFloat) -> tuple[Pos, dict]: + pos += 1 + nested_dict = NestedDict() + flags = Flags() + + pos = skip_chars(src, pos, TOML_WS) + if src.startswith("}", pos): + return pos + 1, nested_dict.dict + while True: + pos, key, value = parse_key_value_pair(src, pos, parse_float) + key_parent, key_stem = key[:-1], key[-1] + if flags.is_(key, Flags.FROZEN): + raise suffixed_err(src, pos, f"Cannot mutate immutable namespace {key}") + try: + nest = nested_dict.get_or_create_nest(key_parent, access_lists=False) + except KeyError: + raise suffixed_err(src, pos, "Cannot overwrite a value") from None + if key_stem in nest: + raise suffixed_err(src, pos, f"Duplicate inline table key {key_stem!r}") + nest[key_stem] = value + pos = skip_chars(src, pos, TOML_WS) + c = src[pos : pos + 1] + if c == "}": + return pos + 1, nested_dict.dict + if c != ",": + raise suffixed_err(src, pos, "Unclosed inline table") + if isinstance(value, (dict, list)): + flags.set(key, Flags.FROZEN, recursive=True) + pos += 1 + pos = skip_chars(src, pos, TOML_WS) + + +def parse_basic_str_escape( + src: str, pos: Pos, *, multiline: bool = False +) -> tuple[Pos, str]: + escape_id = src[pos : pos + 2] + pos += 2 + if multiline and escape_id in {"\\ ", "\\\t", "\\\n"}: + # Skip whitespace until next non-whitespace character or end of + # the doc. Error if non-whitespace is found before newline. + if escape_id != "\\\n": + pos = skip_chars(src, pos, TOML_WS) + try: + char = src[pos] + except IndexError: + return pos, "" + if char != "\n": + raise suffixed_err(src, pos, "Unescaped '\\' in a string") + pos += 1 + pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE) + return pos, "" + if escape_id == "\\u": + return parse_hex_char(src, pos, 4) + if escape_id == "\\U": + return parse_hex_char(src, pos, 8) + try: + return pos, BASIC_STR_ESCAPE_REPLACEMENTS[escape_id] + except KeyError: + raise suffixed_err(src, pos, "Unescaped '\\' in a string") from None + + +def parse_basic_str_escape_multiline(src: str, pos: Pos) -> tuple[Pos, str]: + return parse_basic_str_escape(src, pos, multiline=True) + + +def parse_hex_char(src: str, pos: Pos, hex_len: int) -> tuple[Pos, str]: + hex_str = src[pos : pos + hex_len] + if len(hex_str) != hex_len or not HEXDIGIT_CHARS.issuperset(hex_str): + raise suffixed_err(src, pos, "Invalid hex value") + pos += hex_len + hex_int = int(hex_str, 16) + if not is_unicode_scalar_value(hex_int): + raise suffixed_err(src, pos, "Escaped character is not a Unicode scalar value") + return pos, chr(hex_int) + + +def parse_literal_str(src: str, pos: Pos) -> tuple[Pos, str]: + pos += 1 # Skip starting apostrophe + start_pos = pos + pos = skip_until( + src, pos, "'", error_on=ILLEGAL_LITERAL_STR_CHARS, error_on_eof=True + ) + return pos + 1, src[start_pos:pos] # Skip ending apostrophe + + +def parse_multiline_str(src: str, pos: Pos, *, literal: bool) -> tuple[Pos, str]: + pos += 3 + if src.startswith("\n", pos): + pos += 1 + + if literal: + delim = "'" + end_pos = skip_until( + src, + pos, + "'''", + error_on=ILLEGAL_MULTILINE_LITERAL_STR_CHARS, + error_on_eof=True, + ) + result = src[pos:end_pos] + pos = end_pos + 3 + else: + delim = '"' + pos, result = parse_basic_str(src, pos, multiline=True) + + # Add at maximum two extra apostrophes/quotes if the end sequence + # is 4 or 5 chars long instead of just 3. + if not src.startswith(delim, pos): + return pos, result + pos += 1 + if not src.startswith(delim, pos): + return pos, result + delim + pos += 1 + return pos, result + (delim * 2) + + +def parse_basic_str(src: str, pos: Pos, *, multiline: bool) -> tuple[Pos, str]: + if multiline: + error_on = ILLEGAL_MULTILINE_BASIC_STR_CHARS + parse_escapes = parse_basic_str_escape_multiline + else: + error_on = ILLEGAL_BASIC_STR_CHARS + parse_escapes = parse_basic_str_escape + result = "" + start_pos = pos + while True: + try: + char = src[pos] + except IndexError: + raise suffixed_err(src, pos, "Unterminated string") from None + if char == '"': + if not multiline: + return pos + 1, result + src[start_pos:pos] + if src.startswith('"""', pos): + return pos + 3, result + src[start_pos:pos] + pos += 1 + continue + if char == "\\": + result += src[start_pos:pos] + pos, parsed_escape = parse_escapes(src, pos) + result += parsed_escape + start_pos = pos + continue + if char in error_on: + raise suffixed_err(src, pos, f"Illegal character {char!r}") + pos += 1 + + +def parse_value( # noqa: C901 + src: str, pos: Pos, parse_float: ParseFloat +) -> tuple[Pos, Any]: + try: + char: str | None = src[pos] + except IndexError: + char = None + + # IMPORTANT: order conditions based on speed of checking and likelihood + + # Basic strings + if char == '"': + if src.startswith('"""', pos): + return parse_multiline_str(src, pos, literal=False) + return parse_one_line_basic_str(src, pos) + + # Literal strings + if char == "'": + if src.startswith("'''", pos): + return parse_multiline_str(src, pos, literal=True) + return parse_literal_str(src, pos) + + # Booleans + if char == "t": + if src.startswith("true", pos): + return pos + 4, True + if char == "f": + if src.startswith("false", pos): + return pos + 5, False + + # Arrays + if char == "[": + return parse_array(src, pos, parse_float) + + # Inline tables + if char == "{": + return parse_inline_table(src, pos, parse_float) + + # Dates and times + datetime_match = RE_DATETIME.match(src, pos) + if datetime_match: + try: + datetime_obj = match_to_datetime(datetime_match) + except ValueError as e: + raise suffixed_err(src, pos, "Invalid date or datetime") from e + return datetime_match.end(), datetime_obj + localtime_match = RE_LOCALTIME.match(src, pos) + if localtime_match: + return localtime_match.end(), match_to_localtime(localtime_match) + + # Integers and "normal" floats. + # The regex will greedily match any type starting with a decimal + # char, so needs to be located after handling of dates and times. + number_match = RE_NUMBER.match(src, pos) + if number_match: + return number_match.end(), match_to_number(number_match, parse_float) + + # Special floats + first_three = src[pos : pos + 3] + if first_three in {"inf", "nan"}: + return pos + 3, parse_float(first_three) + first_four = src[pos : pos + 4] + if first_four in {"-inf", "+inf", "-nan", "+nan"}: + return pos + 4, parse_float(first_four) + + raise suffixed_err(src, pos, "Invalid value") + + +def suffixed_err(src: str, pos: Pos, msg: str) -> TOMLDecodeError: + """Return a `TOMLDecodeError` where error message is suffixed with + coordinates in source.""" + + def coord_repr(src: str, pos: Pos) -> str: + if pos >= len(src): + return "end of document" + line = src.count("\n", 0, pos) + 1 + if line == 1: + column = pos + 1 + else: + column = pos - src.rindex("\n", 0, pos) + return f"line {line}, column {column}" + + return TOMLDecodeError(f"{msg} (at {coord_repr(src, pos)})") + + +def is_unicode_scalar_value(codepoint: int) -> bool: + return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111) + + +def make_safe_parse_float(parse_float: ParseFloat) -> ParseFloat: + """A decorator to make `parse_float` safe. + + `parse_float` must not return dicts or lists, because these types + would be mixed with parsed TOML tables and arrays, thus confusing + the parser. The returned decorated callable raises `ValueError` + instead of returning illegal types. + """ + # The default `float` callable never returns illegal types. Optimize it. + if parse_float is float: # type: ignore[comparison-overlap] + return float + + def safe_parse_float(float_str: str) -> Any: + float_value = parse_float(float_str) + if isinstance(float_value, (dict, list)): + raise ValueError("parse_float must not return dicts or lists") + return float_value + + return safe_parse_float diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/_re.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/_re.py new file mode 100644 index 0000000000000000000000000000000000000000..994bb7493fd92865e6ab87c277ba5741b44c31a9 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/_re.py @@ -0,0 +1,107 @@ +# SPDX-License-Identifier: MIT +# SPDX-FileCopyrightText: 2021 Taneli Hukkinen +# Licensed to PSF under a Contributor Agreement. + +from __future__ import annotations + +from datetime import date, datetime, time, timedelta, timezone, tzinfo +from functools import lru_cache +import re +from typing import Any + +from ._types import ParseFloat + +# E.g. +# - 00:32:00.999999 +# - 00:32:00 +_TIME_RE_STR = r"([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\.([0-9]{1,6})[0-9]*)?" + +RE_NUMBER = re.compile( + r""" +0 +(?: + x[0-9A-Fa-f](?:_?[0-9A-Fa-f])* # hex + | + b[01](?:_?[01])* # bin + | + o[0-7](?:_?[0-7])* # oct +) +| +[+-]?(?:0|[1-9](?:_?[0-9])*) # dec, integer part +(?P + (?:\.[0-9](?:_?[0-9])*)? # optional fractional part + (?:[eE][+-]?[0-9](?:_?[0-9])*)? # optional exponent part +) +""", + flags=re.VERBOSE, +) +RE_LOCALTIME = re.compile(_TIME_RE_STR) +RE_DATETIME = re.compile( + rf""" +([0-9]{{4}})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01]) # date, e.g. 1988-10-27 +(?: + [Tt ] + {_TIME_RE_STR} + (?:([Zz])|([+-])([01][0-9]|2[0-3]):([0-5][0-9]))? # optional time offset +)? +""", + flags=re.VERBOSE, +) + + +def match_to_datetime(match: re.Match) -> datetime | date: + """Convert a `RE_DATETIME` match to `datetime.datetime` or `datetime.date`. + + Raises ValueError if the match does not correspond to a valid date + or datetime. + """ + ( + year_str, + month_str, + day_str, + hour_str, + minute_str, + sec_str, + micros_str, + zulu_time, + offset_sign_str, + offset_hour_str, + offset_minute_str, + ) = match.groups() + year, month, day = int(year_str), int(month_str), int(day_str) + if hour_str is None: + return date(year, month, day) + hour, minute, sec = int(hour_str), int(minute_str), int(sec_str) + micros = int(micros_str.ljust(6, "0")) if micros_str else 0 + if offset_sign_str: + tz: tzinfo | None = cached_tz( + offset_hour_str, offset_minute_str, offset_sign_str + ) + elif zulu_time: + tz = timezone.utc + else: # local date-time + tz = None + return datetime(year, month, day, hour, minute, sec, micros, tzinfo=tz) + + +@lru_cache(maxsize=None) +def cached_tz(hour_str: str, minute_str: str, sign_str: str) -> timezone: + sign = 1 if sign_str == "+" else -1 + return timezone( + timedelta( + hours=sign * int(hour_str), + minutes=sign * int(minute_str), + ) + ) + + +def match_to_localtime(match: re.Match) -> time: + hour_str, minute_str, sec_str, micros_str = match.groups() + micros = int(micros_str.ljust(6, "0")) if micros_str else 0 + return time(int(hour_str), int(minute_str), int(sec_str), micros) + + +def match_to_number(match: re.Match, parse_float: ParseFloat) -> Any: + if match.group("floatpart"): + return parse_float(match.group()) + return int(match.group(), 0) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/_types.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/_types.py new file mode 100644 index 0000000000000000000000000000000000000000..d949412e03b29d70592c7721fe747e5085c2e280 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tomllib/_types.py @@ -0,0 +1,10 @@ +# SPDX-License-Identifier: MIT +# SPDX-FileCopyrightText: 2021 Taneli Hukkinen +# Licensed to PSF under a Contributor Agreement. + +from typing import Any, Callable, Tuple + +# Type annotations +ParseFloat = Callable[[str], Any] +Key = Tuple[str, ...] +Pos = int diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/trace.py b/physworld_p1_20261018/envs/p1/lib/python3.11/trace.py new file mode 100644 index 0000000000000000000000000000000000000000..761916b18097d65df9a8bd85477ceba89897b140 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/trace.py @@ -0,0 +1,740 @@ +#!/usr/bin/env python3 + +# portions copyright 2001, Autonomous Zones Industries, Inc., all rights... +# err... reserved and offered to the public under the terms of the +# Python 2.2 license. +# Author: Zooko O'Whielacronx +# http://zooko.com/ +# mailto:zooko@zooko.com +# +# Copyright 2000, Mojam Media, Inc., all rights reserved. +# Author: Skip Montanaro +# +# Copyright 1999, Bioreason, Inc., all rights reserved. +# Author: Andrew Dalke +# +# Copyright 1995-1997, Automatrix, Inc., all rights reserved. +# Author: Skip Montanaro +# +# Copyright 1991-1995, Stichting Mathematisch Centrum, all rights reserved. +# +# +# Permission to use, copy, modify, and distribute this Python software and +# its associated documentation for any purpose without fee is hereby +# granted, provided that the above copyright notice appears in all copies, +# and that both that copyright notice and this permission notice appear in +# supporting documentation, and that the name of neither Automatrix, +# Bioreason or Mojam Media be used in advertising or publicity pertaining to +# distribution of the software without specific, written prior permission. +# +"""program/module to trace Python program or function execution + +Sample use, command line: + trace.py -c -f counts --ignore-dir '$prefix' spam.py eggs + trace.py -t --ignore-dir '$prefix' spam.py eggs + trace.py --trackcalls spam.py eggs + +Sample use, programmatically + import sys + + # create a Trace object, telling it what to ignore, and whether to + # do tracing or line-counting or both. + tracer = trace.Trace(ignoredirs=[sys.base_prefix, sys.base_exec_prefix,], + trace=0, count=1) + # run the new command using the given tracer + tracer.run('main()') + # make a report, placing output in /tmp + r = tracer.results() + r.write_results(show_missing=True, coverdir="/tmp") +""" +__all__ = ['Trace', 'CoverageResults'] + +import io +import linecache +import os +import sys +import sysconfig +import token +import tokenize +import inspect +import gc +import dis +import pickle +from time import monotonic as _time + +import threading + +PRAGMA_NOCOVER = "#pragma NO COVER" + +class _Ignore: + def __init__(self, modules=None, dirs=None): + self._mods = set() if not modules else set(modules) + self._dirs = [] if not dirs else [os.path.normpath(d) + for d in dirs] + self._ignore = { '': 1 } + + def names(self, filename, modulename): + if modulename in self._ignore: + return self._ignore[modulename] + + # haven't seen this one before, so see if the module name is + # on the ignore list. + if modulename in self._mods: # Identical names, so ignore + self._ignore[modulename] = 1 + return 1 + + # check if the module is a proper submodule of something on + # the ignore list + for mod in self._mods: + # Need to take some care since ignoring + # "cmp" mustn't mean ignoring "cmpcache" but ignoring + # "Spam" must also mean ignoring "Spam.Eggs". + if modulename.startswith(mod + '.'): + self._ignore[modulename] = 1 + return 1 + + # Now check that filename isn't in one of the directories + if filename is None: + # must be a built-in, so we must ignore + self._ignore[modulename] = 1 + return 1 + + # Ignore a file when it contains one of the ignorable paths + for d in self._dirs: + # The '+ os.sep' is to ensure that d is a parent directory, + # as compared to cases like: + # d = "/usr/local" + # filename = "/usr/local.py" + # or + # d = "/usr/local.py" + # filename = "/usr/local.py" + if filename.startswith(d + os.sep): + self._ignore[modulename] = 1 + return 1 + + # Tried the different ways, so we don't ignore this module + self._ignore[modulename] = 0 + return 0 + +def _modname(path): + """Return a plausible module name for the path.""" + + base = os.path.basename(path) + filename, ext = os.path.splitext(base) + return filename + +def _fullmodname(path): + """Return a plausible module name for the path.""" + + # If the file 'path' is part of a package, then the filename isn't + # enough to uniquely identify it. Try to do the right thing by + # looking in sys.path for the longest matching prefix. We'll + # assume that the rest is the package name. + + comparepath = os.path.normcase(path) + longest = "" + for dir in sys.path: + dir = os.path.normcase(dir) + if comparepath.startswith(dir) and comparepath[len(dir)] == os.sep: + if len(dir) > len(longest): + longest = dir + + if longest: + base = path[len(longest) + 1:] + else: + base = path + # the drive letter is never part of the module name + drive, base = os.path.splitdrive(base) + base = base.replace(os.sep, ".") + if os.altsep: + base = base.replace(os.altsep, ".") + filename, ext = os.path.splitext(base) + return filename.lstrip(".") + +class CoverageResults: + def __init__(self, counts=None, calledfuncs=None, infile=None, + callers=None, outfile=None): + self.counts = counts + if self.counts is None: + self.counts = {} + self.counter = self.counts.copy() # map (filename, lineno) to count + self.calledfuncs = calledfuncs + if self.calledfuncs is None: + self.calledfuncs = {} + self.calledfuncs = self.calledfuncs.copy() + self.callers = callers + if self.callers is None: + self.callers = {} + self.callers = self.callers.copy() + self.infile = infile + self.outfile = outfile + if self.infile: + # Try to merge existing counts file. + try: + with open(self.infile, 'rb') as f: + counts, calledfuncs, callers = pickle.load(f) + self.update(self.__class__(counts, calledfuncs, callers=callers)) + except (OSError, EOFError, ValueError) as err: + print(("Skipping counts file %r: %s" + % (self.infile, err)), file=sys.stderr) + + def is_ignored_filename(self, filename): + """Return True if the filename does not refer to a file + we want to have reported. + """ + return filename.startswith('<') and filename.endswith('>') + + def update(self, other): + """Merge in the data from another CoverageResults""" + counts = self.counts + calledfuncs = self.calledfuncs + callers = self.callers + other_counts = other.counts + other_calledfuncs = other.calledfuncs + other_callers = other.callers + + for key in other_counts: + counts[key] = counts.get(key, 0) + other_counts[key] + + for key in other_calledfuncs: + calledfuncs[key] = 1 + + for key in other_callers: + callers[key] = 1 + + def write_results(self, show_missing=True, summary=False, coverdir=None): + """ + Write the coverage results. + + :param show_missing: Show lines that had no hits. + :param summary: Include coverage summary per module. + :param coverdir: If None, the results of each module are placed in its + directory, otherwise it is included in the directory + specified. + """ + if self.calledfuncs: + print() + print("functions called:") + calls = self.calledfuncs + for filename, modulename, funcname in sorted(calls): + print(("filename: %s, modulename: %s, funcname: %s" + % (filename, modulename, funcname))) + + if self.callers: + print() + print("calling relationships:") + lastfile = lastcfile = "" + for ((pfile, pmod, pfunc), (cfile, cmod, cfunc)) \ + in sorted(self.callers): + if pfile != lastfile: + print() + print("***", pfile, "***") + lastfile = pfile + lastcfile = "" + if cfile != pfile and lastcfile != cfile: + print(" -->", cfile) + lastcfile = cfile + print(" %s.%s -> %s.%s" % (pmod, pfunc, cmod, cfunc)) + + # turn the counts data ("(filename, lineno) = count") into something + # accessible on a per-file basis + per_file = {} + for filename, lineno in self.counts: + lines_hit = per_file[filename] = per_file.get(filename, {}) + lines_hit[lineno] = self.counts[(filename, lineno)] + + # accumulate summary info, if needed + sums = {} + + for filename, count in per_file.items(): + if self.is_ignored_filename(filename): + continue + + if filename.endswith(".pyc"): + filename = filename[:-1] + + if coverdir is None: + dir = os.path.dirname(os.path.abspath(filename)) + modulename = _modname(filename) + else: + dir = coverdir + os.makedirs(dir, exist_ok=True) + modulename = _fullmodname(filename) + + # If desired, get a list of the line numbers which represent + # executable content (returned as a dict for better lookup speed) + if show_missing: + lnotab = _find_executable_linenos(filename) + else: + lnotab = {} + source = linecache.getlines(filename) + coverpath = os.path.join(dir, modulename + ".cover") + with open(filename, 'rb') as fp: + encoding, _ = tokenize.detect_encoding(fp.readline) + n_hits, n_lines = self.write_results_file(coverpath, source, + lnotab, count, encoding) + if summary and n_lines: + percent = int(100 * n_hits / n_lines) + sums[modulename] = n_lines, percent, modulename, filename + + + if summary and sums: + print("lines cov% module (path)") + for m in sorted(sums): + n_lines, percent, modulename, filename = sums[m] + print("%5d %3d%% %s (%s)" % sums[m]) + + if self.outfile: + # try and store counts and module info into self.outfile + try: + with open(self.outfile, 'wb') as f: + pickle.dump((self.counts, self.calledfuncs, self.callers), + f, 1) + except OSError as err: + print("Can't save counts files because %s" % err, file=sys.stderr) + + def write_results_file(self, path, lines, lnotab, lines_hit, encoding=None): + """Return a coverage results file in path.""" + # ``lnotab`` is a dict of executable lines, or a line number "table" + + try: + outfile = open(path, "w", encoding=encoding) + except OSError as err: + print(("trace: Could not open %r for writing: %s " + "- skipping" % (path, err)), file=sys.stderr) + return 0, 0 + + n_lines = 0 + n_hits = 0 + with outfile: + for lineno, line in enumerate(lines, 1): + # do the blank/comment match to try to mark more lines + # (help the reader find stuff that hasn't been covered) + if lineno in lines_hit: + outfile.write("%5d: " % lines_hit[lineno]) + n_hits += 1 + n_lines += 1 + elif lineno in lnotab and not PRAGMA_NOCOVER in line: + # Highlight never-executed lines, unless the line contains + # #pragma: NO COVER + outfile.write(">>>>>> ") + n_lines += 1 + else: + outfile.write(" ") + outfile.write(line.expandtabs(8)) + + return n_hits, n_lines + +def _find_lines_from_code(code, strs): + """Return dict where keys are lines in the line number table.""" + linenos = {} + + for _, lineno in dis.findlinestarts(code): + if lineno not in strs: + linenos[lineno] = 1 + + return linenos + +def _find_lines(code, strs): + """Return lineno dict for all code objects reachable from code.""" + # get all of the lineno information from the code of this scope level + linenos = _find_lines_from_code(code, strs) + + # and check the constants for references to other code objects + for c in code.co_consts: + if inspect.iscode(c): + # find another code object, so recurse into it + linenos.update(_find_lines(c, strs)) + return linenos + +def _find_strings(filename, encoding=None): + """Return a dict of possible docstring positions. + + The dict maps line numbers to strings. There is an entry for + line that contains only a string or a part of a triple-quoted + string. + """ + d = {} + # If the first token is a string, then it's the module docstring. + # Add this special case so that the test in the loop passes. + prev_ttype = token.INDENT + with open(filename, encoding=encoding) as f: + tok = tokenize.generate_tokens(f.readline) + for ttype, tstr, start, end, line in tok: + if ttype == token.STRING: + if prev_ttype == token.INDENT: + sline, scol = start + eline, ecol = end + for i in range(sline, eline + 1): + d[i] = 1 + prev_ttype = ttype + return d + +def _find_executable_linenos(filename): + """Return dict where keys are line numbers in the line number table.""" + try: + with tokenize.open(filename) as f: + prog = f.read() + encoding = f.encoding + except OSError as err: + print(("Not printing coverage data for %r: %s" + % (filename, err)), file=sys.stderr) + return {} + code = compile(prog, filename, "exec") + strs = _find_strings(filename, encoding) + return _find_lines(code, strs) + +class Trace: + def __init__(self, count=1, trace=1, countfuncs=0, countcallers=0, + ignoremods=(), ignoredirs=(), infile=None, outfile=None, + timing=False): + """ + @param count true iff it should count number of times each + line is executed + @param trace true iff it should print out each line that is + being counted + @param countfuncs true iff it should just output a list of + (filename, modulename, funcname,) for functions + that were called at least once; This overrides + `count' and `trace' + @param ignoremods a list of the names of modules to ignore + @param ignoredirs a list of the names of directories to ignore + all of the (recursive) contents of + @param infile file from which to read stored counts to be + added into the results + @param outfile file in which to write the results + @param timing true iff timing information be displayed + """ + self.infile = infile + self.outfile = outfile + self.ignore = _Ignore(ignoremods, ignoredirs) + self.counts = {} # keys are (filename, linenumber) + self.pathtobasename = {} # for memoizing os.path.basename + self.donothing = 0 + self.trace = trace + self._calledfuncs = {} + self._callers = {} + self._caller_cache = {} + self.start_time = None + if timing: + self.start_time = _time() + if countcallers: + self.globaltrace = self.globaltrace_trackcallers + elif countfuncs: + self.globaltrace = self.globaltrace_countfuncs + elif trace and count: + self.globaltrace = self.globaltrace_lt + self.localtrace = self.localtrace_trace_and_count + elif trace: + self.globaltrace = self.globaltrace_lt + self.localtrace = self.localtrace_trace + elif count: + self.globaltrace = self.globaltrace_lt + self.localtrace = self.localtrace_count + else: + # Ahem -- do nothing? Okay. + self.donothing = 1 + + def run(self, cmd): + import __main__ + dict = __main__.__dict__ + self.runctx(cmd, dict, dict) + + def runctx(self, cmd, globals=None, locals=None): + if globals is None: globals = {} + if locals is None: locals = {} + if not self.donothing: + threading.settrace(self.globaltrace) + sys.settrace(self.globaltrace) + try: + exec(cmd, globals, locals) + finally: + if not self.donothing: + sys.settrace(None) + threading.settrace(None) + + def runfunc(self, func, /, *args, **kw): + result = None + if not self.donothing: + sys.settrace(self.globaltrace) + try: + result = func(*args, **kw) + finally: + if not self.donothing: + sys.settrace(None) + return result + + def file_module_function_of(self, frame): + code = frame.f_code + filename = code.co_filename + if filename: + modulename = _modname(filename) + else: + modulename = None + + funcname = code.co_name + clsname = None + if code in self._caller_cache: + if self._caller_cache[code] is not None: + clsname = self._caller_cache[code] + else: + self._caller_cache[code] = None + ## use of gc.get_referrers() was suggested by Michael Hudson + # all functions which refer to this code object + funcs = [f for f in gc.get_referrers(code) + if inspect.isfunction(f)] + # require len(func) == 1 to avoid ambiguity caused by calls to + # new.function(): "In the face of ambiguity, refuse the + # temptation to guess." + if len(funcs) == 1: + dicts = [d for d in gc.get_referrers(funcs[0]) + if isinstance(d, dict)] + if len(dicts) == 1: + classes = [c for c in gc.get_referrers(dicts[0]) + if hasattr(c, "__bases__")] + if len(classes) == 1: + # ditto for new.classobj() + clsname = classes[0].__name__ + # cache the result - assumption is that new.* is + # not called later to disturb this relationship + # _caller_cache could be flushed if functions in + # the new module get called. + self._caller_cache[code] = clsname + if clsname is not None: + funcname = "%s.%s" % (clsname, funcname) + + return filename, modulename, funcname + + def globaltrace_trackcallers(self, frame, why, arg): + """Handler for call events. + + Adds information about who called who to the self._callers dict. + """ + if why == 'call': + # XXX Should do a better job of identifying methods + this_func = self.file_module_function_of(frame) + parent_func = self.file_module_function_of(frame.f_back) + self._callers[(parent_func, this_func)] = 1 + + def globaltrace_countfuncs(self, frame, why, arg): + """Handler for call events. + + Adds (filename, modulename, funcname) to the self._calledfuncs dict. + """ + if why == 'call': + this_func = self.file_module_function_of(frame) + self._calledfuncs[this_func] = 1 + + def globaltrace_lt(self, frame, why, arg): + """Handler for call events. + + If the code block being entered is to be ignored, returns `None', + else returns self.localtrace. + """ + if why == 'call': + code = frame.f_code + filename = frame.f_globals.get('__file__', None) + if filename: + # XXX _modname() doesn't work right for packages, so + # the ignore support won't work right for packages + modulename = _modname(filename) + if modulename is not None: + ignore_it = self.ignore.names(filename, modulename) + if not ignore_it: + if self.trace: + print((" --- modulename: %s, funcname: %s" + % (modulename, code.co_name))) + return self.localtrace + else: + return None + + def localtrace_trace_and_count(self, frame, why, arg): + if why == "line": + # record the file name and line number of every trace + filename = frame.f_code.co_filename + lineno = frame.f_lineno + key = filename, lineno + self.counts[key] = self.counts.get(key, 0) + 1 + + if self.start_time: + print('%.2f' % (_time() - self.start_time), end=' ') + bname = os.path.basename(filename) + print("%s(%d): %s" % (bname, lineno, + linecache.getline(filename, lineno)), end='') + return self.localtrace + + def localtrace_trace(self, frame, why, arg): + if why == "line": + # record the file name and line number of every trace + filename = frame.f_code.co_filename + lineno = frame.f_lineno + + if self.start_time: + print('%.2f' % (_time() - self.start_time), end=' ') + bname = os.path.basename(filename) + print("%s(%d): %s" % (bname, lineno, + linecache.getline(filename, lineno)), end='') + return self.localtrace + + def localtrace_count(self, frame, why, arg): + if why == "line": + filename = frame.f_code.co_filename + lineno = frame.f_lineno + key = filename, lineno + self.counts[key] = self.counts.get(key, 0) + 1 + return self.localtrace + + def results(self): + return CoverageResults(self.counts, infile=self.infile, + outfile=self.outfile, + calledfuncs=self._calledfuncs, + callers=self._callers) + +def main(): + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument('--version', action='version', version='trace 2.0') + + grp = parser.add_argument_group('Main options', + 'One of these (or --report) must be given') + + grp.add_argument('-c', '--count', action='store_true', + help='Count the number of times each line is executed and write ' + 'the counts to .cover for each module executed, in ' + 'the module\'s directory. See also --coverdir, --file, ' + '--no-report below.') + grp.add_argument('-t', '--trace', action='store_true', + help='Print each line to sys.stdout before it is executed') + grp.add_argument('-l', '--listfuncs', action='store_true', + help='Keep track of which functions are executed at least once ' + 'and write the results to sys.stdout after the program exits. ' + 'Cannot be specified alongside --trace or --count.') + grp.add_argument('-T', '--trackcalls', action='store_true', + help='Keep track of caller/called pairs and write the results to ' + 'sys.stdout after the program exits.') + + grp = parser.add_argument_group('Modifiers') + + _grp = grp.add_mutually_exclusive_group() + _grp.add_argument('-r', '--report', action='store_true', + help='Generate a report from a counts file; does not execute any ' + 'code. --file must specify the results file to read, which ' + 'must have been created in a previous run with --count ' + '--file=FILE') + _grp.add_argument('-R', '--no-report', action='store_true', + help='Do not generate the coverage report files. ' + 'Useful if you want to accumulate over several runs.') + + grp.add_argument('-f', '--file', + help='File to accumulate counts over several runs') + grp.add_argument('-C', '--coverdir', + help='Directory where the report files go. The coverage report ' + 'for . will be written to file ' + '//.cover') + grp.add_argument('-m', '--missing', action='store_true', + help='Annotate executable lines that were not executed with ' + '">>>>>> "') + grp.add_argument('-s', '--summary', action='store_true', + help='Write a brief summary for each file to sys.stdout. ' + 'Can only be used with --count or --report') + grp.add_argument('-g', '--timing', action='store_true', + help='Prefix each line with the time since the program started. ' + 'Only used while tracing') + + grp = parser.add_argument_group('Filters', + 'Can be specified multiple times') + grp.add_argument('--ignore-module', action='append', default=[], + help='Ignore the given module(s) and its submodules ' + '(if it is a package). Accepts comma separated list of ' + 'module names.') + grp.add_argument('--ignore-dir', action='append', default=[], + help='Ignore files in the given directory ' + '(multiple directories can be joined by os.pathsep).') + + parser.add_argument('--module', action='store_true', default=False, + help='Trace a module. ') + parser.add_argument('progname', nargs='?', + help='file to run as main program') + parser.add_argument('arguments', nargs=argparse.REMAINDER, + help='arguments to the program') + + opts = parser.parse_args() + + if opts.ignore_dir: + _prefix = sysconfig.get_path("stdlib") + _exec_prefix = sysconfig.get_path("platstdlib") + + def parse_ignore_dir(s): + s = os.path.expanduser(os.path.expandvars(s)) + s = s.replace('$prefix', _prefix).replace('$exec_prefix', _exec_prefix) + return os.path.normpath(s) + + opts.ignore_module = [mod.strip() + for i in opts.ignore_module for mod in i.split(',')] + opts.ignore_dir = [parse_ignore_dir(s) + for i in opts.ignore_dir for s in i.split(os.pathsep)] + + if opts.report: + if not opts.file: + parser.error('-r/--report requires -f/--file') + results = CoverageResults(infile=opts.file, outfile=opts.file) + return results.write_results(opts.missing, opts.summary, opts.coverdir) + + if not any([opts.trace, opts.count, opts.listfuncs, opts.trackcalls]): + parser.error('must specify one of --trace, --count, --report, ' + '--listfuncs, or --trackcalls') + + if opts.listfuncs and (opts.count or opts.trace): + parser.error('cannot specify both --listfuncs and (--trace or --count)') + + if opts.summary and not opts.count: + parser.error('--summary can only be used with --count or --report') + + if opts.progname is None: + parser.error('progname is missing: required with the main options') + + t = Trace(opts.count, opts.trace, countfuncs=opts.listfuncs, + countcallers=opts.trackcalls, ignoremods=opts.ignore_module, + ignoredirs=opts.ignore_dir, infile=opts.file, + outfile=opts.file, timing=opts.timing) + try: + if opts.module: + import runpy + module_name = opts.progname + mod_name, mod_spec, code = runpy._get_module_details(module_name) + sys.argv = [code.co_filename, *opts.arguments] + globs = { + '__name__': '__main__', + '__file__': code.co_filename, + '__package__': mod_spec.parent, + '__loader__': mod_spec.loader, + '__spec__': mod_spec, + '__cached__': None, + } + else: + sys.argv = [opts.progname, *opts.arguments] + sys.path[0] = os.path.dirname(opts.progname) + + with io.open_code(opts.progname) as fp: + code = compile(fp.read(), opts.progname, 'exec') + # try to emulate __main__ namespace as much as possible + globs = { + '__file__': opts.progname, + '__name__': '__main__', + '__package__': None, + '__cached__': None, + } + t.runctx(code, globs, globs) + except OSError as err: + sys.exit("Cannot run file %r because: %s" % (sys.argv[0], err)) + except SystemExit: + pass + + results = t.results() + + if not opts.no_report: + results.write_results(opts.missing, opts.summary, opts.coverdir) + +if __name__=='__main__': + main() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/traceback.py b/physworld_p1_20261018/envs/p1/lib/python3.11/traceback.py new file mode 100644 index 0000000000000000000000000000000000000000..e7026e545cb1b48d2cf102d84cda5a25ab4e91c9 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/traceback.py @@ -0,0 +1,1022 @@ +"""Extract, format and print information about Python stack traces.""" + +import collections.abc +import itertools +import linecache +import sys +import textwrap +from contextlib import suppress + +__all__ = ['extract_stack', 'extract_tb', 'format_exception', + 'format_exception_only', 'format_list', 'format_stack', + 'format_tb', 'print_exc', 'format_exc', 'print_exception', + 'print_last', 'print_stack', 'print_tb', 'clear_frames', + 'FrameSummary', 'StackSummary', 'TracebackException', + 'walk_stack', 'walk_tb'] + +# +# Formatting and printing lists of traceback lines. +# + +def print_list(extracted_list, file=None): + """Print the list of tuples as returned by extract_tb() or + extract_stack() as a formatted stack trace to the given file.""" + if file is None: + file = sys.stderr + for item in StackSummary.from_list(extracted_list).format(): + print(item, file=file, end="") + +def format_list(extracted_list): + """Format a list of tuples or FrameSummary objects for printing. + + Given a list of tuples or FrameSummary objects as returned by + extract_tb() or extract_stack(), return a list of strings ready + for printing. + + Each string in the resulting list corresponds to the item with the + same index in the argument list. Each string ends in a newline; + the strings may contain internal newlines as well, for those items + whose source text line is not None. + """ + return StackSummary.from_list(extracted_list).format() + +# +# Printing and Extracting Tracebacks. +# + +def print_tb(tb, limit=None, file=None): + """Print up to 'limit' stack trace entries from the traceback 'tb'. + + If 'limit' is omitted or None, all entries are printed. If 'file' + is omitted or None, the output goes to sys.stderr; otherwise + 'file' should be an open file or file-like object with a write() + method. + """ + print_list(extract_tb(tb, limit=limit), file=file) + +def format_tb(tb, limit=None): + """A shorthand for 'format_list(extract_tb(tb, limit))'.""" + return extract_tb(tb, limit=limit).format() + +def extract_tb(tb, limit=None): + """ + Return a StackSummary object representing a list of + pre-processed entries from traceback. + + This is useful for alternate formatting of stack traces. If + 'limit' is omitted or None, all entries are extracted. A + pre-processed stack trace entry is a FrameSummary object + containing attributes filename, lineno, name, and line + representing the information that is usually printed for a stack + trace. The line is a string with leading and trailing + whitespace stripped; if the source is not available it is None. + """ + return StackSummary._extract_from_extended_frame_gen( + _walk_tb_with_full_positions(tb), limit=limit) + +# +# Exception formatting and output. +# + +_cause_message = ( + "\nThe above exception was the direct cause " + "of the following exception:\n\n") + +_context_message = ( + "\nDuring handling of the above exception, " + "another exception occurred:\n\n") + + +class _Sentinel: + def __repr__(self): + return "" + +_sentinel = _Sentinel() + +def _parse_value_tb(exc, value, tb): + if (value is _sentinel) != (tb is _sentinel): + raise ValueError("Both or neither of value and tb must be given") + if value is tb is _sentinel: + if exc is not None: + if isinstance(exc, BaseException): + return exc, exc.__traceback__ + + raise TypeError(f'Exception expected for value, ' + f'{type(exc).__name__} found') + else: + return None, None + return value, tb + + +def print_exception(exc, /, value=_sentinel, tb=_sentinel, limit=None, \ + file=None, chain=True): + """Print exception up to 'limit' stack trace entries from 'tb' to 'file'. + + This differs from print_tb() in the following ways: (1) if + traceback is not None, it prints a header "Traceback (most recent + call last):"; (2) it prints the exception type and value after the + stack trace; (3) if type is SyntaxError and value has the + appropriate format, it prints the line where the syntax error + occurred with a caret on the next line indicating the approximate + position of the error. + """ + value, tb = _parse_value_tb(exc, value, tb) + te = TracebackException(type(value), value, tb, limit=limit, compact=True) + te.print(file=file, chain=chain) + + +def format_exception(exc, /, value=_sentinel, tb=_sentinel, limit=None, \ + chain=True): + """Format a stack trace and the exception information. + + The arguments have the same meaning as the corresponding arguments + to print_exception(). The return value is a list of strings, each + ending in a newline and some containing internal newlines. When + these lines are concatenated and printed, exactly the same text is + printed as does print_exception(). + """ + value, tb = _parse_value_tb(exc, value, tb) + te = TracebackException(type(value), value, tb, limit=limit, compact=True) + return list(te.format(chain=chain)) + + +def format_exception_only(exc, /, value=_sentinel): + """Format the exception part of a traceback. + + The return value is a list of strings, each ending in a newline. + + The list contains the exception's message, which is + normally a single string; however, for :exc:`SyntaxError` exceptions, it + contains several lines that (when printed) display detailed information + about where the syntax error occurred. Following the message, the list + contains the exception's ``__notes__``. + """ + if value is _sentinel: + value = exc + te = TracebackException(type(value), value, None, compact=True) + return list(te.format_exception_only()) + + +# -- not official API but folk probably use these two functions. + +def _format_final_exc_line(etype, value): + valuestr = _safe_string(value, 'exception') + if value is None or not valuestr: + line = "%s\n" % etype + else: + line = "%s: %s\n" % (etype, valuestr) + return line + +def _safe_string(value, what, func=str): + try: + return func(value) + except: + return f'<{what} {func.__name__}() failed>' + +# -- + +def print_exc(limit=None, file=None, chain=True): + """Shorthand for 'print_exception(*sys.exc_info(), limit, file)'.""" + print_exception(*sys.exc_info(), limit=limit, file=file, chain=chain) + +def format_exc(limit=None, chain=True): + """Like print_exc() but return a string.""" + return "".join(format_exception(*sys.exc_info(), limit=limit, chain=chain)) + +def print_last(limit=None, file=None, chain=True): + """This is a shorthand for 'print_exception(sys.last_type, + sys.last_value, sys.last_traceback, limit, file)'.""" + if not hasattr(sys, "last_type"): + raise ValueError("no last exception") + print_exception(sys.last_type, sys.last_value, sys.last_traceback, + limit, file, chain) + +# +# Printing and Extracting Stacks. +# + +def print_stack(f=None, limit=None, file=None): + """Print a stack trace from its invocation point. + + The optional 'f' argument can be used to specify an alternate + stack frame at which to start. The optional 'limit' and 'file' + arguments have the same meaning as for print_exception(). + """ + if f is None: + f = sys._getframe().f_back + print_list(extract_stack(f, limit=limit), file=file) + + +def format_stack(f=None, limit=None): + """Shorthand for 'format_list(extract_stack(f, limit))'.""" + if f is None: + f = sys._getframe().f_back + return format_list(extract_stack(f, limit=limit)) + + +def extract_stack(f=None, limit=None): + """Extract the raw traceback from the current stack frame. + + The return value has the same format as for extract_tb(). The + optional 'f' and 'limit' arguments have the same meaning as for + print_stack(). Each item in the list is a quadruple (filename, + line number, function name, text), and the entries are in order + from oldest to newest stack frame. + """ + if f is None: + f = sys._getframe().f_back + stack = StackSummary.extract(walk_stack(f), limit=limit) + stack.reverse() + return stack + + +def clear_frames(tb): + "Clear all references to local variables in the frames of a traceback." + while tb is not None: + try: + tb.tb_frame.clear() + except RuntimeError: + # Ignore the exception raised if the frame is still executing. + pass + tb = tb.tb_next + + +class FrameSummary: + """Information about a single frame from a traceback. + + - :attr:`filename` The filename for the frame. + - :attr:`lineno` The line within filename for the frame that was + active when the frame was captured. + - :attr:`name` The name of the function or method that was executing + when the frame was captured. + - :attr:`line` The text from the linecache module for the + of code that was running when the frame was captured. + - :attr:`locals` Either None if locals were not supplied, or a dict + mapping the name to the repr() of the variable. + """ + + __slots__ = ('filename', 'lineno', 'end_lineno', 'colno', 'end_colno', + 'name', '_line', 'locals') + + def __init__(self, filename, lineno, name, *, lookup_line=True, + locals=None, line=None, + end_lineno=None, colno=None, end_colno=None): + """Construct a FrameSummary. + + :param lookup_line: If True, `linecache` is consulted for the source + code line. Otherwise, the line will be looked up when first needed. + :param locals: If supplied the frame locals, which will be captured as + object representations. + :param line: If provided, use this instead of looking up the line in + the linecache. + """ + self.filename = filename + self.lineno = lineno + self.name = name + self._line = line + if lookup_line: + self.line + self.locals = {k: repr(v) for k, v in locals.items()} if locals else None + self.end_lineno = end_lineno + self.colno = colno + self.end_colno = end_colno + + def __eq__(self, other): + if isinstance(other, FrameSummary): + return (self.filename == other.filename and + self.lineno == other.lineno and + self.name == other.name and + self.locals == other.locals) + if isinstance(other, tuple): + return (self.filename, self.lineno, self.name, self.line) == other + return NotImplemented + + def __getitem__(self, pos): + return (self.filename, self.lineno, self.name, self.line)[pos] + + def __iter__(self): + return iter([self.filename, self.lineno, self.name, self.line]) + + def __repr__(self): + return "".format( + filename=self.filename, lineno=self.lineno, name=self.name) + + def __len__(self): + return 4 + + @property + def _original_line(self): + # Returns the line as-is from the source, without modifying whitespace. + self.line + return self._line + + @property + def line(self): + if self._line is None: + if self.lineno is None: + return None + self._line = linecache.getline(self.filename, self.lineno) + return self._line.strip() + + +def walk_stack(f): + """Walk a stack yielding the frame and line number for each frame. + + This will follow f.f_back from the given frame. If no frame is given, the + current stack is used. Usually used with StackSummary.extract. + """ + if f is None: + f = sys._getframe().f_back.f_back.f_back.f_back + while f is not None: + yield f, f.f_lineno + f = f.f_back + + +def walk_tb(tb): + """Walk a traceback yielding the frame and line number for each frame. + + This will follow tb.tb_next (and thus is in the opposite order to + walk_stack). Usually used with StackSummary.extract. + """ + while tb is not None: + yield tb.tb_frame, tb.tb_lineno + tb = tb.tb_next + + +def _walk_tb_with_full_positions(tb): + # Internal version of walk_tb that yields full code positions including + # end line and column information. + while tb is not None: + positions = _get_code_position(tb.tb_frame.f_code, tb.tb_lasti) + # Yield tb_lineno when co_positions does not have a line number to + # maintain behavior with walk_tb. + if positions[0] is None: + yield tb.tb_frame, (tb.tb_lineno, ) + positions[1:] + else: + yield tb.tb_frame, positions + tb = tb.tb_next + + +def _get_code_position(code, instruction_index): + if instruction_index < 0: + return (None, None, None, None) + positions_gen = code.co_positions() + return next(itertools.islice(positions_gen, instruction_index // 2, None)) + + +_RECURSIVE_CUTOFF = 3 # Also hardcoded in traceback.c. + +class StackSummary(list): + """A list of FrameSummary objects, representing a stack of frames.""" + + @classmethod + def extract(klass, frame_gen, *, limit=None, lookup_lines=True, + capture_locals=False): + """Create a StackSummary from a traceback or stack object. + + :param frame_gen: A generator that yields (frame, lineno) tuples + whose summaries are to be included in the stack. + :param limit: None to include all frames or the number of frames to + include. + :param lookup_lines: If True, lookup lines for each frame immediately, + otherwise lookup is deferred until the frame is rendered. + :param capture_locals: If True, the local variables from each frame will + be captured as object representations into the FrameSummary. + """ + def extended_frame_gen(): + for f, lineno in frame_gen: + yield f, (lineno, None, None, None) + + return klass._extract_from_extended_frame_gen( + extended_frame_gen(), limit=limit, lookup_lines=lookup_lines, + capture_locals=capture_locals) + + @classmethod + def _extract_from_extended_frame_gen(klass, frame_gen, *, limit=None, + lookup_lines=True, capture_locals=False): + # Same as extract but operates on a frame generator that yields + # (frame, (lineno, end_lineno, colno, end_colno)) in the stack. + # Only lineno is required, the remaining fields can be None if the + # information is not available. + if limit is None: + limit = getattr(sys, 'tracebacklimit', None) + if limit is not None and limit < 0: + limit = 0 + if limit is not None: + if limit >= 0: + frame_gen = itertools.islice(frame_gen, limit) + else: + frame_gen = collections.deque(frame_gen, maxlen=-limit) + + result = klass() + fnames = set() + for f, (lineno, end_lineno, colno, end_colno) in frame_gen: + co = f.f_code + filename = co.co_filename + name = co.co_name + + fnames.add(filename) + linecache.lazycache(filename, f.f_globals) + # Must defer line lookups until we have called checkcache. + if capture_locals: + f_locals = f.f_locals + else: + f_locals = None + result.append(FrameSummary( + filename, lineno, name, lookup_line=False, locals=f_locals, + end_lineno=end_lineno, colno=colno, end_colno=end_colno)) + for filename in fnames: + linecache.checkcache(filename) + # If immediate lookup was desired, trigger lookups now. + if lookup_lines: + for f in result: + f.line + return result + + @classmethod + def from_list(klass, a_list): + """ + Create a StackSummary object from a supplied list of + FrameSummary objects or old-style list of tuples. + """ + # While doing a fast-path check for isinstance(a_list, StackSummary) is + # appealing, idlelib.run.cleanup_traceback and other similar code may + # break this by making arbitrary frames plain tuples, so we need to + # check on a frame by frame basis. + result = StackSummary() + for frame in a_list: + if isinstance(frame, FrameSummary): + result.append(frame) + else: + filename, lineno, name, line = frame + result.append(FrameSummary(filename, lineno, name, line=line)) + return result + + def format_frame_summary(self, frame_summary): + """Format the lines for a single FrameSummary. + + Returns a string representing one frame involved in the stack. This + gets called for every frame to be printed in the stack summary. + """ + row = [] + row.append(' File "{}", line {}, in {}\n'.format( + frame_summary.filename, frame_summary.lineno, frame_summary.name)) + if frame_summary.line: + stripped_line = frame_summary.line.strip() + row.append(' {}\n'.format(stripped_line)) + + line = frame_summary._original_line + orig_line_len = len(line) + frame_line_len = len(frame_summary.line.lstrip()) + stripped_characters = orig_line_len - frame_line_len + if ( + frame_summary.colno is not None + and frame_summary.end_colno is not None + ): + start_offset = _byte_offset_to_character_offset( + line, frame_summary.colno) + end_offset = _byte_offset_to_character_offset( + line, frame_summary.end_colno) + code_segment = line[start_offset:end_offset] + + anchors = None + if frame_summary.lineno == frame_summary.end_lineno: + with suppress(Exception): + anchors = _extract_caret_anchors_from_line_segment(code_segment) + else: + # Don't count the newline since the anchors only need to + # go up until the last character of the line. + end_offset = len(line.rstrip()) + + # show indicators if primary char doesn't span the frame line + if end_offset - start_offset < len(stripped_line) or ( + anchors and anchors.right_start_offset - anchors.left_end_offset > 0): + # When showing this on a terminal, some of the non-ASCII characters + # might be rendered as double-width characters, so we need to take + # that into account when calculating the length of the line. + dp_start_offset = _display_width(line, start_offset) + 1 + dp_end_offset = _display_width(line, end_offset) + 1 + + row.append(' ') + row.append(' ' * (dp_start_offset - stripped_characters)) + + if anchors: + dp_left_end_offset = _display_width(code_segment, anchors.left_end_offset) + dp_right_start_offset = _display_width(code_segment, anchors.right_start_offset) + row.append(anchors.primary_char * dp_left_end_offset) + row.append(anchors.secondary_char * (dp_right_start_offset - dp_left_end_offset)) + row.append(anchors.primary_char * (dp_end_offset - dp_start_offset - dp_right_start_offset)) + else: + row.append('^' * (dp_end_offset - dp_start_offset)) + + row.append('\n') + + if frame_summary.locals: + for name, value in sorted(frame_summary.locals.items()): + row.append(' {name} = {value}\n'.format(name=name, value=value)) + + return ''.join(row) + + def format(self): + """Format the stack ready for printing. + + Returns a list of strings ready for printing. Each string in the + resulting list corresponds to a single frame from the stack. + Each string ends in a newline; the strings may contain internal + newlines as well, for those items with source text lines. + + For long sequences of the same frame and line, the first few + repetitions are shown, followed by a summary line stating the exact + number of further repetitions. + """ + result = [] + last_file = None + last_line = None + last_name = None + count = 0 + for frame_summary in self: + formatted_frame = self.format_frame_summary(frame_summary) + if formatted_frame is None: + continue + if (last_file is None or last_file != frame_summary.filename or + last_line is None or last_line != frame_summary.lineno or + last_name is None or last_name != frame_summary.name): + if count > _RECURSIVE_CUTOFF: + count -= _RECURSIVE_CUTOFF + result.append( + f' [Previous line repeated {count} more ' + f'time{"s" if count > 1 else ""}]\n' + ) + last_file = frame_summary.filename + last_line = frame_summary.lineno + last_name = frame_summary.name + count = 0 + count += 1 + if count > _RECURSIVE_CUTOFF: + continue + result.append(formatted_frame) + + if count > _RECURSIVE_CUTOFF: + count -= _RECURSIVE_CUTOFF + result.append( + f' [Previous line repeated {count} more ' + f'time{"s" if count > 1 else ""}]\n' + ) + return result + + +def _byte_offset_to_character_offset(str, offset): + as_utf8 = str.encode('utf-8') + return len(as_utf8[:offset].decode("utf-8", errors="replace")) + + +_Anchors = collections.namedtuple( + "_Anchors", + [ + "left_end_offset", + "right_start_offset", + "primary_char", + "secondary_char", + ], + defaults=["~", "^"] +) + +def _extract_caret_anchors_from_line_segment(segment): + import ast + + try: + tree = ast.parse(segment) + except SyntaxError: + return None + + if len(tree.body) != 1: + return None + + normalize = lambda offset: _byte_offset_to_character_offset(segment, offset) + statement = tree.body[0] + match statement: + case ast.Expr(expr): + match expr: + case ast.BinOp(): + operator_start = normalize(expr.left.end_col_offset) + operator_end = normalize(expr.right.col_offset) + operator_str = segment[operator_start:operator_end] + operator_offset = len(operator_str) - len(operator_str.lstrip()) + + left_anchor = expr.left.end_col_offset + operator_offset + right_anchor = left_anchor + 1 + if ( + operator_offset + 1 < len(operator_str) + and not operator_str[operator_offset + 1].isspace() + ): + right_anchor += 1 + + while left_anchor < len(segment) and ((ch := segment[left_anchor]).isspace() or ch in ")#"): + left_anchor += 1 + right_anchor += 1 + return _Anchors(normalize(left_anchor), normalize(right_anchor)) + case ast.Subscript(): + left_anchor = normalize(expr.value.end_col_offset) + right_anchor = normalize(expr.slice.end_col_offset + 1) + while left_anchor < len(segment) and ((ch := segment[left_anchor]).isspace() or ch != "["): + left_anchor += 1 + while right_anchor < len(segment) and ((ch := segment[right_anchor]).isspace() or ch != "]"): + right_anchor += 1 + if right_anchor < len(segment): + right_anchor += 1 + return _Anchors(left_anchor, right_anchor) + + return None + +_WIDE_CHAR_SPECIFIERS = "WF" + +def _display_width(line, offset): + """Calculate the extra amount of width space the given source + code segment might take if it were to be displayed on a fixed + width output device. Supports wide unicode characters and emojis.""" + + # Fast track for ASCII-only strings + if line.isascii(): + return offset + + import unicodedata + + return sum( + 2 if unicodedata.east_asian_width(char) in _WIDE_CHAR_SPECIFIERS else 1 + for char in line[:offset] + ) + + + +class _ExceptionPrintContext: + def __init__(self): + self.seen = set() + self.exception_group_depth = 0 + self.need_close = False + + def indent(self): + return ' ' * (2 * self.exception_group_depth) + + def emit(self, text_gen, margin_char=None): + if margin_char is None: + margin_char = '|' + indent_str = self.indent() + if self.exception_group_depth: + indent_str += margin_char + ' ' + + if isinstance(text_gen, str): + yield textwrap.indent(text_gen, indent_str, lambda line: True) + else: + for text in text_gen: + yield textwrap.indent(text, indent_str, lambda line: True) + + +class TracebackException: + """An exception ready for rendering. + + The traceback module captures enough attributes from the original exception + to this intermediary form to ensure that no references are held, while + still being able to fully print or format it. + + max_group_width and max_group_depth control the formatting of exception + groups. The depth refers to the nesting level of the group, and the width + refers to the size of a single exception group's exceptions array. The + formatted output is truncated when either limit is exceeded. + + Use `from_exception` to create TracebackException instances from exception + objects, or the constructor to create TracebackException instances from + individual components. + + - :attr:`__cause__` A TracebackException of the original *__cause__*. + - :attr:`__context__` A TracebackException of the original *__context__*. + - :attr:`exceptions` For exception groups - a list of TracebackException + instances for the nested *exceptions*. ``None`` for other exceptions. + - :attr:`__suppress_context__` The *__suppress_context__* value from the + original exception. + - :attr:`stack` A `StackSummary` representing the traceback. + - :attr:`exc_type` The class of the original traceback. + - :attr:`filename` For syntax errors - the filename where the error + occurred. + - :attr:`lineno` For syntax errors - the linenumber where the error + occurred. + - :attr:`end_lineno` For syntax errors - the end linenumber where the error + occurred. Can be `None` if not present. + - :attr:`text` For syntax errors - the text where the error + occurred. + - :attr:`offset` For syntax errors - the offset into the text where the + error occurred. + - :attr:`end_offset` For syntax errors - the end offset into the text where + the error occurred. Can be `None` if not present. + - :attr:`msg` For syntax errors - the compiler error message. + """ + + def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None, + lookup_lines=True, capture_locals=False, compact=False, + max_group_width=15, max_group_depth=10, _seen=None): + # NB: we need to accept exc_traceback, exc_value, exc_traceback to + # permit backwards compat with the existing API, otherwise we + # need stub thunk objects just to glue it together. + # Handle loops in __cause__ or __context__. + is_recursive_call = _seen is not None + if _seen is None: + _seen = set() + _seen.add(id(exc_value)) + + self.max_group_width = max_group_width + self.max_group_depth = max_group_depth + + self.stack = StackSummary._extract_from_extended_frame_gen( + _walk_tb_with_full_positions(exc_traceback), + limit=limit, lookup_lines=lookup_lines, + capture_locals=capture_locals) + self.exc_type = exc_type + # Capture now to permit freeing resources: only complication is in the + # unofficial API _format_final_exc_line + self._str = _safe_string(exc_value, 'exception') + try: + self.__notes__ = getattr(exc_value, '__notes__', None) + except Exception as e: + self.__notes__ = [ + f'Ignored error getting __notes__: {_safe_string(e, "__notes__", repr)}'] + + if exc_type and issubclass(exc_type, SyntaxError): + # Handle SyntaxError's specially + self.filename = exc_value.filename + lno = exc_value.lineno + self.lineno = str(lno) if lno is not None else None + end_lno = exc_value.end_lineno + self.end_lineno = str(end_lno) if end_lno is not None else None + self.text = exc_value.text + self.offset = exc_value.offset + self.end_offset = exc_value.end_offset + self.msg = exc_value.msg + if lookup_lines: + self._load_lines() + self.__suppress_context__ = \ + exc_value.__suppress_context__ if exc_value is not None else False + + # Convert __cause__ and __context__ to `TracebackExceptions`s, use a + # queue to avoid recursion (only the top-level call gets _seen == None) + if not is_recursive_call: + queue = [(self, exc_value)] + while queue: + te, e = queue.pop() + if (e and e.__cause__ is not None + and id(e.__cause__) not in _seen): + cause = TracebackException( + type(e.__cause__), + e.__cause__, + e.__cause__.__traceback__, + limit=limit, + lookup_lines=lookup_lines, + capture_locals=capture_locals, + max_group_width=max_group_width, + max_group_depth=max_group_depth, + _seen=_seen) + else: + cause = None + + if compact: + need_context = (cause is None and + e is not None and + not e.__suppress_context__) + else: + need_context = True + if (e and e.__context__ is not None + and need_context and id(e.__context__) not in _seen): + context = TracebackException( + type(e.__context__), + e.__context__, + e.__context__.__traceback__, + limit=limit, + lookup_lines=lookup_lines, + capture_locals=capture_locals, + max_group_width=max_group_width, + max_group_depth=max_group_depth, + _seen=_seen) + else: + context = None + + if e and isinstance(e, BaseExceptionGroup): + exceptions = [] + for exc in e.exceptions: + texc = TracebackException( + type(exc), + exc, + exc.__traceback__, + limit=limit, + lookup_lines=lookup_lines, + capture_locals=capture_locals, + max_group_width=max_group_width, + max_group_depth=max_group_depth, + _seen=_seen) + exceptions.append(texc) + else: + exceptions = None + + te.__cause__ = cause + te.__context__ = context + te.exceptions = exceptions + if cause: + queue.append((te.__cause__, e.__cause__)) + if context: + queue.append((te.__context__, e.__context__)) + if exceptions: + queue.extend(zip(te.exceptions, e.exceptions)) + + @classmethod + def from_exception(cls, exc, *args, **kwargs): + """Create a TracebackException from an exception.""" + return cls(type(exc), exc, exc.__traceback__, *args, **kwargs) + + def _load_lines(self): + """Private API. force all lines in the stack to be loaded.""" + for frame in self.stack: + frame.line + + def __eq__(self, other): + if isinstance(other, TracebackException): + return self.__dict__ == other.__dict__ + return NotImplemented + + def __str__(self): + return self._str + + def format_exception_only(self): + """Format the exception part of the traceback. + + The return value is a generator of strings, each ending in a newline. + + Generator yields the exception message. + For :exc:`SyntaxError` exceptions, it + also yields (before the exception message) + several lines that (when printed) + display detailed information about where the syntax error occurred. + Following the message, generator also yields + all the exception's ``__notes__``. + """ + if self.exc_type is None: + yield _format_final_exc_line(None, self._str) + return + + stype = self.exc_type.__qualname__ + smod = self.exc_type.__module__ + if smod not in ("__main__", "builtins"): + if not isinstance(smod, str): + smod = "" + stype = smod + '.' + stype + + if not issubclass(self.exc_type, SyntaxError): + yield _format_final_exc_line(stype, self._str) + else: + yield from self._format_syntax_error(stype) + if isinstance(self.__notes__, collections.abc.Sequence): + for note in self.__notes__: + note = _safe_string(note, 'note') + yield from [l + '\n' for l in note.split('\n')] + elif self.__notes__ is not None: + yield _safe_string(self.__notes__, '__notes__', func=repr) + + def _format_syntax_error(self, stype): + """Format SyntaxError exceptions (internal helper).""" + # Show exactly where the problem was found. + filename_suffix = '' + if self.lineno is not None: + yield ' File "{}", line {}\n'.format( + self.filename or "", self.lineno) + elif self.filename is not None: + filename_suffix = ' ({})'.format(self.filename) + + text = self.text + if text is not None: + # text = " foo\n" + # rtext = " foo" + # ltext = "foo" + rtext = text.rstrip('\n') + ltext = rtext.lstrip(' \n\f') + spaces = len(rtext) - len(ltext) + yield ' {}\n'.format(ltext) + + if self.offset is not None: + offset = self.offset + end_offset = self.end_offset if self.end_offset not in {None, 0} else offset + if offset == end_offset or end_offset == -1: + end_offset = offset + 1 + + # Convert 1-based column offset to 0-based index into stripped text + colno = offset - 1 - spaces + end_colno = end_offset - 1 - spaces + if colno >= 0: + # non-space whitespace (likes tabs) must be kept for alignment + caretspace = ((c if c.isspace() else ' ') for c in ltext[:colno]) + yield ' {}{}'.format("".join(caretspace), ('^' * (end_colno - colno) + "\n")) + msg = self.msg or "" + yield "{}: {}{}\n".format(stype, msg, filename_suffix) + + def format(self, *, chain=True, _ctx=None): + """Format the exception. + + If chain is not *True*, *__cause__* and *__context__* will not be formatted. + + The return value is a generator of strings, each ending in a newline and + some containing internal newlines. `print_exception` is a wrapper around + this method which just prints the lines to a file. + + The message indicating which exception occurred is always the last + string in the output. + """ + + if _ctx is None: + _ctx = _ExceptionPrintContext() + + output = [] + exc = self + if chain: + while exc: + if exc.__cause__ is not None: + chained_msg = _cause_message + chained_exc = exc.__cause__ + elif (exc.__context__ is not None and + not exc.__suppress_context__): + chained_msg = _context_message + chained_exc = exc.__context__ + else: + chained_msg = None + chained_exc = None + + output.append((chained_msg, exc)) + exc = chained_exc + else: + output.append((None, exc)) + + for msg, exc in reversed(output): + if msg is not None: + yield from _ctx.emit(msg) + if exc.exceptions is None: + if exc.stack: + yield from _ctx.emit('Traceback (most recent call last):\n') + yield from _ctx.emit(exc.stack.format()) + yield from _ctx.emit(exc.format_exception_only()) + elif _ctx.exception_group_depth > self.max_group_depth: + # exception group, but depth exceeds limit + yield from _ctx.emit( + f"... (max_group_depth is {self.max_group_depth})\n") + else: + # format exception group + is_toplevel = (_ctx.exception_group_depth == 0) + if is_toplevel: + _ctx.exception_group_depth += 1 + + if exc.stack: + yield from _ctx.emit( + 'Exception Group Traceback (most recent call last):\n', + margin_char = '+' if is_toplevel else None) + yield from _ctx.emit(exc.stack.format()) + + yield from _ctx.emit(exc.format_exception_only()) + num_excs = len(exc.exceptions) + if num_excs <= self.max_group_width: + n = num_excs + else: + n = self.max_group_width + 1 + _ctx.need_close = False + for i in range(n): + last_exc = (i == n-1) + if last_exc: + # The closing frame may be added by a recursive call + _ctx.need_close = True + + if self.max_group_width is not None: + truncated = (i >= self.max_group_width) + else: + truncated = False + title = f'{i+1}' if not truncated else '...' + yield (_ctx.indent() + + ('+-' if i==0 else ' ') + + f'+---------------- {title} ----------------\n') + _ctx.exception_group_depth += 1 + if not truncated: + yield from exc.exceptions[i].format(chain=chain, _ctx=_ctx) + else: + remaining = num_excs - self.max_group_width + plural = 's' if remaining > 1 else '' + yield from _ctx.emit( + f"and {remaining} more exception{plural}\n") + + if last_exc and _ctx.need_close: + yield (_ctx.indent() + + "+------------------------------------\n") + _ctx.need_close = False + _ctx.exception_group_depth -= 1 + + if is_toplevel: + assert _ctx.exception_group_depth == 1 + _ctx.exception_group_depth = 0 + + + def print(self, *, file=None, chain=True): + """Print the result of self.format(chain=chain) to 'file'.""" + if file is None: + file = sys.stderr + for line in self.format(chain=chain): + print(line, file=file, end="") diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tracemalloc.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tracemalloc.py new file mode 100644 index 0000000000000000000000000000000000000000..cec99c59700fe05e457f3668d2b947cc6bfef9c6 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tracemalloc.py @@ -0,0 +1,560 @@ +from collections.abc import Sequence, Iterable +from functools import total_ordering +import fnmatch +import linecache +import os.path +import pickle + +# Import types and functions implemented in C +from _tracemalloc import * +from _tracemalloc import _get_object_traceback, _get_traces + + +def _format_size(size, sign): + for unit in ('B', 'KiB', 'MiB', 'GiB', 'TiB'): + if abs(size) < 100 and unit != 'B': + # 3 digits (xx.x UNIT) + if sign: + return "%+.1f %s" % (size, unit) + else: + return "%.1f %s" % (size, unit) + if abs(size) < 10 * 1024 or unit == 'TiB': + # 4 or 5 digits (xxxx UNIT) + if sign: + return "%+.0f %s" % (size, unit) + else: + return "%.0f %s" % (size, unit) + size /= 1024 + + +class Statistic: + """ + Statistic difference on memory allocations between two Snapshot instance. + """ + + __slots__ = ('traceback', 'size', 'count') + + def __init__(self, traceback, size, count): + self.traceback = traceback + self.size = size + self.count = count + + def __hash__(self): + return hash((self.traceback, self.size, self.count)) + + def __eq__(self, other): + if not isinstance(other, Statistic): + return NotImplemented + return (self.traceback == other.traceback + and self.size == other.size + and self.count == other.count) + + def __str__(self): + text = ("%s: size=%s, count=%i" + % (self.traceback, + _format_size(self.size, False), + self.count)) + if self.count: + average = self.size / self.count + text += ", average=%s" % _format_size(average, False) + return text + + def __repr__(self): + return ('' + % (self.traceback, self.size, self.count)) + + def _sort_key(self): + return (self.size, self.count, self.traceback) + + +class StatisticDiff: + """ + Statistic difference on memory allocations between an old and a new + Snapshot instance. + """ + __slots__ = ('traceback', 'size', 'size_diff', 'count', 'count_diff') + + def __init__(self, traceback, size, size_diff, count, count_diff): + self.traceback = traceback + self.size = size + self.size_diff = size_diff + self.count = count + self.count_diff = count_diff + + def __hash__(self): + return hash((self.traceback, self.size, self.size_diff, + self.count, self.count_diff)) + + def __eq__(self, other): + if not isinstance(other, StatisticDiff): + return NotImplemented + return (self.traceback == other.traceback + and self.size == other.size + and self.size_diff == other.size_diff + and self.count == other.count + and self.count_diff == other.count_diff) + + def __str__(self): + text = ("%s: size=%s (%s), count=%i (%+i)" + % (self.traceback, + _format_size(self.size, False), + _format_size(self.size_diff, True), + self.count, + self.count_diff)) + if self.count: + average = self.size / self.count + text += ", average=%s" % _format_size(average, False) + return text + + def __repr__(self): + return ('' + % (self.traceback, self.size, self.size_diff, + self.count, self.count_diff)) + + def _sort_key(self): + return (abs(self.size_diff), self.size, + abs(self.count_diff), self.count, + self.traceback) + + +def _compare_grouped_stats(old_group, new_group): + statistics = [] + for traceback, stat in new_group.items(): + previous = old_group.pop(traceback, None) + if previous is not None: + stat = StatisticDiff(traceback, + stat.size, stat.size - previous.size, + stat.count, stat.count - previous.count) + else: + stat = StatisticDiff(traceback, + stat.size, stat.size, + stat.count, stat.count) + statistics.append(stat) + + for traceback, stat in old_group.items(): + stat = StatisticDiff(traceback, 0, -stat.size, 0, -stat.count) + statistics.append(stat) + return statistics + + +@total_ordering +class Frame: + """ + Frame of a traceback. + """ + __slots__ = ("_frame",) + + def __init__(self, frame): + # frame is a tuple: (filename: str, lineno: int) + self._frame = frame + + @property + def filename(self): + return self._frame[0] + + @property + def lineno(self): + return self._frame[1] + + def __eq__(self, other): + if not isinstance(other, Frame): + return NotImplemented + return (self._frame == other._frame) + + def __lt__(self, other): + if not isinstance(other, Frame): + return NotImplemented + return (self._frame < other._frame) + + def __hash__(self): + return hash(self._frame) + + def __str__(self): + return "%s:%s" % (self.filename, self.lineno) + + def __repr__(self): + return "" % (self.filename, self.lineno) + + +@total_ordering +class Traceback(Sequence): + """ + Sequence of Frame instances sorted from the oldest frame + to the most recent frame. + """ + __slots__ = ("_frames", '_total_nframe') + + def __init__(self, frames, total_nframe=None): + Sequence.__init__(self) + # frames is a tuple of frame tuples: see Frame constructor for the + # format of a frame tuple; it is reversed, because _tracemalloc + # returns frames sorted from most recent to oldest, but the + # Python API expects oldest to most recent + self._frames = tuple(reversed(frames)) + self._total_nframe = total_nframe + + @property + def total_nframe(self): + return self._total_nframe + + def __len__(self): + return len(self._frames) + + def __getitem__(self, index): + if isinstance(index, slice): + return tuple(Frame(trace) for trace in self._frames[index]) + else: + return Frame(self._frames[index]) + + def __contains__(self, frame): + return frame._frame in self._frames + + def __hash__(self): + return hash(self._frames) + + def __eq__(self, other): + if not isinstance(other, Traceback): + return NotImplemented + return (self._frames == other._frames) + + def __lt__(self, other): + if not isinstance(other, Traceback): + return NotImplemented + return (self._frames < other._frames) + + def __str__(self): + return str(self[0]) + + def __repr__(self): + s = f"" + return s + + def format(self, limit=None, most_recent_first=False): + lines = [] + if limit is not None: + if limit > 0: + frame_slice = self[-limit:] + else: + frame_slice = self[:limit] + else: + frame_slice = self + + if most_recent_first: + frame_slice = reversed(frame_slice) + for frame in frame_slice: + lines.append(' File "%s", line %s' + % (frame.filename, frame.lineno)) + line = linecache.getline(frame.filename, frame.lineno).strip() + if line: + lines.append(' %s' % line) + return lines + + +def get_object_traceback(obj): + """ + Get the traceback where the Python object *obj* was allocated. + Return a Traceback instance. + + Return None if the tracemalloc module is not tracing memory allocations or + did not trace the allocation of the object. + """ + frames = _get_object_traceback(obj) + if frames is not None: + return Traceback(frames) + else: + return None + + +class Trace: + """ + Trace of a memory block. + """ + __slots__ = ("_trace",) + + def __init__(self, trace): + # trace is a tuple: (domain: int, size: int, traceback: tuple). + # See Traceback constructor for the format of the traceback tuple. + self._trace = trace + + @property + def domain(self): + return self._trace[0] + + @property + def size(self): + return self._trace[1] + + @property + def traceback(self): + return Traceback(*self._trace[2:]) + + def __eq__(self, other): + if not isinstance(other, Trace): + return NotImplemented + return (self._trace == other._trace) + + def __hash__(self): + return hash(self._trace) + + def __str__(self): + return "%s: %s" % (self.traceback, _format_size(self.size, False)) + + def __repr__(self): + return ("" + % (self.domain, _format_size(self.size, False), self.traceback)) + + +class _Traces(Sequence): + def __init__(self, traces): + Sequence.__init__(self) + # traces is a tuple of trace tuples: see Trace constructor + self._traces = traces + + def __len__(self): + return len(self._traces) + + def __getitem__(self, index): + if isinstance(index, slice): + return tuple(Trace(trace) for trace in self._traces[index]) + else: + return Trace(self._traces[index]) + + def __contains__(self, trace): + return trace._trace in self._traces + + def __eq__(self, other): + if not isinstance(other, _Traces): + return NotImplemented + return (self._traces == other._traces) + + def __repr__(self): + return "" % len(self) + + +def _normalize_filename(filename): + filename = os.path.normcase(filename) + if filename.endswith('.pyc'): + filename = filename[:-1] + return filename + + +class BaseFilter: + def __init__(self, inclusive): + self.inclusive = inclusive + + def _match(self, trace): + raise NotImplementedError + + +class Filter(BaseFilter): + def __init__(self, inclusive, filename_pattern, + lineno=None, all_frames=False, domain=None): + super().__init__(inclusive) + self.inclusive = inclusive + self._filename_pattern = _normalize_filename(filename_pattern) + self.lineno = lineno + self.all_frames = all_frames + self.domain = domain + + @property + def filename_pattern(self): + return self._filename_pattern + + def _match_frame_impl(self, filename, lineno): + filename = _normalize_filename(filename) + if not fnmatch.fnmatch(filename, self._filename_pattern): + return False + if self.lineno is None: + return True + else: + return (lineno == self.lineno) + + def _match_frame(self, filename, lineno): + return self._match_frame_impl(filename, lineno) ^ (not self.inclusive) + + def _match_traceback(self, traceback): + if self.all_frames: + if any(self._match_frame_impl(filename, lineno) + for filename, lineno in traceback): + return self.inclusive + else: + return (not self.inclusive) + else: + filename, lineno = traceback[0] + return self._match_frame(filename, lineno) + + def _match(self, trace): + domain, size, traceback, total_nframe = trace + res = self._match_traceback(traceback) + if self.domain is not None: + if self.inclusive: + return res and (domain == self.domain) + else: + return res or (domain != self.domain) + return res + + +class DomainFilter(BaseFilter): + def __init__(self, inclusive, domain): + super().__init__(inclusive) + self._domain = domain + + @property + def domain(self): + return self._domain + + def _match(self, trace): + domain, size, traceback, total_nframe = trace + return (domain == self.domain) ^ (not self.inclusive) + + +class Snapshot: + """ + Snapshot of traces of memory blocks allocated by Python. + """ + + def __init__(self, traces, traceback_limit): + # traces is a tuple of trace tuples: see _Traces constructor for + # the exact format + self.traces = _Traces(traces) + self.traceback_limit = traceback_limit + + def dump(self, filename): + """ + Write the snapshot into a file. + """ + with open(filename, "wb") as fp: + pickle.dump(self, fp, pickle.HIGHEST_PROTOCOL) + + @staticmethod + def load(filename): + """ + Load a snapshot from a file. + """ + with open(filename, "rb") as fp: + return pickle.load(fp) + + def _filter_trace(self, include_filters, exclude_filters, trace): + if include_filters: + if not any(trace_filter._match(trace) + for trace_filter in include_filters): + return False + if exclude_filters: + if any(not trace_filter._match(trace) + for trace_filter in exclude_filters): + return False + return True + + def filter_traces(self, filters): + """ + Create a new Snapshot instance with a filtered traces sequence, filters + is a list of Filter or DomainFilter instances. If filters is an empty + list, return a new Snapshot instance with a copy of the traces. + """ + if not isinstance(filters, Iterable): + raise TypeError("filters must be a list of filters, not %s" + % type(filters).__name__) + if filters: + include_filters = [] + exclude_filters = [] + for trace_filter in filters: + if trace_filter.inclusive: + include_filters.append(trace_filter) + else: + exclude_filters.append(trace_filter) + new_traces = [trace for trace in self.traces._traces + if self._filter_trace(include_filters, + exclude_filters, + trace)] + else: + new_traces = self.traces._traces.copy() + return Snapshot(new_traces, self.traceback_limit) + + def _group_by(self, key_type, cumulative): + if key_type not in ('traceback', 'filename', 'lineno'): + raise ValueError("unknown key_type: %r" % (key_type,)) + if cumulative and key_type not in ('lineno', 'filename'): + raise ValueError("cumulative mode cannot by used " + "with key type %r" % key_type) + + stats = {} + tracebacks = {} + if not cumulative: + for trace in self.traces._traces: + domain, size, trace_traceback, total_nframe = trace + try: + traceback = tracebacks[trace_traceback] + except KeyError: + if key_type == 'traceback': + frames = trace_traceback + elif key_type == 'lineno': + frames = trace_traceback[:1] + else: # key_type == 'filename': + frames = ((trace_traceback[0][0], 0),) + traceback = Traceback(frames) + tracebacks[trace_traceback] = traceback + try: + stat = stats[traceback] + stat.size += size + stat.count += 1 + except KeyError: + stats[traceback] = Statistic(traceback, size, 1) + else: + # cumulative statistics + for trace in self.traces._traces: + domain, size, trace_traceback, total_nframe = trace + for frame in trace_traceback: + try: + traceback = tracebacks[frame] + except KeyError: + if key_type == 'lineno': + frames = (frame,) + else: # key_type == 'filename': + frames = ((frame[0], 0),) + traceback = Traceback(frames) + tracebacks[frame] = traceback + try: + stat = stats[traceback] + stat.size += size + stat.count += 1 + except KeyError: + stats[traceback] = Statistic(traceback, size, 1) + return stats + + def statistics(self, key_type, cumulative=False): + """ + Group statistics by key_type. Return a sorted list of Statistic + instances. + """ + grouped = self._group_by(key_type, cumulative) + statistics = list(grouped.values()) + statistics.sort(reverse=True, key=Statistic._sort_key) + return statistics + + def compare_to(self, old_snapshot, key_type, cumulative=False): + """ + Compute the differences with an old snapshot old_snapshot. Get + statistics as a sorted list of StatisticDiff instances, grouped by + group_by. + """ + new_group = self._group_by(key_type, cumulative) + old_group = old_snapshot._group_by(key_type, cumulative) + statistics = _compare_grouped_stats(old_group, new_group) + statistics.sort(reverse=True, key=StatisticDiff._sort_key) + return statistics + + +def take_snapshot(): + """ + Take a snapshot of traces of memory blocks allocated by Python. + """ + if not is_tracing(): + raise RuntimeError("the tracemalloc module must be tracing memory " + "allocations to take a snapshot") + traces = _get_traces() + traceback_limit = get_traceback_limit() + return Snapshot(traces, traceback_limit) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/tty.py b/physworld_p1_20261018/envs/p1/lib/python3.11/tty.py new file mode 100644 index 0000000000000000000000000000000000000000..a72eb6755450bb07d9bb77fb9cdc3cf2f0148534 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/tty.py @@ -0,0 +1,36 @@ +"""Terminal utilities.""" + +# Author: Steen Lumholt. + +from termios import * + +__all__ = ["setraw", "setcbreak"] + +# Indexes for termios list. +IFLAG = 0 +OFLAG = 1 +CFLAG = 2 +LFLAG = 3 +ISPEED = 4 +OSPEED = 5 +CC = 6 + +def setraw(fd, when=TCSAFLUSH): + """Put terminal into a raw mode.""" + mode = tcgetattr(fd) + mode[IFLAG] = mode[IFLAG] & ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON) + mode[OFLAG] = mode[OFLAG] & ~(OPOST) + mode[CFLAG] = mode[CFLAG] & ~(CSIZE | PARENB) + mode[CFLAG] = mode[CFLAG] | CS8 + mode[LFLAG] = mode[LFLAG] & ~(ECHO | ICANON | IEXTEN | ISIG) + mode[CC][VMIN] = 1 + mode[CC][VTIME] = 0 + tcsetattr(fd, when, mode) + +def setcbreak(fd, when=TCSAFLUSH): + """Put terminal into a cbreak mode.""" + mode = tcgetattr(fd) + mode[LFLAG] = mode[LFLAG] & ~(ECHO | ICANON) + mode[CC][VMIN] = 1 + mode[CC][VTIME] = 0 + tcsetattr(fd, when, mode) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtle.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtle.py new file mode 100644 index 0000000000000000000000000000000000000000..1b369327bc8eff067ea8ec01a8bcbceb18fb6e57 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtle.py @@ -0,0 +1,4157 @@ +# +# turtle.py: a Tkinter based turtle graphics module for Python +# Version 1.1b - 4. 5. 2009 +# +# Copyright (C) 2006 - 2010 Gregor Lingl +# email: glingl@aon.at +# +# This software is provided 'as-is', without any express or implied +# warranty. In no event will the authors be held liable for any damages +# arising from the use of this software. +# +# Permission is granted to anyone to use this software for any purpose, +# including commercial applications, and to alter it and redistribute it +# freely, subject to the following restrictions: +# +# 1. The origin of this software must not be misrepresented; you must not +# claim that you wrote the original software. If you use this software +# in a product, an acknowledgment in the product documentation would be +# appreciated but is not required. +# 2. Altered source versions must be plainly marked as such, and must not be +# misrepresented as being the original software. +# 3. This notice may not be removed or altered from any source distribution. + + +""" +Turtle graphics is a popular way for introducing programming to +kids. It was part of the original Logo programming language developed +by Wally Feurzig and Seymour Papert in 1966. + +Imagine a robotic turtle starting at (0, 0) in the x-y plane. After an ``import turtle``, give it +the command turtle.forward(15), and it moves (on-screen!) 15 pixels in +the direction it is facing, drawing a line as it moves. Give it the +command turtle.right(25), and it rotates in-place 25 degrees clockwise. + +By combining together these and similar commands, intricate shapes and +pictures can easily be drawn. + +----- turtle.py + +This module is an extended reimplementation of turtle.py from the +Python standard distribution up to Python 2.5. (See: https://www.python.org) + +It tries to keep the merits of turtle.py and to be (nearly) 100% +compatible with it. This means in the first place to enable the +learning programmer to use all the commands, classes and methods +interactively when using the module from within IDLE run with +the -n switch. + +Roughly it has the following features added: + +- Better animation of the turtle movements, especially of turning the + turtle. So the turtles can more easily be used as a visual feedback + instrument by the (beginning) programmer. + +- Different turtle shapes, gif-images as turtle shapes, user defined + and user controllable turtle shapes, among them compound + (multicolored) shapes. Turtle shapes can be stretched and tilted, which + makes turtles very versatile geometrical objects. + +- Fine control over turtle movement and screen updates via delay(), + and enhanced tracer() and speed() methods. + +- Aliases for the most commonly used commands, like fd for forward etc., + following the early Logo traditions. This reduces the boring work of + typing long sequences of commands, which often occur in a natural way + when kids try to program fancy pictures on their first encounter with + turtle graphics. + +- Turtles now have an undo()-method with configurable undo-buffer. + +- Some simple commands/methods for creating event driven programs + (mouse-, key-, timer-events). Especially useful for programming games. + +- A scrollable Canvas class. The default scrollable Canvas can be + extended interactively as needed while playing around with the turtle(s). + +- A TurtleScreen class with methods controlling background color or + background image, window and canvas size and other properties of the + TurtleScreen. + +- There is a method, setworldcoordinates(), to install a user defined + coordinate-system for the TurtleScreen. + +- The implementation uses a 2-vector class named Vec2D, derived from tuple. + This class is public, so it can be imported by the application programmer, + which makes certain types of computations very natural and compact. + +- Appearance of the TurtleScreen and the Turtles at startup/import can be + configured by means of a turtle.cfg configuration file. + The default configuration mimics the appearance of the old turtle module. + +- If configured appropriately the module reads in docstrings from a docstring + dictionary in some different language, supplied separately and replaces + the English ones by those read in. There is a utility function + write_docstringdict() to write a dictionary with the original (English) + docstrings to disc, so it can serve as a template for translations. + +Behind the scenes there are some features included with possible +extensions in mind. These will be commented and documented elsewhere. + +""" + +_ver = "turtle 1.1b- - for Python 3.1 - 4. 5. 2009" + +# print(_ver) + +import tkinter as TK +import types +import math +import time +import inspect +import sys +import warnings + +from os.path import isfile, split, join +from copy import deepcopy +from tkinter import simpledialog + +_tg_classes = ['ScrolledCanvas', 'TurtleScreen', 'Screen', + 'RawTurtle', 'Turtle', 'RawPen', 'Pen', 'Shape', 'Vec2D'] +_tg_screen_functions = ['addshape', 'bgcolor', 'bgpic', 'bye', + 'clearscreen', 'colormode', 'delay', 'exitonclick', 'getcanvas', + 'getshapes', 'listen', 'mainloop', 'mode', 'numinput', + 'onkey', 'onkeypress', 'onkeyrelease', 'onscreenclick', 'ontimer', + 'register_shape', 'resetscreen', 'screensize', 'setup', + 'setworldcoordinates', 'textinput', 'title', 'tracer', 'turtles', 'update', + 'window_height', 'window_width'] +_tg_turtle_functions = ['back', 'backward', 'begin_fill', 'begin_poly', 'bk', + 'circle', 'clear', 'clearstamp', 'clearstamps', 'clone', 'color', + 'degrees', 'distance', 'dot', 'down', 'end_fill', 'end_poly', 'fd', + 'fillcolor', 'filling', 'forward', 'get_poly', 'getpen', 'getscreen', 'get_shapepoly', + 'getturtle', 'goto', 'heading', 'hideturtle', 'home', 'ht', 'isdown', + 'isvisible', 'left', 'lt', 'onclick', 'ondrag', 'onrelease', 'pd', + 'pen', 'pencolor', 'pendown', 'pensize', 'penup', 'pos', 'position', + 'pu', 'radians', 'right', 'reset', 'resizemode', 'rt', + 'seth', 'setheading', 'setpos', 'setposition', 'settiltangle', + 'setundobuffer', 'setx', 'sety', 'shape', 'shapesize', 'shapetransform', 'shearfactor', 'showturtle', + 'speed', 'st', 'stamp', 'tilt', 'tiltangle', 'towards', + 'turtlesize', 'undo', 'undobufferentries', 'up', 'width', + 'write', 'xcor', 'ycor'] +_tg_utilities = ['write_docstringdict', 'done'] + +__all__ = (_tg_classes + _tg_screen_functions + _tg_turtle_functions + + _tg_utilities + ['Terminator']) # + _math_functions) + +_alias_list = ['addshape', 'backward', 'bk', 'fd', 'ht', 'lt', 'pd', 'pos', + 'pu', 'rt', 'seth', 'setpos', 'setposition', 'st', + 'turtlesize', 'up', 'width'] + +_CFG = {"width" : 0.5, # Screen + "height" : 0.75, + "canvwidth" : 400, + "canvheight": 300, + "leftright": None, + "topbottom": None, + "mode": "standard", # TurtleScreen + "colormode": 1.0, + "delay": 10, + "undobuffersize": 1000, # RawTurtle + "shape": "classic", + "pencolor" : "black", + "fillcolor" : "black", + "resizemode" : "noresize", + "visible" : True, + "language": "english", # docstrings + "exampleturtle": "turtle", + "examplescreen": "screen", + "title": "Python Turtle Graphics", + "using_IDLE": False + } + +def config_dict(filename): + """Convert content of config-file into dictionary.""" + with open(filename, "r") as f: + cfglines = f.readlines() + cfgdict = {} + for line in cfglines: + line = line.strip() + if not line or line.startswith("#"): + continue + try: + key, value = line.split("=") + except ValueError: + print("Bad line in config-file %s:\n%s" % (filename,line)) + continue + key = key.strip() + value = value.strip() + if value in ["True", "False", "None", "''", '""']: + value = eval(value) + else: + try: + if "." in value: + value = float(value) + else: + value = int(value) + except ValueError: + pass # value need not be converted + cfgdict[key] = value + return cfgdict + +def readconfig(cfgdict): + """Read config-files, change configuration-dict accordingly. + + If there is a turtle.cfg file in the current working directory, + read it from there. If this contains an importconfig-value, + say 'myway', construct filename turtle_mayway.cfg else use + turtle.cfg and read it from the import-directory, where + turtle.py is located. + Update configuration dictionary first according to config-file, + in the import directory, then according to config-file in the + current working directory. + If no config-file is found, the default configuration is used. + """ + default_cfg = "turtle.cfg" + cfgdict1 = {} + cfgdict2 = {} + if isfile(default_cfg): + cfgdict1 = config_dict(default_cfg) + if "importconfig" in cfgdict1: + default_cfg = "turtle_%s.cfg" % cfgdict1["importconfig"] + try: + head, tail = split(__file__) + cfg_file2 = join(head, default_cfg) + except Exception: + cfg_file2 = "" + if isfile(cfg_file2): + cfgdict2 = config_dict(cfg_file2) + _CFG.update(cfgdict2) + _CFG.update(cfgdict1) + +try: + readconfig(_CFG) +except Exception: + print ("No configfile read, reason unknown") + + +class Vec2D(tuple): + """A 2 dimensional vector class, used as a helper class + for implementing turtle graphics. + May be useful for turtle graphics programs also. + Derived from tuple, so a vector is a tuple! + + Provides (for a, b vectors, k number): + a+b vector addition + a-b vector subtraction + a*b inner product + k*a and a*k multiplication with scalar + |a| absolute value of a + a.rotate(angle) rotation + """ + def __new__(cls, x, y): + return tuple.__new__(cls, (x, y)) + def __add__(self, other): + return Vec2D(self[0]+other[0], self[1]+other[1]) + def __mul__(self, other): + if isinstance(other, Vec2D): + return self[0]*other[0]+self[1]*other[1] + return Vec2D(self[0]*other, self[1]*other) + def __rmul__(self, other): + if isinstance(other, int) or isinstance(other, float): + return Vec2D(self[0]*other, self[1]*other) + return NotImplemented + def __sub__(self, other): + return Vec2D(self[0]-other[0], self[1]-other[1]) + def __neg__(self): + return Vec2D(-self[0], -self[1]) + def __abs__(self): + return math.hypot(*self) + def rotate(self, angle): + """rotate self counterclockwise by angle + """ + perp = Vec2D(-self[1], self[0]) + angle = math.radians(angle) + c, s = math.cos(angle), math.sin(angle) + return Vec2D(self[0]*c+perp[0]*s, self[1]*c+perp[1]*s) + def __getnewargs__(self): + return (self[0], self[1]) + def __repr__(self): + return "(%.2f,%.2f)" % self + + +############################################################################## +### From here up to line : Tkinter - Interface for turtle.py ### +### May be replaced by an interface to some different graphics toolkit ### +############################################################################## + +## helper functions for Scrolled Canvas, to forward Canvas-methods +## to ScrolledCanvas class + +def __methodDict(cls, _dict): + """helper function for Scrolled Canvas""" + baseList = list(cls.__bases__) + baseList.reverse() + for _super in baseList: + __methodDict(_super, _dict) + for key, value in cls.__dict__.items(): + if type(value) == types.FunctionType: + _dict[key] = value + +def __methods(cls): + """helper function for Scrolled Canvas""" + _dict = {} + __methodDict(cls, _dict) + return _dict.keys() + +__stringBody = ( + 'def %(method)s(self, *args, **kw): return ' + + 'self.%(attribute)s.%(method)s(*args, **kw)') + +def __forwardmethods(fromClass, toClass, toPart, exclude = ()): + ### MANY CHANGES ### + _dict_1 = {} + __methodDict(toClass, _dict_1) + _dict = {} + mfc = __methods(fromClass) + for ex in _dict_1.keys(): + if ex[:1] == '_' or ex[-1:] == '_' or ex in exclude or ex in mfc: + pass + else: + _dict[ex] = _dict_1[ex] + + for method, func in _dict.items(): + d = {'method': method, 'func': func} + if isinstance(toPart, str): + execString = \ + __stringBody % {'method' : method, 'attribute' : toPart} + exec(execString, d) + setattr(fromClass, method, d[method]) ### NEWU! + + +class ScrolledCanvas(TK.Frame): + """Modeled after the scrolled canvas class from Grayons's Tkinter book. + + Used as the default canvas, which pops up automatically when + using turtle graphics functions or the Turtle class. + """ + def __init__(self, master, width=500, height=350, + canvwidth=600, canvheight=500): + TK.Frame.__init__(self, master, width=width, height=height) + self._rootwindow = self.winfo_toplevel() + self.width, self.height = width, height + self.canvwidth, self.canvheight = canvwidth, canvheight + self.bg = "white" + self._canvas = TK.Canvas(master, width=width, height=height, + bg=self.bg, relief=TK.SUNKEN, borderwidth=2) + self.hscroll = TK.Scrollbar(master, command=self._canvas.xview, + orient=TK.HORIZONTAL) + self.vscroll = TK.Scrollbar(master, command=self._canvas.yview) + self._canvas.configure(xscrollcommand=self.hscroll.set, + yscrollcommand=self.vscroll.set) + self.rowconfigure(0, weight=1, minsize=0) + self.columnconfigure(0, weight=1, minsize=0) + self._canvas.grid(padx=1, in_ = self, pady=1, row=0, + column=0, rowspan=1, columnspan=1, sticky='news') + self.vscroll.grid(padx=1, in_ = self, pady=1, row=0, + column=1, rowspan=1, columnspan=1, sticky='news') + self.hscroll.grid(padx=1, in_ = self, pady=1, row=1, + column=0, rowspan=1, columnspan=1, sticky='news') + self.reset() + self._rootwindow.bind('', self.onResize) + + def reset(self, canvwidth=None, canvheight=None, bg = None): + """Adjust canvas and scrollbars according to given canvas size.""" + if canvwidth: + self.canvwidth = canvwidth + if canvheight: + self.canvheight = canvheight + if bg: + self.bg = bg + self._canvas.config(bg=bg, + scrollregion=(-self.canvwidth//2, -self.canvheight//2, + self.canvwidth//2, self.canvheight//2)) + self._canvas.xview_moveto(0.5*(self.canvwidth - self.width + 30) / + self.canvwidth) + self._canvas.yview_moveto(0.5*(self.canvheight- self.height + 30) / + self.canvheight) + self.adjustScrolls() + + + def adjustScrolls(self): + """ Adjust scrollbars according to window- and canvas-size. + """ + cwidth = self._canvas.winfo_width() + cheight = self._canvas.winfo_height() + self._canvas.xview_moveto(0.5*(self.canvwidth-cwidth)/self.canvwidth) + self._canvas.yview_moveto(0.5*(self.canvheight-cheight)/self.canvheight) + if cwidth < self.canvwidth or cheight < self.canvheight: + self.hscroll.grid(padx=1, in_ = self, pady=1, row=1, + column=0, rowspan=1, columnspan=1, sticky='news') + self.vscroll.grid(padx=1, in_ = self, pady=1, row=0, + column=1, rowspan=1, columnspan=1, sticky='news') + else: + self.hscroll.grid_forget() + self.vscroll.grid_forget() + + def onResize(self, event): + """self-explanatory""" + self.adjustScrolls() + + def bbox(self, *args): + """ 'forward' method, which canvas itself has inherited... + """ + return self._canvas.bbox(*args) + + def cget(self, *args, **kwargs): + """ 'forward' method, which canvas itself has inherited... + """ + return self._canvas.cget(*args, **kwargs) + + def config(self, *args, **kwargs): + """ 'forward' method, which canvas itself has inherited... + """ + self._canvas.config(*args, **kwargs) + + def bind(self, *args, **kwargs): + """ 'forward' method, which canvas itself has inherited... + """ + self._canvas.bind(*args, **kwargs) + + def unbind(self, *args, **kwargs): + """ 'forward' method, which canvas itself has inherited... + """ + self._canvas.unbind(*args, **kwargs) + + def focus_force(self): + """ 'forward' method, which canvas itself has inherited... + """ + self._canvas.focus_force() + +__forwardmethods(ScrolledCanvas, TK.Canvas, '_canvas') + + +class _Root(TK.Tk): + """Root class for Screen based on Tkinter.""" + def __init__(self): + TK.Tk.__init__(self) + + def setupcanvas(self, width, height, cwidth, cheight): + self._canvas = ScrolledCanvas(self, width, height, cwidth, cheight) + self._canvas.pack(expand=1, fill="both") + + def _getcanvas(self): + return self._canvas + + def set_geometry(self, width, height, startx, starty): + self.geometry("%dx%d%+d%+d"%(width, height, startx, starty)) + + def ondestroy(self, destroy): + self.wm_protocol("WM_DELETE_WINDOW", destroy) + + def win_width(self): + return self.winfo_screenwidth() + + def win_height(self): + return self.winfo_screenheight() + +Canvas = TK.Canvas + + +class TurtleScreenBase(object): + """Provide the basic graphics functionality. + Interface between Tkinter and turtle.py. + + To port turtle.py to some different graphics toolkit + a corresponding TurtleScreenBase class has to be implemented. + """ + + def _blankimage(self): + """return a blank image object + """ + img = TK.PhotoImage(width=1, height=1, master=self.cv) + img.blank() + return img + + def _image(self, filename): + """return an image object containing the + imagedata from a gif-file named filename. + """ + return TK.PhotoImage(file=filename, master=self.cv) + + def __init__(self, cv): + self.cv = cv + if isinstance(cv, ScrolledCanvas): + w = self.cv.canvwidth + h = self.cv.canvheight + else: # expected: ordinary TK.Canvas + w = int(self.cv.cget("width")) + h = int(self.cv.cget("height")) + self.cv.config(scrollregion = (-w//2, -h//2, w//2, h//2 )) + self.canvwidth = w + self.canvheight = h + self.xscale = self.yscale = 1.0 + + def _createpoly(self): + """Create an invisible polygon item on canvas self.cv) + """ + return self.cv.create_polygon((0, 0, 0, 0, 0, 0), fill="", outline="") + + def _drawpoly(self, polyitem, coordlist, fill=None, + outline=None, width=None, top=False): + """Configure polygonitem polyitem according to provided + arguments: + coordlist is sequence of coordinates + fill is filling color + outline is outline color + top is a boolean value, which specifies if polyitem + will be put on top of the canvas' displaylist so it + will not be covered by other items. + """ + cl = [] + for x, y in coordlist: + cl.append(x * self.xscale) + cl.append(-y * self.yscale) + self.cv.coords(polyitem, *cl) + if fill is not None: + self.cv.itemconfigure(polyitem, fill=fill) + if outline is not None: + self.cv.itemconfigure(polyitem, outline=outline) + if width is not None: + self.cv.itemconfigure(polyitem, width=width) + if top: + self.cv.tag_raise(polyitem) + + def _createline(self): + """Create an invisible line item on canvas self.cv) + """ + return self.cv.create_line(0, 0, 0, 0, fill="", width=2, + capstyle = TK.ROUND) + + def _drawline(self, lineitem, coordlist=None, + fill=None, width=None, top=False): + """Configure lineitem according to provided arguments: + coordlist is sequence of coordinates + fill is drawing color + width is width of drawn line. + top is a boolean value, which specifies if polyitem + will be put on top of the canvas' displaylist so it + will not be covered by other items. + """ + if coordlist is not None: + cl = [] + for x, y in coordlist: + cl.append(x * self.xscale) + cl.append(-y * self.yscale) + self.cv.coords(lineitem, *cl) + if fill is not None: + self.cv.itemconfigure(lineitem, fill=fill) + if width is not None: + self.cv.itemconfigure(lineitem, width=width) + if top: + self.cv.tag_raise(lineitem) + + def _delete(self, item): + """Delete graphics item from canvas. + If item is"all" delete all graphics items. + """ + self.cv.delete(item) + + def _update(self): + """Redraw graphics items on canvas + """ + self.cv.update() + + def _delay(self, delay): + """Delay subsequent canvas actions for delay ms.""" + self.cv.after(delay) + + def _iscolorstring(self, color): + """Check if the string color is a legal Tkinter color string. + """ + try: + rgb = self.cv.winfo_rgb(color) + ok = True + except TK.TclError: + ok = False + return ok + + def _bgcolor(self, color=None): + """Set canvas' backgroundcolor if color is not None, + else return backgroundcolor.""" + if color is not None: + self.cv.config(bg = color) + self._update() + else: + return self.cv.cget("bg") + + def _write(self, pos, txt, align, font, pencolor): + """Write txt at pos in canvas with specified font + and color. + Return text item and x-coord of right bottom corner + of text's bounding box.""" + x, y = pos + x = x * self.xscale + y = y * self.yscale + anchor = {"left":"sw", "center":"s", "right":"se" } + item = self.cv.create_text(x-1, -y, text = txt, anchor = anchor[align], + fill = pencolor, font = font) + x0, y0, x1, y1 = self.cv.bbox(item) + return item, x1-1 + +## def _dot(self, pos, size, color): +## """may be implemented for some other graphics toolkit""" + + def _onclick(self, item, fun, num=1, add=None): + """Bind fun to mouse-click event on turtle. + fun must be a function with two arguments, the coordinates + of the clicked point on the canvas. + num, the number of the mouse-button defaults to 1 + """ + if fun is None: + self.cv.tag_unbind(item, "" % num) + else: + def eventfun(event): + x, y = (self.cv.canvasx(event.x)/self.xscale, + -self.cv.canvasy(event.y)/self.yscale) + fun(x, y) + self.cv.tag_bind(item, "" % num, eventfun, add) + + def _onrelease(self, item, fun, num=1, add=None): + """Bind fun to mouse-button-release event on turtle. + fun must be a function with two arguments, the coordinates + of the point on the canvas where mouse button is released. + num, the number of the mouse-button defaults to 1 + + If a turtle is clicked, first _onclick-event will be performed, + then _onscreensclick-event. + """ + if fun is None: + self.cv.tag_unbind(item, "" % num) + else: + def eventfun(event): + x, y = (self.cv.canvasx(event.x)/self.xscale, + -self.cv.canvasy(event.y)/self.yscale) + fun(x, y) + self.cv.tag_bind(item, "" % num, + eventfun, add) + + def _ondrag(self, item, fun, num=1, add=None): + """Bind fun to mouse-move-event (with pressed mouse button) on turtle. + fun must be a function with two arguments, the coordinates of the + actual mouse position on the canvas. + num, the number of the mouse-button defaults to 1 + + Every sequence of mouse-move-events on a turtle is preceded by a + mouse-click event on that turtle. + """ + if fun is None: + self.cv.tag_unbind(item, "" % num) + else: + def eventfun(event): + try: + x, y = (self.cv.canvasx(event.x)/self.xscale, + -self.cv.canvasy(event.y)/self.yscale) + fun(x, y) + except Exception: + pass + self.cv.tag_bind(item, "" % num, eventfun, add) + + def _onscreenclick(self, fun, num=1, add=None): + """Bind fun to mouse-click event on canvas. + fun must be a function with two arguments, the coordinates + of the clicked point on the canvas. + num, the number of the mouse-button defaults to 1 + + If a turtle is clicked, first _onclick-event will be performed, + then _onscreensclick-event. + """ + if fun is None: + self.cv.unbind("" % num) + else: + def eventfun(event): + x, y = (self.cv.canvasx(event.x)/self.xscale, + -self.cv.canvasy(event.y)/self.yscale) + fun(x, y) + self.cv.bind("" % num, eventfun, add) + + def _onkeyrelease(self, fun, key): + """Bind fun to key-release event of key. + Canvas must have focus. See method listen + """ + if fun is None: + self.cv.unbind("" % key, None) + else: + def eventfun(event): + fun() + self.cv.bind("" % key, eventfun) + + def _onkeypress(self, fun, key=None): + """If key is given, bind fun to key-press event of key. + Otherwise bind fun to any key-press. + Canvas must have focus. See method listen. + """ + if fun is None: + if key is None: + self.cv.unbind("", None) + else: + self.cv.unbind("" % key, None) + else: + def eventfun(event): + fun() + if key is None: + self.cv.bind("", eventfun) + else: + self.cv.bind("" % key, eventfun) + + def _listen(self): + """Set focus on canvas (in order to collect key-events) + """ + self.cv.focus_force() + + def _ontimer(self, fun, t): + """Install a timer, which calls fun after t milliseconds. + """ + if t == 0: + self.cv.after_idle(fun) + else: + self.cv.after(t, fun) + + def _createimage(self, image): + """Create and return image item on canvas. + """ + return self.cv.create_image(0, 0, image=image) + + def _drawimage(self, item, pos, image): + """Configure image item as to draw image object + at position (x,y) on canvas) + """ + x, y = pos + self.cv.coords(item, (x * self.xscale, -y * self.yscale)) + self.cv.itemconfig(item, image=image) + + def _setbgpic(self, item, image): + """Configure image item as to draw image object + at center of canvas. Set item to the first item + in the displaylist, so it will be drawn below + any other item .""" + self.cv.itemconfig(item, image=image) + self.cv.tag_lower(item) + + def _type(self, item): + """Return 'line' or 'polygon' or 'image' depending on + type of item. + """ + return self.cv.type(item) + + def _pointlist(self, item): + """returns list of coordinate-pairs of points of item + Example (for insiders): + >>> from turtle import * + >>> getscreen()._pointlist(getturtle().turtle._item) + [(0.0, 9.9999999999999982), (0.0, -9.9999999999999982), + (9.9999999999999982, 0.0)] + >>> """ + cl = self.cv.coords(item) + pl = [(cl[i], -cl[i+1]) for i in range(0, len(cl), 2)] + return pl + + def _setscrollregion(self, srx1, sry1, srx2, sry2): + self.cv.config(scrollregion=(srx1, sry1, srx2, sry2)) + + def _rescale(self, xscalefactor, yscalefactor): + items = self.cv.find_all() + for item in items: + coordinates = list(self.cv.coords(item)) + newcoordlist = [] + while coordinates: + x, y = coordinates[:2] + newcoordlist.append(x * xscalefactor) + newcoordlist.append(y * yscalefactor) + coordinates = coordinates[2:] + self.cv.coords(item, *newcoordlist) + + def _resize(self, canvwidth=None, canvheight=None, bg=None): + """Resize the canvas the turtles are drawing on. Does + not alter the drawing window. + """ + # needs amendment + if not isinstance(self.cv, ScrolledCanvas): + return self.canvwidth, self.canvheight + if canvwidth is canvheight is bg is None: + return self.cv.canvwidth, self.cv.canvheight + if canvwidth is not None: + self.canvwidth = canvwidth + if canvheight is not None: + self.canvheight = canvheight + self.cv.reset(canvwidth, canvheight, bg) + + def _window_size(self): + """ Return the width and height of the turtle window. + """ + width = self.cv.winfo_width() + if width <= 1: # the window isn't managed by a geometry manager + width = self.cv['width'] + height = self.cv.winfo_height() + if height <= 1: # the window isn't managed by a geometry manager + height = self.cv['height'] + return width, height + + def mainloop(self): + """Starts event loop - calling Tkinter's mainloop function. + + No argument. + + Must be last statement in a turtle graphics program. + Must NOT be used if a script is run from within IDLE in -n mode + (No subprocess) - for interactive use of turtle graphics. + + Example (for a TurtleScreen instance named screen): + >>> screen.mainloop() + + """ + self.cv.tk.mainloop() + + def textinput(self, title, prompt): + """Pop up a dialog window for input of a string. + + Arguments: title is the title of the dialog window, + prompt is a text mostly describing what information to input. + + Return the string input + If the dialog is canceled, return None. + + Example (for a TurtleScreen instance named screen): + >>> screen.textinput("NIM", "Name of first player:") + + """ + return simpledialog.askstring(title, prompt, parent=self.cv) + + def numinput(self, title, prompt, default=None, minval=None, maxval=None): + """Pop up a dialog window for input of a number. + + Arguments: title is the title of the dialog window, + prompt is a text mostly describing what numerical information to input. + default: default value + minval: minimum value for input + maxval: maximum value for input + + The number input must be in the range minval .. maxval if these are + given. If not, a hint is issued and the dialog remains open for + correction. Return the number input. + If the dialog is canceled, return None. + + Example (for a TurtleScreen instance named screen): + >>> screen.numinput("Poker", "Your stakes:", 1000, minval=10, maxval=10000) + + """ + return simpledialog.askfloat(title, prompt, initialvalue=default, + minvalue=minval, maxvalue=maxval, + parent=self.cv) + + +############################################################################## +### End of Tkinter - interface ### +############################################################################## + + +class Terminator (Exception): + """Will be raised in TurtleScreen.update, if _RUNNING becomes False. + + This stops execution of a turtle graphics script. + Main purpose: use in the Demo-Viewer turtle.Demo.py. + """ + pass + + +class TurtleGraphicsError(Exception): + """Some TurtleGraphics Error + """ + + +class Shape(object): + """Data structure modeling shapes. + + attribute _type is one of "polygon", "image", "compound" + attribute _data is - depending on _type a poygon-tuple, + an image or a list constructed using the addcomponent method. + """ + def __init__(self, type_, data=None): + self._type = type_ + if type_ == "polygon": + if isinstance(data, list): + data = tuple(data) + elif type_ == "image": + if isinstance(data, str): + if data.lower().endswith(".gif") and isfile(data): + data = TurtleScreen._image(data) + # else data assumed to be Photoimage + elif type_ == "compound": + data = [] + else: + raise TurtleGraphicsError("There is no shape type %s" % type_) + self._data = data + + def addcomponent(self, poly, fill, outline=None): + """Add component to a shape of type compound. + + Arguments: poly is a polygon, i. e. a tuple of number pairs. + fill is the fillcolor of the component, + outline is the outline color of the component. + + call (for a Shapeobject namend s): + -- s.addcomponent(((0,0), (10,10), (-10,10)), "red", "blue") + + Example: + >>> poly = ((0,0),(10,-5),(0,10),(-10,-5)) + >>> s = Shape("compound") + >>> s.addcomponent(poly, "red", "blue") + >>> # .. add more components and then use register_shape() + """ + if self._type != "compound": + raise TurtleGraphicsError("Cannot add component to %s Shape" + % self._type) + if outline is None: + outline = fill + self._data.append([poly, fill, outline]) + + +class Tbuffer(object): + """Ring buffer used as undobuffer for RawTurtle objects.""" + def __init__(self, bufsize=10): + self.bufsize = bufsize + self.buffer = [[None]] * bufsize + self.ptr = -1 + self.cumulate = False + def reset(self, bufsize=None): + if bufsize is None: + for i in range(self.bufsize): + self.buffer[i] = [None] + else: + self.bufsize = bufsize + self.buffer = [[None]] * bufsize + self.ptr = -1 + def push(self, item): + if self.bufsize > 0: + if not self.cumulate: + self.ptr = (self.ptr + 1) % self.bufsize + self.buffer[self.ptr] = item + else: + self.buffer[self.ptr].append(item) + def pop(self): + if self.bufsize > 0: + item = self.buffer[self.ptr] + if item is None: + return None + else: + self.buffer[self.ptr] = [None] + self.ptr = (self.ptr - 1) % self.bufsize + return (item) + def nr_of_items(self): + return self.bufsize - self.buffer.count([None]) + def __repr__(self): + return str(self.buffer) + " " + str(self.ptr) + + + +class TurtleScreen(TurtleScreenBase): + """Provides screen oriented methods like bgcolor etc. + + Only relies upon the methods of TurtleScreenBase and NOT + upon components of the underlying graphics toolkit - + which is Tkinter in this case. + """ + _RUNNING = True + + def __init__(self, cv, mode=_CFG["mode"], + colormode=_CFG["colormode"], delay=_CFG["delay"]): + TurtleScreenBase.__init__(self, cv) + + self._shapes = { + "arrow" : Shape("polygon", ((-10,0), (10,0), (0,10))), + "turtle" : Shape("polygon", ((0,16), (-2,14), (-1,10), (-4,7), + (-7,9), (-9,8), (-6,5), (-7,1), (-5,-3), (-8,-6), + (-6,-8), (-4,-5), (0,-7), (4,-5), (6,-8), (8,-6), + (5,-3), (7,1), (6,5), (9,8), (7,9), (4,7), (1,10), + (2,14))), + "circle" : Shape("polygon", ((10,0), (9.51,3.09), (8.09,5.88), + (5.88,8.09), (3.09,9.51), (0,10), (-3.09,9.51), + (-5.88,8.09), (-8.09,5.88), (-9.51,3.09), (-10,0), + (-9.51,-3.09), (-8.09,-5.88), (-5.88,-8.09), + (-3.09,-9.51), (-0.00,-10.00), (3.09,-9.51), + (5.88,-8.09), (8.09,-5.88), (9.51,-3.09))), + "square" : Shape("polygon", ((10,-10), (10,10), (-10,10), + (-10,-10))), + "triangle" : Shape("polygon", ((10,-5.77), (0,11.55), + (-10,-5.77))), + "classic": Shape("polygon", ((0,0),(-5,-9),(0,-7),(5,-9))), + "blank" : Shape("image", self._blankimage()) + } + + self._bgpics = {"nopic" : ""} + + self._mode = mode + self._delayvalue = delay + self._colormode = _CFG["colormode"] + self._keys = [] + self.clear() + if sys.platform == 'darwin': + # Force Turtle window to the front on OS X. This is needed because + # the Turtle window will show behind the Terminal window when you + # start the demo from the command line. + rootwindow = cv.winfo_toplevel() + rootwindow.call('wm', 'attributes', '.', '-topmost', '1') + rootwindow.call('wm', 'attributes', '.', '-topmost', '0') + + def clear(self): + """Delete all drawings and all turtles from the TurtleScreen. + + No argument. + + Reset empty TurtleScreen to its initial state: white background, + no backgroundimage, no eventbindings and tracing on. + + Example (for a TurtleScreen instance named screen): + >>> screen.clear() + + Note: this method is not available as function. + """ + self._delayvalue = _CFG["delay"] + self._colormode = _CFG["colormode"] + self._delete("all") + self._bgpic = self._createimage("") + self._bgpicname = "nopic" + self._tracing = 1 + self._updatecounter = 0 + self._turtles = [] + self.bgcolor("white") + for btn in 1, 2, 3: + self.onclick(None, btn) + self.onkeypress(None) + for key in self._keys[:]: + self.onkey(None, key) + self.onkeypress(None, key) + Turtle._pen = None + + def mode(self, mode=None): + """Set turtle-mode ('standard', 'logo' or 'world') and perform reset. + + Optional argument: + mode -- one of the strings 'standard', 'logo' or 'world' + + Mode 'standard' is compatible with turtle.py. + Mode 'logo' is compatible with most Logo-Turtle-Graphics. + Mode 'world' uses userdefined 'worldcoordinates'. *Attention*: in + this mode angles appear distorted if x/y unit-ratio doesn't equal 1. + If mode is not given, return the current mode. + + Mode Initial turtle heading positive angles + ------------|-------------------------|------------------- + 'standard' to the right (east) counterclockwise + 'logo' upward (north) clockwise + + Examples: + >>> mode('logo') # resets turtle heading to north + >>> mode() + 'logo' + """ + if mode is None: + return self._mode + mode = mode.lower() + if mode not in ["standard", "logo", "world"]: + raise TurtleGraphicsError("No turtle-graphics-mode %s" % mode) + self._mode = mode + if mode in ["standard", "logo"]: + self._setscrollregion(-self.canvwidth//2, -self.canvheight//2, + self.canvwidth//2, self.canvheight//2) + self.xscale = self.yscale = 1.0 + self.reset() + + def setworldcoordinates(self, llx, lly, urx, ury): + """Set up a user defined coordinate-system. + + Arguments: + llx -- a number, x-coordinate of lower left corner of canvas + lly -- a number, y-coordinate of lower left corner of canvas + urx -- a number, x-coordinate of upper right corner of canvas + ury -- a number, y-coordinate of upper right corner of canvas + + Set up user coodinat-system and switch to mode 'world' if necessary. + This performs a screen.reset. If mode 'world' is already active, + all drawings are redrawn according to the new coordinates. + + But ATTENTION: in user-defined coordinatesystems angles may appear + distorted. (see Screen.mode()) + + Example (for a TurtleScreen instance named screen): + >>> screen.setworldcoordinates(-10,-0.5,50,1.5) + >>> for _ in range(36): + ... left(10) + ... forward(0.5) + """ + if self.mode() != "world": + self.mode("world") + xspan = float(urx - llx) + yspan = float(ury - lly) + wx, wy = self._window_size() + self.screensize(wx-20, wy-20) + oldxscale, oldyscale = self.xscale, self.yscale + self.xscale = self.canvwidth / xspan + self.yscale = self.canvheight / yspan + srx1 = llx * self.xscale + sry1 = -ury * self.yscale + srx2 = self.canvwidth + srx1 + sry2 = self.canvheight + sry1 + self._setscrollregion(srx1, sry1, srx2, sry2) + self._rescale(self.xscale/oldxscale, self.yscale/oldyscale) + self.update() + + def register_shape(self, name, shape=None): + """Adds a turtle shape to TurtleScreen's shapelist. + + Arguments: + (1) name is the name of a gif-file and shape is None. + Installs the corresponding image shape. + !! Image-shapes DO NOT rotate when turning the turtle, + !! so they do not display the heading of the turtle! + (2) name is an arbitrary string and shape is a tuple + of pairs of coordinates. Installs the corresponding + polygon shape + (3) name is an arbitrary string and shape is a + (compound) Shape object. Installs the corresponding + compound shape. + To use a shape, you have to issue the command shape(shapename). + + call: register_shape("turtle.gif") + --or: register_shape("tri", ((0,0), (10,10), (-10,10))) + + Example (for a TurtleScreen instance named screen): + >>> screen.register_shape("triangle", ((5,-3),(0,5),(-5,-3))) + + """ + if shape is None: + # image + if name.lower().endswith(".gif"): + shape = Shape("image", self._image(name)) + else: + raise TurtleGraphicsError("Bad arguments for register_shape.\n" + + "Use help(register_shape)" ) + elif isinstance(shape, tuple): + shape = Shape("polygon", shape) + ## else shape assumed to be Shape-instance + self._shapes[name] = shape + + def _colorstr(self, color): + """Return color string corresponding to args. + + Argument may be a string or a tuple of three + numbers corresponding to actual colormode, + i.e. in the range 0<=n<=colormode. + + If the argument doesn't represent a color, + an error is raised. + """ + if len(color) == 1: + color = color[0] + if isinstance(color, str): + if self._iscolorstring(color) or color == "": + return color + else: + raise TurtleGraphicsError("bad color string: %s" % str(color)) + try: + r, g, b = color + except (TypeError, ValueError): + raise TurtleGraphicsError("bad color arguments: %s" % str(color)) + if self._colormode == 1.0: + r, g, b = [round(255.0*x) for x in (r, g, b)] + if not ((0 <= r <= 255) and (0 <= g <= 255) and (0 <= b <= 255)): + raise TurtleGraphicsError("bad color sequence: %s" % str(color)) + return "#%02x%02x%02x" % (r, g, b) + + def _color(self, cstr): + if not cstr.startswith("#"): + return cstr + if len(cstr) == 7: + cl = [int(cstr[i:i+2], 16) for i in (1, 3, 5)] + elif len(cstr) == 4: + cl = [16*int(cstr[h], 16) for h in cstr[1:]] + else: + raise TurtleGraphicsError("bad colorstring: %s" % cstr) + return tuple(c * self._colormode/255 for c in cl) + + def colormode(self, cmode=None): + """Return the colormode or set it to 1.0 or 255. + + Optional argument: + cmode -- one of the values 1.0 or 255 + + r, g, b values of colortriples have to be in range 0..cmode. + + Example (for a TurtleScreen instance named screen): + >>> screen.colormode() + 1.0 + >>> screen.colormode(255) + >>> pencolor(240,160,80) + """ + if cmode is None: + return self._colormode + if cmode == 1.0: + self._colormode = float(cmode) + elif cmode == 255: + self._colormode = int(cmode) + + def reset(self): + """Reset all Turtles on the Screen to their initial state. + + No argument. + + Example (for a TurtleScreen instance named screen): + >>> screen.reset() + """ + for turtle in self._turtles: + turtle._setmode(self._mode) + turtle.reset() + + def turtles(self): + """Return the list of turtles on the screen. + + Example (for a TurtleScreen instance named screen): + >>> screen.turtles() + [] + """ + return self._turtles + + def bgcolor(self, *args): + """Set or return backgroundcolor of the TurtleScreen. + + Arguments (if given): a color string or three numbers + in the range 0..colormode or a 3-tuple of such numbers. + + Example (for a TurtleScreen instance named screen): + >>> screen.bgcolor("orange") + >>> screen.bgcolor() + 'orange' + >>> screen.bgcolor(0.5,0,0.5) + >>> screen.bgcolor() + '#800080' + """ + if args: + color = self._colorstr(args) + else: + color = None + color = self._bgcolor(color) + if color is not None: + color = self._color(color) + return color + + def tracer(self, n=None, delay=None): + """Turns turtle animation on/off and set delay for update drawings. + + Optional arguments: + n -- nonnegative integer + delay -- nonnegative integer + + If n is given, only each n-th regular screen update is really performed. + (Can be used to accelerate the drawing of complex graphics.) + Second arguments sets delay value (see RawTurtle.delay()) + + Example (for a TurtleScreen instance named screen): + >>> screen.tracer(8, 25) + >>> dist = 2 + >>> for i in range(200): + ... fd(dist) + ... rt(90) + ... dist += 2 + """ + if n is None: + return self._tracing + self._tracing = int(n) + self._updatecounter = 0 + if delay is not None: + self._delayvalue = int(delay) + if self._tracing: + self.update() + + def delay(self, delay=None): + """ Return or set the drawing delay in milliseconds. + + Optional argument: + delay -- positive integer + + Example (for a TurtleScreen instance named screen): + >>> screen.delay(15) + >>> screen.delay() + 15 + """ + if delay is None: + return self._delayvalue + self._delayvalue = int(delay) + + def _incrementudc(self): + """Increment update counter.""" + if not TurtleScreen._RUNNING: + TurtleScreen._RUNNING = True + raise Terminator + if self._tracing > 0: + self._updatecounter += 1 + self._updatecounter %= self._tracing + + def update(self): + """Perform a TurtleScreen update. + """ + tracing = self._tracing + self._tracing = True + for t in self.turtles(): + t._update_data() + t._drawturtle() + self._tracing = tracing + self._update() + + def window_width(self): + """ Return the width of the turtle window. + + Example (for a TurtleScreen instance named screen): + >>> screen.window_width() + 640 + """ + return self._window_size()[0] + + def window_height(self): + """ Return the height of the turtle window. + + Example (for a TurtleScreen instance named screen): + >>> screen.window_height() + 480 + """ + return self._window_size()[1] + + def getcanvas(self): + """Return the Canvas of this TurtleScreen. + + No argument. + + Example (for a Screen instance named screen): + >>> cv = screen.getcanvas() + >>> cv + + """ + return self.cv + + def getshapes(self): + """Return a list of names of all currently available turtle shapes. + + No argument. + + Example (for a TurtleScreen instance named screen): + >>> screen.getshapes() + ['arrow', 'blank', 'circle', ... , 'turtle'] + """ + return sorted(self._shapes.keys()) + + def onclick(self, fun, btn=1, add=None): + """Bind fun to mouse-click event on canvas. + + Arguments: + fun -- a function with two arguments, the coordinates of the + clicked point on the canvas. + btn -- the number of the mouse-button, defaults to 1 + + Example (for a TurtleScreen instance named screen) + + >>> screen.onclick(goto) + >>> # Subsequently clicking into the TurtleScreen will + >>> # make the turtle move to the clicked point. + >>> screen.onclick(None) + """ + self._onscreenclick(fun, btn, add) + + def onkey(self, fun, key): + """Bind fun to key-release event of key. + + Arguments: + fun -- a function with no arguments + key -- a string: key (e.g. "a") or key-symbol (e.g. "space") + + In order to be able to register key-events, TurtleScreen + must have focus. (See method listen.) + + Example (for a TurtleScreen instance named screen): + + >>> def f(): + ... fd(50) + ... lt(60) + ... + >>> screen.onkey(f, "Up") + >>> screen.listen() + + Subsequently the turtle can be moved by repeatedly pressing + the up-arrow key, consequently drawing a hexagon + + """ + if fun is None: + if key in self._keys: + self._keys.remove(key) + elif key not in self._keys: + self._keys.append(key) + self._onkeyrelease(fun, key) + + def onkeypress(self, fun, key=None): + """Bind fun to key-press event of key if key is given, + or to any key-press-event if no key is given. + + Arguments: + fun -- a function with no arguments + key -- a string: key (e.g. "a") or key-symbol (e.g. "space") + + In order to be able to register key-events, TurtleScreen + must have focus. (See method listen.) + + Example (for a TurtleScreen instance named screen + and a Turtle instance named turtle): + + >>> def f(): + ... fd(50) + ... lt(60) + ... + >>> screen.onkeypress(f, "Up") + >>> screen.listen() + + Subsequently the turtle can be moved by repeatedly pressing + the up-arrow key, or by keeping pressed the up-arrow key. + consequently drawing a hexagon. + """ + if fun is None: + if key in self._keys: + self._keys.remove(key) + elif key is not None and key not in self._keys: + self._keys.append(key) + self._onkeypress(fun, key) + + def listen(self, xdummy=None, ydummy=None): + """Set focus on TurtleScreen (in order to collect key-events) + + No arguments. + Dummy arguments are provided in order + to be able to pass listen to the onclick method. + + Example (for a TurtleScreen instance named screen): + >>> screen.listen() + """ + self._listen() + + def ontimer(self, fun, t=0): + """Install a timer, which calls fun after t milliseconds. + + Arguments: + fun -- a function with no arguments. + t -- a number >= 0 + + Example (for a TurtleScreen instance named screen): + + >>> running = True + >>> def f(): + ... if running: + ... fd(50) + ... lt(60) + ... screen.ontimer(f, 250) + ... + >>> f() # makes the turtle marching around + >>> running = False + """ + self._ontimer(fun, t) + + def bgpic(self, picname=None): + """Set background image or return name of current backgroundimage. + + Optional argument: + picname -- a string, name of a gif-file or "nopic". + + If picname is a filename, set the corresponding image as background. + If picname is "nopic", delete backgroundimage, if present. + If picname is None, return the filename of the current backgroundimage. + + Example (for a TurtleScreen instance named screen): + >>> screen.bgpic() + 'nopic' + >>> screen.bgpic("landscape.gif") + >>> screen.bgpic() + 'landscape.gif' + """ + if picname is None: + return self._bgpicname + if picname not in self._bgpics: + self._bgpics[picname] = self._image(picname) + self._setbgpic(self._bgpic, self._bgpics[picname]) + self._bgpicname = picname + + def screensize(self, canvwidth=None, canvheight=None, bg=None): + """Resize the canvas the turtles are drawing on. + + Optional arguments: + canvwidth -- positive integer, new width of canvas in pixels + canvheight -- positive integer, new height of canvas in pixels + bg -- colorstring or color-tuple, new backgroundcolor + If no arguments are given, return current (canvaswidth, canvasheight) + + Do not alter the drawing window. To observe hidden parts of + the canvas use the scrollbars. (Can make visible those parts + of a drawing, which were outside the canvas before!) + + Example (for a Turtle instance named turtle): + >>> turtle.screensize(2000,1500) + >>> # e.g. to search for an erroneously escaped turtle ;-) + """ + return self._resize(canvwidth, canvheight, bg) + + onscreenclick = onclick + resetscreen = reset + clearscreen = clear + addshape = register_shape + onkeyrelease = onkey + +class TNavigator(object): + """Navigation part of the RawTurtle. + Implements methods for turtle movement. + """ + START_ORIENTATION = { + "standard": Vec2D(1.0, 0.0), + "world" : Vec2D(1.0, 0.0), + "logo" : Vec2D(0.0, 1.0) } + DEFAULT_MODE = "standard" + DEFAULT_ANGLEOFFSET = 0 + DEFAULT_ANGLEORIENT = 1 + + def __init__(self, mode=DEFAULT_MODE): + self._angleOffset = self.DEFAULT_ANGLEOFFSET + self._angleOrient = self.DEFAULT_ANGLEORIENT + self._mode = mode + self.undobuffer = None + self.degrees() + self._mode = None + self._setmode(mode) + TNavigator.reset(self) + + def reset(self): + """reset turtle to its initial values + + Will be overwritten by parent class + """ + self._position = Vec2D(0.0, 0.0) + self._orient = TNavigator.START_ORIENTATION[self._mode] + + def _setmode(self, mode=None): + """Set turtle-mode to 'standard', 'world' or 'logo'. + """ + if mode is None: + return self._mode + if mode not in ["standard", "logo", "world"]: + return + self._mode = mode + if mode in ["standard", "world"]: + self._angleOffset = 0 + self._angleOrient = 1 + else: # mode == "logo": + self._angleOffset = self._fullcircle/4. + self._angleOrient = -1 + + def _setDegreesPerAU(self, fullcircle): + """Helper function for degrees() and radians()""" + self._fullcircle = fullcircle + self._degreesPerAU = 360/fullcircle + if self._mode == "standard": + self._angleOffset = 0 + else: + self._angleOffset = fullcircle/4. + + def degrees(self, fullcircle=360.0): + """ Set angle measurement units to degrees. + + Optional argument: + fullcircle - a number + + Set angle measurement units, i. e. set number + of 'degrees' for a full circle. Default value is + 360 degrees. + + Example (for a Turtle instance named turtle): + >>> turtle.left(90) + >>> turtle.heading() + 90 + + Change angle measurement unit to grad (also known as gon, + grade, or gradian and equals 1/100-th of the right angle.) + >>> turtle.degrees(400.0) + >>> turtle.heading() + 100 + + """ + self._setDegreesPerAU(fullcircle) + + def radians(self): + """ Set the angle measurement units to radians. + + No arguments. + + Example (for a Turtle instance named turtle): + >>> turtle.heading() + 90 + >>> turtle.radians() + >>> turtle.heading() + 1.5707963267948966 + """ + self._setDegreesPerAU(math.tau) + + def _go(self, distance): + """move turtle forward by specified distance""" + ende = self._position + self._orient * distance + self._goto(ende) + + def _rotate(self, angle): + """Turn turtle counterclockwise by specified angle if angle > 0.""" + angle *= self._degreesPerAU + self._orient = self._orient.rotate(angle) + + def _goto(self, end): + """move turtle to position end.""" + self._position = end + + def forward(self, distance): + """Move the turtle forward by the specified distance. + + Aliases: forward | fd + + Argument: + distance -- a number (integer or float) + + Move the turtle forward by the specified distance, in the direction + the turtle is headed. + + Example (for a Turtle instance named turtle): + >>> turtle.position() + (0.00, 0.00) + >>> turtle.forward(25) + >>> turtle.position() + (25.00,0.00) + >>> turtle.forward(-75) + >>> turtle.position() + (-50.00,0.00) + """ + self._go(distance) + + def back(self, distance): + """Move the turtle backward by distance. + + Aliases: back | backward | bk + + Argument: + distance -- a number + + Move the turtle backward by distance, opposite to the direction the + turtle is headed. Do not change the turtle's heading. + + Example (for a Turtle instance named turtle): + >>> turtle.position() + (0.00, 0.00) + >>> turtle.backward(30) + >>> turtle.position() + (-30.00, 0.00) + """ + self._go(-distance) + + def right(self, angle): + """Turn turtle right by angle units. + + Aliases: right | rt + + Argument: + angle -- a number (integer or float) + + Turn turtle right by angle units. (Units are by default degrees, + but can be set via the degrees() and radians() functions.) + Angle orientation depends on mode. (See this.) + + Example (for a Turtle instance named turtle): + >>> turtle.heading() + 22.0 + >>> turtle.right(45) + >>> turtle.heading() + 337.0 + """ + self._rotate(-angle) + + def left(self, angle): + """Turn turtle left by angle units. + + Aliases: left | lt + + Argument: + angle -- a number (integer or float) + + Turn turtle left by angle units. (Units are by default degrees, + but can be set via the degrees() and radians() functions.) + Angle orientation depends on mode. (See this.) + + Example (for a Turtle instance named turtle): + >>> turtle.heading() + 22.0 + >>> turtle.left(45) + >>> turtle.heading() + 67.0 + """ + self._rotate(angle) + + def pos(self): + """Return the turtle's current location (x,y), as a Vec2D-vector. + + Aliases: pos | position + + No arguments. + + Example (for a Turtle instance named turtle): + >>> turtle.pos() + (0.00, 240.00) + """ + return self._position + + def xcor(self): + """ Return the turtle's x coordinate. + + No arguments. + + Example (for a Turtle instance named turtle): + >>> reset() + >>> turtle.left(60) + >>> turtle.forward(100) + >>> print turtle.xcor() + 50.0 + """ + return self._position[0] + + def ycor(self): + """ Return the turtle's y coordinate + --- + No arguments. + + Example (for a Turtle instance named turtle): + >>> reset() + >>> turtle.left(60) + >>> turtle.forward(100) + >>> print turtle.ycor() + 86.6025403784 + """ + return self._position[1] + + + def goto(self, x, y=None): + """Move turtle to an absolute position. + + Aliases: setpos | setposition | goto: + + Arguments: + x -- a number or a pair/vector of numbers + y -- a number None + + call: goto(x, y) # two coordinates + --or: goto((x, y)) # a pair (tuple) of coordinates + --or: goto(vec) # e.g. as returned by pos() + + Move turtle to an absolute position. If the pen is down, + a line will be drawn. The turtle's orientation does not change. + + Example (for a Turtle instance named turtle): + >>> tp = turtle.pos() + >>> tp + (0.00, 0.00) + >>> turtle.setpos(60,30) + >>> turtle.pos() + (60.00,30.00) + >>> turtle.setpos((20,80)) + >>> turtle.pos() + (20.00,80.00) + >>> turtle.setpos(tp) + >>> turtle.pos() + (0.00,0.00) + """ + if y is None: + self._goto(Vec2D(*x)) + else: + self._goto(Vec2D(x, y)) + + def home(self): + """Move turtle to the origin - coordinates (0,0). + + No arguments. + + Move turtle to the origin - coordinates (0,0) and set its + heading to its start-orientation (which depends on mode). + + Example (for a Turtle instance named turtle): + >>> turtle.home() + """ + self.goto(0, 0) + self.setheading(0) + + def setx(self, x): + """Set the turtle's first coordinate to x + + Argument: + x -- a number (integer or float) + + Set the turtle's first coordinate to x, leave second coordinate + unchanged. + + Example (for a Turtle instance named turtle): + >>> turtle.position() + (0.00, 240.00) + >>> turtle.setx(10) + >>> turtle.position() + (10.00, 240.00) + """ + self._goto(Vec2D(x, self._position[1])) + + def sety(self, y): + """Set the turtle's second coordinate to y + + Argument: + y -- a number (integer or float) + + Set the turtle's first coordinate to x, second coordinate remains + unchanged. + + Example (for a Turtle instance named turtle): + >>> turtle.position() + (0.00, 40.00) + >>> turtle.sety(-10) + >>> turtle.position() + (0.00, -10.00) + """ + self._goto(Vec2D(self._position[0], y)) + + def distance(self, x, y=None): + """Return the distance from the turtle to (x,y) in turtle step units. + + Arguments: + x -- a number or a pair/vector of numbers or a turtle instance + y -- a number None None + + call: distance(x, y) # two coordinates + --or: distance((x, y)) # a pair (tuple) of coordinates + --or: distance(vec) # e.g. as returned by pos() + --or: distance(mypen) # where mypen is another turtle + + Example (for a Turtle instance named turtle): + >>> turtle.pos() + (0.00, 0.00) + >>> turtle.distance(30,40) + 50.0 + >>> pen = Turtle() + >>> pen.forward(77) + >>> turtle.distance(pen) + 77.0 + """ + if y is not None: + pos = Vec2D(x, y) + if isinstance(x, Vec2D): + pos = x + elif isinstance(x, tuple): + pos = Vec2D(*x) + elif isinstance(x, TNavigator): + pos = x._position + return abs(pos - self._position) + + def towards(self, x, y=None): + """Return the angle of the line from the turtle's position to (x, y). + + Arguments: + x -- a number or a pair/vector of numbers or a turtle instance + y -- a number None None + + call: distance(x, y) # two coordinates + --or: distance((x, y)) # a pair (tuple) of coordinates + --or: distance(vec) # e.g. as returned by pos() + --or: distance(mypen) # where mypen is another turtle + + Return the angle, between the line from turtle-position to position + specified by x, y and the turtle's start orientation. (Depends on + modes - "standard" or "logo") + + Example (for a Turtle instance named turtle): + >>> turtle.pos() + (10.00, 10.00) + >>> turtle.towards(0,0) + 225.0 + """ + if y is not None: + pos = Vec2D(x, y) + if isinstance(x, Vec2D): + pos = x + elif isinstance(x, tuple): + pos = Vec2D(*x) + elif isinstance(x, TNavigator): + pos = x._position + x, y = pos - self._position + result = round(math.degrees(math.atan2(y, x)), 10) % 360.0 + result /= self._degreesPerAU + return (self._angleOffset + self._angleOrient*result) % self._fullcircle + + def heading(self): + """ Return the turtle's current heading. + + No arguments. + + Example (for a Turtle instance named turtle): + >>> turtle.left(67) + >>> turtle.heading() + 67.0 + """ + x, y = self._orient + result = round(math.degrees(math.atan2(y, x)), 10) % 360.0 + result /= self._degreesPerAU + return (self._angleOffset + self._angleOrient*result) % self._fullcircle + + def setheading(self, to_angle): + """Set the orientation of the turtle to to_angle. + + Aliases: setheading | seth + + Argument: + to_angle -- a number (integer or float) + + Set the orientation of the turtle to to_angle. + Here are some common directions in degrees: + + standard - mode: logo-mode: + -------------------|-------------------- + 0 - east 0 - north + 90 - north 90 - east + 180 - west 180 - south + 270 - south 270 - west + + Example (for a Turtle instance named turtle): + >>> turtle.setheading(90) + >>> turtle.heading() + 90 + """ + angle = (to_angle - self.heading())*self._angleOrient + full = self._fullcircle + angle = (angle+full/2.)%full - full/2. + self._rotate(angle) + + def circle(self, radius, extent = None, steps = None): + """ Draw a circle with given radius. + + Arguments: + radius -- a number + extent (optional) -- a number + steps (optional) -- an integer + + Draw a circle with given radius. The center is radius units left + of the turtle; extent - an angle - determines which part of the + circle is drawn. If extent is not given, draw the entire circle. + If extent is not a full circle, one endpoint of the arc is the + current pen position. Draw the arc in counterclockwise direction + if radius is positive, otherwise in clockwise direction. Finally + the direction of the turtle is changed by the amount of extent. + + As the circle is approximated by an inscribed regular polygon, + steps determines the number of steps to use. If not given, + it will be calculated automatically. Maybe used to draw regular + polygons. + + call: circle(radius) # full circle + --or: circle(radius, extent) # arc + --or: circle(radius, extent, steps) + --or: circle(radius, steps=6) # 6-sided polygon + + Example (for a Turtle instance named turtle): + >>> turtle.circle(50) + >>> turtle.circle(120, 180) # semicircle + """ + if self.undobuffer: + self.undobuffer.push(["seq"]) + self.undobuffer.cumulate = True + speed = self.speed() + if extent is None: + extent = self._fullcircle + if steps is None: + frac = abs(extent)/self._fullcircle + steps = 1+int(min(11+abs(radius)/6.0, 59.0)*frac) + w = 1.0 * extent / steps + w2 = 0.5 * w + l = 2.0 * radius * math.sin(math.radians(w2)*self._degreesPerAU) + if radius < 0: + l, w, w2 = -l, -w, -w2 + tr = self._tracer() + dl = self._delay() + if speed == 0: + self._tracer(0, 0) + else: + self.speed(0) + self._rotate(w2) + for i in range(steps): + self.speed(speed) + self._go(l) + self.speed(0) + self._rotate(w) + self._rotate(-w2) + if speed == 0: + self._tracer(tr, dl) + self.speed(speed) + if self.undobuffer: + self.undobuffer.cumulate = False + +## three dummy methods to be implemented by child class: + + def speed(self, s=0): + """dummy method - to be overwritten by child class""" + def _tracer(self, a=None, b=None): + """dummy method - to be overwritten by child class""" + def _delay(self, n=None): + """dummy method - to be overwritten by child class""" + + fd = forward + bk = back + backward = back + rt = right + lt = left + position = pos + setpos = goto + setposition = goto + seth = setheading + + +class TPen(object): + """Drawing part of the RawTurtle. + Implements drawing properties. + """ + def __init__(self, resizemode=_CFG["resizemode"]): + self._resizemode = resizemode # or "user" or "noresize" + self.undobuffer = None + TPen._reset(self) + + def _reset(self, pencolor=_CFG["pencolor"], + fillcolor=_CFG["fillcolor"]): + self._pensize = 1 + self._shown = True + self._pencolor = pencolor + self._fillcolor = fillcolor + self._drawing = True + self._speed = 3 + self._stretchfactor = (1., 1.) + self._shearfactor = 0. + self._tilt = 0. + self._shapetrafo = (1., 0., 0., 1.) + self._outlinewidth = 1 + + def resizemode(self, rmode=None): + """Set resizemode to one of the values: "auto", "user", "noresize". + + (Optional) Argument: + rmode -- one of the strings "auto", "user", "noresize" + + Different resizemodes have the following effects: + - "auto" adapts the appearance of the turtle + corresponding to the value of pensize. + - "user" adapts the appearance of the turtle according to the + values of stretchfactor and outlinewidth (outline), + which are set by shapesize() + - "noresize" no adaption of the turtle's appearance takes place. + If no argument is given, return current resizemode. + resizemode("user") is called by a call of shapesize with arguments. + + + Examples (for a Turtle instance named turtle): + >>> turtle.resizemode("noresize") + >>> turtle.resizemode() + 'noresize' + """ + if rmode is None: + return self._resizemode + rmode = rmode.lower() + if rmode in ["auto", "user", "noresize"]: + self.pen(resizemode=rmode) + + def pensize(self, width=None): + """Set or return the line thickness. + + Aliases: pensize | width + + Argument: + width -- positive number + + Set the line thickness to width or return it. If resizemode is set + to "auto" and turtleshape is a polygon, that polygon is drawn with + the same line thickness. If no argument is given, current pensize + is returned. + + Example (for a Turtle instance named turtle): + >>> turtle.pensize() + 1 + >>> turtle.pensize(10) # from here on lines of width 10 are drawn + """ + if width is None: + return self._pensize + self.pen(pensize=width) + + + def penup(self): + """Pull the pen up -- no drawing when moving. + + Aliases: penup | pu | up + + No argument + + Example (for a Turtle instance named turtle): + >>> turtle.penup() + """ + if not self._drawing: + return + self.pen(pendown=False) + + def pendown(self): + """Pull the pen down -- drawing when moving. + + Aliases: pendown | pd | down + + No argument. + + Example (for a Turtle instance named turtle): + >>> turtle.pendown() + """ + if self._drawing: + return + self.pen(pendown=True) + + def isdown(self): + """Return True if pen is down, False if it's up. + + No argument. + + Example (for a Turtle instance named turtle): + >>> turtle.penup() + >>> turtle.isdown() + False + >>> turtle.pendown() + >>> turtle.isdown() + True + """ + return self._drawing + + def speed(self, speed=None): + """ Return or set the turtle's speed. + + Optional argument: + speed -- an integer in the range 0..10 or a speedstring (see below) + + Set the turtle's speed to an integer value in the range 0 .. 10. + If no argument is given: return current speed. + + If input is a number greater than 10 or smaller than 0.5, + speed is set to 0. + Speedstrings are mapped to speedvalues in the following way: + 'fastest' : 0 + 'fast' : 10 + 'normal' : 6 + 'slow' : 3 + 'slowest' : 1 + speeds from 1 to 10 enforce increasingly faster animation of + line drawing and turtle turning. + + Attention: + speed = 0 : *no* animation takes place. forward/back makes turtle jump + and likewise left/right make the turtle turn instantly. + + Example (for a Turtle instance named turtle): + >>> turtle.speed(3) + """ + speeds = {'fastest':0, 'fast':10, 'normal':6, 'slow':3, 'slowest':1 } + if speed is None: + return self._speed + if speed in speeds: + speed = speeds[speed] + elif 0.5 < speed < 10.5: + speed = int(round(speed)) + else: + speed = 0 + self.pen(speed=speed) + + def color(self, *args): + """Return or set the pencolor and fillcolor. + + Arguments: + Several input formats are allowed. + They use 0, 1, 2, or 3 arguments as follows: + + color() + Return the current pencolor and the current fillcolor + as a pair of color specification strings as are returned + by pencolor and fillcolor. + color(colorstring), color((r,g,b)), color(r,g,b) + inputs as in pencolor, set both, fillcolor and pencolor, + to the given value. + color(colorstring1, colorstring2), + color((r1,g1,b1), (r2,g2,b2)) + equivalent to pencolor(colorstring1) and fillcolor(colorstring2) + and analogously, if the other input format is used. + + If turtleshape is a polygon, outline and interior of that polygon + is drawn with the newly set colors. + For more info see: pencolor, fillcolor + + Example (for a Turtle instance named turtle): + >>> turtle.color('red', 'green') + >>> turtle.color() + ('red', 'green') + >>> colormode(255) + >>> color((40, 80, 120), (160, 200, 240)) + >>> color() + ('#285078', '#a0c8f0') + """ + if args: + l = len(args) + if l == 1: + pcolor = fcolor = args[0] + elif l == 2: + pcolor, fcolor = args + elif l == 3: + pcolor = fcolor = args + pcolor = self._colorstr(pcolor) + fcolor = self._colorstr(fcolor) + self.pen(pencolor=pcolor, fillcolor=fcolor) + else: + return self._color(self._pencolor), self._color(self._fillcolor) + + def pencolor(self, *args): + """ Return or set the pencolor. + + Arguments: + Four input formats are allowed: + - pencolor() + Return the current pencolor as color specification string, + possibly in hex-number format (see example). + May be used as input to another color/pencolor/fillcolor call. + - pencolor(colorstring) + s is a Tk color specification string, such as "red" or "yellow" + - pencolor((r, g, b)) + *a tuple* of r, g, and b, which represent, an RGB color, + and each of r, g, and b are in the range 0..colormode, + where colormode is either 1.0 or 255 + - pencolor(r, g, b) + r, g, and b represent an RGB color, and each of r, g, and b + are in the range 0..colormode + + If turtleshape is a polygon, the outline of that polygon is drawn + with the newly set pencolor. + + Example (for a Turtle instance named turtle): + >>> turtle.pencolor('brown') + >>> tup = (0.2, 0.8, 0.55) + >>> turtle.pencolor(tup) + >>> turtle.pencolor() + '#33cc8c' + """ + if args: + color = self._colorstr(args) + if color == self._pencolor: + return + self.pen(pencolor=color) + else: + return self._color(self._pencolor) + + def fillcolor(self, *args): + """ Return or set the fillcolor. + + Arguments: + Four input formats are allowed: + - fillcolor() + Return the current fillcolor as color specification string, + possibly in hex-number format (see example). + May be used as input to another color/pencolor/fillcolor call. + - fillcolor(colorstring) + s is a Tk color specification string, such as "red" or "yellow" + - fillcolor((r, g, b)) + *a tuple* of r, g, and b, which represent, an RGB color, + and each of r, g, and b are in the range 0..colormode, + where colormode is either 1.0 or 255 + - fillcolor(r, g, b) + r, g, and b represent an RGB color, and each of r, g, and b + are in the range 0..colormode + + If turtleshape is a polygon, the interior of that polygon is drawn + with the newly set fillcolor. + + Example (for a Turtle instance named turtle): + >>> turtle.fillcolor('violet') + >>> col = turtle.pencolor() + >>> turtle.fillcolor(col) + >>> turtle.fillcolor(0, .5, 0) + """ + if args: + color = self._colorstr(args) + if color == self._fillcolor: + return + self.pen(fillcolor=color) + else: + return self._color(self._fillcolor) + + def showturtle(self): + """Makes the turtle visible. + + Aliases: showturtle | st + + No argument. + + Example (for a Turtle instance named turtle): + >>> turtle.hideturtle() + >>> turtle.showturtle() + """ + self.pen(shown=True) + + def hideturtle(self): + """Makes the turtle invisible. + + Aliases: hideturtle | ht + + No argument. + + It's a good idea to do this while you're in the + middle of a complicated drawing, because hiding + the turtle speeds up the drawing observably. + + Example (for a Turtle instance named turtle): + >>> turtle.hideturtle() + """ + self.pen(shown=False) + + def isvisible(self): + """Return True if the Turtle is shown, False if it's hidden. + + No argument. + + Example (for a Turtle instance named turtle): + >>> turtle.hideturtle() + >>> print turtle.isvisible(): + False + """ + return self._shown + + def pen(self, pen=None, **pendict): + """Return or set the pen's attributes. + + Arguments: + pen -- a dictionary with some or all of the below listed keys. + **pendict -- one or more keyword-arguments with the below + listed keys as keywords. + + Return or set the pen's attributes in a 'pen-dictionary' + with the following key/value pairs: + "shown" : True/False + "pendown" : True/False + "pencolor" : color-string or color-tuple + "fillcolor" : color-string or color-tuple + "pensize" : positive number + "speed" : number in range 0..10 + "resizemode" : "auto" or "user" or "noresize" + "stretchfactor": (positive number, positive number) + "shearfactor": number + "outline" : positive number + "tilt" : number + + This dictionary can be used as argument for a subsequent + pen()-call to restore the former pen-state. Moreover one + or more of these attributes can be provided as keyword-arguments. + This can be used to set several pen attributes in one statement. + + + Examples (for a Turtle instance named turtle): + >>> turtle.pen(fillcolor="black", pencolor="red", pensize=10) + >>> turtle.pen() + {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1, + 'pencolor': 'red', 'pendown': True, 'fillcolor': 'black', + 'stretchfactor': (1,1), 'speed': 3, 'shearfactor': 0.0} + >>> penstate=turtle.pen() + >>> turtle.color("yellow","") + >>> turtle.penup() + >>> turtle.pen() + {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1, + 'pencolor': 'yellow', 'pendown': False, 'fillcolor': '', + 'stretchfactor': (1,1), 'speed': 3, 'shearfactor': 0.0} + >>> p.pen(penstate, fillcolor="green") + >>> p.pen() + {'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1, + 'pencolor': 'red', 'pendown': True, 'fillcolor': 'green', + 'stretchfactor': (1,1), 'speed': 3, 'shearfactor': 0.0} + """ + _pd = {"shown" : self._shown, + "pendown" : self._drawing, + "pencolor" : self._pencolor, + "fillcolor" : self._fillcolor, + "pensize" : self._pensize, + "speed" : self._speed, + "resizemode" : self._resizemode, + "stretchfactor" : self._stretchfactor, + "shearfactor" : self._shearfactor, + "outline" : self._outlinewidth, + "tilt" : self._tilt + } + + if not (pen or pendict): + return _pd + + if isinstance(pen, dict): + p = pen + else: + p = {} + p.update(pendict) + + _p_buf = {} + for key in p: + _p_buf[key] = _pd[key] + + if self.undobuffer: + self.undobuffer.push(("pen", _p_buf)) + + newLine = False + if "pendown" in p: + if self._drawing != p["pendown"]: + newLine = True + if "pencolor" in p: + if isinstance(p["pencolor"], tuple): + p["pencolor"] = self._colorstr((p["pencolor"],)) + if self._pencolor != p["pencolor"]: + newLine = True + if "pensize" in p: + if self._pensize != p["pensize"]: + newLine = True + if newLine: + self._newLine() + if "pendown" in p: + self._drawing = p["pendown"] + if "pencolor" in p: + self._pencolor = p["pencolor"] + if "pensize" in p: + self._pensize = p["pensize"] + if "fillcolor" in p: + if isinstance(p["fillcolor"], tuple): + p["fillcolor"] = self._colorstr((p["fillcolor"],)) + self._fillcolor = p["fillcolor"] + if "speed" in p: + self._speed = p["speed"] + if "resizemode" in p: + self._resizemode = p["resizemode"] + if "stretchfactor" in p: + sf = p["stretchfactor"] + if isinstance(sf, (int, float)): + sf = (sf, sf) + self._stretchfactor = sf + if "shearfactor" in p: + self._shearfactor = p["shearfactor"] + if "outline" in p: + self._outlinewidth = p["outline"] + if "shown" in p: + self._shown = p["shown"] + if "tilt" in p: + self._tilt = p["tilt"] + if "stretchfactor" in p or "tilt" in p or "shearfactor" in p: + scx, scy = self._stretchfactor + shf = self._shearfactor + sa, ca = math.sin(self._tilt), math.cos(self._tilt) + self._shapetrafo = ( scx*ca, scy*(shf*ca + sa), + -scx*sa, scy*(ca - shf*sa)) + self._update() + +## three dummy methods to be implemented by child class: + + def _newLine(self, usePos = True): + """dummy method - to be overwritten by child class""" + def _update(self, count=True, forced=False): + """dummy method - to be overwritten by child class""" + def _color(self, args): + """dummy method - to be overwritten by child class""" + def _colorstr(self, args): + """dummy method - to be overwritten by child class""" + + width = pensize + up = penup + pu = penup + pd = pendown + down = pendown + st = showturtle + ht = hideturtle + + +class _TurtleImage(object): + """Helper class: Datatype to store Turtle attributes + """ + + def __init__(self, screen, shapeIndex): + self.screen = screen + self._type = None + self._setshape(shapeIndex) + + def _setshape(self, shapeIndex): + screen = self.screen + self.shapeIndex = shapeIndex + if self._type == "polygon" == screen._shapes[shapeIndex]._type: + return + if self._type == "image" == screen._shapes[shapeIndex]._type: + return + if self._type in ["image", "polygon"]: + screen._delete(self._item) + elif self._type == "compound": + for item in self._item: + screen._delete(item) + self._type = screen._shapes[shapeIndex]._type + if self._type == "polygon": + self._item = screen._createpoly() + elif self._type == "image": + self._item = screen._createimage(screen._shapes["blank"]._data) + elif self._type == "compound": + self._item = [screen._createpoly() for item in + screen._shapes[shapeIndex]._data] + + +class RawTurtle(TPen, TNavigator): + """Animation part of the RawTurtle. + Puts RawTurtle upon a TurtleScreen and provides tools for + its animation. + """ + screens = [] + + def __init__(self, canvas=None, + shape=_CFG["shape"], + undobuffersize=_CFG["undobuffersize"], + visible=_CFG["visible"]): + if isinstance(canvas, _Screen): + self.screen = canvas + elif isinstance(canvas, TurtleScreen): + if canvas not in RawTurtle.screens: + RawTurtle.screens.append(canvas) + self.screen = canvas + elif isinstance(canvas, (ScrolledCanvas, Canvas)): + for screen in RawTurtle.screens: + if screen.cv == canvas: + self.screen = screen + break + else: + self.screen = TurtleScreen(canvas) + RawTurtle.screens.append(self.screen) + else: + raise TurtleGraphicsError("bad canvas argument %s" % canvas) + + screen = self.screen + TNavigator.__init__(self, screen.mode()) + TPen.__init__(self) + screen._turtles.append(self) + self.drawingLineItem = screen._createline() + self.turtle = _TurtleImage(screen, shape) + self._poly = None + self._creatingPoly = False + self._fillitem = self._fillpath = None + self._shown = visible + self._hidden_from_screen = False + self.currentLineItem = screen._createline() + self.currentLine = [self._position] + self.items = [self.currentLineItem] + self.stampItems = [] + self._undobuffersize = undobuffersize + self.undobuffer = Tbuffer(undobuffersize) + self._update() + + def reset(self): + """Delete the turtle's drawings and restore its default values. + + No argument. + + Delete the turtle's drawings from the screen, re-center the turtle + and set variables to the default values. + + Example (for a Turtle instance named turtle): + >>> turtle.position() + (0.00,-22.00) + >>> turtle.heading() + 100.0 + >>> turtle.reset() + >>> turtle.position() + (0.00,0.00) + >>> turtle.heading() + 0.0 + """ + TNavigator.reset(self) + TPen._reset(self) + self._clear() + self._drawturtle() + self._update() + + def setundobuffer(self, size): + """Set or disable undobuffer. + + Argument: + size -- an integer or None + + If size is an integer an empty undobuffer of given size is installed. + Size gives the maximum number of turtle-actions that can be undone + by the undo() function. + If size is None, no undobuffer is present. + + Example (for a Turtle instance named turtle): + >>> turtle.setundobuffer(42) + """ + if size is None or size <= 0: + self.undobuffer = None + else: + self.undobuffer = Tbuffer(size) + + def undobufferentries(self): + """Return count of entries in the undobuffer. + + No argument. + + Example (for a Turtle instance named turtle): + >>> while undobufferentries(): + ... undo() + """ + if self.undobuffer is None: + return 0 + return self.undobuffer.nr_of_items() + + def _clear(self): + """Delete all of pen's drawings""" + self._fillitem = self._fillpath = None + for item in self.items: + self.screen._delete(item) + self.currentLineItem = self.screen._createline() + self.currentLine = [] + if self._drawing: + self.currentLine.append(self._position) + self.items = [self.currentLineItem] + self.clearstamps() + self.setundobuffer(self._undobuffersize) + + + def clear(self): + """Delete the turtle's drawings from the screen. Do not move turtle. + + No arguments. + + Delete the turtle's drawings from the screen. Do not move turtle. + State and position of the turtle as well as drawings of other + turtles are not affected. + + Examples (for a Turtle instance named turtle): + >>> turtle.clear() + """ + self._clear() + self._update() + + def _update_data(self): + self.screen._incrementudc() + if self.screen._updatecounter != 0: + return + if len(self.currentLine)>1: + self.screen._drawline(self.currentLineItem, self.currentLine, + self._pencolor, self._pensize) + + def _update(self): + """Perform a Turtle-data update. + """ + screen = self.screen + if screen._tracing == 0: + return + elif screen._tracing == 1: + self._update_data() + self._drawturtle() + screen._update() # TurtleScreenBase + screen._delay(screen._delayvalue) # TurtleScreenBase + else: + self._update_data() + if screen._updatecounter == 0: + for t in screen.turtles(): + t._drawturtle() + screen._update() + + def _tracer(self, flag=None, delay=None): + """Turns turtle animation on/off and set delay for update drawings. + + Optional arguments: + n -- nonnegative integer + delay -- nonnegative integer + + If n is given, only each n-th regular screen update is really performed. + (Can be used to accelerate the drawing of complex graphics.) + Second arguments sets delay value (see RawTurtle.delay()) + + Example (for a Turtle instance named turtle): + >>> turtle.tracer(8, 25) + >>> dist = 2 + >>> for i in range(200): + ... turtle.fd(dist) + ... turtle.rt(90) + ... dist += 2 + """ + return self.screen.tracer(flag, delay) + + def _color(self, args): + return self.screen._color(args) + + def _colorstr(self, args): + return self.screen._colorstr(args) + + def _cc(self, args): + """Convert colortriples to hexstrings. + """ + if isinstance(args, str): + return args + try: + r, g, b = args + except (TypeError, ValueError): + raise TurtleGraphicsError("bad color arguments: %s" % str(args)) + if self.screen._colormode == 1.0: + r, g, b = [round(255.0*x) for x in (r, g, b)] + if not ((0 <= r <= 255) and (0 <= g <= 255) and (0 <= b <= 255)): + raise TurtleGraphicsError("bad color sequence: %s" % str(args)) + return "#%02x%02x%02x" % (r, g, b) + + def clone(self): + """Create and return a clone of the turtle. + + No argument. + + Create and return a clone of the turtle with same position, heading + and turtle properties. + + Example (for a Turtle instance named mick): + mick = Turtle() + joe = mick.clone() + """ + screen = self.screen + self._newLine(self._drawing) + + turtle = self.turtle + self.screen = None + self.turtle = None # too make self deepcopy-able + + q = deepcopy(self) + + self.screen = screen + self.turtle = turtle + + q.screen = screen + q.turtle = _TurtleImage(screen, self.turtle.shapeIndex) + + screen._turtles.append(q) + ttype = screen._shapes[self.turtle.shapeIndex]._type + if ttype == "polygon": + q.turtle._item = screen._createpoly() + elif ttype == "image": + q.turtle._item = screen._createimage(screen._shapes["blank"]._data) + elif ttype == "compound": + q.turtle._item = [screen._createpoly() for item in + screen._shapes[self.turtle.shapeIndex]._data] + q.currentLineItem = screen._createline() + q._update() + return q + + def shape(self, name=None): + """Set turtle shape to shape with given name / return current shapename. + + Optional argument: + name -- a string, which is a valid shapename + + Set turtle shape to shape with given name or, if name is not given, + return name of current shape. + Shape with name must exist in the TurtleScreen's shape dictionary. + Initially there are the following polygon shapes: + 'arrow', 'turtle', 'circle', 'square', 'triangle', 'classic'. + To learn about how to deal with shapes see Screen-method register_shape. + + Example (for a Turtle instance named turtle): + >>> turtle.shape() + 'arrow' + >>> turtle.shape("turtle") + >>> turtle.shape() + 'turtle' + """ + if name is None: + return self.turtle.shapeIndex + if not name in self.screen.getshapes(): + raise TurtleGraphicsError("There is no shape named %s" % name) + self.turtle._setshape(name) + self._update() + + def shapesize(self, stretch_wid=None, stretch_len=None, outline=None): + """Set/return turtle's stretchfactors/outline. Set resizemode to "user". + + Optional arguments: + stretch_wid : positive number + stretch_len : positive number + outline : positive number + + Return or set the pen's attributes x/y-stretchfactors and/or outline. + Set resizemode to "user". + If and only if resizemode is set to "user", the turtle will be displayed + stretched according to its stretchfactors: + stretch_wid is stretchfactor perpendicular to orientation + stretch_len is stretchfactor in direction of turtles orientation. + outline determines the width of the shapes's outline. + + Examples (for a Turtle instance named turtle): + >>> turtle.resizemode("user") + >>> turtle.shapesize(5, 5, 12) + >>> turtle.shapesize(outline=8) + """ + if stretch_wid is stretch_len is outline is None: + stretch_wid, stretch_len = self._stretchfactor + return stretch_wid, stretch_len, self._outlinewidth + if stretch_wid == 0 or stretch_len == 0: + raise TurtleGraphicsError("stretch_wid/stretch_len must not be zero") + if stretch_wid is not None: + if stretch_len is None: + stretchfactor = stretch_wid, stretch_wid + else: + stretchfactor = stretch_wid, stretch_len + elif stretch_len is not None: + stretchfactor = self._stretchfactor[0], stretch_len + else: + stretchfactor = self._stretchfactor + if outline is None: + outline = self._outlinewidth + self.pen(resizemode="user", + stretchfactor=stretchfactor, outline=outline) + + def shearfactor(self, shear=None): + """Set or return the current shearfactor. + + Optional argument: shear -- number, tangent of the shear angle + + Shear the turtleshape according to the given shearfactor shear, + which is the tangent of the shear angle. DO NOT change the + turtle's heading (direction of movement). + If shear is not given: return the current shearfactor, i. e. the + tangent of the shear angle, by which lines parallel to the + heading of the turtle are sheared. + + Examples (for a Turtle instance named turtle): + >>> turtle.shape("circle") + >>> turtle.shapesize(5,2) + >>> turtle.shearfactor(0.5) + >>> turtle.shearfactor() + >>> 0.5 + """ + if shear is None: + return self._shearfactor + self.pen(resizemode="user", shearfactor=shear) + + def settiltangle(self, angle): + """Rotate the turtleshape to point in the specified direction + + Argument: angle -- number + + Rotate the turtleshape to point in the direction specified by angle, + regardless of its current tilt-angle. DO NOT change the turtle's + heading (direction of movement). + + Deprecated since Python 3.1 + + Examples (for a Turtle instance named turtle): + >>> turtle.shape("circle") + >>> turtle.shapesize(5,2) + >>> turtle.settiltangle(45) + >>> turtle.stamp() + >>> turtle.fd(50) + >>> turtle.settiltangle(-45) + >>> turtle.stamp() + >>> turtle.fd(50) + """ + warnings._deprecated("turtle.RawTurtle.settiltangle()", + "{name!r} is deprecated since Python 3.1 and scheduled " + "for removal in Python {remove}. Use tiltangle() instead.", + remove=(3, 13)) + self.tiltangle(angle) + + def tiltangle(self, angle=None): + """Set or return the current tilt-angle. + + Optional argument: angle -- number + + Rotate the turtleshape to point in the direction specified by angle, + regardless of its current tilt-angle. DO NOT change the turtle's + heading (direction of movement). + If angle is not given: return the current tilt-angle, i. e. the angle + between the orientation of the turtleshape and the heading of the + turtle (its direction of movement). + + (Incorrectly marked as deprecated since Python 3.1, it is really + settiltangle that is deprecated.) + + Examples (for a Turtle instance named turtle): + >>> turtle.shape("circle") + >>> turtle.shapesize(5, 2) + >>> turtle.tiltangle() + 0.0 + >>> turtle.tiltangle(45) + >>> turtle.tiltangle() + 45.0 + >>> turtle.stamp() + >>> turtle.fd(50) + >>> turtle.tiltangle(-45) + >>> turtle.tiltangle() + 315.0 + >>> turtle.stamp() + >>> turtle.fd(50) + """ + if angle is None: + tilt = -math.degrees(self._tilt) * self._angleOrient + return (tilt / self._degreesPerAU) % self._fullcircle + else: + tilt = -angle * self._degreesPerAU * self._angleOrient + tilt = math.radians(tilt) % math.tau + self.pen(resizemode="user", tilt=tilt) + + def tilt(self, angle): + """Rotate the turtleshape by angle. + + Argument: + angle - a number + + Rotate the turtleshape by angle from its current tilt-angle, + but do NOT change the turtle's heading (direction of movement). + + Examples (for a Turtle instance named turtle): + >>> turtle.shape("circle") + >>> turtle.shapesize(5,2) + >>> turtle.tilt(30) + >>> turtle.fd(50) + >>> turtle.tilt(30) + >>> turtle.fd(50) + """ + self.tiltangle(angle + self.tiltangle()) + + def shapetransform(self, t11=None, t12=None, t21=None, t22=None): + """Set or return the current transformation matrix of the turtle shape. + + Optional arguments: t11, t12, t21, t22 -- numbers. + + If none of the matrix elements are given, return the transformation + matrix. + Otherwise set the given elements and transform the turtleshape + according to the matrix consisting of first row t11, t12 and + second row t21, 22. + Modify stretchfactor, shearfactor and tiltangle according to the + given matrix. + + Examples (for a Turtle instance named turtle): + >>> turtle.shape("square") + >>> turtle.shapesize(4,2) + >>> turtle.shearfactor(-0.5) + >>> turtle.shapetransform() + (4.0, -1.0, -0.0, 2.0) + """ + if t11 is t12 is t21 is t22 is None: + return self._shapetrafo + m11, m12, m21, m22 = self._shapetrafo + if t11 is not None: m11 = t11 + if t12 is not None: m12 = t12 + if t21 is not None: m21 = t21 + if t22 is not None: m22 = t22 + if t11 * t22 - t12 * t21 == 0: + raise TurtleGraphicsError("Bad shape transform matrix: must not be singular") + self._shapetrafo = (m11, m12, m21, m22) + alfa = math.atan2(-m21, m11) % math.tau + sa, ca = math.sin(alfa), math.cos(alfa) + a11, a12, a21, a22 = (ca*m11 - sa*m21, ca*m12 - sa*m22, + sa*m11 + ca*m21, sa*m12 + ca*m22) + self._stretchfactor = a11, a22 + self._shearfactor = a12/a22 + self._tilt = alfa + self.pen(resizemode="user") + + + def _polytrafo(self, poly): + """Computes transformed polygon shapes from a shape + according to current position and heading. + """ + screen = self.screen + p0, p1 = self._position + e0, e1 = self._orient + e = Vec2D(e0, e1 * screen.yscale / screen.xscale) + e0, e1 = (1.0 / abs(e)) * e + return [(p0+(e1*x+e0*y)/screen.xscale, p1+(-e0*x+e1*y)/screen.yscale) + for (x, y) in poly] + + def get_shapepoly(self): + """Return the current shape polygon as tuple of coordinate pairs. + + No argument. + + Examples (for a Turtle instance named turtle): + >>> turtle.shape("square") + >>> turtle.shapetransform(4, -1, 0, 2) + >>> turtle.get_shapepoly() + ((50, -20), (30, 20), (-50, 20), (-30, -20)) + + """ + shape = self.screen._shapes[self.turtle.shapeIndex] + if shape._type == "polygon": + return self._getshapepoly(shape._data, shape._type == "compound") + # else return None + + def _getshapepoly(self, polygon, compound=False): + """Calculate transformed shape polygon according to resizemode + and shapetransform. + """ + if self._resizemode == "user" or compound: + t11, t12, t21, t22 = self._shapetrafo + elif self._resizemode == "auto": + l = max(1, self._pensize/5.0) + t11, t12, t21, t22 = l, 0, 0, l + elif self._resizemode == "noresize": + return polygon + return tuple((t11*x + t12*y, t21*x + t22*y) for (x, y) in polygon) + + def _drawturtle(self): + """Manages the correct rendering of the turtle with respect to + its shape, resizemode, stretch and tilt etc.""" + screen = self.screen + shape = screen._shapes[self.turtle.shapeIndex] + ttype = shape._type + titem = self.turtle._item + if self._shown and screen._updatecounter == 0 and screen._tracing > 0: + self._hidden_from_screen = False + tshape = shape._data + if ttype == "polygon": + if self._resizemode == "noresize": w = 1 + elif self._resizemode == "auto": w = self._pensize + else: w =self._outlinewidth + shape = self._polytrafo(self._getshapepoly(tshape)) + fc, oc = self._fillcolor, self._pencolor + screen._drawpoly(titem, shape, fill=fc, outline=oc, + width=w, top=True) + elif ttype == "image": + screen._drawimage(titem, self._position, tshape) + elif ttype == "compound": + for item, (poly, fc, oc) in zip(titem, tshape): + poly = self._polytrafo(self._getshapepoly(poly, True)) + screen._drawpoly(item, poly, fill=self._cc(fc), + outline=self._cc(oc), width=self._outlinewidth, top=True) + else: + if self._hidden_from_screen: + return + if ttype == "polygon": + screen._drawpoly(titem, ((0, 0), (0, 0), (0, 0)), "", "") + elif ttype == "image": + screen._drawimage(titem, self._position, + screen._shapes["blank"]._data) + elif ttype == "compound": + for item in titem: + screen._drawpoly(item, ((0, 0), (0, 0), (0, 0)), "", "") + self._hidden_from_screen = True + +############################## stamp stuff ############################### + + def stamp(self): + """Stamp a copy of the turtleshape onto the canvas and return its id. + + No argument. + + Stamp a copy of the turtle shape onto the canvas at the current + turtle position. Return a stamp_id for that stamp, which can be + used to delete it by calling clearstamp(stamp_id). + + Example (for a Turtle instance named turtle): + >>> turtle.color("blue") + >>> turtle.stamp() + 13 + >>> turtle.fd(50) + """ + screen = self.screen + shape = screen._shapes[self.turtle.shapeIndex] + ttype = shape._type + tshape = shape._data + if ttype == "polygon": + stitem = screen._createpoly() + if self._resizemode == "noresize": w = 1 + elif self._resizemode == "auto": w = self._pensize + else: w =self._outlinewidth + shape = self._polytrafo(self._getshapepoly(tshape)) + fc, oc = self._fillcolor, self._pencolor + screen._drawpoly(stitem, shape, fill=fc, outline=oc, + width=w, top=True) + elif ttype == "image": + stitem = screen._createimage("") + screen._drawimage(stitem, self._position, tshape) + elif ttype == "compound": + stitem = [] + for element in tshape: + item = screen._createpoly() + stitem.append(item) + stitem = tuple(stitem) + for item, (poly, fc, oc) in zip(stitem, tshape): + poly = self._polytrafo(self._getshapepoly(poly, True)) + screen._drawpoly(item, poly, fill=self._cc(fc), + outline=self._cc(oc), width=self._outlinewidth, top=True) + self.stampItems.append(stitem) + self.undobuffer.push(("stamp", stitem)) + return stitem + + def _clearstamp(self, stampid): + """does the work for clearstamp() and clearstamps() + """ + if stampid in self.stampItems: + if isinstance(stampid, tuple): + for subitem in stampid: + self.screen._delete(subitem) + else: + self.screen._delete(stampid) + self.stampItems.remove(stampid) + # Delete stampitem from undobuffer if necessary + # if clearstamp is called directly. + item = ("stamp", stampid) + buf = self.undobuffer + if item not in buf.buffer: + return + index = buf.buffer.index(item) + buf.buffer.remove(item) + if index <= buf.ptr: + buf.ptr = (buf.ptr - 1) % buf.bufsize + buf.buffer.insert((buf.ptr+1)%buf.bufsize, [None]) + + def clearstamp(self, stampid): + """Delete stamp with given stampid + + Argument: + stampid - an integer, must be return value of previous stamp() call. + + Example (for a Turtle instance named turtle): + >>> turtle.color("blue") + >>> astamp = turtle.stamp() + >>> turtle.fd(50) + >>> turtle.clearstamp(astamp) + """ + self._clearstamp(stampid) + self._update() + + def clearstamps(self, n=None): + """Delete all or first/last n of turtle's stamps. + + Optional argument: + n -- an integer + + If n is None, delete all of pen's stamps, + else if n > 0 delete first n stamps + else if n < 0 delete last n stamps. + + Example (for a Turtle instance named turtle): + >>> for i in range(8): + ... turtle.stamp(); turtle.fd(30) + ... + >>> turtle.clearstamps(2) + >>> turtle.clearstamps(-2) + >>> turtle.clearstamps() + """ + if n is None: + toDelete = self.stampItems[:] + elif n >= 0: + toDelete = self.stampItems[:n] + else: + toDelete = self.stampItems[n:] + for item in toDelete: + self._clearstamp(item) + self._update() + + def _goto(self, end): + """Move the pen to the point end, thereby drawing a line + if pen is down. All other methods for turtle movement depend + on this one. + """ + ## Version with undo-stuff + go_modes = ( self._drawing, + self._pencolor, + self._pensize, + isinstance(self._fillpath, list)) + screen = self.screen + undo_entry = ("go", self._position, end, go_modes, + (self.currentLineItem, + self.currentLine[:], + screen._pointlist(self.currentLineItem), + self.items[:]) + ) + if self.undobuffer: + self.undobuffer.push(undo_entry) + start = self._position + if self._speed and screen._tracing == 1: + diff = (end-start) + diffsq = (diff[0]*screen.xscale)**2 + (diff[1]*screen.yscale)**2 + nhops = 1+int((diffsq**0.5)/(3*(1.1**self._speed)*self._speed)) + delta = diff * (1.0/nhops) + for n in range(1, nhops): + if n == 1: + top = True + else: + top = False + self._position = start + delta * n + if self._drawing: + screen._drawline(self.drawingLineItem, + (start, self._position), + self._pencolor, self._pensize, top) + self._update() + if self._drawing: + screen._drawline(self.drawingLineItem, ((0, 0), (0, 0)), + fill="", width=self._pensize) + # Turtle now at end, + if self._drawing: # now update currentLine + self.currentLine.append(end) + if isinstance(self._fillpath, list): + self._fillpath.append(end) + ###### vererbung!!!!!!!!!!!!!!!!!!!!!! + self._position = end + if self._creatingPoly: + self._poly.append(end) + if len(self.currentLine) > 42: # 42! answer to the ultimate question + # of life, the universe and everything + self._newLine() + self._update() #count=True) + + def _undogoto(self, entry): + """Reverse a _goto. Used for undo() + """ + old, new, go_modes, coodata = entry + drawing, pc, ps, filling = go_modes + cLI, cL, pl, items = coodata + screen = self.screen + if abs(self._position - new) > 0.5: + print ("undogoto: HALLO-DA-STIMMT-WAS-NICHT!") + # restore former situation + self.currentLineItem = cLI + self.currentLine = cL + + if pl == [(0, 0), (0, 0)]: + usepc = "" + else: + usepc = pc + screen._drawline(cLI, pl, fill=usepc, width=ps) + + todelete = [i for i in self.items if (i not in items) and + (screen._type(i) == "line")] + for i in todelete: + screen._delete(i) + self.items.remove(i) + + start = old + if self._speed and screen._tracing == 1: + diff = old - new + diffsq = (diff[0]*screen.xscale)**2 + (diff[1]*screen.yscale)**2 + nhops = 1+int((diffsq**0.5)/(3*(1.1**self._speed)*self._speed)) + delta = diff * (1.0/nhops) + for n in range(1, nhops): + if n == 1: + top = True + else: + top = False + self._position = new + delta * n + if drawing: + screen._drawline(self.drawingLineItem, + (start, self._position), + pc, ps, top) + self._update() + if drawing: + screen._drawline(self.drawingLineItem, ((0, 0), (0, 0)), + fill="", width=ps) + # Turtle now at position old, + self._position = old + ## if undo is done during creating a polygon, the last vertex + ## will be deleted. if the polygon is entirely deleted, + ## creatingPoly will be set to False. + ## Polygons created before the last one will not be affected by undo() + if self._creatingPoly: + if len(self._poly) > 0: + self._poly.pop() + if self._poly == []: + self._creatingPoly = False + self._poly = None + if filling: + if self._fillpath == []: + self._fillpath = None + print("Unwahrscheinlich in _undogoto!") + elif self._fillpath is not None: + self._fillpath.pop() + self._update() #count=True) + + def _rotate(self, angle): + """Turns pen clockwise by angle. + """ + if self.undobuffer: + self.undobuffer.push(("rot", angle, self._degreesPerAU)) + angle *= self._degreesPerAU + neworient = self._orient.rotate(angle) + tracing = self.screen._tracing + if tracing == 1 and self._speed > 0: + anglevel = 3.0 * self._speed + steps = 1 + int(abs(angle)/anglevel) + delta = 1.0*angle/steps + for _ in range(steps): + self._orient = self._orient.rotate(delta) + self._update() + self._orient = neworient + self._update() + + def _newLine(self, usePos=True): + """Closes current line item and starts a new one. + Remark: if current line became too long, animation + performance (via _drawline) slowed down considerably. + """ + if len(self.currentLine) > 1: + self.screen._drawline(self.currentLineItem, self.currentLine, + self._pencolor, self._pensize) + self.currentLineItem = self.screen._createline() + self.items.append(self.currentLineItem) + else: + self.screen._drawline(self.currentLineItem, top=True) + self.currentLine = [] + if usePos: + self.currentLine = [self._position] + + def filling(self): + """Return fillstate (True if filling, False else). + + No argument. + + Example (for a Turtle instance named turtle): + >>> turtle.begin_fill() + >>> if turtle.filling(): + ... turtle.pensize(5) + ... else: + ... turtle.pensize(3) + """ + return isinstance(self._fillpath, list) + + def begin_fill(self): + """Called just before drawing a shape to be filled. + + No argument. + + Example (for a Turtle instance named turtle): + >>> turtle.color("black", "red") + >>> turtle.begin_fill() + >>> turtle.circle(60) + >>> turtle.end_fill() + """ + if not self.filling(): + self._fillitem = self.screen._createpoly() + self.items.append(self._fillitem) + self._fillpath = [self._position] + self._newLine() + if self.undobuffer: + self.undobuffer.push(("beginfill", self._fillitem)) + self._update() + + + def end_fill(self): + """Fill the shape drawn after the call begin_fill(). + + No argument. + + Example (for a Turtle instance named turtle): + >>> turtle.color("black", "red") + >>> turtle.begin_fill() + >>> turtle.circle(60) + >>> turtle.end_fill() + """ + if self.filling(): + if len(self._fillpath) > 2: + self.screen._drawpoly(self._fillitem, self._fillpath, + fill=self._fillcolor) + if self.undobuffer: + self.undobuffer.push(("dofill", self._fillitem)) + self._fillitem = self._fillpath = None + self._update() + + def dot(self, size=None, *color): + """Draw a dot with diameter size, using color. + + Optional arguments: + size -- an integer >= 1 (if given) + color -- a colorstring or a numeric color tuple + + Draw a circular dot with diameter size, using color. + If size is not given, the maximum of pensize+4 and 2*pensize is used. + + Example (for a Turtle instance named turtle): + >>> turtle.dot() + >>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50) + """ + if not color: + if isinstance(size, (str, tuple)): + color = self._colorstr(size) + size = self._pensize + max(self._pensize, 4) + else: + color = self._pencolor + if not size: + size = self._pensize + max(self._pensize, 4) + else: + if size is None: + size = self._pensize + max(self._pensize, 4) + color = self._colorstr(color) + if hasattr(self.screen, "_dot"): + item = self.screen._dot(self._position, size, color) + self.items.append(item) + if self.undobuffer: + self.undobuffer.push(("dot", item)) + else: + pen = self.pen() + if self.undobuffer: + self.undobuffer.push(["seq"]) + self.undobuffer.cumulate = True + try: + if self.resizemode() == 'auto': + self.ht() + self.pendown() + self.pensize(size) + self.pencolor(color) + self.forward(0) + finally: + self.pen(pen) + if self.undobuffer: + self.undobuffer.cumulate = False + + def _write(self, txt, align, font): + """Performs the writing for write() + """ + item, end = self.screen._write(self._position, txt, align, font, + self._pencolor) + self._update() + self.items.append(item) + if self.undobuffer: + self.undobuffer.push(("wri", item)) + return end + + def write(self, arg, move=False, align="left", font=("Arial", 8, "normal")): + """Write text at the current turtle position. + + Arguments: + arg -- info, which is to be written to the TurtleScreen + move (optional) -- True/False + align (optional) -- one of the strings "left", "center" or right" + font (optional) -- a triple (fontname, fontsize, fonttype) + + Write text - the string representation of arg - at the current + turtle position according to align ("left", "center" or right") + and with the given font. + If move is True, the pen is moved to the bottom-right corner + of the text. By default, move is False. + + Example (for a Turtle instance named turtle): + >>> turtle.write('Home = ', True, align="center") + >>> turtle.write((0,0), True) + """ + if self.undobuffer: + self.undobuffer.push(["seq"]) + self.undobuffer.cumulate = True + end = self._write(str(arg), align.lower(), font) + if move: + x, y = self.pos() + self.setpos(end, y) + if self.undobuffer: + self.undobuffer.cumulate = False + + def begin_poly(self): + """Start recording the vertices of a polygon. + + No argument. + + Start recording the vertices of a polygon. Current turtle position + is first point of polygon. + + Example (for a Turtle instance named turtle): + >>> turtle.begin_poly() + """ + self._poly = [self._position] + self._creatingPoly = True + + def end_poly(self): + """Stop recording the vertices of a polygon. + + No argument. + + Stop recording the vertices of a polygon. Current turtle position is + last point of polygon. This will be connected with the first point. + + Example (for a Turtle instance named turtle): + >>> turtle.end_poly() + """ + self._creatingPoly = False + + def get_poly(self): + """Return the lastly recorded polygon. + + No argument. + + Example (for a Turtle instance named turtle): + >>> p = turtle.get_poly() + >>> turtle.register_shape("myFavouriteShape", p) + """ + ## check if there is any poly? + if self._poly is not None: + return tuple(self._poly) + + def getscreen(self): + """Return the TurtleScreen object, the turtle is drawing on. + + No argument. + + Return the TurtleScreen object, the turtle is drawing on. + So TurtleScreen-methods can be called for that object. + + Example (for a Turtle instance named turtle): + >>> ts = turtle.getscreen() + >>> ts + + >>> ts.bgcolor("pink") + """ + return self.screen + + def getturtle(self): + """Return the Turtleobject itself. + + No argument. + + Only reasonable use: as a function to return the 'anonymous turtle': + + Example: + >>> pet = getturtle() + >>> pet.fd(50) + >>> pet + + >>> turtles() + [] + """ + return self + + getpen = getturtle + + + ################################################################ + ### screen oriented methods recurring to methods of TurtleScreen + ################################################################ + + def _delay(self, delay=None): + """Set delay value which determines speed of turtle animation. + """ + return self.screen.delay(delay) + + def onclick(self, fun, btn=1, add=None): + """Bind fun to mouse-click event on this turtle on canvas. + + Arguments: + fun -- a function with two arguments, to which will be assigned + the coordinates of the clicked point on the canvas. + btn -- number of the mouse-button defaults to 1 (left mouse button). + add -- True or False. If True, new binding will be added, otherwise + it will replace a former binding. + + Example for the anonymous turtle, i. e. the procedural way: + + >>> def turn(x, y): + ... left(360) + ... + >>> onclick(turn) # Now clicking into the turtle will turn it. + >>> onclick(None) # event-binding will be removed + """ + self.screen._onclick(self.turtle._item, fun, btn, add) + self._update() + + def onrelease(self, fun, btn=1, add=None): + """Bind fun to mouse-button-release event on this turtle on canvas. + + Arguments: + fun -- a function with two arguments, to which will be assigned + the coordinates of the clicked point on the canvas. + btn -- number of the mouse-button defaults to 1 (left mouse button). + + Example (for a MyTurtle instance named joe): + >>> class MyTurtle(Turtle): + ... def glow(self,x,y): + ... self.fillcolor("red") + ... def unglow(self,x,y): + ... self.fillcolor("") + ... + >>> joe = MyTurtle() + >>> joe.onclick(joe.glow) + >>> joe.onrelease(joe.unglow) + + Clicking on joe turns fillcolor red, unclicking turns it to + transparent. + """ + self.screen._onrelease(self.turtle._item, fun, btn, add) + self._update() + + def ondrag(self, fun, btn=1, add=None): + """Bind fun to mouse-move event on this turtle on canvas. + + Arguments: + fun -- a function with two arguments, to which will be assigned + the coordinates of the clicked point on the canvas. + btn -- number of the mouse-button defaults to 1 (left mouse button). + + Every sequence of mouse-move-events on a turtle is preceded by a + mouse-click event on that turtle. + + Example (for a Turtle instance named turtle): + >>> turtle.ondrag(turtle.goto) + + Subsequently clicking and dragging a Turtle will move it + across the screen thereby producing handdrawings (if pen is + down). + """ + self.screen._ondrag(self.turtle._item, fun, btn, add) + + + def _undo(self, action, data): + """Does the main part of the work for undo() + """ + if self.undobuffer is None: + return + if action == "rot": + angle, degPAU = data + self._rotate(-angle*degPAU/self._degreesPerAU) + dummy = self.undobuffer.pop() + elif action == "stamp": + stitem = data[0] + self.clearstamp(stitem) + elif action == "go": + self._undogoto(data) + elif action in ["wri", "dot"]: + item = data[0] + self.screen._delete(item) + self.items.remove(item) + elif action == "dofill": + item = data[0] + self.screen._drawpoly(item, ((0, 0),(0, 0),(0, 0)), + fill="", outline="") + elif action == "beginfill": + item = data[0] + self._fillitem = self._fillpath = None + if item in self.items: + self.screen._delete(item) + self.items.remove(item) + elif action == "pen": + TPen.pen(self, data[0]) + self.undobuffer.pop() + + def undo(self): + """undo (repeatedly) the last turtle action. + + No argument. + + undo (repeatedly) the last turtle action. + Number of available undo actions is determined by the size of + the undobuffer. + + Example (for a Turtle instance named turtle): + >>> for i in range(4): + ... turtle.fd(50); turtle.lt(80) + ... + >>> for i in range(8): + ... turtle.undo() + ... + """ + if self.undobuffer is None: + return + item = self.undobuffer.pop() + action = item[0] + data = item[1:] + if action == "seq": + while data: + item = data.pop() + self._undo(item[0], item[1:]) + else: + self._undo(action, data) + + turtlesize = shapesize + +RawPen = RawTurtle + +### Screen - Singleton ######################## + +def Screen(): + """Return the singleton screen object. + If none exists at the moment, create a new one and return it, + else return the existing one.""" + if Turtle._screen is None: + Turtle._screen = _Screen() + return Turtle._screen + +class _Screen(TurtleScreen): + + _root = None + _canvas = None + _title = _CFG["title"] + + def __init__(self): + # XXX there is no need for this code to be conditional, + # as there will be only a single _Screen instance, anyway + # XXX actually, the turtle demo is injecting root window, + # so perhaps the conditional creation of a root should be + # preserved (perhaps by passing it as an optional parameter) + if _Screen._root is None: + _Screen._root = self._root = _Root() + self._root.title(_Screen._title) + self._root.ondestroy(self._destroy) + if _Screen._canvas is None: + width = _CFG["width"] + height = _CFG["height"] + canvwidth = _CFG["canvwidth"] + canvheight = _CFG["canvheight"] + leftright = _CFG["leftright"] + topbottom = _CFG["topbottom"] + self._root.setupcanvas(width, height, canvwidth, canvheight) + _Screen._canvas = self._root._getcanvas() + TurtleScreen.__init__(self, _Screen._canvas) + self.setup(width, height, leftright, topbottom) + + def setup(self, width=_CFG["width"], height=_CFG["height"], + startx=_CFG["leftright"], starty=_CFG["topbottom"]): + """ Set the size and position of the main window. + + Arguments: + width: as integer a size in pixels, as float a fraction of the screen. + Default is 50% of screen. + height: as integer the height in pixels, as float a fraction of the + screen. Default is 75% of screen. + startx: if positive, starting position in pixels from the left + edge of the screen, if negative from the right edge + Default, startx=None is to center window horizontally. + starty: if positive, starting position in pixels from the top + edge of the screen, if negative from the bottom edge + Default, starty=None is to center window vertically. + + Examples (for a Screen instance named screen): + >>> screen.setup (width=200, height=200, startx=0, starty=0) + + sets window to 200x200 pixels, in upper left of screen + + >>> screen.setup(width=.75, height=0.5, startx=None, starty=None) + + sets window to 75% of screen by 50% of screen and centers + """ + if not hasattr(self._root, "set_geometry"): + return + sw = self._root.win_width() + sh = self._root.win_height() + if isinstance(width, float) and 0 <= width <= 1: + width = sw*width + if startx is None: + startx = (sw - width) / 2 + if isinstance(height, float) and 0 <= height <= 1: + height = sh*height + if starty is None: + starty = (sh - height) / 2 + self._root.set_geometry(width, height, startx, starty) + self.update() + + def title(self, titlestring): + """Set title of turtle-window + + Argument: + titlestring -- a string, to appear in the titlebar of the + turtle graphics window. + + This is a method of Screen-class. Not available for TurtleScreen- + objects. + + Example (for a Screen instance named screen): + >>> screen.title("Welcome to the turtle-zoo!") + """ + if _Screen._root is not None: + _Screen._root.title(titlestring) + _Screen._title = titlestring + + def _destroy(self): + root = self._root + if root is _Screen._root: + Turtle._pen = None + Turtle._screen = None + _Screen._root = None + _Screen._canvas = None + TurtleScreen._RUNNING = False + root.destroy() + + def bye(self): + """Shut the turtlegraphics window. + + Example (for a TurtleScreen instance named screen): + >>> screen.bye() + """ + self._destroy() + + def exitonclick(self): + """Go into mainloop until the mouse is clicked. + + No arguments. + + Bind bye() method to mouseclick on TurtleScreen. + If "using_IDLE" - value in configuration dictionary is False + (default value), enter mainloop. + If IDLE with -n switch (no subprocess) is used, this value should be + set to True in turtle.cfg. In this case IDLE's mainloop + is active also for the client script. + + This is a method of the Screen-class and not available for + TurtleScreen instances. + + Example (for a Screen instance named screen): + >>> screen.exitonclick() + + """ + def exitGracefully(x, y): + """Screen.bye() with two dummy-parameters""" + self.bye() + self.onclick(exitGracefully) + if _CFG["using_IDLE"]: + return + try: + mainloop() + except AttributeError: + exit(0) + +class Turtle(RawTurtle): + """RawTurtle auto-creating (scrolled) canvas. + + When a Turtle object is created or a function derived from some + Turtle method is called a TurtleScreen object is automatically created. + """ + _pen = None + _screen = None + + def __init__(self, + shape=_CFG["shape"], + undobuffersize=_CFG["undobuffersize"], + visible=_CFG["visible"]): + if Turtle._screen is None: + Turtle._screen = Screen() + RawTurtle.__init__(self, Turtle._screen, + shape=shape, + undobuffersize=undobuffersize, + visible=visible) + +Pen = Turtle + +def write_docstringdict(filename="turtle_docstringdict"): + """Create and write docstring-dictionary to file. + + Optional argument: + filename -- a string, used as filename + default value is turtle_docstringdict + + Has to be called explicitly, (not used by the turtle-graphics classes) + The docstring dictionary will be written to the Python script .py + It is intended to serve as a template for translation of the docstrings + into different languages. + """ + docsdict = {} + + for methodname in _tg_screen_functions: + key = "_Screen."+methodname + docsdict[key] = eval(key).__doc__ + for methodname in _tg_turtle_functions: + key = "Turtle."+methodname + docsdict[key] = eval(key).__doc__ + + with open("%s.py" % filename,"w") as f: + keys = sorted(x for x in docsdict + if x.split('.')[1] not in _alias_list) + f.write('docsdict = {\n\n') + for key in keys[:-1]: + f.write('%s :\n' % repr(key)) + f.write(' """%s\n""",\n\n' % docsdict[key]) + key = keys[-1] + f.write('%s :\n' % repr(key)) + f.write(' """%s\n"""\n\n' % docsdict[key]) + f.write("}\n") + f.close() + +def read_docstrings(lang): + """Read in docstrings from lang-specific docstring dictionary. + + Transfer docstrings, translated to lang, from a dictionary-file + to the methods of classes Screen and Turtle and - in revised form - + to the corresponding functions. + """ + modname = "turtle_docstringdict_%(language)s" % {'language':lang.lower()} + module = __import__(modname) + docsdict = module.docsdict + for key in docsdict: + try: +# eval(key).im_func.__doc__ = docsdict[key] + eval(key).__doc__ = docsdict[key] + except Exception: + print("Bad docstring-entry: %s" % key) + +_LANGUAGE = _CFG["language"] + +try: + if _LANGUAGE != "english": + read_docstrings(_LANGUAGE) +except ImportError: + print("Cannot find docsdict for", _LANGUAGE) +except Exception: + print ("Unknown Error when trying to import %s-docstring-dictionary" % + _LANGUAGE) + + +def getmethparlist(ob): + """Get strings describing the arguments for the given object + + Returns a pair of strings representing function parameter lists + including parenthesis. The first string is suitable for use in + function definition and the second is suitable for use in function + call. The "self" parameter is not included. + """ + defText = callText = "" + # bit of a hack for methods - turn it into a function + # but we drop the "self" param. + # Try and build one for Python defined functions + args, varargs, varkw = inspect.getargs(ob.__code__) + items2 = args[1:] + realArgs = args[1:] + defaults = ob.__defaults__ or [] + defaults = ["=%r" % (value,) for value in defaults] + defaults = [""] * (len(realArgs)-len(defaults)) + defaults + items1 = [arg + dflt for arg, dflt in zip(realArgs, defaults)] + if varargs is not None: + items1.append("*" + varargs) + items2.append("*" + varargs) + if varkw is not None: + items1.append("**" + varkw) + items2.append("**" + varkw) + defText = ", ".join(items1) + defText = "(%s)" % defText + callText = ", ".join(items2) + callText = "(%s)" % callText + return defText, callText + +def _turtle_docrevise(docstr): + """To reduce docstrings from RawTurtle class for functions + """ + import re + if docstr is None: + return None + turtlename = _CFG["exampleturtle"] + newdocstr = docstr.replace("%s." % turtlename,"") + parexp = re.compile(r' \(.+ %s\):' % turtlename) + newdocstr = parexp.sub(":", newdocstr) + return newdocstr + +def _screen_docrevise(docstr): + """To reduce docstrings from TurtleScreen class for functions + """ + import re + if docstr is None: + return None + screenname = _CFG["examplescreen"] + newdocstr = docstr.replace("%s." % screenname,"") + parexp = re.compile(r' \(.+ %s\):' % screenname) + newdocstr = parexp.sub(":", newdocstr) + return newdocstr + +## The following mechanism makes all methods of RawTurtle and Turtle available +## as functions. So we can enhance, change, add, delete methods to these +## classes and do not need to change anything here. + +__func_body = """\ +def {name}{paramslist}: + if {obj} is None: + if not TurtleScreen._RUNNING: + TurtleScreen._RUNNING = True + raise Terminator + {obj} = {init} + try: + return {obj}.{name}{argslist} + except TK.TclError: + if not TurtleScreen._RUNNING: + TurtleScreen._RUNNING = True + raise Terminator + raise +""" + +def _make_global_funcs(functions, cls, obj, init, docrevise): + for methodname in functions: + method = getattr(cls, methodname) + pl1, pl2 = getmethparlist(method) + if pl1 == "": + print(">>>>>>", pl1, pl2) + continue + defstr = __func_body.format(obj=obj, init=init, name=methodname, + paramslist=pl1, argslist=pl2) + exec(defstr, globals()) + globals()[methodname].__doc__ = docrevise(method.__doc__) + +_make_global_funcs(_tg_screen_functions, _Screen, + 'Turtle._screen', 'Screen()', _screen_docrevise) +_make_global_funcs(_tg_turtle_functions, Turtle, + 'Turtle._pen', 'Turtle()', _turtle_docrevise) + + +done = mainloop + +if __name__ == "__main__": + def switchpen(): + if isdown(): + pu() + else: + pd() + + def demo1(): + """Demo of old turtle.py - module""" + reset() + tracer(True) + up() + backward(100) + down() + # draw 3 squares; the last filled + width(3) + for i in range(3): + if i == 2: + begin_fill() + for _ in range(4): + forward(20) + left(90) + if i == 2: + color("maroon") + end_fill() + up() + forward(30) + down() + width(1) + color("black") + # move out of the way + tracer(False) + up() + right(90) + forward(100) + right(90) + forward(100) + right(180) + down() + # some text + write("startstart", 1) + write("start", 1) + color("red") + # staircase + for i in range(5): + forward(20) + left(90) + forward(20) + right(90) + # filled staircase + tracer(True) + begin_fill() + for i in range(5): + forward(20) + left(90) + forward(20) + right(90) + end_fill() + # more text + + def demo2(): + """Demo of some new features.""" + speed(1) + st() + pensize(3) + setheading(towards(0, 0)) + radius = distance(0, 0)/2.0 + rt(90) + for _ in range(18): + switchpen() + circle(radius, 10) + write("wait a moment...") + while undobufferentries(): + undo() + reset() + lt(90) + colormode(255) + laenge = 10 + pencolor("green") + pensize(3) + lt(180) + for i in range(-2, 16): + if i > 0: + begin_fill() + fillcolor(255-15*i, 0, 15*i) + for _ in range(3): + fd(laenge) + lt(120) + end_fill() + laenge += 10 + lt(15) + speed((speed()+1)%12) + #end_fill() + + lt(120) + pu() + fd(70) + rt(30) + pd() + color("red","yellow") + speed(0) + begin_fill() + for _ in range(4): + circle(50, 90) + rt(90) + fd(30) + rt(90) + end_fill() + lt(90) + pu() + fd(30) + pd() + shape("turtle") + + tri = getturtle() + tri.resizemode("auto") + turtle = Turtle() + turtle.resizemode("auto") + turtle.shape("turtle") + turtle.reset() + turtle.left(90) + turtle.speed(0) + turtle.up() + turtle.goto(280, 40) + turtle.lt(30) + turtle.down() + turtle.speed(6) + turtle.color("blue","orange") + turtle.pensize(2) + tri.speed(6) + setheading(towards(turtle)) + count = 1 + while tri.distance(turtle) > 4: + turtle.fd(3.5) + turtle.lt(0.6) + tri.setheading(tri.towards(turtle)) + tri.fd(4) + if count % 20 == 0: + turtle.stamp() + tri.stamp() + switchpen() + count += 1 + tri.write("CAUGHT! ", font=("Arial", 16, "bold"), align="right") + tri.pencolor("black") + tri.pencolor("red") + + def baba(xdummy, ydummy): + clearscreen() + bye() + + time.sleep(2) + + while undobufferentries(): + tri.undo() + turtle.undo() + tri.fd(50) + tri.write(" Click me!", font = ("Courier", 12, "bold") ) + tri.onclick(baba, 1) + + demo1() + demo2() + exitonclick() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..77150e25331cc4b31d3fd64c9ed079dc880e8356 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__init__.py @@ -0,0 +1,14 @@ +""" + -------------------------------------- + About this viewer + -------------------------------------- + + Tiny demo viewer to view turtle graphics example scripts. + + Quickly and dirtyly assembled by Gregor Lingl. + June, 2006 + + For more information see: turtledemo - Help + + Have fun! +""" diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__main__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..7bf8c960eb4c22bdf04c12c663017acc80e0e2f7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__main__.py @@ -0,0 +1,402 @@ +#!/usr/bin/env python3 + +""" + ---------------------------------------------- + turtleDemo - Help + ---------------------------------------------- + + This document has two sections: + + (1) How to use the demo viewer + (2) How to add your own demos to the demo repository + + + (1) How to use the demo viewer. + + Select a demoscript from the example menu. + The (syntax colored) source code appears in the left + source code window. IT CANNOT BE EDITED, but ONLY VIEWED! + + The demo viewer windows can be resized. The divider between text + and canvas can be moved by grabbing it with the mouse. The text font + size can be changed from the menu and with Control/Command '-'/'+'. + It can also be changed on most systems with Control-mousewheel + when the mouse is over the text. + + Press START button to start the demo. + Stop execution by pressing the STOP button. + Clear screen by pressing the CLEAR button. + Restart by pressing the START button again. + + SPECIAL demos, such as clock.py are those which run EVENTDRIVEN. + + Press START button to start the demo. + + - Until the EVENTLOOP is entered everything works + as in an ordinary demo script. + + - When the EVENTLOOP is entered, you control the + application by using the mouse and/or keys (or it's + controlled by some timer events) + To stop it you can and must press the STOP button. + + While the EVENTLOOP is running, the examples menu is disabled. + + - Only after having pressed the STOP button, you may + restart it or choose another example script. + + * * * * * * * * + In some rare situations there may occur interferences/conflicts + between events concerning the demo script and those concerning the + demo-viewer. (They run in the same process.) Strange behaviour may be + the consequence and in the worst case you must close and restart the + viewer. + * * * * * * * * + + + (2) How to add your own demos to the demo repository + + - Place the file in the same directory as turtledemo/__main__.py + IMPORTANT! When imported, the demo should not modify the system + by calling functions in other modules, such as sys, tkinter, or + turtle. Global variables should be initialized in main(). + + - The code must contain a main() function which will + be executed by the viewer (see provided example scripts). + It may return a string which will be displayed in the Label below + the source code window (when execution has finished.) + + - In order to run mydemo.py by itself, such as during development, + add the following at the end of the file: + + if __name__ == '__main__': + main() + mainloop() # keep window open + + python -m turtledemo.mydemo # will then run it + + - If the demo is EVENT DRIVEN, main must return the string + "EVENTLOOP". This informs the demo viewer that the script is + still running and must be stopped by the user! + + If an "EVENTLOOP" demo runs by itself, as with clock, which uses + ontimer, or minimal_hanoi, which loops by recursion, then the + code should catch the turtle.Terminator exception that will be + raised when the user presses the STOP button. (Paint is not such + a demo; it only acts in response to mouse clicks and movements.) +""" +import sys +import os + +from tkinter import * +from idlelib.colorizer import ColorDelegator, color_config +from idlelib.percolator import Percolator +from idlelib.textview import view_text +from turtledemo import __doc__ as about_turtledemo + +import turtle + +demo_dir = os.path.dirname(os.path.abspath(__file__)) +darwin = sys.platform == 'darwin' + +STARTUP = 1 +READY = 2 +RUNNING = 3 +DONE = 4 +EVENTDRIVEN = 5 + +menufont = ("Arial", 12, NORMAL) +btnfont = ("Arial", 12, 'bold') +txtfont = ['Lucida Console', 10, 'normal'] + +MINIMUM_FONT_SIZE = 6 +MAXIMUM_FONT_SIZE = 100 +font_sizes = [8, 9, 10, 11, 12, 14, 18, 20, 22, 24, 30] + +def getExampleEntries(): + return [entry[:-3] for entry in os.listdir(demo_dir) if + entry.endswith(".py") and entry[0] != '_'] + +help_entries = ( # (help_label, help_doc) + ('Turtledemo help', __doc__), + ('About turtledemo', about_turtledemo), + ('About turtle module', turtle.__doc__), + ) + + +class DemoWindow(object): + + def __init__(self, filename=None): + self.root = root = turtle._root = Tk() + root.title('Python turtle-graphics examples') + root.wm_protocol("WM_DELETE_WINDOW", self._destroy) + + if darwin: + import subprocess + # Make sure we are the currently activated OS X application + # so that our menu bar appears. + subprocess.run( + [ + '/usr/bin/osascript', + '-e', 'tell application "System Events"', + '-e', 'set frontmost of the first process whose ' + 'unix id is {} to true'.format(os.getpid()), + '-e', 'end tell', + ], + stderr=subprocess.DEVNULL, + stdout=subprocess.DEVNULL,) + + root.grid_rowconfigure(0, weight=1) + root.grid_columnconfigure(0, weight=1) + root.grid_columnconfigure(1, minsize=90, weight=1) + root.grid_columnconfigure(2, minsize=90, weight=1) + root.grid_columnconfigure(3, minsize=90, weight=1) + + self.mBar = Menu(root, relief=RAISED, borderwidth=2) + self.mBar.add_cascade(menu=self.makeLoadDemoMenu(self.mBar), + label='Examples', underline=0) + self.mBar.add_cascade(menu=self.makeFontMenu(self.mBar), + label='Fontsize', underline=0) + self.mBar.add_cascade(menu=self.makeHelpMenu(self.mBar), + label='Help', underline=0) + root['menu'] = self.mBar + + pane = PanedWindow(root, orient=HORIZONTAL, sashwidth=5, + sashrelief=SOLID, bg='#ddd') + pane.add(self.makeTextFrame(pane)) + pane.add(self.makeGraphFrame(pane)) + pane.grid(row=0, columnspan=4, sticky='news') + + self.output_lbl = Label(root, height= 1, text=" --- ", bg="#ddf", + font=("Arial", 16, 'normal'), borderwidth=2, + relief=RIDGE) + if darwin: # Leave Mac button colors alone - #44254. + self.start_btn = Button(root, text=" START ", font=btnfont, + fg='#00cc22', command=self.startDemo) + self.stop_btn = Button(root, text=" STOP ", font=btnfont, + fg='#00cc22', command=self.stopIt) + self.clear_btn = Button(root, text=" CLEAR ", font=btnfont, + fg='#00cc22', command = self.clearCanvas) + else: + self.start_btn = Button(root, text=" START ", font=btnfont, + fg="white", disabledforeground = "#fed", + command=self.startDemo) + self.stop_btn = Button(root, text=" STOP ", font=btnfont, + fg="white", disabledforeground = "#fed", + command=self.stopIt) + self.clear_btn = Button(root, text=" CLEAR ", font=btnfont, + fg="white", disabledforeground="#fed", + command = self.clearCanvas) + self.output_lbl.grid(row=1, column=0, sticky='news', padx=(0,5)) + self.start_btn.grid(row=1, column=1, sticky='ew') + self.stop_btn.grid(row=1, column=2, sticky='ew') + self.clear_btn.grid(row=1, column=3, sticky='ew') + + Percolator(self.text).insertfilter(ColorDelegator()) + self.dirty = False + self.exitflag = False + if filename: + self.loadfile(filename) + self.configGUI(DISABLED, DISABLED, DISABLED, + "Choose example from menu", "black") + self.state = STARTUP + + + def onResize(self, event): + cwidth = self.canvas.winfo_width() + cheight = self.canvas.winfo_height() + self.canvas.xview_moveto(0.5*(self.canvwidth-cwidth)/self.canvwidth) + self.canvas.yview_moveto(0.5*(self.canvheight-cheight)/self.canvheight) + + def makeTextFrame(self, root): + self.text_frame = text_frame = Frame(root) + self.text = text = Text(text_frame, name='text', padx=5, + wrap='none', width=45) + color_config(text) + + self.vbar = vbar = Scrollbar(text_frame, name='vbar') + vbar['command'] = text.yview + vbar.pack(side=LEFT, fill=Y) + self.hbar = hbar = Scrollbar(text_frame, name='hbar', orient=HORIZONTAL) + hbar['command'] = text.xview + hbar.pack(side=BOTTOM, fill=X) + text['yscrollcommand'] = vbar.set + text['xscrollcommand'] = hbar.set + + text['font'] = tuple(txtfont) + shortcut = 'Command' if darwin else 'Control' + text.bind_all('<%s-minus>' % shortcut, self.decrease_size) + text.bind_all('<%s-underscore>' % shortcut, self.decrease_size) + text.bind_all('<%s-equal>' % shortcut, self.increase_size) + text.bind_all('<%s-plus>' % shortcut, self.increase_size) + text.bind('', self.update_mousewheel) + text.bind('', self.increase_size) + text.bind('', self.decrease_size) + + text.pack(side=LEFT, fill=BOTH, expand=1) + return text_frame + + def makeGraphFrame(self, root): + # t._Screen is a singleton class instantiated or retrieved + # by calling Screen. Since tdemo canvas needs a different + # configuration, we manually set class attributes before + # calling Screen and manually call superclass init after. + turtle._Screen._root = root + + self.canvwidth = 1000 + self.canvheight = 800 + turtle._Screen._canvas = self.canvas = canvas = turtle.ScrolledCanvas( + root, 800, 600, self.canvwidth, self.canvheight) + canvas.adjustScrolls() + canvas._rootwindow.bind('', self.onResize) + canvas._canvas['borderwidth'] = 0 + + self.screen = screen = turtle.Screen() + turtle.TurtleScreen.__init__(screen, canvas) + turtle.RawTurtle.screens = [screen] + return canvas + + def set_txtsize(self, size): + txtfont[1] = size + self.text['font'] = tuple(txtfont) + self.output_lbl['text'] = 'Font size %d' % size + + def decrease_size(self, dummy=None): + self.set_txtsize(max(txtfont[1] - 1, MINIMUM_FONT_SIZE)) + return 'break' + + def increase_size(self, dummy=None): + self.set_txtsize(min(txtfont[1] + 1, MAXIMUM_FONT_SIZE)) + return 'break' + + def update_mousewheel(self, event): + # For wheel up, event.delta = 120 on Windows, -1 on darwin. + # X-11 sends Control-Button-4 event instead. + if (event.delta < 0) == (not darwin): + return self.decrease_size() + else: + return self.increase_size() + + def configGUI(self, start, stop, clear, txt="", color="blue"): + if darwin: # Leave Mac button colors alone - #44254. + self.start_btn.config(state=start) + self.stop_btn.config(state=stop) + self.clear_btn.config(state=clear) + else: + self.start_btn.config(state=start, + bg="#d00" if start == NORMAL else "#fca") + self.stop_btn.config(state=stop, + bg="#d00" if stop == NORMAL else "#fca") + self.clear_btn.config(state=clear, + bg="#d00" if clear == NORMAL else "#fca") + self.output_lbl.config(text=txt, fg=color) + + def makeLoadDemoMenu(self, master): + menu = Menu(master) + + for entry in getExampleEntries(): + def load(entry=entry): + self.loadfile(entry) + menu.add_command(label=entry, underline=0, + font=menufont, command=load) + return menu + + def makeFontMenu(self, master): + menu = Menu(master) + menu.add_command(label="Decrease (C-'-')", command=self.decrease_size, + font=menufont) + menu.add_command(label="Increase (C-'+')", command=self.increase_size, + font=menufont) + menu.add_separator() + + for size in font_sizes: + def resize(size=size): + self.set_txtsize(size) + menu.add_command(label=str(size), underline=0, + font=menufont, command=resize) + return menu + + def makeHelpMenu(self, master): + menu = Menu(master) + + for help_label, help_file in help_entries: + def show(help_label=help_label, help_file=help_file): + view_text(self.root, help_label, help_file) + menu.add_command(label=help_label, font=menufont, command=show) + return menu + + def refreshCanvas(self): + if self.dirty: + self.screen.clear() + self.dirty=False + + def loadfile(self, filename): + self.clearCanvas() + turtle.TurtleScreen._RUNNING = False + modname = 'turtledemo.' + filename + __import__(modname) + self.module = sys.modules[modname] + with open(self.module.__file__, 'r') as f: + chars = f.read() + self.text.delete("1.0", "end") + self.text.insert("1.0", chars) + self.root.title(filename + " - a Python turtle graphics example") + self.configGUI(NORMAL, DISABLED, DISABLED, + "Press start button", "red") + self.state = READY + + def startDemo(self): + self.refreshCanvas() + self.dirty = True + turtle.TurtleScreen._RUNNING = True + self.configGUI(DISABLED, NORMAL, DISABLED, + "demo running...", "black") + self.screen.clear() + self.screen.mode("standard") + self.state = RUNNING + + try: + result = self.module.main() + if result == "EVENTLOOP": + self.state = EVENTDRIVEN + else: + self.state = DONE + except turtle.Terminator: + if self.root is None: + return + self.state = DONE + result = "stopped!" + if self.state == DONE: + self.configGUI(NORMAL, DISABLED, NORMAL, + result) + elif self.state == EVENTDRIVEN: + self.exitflag = True + self.configGUI(DISABLED, NORMAL, DISABLED, + "use mouse/keys or STOP", "red") + + def clearCanvas(self): + self.refreshCanvas() + self.screen._delete("all") + self.canvas.config(cursor="") + self.configGUI(NORMAL, DISABLED, DISABLED) + + def stopIt(self): + if self.exitflag: + self.clearCanvas() + self.exitflag = False + self.configGUI(NORMAL, DISABLED, DISABLED, + "STOPPED!", "red") + turtle.TurtleScreen._RUNNING = False + + def _destroy(self): + turtle.TurtleScreen._RUNNING = False + self.root.destroy() + self.root = None + + +def main(): + demo = DemoWindow() + demo.root.mainloop() + +if __name__ == '__main__': + main() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3c39f4a1e14398338b44e337694c4c74ce04831e Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/__main__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/__main__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4935a58a20661ff5ab7f6fc92bf2d4b5116a539a Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/__main__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/bytedesign.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/bytedesign.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0347254d9303c5d9e49b5da88f79e1e333126ce5 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/bytedesign.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/chaos.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/chaos.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a0a5d3bb2a7ef307fd4bb0a794767c8df502566 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/chaos.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/clock.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/clock.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4453cebc58eba8553adb43a72123adc8e74b508b Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/clock.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/colormixer.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/colormixer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2bf1a57b20d5f4a109c3be9e44a4d5ba5acbf30c Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/colormixer.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/forest.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/forest.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fad0c50ced913d4e397c8134352e6e7f396eb09f Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/forest.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/fractalcurves.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/fractalcurves.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..610a50df30363d66c6b02ea457acf816619d83d1 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/fractalcurves.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/lindenmayer.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/lindenmayer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a7478e751fdba6ee5f7c3afc624cd03406687f1d Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/lindenmayer.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/minimal_hanoi.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/minimal_hanoi.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..233cd587e2b03ca520f28ce16b95535f696e3b9b Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/minimal_hanoi.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/nim.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/nim.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f3d21eae2a90c29e63180f2a54181c5d48387332 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/nim.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/paint.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/paint.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..53da6f405850af9225f34dc778599d86c901eb2a Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/paint.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/peace.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/peace.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a2698ea8502be96987a3691cc0774645cc50fc1 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/peace.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/penrose.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/penrose.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7e3b7b3eb133be76daa4ae7da090ee3f4551a2d4 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/penrose.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/planet_and_moon.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/planet_and_moon.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..69b7850f64b1177708d21664731b10043221f00b Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/planet_and_moon.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/rosette.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/rosette.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..017124bd727485babd3d360cd8499275b8500b9b Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/rosette.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/round_dance.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/round_dance.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4fbd0a9beadaf75b5917b49b362a8346223bf368 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/round_dance.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/sorting_animate.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/sorting_animate.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e74a9a4ec7fb03bef2d520513caebd95861c40ca Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/sorting_animate.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/tree.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/tree.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cb589d8d1d5b39830b4205a49ae505824b3b91f1 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/tree.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/two_canvases.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/two_canvases.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..92ba3095b949619eae63ac64bb642367286c6f56 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/two_canvases.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/yinyang.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/yinyang.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..76b350c6396f1526dc5b514de0b50d9a0820bffe Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/__pycache__/yinyang.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/bytedesign.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/bytedesign.py new file mode 100644 index 0000000000000000000000000000000000000000..1b7452b512c6eb9a1ff6e47c2da78a63f7946185 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/bytedesign.py @@ -0,0 +1,161 @@ +#!/usr/bin/env python3 +""" turtle-example-suite: + + tdemo_bytedesign.py + +An example adapted from the example-suite +of PythonCard's turtle graphics. + +It's based on an article in BYTE magazine +Problem Solving with Logo: Using Turtle +Graphics to Redraw a Design +November 1982, p. 118 - 134 + +------------------------------------------- + +Due to the statement + +t.delay(0) + +in line 152, which sets the animation delay +to 0, this animation runs in "line per line" +mode as fast as possible. +""" + +from turtle import Turtle, mainloop +from time import perf_counter as clock + +# wrapper for any additional drawing routines +# that need to know about each other +class Designer(Turtle): + + def design(self, homePos, scale): + self.up() + for i in range(5): + self.forward(64.65 * scale) + self.down() + self.wheel(self.position(), scale) + self.up() + self.backward(64.65 * scale) + self.right(72) + self.up() + self.goto(homePos) + self.right(36) + self.forward(24.5 * scale) + self.right(198) + self.down() + self.centerpiece(46 * scale, 143.4, scale) + self.getscreen().tracer(True) + + def wheel(self, initpos, scale): + self.right(54) + for i in range(4): + self.pentpiece(initpos, scale) + self.down() + self.left(36) + for i in range(5): + self.tripiece(initpos, scale) + self.left(36) + for i in range(5): + self.down() + self.right(72) + self.forward(28 * scale) + self.up() + self.backward(28 * scale) + self.left(54) + self.getscreen().update() + + def tripiece(self, initpos, scale): + oldh = self.heading() + self.down() + self.backward(2.5 * scale) + self.tripolyr(31.5 * scale, scale) + self.up() + self.goto(initpos) + self.setheading(oldh) + self.down() + self.backward(2.5 * scale) + self.tripolyl(31.5 * scale, scale) + self.up() + self.goto(initpos) + self.setheading(oldh) + self.left(72) + self.getscreen().update() + + def pentpiece(self, initpos, scale): + oldh = self.heading() + self.up() + self.forward(29 * scale) + self.down() + for i in range(5): + self.forward(18 * scale) + self.right(72) + self.pentr(18 * scale, 75, scale) + self.up() + self.goto(initpos) + self.setheading(oldh) + self.forward(29 * scale) + self.down() + for i in range(5): + self.forward(18 * scale) + self.right(72) + self.pentl(18 * scale, 75, scale) + self.up() + self.goto(initpos) + self.setheading(oldh) + self.left(72) + self.getscreen().update() + + def pentl(self, side, ang, scale): + if side < (2 * scale): return + self.forward(side) + self.left(ang) + self.pentl(side - (.38 * scale), ang, scale) + + def pentr(self, side, ang, scale): + if side < (2 * scale): return + self.forward(side) + self.right(ang) + self.pentr(side - (.38 * scale), ang, scale) + + def tripolyr(self, side, scale): + if side < (4 * scale): return + self.forward(side) + self.right(111) + self.forward(side / 1.78) + self.right(111) + self.forward(side / 1.3) + self.right(146) + self.tripolyr(side * .75, scale) + + def tripolyl(self, side, scale): + if side < (4 * scale): return + self.forward(side) + self.left(111) + self.forward(side / 1.78) + self.left(111) + self.forward(side / 1.3) + self.left(146) + self.tripolyl(side * .75, scale) + + def centerpiece(self, s, a, scale): + self.forward(s); self.left(a) + if s < (7.5 * scale): + return + self.centerpiece(s - (1.2 * scale), a, scale) + +def main(): + t = Designer() + t.speed(0) + t.hideturtle() + t.getscreen().delay(0) + t.getscreen().tracer(0) + at = clock() + t.design(t.position(), 2) + et = clock() + return "runtime: %.2f sec." % (et-at) + +if __name__ == '__main__': + msg = main() + print(msg) + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/chaos.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/chaos.py new file mode 100644 index 0000000000000000000000000000000000000000..6a45d0d807ef0b88bb2189a0bf82490ac3dd0df9 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/chaos.py @@ -0,0 +1,59 @@ +# File: tdemo_chaos.py +# Author: Gregor Lingl +# Date: 2009-06-24 + +# A demonstration of chaos + +from turtle import * + +N = 80 + +def f(x): + return 3.9*x*(1-x) + +def g(x): + return 3.9*(x-x**2) + +def h(x): + return 3.9*x-3.9*x*x + +def jumpto(x, y): + penup(); goto(x,y) + +def line(x1, y1, x2, y2): + jumpto(x1, y1) + pendown() + goto(x2, y2) + +def coosys(): + line(-1, 0, N+1, 0) + line(0, -0.1, 0, 1.1) + +def plot(fun, start, color): + pencolor(color) + x = start + jumpto(0, x) + pendown() + dot(5) + for i in range(N): + x=fun(x) + goto(i+1,x) + dot(5) + +def main(): + reset() + setworldcoordinates(-1.0,-0.1, N+1, 1.1) + speed(0) + hideturtle() + coosys() + plot(f, 0.35, "blue") + plot(g, 0.35, "green") + plot(h, 0.35, "red") + # Now zoom in: + for s in range(100): + setworldcoordinates(0.5*s,-0.1, N+1, 1.1) + return "Done!" + +if __name__ == "__main__": + main() + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/clock.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/clock.py new file mode 100644 index 0000000000000000000000000000000000000000..9f8585bd11e053e3ce668c0a9feccc5f7db438e9 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/clock.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +# -*- coding: cp1252 -*- +""" turtle-example-suite: + + tdemo_clock.py + +Enhanced clock-program, showing date +and time + ------------------------------------ + Press STOP to exit the program! + ------------------------------------ +""" +from turtle import * +from datetime import datetime + +def jump(distanz, winkel=0): + penup() + right(winkel) + forward(distanz) + left(winkel) + pendown() + +def hand(laenge, spitze): + fd(laenge*1.15) + rt(90) + fd(spitze/2.0) + lt(120) + fd(spitze) + lt(120) + fd(spitze) + lt(120) + fd(spitze/2.0) + +def make_hand_shape(name, laenge, spitze): + reset() + jump(-laenge*0.15) + begin_poly() + hand(laenge, spitze) + end_poly() + hand_form = get_poly() + register_shape(name, hand_form) + +def clockface(radius): + reset() + pensize(7) + for i in range(60): + jump(radius) + if i % 5 == 0: + fd(25) + jump(-radius-25) + else: + dot(3) + jump(-radius) + rt(6) + +def setup(): + global second_hand, minute_hand, hour_hand, writer + mode("logo") + make_hand_shape("second_hand", 125, 25) + make_hand_shape("minute_hand", 130, 25) + make_hand_shape("hour_hand", 90, 25) + clockface(160) + second_hand = Turtle() + second_hand.shape("second_hand") + second_hand.color("gray20", "gray80") + minute_hand = Turtle() + minute_hand.shape("minute_hand") + minute_hand.color("blue1", "red1") + hour_hand = Turtle() + hour_hand.shape("hour_hand") + hour_hand.color("blue3", "red3") + for hand in second_hand, minute_hand, hour_hand: + hand.resizemode("user") + hand.shapesize(1, 1, 3) + hand.speed(0) + ht() + writer = Turtle() + #writer.mode("logo") + writer.ht() + writer.pu() + writer.bk(85) + +def wochentag(t): + wochentag = ["Monday", "Tuesday", "Wednesday", + "Thursday", "Friday", "Saturday", "Sunday"] + return wochentag[t.weekday()] + +def datum(z): + monat = ["Jan.", "Feb.", "Mar.", "Apr.", "May", "June", + "July", "Aug.", "Sep.", "Oct.", "Nov.", "Dec."] + j = z.year + m = monat[z.month - 1] + t = z.day + return "%s %d %d" % (m, t, j) + +def tick(): + t = datetime.today() + sekunde = t.second + t.microsecond*0.000001 + minute = t.minute + sekunde/60.0 + stunde = t.hour + minute/60.0 + try: + tracer(False) # Terminator can occur here + writer.clear() + writer.home() + writer.forward(65) + writer.write(wochentag(t), + align="center", font=("Courier", 14, "bold")) + writer.back(150) + writer.write(datum(t), + align="center", font=("Courier", 14, "bold")) + writer.forward(85) + second_hand.setheading(6*sekunde) # or here + minute_hand.setheading(6*minute) + hour_hand.setheading(30*stunde) + tracer(True) + ontimer(tick, 100) + except Terminator: + pass # turtledemo user pressed STOP + +def main(): + tracer(False) + setup() + tracer(True) + tick() + return "EVENTLOOP" + +if __name__ == "__main__": + mode("logo") + msg = main() + print(msg) + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/colormixer.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/colormixer.py new file mode 100644 index 0000000000000000000000000000000000000000..448db83361a649eff317733a5b932a1989a8697f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/colormixer.py @@ -0,0 +1,58 @@ +# colormixer + +from turtle import Screen, Turtle, mainloop + +class ColorTurtle(Turtle): + + def __init__(self, x, y): + Turtle.__init__(self) + self.shape("turtle") + self.resizemode("user") + self.shapesize(3,3,5) + self.pensize(10) + self._color = [0,0,0] + self.x = x + self._color[x] = y + self.color(self._color) + self.speed(0) + self.left(90) + self.pu() + self.goto(x,0) + self.pd() + self.sety(1) + self.pu() + self.sety(y) + self.pencolor("gray25") + self.ondrag(self.shift) + + def shift(self, x, y): + self.sety(max(0,min(y,1))) + self._color[self.x] = self.ycor() + self.fillcolor(self._color) + setbgcolor() + +def setbgcolor(): + screen.bgcolor(red.ycor(), green.ycor(), blue.ycor()) + +def main(): + global screen, red, green, blue + screen = Screen() + screen.delay(0) + screen.setworldcoordinates(-1, -0.3, 3, 1.3) + + red = ColorTurtle(0, .5) + green = ColorTurtle(1, .5) + blue = ColorTurtle(2, .5) + setbgcolor() + + writer = Turtle() + writer.ht() + writer.pu() + writer.goto(1,1.15) + writer.write("DRAG!",align="center",font=("Arial",30,("bold","italic"))) + return "EVENTLOOP" + +if __name__ == "__main__": + msg = main() + print(msg) + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/forest.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/forest.py new file mode 100644 index 0000000000000000000000000000000000000000..55b7da947d24760b204afc45bff9474b48f45848 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/forest.py @@ -0,0 +1,108 @@ +#!/usr/bin/env python3 +""" turtlegraphics-example-suite: + + tdemo_forest.py + +Displays a 'forest' of 3 breadth-first-trees +similar to the one in tree. +For further remarks see tree.py + +This example is a 'breadth-first'-rewrite of +a Logo program written by Erich Neuwirth. See +http://homepage.univie.ac.at/erich.neuwirth/ +""" +from turtle import Turtle, colormode, tracer, mainloop +from random import randrange +from time import perf_counter as clock + +def symRandom(n): + return randrange(-n,n+1) + +def randomize( branchlist, angledist, sizedist ): + return [ (angle+symRandom(angledist), + sizefactor*1.01**symRandom(sizedist)) + for angle, sizefactor in branchlist ] + +def randomfd( t, distance, parts, angledist ): + for i in range(parts): + t.left(symRandom(angledist)) + t.forward( (1.0 * distance)/parts ) + +def tree(tlist, size, level, widthfactor, branchlists, angledist=10, sizedist=5): + # benutzt Liste von turtles und Liste von Zweiglisten, + # fuer jede turtle eine! + if level > 0: + lst = [] + brs = [] + for t, branchlist in list(zip(tlist,branchlists)): + t.pensize( size * widthfactor ) + t.pencolor( 255 - (180 - 11 * level + symRandom(15)), + 180 - 11 * level + symRandom(15), + 0 ) + t.pendown() + randomfd(t, size, level, angledist ) + yield 1 + for angle, sizefactor in branchlist: + t.left(angle) + lst.append(t.clone()) + brs.append(randomize(branchlist, angledist, sizedist)) + t.right(angle) + for x in tree(lst, size*sizefactor, level-1, widthfactor, brs, + angledist, sizedist): + yield None + + +def start(t,x,y): + colormode(255) + t.reset() + t.speed(0) + t.hideturtle() + t.left(90) + t.penup() + t.setpos(x,y) + t.pendown() + +def doit1(level, pen): + pen.hideturtle() + start(pen, 20, -208) + t = tree( [pen], 80, level, 0.1, [[ (45,0.69), (0,0.65), (-45,0.71) ]] ) + return t + +def doit2(level, pen): + pen.hideturtle() + start(pen, -135, -130) + t = tree( [pen], 120, level, 0.1, [[ (45,0.69), (-45,0.71) ]] ) + return t + +def doit3(level, pen): + pen.hideturtle() + start(pen, 190, -90) + t = tree( [pen], 100, level, 0.1, [[ (45,0.7), (0,0.72), (-45,0.65) ]] ) + return t + +# Hier 3 Baumgeneratoren: +def main(): + p = Turtle() + p.ht() + tracer(75,0) + u = doit1(6, Turtle(undobuffersize=1)) + s = doit2(7, Turtle(undobuffersize=1)) + t = doit3(5, Turtle(undobuffersize=1)) + a = clock() + while True: + done = 0 + for b in u,s,t: + try: + b.__next__() + except: + done += 1 + if done == 3: + break + + tracer(1,10) + b = clock() + return "runtime: %.2f sec." % (b-a) + +if __name__ == '__main__': + main() + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/fractalcurves.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/fractalcurves.py new file mode 100644 index 0000000000000000000000000000000000000000..54ade96a0ad05eba6304b643c21906db609903c4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/fractalcurves.py @@ -0,0 +1,138 @@ +#!/usr/bin/env python3 +""" turtle-example-suite: + + tdemo_fractalCurves.py + +This program draws two fractal-curve-designs: +(1) A hilbert curve (in a box) +(2) A combination of Koch-curves. + +The CurvesTurtle class and the fractal-curve- +methods are taken from the PythonCard example +scripts for turtle-graphics. +""" +from turtle import * +from time import sleep, perf_counter as clock + +class CurvesTurtle(Pen): + # example derived from + # Turtle Geometry: The Computer as a Medium for Exploring Mathematics + # by Harold Abelson and Andrea diSessa + # p. 96-98 + def hilbert(self, size, level, parity): + if level == 0: + return + # rotate and draw first subcurve with opposite parity to big curve + self.left(parity * 90) + self.hilbert(size, level - 1, -parity) + # interface to and draw second subcurve with same parity as big curve + self.forward(size) + self.right(parity * 90) + self.hilbert(size, level - 1, parity) + # third subcurve + self.forward(size) + self.hilbert(size, level - 1, parity) + # fourth subcurve + self.right(parity * 90) + self.forward(size) + self.hilbert(size, level - 1, -parity) + # a final turn is needed to make the turtle + # end up facing outward from the large square + self.left(parity * 90) + + # Visual Modeling with Logo: A Structural Approach to Seeing + # by James Clayson + # Koch curve, after Helge von Koch who introduced this geometric figure in 1904 + # p. 146 + def fractalgon(self, n, rad, lev, dir): + import math + + # if dir = 1 turn outward + # if dir = -1 turn inward + edge = 2 * rad * math.sin(math.pi / n) + self.pu() + self.fd(rad) + self.pd() + self.rt(180 - (90 * (n - 2) / n)) + for i in range(n): + self.fractal(edge, lev, dir) + self.rt(360 / n) + self.lt(180 - (90 * (n - 2) / n)) + self.pu() + self.bk(rad) + self.pd() + + # p. 146 + def fractal(self, dist, depth, dir): + if depth < 1: + self.fd(dist) + return + self.fractal(dist / 3, depth - 1, dir) + self.lt(60 * dir) + self.fractal(dist / 3, depth - 1, dir) + self.rt(120 * dir) + self.fractal(dist / 3, depth - 1, dir) + self.lt(60 * dir) + self.fractal(dist / 3, depth - 1, dir) + +def main(): + ft = CurvesTurtle() + + ft.reset() + ft.speed(0) + ft.ht() + ft.getscreen().tracer(1,0) + ft.pu() + + size = 6 + ft.setpos(-33*size, -32*size) + ft.pd() + + ta=clock() + ft.fillcolor("red") + ft.begin_fill() + ft.fd(size) + + ft.hilbert(size, 6, 1) + + # frame + ft.fd(size) + for i in range(3): + ft.lt(90) + ft.fd(size*(64+i%2)) + ft.pu() + for i in range(2): + ft.fd(size) + ft.rt(90) + ft.pd() + for i in range(4): + ft.fd(size*(66+i%2)) + ft.rt(90) + ft.end_fill() + tb=clock() + res = "Hilbert: %.2fsec. " % (tb-ta) + + sleep(3) + + ft.reset() + ft.speed(0) + ft.ht() + ft.getscreen().tracer(1,0) + + ta=clock() + ft.color("black", "blue") + ft.begin_fill() + ft.fractalgon(3, 250, 4, 1) + ft.end_fill() + ft.begin_fill() + ft.color("red") + ft.fractalgon(3, 200, 4, -1) + ft.end_fill() + tb=clock() + res += "Koch: %.2fsec." % (tb-ta) + return res + +if __name__ == '__main__': + msg = main() + print(msg) + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/lindenmayer.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/lindenmayer.py new file mode 100644 index 0000000000000000000000000000000000000000..3925f25da61870d0cf75ede6ddefbef2562afd03 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/lindenmayer.py @@ -0,0 +1,119 @@ +#!/usr/bin/env python3 +""" turtle-example-suite: + + xtx_lindenmayer_indian.py + +Each morning women in Tamil Nadu, in southern +India, place designs, created by using rice +flour and known as kolam on the thresholds of +their homes. + +These can be described by Lindenmayer systems, +which can easily be implemented with turtle +graphics and Python. + +Two examples are shown here: +(1) the snake kolam +(2) anklets of Krishna + +Taken from Marcia Ascher: Mathematics +Elsewhere, An Exploration of Ideas Across +Cultures + +""" +################################ +# Mini Lindenmayer tool +############################### + +from turtle import * + +def replace( seq, replacementRules, n ): + for i in range(n): + newseq = "" + for element in seq: + newseq = newseq + replacementRules.get(element,element) + seq = newseq + return seq + +def draw( commands, rules ): + for b in commands: + try: + rules[b]() + except TypeError: + try: + draw(rules[b], rules) + except: + pass + + +def main(): + ################################ + # Example 1: Snake kolam + ################################ + + + def r(): + right(45) + + def l(): + left(45) + + def f(): + forward(7.5) + + snake_rules = {"-":r, "+":l, "f":f, "b":"f+f+f--f--f+f+f"} + snake_replacementRules = {"b": "b+f+b--f--b+f+b"} + snake_start = "b--f--b--f" + + drawing = replace(snake_start, snake_replacementRules, 3) + + reset() + speed(3) + tracer(1,0) + ht() + up() + backward(195) + down() + draw(drawing, snake_rules) + + from time import sleep + sleep(3) + + ################################ + # Example 2: Anklets of Krishna + ################################ + + def A(): + color("red") + circle(10,90) + + def B(): + from math import sqrt + color("black") + l = 5/sqrt(2) + forward(l) + circle(l, 270) + forward(l) + + def F(): + color("green") + forward(10) + + krishna_rules = {"a":A, "b":B, "f":F} + krishna_replacementRules = {"a" : "afbfa", "b" : "afbfbfbfa" } + krishna_start = "fbfbfbfb" + + reset() + speed(0) + tracer(3,0) + ht() + left(45) + drawing = replace(krishna_start, krishna_replacementRules, 3) + draw(drawing, krishna_rules) + tracer(1) + return "Done!" + +if __name__=='__main__': + msg = main() + print(msg) + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/minimal_hanoi.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/minimal_hanoi.py new file mode 100644 index 0000000000000000000000000000000000000000..4a432f2b2908d5ec6c18640fe856044bddc8a7f6 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/minimal_hanoi.py @@ -0,0 +1,79 @@ +#!/usr/bin/env python3 +""" turtle-example-suite: + + tdemo_minimal_hanoi.py + +A minimal 'Towers of Hanoi' animation: +A tower of 6 discs is transferred from the +left to the right peg. + +An imho quite elegant and concise +implementation using a tower class, which +is derived from the built-in type list. + +Discs are turtles with shape "square", but +stretched to rectangles by shapesize() + --------------------------------------- + To exit press STOP button + --------------------------------------- +""" +from turtle import * + +class Disc(Turtle): + def __init__(self, n): + Turtle.__init__(self, shape="square", visible=False) + self.pu() + self.shapesize(1.5, n*1.5, 2) # square-->rectangle + self.fillcolor(n/6., 0, 1-n/6.) + self.st() + +class Tower(list): + "Hanoi tower, a subclass of built-in type list" + def __init__(self, x): + "create an empty tower. x is x-position of peg" + self.x = x + def push(self, d): + d.setx(self.x) + d.sety(-150+34*len(self)) + self.append(d) + def pop(self): + d = list.pop(self) + d.sety(150) + return d + +def hanoi(n, from_, with_, to_): + if n > 0: + hanoi(n-1, from_, to_, with_) + to_.push(from_.pop()) + hanoi(n-1, with_, from_, to_) + +def play(): + onkey(None,"space") + clear() + try: + hanoi(6, t1, t2, t3) + write("press STOP button to exit", + align="center", font=("Courier", 16, "bold")) + except Terminator: + pass # turtledemo user pressed STOP + +def main(): + global t1, t2, t3 + ht(); penup(); goto(0, -225) # writer turtle + t1 = Tower(-250) + t2 = Tower(0) + t3 = Tower(250) + # make tower of 6 discs + for i in range(6,0,-1): + t1.push(Disc(i)) + # prepare spartanic user interface ;-) + write("press spacebar to start game", + align="center", font=("Courier", 16, "bold")) + onkey(play, "space") + listen() + return "EVENTLOOP" + +if __name__=="__main__": + msg = main() + print(msg) + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/nim.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/nim.py new file mode 100644 index 0000000000000000000000000000000000000000..9ae6cc5c01b9039981f31f4c28a470ac249ee5dc --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/nim.py @@ -0,0 +1,226 @@ +""" turtle-example-suite: + + tdemo_nim.py + +Play nim against the computer. The player +who takes the last stick is the winner. + +Implements the model-view-controller +design pattern. +""" + + +import turtle +import random +import time + +SCREENWIDTH = 640 +SCREENHEIGHT = 480 + +MINSTICKS = 7 +MAXSTICKS = 31 + +HUNIT = SCREENHEIGHT // 12 +WUNIT = SCREENWIDTH // ((MAXSTICKS // 5) * 11 + (MAXSTICKS % 5) * 2) + +SCOLOR = (63, 63, 31) +HCOLOR = (255, 204, 204) +COLOR = (204, 204, 255) + +def randomrow(): + return random.randint(MINSTICKS, MAXSTICKS) + +def computerzug(state): + xored = state[0] ^ state[1] ^ state[2] + if xored == 0: + return randommove(state) + for z in range(3): + s = state[z] ^ xored + if s <= state[z]: + move = (z, s) + return move + +def randommove(state): + m = max(state) + while True: + z = random.randint(0,2) + if state[z] > (m > 1): + break + rand = random.randint(m > 1, state[z]-1) + return z, rand + + +class NimModel(object): + def __init__(self, game): + self.game = game + + def setup(self): + if self.game.state not in [Nim.CREATED, Nim.OVER]: + return + self.sticks = [randomrow(), randomrow(), randomrow()] + self.player = 0 + self.winner = None + self.game.view.setup() + self.game.state = Nim.RUNNING + + def move(self, row, col): + maxspalte = self.sticks[row] + self.sticks[row] = col + self.game.view.notify_move(row, col, maxspalte, self.player) + if self.game_over(): + self.game.state = Nim.OVER + self.winner = self.player + self.game.view.notify_over() + elif self.player == 0: + self.player = 1 + row, col = computerzug(self.sticks) + self.move(row, col) + self.player = 0 + + def game_over(self): + return self.sticks == [0, 0, 0] + + def notify_move(self, row, col): + if self.sticks[row] <= col: + return + self.move(row, col) + + +class Stick(turtle.Turtle): + def __init__(self, row, col, game): + turtle.Turtle.__init__(self, visible=False) + self.row = row + self.col = col + self.game = game + x, y = self.coords(row, col) + self.shape("square") + self.shapesize(HUNIT/10.0, WUNIT/20.0) + self.speed(0) + self.pu() + self.goto(x,y) + self.color("white") + self.showturtle() + + def coords(self, row, col): + packet, remainder = divmod(col, 5) + x = (3 + 11 * packet + 2 * remainder) * WUNIT + y = (2 + 3 * row) * HUNIT + return x - SCREENWIDTH // 2 + WUNIT // 2, SCREENHEIGHT // 2 - y - HUNIT // 2 + + def makemove(self, x, y): + if self.game.state != Nim.RUNNING: + return + self.game.controller.notify_move(self.row, self.col) + + +class NimView(object): + def __init__(self, game): + self.game = game + self.screen = game.screen + self.model = game.model + self.screen.colormode(255) + self.screen.tracer(False) + self.screen.bgcolor((240, 240, 255)) + self.writer = turtle.Turtle(visible=False) + self.writer.pu() + self.writer.speed(0) + self.sticks = {} + for row in range(3): + for col in range(MAXSTICKS): + self.sticks[(row, col)] = Stick(row, col, game) + self.display("... a moment please ...") + self.screen.tracer(True) + + def display(self, msg1, msg2=None): + self.screen.tracer(False) + self.writer.clear() + if msg2 is not None: + self.writer.goto(0, - SCREENHEIGHT // 2 + 48) + self.writer.pencolor("red") + self.writer.write(msg2, align="center", font=("Courier",18,"bold")) + self.writer.goto(0, - SCREENHEIGHT // 2 + 20) + self.writer.pencolor("black") + self.writer.write(msg1, align="center", font=("Courier",14,"bold")) + self.screen.tracer(True) + + def setup(self): + self.screen.tracer(False) + for row in range(3): + for col in range(self.model.sticks[row]): + self.sticks[(row, col)].color(SCOLOR) + for row in range(3): + for col in range(self.model.sticks[row], MAXSTICKS): + self.sticks[(row, col)].color("white") + self.display("Your turn! Click leftmost stick to remove.") + self.screen.tracer(True) + + def notify_move(self, row, col, maxspalte, player): + if player == 0: + farbe = HCOLOR + for s in range(col, maxspalte): + self.sticks[(row, s)].color(farbe) + else: + self.display(" ... thinking ... ") + time.sleep(0.5) + self.display(" ... thinking ... aaah ...") + farbe = COLOR + for s in range(maxspalte-1, col-1, -1): + time.sleep(0.2) + self.sticks[(row, s)].color(farbe) + self.display("Your turn! Click leftmost stick to remove.") + + def notify_over(self): + if self.game.model.winner == 0: + msg2 = "Congrats. You're the winner!!!" + else: + msg2 = "Sorry, the computer is the winner." + self.display("To play again press space bar. To leave press ESC.", msg2) + + def clear(self): + if self.game.state == Nim.OVER: + self.screen.clear() + + +class NimController(object): + + def __init__(self, game): + self.game = game + self.sticks = game.view.sticks + self.BUSY = False + for stick in self.sticks.values(): + stick.onclick(stick.makemove) + self.game.screen.onkey(self.game.model.setup, "space") + self.game.screen.onkey(self.game.view.clear, "Escape") + self.game.view.display("Press space bar to start game") + self.game.screen.listen() + + def notify_move(self, row, col): + if self.BUSY: + return + self.BUSY = True + self.game.model.notify_move(row, col) + self.BUSY = False + + +class Nim(object): + CREATED = 0 + RUNNING = 1 + OVER = 2 + def __init__(self, screen): + self.state = Nim.CREATED + self.screen = screen + self.model = NimModel(self) + self.view = NimView(self) + self.controller = NimController(self) + + +def main(): + mainscreen = turtle.Screen() + mainscreen.mode("standard") + mainscreen.setup(SCREENWIDTH, SCREENHEIGHT) + nim = Nim(mainscreen) + return "EVENTLOOP" + +if __name__ == "__main__": + main() + turtle.mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/paint.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/paint.py new file mode 100644 index 0000000000000000000000000000000000000000..fc6852a20082f5fb085b35201c452d0ed96bafe0 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/paint.py @@ -0,0 +1,54 @@ +#!/usr/bin/env python3 +""" turtle-example-suite: + + tdemo_paint.py + +A simple event-driven paint program + +- left mouse button moves turtle +- middle mouse button changes color +- right mouse button toggles between pen up +(no line drawn when the turtle moves) and +pen down (line is drawn). If pen up follows +at least two pen-down moves, the polygon that +includes the starting point is filled. + ------------------------------------------- + Play around by clicking into the canvas + using all three mouse buttons. + ------------------------------------------- + To exit press STOP button + ------------------------------------------- +""" +from turtle import * + +def switchupdown(x=0, y=0): + if pen()["pendown"]: + end_fill() + up() + else: + down() + begin_fill() + +def changecolor(x=0, y=0): + global colors + colors = colors[1:]+colors[:1] + color(colors[0]) + +def main(): + global colors + shape("circle") + resizemode("user") + shapesize(.5) + width(3) + colors=["red", "green", "blue", "yellow"] + color(colors[0]) + switchupdown() + onscreenclick(goto,1) + onscreenclick(changecolor,2) + onscreenclick(switchupdown,3) + return "EVENTLOOP" + +if __name__ == "__main__": + msg = main() + print(msg) + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/peace.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/peace.py new file mode 100644 index 0000000000000000000000000000000000000000..e2ba9288d9e42e78bb0ad68f69ed4910aa65567d --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/peace.py @@ -0,0 +1,61 @@ +#!/usr/bin/env python3 +""" turtle-example-suite: + + tdemo_peace.py + +A simple drawing suitable as a beginner's +programming example. Aside from the +peacecolors assignment and the for loop, +it only uses turtle commands. +""" + +from turtle import * + +def main(): + peacecolors = ("red3", "orange", "yellow", + "seagreen4", "orchid4", + "royalblue1", "dodgerblue4") + + reset() + Screen() + up() + goto(-320,-195) + width(70) + + for pcolor in peacecolors: + color(pcolor) + down() + forward(640) + up() + backward(640) + left(90) + forward(66) + right(90) + + width(25) + color("white") + goto(0,-170) + down() + + circle(170) + left(90) + forward(340) + up() + left(180) + forward(170) + right(45) + down() + forward(170) + up() + backward(170) + left(90) + down() + forward(170) + up() + + goto(0,300) # vanish if hideturtle() is not available ;-) + return "Done!" + +if __name__ == "__main__": + main() + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/penrose.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/penrose.py new file mode 100644 index 0000000000000000000000000000000000000000..045722a2286061eb9cb22e1e245f0164fc665afc --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/penrose.py @@ -0,0 +1,175 @@ +#!/usr/bin/env python3 +""" xturtle-example-suite: + + xtx_kites_and_darts.py + +Constructs two aperiodic penrose-tilings, +consisting of kites and darts, by the method +of inflation in six steps. + +Starting points are the patterns "sun" +consisting of five kites and "star" +consisting of five darts. + +For more information see: + http://en.wikipedia.org/wiki/Penrose_tiling + ------------------------------------------- +""" +from turtle import * +from math import cos, pi +from time import perf_counter as clock, sleep + +f = (5**0.5-1)/2.0 # (sqrt(5)-1)/2 -- golden ratio +d = 2 * cos(3*pi/10) + +def kite(l): + fl = f * l + lt(36) + fd(l) + rt(108) + fd(fl) + rt(36) + fd(fl) + rt(108) + fd(l) + rt(144) + +def dart(l): + fl = f * l + lt(36) + fd(l) + rt(144) + fd(fl) + lt(36) + fd(fl) + rt(144) + fd(l) + rt(144) + +def inflatekite(l, n): + if n == 0: + px, py = pos() + h, x, y = int(heading()), round(px,3), round(py,3) + tiledict[(h,x,y)] = True + return + fl = f * l + lt(36) + inflatedart(fl, n-1) + fd(l) + rt(144) + inflatekite(fl, n-1) + lt(18) + fd(l*d) + rt(162) + inflatekite(fl, n-1) + lt(36) + fd(l) + rt(180) + inflatedart(fl, n-1) + lt(36) + +def inflatedart(l, n): + if n == 0: + px, py = pos() + h, x, y = int(heading()), round(px,3), round(py,3) + tiledict[(h,x,y)] = False + return + fl = f * l + inflatekite(fl, n-1) + lt(36) + fd(l) + rt(180) + inflatedart(fl, n-1) + lt(54) + fd(l*d) + rt(126) + inflatedart(fl, n-1) + fd(l) + rt(144) + +def draw(l, n, th=2): + clear() + l = l * f**n + shapesize(l/100.0, l/100.0, th) + for k in tiledict: + h, x, y = k + setpos(x, y) + setheading(h) + if tiledict[k]: + shape("kite") + color("black", (0, 0.75, 0)) + else: + shape("dart") + color("black", (0.75, 0, 0)) + stamp() + +def sun(l, n): + for i in range(5): + inflatekite(l, n) + lt(72) + +def star(l,n): + for i in range(5): + inflatedart(l, n) + lt(72) + +def makeshapes(): + tracer(0) + begin_poly() + kite(100) + end_poly() + register_shape("kite", get_poly()) + begin_poly() + dart(100) + end_poly() + register_shape("dart", get_poly()) + tracer(1) + +def start(): + reset() + ht() + pu() + makeshapes() + resizemode("user") + +def test(l=200, n=4, fun=sun, startpos=(0,0), th=2): + global tiledict + goto(startpos) + setheading(0) + tiledict = {} + tracer(0) + fun(l, n) + draw(l, n, th) + tracer(1) + nk = len([x for x in tiledict if tiledict[x]]) + nd = len([x for x in tiledict if not tiledict[x]]) + print("%d kites and %d darts = %d pieces." % (nk, nd, nk+nd)) + +def demo(fun=sun): + start() + for i in range(8): + a = clock() + test(300, i, fun) + b = clock() + t = b - a + if t < 2: + sleep(2 - t) + +def main(): + #title("Penrose-tiling with kites and darts.") + mode("logo") + bgcolor(0.3, 0.3, 0) + demo(sun) + sleep(2) + demo(star) + pencolor("black") + goto(0,-200) + pencolor(0.7,0.7,1) + write("Please wait...", + align="center", font=('Arial Black', 36, 'bold')) + test(600, 8, startpos=(70, 117)) + return "Done" + +if __name__ == "__main__": + msg = main() + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/planet_and_moon.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/planet_and_moon.py new file mode 100644 index 0000000000000000000000000000000000000000..021ff99383aa65122b663f394b9d55bf57a24e9d --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/planet_and_moon.py @@ -0,0 +1,111 @@ +#!/usr/bin/env python3 +""" turtle-example-suite: + + tdemo_planets_and_moon.py + +Gravitational system simulation using the +approximation method from Feynman-lectures, +p.9-8, using turtlegraphics. + +Example: heavy central body, light planet, +very light moon! +Planet has a circular orbit, moon a stable +orbit around the planet. + +You can hold the movement temporarily by +pressing the left mouse button with the +mouse over the scrollbar of the canvas. + +""" +from turtle import Shape, Turtle, mainloop, Vec2D as Vec + +G = 8 + +class GravSys(object): + def __init__(self): + self.planets = [] + self.t = 0 + self.dt = 0.01 + def init(self): + for p in self.planets: + p.init() + def start(self): + for i in range(10000): + self.t += self.dt + for p in self.planets: + p.step() + +class Star(Turtle): + def __init__(self, m, x, v, gravSys, shape): + Turtle.__init__(self, shape=shape) + self.penup() + self.m = m + self.setpos(x) + self.v = v + gravSys.planets.append(self) + self.gravSys = gravSys + self.resizemode("user") + self.pendown() + def init(self): + dt = self.gravSys.dt + self.a = self.acc() + self.v = self.v + 0.5*dt*self.a + def acc(self): + a = Vec(0,0) + for planet in self.gravSys.planets: + if planet != self: + v = planet.pos()-self.pos() + a += (G*planet.m/abs(v)**3)*v + return a + def step(self): + dt = self.gravSys.dt + self.setpos(self.pos() + dt*self.v) + if self.gravSys.planets.index(self) != 0: + self.setheading(self.towards(self.gravSys.planets[0])) + self.a = self.acc() + self.v = self.v + dt*self.a + +## create compound yellow/blue turtleshape for planets + +def main(): + s = Turtle() + s.reset() + s.getscreen().tracer(0,0) + s.ht() + s.pu() + s.fd(6) + s.lt(90) + s.begin_poly() + s.circle(6, 180) + s.end_poly() + m1 = s.get_poly() + s.begin_poly() + s.circle(6,180) + s.end_poly() + m2 = s.get_poly() + + planetshape = Shape("compound") + planetshape.addcomponent(m1,"orange") + planetshape.addcomponent(m2,"blue") + s.getscreen().register_shape("planet", planetshape) + s.getscreen().tracer(1,0) + + ## setup gravitational system + gs = GravSys() + sun = Star(1000000, Vec(0,0), Vec(0,-2.5), gs, "circle") + sun.color("yellow") + sun.shapesize(1.8) + sun.pu() + earth = Star(12500, Vec(210,0), Vec(0,195), gs, "planet") + earth.pencolor("green") + earth.shapesize(0.8) + moon = Star(1, Vec(220,0), Vec(0,295), gs, "planet") + moon.pencolor("blue") + moon.shapesize(0.5) + gs.init() + gs.start() + return "Done!" + +if __name__ == '__main__': + main() + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/rosette.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/rosette.py new file mode 100644 index 0000000000000000000000000000000000000000..47d0f00e9da9d15dc93b0814208949e86be618f5 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/rosette.py @@ -0,0 +1,65 @@ +""" turtle-example-suite: + + tdemo_wikipedia3.py + +This example is +inspired by the Wikipedia article on turtle +graphics. (See example wikipedia1 for URLs) + +First we create (ne-1) (i.e. 35 in this +example) copies of our first turtle p. +Then we let them perform their steps in +parallel. + +Followed by a complete undo(). +""" +from turtle import Screen, Turtle, mainloop +from time import perf_counter as clock, sleep + +def mn_eck(p, ne,sz): + turtlelist = [p] + #create ne-1 additional turtles + for i in range(1,ne): + q = p.clone() + q.rt(360.0/ne) + turtlelist.append(q) + p = q + for i in range(ne): + c = abs(ne/2.0-i)/(ne*.7) + # let those ne turtles make a step + # in parallel: + for t in turtlelist: + t.rt(360./ne) + t.pencolor(1-c,0,c) + t.fd(sz) + +def main(): + s = Screen() + s.bgcolor("black") + p=Turtle() + p.speed(0) + p.hideturtle() + p.pencolor("red") + p.pensize(3) + + s.tracer(36,0) + + at = clock() + mn_eck(p, 36, 19) + et = clock() + z1 = et-at + + sleep(1) + + at = clock() + while any(t.undobufferentries() for t in s.turtles()): + for t in s.turtles(): + t.undo() + et = clock() + return "runtime: %.3f sec" % (z1+et-at) + + +if __name__ == '__main__': + msg = main() + print(msg) + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/round_dance.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/round_dance.py new file mode 100644 index 0000000000000000000000000000000000000000..10383614c6e974c7b0cbd3e9ad99ba8ee5371922 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/round_dance.py @@ -0,0 +1,86 @@ +""" turtle-example-suite: + + tdemo_round_dance.py + +(Needs version 1.1 of the turtle module that +comes with Python 3.1) + +Dancing turtles have a compound shape +consisting of a series of triangles of +decreasing size. + +Turtles march along a circle while rotating +pairwise in opposite direction, with one +exception. Does that breaking of symmetry +enhance the attractiveness of the example? + +Press any key to stop the animation. + +Technically: demonstrates use of compound +shapes, transformation of shapes as well as +cloning turtles. The animation is +controlled through update(). +""" + +from turtle import * + +def stop(): + global running + running = False + +def main(): + global running + clearscreen() + bgcolor("gray10") + tracer(False) + shape("triangle") + f = 0.793402 + phi = 9.064678 + s = 5 + c = 1 + # create compound shape + sh = Shape("compound") + for i in range(10): + shapesize(s) + p =get_shapepoly() + s *= f + c *= f + tilt(-phi) + sh.addcomponent(p, (c, 0.25, 1-c), "black") + register_shape("multitri", sh) + # create dancers + shapesize(1) + shape("multitri") + pu() + setpos(0, -200) + dancers = [] + for i in range(180): + fd(7) + tilt(-4) + lt(2) + update() + if i % 12 == 0: + dancers.append(clone()) + home() + # dance + running = True + onkeypress(stop) + listen() + cs = 1 + while running: + ta = -4 + for dancer in dancers: + dancer.fd(7) + dancer.lt(2) + dancer.tilt(ta) + ta = -4 if ta > 0 else 2 + if cs < 180: + right(4) + shapesize(cs) + cs *= 1.005 + update() + return "DONE!" + +if __name__=='__main__': + print(main()) + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/sorting_animate.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/sorting_animate.py new file mode 100644 index 0000000000000000000000000000000000000000..d25a0ab6cebdc09e79a7a7974345852cd23a469c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/sorting_animate.py @@ -0,0 +1,204 @@ +#!/usr/bin/env python3 +""" + + sorting_animation.py + +A minimal sorting algorithm animation: +Sorts a shelf of 10 blocks using insertion +sort, selection sort and quicksort. + +Shelfs are implemented using builtin lists. + +Blocks are turtles with shape "square", but +stretched to rectangles by shapesize() + --------------------------------------- + To exit press space button + --------------------------------------- +""" +from turtle import * +import random + + +class Block(Turtle): + + def __init__(self, size): + self.size = size + Turtle.__init__(self, shape="square", visible=False) + self.pu() + self.shapesize(size * 1.5, 1.5, 2) # square-->rectangle + self.fillcolor("black") + self.st() + + def glow(self): + self.fillcolor("red") + + def unglow(self): + self.fillcolor("black") + + def __repr__(self): + return "Block size: {0}".format(self.size) + + +class Shelf(list): + + def __init__(self, y): + "create a shelf. y is y-position of first block" + self.y = y + self.x = -150 + + def push(self, d): + width, _, _ = d.shapesize() + # align blocks by the bottom edge + y_offset = width / 2 * 20 + d.sety(self.y + y_offset) + d.setx(self.x + 34 * len(self)) + self.append(d) + + def _close_gap_from_i(self, i): + for b in self[i:]: + xpos, _ = b.pos() + b.setx(xpos - 34) + + def _open_gap_from_i(self, i): + for b in self[i:]: + xpos, _ = b.pos() + b.setx(xpos + 34) + + def pop(self, key): + b = list.pop(self, key) + b.glow() + b.sety(200) + self._close_gap_from_i(key) + return b + + def insert(self, key, b): + self._open_gap_from_i(key) + list.insert(self, key, b) + b.setx(self.x + 34 * key) + width, _, _ = b.shapesize() + # align blocks by the bottom edge + y_offset = width / 2 * 20 + b.sety(self.y + y_offset) + b.unglow() + +def isort(shelf): + length = len(shelf) + for i in range(1, length): + hole = i + while hole > 0 and shelf[i].size < shelf[hole - 1].size: + hole = hole - 1 + shelf.insert(hole, shelf.pop(i)) + return + +def ssort(shelf): + length = len(shelf) + for j in range(0, length - 1): + imin = j + for i in range(j + 1, length): + if shelf[i].size < shelf[imin].size: + imin = i + if imin != j: + shelf.insert(j, shelf.pop(imin)) + +def partition(shelf, left, right, pivot_index): + pivot = shelf[pivot_index] + shelf.insert(right, shelf.pop(pivot_index)) + store_index = left + for i in range(left, right): # range is non-inclusive of ending value + if shelf[i].size < pivot.size: + shelf.insert(store_index, shelf.pop(i)) + store_index = store_index + 1 + shelf.insert(store_index, shelf.pop(right)) # move pivot to correct position + return store_index + +def qsort(shelf, left, right): + if left < right: + pivot_index = left + pivot_new_index = partition(shelf, left, right, pivot_index) + qsort(shelf, left, pivot_new_index - 1) + qsort(shelf, pivot_new_index + 1, right) + +def randomize(): + disable_keys() + clear() + target = list(range(10)) + random.shuffle(target) + for i, t in enumerate(target): + for j in range(i, len(s)): + if s[j].size == t + 1: + s.insert(i, s.pop(j)) + show_text(instructions1) + show_text(instructions2, line=1) + enable_keys() + +def show_text(text, line=0): + line = 20 * line + goto(0,-250 - line) + write(text, align="center", font=("Courier", 16, "bold")) + +def start_ssort(): + disable_keys() + clear() + show_text("Selection Sort") + ssort(s) + clear() + show_text(instructions1) + show_text(instructions2, line=1) + enable_keys() + +def start_isort(): + disable_keys() + clear() + show_text("Insertion Sort") + isort(s) + clear() + show_text(instructions1) + show_text(instructions2, line=1) + enable_keys() + +def start_qsort(): + disable_keys() + clear() + show_text("Quicksort") + qsort(s, 0, len(s) - 1) + clear() + show_text(instructions1) + show_text(instructions2, line=1) + enable_keys() + +def init_shelf(): + global s + s = Shelf(-200) + vals = (4, 2, 8, 9, 1, 5, 10, 3, 7, 6) + for i in vals: + s.push(Block(i)) + +def disable_keys(): + onkey(None, "s") + onkey(None, "i") + onkey(None, "q") + onkey(None, "r") + +def enable_keys(): + onkey(start_isort, "i") + onkey(start_ssort, "s") + onkey(start_qsort, "q") + onkey(randomize, "r") + onkey(bye, "space") + +def main(): + getscreen().clearscreen() + ht(); penup() + init_shelf() + show_text(instructions1) + show_text(instructions2, line=1) + enable_keys() + listen() + return "EVENTLOOP" + +instructions1 = "press i for insertion sort, s for selection sort, q for quicksort" +instructions2 = "spacebar to quit, r to randomize" + +if __name__=="__main__": + msg = main() + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/tree.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/tree.py new file mode 100644 index 0000000000000000000000000000000000000000..98a20da7f15c11d90a4243b8319131ceed2e8f4c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/tree.py @@ -0,0 +1,62 @@ +#!/usr/bin/env python3 +""" turtle-example-suite: + + tdemo_tree.py + +Displays a 'breadth-first-tree' - in contrast +to the classical Logo tree drawing programs, +which use a depth-first-algorithm. + +Uses: +(1) a tree-generator, where the drawing is +quasi the side-effect, whereas the generator +always yields None. +(2) Turtle-cloning: At each branching point +the current pen is cloned. So in the end +there are 1024 turtles. +""" +from turtle import Turtle, mainloop +from time import perf_counter as clock + +def tree(plist, l, a, f): + """ plist is list of pens + l is length of branch + a is half of the angle between 2 branches + f is factor by which branch is shortened + from level to level.""" + if l > 3: + lst = [] + for p in plist: + p.forward(l) + q = p.clone() + p.left(a) + q.right(a) + lst.append(p) + lst.append(q) + for x in tree(lst, l*f, a, f): + yield None + +def maketree(): + p = Turtle() + p.setundobuffer(None) + p.hideturtle() + p.speed(0) + p.getscreen().tracer(30,0) + p.left(90) + p.penup() + p.forward(-210) + p.pendown() + t = tree([p], 200, 65, 0.6375) + for x in t: + pass + +def main(): + a=clock() + maketree() + b=clock() + return "done: %.2f sec." % (b-a) + +if __name__ == "__main__": + msg = main() + print(msg) + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/turtle.cfg b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/turtle.cfg new file mode 100644 index 0000000000000000000000000000000000000000..bd89a741f926912a6a9288a688d1f31d133afac9 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/turtle.cfg @@ -0,0 +1,10 @@ +width = 800 +height = 600 +canvwidth = 1200 +canvheight = 900 +shape = arrow +mode = standard +resizemode = auto +fillcolor = "" +title = Python turtle graphics demo. + diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/two_canvases.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/two_canvases.py new file mode 100644 index 0000000000000000000000000000000000000000..f3602585ab0592c393fbe9526cb5aae4ae902f6c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/two_canvases.py @@ -0,0 +1,54 @@ +"""turtledemo.two_canvases + +Use TurtleScreen and RawTurtle to draw on two +distinct canvases in a separate window. The +new window must be separately closed in +addition to pressing the STOP button. +""" + +from turtle import TurtleScreen, RawTurtle, TK + +def main(): + root = TK.Tk() + cv1 = TK.Canvas(root, width=300, height=200, bg="#ddffff") + cv2 = TK.Canvas(root, width=300, height=200, bg="#ffeeee") + cv1.pack() + cv2.pack() + + s1 = TurtleScreen(cv1) + s1.bgcolor(0.85, 0.85, 1) + s2 = TurtleScreen(cv2) + s2.bgcolor(1, 0.85, 0.85) + + p = RawTurtle(s1) + q = RawTurtle(s2) + + p.color("red", (1, 0.85, 0.85)) + p.width(3) + q.color("blue", (0.85, 0.85, 1)) + q.width(3) + + for t in p,q: + t.shape("turtle") + t.lt(36) + + q.lt(180) + + for t in p, q: + t.begin_fill() + for i in range(5): + for t in p, q: + t.fd(50) + t.lt(72) + for t in p,q: + t.end_fill() + t.lt(54) + t.pu() + t.bk(50) + + return "EVENTLOOP" + + +if __name__ == '__main__': + main() + TK.mainloop() # keep window open until user closes it diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/yinyang.py b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/yinyang.py new file mode 100644 index 0000000000000000000000000000000000000000..11d1f47cae25491b302f2a387a816c3558130444 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/turtledemo/yinyang.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python3 +""" turtle-example-suite: + + tdemo_yinyang.py + +Another drawing suitable as a beginner's +programming example. + +The small circles are drawn by the circle +command. + +""" + +from turtle import * + +def yin(radius, color1, color2): + width(3) + color("black", color1) + begin_fill() + circle(radius/2., 180) + circle(radius, 180) + left(180) + circle(-radius/2., 180) + end_fill() + left(90) + up() + forward(radius*0.35) + right(90) + down() + color(color1, color2) + begin_fill() + circle(radius*0.15) + end_fill() + left(90) + up() + backward(radius*0.35) + down() + left(90) + +def main(): + reset() + yin(200, "black", "white") + yin(200, "white", "black") + ht() + return "Done!" + +if __name__ == '__main__': + main() + mainloop() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/types.py b/physworld_p1_20261018/envs/p1/lib/python3.11/types.py new file mode 100644 index 0000000000000000000000000000000000000000..2e73fbc45013372a8ced6d5c2ec41c4e1656d1b7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/types.py @@ -0,0 +1,305 @@ +""" +Define names for built-in types that aren't directly accessible as a builtin. +""" +import sys + +# Iterators in Python aren't a matter of type but of protocol. A large +# and changing number of builtin types implement *some* flavor of +# iterator. Don't check the type! Use hasattr to check for both +# "__iter__" and "__next__" attributes instead. + +def _f(): pass +FunctionType = type(_f) +LambdaType = type(lambda: None) # Same as FunctionType +CodeType = type(_f.__code__) +MappingProxyType = type(type.__dict__) +SimpleNamespace = type(sys.implementation) + +def _cell_factory(): + a = 1 + def f(): + nonlocal a + return f.__closure__[0] +CellType = type(_cell_factory()) + +def _g(): + yield 1 +GeneratorType = type(_g()) + +async def _c(): pass +_c = _c() +CoroutineType = type(_c) +_c.close() # Prevent ResourceWarning + +async def _ag(): + yield +_ag = _ag() +AsyncGeneratorType = type(_ag) + +class _C: + def _m(self): pass +MethodType = type(_C()._m) + +BuiltinFunctionType = type(len) +BuiltinMethodType = type([].append) # Same as BuiltinFunctionType + +WrapperDescriptorType = type(object.__init__) +MethodWrapperType = type(object().__str__) +MethodDescriptorType = type(str.join) +ClassMethodDescriptorType = type(dict.__dict__['fromkeys']) + +ModuleType = type(sys) + +try: + raise TypeError +except TypeError as exc: + TracebackType = type(exc.__traceback__) + FrameType = type(exc.__traceback__.tb_frame) + +# For Jython, the following two types are identical +GetSetDescriptorType = type(FunctionType.__code__) +MemberDescriptorType = type(FunctionType.__globals__) + +del sys, _f, _g, _C, _c, _ag # Not for export + + +# Provide a PEP 3115 compliant mechanism for class creation +def new_class(name, bases=(), kwds=None, exec_body=None): + """Create a class object dynamically using the appropriate metaclass.""" + resolved_bases = resolve_bases(bases) + meta, ns, kwds = prepare_class(name, resolved_bases, kwds) + if exec_body is not None: + exec_body(ns) + if resolved_bases is not bases: + ns['__orig_bases__'] = bases + return meta(name, resolved_bases, ns, **kwds) + +def resolve_bases(bases): + """Resolve MRO entries dynamically as specified by PEP 560.""" + new_bases = list(bases) + updated = False + shift = 0 + for i, base in enumerate(bases): + if isinstance(base, type): + continue + if not hasattr(base, "__mro_entries__"): + continue + new_base = base.__mro_entries__(bases) + updated = True + if not isinstance(new_base, tuple): + raise TypeError("__mro_entries__ must return a tuple") + else: + new_bases[i+shift:i+shift+1] = new_base + shift += len(new_base) - 1 + if not updated: + return bases + return tuple(new_bases) + +def prepare_class(name, bases=(), kwds=None): + """Call the __prepare__ method of the appropriate metaclass. + + Returns (metaclass, namespace, kwds) as a 3-tuple + + *metaclass* is the appropriate metaclass + *namespace* is the prepared class namespace + *kwds* is an updated copy of the passed in kwds argument with any + 'metaclass' entry removed. If no kwds argument is passed in, this will + be an empty dict. + """ + if kwds is None: + kwds = {} + else: + kwds = dict(kwds) # Don't alter the provided mapping + if 'metaclass' in kwds: + meta = kwds.pop('metaclass') + else: + if bases: + meta = type(bases[0]) + else: + meta = type + if isinstance(meta, type): + # when meta is a type, we first determine the most-derived metaclass + # instead of invoking the initial candidate directly + meta = _calculate_meta(meta, bases) + if hasattr(meta, '__prepare__'): + ns = meta.__prepare__(name, bases, **kwds) + else: + ns = {} + return meta, ns, kwds + +def _calculate_meta(meta, bases): + """Calculate the most derived metaclass.""" + winner = meta + for base in bases: + base_meta = type(base) + if issubclass(winner, base_meta): + continue + if issubclass(base_meta, winner): + winner = base_meta + continue + # else: + raise TypeError("metaclass conflict: " + "the metaclass of a derived class " + "must be a (non-strict) subclass " + "of the metaclasses of all its bases") + return winner + +class DynamicClassAttribute: + """Route attribute access on a class to __getattr__. + + This is a descriptor, used to define attributes that act differently when + accessed through an instance and through a class. Instance access remains + normal, but access to an attribute through a class will be routed to the + class's __getattr__ method; this is done by raising AttributeError. + + This allows one to have properties active on an instance, and have virtual + attributes on the class with the same name. (Enum used this between Python + versions 3.4 - 3.9 .) + + Subclass from this to use a different method of accessing virtual attributes + and still be treated properly by the inspect module. (Enum uses this since + Python 3.10 .) + + """ + def __init__(self, fget=None, fset=None, fdel=None, doc=None): + self.fget = fget + self.fset = fset + self.fdel = fdel + # next two lines make DynamicClassAttribute act the same as property + self.__doc__ = doc or fget.__doc__ + self.overwrite_doc = doc is None + # support for abstract methods + self.__isabstractmethod__ = bool(getattr(fget, '__isabstractmethod__', False)) + + def __get__(self, instance, ownerclass=None): + if instance is None: + if self.__isabstractmethod__: + return self + raise AttributeError() + elif self.fget is None: + raise AttributeError("unreadable attribute") + return self.fget(instance) + + def __set__(self, instance, value): + if self.fset is None: + raise AttributeError("can't set attribute") + self.fset(instance, value) + + def __delete__(self, instance): + if self.fdel is None: + raise AttributeError("can't delete attribute") + self.fdel(instance) + + def getter(self, fget): + fdoc = fget.__doc__ if self.overwrite_doc else None + result = type(self)(fget, self.fset, self.fdel, fdoc or self.__doc__) + result.overwrite_doc = self.overwrite_doc + return result + + def setter(self, fset): + result = type(self)(self.fget, fset, self.fdel, self.__doc__) + result.overwrite_doc = self.overwrite_doc + return result + + def deleter(self, fdel): + result = type(self)(self.fget, self.fset, fdel, self.__doc__) + result.overwrite_doc = self.overwrite_doc + return result + + +class _GeneratorWrapper: + # TODO: Implement this in C. + def __init__(self, gen): + self.__wrapped = gen + self.__isgen = gen.__class__ is GeneratorType + self.__name__ = getattr(gen, '__name__', None) + self.__qualname__ = getattr(gen, '__qualname__', None) + def send(self, val): + return self.__wrapped.send(val) + def throw(self, tp, *rest): + return self.__wrapped.throw(tp, *rest) + def close(self): + return self.__wrapped.close() + @property + def gi_code(self): + return self.__wrapped.gi_code + @property + def gi_frame(self): + return self.__wrapped.gi_frame + @property + def gi_running(self): + return self.__wrapped.gi_running + @property + def gi_yieldfrom(self): + return self.__wrapped.gi_yieldfrom + cr_code = gi_code + cr_frame = gi_frame + cr_running = gi_running + cr_await = gi_yieldfrom + def __next__(self): + return next(self.__wrapped) + def __iter__(self): + if self.__isgen: + return self.__wrapped + return self + __await__ = __iter__ + +def coroutine(func): + """Convert regular generator function to a coroutine.""" + + if not callable(func): + raise TypeError('types.coroutine() expects a callable') + + if (func.__class__ is FunctionType and + getattr(func, '__code__', None).__class__ is CodeType): + + co_flags = func.__code__.co_flags + + # Check if 'func' is a coroutine function. + # (0x180 == CO_COROUTINE | CO_ITERABLE_COROUTINE) + if co_flags & 0x180: + return func + + # Check if 'func' is a generator function. + # (0x20 == CO_GENERATOR) + if co_flags & 0x20: + # TODO: Implement this in C. + co = func.__code__ + # 0x100 == CO_ITERABLE_COROUTINE + func.__code__ = co.replace(co_flags=co.co_flags | 0x100) + return func + + # The following code is primarily to support functions that + # return generator-like objects (for instance generators + # compiled with Cython). + + # Delay functools and _collections_abc import for speeding up types import. + import functools + import _collections_abc + @functools.wraps(func) + def wrapped(*args, **kwargs): + coro = func(*args, **kwargs) + if (coro.__class__ is CoroutineType or + coro.__class__ is GeneratorType and coro.gi_code.co_flags & 0x100): + # 'coro' is a native coroutine object or an iterable coroutine + return coro + if (isinstance(coro, _collections_abc.Generator) and + not isinstance(coro, _collections_abc.Coroutine)): + # 'coro' is either a pure Python generator iterator, or it + # implements collections.abc.Generator (and does not implement + # collections.abc.Coroutine). + return _GeneratorWrapper(coro) + # 'coro' is either an instance of collections.abc.Coroutine or + # some other object -- pass it through. + return coro + + return wrapped + +GenericAlias = type(list[int]) +UnionType = type(int | str) + +EllipsisType = type(Ellipsis) +NoneType = type(None) +NotImplementedType = type(NotImplemented) + +__all__ = [n for n in globals() if n[:1] != '_'] diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/typing.py b/physworld_p1_20261018/envs/p1/lib/python3.11/typing.py new file mode 100644 index 0000000000000000000000000000000000000000..c26d01f76ace55648e0385b6887feb9a9208b6bc --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/typing.py @@ -0,0 +1,3538 @@ +""" +The typing module: Support for gradual typing as defined by PEP 484 and subsequent PEPs. + +Among other things, the module includes the following: +* Generic, Protocol, and internal machinery to support generic aliases. + All subscripted types like X[int], Union[int, str] are generic aliases. +* Various "special forms" that have unique meanings in type annotations: + NoReturn, Never, ClassVar, Self, Concatenate, Unpack, and others. +* Classes whose instances can be type arguments to generic classes and functions: + TypeVar, ParamSpec, TypeVarTuple. +* Public helper functions: get_type_hints, overload, cast, final, and others. +* Several protocols to support duck-typing: + SupportsFloat, SupportsIndex, SupportsAbs, and others. +* Special types: NewType, NamedTuple, TypedDict. +* Deprecated wrapper submodules for re and io related types. +* Deprecated aliases for builtin types and collections.abc ABCs. + +Any name not present in __all__ is an implementation detail +that may be changed without notice. Use at your own risk! +""" + +from abc import abstractmethod, ABCMeta +import collections +from collections import defaultdict +import collections.abc +import contextlib +import functools +import operator +import re as stdlib_re # Avoid confusion with the re we export. +import sys +import types +import warnings +from types import WrapperDescriptorType, MethodWrapperType, MethodDescriptorType, GenericAlias + + +try: + from _typing import _idfunc +except ImportError: + def _idfunc(_, x): + return x + +# Please keep __all__ alphabetized within each category. +__all__ = [ + # Super-special typing primitives. + 'Annotated', + 'Any', + 'Callable', + 'ClassVar', + 'Concatenate', + 'Final', + 'ForwardRef', + 'Generic', + 'Literal', + 'Optional', + 'ParamSpec', + 'Protocol', + 'Tuple', + 'Type', + 'TypeVar', + 'TypeVarTuple', + 'Union', + + # ABCs (from collections.abc). + 'AbstractSet', # collections.abc.Set. + 'ByteString', + 'Container', + 'ContextManager', + 'Hashable', + 'ItemsView', + 'Iterable', + 'Iterator', + 'KeysView', + 'Mapping', + 'MappingView', + 'MutableMapping', + 'MutableSequence', + 'MutableSet', + 'Sequence', + 'Sized', + 'ValuesView', + 'Awaitable', + 'AsyncIterator', + 'AsyncIterable', + 'Coroutine', + 'Collection', + 'AsyncGenerator', + 'AsyncContextManager', + + # Structural checks, a.k.a. protocols. + 'Reversible', + 'SupportsAbs', + 'SupportsBytes', + 'SupportsComplex', + 'SupportsFloat', + 'SupportsIndex', + 'SupportsInt', + 'SupportsRound', + + # Concrete collection types. + 'ChainMap', + 'Counter', + 'Deque', + 'Dict', + 'DefaultDict', + 'List', + 'OrderedDict', + 'Set', + 'FrozenSet', + 'NamedTuple', # Not really a type. + 'TypedDict', # Not really a type. + 'Generator', + + # Other concrete types. + 'BinaryIO', + 'IO', + 'Match', + 'Pattern', + 'TextIO', + + # One-off things. + 'AnyStr', + 'assert_type', + 'assert_never', + 'cast', + 'clear_overloads', + 'dataclass_transform', + 'final', + 'get_args', + 'get_origin', + 'get_overloads', + 'get_type_hints', + 'is_typeddict', + 'LiteralString', + 'Never', + 'NewType', + 'no_type_check', + 'no_type_check_decorator', + 'NoReturn', + 'NotRequired', + 'overload', + 'ParamSpecArgs', + 'ParamSpecKwargs', + 'Required', + 'reveal_type', + 'runtime_checkable', + 'Self', + 'Text', + 'TYPE_CHECKING', + 'TypeAlias', + 'TypeGuard', + 'Unpack', +] + +# The pseudo-submodules 're' and 'io' are part of the public +# namespace, but excluded from __all__ because they might stomp on +# legitimate imports of those modules. + + +def _type_convert(arg, module=None, *, allow_special_forms=False): + """For converting None to type(None), and strings to ForwardRef.""" + if arg is None: + return type(None) + if isinstance(arg, str): + return ForwardRef(arg, module=module, is_class=allow_special_forms) + return arg + + +def _type_check(arg, msg, is_argument=True, module=None, *, allow_special_forms=False): + """Check that the argument is a type, and return it (internal helper). + + As a special case, accept None and return type(None) instead. Also wrap strings + into ForwardRef instances. Consider several corner cases, for example plain + special forms like Union are not valid, while Union[int, str] is OK, etc. + The msg argument is a human-readable error message, e.g.:: + + "Union[arg, ...]: arg should be a type." + + We append the repr() of the actual value (truncated to 100 chars). + """ + invalid_generic_forms = (Generic, Protocol) + if not allow_special_forms: + invalid_generic_forms += (ClassVar,) + if is_argument: + invalid_generic_forms += (Final,) + + arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms) + if (isinstance(arg, _GenericAlias) and + arg.__origin__ in invalid_generic_forms): + raise TypeError(f"{arg} is not valid as type argument") + if arg in (Any, LiteralString, NoReturn, Never, Self, TypeAlias): + return arg + if allow_special_forms and arg in (ClassVar, Final): + return arg + if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol): + raise TypeError(f"Plain {arg} is not valid as type argument") + if type(arg) is tuple: + raise TypeError(f"{msg} Got {arg!r:.100}.") + return arg + + +def _is_param_expr(arg): + return arg is ... or isinstance(arg, + (tuple, list, ParamSpec, _ConcatenateGenericAlias)) + + +def _should_unflatten_callable_args(typ, args): + """Internal helper for munging collections.abc.Callable's __args__. + + The canonical representation for a Callable's __args__ flattens the + argument types, see https://github.com/python/cpython/issues/86361. + + For example:: + + >>> import collections.abc + >>> P = ParamSpec('P') + >>> collections.abc.Callable[[int, int], str].__args__ == (int, int, str) + True + >>> collections.abc.Callable[P, str].__args__ == (P, str) + True + + As a result, if we need to reconstruct the Callable from its __args__, + we need to unflatten it. + """ + return ( + typ.__origin__ is collections.abc.Callable + and not (len(args) == 2 and _is_param_expr(args[0])) + ) + + +def _type_repr(obj): + """Return the repr() of an object, special-casing types (internal helper). + + If obj is a type, we return a shorter version than the default + type.__repr__, based on the module and qualified name, which is + typically enough to uniquely identify a type. For everything + else, we fall back on repr(obj). + """ + if isinstance(obj, types.GenericAlias): + return repr(obj) + if isinstance(obj, type): + if obj.__module__ == 'builtins': + return obj.__qualname__ + return f'{obj.__module__}.{obj.__qualname__}' + if obj is ...: + return('...') + if isinstance(obj, types.FunctionType): + return obj.__name__ + return repr(obj) + + +def _collect_parameters(args): + """Collect all type variables and parameter specifications in args + in order of first appearance (lexicographic order). + + For example:: + + >>> P = ParamSpec('P') + >>> T = TypeVar('T') + >>> _collect_parameters((T, Callable[P, T])) + (~T, ~P) + """ + parameters = [] + for t in args: + if isinstance(t, type): + # We don't want __parameters__ descriptor of a bare Python class. + pass + elif isinstance(t, tuple): + # `t` might be a tuple, when `ParamSpec` is substituted with + # `[T, int]`, or `[int, *Ts]`, etc. + for x in t: + for collected in _collect_parameters([x]): + if collected not in parameters: + parameters.append(collected) + elif hasattr(t, '__typing_subst__'): + if t not in parameters: + parameters.append(t) + else: + for x in getattr(t, '__parameters__', ()): + if x not in parameters: + parameters.append(x) + return tuple(parameters) + + +def _check_generic(cls, parameters, elen): + """Check correct count for parameters of a generic cls (internal helper). + + This gives a nice error message in case of count mismatch. + """ + if not elen: + raise TypeError(f"{cls} is not a generic class") + alen = len(parameters) + if alen != elen: + raise TypeError(f"Too {'many' if alen > elen else 'few'} arguments for {cls};" + f" actual {alen}, expected {elen}") + +def _unpack_args(args): + newargs = [] + for arg in args: + subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) + if subargs is not None and not (subargs and subargs[-1] is ...): + newargs.extend(subargs) + else: + newargs.append(arg) + return newargs + +def _deduplicate(params, *, unhashable_fallback=False): + # Weed out strict duplicates, preserving the first of each occurrence. + try: + return dict.fromkeys(params) + except TypeError: + if not unhashable_fallback: + raise + # Happens for cases like `Annotated[dict, {'x': IntValidator()}]` + return _deduplicate_unhashable(params) + +def _deduplicate_unhashable(unhashable_params): + new_unhashable = [] + for t in unhashable_params: + if t not in new_unhashable: + new_unhashable.append(t) + return new_unhashable + +def _compare_args_orderless(first_args, second_args): + first_unhashable = _deduplicate_unhashable(first_args) + second_unhashable = _deduplicate_unhashable(second_args) + t = list(second_unhashable) + try: + for elem in first_unhashable: + t.remove(elem) + except ValueError: + return False + return not t + +def _remove_dups_flatten(parameters): + """Internal helper for Union creation and substitution. + + Flatten Unions among parameters, then remove duplicates. + """ + # Flatten out Union[Union[...], ...]. + params = [] + for p in parameters: + if isinstance(p, (_UnionGenericAlias, types.UnionType)): + params.extend(p.__args__) + else: + params.append(p) + + return tuple(_deduplicate(params, unhashable_fallback=True)) + + +def _flatten_literal_params(parameters): + """Internal helper for Literal creation: flatten Literals among parameters.""" + params = [] + for p in parameters: + if isinstance(p, _LiteralGenericAlias): + params.extend(p.__args__) + else: + params.append(p) + return tuple(params) + + +_cleanups = [] + + +def _tp_cache(func=None, /, *, typed=False): + """Internal wrapper caching __getitem__ of generic types. + + For non-hashable arguments, the original function is used as a fallback. + """ + def decorator(func): + cached = functools.lru_cache(typed=typed)(func) + _cleanups.append(cached.cache_clear) + + @functools.wraps(func) + def inner(*args, **kwds): + try: + return cached(*args, **kwds) + except TypeError: + pass # All real errors (not unhashable args) are raised below. + return func(*args, **kwds) + return inner + + if func is not None: + return decorator(func) + + return decorator + +def _eval_type(t, globalns, localns, recursive_guard=frozenset()): + """Evaluate all forward references in the given type t. + + For use of globalns and localns see the docstring for get_type_hints(). + recursive_guard is used to prevent infinite recursion with a recursive + ForwardRef. + """ + if isinstance(t, ForwardRef): + return t._evaluate(globalns, localns, recursive_guard) + if isinstance(t, (_GenericAlias, GenericAlias, types.UnionType)): + if isinstance(t, GenericAlias): + args = tuple( + ForwardRef(arg) if isinstance(arg, str) else arg + for arg in t.__args__ + ) + is_unpacked = t.__unpacked__ + if _should_unflatten_callable_args(t, args): + t = t.__origin__[(args[:-1], args[-1])] + else: + t = t.__origin__[args] + if is_unpacked: + t = Unpack[t] + ev_args = tuple(_eval_type(a, globalns, localns, recursive_guard) for a in t.__args__) + if ev_args == t.__args__: + return t + if isinstance(t, GenericAlias): + return GenericAlias(t.__origin__, ev_args) + if isinstance(t, types.UnionType): + return functools.reduce(operator.or_, ev_args) + else: + return t.copy_with(ev_args) + return t + + +class _Final: + """Mixin to prohibit subclassing.""" + + __slots__ = ('__weakref__',) + + def __init_subclass__(cls, /, *args, **kwds): + if '_root' not in kwds: + raise TypeError("Cannot subclass special typing classes") + +class _Immutable: + """Mixin to indicate that object should not be copied.""" + + __slots__ = () + + def __copy__(self): + return self + + def __deepcopy__(self, memo): + return self + + +class _NotIterable: + """Mixin to prevent iteration, without being compatible with Iterable. + + That is, we could do:: + + def __iter__(self): raise TypeError() + + But this would make users of this mixin duck type-compatible with + collections.abc.Iterable - isinstance(foo, Iterable) would be True. + + Luckily, we can instead prevent iteration by setting __iter__ to None, which + is treated specially. + """ + + __slots__ = () + __iter__ = None + + +# Internal indicator of special typing constructs. +# See __doc__ instance attribute for specific docs. +class _SpecialForm(_Final, _NotIterable, _root=True): + __slots__ = ('_name', '__doc__', '_getitem') + + def __init__(self, getitem): + self._getitem = getitem + self._name = getitem.__name__ + self.__doc__ = getitem.__doc__ + + def __getattr__(self, item): + if item in {'__name__', '__qualname__'}: + return self._name + + raise AttributeError(item) + + def __mro_entries__(self, bases): + raise TypeError(f"Cannot subclass {self!r}") + + def __repr__(self): + return 'typing.' + self._name + + def __reduce__(self): + return self._name + + def __call__(self, *args, **kwds): + raise TypeError(f"Cannot instantiate {self!r}") + + def __or__(self, other): + return Union[self, other] + + def __ror__(self, other): + return Union[other, self] + + def __instancecheck__(self, obj): + raise TypeError(f"{self} cannot be used with isinstance()") + + def __subclasscheck__(self, cls): + raise TypeError(f"{self} cannot be used with issubclass()") + + @_tp_cache + def __getitem__(self, parameters): + return self._getitem(self, parameters) + + +class _LiteralSpecialForm(_SpecialForm, _root=True): + def __getitem__(self, parameters): + if not isinstance(parameters, tuple): + parameters = (parameters,) + return self._getitem(self, *parameters) + + +class _AnyMeta(type): + def __instancecheck__(self, obj): + if self is Any: + raise TypeError("typing.Any cannot be used with isinstance()") + return super().__instancecheck__(obj) + + def __repr__(self): + if self is Any: + return "typing.Any" + return super().__repr__() # respect to subclasses + + +class Any(metaclass=_AnyMeta): + """Special type indicating an unconstrained type. + + - Any is compatible with every type. + - Any assumed to have all methods. + - All values assumed to be instances of Any. + + Note that all the above statements are true from the point of view of + static type checkers. At runtime, Any should not be used with instance + checks. + """ + + def __new__(cls, *args, **kwargs): + if cls is Any: + raise TypeError("Any cannot be instantiated") + return super().__new__(cls) + + +@_SpecialForm +def NoReturn(self, parameters): + """Special type indicating functions that never return. + + Example:: + + from typing import NoReturn + + def stop() -> NoReturn: + raise Exception('no way') + + NoReturn can also be used as a bottom type, a type that + has no values. Starting in Python 3.11, the Never type should + be used for this concept instead. Type checkers should treat the two + equivalently. + """ + raise TypeError(f"{self} is not subscriptable") + +# This is semantically identical to NoReturn, but it is implemented +# separately so that type checkers can distinguish between the two +# if they want. +@_SpecialForm +def Never(self, parameters): + """The bottom type, a type that has no members. + + This can be used to define a function that should never be + called, or a function that never returns:: + + from typing import Never + + def never_call_me(arg: Never) -> None: + pass + + def int_or_str(arg: int | str) -> None: + never_call_me(arg) # type checker error + match arg: + case int(): + print("It's an int") + case str(): + print("It's a str") + case _: + never_call_me(arg) # OK, arg is of type Never + """ + raise TypeError(f"{self} is not subscriptable") + + +@_SpecialForm +def Self(self, parameters): + """Used to spell the type of "self" in classes. + + Example:: + + from typing import Self + + class Foo: + def return_self(self) -> Self: + ... + return self + + This is especially useful for: + - classmethods that are used as alternative constructors + - annotating an `__enter__` method which returns self + """ + raise TypeError(f"{self} is not subscriptable") + + +@_SpecialForm +def LiteralString(self, parameters): + """Represents an arbitrary literal string. + + Example:: + + from typing import LiteralString + + def run_query(sql: LiteralString) -> None: + ... + + def caller(arbitrary_string: str, literal_string: LiteralString) -> None: + run_query("SELECT * FROM students") # OK + run_query(literal_string) # OK + run_query("SELECT * FROM " + literal_string) # OK + run_query(arbitrary_string) # type checker error + run_query( # type checker error + f"SELECT * FROM students WHERE name = {arbitrary_string}" + ) + + Only string literals and other LiteralStrings are compatible + with LiteralString. This provides a tool to help prevent + security issues such as SQL injection. + """ + raise TypeError(f"{self} is not subscriptable") + + +@_SpecialForm +def ClassVar(self, parameters): + """Special type construct to mark class variables. + + An annotation wrapped in ClassVar indicates that a given + attribute is intended to be used as a class variable and + should not be set on instances of that class. + + Usage:: + + class Starship: + stats: ClassVar[dict[str, int]] = {} # class variable + damage: int = 10 # instance variable + + ClassVar accepts only types and cannot be further subscribed. + + Note that ClassVar is not a class itself, and should not + be used with isinstance() or issubclass(). + """ + item = _type_check(parameters, f'{self} accepts only single type.') + return _GenericAlias(self, (item,)) + +@_SpecialForm +def Final(self, parameters): + """Special typing construct to indicate final names to type checkers. + + A final name cannot be re-assigned or overridden in a subclass. + + For example:: + + MAX_SIZE: Final = 9000 + MAX_SIZE += 1 # Error reported by type checker + + class Connection: + TIMEOUT: Final[int] = 10 + + class FastConnector(Connection): + TIMEOUT = 1 # Error reported by type checker + + There is no runtime checking of these properties. + """ + item = _type_check(parameters, f'{self} accepts only single type.') + return _GenericAlias(self, (item,)) + +@_SpecialForm +def Union(self, parameters): + """Union type; Union[X, Y] means either X or Y. + + On Python 3.10 and higher, the | operator + can also be used to denote unions; + X | Y means the same thing to the type checker as Union[X, Y]. + + To define a union, use e.g. Union[int, str]. Details: + - The arguments must be types and there must be at least one. + - None as an argument is a special case and is replaced by + type(None). + - Unions of unions are flattened, e.g.:: + + assert Union[Union[int, str], float] == Union[int, str, float] + + - Unions of a single argument vanish, e.g.:: + + assert Union[int] == int # The constructor actually returns int + + - Redundant arguments are skipped, e.g.:: + + assert Union[int, str, int] == Union[int, str] + + - When comparing unions, the argument order is ignored, e.g.:: + + assert Union[int, str] == Union[str, int] + + - You cannot subclass or instantiate a union. + - You can use Optional[X] as a shorthand for Union[X, None]. + """ + if parameters == (): + raise TypeError("Cannot take a Union of no types.") + if not isinstance(parameters, tuple): + parameters = (parameters,) + msg = "Union[arg, ...]: each arg must be a type." + parameters = tuple(_type_check(p, msg) for p in parameters) + parameters = _remove_dups_flatten(parameters) + if len(parameters) == 1: + return parameters[0] + if len(parameters) == 2 and type(None) in parameters: + return _UnionGenericAlias(self, parameters, name="Optional") + return _UnionGenericAlias(self, parameters) + +@_SpecialForm +def Optional(self, parameters): + """Optional[X] is equivalent to Union[X, None].""" + arg = _type_check(parameters, f"{self} requires a single type.") + return Union[arg, type(None)] + +@_LiteralSpecialForm +@_tp_cache(typed=True) +def Literal(self, *parameters): + """Special typing form to define literal types (a.k.a. value types). + + This form can be used to indicate to type checkers that the corresponding + variable or function parameter has a value equivalent to the provided + literal (or one of several literals):: + + def validate_simple(data: Any) -> Literal[True]: # always returns True + ... + + MODE = Literal['r', 'rb', 'w', 'wb'] + def open_helper(file: str, mode: MODE) -> str: + ... + + open_helper('/some/path', 'r') # Passes type check + open_helper('/other/path', 'typo') # Error in type checker + + Literal[...] cannot be subclassed. At runtime, an arbitrary value + is allowed as type argument to Literal[...], but type checkers may + impose restrictions. + """ + # There is no '_type_check' call because arguments to Literal[...] are + # values, not types. + parameters = _flatten_literal_params(parameters) + + try: + parameters = tuple(p for p, _ in _deduplicate(list(_value_and_type_iter(parameters)))) + except TypeError: # unhashable parameters + pass + + return _LiteralGenericAlias(self, parameters) + + +@_SpecialForm +def TypeAlias(self, parameters): + """Special form for marking type aliases. + + Use TypeAlias to indicate that an assignment should + be recognized as a proper type alias definition by type + checkers. + + For example:: + + Predicate: TypeAlias = Callable[..., bool] + + It's invalid when used anywhere except as in the example above. + """ + raise TypeError(f"{self} is not subscriptable") + + +@_SpecialForm +def Concatenate(self, parameters): + """Special form for annotating higher-order functions. + + ``Concatenate`` can be used in conjunction with ``ParamSpec`` and + ``Callable`` to represent a higher-order function which adds, removes or + transforms the parameters of a callable. + + For example:: + + Callable[Concatenate[int, P], int] + + See PEP 612 for detailed information. + """ + if parameters == (): + raise TypeError("Cannot take a Concatenate of no types.") + if not isinstance(parameters, tuple): + parameters = (parameters,) + if not (parameters[-1] is ... or isinstance(parameters[-1], ParamSpec)): + raise TypeError("The last parameter to Concatenate should be a " + "ParamSpec variable or ellipsis.") + msg = "Concatenate[arg, ...]: each arg must be a type." + parameters = (*(_type_check(p, msg) for p in parameters[:-1]), parameters[-1]) + return _ConcatenateGenericAlias(self, parameters, + _paramspec_tvars=True) + + +@_SpecialForm +def TypeGuard(self, parameters): + """Special typing construct for marking user-defined type guard functions. + + ``TypeGuard`` can be used to annotate the return type of a user-defined + type guard function. ``TypeGuard`` only accepts a single type argument. + At runtime, functions marked this way should return a boolean. + + ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static + type checkers to determine a more precise type of an expression within a + program's code flow. Usually type narrowing is done by analyzing + conditional code flow and applying the narrowing to a block of code. The + conditional expression here is sometimes referred to as a "type guard". + + Sometimes it would be convenient to use a user-defined boolean function + as a type guard. Such a function should use ``TypeGuard[...]`` as its + return type to alert static type checkers to this intention. + + Using ``-> TypeGuard`` tells the static type checker that for a given + function: + + 1. The return value is a boolean. + 2. If the return value is ``True``, the type of its argument + is the type inside ``TypeGuard``. + + For example:: + + def is_str(val: Union[str, float]): + # "isinstance" type guard + if isinstance(val, str): + # Type of ``val`` is narrowed to ``str`` + ... + else: + # Else, type of ``val`` is narrowed to ``float``. + ... + + Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower + form of ``TypeA`` (it can even be a wider form) and this may lead to + type-unsafe results. The main reason is to allow for things like + narrowing ``List[object]`` to ``List[str]`` even though the latter is not + a subtype of the former, since ``List`` is invariant. The responsibility of + writing type-safe type guards is left to the user. + + ``TypeGuard`` also works with type variables. For more information, see + PEP 647 (User-Defined Type Guards). + """ + item = _type_check(parameters, f'{self} accepts only single type.') + return _GenericAlias(self, (item,)) + + +class ForwardRef(_Final, _root=True): + """Internal wrapper to hold a forward reference.""" + + __slots__ = ('__forward_arg__', '__forward_code__', + '__forward_evaluated__', '__forward_value__', + '__forward_is_argument__', '__forward_is_class__', + '__forward_module__') + + def __init__(self, arg, is_argument=True, module=None, *, is_class=False): + if not isinstance(arg, str): + raise TypeError(f"Forward reference must be a string -- got {arg!r}") + + # If we do `def f(*args: *Ts)`, then we'll have `arg = '*Ts'`. + # Unfortunately, this isn't a valid expression on its own, so we + # do the unpacking manually. + if arg.startswith('*'): + arg_to_compile = f'({arg},)[0]' # E.g. (*Ts,)[0] or (*tuple[int, int],)[0] + else: + arg_to_compile = arg + try: + code = compile(arg_to_compile, '', 'eval') + except SyntaxError: + raise SyntaxError(f"Forward reference must be an expression -- got {arg!r}") + + self.__forward_arg__ = arg + self.__forward_code__ = code + self.__forward_evaluated__ = False + self.__forward_value__ = None + self.__forward_is_argument__ = is_argument + self.__forward_is_class__ = is_class + self.__forward_module__ = module + + def _evaluate(self, globalns, localns, recursive_guard): + if self.__forward_arg__ in recursive_guard: + return self + if not self.__forward_evaluated__ or localns is not globalns: + if globalns is None and localns is None: + globalns = localns = {} + elif globalns is None: + globalns = localns + elif localns is None: + localns = globalns + if self.__forward_module__ is not None: + globalns = getattr( + sys.modules.get(self.__forward_module__, None), '__dict__', globalns + ) + type_ = _type_check( + eval(self.__forward_code__, globalns, localns), + "Forward references must evaluate to types.", + is_argument=self.__forward_is_argument__, + allow_special_forms=self.__forward_is_class__, + ) + self.__forward_value__ = _eval_type( + type_, globalns, localns, recursive_guard | {self.__forward_arg__} + ) + self.__forward_evaluated__ = True + return self.__forward_value__ + + def __eq__(self, other): + if not isinstance(other, ForwardRef): + return NotImplemented + if self.__forward_evaluated__ and other.__forward_evaluated__: + return (self.__forward_arg__ == other.__forward_arg__ and + self.__forward_value__ == other.__forward_value__) + return (self.__forward_arg__ == other.__forward_arg__ and + self.__forward_module__ == other.__forward_module__) + + def __hash__(self): + return hash((self.__forward_arg__, self.__forward_module__)) + + def __or__(self, other): + return Union[self, other] + + def __ror__(self, other): + return Union[other, self] + + def __repr__(self): + if self.__forward_module__ is None: + module_repr = '' + else: + module_repr = f', module={self.__forward_module__!r}' + return f'ForwardRef({self.__forward_arg__!r}{module_repr})' + + +def _is_unpacked_typevartuple(x: Any) -> bool: + return ((not isinstance(x, type)) and + getattr(x, '__typing_is_unpacked_typevartuple__', False)) + + +def _is_typevar_like(x: Any) -> bool: + return isinstance(x, (TypeVar, ParamSpec)) or _is_unpacked_typevartuple(x) + + +class _PickleUsingNameMixin: + """Mixin enabling pickling based on self.__name__.""" + + def __reduce__(self): + return self.__name__ + + +class _BoundVarianceMixin: + """Mixin giving __init__ bound and variance arguments. + + This is used by TypeVar and ParamSpec, which both employ the notions of + a type 'bound' (restricting type arguments to be a subtype of some + specified type) and type 'variance' (determining subtype relations between + generic types). + """ + def __init__(self, bound, covariant, contravariant): + """Used to setup TypeVars and ParamSpec's bound, covariant and + contravariant attributes. + """ + if covariant and contravariant: + raise ValueError("Bivariant types are not supported.") + self.__covariant__ = bool(covariant) + self.__contravariant__ = bool(contravariant) + if bound: + self.__bound__ = _type_check(bound, "Bound must be a type.") + else: + self.__bound__ = None + + def __or__(self, right): + return Union[self, right] + + def __ror__(self, left): + return Union[left, self] + + def __repr__(self): + if self.__covariant__: + prefix = '+' + elif self.__contravariant__: + prefix = '-' + else: + prefix = '~' + return prefix + self.__name__ + + +class TypeVar(_Final, _Immutable, _BoundVarianceMixin, _PickleUsingNameMixin, + _root=True): + """Type variable. + + Usage:: + + T = TypeVar('T') # Can be anything + A = TypeVar('A', str, bytes) # Must be str or bytes + + Type variables exist primarily for the benefit of static type + checkers. They serve as the parameters for generic types as well + as for generic function definitions. See class Generic for more + information on generic types. Generic functions work as follows: + + def repeat(x: T, n: int) -> List[T]: + '''Return a list containing n references to x.''' + return [x]*n + + def longest(x: A, y: A) -> A: + '''Return the longest of two strings.''' + return x if len(x) >= len(y) else y + + The latter example's signature is essentially the overloading + of (str, str) -> str and (bytes, bytes) -> bytes. Also note + that if the arguments are instances of some subclass of str, + the return type is still plain str. + + At runtime, isinstance(x, T) and issubclass(C, T) will raise TypeError. + + Type variables defined with covariant=True or contravariant=True + can be used to declare covariant or contravariant generic types. + See PEP 484 for more details. By default generic types are invariant + in all type variables. + + Type variables can be introspected. e.g.: + + T.__name__ == 'T' + T.__constraints__ == () + T.__covariant__ == False + T.__contravariant__ = False + A.__constraints__ == (str, bytes) + + Note that only type variables defined in global scope can be pickled. + """ + + def __init__(self, name, *constraints, bound=None, + covariant=False, contravariant=False): + self.__name__ = name + super().__init__(bound, covariant, contravariant) + if constraints and bound is not None: + raise TypeError("Constraints cannot be combined with bound=...") + if constraints and len(constraints) == 1: + raise TypeError("A single constraint is not allowed") + msg = "TypeVar(name, constraint, ...): constraints must be types." + self.__constraints__ = tuple(_type_check(t, msg) for t in constraints) + def_mod = _caller() + if def_mod != 'typing': + self.__module__ = def_mod + + def __typing_subst__(self, arg): + msg = "Parameters to generic types must be types." + arg = _type_check(arg, msg, is_argument=True) + if ((isinstance(arg, _GenericAlias) and arg.__origin__ is Unpack) or + (isinstance(arg, GenericAlias) and getattr(arg, '__unpacked__', False))): + raise TypeError(f"{arg} is not valid as type argument") + return arg + + +class TypeVarTuple(_Final, _Immutable, _PickleUsingNameMixin, _root=True): + """Type variable tuple. + + Usage: + + Ts = TypeVarTuple('Ts') # Can be given any name + + Just as a TypeVar (type variable) is a placeholder for a single type, + a TypeVarTuple is a placeholder for an *arbitrary* number of types. For + example, if we define a generic class using a TypeVarTuple: + + class C(Generic[*Ts]): ... + + Then we can parameterize that class with an arbitrary number of type + arguments: + + C[int] # Fine + C[int, str] # Also fine + C[()] # Even this is fine + + For more details, see PEP 646. + + Note that only TypeVarTuples defined in global scope can be pickled. + """ + + def __init__(self, name): + self.__name__ = name + + # Used for pickling. + def_mod = _caller() + if def_mod != 'typing': + self.__module__ = def_mod + + def __iter__(self): + yield Unpack[self] + + def __repr__(self): + return self.__name__ + + def __typing_subst__(self, arg): + raise TypeError("Substitution of bare TypeVarTuple is not supported") + + def __typing_prepare_subst__(self, alias, args): + params = alias.__parameters__ + typevartuple_index = params.index(self) + for param in params[typevartuple_index + 1:]: + if isinstance(param, TypeVarTuple): + raise TypeError(f"More than one TypeVarTuple parameter in {alias}") + + alen = len(args) + plen = len(params) + left = typevartuple_index + right = plen - typevartuple_index - 1 + var_tuple_index = None + fillarg = None + for k, arg in enumerate(args): + if not isinstance(arg, type): + subargs = getattr(arg, '__typing_unpacked_tuple_args__', None) + if subargs and len(subargs) == 2 and subargs[-1] is ...: + if var_tuple_index is not None: + raise TypeError("More than one unpacked arbitrary-length tuple argument") + var_tuple_index = k + fillarg = subargs[0] + if var_tuple_index is not None: + left = min(left, var_tuple_index) + right = min(right, alen - var_tuple_index - 1) + elif left + right > alen: + raise TypeError(f"Too few arguments for {alias};" + f" actual {alen}, expected at least {plen-1}") + + return ( + *args[:left], + *([fillarg]*(typevartuple_index - left)), + tuple(args[left: alen - right]), + *([fillarg]*(plen - right - left - typevartuple_index - 1)), + *args[alen - right:], + ) + + +class ParamSpecArgs(_Final, _Immutable, _root=True): + """The args for a ParamSpec object. + + Given a ParamSpec object P, P.args is an instance of ParamSpecArgs. + + ParamSpecArgs objects have a reference back to their ParamSpec: + + P.args.__origin__ is P + + This type is meant for runtime introspection and has no special meaning to + static type checkers. + """ + def __init__(self, origin): + self.__origin__ = origin + + def __repr__(self): + return f"{self.__origin__.__name__}.args" + + def __eq__(self, other): + if not isinstance(other, ParamSpecArgs): + return NotImplemented + return self.__origin__ == other.__origin__ + + +class ParamSpecKwargs(_Final, _Immutable, _root=True): + """The kwargs for a ParamSpec object. + + Given a ParamSpec object P, P.kwargs is an instance of ParamSpecKwargs. + + ParamSpecKwargs objects have a reference back to their ParamSpec: + + P.kwargs.__origin__ is P + + This type is meant for runtime introspection and has no special meaning to + static type checkers. + """ + def __init__(self, origin): + self.__origin__ = origin + + def __repr__(self): + return f"{self.__origin__.__name__}.kwargs" + + def __eq__(self, other): + if not isinstance(other, ParamSpecKwargs): + return NotImplemented + return self.__origin__ == other.__origin__ + + +class ParamSpec(_Final, _Immutable, _BoundVarianceMixin, _PickleUsingNameMixin, + _root=True): + """Parameter specification variable. + + Usage:: + + P = ParamSpec('P') + + Parameter specification variables exist primarily for the benefit of static + type checkers. They are used to forward the parameter types of one + callable to another callable, a pattern commonly found in higher order + functions and decorators. They are only valid when used in ``Concatenate``, + or as the first argument to ``Callable``, or as parameters for user-defined + Generics. See class Generic for more information on generic types. An + example for annotating a decorator:: + + T = TypeVar('T') + P = ParamSpec('P') + + def add_logging(f: Callable[P, T]) -> Callable[P, T]: + '''A type-safe decorator to add logging to a function.''' + def inner(*args: P.args, **kwargs: P.kwargs) -> T: + logging.info(f'{f.__name__} was called') + return f(*args, **kwargs) + return inner + + @add_logging + def add_two(x: float, y: float) -> float: + '''Add two numbers together.''' + return x + y + + Parameter specification variables can be introspected. e.g.: + + P.__name__ == 'P' + + Note that only parameter specification variables defined in global scope can + be pickled. + """ + + @property + def args(self): + return ParamSpecArgs(self) + + @property + def kwargs(self): + return ParamSpecKwargs(self) + + def __init__(self, name, *, bound=None, covariant=False, contravariant=False): + self.__name__ = name + super().__init__(bound, covariant, contravariant) + def_mod = _caller() + if def_mod != 'typing': + self.__module__ = def_mod + + def __typing_subst__(self, arg): + if isinstance(arg, (list, tuple)): + arg = tuple(_type_check(a, "Expected a type.") for a in arg) + elif not _is_param_expr(arg): + raise TypeError(f"Expected a list of types, an ellipsis, " + f"ParamSpec, or Concatenate. Got {arg}") + return arg + + def __typing_prepare_subst__(self, alias, args): + params = alias.__parameters__ + i = params.index(self) + if i >= len(args): + raise TypeError(f"Too few arguments for {alias}") + # Special case where Z[[int, str, bool]] == Z[int, str, bool] in PEP 612. + if len(params) == 1 and not _is_param_expr(args[0]): + assert i == 0 + args = (args,) + # Convert lists to tuples to help other libraries cache the results. + elif isinstance(args[i], list): + args = (*args[:i], tuple(args[i]), *args[i+1:]) + return args + +def _is_dunder(attr): + return attr.startswith('__') and attr.endswith('__') + +class _BaseGenericAlias(_Final, _root=True): + """The central part of the internal API. + + This represents a generic version of type 'origin' with type arguments 'params'. + There are two kind of these aliases: user defined and special. The special ones + are wrappers around builtin collections and ABCs in collections.abc. These must + have 'name' always set. If 'inst' is False, then the alias can't be instantiated; + this is used by e.g. typing.List and typing.Dict. + """ + + def __init__(self, origin, *, inst=True, name=None): + self._inst = inst + self._name = name + self.__origin__ = origin + self.__slots__ = None # This is not documented. + + def __call__(self, *args, **kwargs): + if not self._inst: + raise TypeError(f"Type {self._name} cannot be instantiated; " + f"use {self.__origin__.__name__}() instead") + result = self.__origin__(*args, **kwargs) + try: + result.__orig_class__ = self + # Some objects raise TypeError (or something even more exotic) + # if you try to set attributes on them; we guard against that here + except Exception: + pass + return result + + def __mro_entries__(self, bases): + res = [] + if self.__origin__ not in bases: + res.append(self.__origin__) + i = bases.index(self) + for b in bases[i+1:]: + if isinstance(b, _BaseGenericAlias) or issubclass(b, Generic): + break + else: + res.append(Generic) + return tuple(res) + + def __getattr__(self, attr): + if attr in {'__name__', '__qualname__'}: + return self._name or self.__origin__.__name__ + + # We are careful for copy and pickle. + # Also for simplicity we don't relay any dunder names + if '__origin__' in self.__dict__ and not _is_dunder(attr): + return getattr(self.__origin__, attr) + raise AttributeError(attr) + + def __setattr__(self, attr, val): + if _is_dunder(attr) or attr in {'_name', '_inst', '_nparams', + '_paramspec_tvars'}: + super().__setattr__(attr, val) + else: + setattr(self.__origin__, attr, val) + + def __instancecheck__(self, obj): + return self.__subclasscheck__(type(obj)) + + def __subclasscheck__(self, cls): + raise TypeError("Subscripted generics cannot be used with" + " class and instance checks") + + def __dir__(self): + return list(set(super().__dir__() + + [attr for attr in dir(self.__origin__) if not _is_dunder(attr)])) + + +# Special typing constructs Union, Optional, Generic, Callable and Tuple +# use three special attributes for internal bookkeeping of generic types: +# * __parameters__ is a tuple of unique free type parameters of a generic +# type, for example, Dict[T, T].__parameters__ == (T,); +# * __origin__ keeps a reference to a type that was subscripted, +# e.g., Union[T, int].__origin__ == Union, or the non-generic version of +# the type. +# * __args__ is a tuple of all arguments used in subscripting, +# e.g., Dict[T, int].__args__ == (T, int). + + +class _GenericAlias(_BaseGenericAlias, _root=True): + # The type of parameterized generics. + # + # That is, for example, `type(List[int])` is `_GenericAlias`. + # + # Objects which are instances of this class include: + # * Parameterized container types, e.g. `Tuple[int]`, `List[int]`. + # * Note that native container types, e.g. `tuple`, `list`, use + # `types.GenericAlias` instead. + # * Parameterized classes: + # T = TypeVar('T') + # class C(Generic[T]): pass + # # C[int] is a _GenericAlias + # * `Callable` aliases, generic `Callable` aliases, and + # parameterized `Callable` aliases: + # T = TypeVar('T') + # # _CallableGenericAlias inherits from _GenericAlias. + # A = Callable[[], None] # _CallableGenericAlias + # B = Callable[[T], None] # _CallableGenericAlias + # C = B[int] # _CallableGenericAlias + # * Parameterized `Final`, `ClassVar` and `TypeGuard`: + # # All _GenericAlias + # Final[int] + # ClassVar[float] + # TypeVar[bool] + + def __init__(self, origin, args, *, inst=True, name=None, + _paramspec_tvars=False): + super().__init__(origin, inst=inst, name=name) + if not isinstance(args, tuple): + args = (args,) + self.__args__ = tuple(... if a is _TypingEllipsis else + a for a in args) + self.__parameters__ = _collect_parameters(args) + self._paramspec_tvars = _paramspec_tvars + if not name: + self.__module__ = origin.__module__ + + def __eq__(self, other): + if not isinstance(other, _GenericAlias): + return NotImplemented + return (self.__origin__ == other.__origin__ + and self.__args__ == other.__args__) + + def __hash__(self): + return hash((self.__origin__, self.__args__)) + + def __or__(self, right): + return Union[self, right] + + def __ror__(self, left): + return Union[left, self] + + @_tp_cache + def __getitem__(self, args): + # Parameterizes an already-parameterized object. + # + # For example, we arrive here doing something like: + # T1 = TypeVar('T1') + # T2 = TypeVar('T2') + # T3 = TypeVar('T3') + # class A(Generic[T1]): pass + # B = A[T2] # B is a _GenericAlias + # C = B[T3] # Invokes _GenericAlias.__getitem__ + # + # We also arrive here when parameterizing a generic `Callable` alias: + # T = TypeVar('T') + # C = Callable[[T], None] + # C[int] # Invokes _GenericAlias.__getitem__ + + if self.__origin__ in (Generic, Protocol): + # Can't subscript Generic[...] or Protocol[...]. + raise TypeError(f"Cannot subscript already-subscripted {self}") + if not self.__parameters__: + raise TypeError(f"{self} is not a generic class") + + # Preprocess `args`. + if not isinstance(args, tuple): + args = (args,) + args = tuple(_type_convert(p) for p in args) + args = _unpack_args(args) + new_args = self._determine_new_args(args) + r = self.copy_with(new_args) + return r + + def _determine_new_args(self, args): + # Determines new __args__ for __getitem__. + # + # For example, suppose we had: + # T1 = TypeVar('T1') + # T2 = TypeVar('T2') + # class A(Generic[T1, T2]): pass + # T3 = TypeVar('T3') + # B = A[int, T3] + # C = B[str] + # `B.__args__` is `(int, T3)`, so `C.__args__` should be `(int, str)`. + # Unfortunately, this is harder than it looks, because if `T3` is + # anything more exotic than a plain `TypeVar`, we need to consider + # edge cases. + + params = self.__parameters__ + # In the example above, this would be {T3: str} + for param in params: + prepare = getattr(param, '__typing_prepare_subst__', None) + if prepare is not None: + args = prepare(self, args) + alen = len(args) + plen = len(params) + if alen != plen: + raise TypeError(f"Too {'many' if alen > plen else 'few'} arguments for {self};" + f" actual {alen}, expected {plen}") + new_arg_by_param = dict(zip(params, args)) + return tuple(self._make_substitution(self.__args__, new_arg_by_param)) + + def _make_substitution(self, args, new_arg_by_param): + """Create a list of new type arguments.""" + new_args = [] + for old_arg in args: + if isinstance(old_arg, type): + new_args.append(old_arg) + continue + + substfunc = getattr(old_arg, '__typing_subst__', None) + if substfunc: + new_arg = substfunc(new_arg_by_param[old_arg]) + else: + subparams = getattr(old_arg, '__parameters__', ()) + if not subparams: + new_arg = old_arg + else: + subargs = [] + for x in subparams: + if isinstance(x, TypeVarTuple): + subargs.extend(new_arg_by_param[x]) + else: + subargs.append(new_arg_by_param[x]) + new_arg = old_arg[tuple(subargs)] + + if self.__origin__ == collections.abc.Callable and isinstance(new_arg, tuple): + # Consider the following `Callable`. + # C = Callable[[int], str] + # Here, `C.__args__` should be (int, str) - NOT ([int], str). + # That means that if we had something like... + # P = ParamSpec('P') + # T = TypeVar('T') + # C = Callable[P, T] + # D = C[[int, str], float] + # ...we need to be careful; `new_args` should end up as + # `(int, str, float)` rather than `([int, str], float)`. + new_args.extend(new_arg) + elif _is_unpacked_typevartuple(old_arg): + # Consider the following `_GenericAlias`, `B`: + # class A(Generic[*Ts]): ... + # B = A[T, *Ts] + # If we then do: + # B[float, int, str] + # The `new_arg` corresponding to `T` will be `float`, and the + # `new_arg` corresponding to `*Ts` will be `(int, str)`. We + # should join all these types together in a flat list + # `(float, int, str)` - so again, we should `extend`. + new_args.extend(new_arg) + elif isinstance(old_arg, tuple): + # Corner case: + # P = ParamSpec('P') + # T = TypeVar('T') + # class Base(Generic[P]): ... + # Can be substituted like this: + # X = Base[[int, T]] + # In this case, `old_arg` will be a tuple: + new_args.append( + tuple(self._make_substitution(old_arg, new_arg_by_param)), + ) + else: + new_args.append(new_arg) + return new_args + + def copy_with(self, args): + return self.__class__(self.__origin__, args, name=self._name, inst=self._inst, + _paramspec_tvars=self._paramspec_tvars) + + def __repr__(self): + if self._name: + name = 'typing.' + self._name + else: + name = _type_repr(self.__origin__) + if self.__args__: + args = ", ".join([_type_repr(a) for a in self.__args__]) + else: + # To ensure the repr is eval-able. + args = "()" + return f'{name}[{args}]' + + def __reduce__(self): + if self._name: + origin = globals()[self._name] + else: + origin = self.__origin__ + args = tuple(self.__args__) + if len(args) == 1 and not isinstance(args[0], tuple): + args, = args + return operator.getitem, (origin, args) + + def __mro_entries__(self, bases): + if isinstance(self.__origin__, _SpecialForm): + raise TypeError(f"Cannot subclass {self!r}") + + if self._name: # generic version of an ABC or built-in class + return super().__mro_entries__(bases) + if self.__origin__ is Generic: + if Protocol in bases: + return () + i = bases.index(self) + for b in bases[i+1:]: + if isinstance(b, _BaseGenericAlias) and b is not self: + return () + return (self.__origin__,) + + def __iter__(self): + yield Unpack[self] + + +# _nparams is the number of accepted parameters, e.g. 0 for Hashable, +# 1 for List and 2 for Dict. It may be -1 if variable number of +# parameters are accepted (needs custom __getitem__). + +class _SpecialGenericAlias(_NotIterable, _BaseGenericAlias, _root=True): + def __init__(self, origin, nparams, *, inst=True, name=None): + if name is None: + name = origin.__name__ + super().__init__(origin, inst=inst, name=name) + self._nparams = nparams + if origin.__module__ == 'builtins': + self.__doc__ = f'A generic version of {origin.__qualname__}.' + else: + self.__doc__ = f'A generic version of {origin.__module__}.{origin.__qualname__}.' + + @_tp_cache + def __getitem__(self, params): + if not isinstance(params, tuple): + params = (params,) + msg = "Parameters to generic types must be types." + params = tuple(_type_check(p, msg) for p in params) + _check_generic(self, params, self._nparams) + return self.copy_with(params) + + def copy_with(self, params): + return _GenericAlias(self.__origin__, params, + name=self._name, inst=self._inst) + + def __repr__(self): + return 'typing.' + self._name + + def __subclasscheck__(self, cls): + if isinstance(cls, _SpecialGenericAlias): + return issubclass(cls.__origin__, self.__origin__) + if not isinstance(cls, _GenericAlias): + return issubclass(cls, self.__origin__) + return super().__subclasscheck__(cls) + + def __reduce__(self): + return self._name + + def __or__(self, right): + return Union[self, right] + + def __ror__(self, left): + return Union[left, self] + +class _CallableGenericAlias(_NotIterable, _GenericAlias, _root=True): + def __repr__(self): + assert self._name == 'Callable' + args = self.__args__ + if len(args) == 2 and _is_param_expr(args[0]): + return super().__repr__() + return (f'typing.Callable' + f'[[{", ".join([_type_repr(a) for a in args[:-1]])}], ' + f'{_type_repr(args[-1])}]') + + def __reduce__(self): + args = self.__args__ + if not (len(args) == 2 and _is_param_expr(args[0])): + args = list(args[:-1]), args[-1] + return operator.getitem, (Callable, args) + + +class _CallableType(_SpecialGenericAlias, _root=True): + def copy_with(self, params): + return _CallableGenericAlias(self.__origin__, params, + name=self._name, inst=self._inst, + _paramspec_tvars=True) + + def __getitem__(self, params): + if not isinstance(params, tuple) or len(params) != 2: + raise TypeError("Callable must be used as " + "Callable[[arg, ...], result].") + args, result = params + # This relaxes what args can be on purpose to allow things like + # PEP 612 ParamSpec. Responsibility for whether a user is using + # Callable[...] properly is deferred to static type checkers. + if isinstance(args, list): + params = (tuple(args), result) + else: + params = (args, result) + return self.__getitem_inner__(params) + + @_tp_cache + def __getitem_inner__(self, params): + args, result = params + msg = "Callable[args, result]: result must be a type." + result = _type_check(result, msg) + if args is Ellipsis: + return self.copy_with((_TypingEllipsis, result)) + if not isinstance(args, tuple): + args = (args,) + args = tuple(_type_convert(arg) for arg in args) + params = args + (result,) + return self.copy_with(params) + + +class _TupleType(_SpecialGenericAlias, _root=True): + @_tp_cache + def __getitem__(self, params): + if not isinstance(params, tuple): + params = (params,) + if len(params) >= 2 and params[-1] is ...: + msg = "Tuple[t, ...]: t must be a type." + params = tuple(_type_check(p, msg) for p in params[:-1]) + return self.copy_with((*params, _TypingEllipsis)) + msg = "Tuple[t0, t1, ...]: each t must be a type." + params = tuple(_type_check(p, msg) for p in params) + return self.copy_with(params) + + +class _UnionGenericAlias(_NotIterable, _GenericAlias, _root=True): + def copy_with(self, params): + return Union[params] + + def __eq__(self, other): + if not isinstance(other, (_UnionGenericAlias, types.UnionType)): + return NotImplemented + try: # fast path + return set(self.__args__) == set(other.__args__) + except TypeError: # not hashable, slow path + return _compare_args_orderless(self.__args__, other.__args__) + + def __hash__(self): + return hash(frozenset(self.__args__)) + + def __repr__(self): + args = self.__args__ + if len(args) == 2: + if args[0] is type(None): + return f'typing.Optional[{_type_repr(args[1])}]' + elif args[1] is type(None): + return f'typing.Optional[{_type_repr(args[0])}]' + return super().__repr__() + + def __instancecheck__(self, obj): + return self.__subclasscheck__(type(obj)) + + def __subclasscheck__(self, cls): + for arg in self.__args__: + if issubclass(cls, arg): + return True + + def __reduce__(self): + func, (origin, args) = super().__reduce__() + return func, (Union, args) + + +def _value_and_type_iter(parameters): + return ((p, type(p)) for p in parameters) + + +class _LiteralGenericAlias(_GenericAlias, _root=True): + def __eq__(self, other): + if not isinstance(other, _LiteralGenericAlias): + return NotImplemented + + return set(_value_and_type_iter(self.__args__)) == set(_value_and_type_iter(other.__args__)) + + def __hash__(self): + return hash(frozenset(_value_and_type_iter(self.__args__))) + + +class _ConcatenateGenericAlias(_GenericAlias, _root=True): + def copy_with(self, params): + if isinstance(params[-1], (list, tuple)): + return (*params[:-1], *params[-1]) + if isinstance(params[-1], _ConcatenateGenericAlias): + params = (*params[:-1], *params[-1].__args__) + return super().copy_with(params) + + +@_SpecialForm +def Unpack(self, parameters): + """Type unpack operator. + + The type unpack operator takes the child types from some container type, + such as `tuple[int, str]` or a `TypeVarTuple`, and 'pulls them out'. + + For example:: + + # For some generic class `Foo`: + Foo[Unpack[tuple[int, str]]] # Equivalent to Foo[int, str] + + Ts = TypeVarTuple('Ts') + # Specifies that `Bar` is generic in an arbitrary number of types. + # (Think of `Ts` as a tuple of an arbitrary number of individual + # `TypeVar`s, which the `Unpack` is 'pulling out' directly into the + # `Generic[]`.) + class Bar(Generic[Unpack[Ts]]): ... + Bar[int] # Valid + Bar[int, str] # Also valid + + From Python 3.11, this can also be done using the `*` operator:: + + Foo[*tuple[int, str]] + class Bar(Generic[*Ts]): ... + + Note that there is only some runtime checking of this operator. Not + everything the runtime allows may be accepted by static type checkers. + + For more information, see PEP 646. + """ + item = _type_check(parameters, f'{self} accepts only single type.') + return _UnpackGenericAlias(origin=self, args=(item,)) + + +class _UnpackGenericAlias(_GenericAlias, _root=True): + def __repr__(self): + # `Unpack` only takes one argument, so __args__ should contain only + # a single item. + return '*' + repr(self.__args__[0]) + + def __getitem__(self, args): + if self.__typing_is_unpacked_typevartuple__: + return args + return super().__getitem__(args) + + @property + def __typing_unpacked_tuple_args__(self): + assert self.__origin__ is Unpack + assert len(self.__args__) == 1 + arg, = self.__args__ + if isinstance(arg, _GenericAlias): + assert arg.__origin__ is tuple + return arg.__args__ + return None + + @property + def __typing_is_unpacked_typevartuple__(self): + assert self.__origin__ is Unpack + assert len(self.__args__) == 1 + return isinstance(self.__args__[0], TypeVarTuple) + + +class Generic: + """Abstract base class for generic types. + + A generic type is typically declared by inheriting from + this class parameterized with one or more type variables. + For example, a generic mapping type might be defined as:: + + class Mapping(Generic[KT, VT]): + def __getitem__(self, key: KT) -> VT: + ... + # Etc. + + This class can then be used as follows:: + + def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT: + try: + return mapping[key] + except KeyError: + return default + """ + __slots__ = () + _is_protocol = False + + @_tp_cache + def __class_getitem__(cls, params): + """Parameterizes a generic class. + + At least, parameterizing a generic class is the *main* thing this method + does. For example, for some generic class `Foo`, this is called when we + do `Foo[int]` - there, with `cls=Foo` and `params=int`. + + However, note that this method is also called when defining generic + classes in the first place with `class Foo(Generic[T]): ...`. + """ + if not isinstance(params, tuple): + params = (params,) + + params = tuple(_type_convert(p) for p in params) + if cls in (Generic, Protocol): + # Generic and Protocol can only be subscripted with unique type variables. + if not params: + raise TypeError( + f"Parameter list to {cls.__qualname__}[...] cannot be empty" + ) + if not all(_is_typevar_like(p) for p in params): + raise TypeError( + f"Parameters to {cls.__name__}[...] must all be type variables " + f"or parameter specification variables.") + if len(set(params)) != len(params): + raise TypeError( + f"Parameters to {cls.__name__}[...] must all be unique") + else: + # Subscripting a regular Generic subclass. + for param in cls.__parameters__: + prepare = getattr(param, '__typing_prepare_subst__', None) + if prepare is not None: + params = prepare(cls, params) + _check_generic(cls, params, len(cls.__parameters__)) + + new_args = [] + for param, new_arg in zip(cls.__parameters__, params): + if isinstance(param, TypeVarTuple): + new_args.extend(new_arg) + else: + new_args.append(new_arg) + params = tuple(new_args) + + return _GenericAlias(cls, params, + _paramspec_tvars=True) + + def __init_subclass__(cls, *args, **kwargs): + super().__init_subclass__(*args, **kwargs) + tvars = [] + if '__orig_bases__' in cls.__dict__: + error = Generic in cls.__orig_bases__ + else: + error = (Generic in cls.__bases__ and + cls.__name__ != 'Protocol' and + type(cls) != _TypedDictMeta) + if error: + raise TypeError("Cannot inherit from plain Generic") + if '__orig_bases__' in cls.__dict__: + tvars = _collect_parameters(cls.__orig_bases__) + # Look for Generic[T1, ..., Tn]. + # If found, tvars must be a subset of it. + # If not found, tvars is it. + # Also check for and reject plain Generic, + # and reject multiple Generic[...]. + gvars = None + for base in cls.__orig_bases__: + if (isinstance(base, _GenericAlias) and + base.__origin__ is Generic): + if gvars is not None: + raise TypeError( + "Cannot inherit from Generic[...] multiple times.") + gvars = base.__parameters__ + if gvars is not None: + tvarset = set(tvars) + gvarset = set(gvars) + if not tvarset <= gvarset: + s_vars = ', '.join(str(t) for t in tvars if t not in gvarset) + s_args = ', '.join(str(g) for g in gvars) + raise TypeError(f"Some type variables ({s_vars}) are" + f" not listed in Generic[{s_args}]") + tvars = gvars + cls.__parameters__ = tuple(tvars) + + +class _TypingEllipsis: + """Internal placeholder for ... (ellipsis).""" + + +_TYPING_INTERNALS = ['__parameters__', '__orig_bases__', '__orig_class__', + '_is_protocol', '_is_runtime_protocol', '__final__'] + +_SPECIAL_NAMES = ['__abstractmethods__', '__annotations__', '__dict__', '__doc__', + '__init__', '__module__', '__new__', '__slots__', + '__subclasshook__', '__weakref__', '__class_getitem__'] + +# These special attributes will be not collected as protocol members. +EXCLUDED_ATTRIBUTES = _TYPING_INTERNALS + _SPECIAL_NAMES + ['_MutableMapping__marker'] + + +def _get_protocol_attrs(cls): + """Collect protocol members from a protocol class objects. + + This includes names actually defined in the class dictionary, as well + as names that appear in annotations. Special names (above) are skipped. + """ + attrs = set() + for base in cls.__mro__[:-1]: # without object + if base.__name__ in ('Protocol', 'Generic'): + continue + annotations = getattr(base, '__annotations__', {}) + for attr in list(base.__dict__.keys()) + list(annotations.keys()): + if not attr.startswith('_abc_') and attr not in EXCLUDED_ATTRIBUTES: + attrs.add(attr) + return attrs + + +def _is_callable_members_only(cls): + # PEP 544 prohibits using issubclass() with protocols that have non-method members. + return all(callable(getattr(cls, attr, None)) for attr in _get_protocol_attrs(cls)) + + +def _no_init_or_replace_init(self, *args, **kwargs): + cls = type(self) + + if cls._is_protocol: + raise TypeError('Protocols cannot be instantiated') + + # Already using a custom `__init__`. No need to calculate correct + # `__init__` to call. This can lead to RecursionError. See bpo-45121. + if cls.__init__ is not _no_init_or_replace_init: + return + + # Initially, `__init__` of a protocol subclass is set to `_no_init_or_replace_init`. + # The first instantiation of the subclass will call `_no_init_or_replace_init` which + # searches for a proper new `__init__` in the MRO. The new `__init__` + # replaces the subclass' old `__init__` (ie `_no_init_or_replace_init`). Subsequent + # instantiation of the protocol subclass will thus use the new + # `__init__` and no longer call `_no_init_or_replace_init`. + for base in cls.__mro__: + init = base.__dict__.get('__init__', _no_init_or_replace_init) + if init is not _no_init_or_replace_init: + cls.__init__ = init + break + else: + # should not happen + cls.__init__ = object.__init__ + + cls.__init__(self, *args, **kwargs) + + +def _caller(depth=1, default='__main__'): + try: + return sys._getframe(depth + 1).f_globals.get('__name__', default) + except (AttributeError, ValueError): # For platforms without _getframe() + return None + + +def _allow_reckless_class_checks(depth=3): + """Allow instance and class checks for special stdlib modules. + + The abc and functools modules indiscriminately call isinstance() and + issubclass() on the whole MRO of a user class, which may contain protocols. + """ + return _caller(depth) in {'abc', 'functools', None} + + +_PROTO_ALLOWLIST = { + 'collections.abc': [ + 'Callable', 'Awaitable', 'Iterable', 'Iterator', 'AsyncIterable', + 'Hashable', 'Sized', 'Container', 'Collection', 'Reversible', + ], + 'contextlib': ['AbstractContextManager', 'AbstractAsyncContextManager'], +} + + +class _ProtocolMeta(ABCMeta): + # This metaclass is really unfortunate and exists only because of + # the lack of __instancehook__. + def __instancecheck__(cls, instance): + # We need this method for situations where attributes are + # assigned in __init__. + if ( + getattr(cls, '_is_protocol', False) and + not getattr(cls, '_is_runtime_protocol', False) and + not _allow_reckless_class_checks(depth=2) + ): + raise TypeError("Instance and class checks can only be used with" + " @runtime_checkable protocols") + + if ((not getattr(cls, '_is_protocol', False) or + _is_callable_members_only(cls)) and + issubclass(instance.__class__, cls)): + return True + if cls._is_protocol: + if all(hasattr(instance, attr) and + # All *methods* can be blocked by setting them to None. + (not callable(getattr(cls, attr, None)) or + getattr(instance, attr) is not None) + for attr in _get_protocol_attrs(cls)): + return True + return super().__instancecheck__(instance) + + +class Protocol(Generic, metaclass=_ProtocolMeta): + """Base class for protocol classes. + + Protocol classes are defined as:: + + class Proto(Protocol): + def meth(self) -> int: + ... + + Such classes are primarily used with static type checkers that recognize + structural subtyping (static duck-typing). + + For example:: + + class C: + def meth(self) -> int: + return 0 + + def func(x: Proto) -> int: + return x.meth() + + func(C()) # Passes static type check + + See PEP 544 for details. Protocol classes decorated with + @typing.runtime_checkable act as simple-minded runtime protocols that check + only the presence of given attributes, ignoring their type signatures. + Protocol classes can be generic, they are defined as:: + + class GenProto(Protocol[T]): + def meth(self) -> T: + ... + """ + + __slots__ = () + _is_protocol = True + _is_runtime_protocol = False + + def __init_subclass__(cls, *args, **kwargs): + super().__init_subclass__(*args, **kwargs) + + # Determine if this is a protocol or a concrete subclass. + if not cls.__dict__.get('_is_protocol', False): + cls._is_protocol = any(b is Protocol for b in cls.__bases__) + + # Set (or override) the protocol subclass hook. + def _proto_hook(other): + if not cls.__dict__.get('_is_protocol', False): + return NotImplemented + + # First, perform various sanity checks. + if not getattr(cls, '_is_runtime_protocol', False): + if _allow_reckless_class_checks(): + return NotImplemented + raise TypeError("Instance and class checks can only be used with" + " @runtime_checkable protocols") + if not _is_callable_members_only(cls): + if _allow_reckless_class_checks(): + return NotImplemented + raise TypeError("Protocols with non-method members" + " don't support issubclass()") + if not isinstance(other, type): + # Same error message as for issubclass(1, int). + raise TypeError('issubclass() arg 1 must be a class') + + # Second, perform the actual structural compatibility check. + for attr in _get_protocol_attrs(cls): + for base in other.__mro__: + # Check if the members appears in the class dictionary... + if attr in base.__dict__: + if base.__dict__[attr] is None: + return NotImplemented + break + + # ...or in annotations, if it is a sub-protocol. + annotations = getattr(base, '__annotations__', {}) + if (isinstance(annotations, collections.abc.Mapping) and + attr in annotations and + issubclass(other, Generic) and other._is_protocol): + break + else: + return NotImplemented + return True + + if '__subclasshook__' not in cls.__dict__: + cls.__subclasshook__ = _proto_hook + + # We have nothing more to do for non-protocols... + if not cls._is_protocol: + return + + # ... otherwise check consistency of bases, and prohibit instantiation. + for base in cls.__bases__: + if not (base in (object, Generic) or + base.__module__ in _PROTO_ALLOWLIST and + base.__name__ in _PROTO_ALLOWLIST[base.__module__] or + issubclass(base, Generic) and base._is_protocol): + raise TypeError('Protocols can only inherit from other' + ' protocols, got %r' % base) + if cls.__init__ is Protocol.__init__: + cls.__init__ = _no_init_or_replace_init + + +class _AnnotatedAlias(_NotIterable, _GenericAlias, _root=True): + """Runtime representation of an annotated type. + + At its core 'Annotated[t, dec1, dec2, ...]' is an alias for the type 't' + with extra annotations. The alias behaves like a normal typing alias. + Instantiating is the same as instantiating the underlying type; binding + it to types is also the same. + + The metadata itself is stored in a '__metadata__' attribute as a tuple. + """ + + def __init__(self, origin, metadata): + if isinstance(origin, _AnnotatedAlias): + metadata = origin.__metadata__ + metadata + origin = origin.__origin__ + super().__init__(origin, origin) + self.__metadata__ = metadata + + def copy_with(self, params): + assert len(params) == 1 + new_type = params[0] + return _AnnotatedAlias(new_type, self.__metadata__) + + def __repr__(self): + return "typing.Annotated[{}, {}]".format( + _type_repr(self.__origin__), + ", ".join(repr(a) for a in self.__metadata__) + ) + + def __reduce__(self): + return operator.getitem, ( + Annotated, (self.__origin__,) + self.__metadata__ + ) + + def __eq__(self, other): + if not isinstance(other, _AnnotatedAlias): + return NotImplemented + return (self.__origin__ == other.__origin__ + and self.__metadata__ == other.__metadata__) + + def __hash__(self): + return hash((self.__origin__, self.__metadata__)) + + def __getattr__(self, attr): + if attr in {'__name__', '__qualname__'}: + return 'Annotated' + return super().__getattr__(attr) + + +class Annotated: + """Add context-specific metadata to a type. + + Example: Annotated[int, runtime_check.Unsigned] indicates to the + hypothetical runtime_check module that this type is an unsigned int. + Every other consumer of this type can ignore this metadata and treat + this type as int. + + The first argument to Annotated must be a valid type. + + Details: + + - It's an error to call `Annotated` with less than two arguments. + - Access the metadata via the ``__metadata__`` attribute:: + + assert Annotated[int, '$'].__metadata__ == ('$',) + + - Nested Annotated types are flattened:: + + assert Annotated[Annotated[T, Ann1, Ann2], Ann3] == Annotated[T, Ann1, Ann2, Ann3] + + - Instantiating an annotated type is equivalent to instantiating the + underlying type:: + + assert Annotated[C, Ann1](5) == C(5) + + - Annotated can be used as a generic type alias:: + + Optimized: TypeAlias = Annotated[T, runtime.Optimize()] + assert Optimized[int] == Annotated[int, runtime.Optimize()] + + OptimizedList: TypeAlias = Annotated[list[T], runtime.Optimize()] + assert OptimizedList[int] == Annotated[list[int], runtime.Optimize()] + + - Annotated cannot be used with an unpacked TypeVarTuple:: + + Variadic: TypeAlias = Annotated[*Ts, Ann1] # NOT valid + + This would be equivalent to:: + + Annotated[T1, T2, T3, ..., Ann1] + + where T1, T2 etc. are TypeVars, which would be invalid, because + only one type should be passed to Annotated. + """ + + __slots__ = () + + def __new__(cls, *args, **kwargs): + raise TypeError("Type Annotated cannot be instantiated.") + + def __class_getitem__(cls, params): + if not isinstance(params, tuple): + params = (params,) + return cls._class_getitem_inner(cls, *params) + + @_tp_cache(typed=True) + def _class_getitem_inner(cls, *params): + if len(params) < 2: + raise TypeError("Annotated[...] should be used " + "with at least two arguments (a type and an " + "annotation).") + if _is_unpacked_typevartuple(params[0]): + raise TypeError("Annotated[...] should not be used with an " + "unpacked TypeVarTuple") + msg = "Annotated[t, ...]: t must be a type." + origin = _type_check(params[0], msg, allow_special_forms=True) + metadata = tuple(params[1:]) + return _AnnotatedAlias(origin, metadata) + + def __init_subclass__(cls, *args, **kwargs): + raise TypeError( + "Cannot subclass {}.Annotated".format(cls.__module__) + ) + + +def runtime_checkable(cls): + """Mark a protocol class as a runtime protocol. + + Such protocol can be used with isinstance() and issubclass(). + Raise TypeError if applied to a non-protocol class. + This allows a simple-minded structural check very similar to + one trick ponies in collections.abc such as Iterable. + + For example:: + + @runtime_checkable + class Closable(Protocol): + def close(self): ... + + assert isinstance(open('/some/file'), Closable) + + Warning: this will check only the presence of the required methods, + not their type signatures! + """ + if not issubclass(cls, Generic) or not cls._is_protocol: + raise TypeError('@runtime_checkable can be only applied to protocol classes,' + ' got %r' % cls) + cls._is_runtime_protocol = True + return cls + + +def cast(typ, val): + """Cast a value to a type. + + This returns the value unchanged. To the type checker this + signals that the return value has the designated type, but at + runtime we intentionally don't check anything (we want this + to be as fast as possible). + """ + return val + + +def assert_type(val, typ, /): + """Ask a static type checker to confirm that the value is of the given type. + + At runtime this does nothing: it returns the first argument unchanged with no + checks or side effects, no matter the actual type of the argument. + + When a static type checker encounters a call to assert_type(), it + emits an error if the value is not of the specified type:: + + def greet(name: str) -> None: + assert_type(name, str) # OK + assert_type(name, int) # type checker error + """ + return val + + +_allowed_types = (types.FunctionType, types.BuiltinFunctionType, + types.MethodType, types.ModuleType, + WrapperDescriptorType, MethodWrapperType, MethodDescriptorType) + + +def get_type_hints(obj, globalns=None, localns=None, include_extras=False): + """Return type hints for an object. + + This is often the same as obj.__annotations__, but it handles + forward references encoded as string literals and recursively replaces all + 'Annotated[T, ...]' with 'T' (unless 'include_extras=True'). + + The argument may be a module, class, method, or function. The annotations + are returned as a dictionary. For classes, annotations include also + inherited members. + + TypeError is raised if the argument is not of a type that can contain + annotations, and an empty dictionary is returned if no annotations are + present. + + BEWARE -- the behavior of globalns and localns is counterintuitive + (unless you are familiar with how eval() and exec() work). The + search order is locals first, then globals. + + - If no dict arguments are passed, an attempt is made to use the + globals from obj (or the respective module's globals for classes), + and these are also used as the locals. If the object does not appear + to have globals, an empty dictionary is used. For classes, the search + order is globals first then locals. + + - If one dict argument is passed, it is used for both globals and + locals. + + - If two dict arguments are passed, they specify globals and + locals, respectively. + """ + if getattr(obj, '__no_type_check__', None): + return {} + # Classes require a special treatment. + if isinstance(obj, type): + hints = {} + for base in reversed(obj.__mro__): + if globalns is None: + base_globals = getattr(sys.modules.get(base.__module__, None), '__dict__', {}) + else: + base_globals = globalns + ann = base.__dict__.get('__annotations__', {}) + if isinstance(ann, types.GetSetDescriptorType): + ann = {} + base_locals = dict(vars(base)) if localns is None else localns + if localns is None and globalns is None: + # This is surprising, but required. Before Python 3.10, + # get_type_hints only evaluated the globalns of + # a class. To maintain backwards compatibility, we reverse + # the globalns and localns order so that eval() looks into + # *base_globals* first rather than *base_locals*. + # This only affects ForwardRefs. + base_globals, base_locals = base_locals, base_globals + for name, value in ann.items(): + if value is None: + value = type(None) + if isinstance(value, str): + value = ForwardRef(value, is_argument=False, is_class=True) + value = _eval_type(value, base_globals, base_locals) + hints[name] = value + return hints if include_extras else {k: _strip_annotations(t) for k, t in hints.items()} + + if globalns is None: + if isinstance(obj, types.ModuleType): + globalns = obj.__dict__ + else: + nsobj = obj + # Find globalns for the unwrapped object. + while hasattr(nsobj, '__wrapped__'): + nsobj = nsobj.__wrapped__ + globalns = getattr(nsobj, '__globals__', {}) + if localns is None: + localns = globalns + elif localns is None: + localns = globalns + hints = getattr(obj, '__annotations__', None) + if hints is None: + # Return empty annotations for something that _could_ have them. + if isinstance(obj, _allowed_types): + return {} + else: + raise TypeError('{!r} is not a module, class, method, ' + 'or function.'.format(obj)) + hints = dict(hints) + for name, value in hints.items(): + if value is None: + value = type(None) + if isinstance(value, str): + # class-level forward refs were handled above, this must be either + # a module-level annotation or a function argument annotation + value = ForwardRef( + value, + is_argument=not isinstance(obj, types.ModuleType), + is_class=False, + ) + hints[name] = _eval_type(value, globalns, localns) + return hints if include_extras else {k: _strip_annotations(t) for k, t in hints.items()} + + +def _strip_annotations(t): + """Strip the annotations from a given type.""" + if isinstance(t, _AnnotatedAlias): + return _strip_annotations(t.__origin__) + if hasattr(t, "__origin__") and t.__origin__ in (Required, NotRequired): + return _strip_annotations(t.__args__[0]) + if isinstance(t, _GenericAlias): + stripped_args = tuple(_strip_annotations(a) for a in t.__args__) + if stripped_args == t.__args__: + return t + return t.copy_with(stripped_args) + if isinstance(t, GenericAlias): + stripped_args = tuple(_strip_annotations(a) for a in t.__args__) + if stripped_args == t.__args__: + return t + return GenericAlias(t.__origin__, stripped_args) + if isinstance(t, types.UnionType): + stripped_args = tuple(_strip_annotations(a) for a in t.__args__) + if stripped_args == t.__args__: + return t + return functools.reduce(operator.or_, stripped_args) + + return t + + +def get_origin(tp): + """Get the unsubscripted version of a type. + + This supports generic types, Callable, Tuple, Union, Literal, Final, ClassVar, + Annotated, and others. Return None for unsupported types. + + Examples:: + + >>> P = ParamSpec('P') + >>> assert get_origin(Literal[42]) is Literal + >>> assert get_origin(int) is None + >>> assert get_origin(ClassVar[int]) is ClassVar + >>> assert get_origin(Generic) is Generic + >>> assert get_origin(Generic[T]) is Generic + >>> assert get_origin(Union[T, int]) is Union + >>> assert get_origin(List[Tuple[T, T]][int]) is list + >>> assert get_origin(P.args) is P + """ + if isinstance(tp, _AnnotatedAlias): + return Annotated + if isinstance(tp, (_BaseGenericAlias, GenericAlias, + ParamSpecArgs, ParamSpecKwargs)): + return tp.__origin__ + if tp is Generic: + return Generic + if isinstance(tp, types.UnionType): + return types.UnionType + return None + + +def get_args(tp): + """Get type arguments with all substitutions performed. + + For unions, basic simplifications used by Union constructor are performed. + + Examples:: + + >>> T = TypeVar('T') + >>> assert get_args(Dict[str, int]) == (str, int) + >>> assert get_args(int) == () + >>> assert get_args(Union[int, Union[T, int], str][int]) == (int, str) + >>> assert get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int]) + >>> assert get_args(Callable[[], T][int]) == ([], int) + """ + if isinstance(tp, _AnnotatedAlias): + return (tp.__origin__,) + tp.__metadata__ + if isinstance(tp, (_GenericAlias, GenericAlias)): + res = tp.__args__ + if _should_unflatten_callable_args(tp, res): + res = (list(res[:-1]), res[-1]) + return res + if isinstance(tp, types.UnionType): + return tp.__args__ + return () + + +def is_typeddict(tp): + """Check if an annotation is a TypedDict class. + + For example:: + + >>> from typing import TypedDict + >>> class Film(TypedDict): + ... title: str + ... year: int + ... + >>> is_typeddict(Film) + True + >>> is_typeddict(dict) + False + """ + return isinstance(tp, _TypedDictMeta) + + +_ASSERT_NEVER_REPR_MAX_LENGTH = 100 + + +def assert_never(arg: Never, /) -> Never: + """Statically assert that a line of code is unreachable. + + Example:: + + def int_or_str(arg: int | str) -> None: + match arg: + case int(): + print("It's an int") + case str(): + print("It's a str") + case _: + assert_never(arg) + + If a type checker finds that a call to assert_never() is + reachable, it will emit an error. + + At runtime, this throws an exception when called. + """ + value = repr(arg) + if len(value) > _ASSERT_NEVER_REPR_MAX_LENGTH: + value = value[:_ASSERT_NEVER_REPR_MAX_LENGTH] + '...' + raise AssertionError(f"Expected code to be unreachable, but got: {value}") + + +def no_type_check(arg): + """Decorator to indicate that annotations are not type hints. + + The argument must be a class or function; if it is a class, it + applies recursively to all methods and classes defined in that class + (but not to methods defined in its superclasses or subclasses). + + This mutates the function(s) or class(es) in place. + """ + if isinstance(arg, type): + for key in dir(arg): + obj = getattr(arg, key) + if ( + not hasattr(obj, '__qualname__') + or obj.__qualname__ != f'{arg.__qualname__}.{obj.__name__}' + or getattr(obj, '__module__', None) != arg.__module__ + ): + # We only modify objects that are defined in this type directly. + # If classes / methods are nested in multiple layers, + # we will modify them when processing their direct holders. + continue + # Instance, class, and static methods: + if isinstance(obj, types.FunctionType): + obj.__no_type_check__ = True + if isinstance(obj, types.MethodType): + obj.__func__.__no_type_check__ = True + # Nested types: + if isinstance(obj, type): + no_type_check(obj) + try: + arg.__no_type_check__ = True + except TypeError: # built-in classes + pass + return arg + + +def no_type_check_decorator(decorator): + """Decorator to give another decorator the @no_type_check effect. + + This wraps the decorator with something that wraps the decorated + function in @no_type_check. + """ + @functools.wraps(decorator) + def wrapped_decorator(*args, **kwds): + func = decorator(*args, **kwds) + func = no_type_check(func) + return func + + return wrapped_decorator + + +def _overload_dummy(*args, **kwds): + """Helper for @overload to raise when called.""" + raise NotImplementedError( + "You should not call an overloaded function. " + "A series of @overload-decorated functions " + "outside a stub module should always be followed " + "by an implementation that is not @overload-ed.") + + +# {module: {qualname: {firstlineno: func}}} +_overload_registry = defaultdict(functools.partial(defaultdict, dict)) + + +def overload(func): + """Decorator for overloaded functions/methods. + + In a stub file, place two or more stub definitions for the same + function in a row, each decorated with @overload. + + For example:: + + @overload + def utf8(value: None) -> None: ... + @overload + def utf8(value: bytes) -> bytes: ... + @overload + def utf8(value: str) -> bytes: ... + + In a non-stub file (i.e. a regular .py file), do the same but + follow it with an implementation. The implementation should *not* + be decorated with @overload:: + + @overload + def utf8(value: None) -> None: ... + @overload + def utf8(value: bytes) -> bytes: ... + @overload + def utf8(value: str) -> bytes: ... + def utf8(value): + ... # implementation goes here + + The overloads for a function can be retrieved at runtime using the + get_overloads() function. + """ + # classmethod and staticmethod + f = getattr(func, "__func__", func) + try: + _overload_registry[f.__module__][f.__qualname__][f.__code__.co_firstlineno] = func + except AttributeError: + # Not a normal function; ignore. + pass + return _overload_dummy + + +def get_overloads(func): + """Return all defined overloads for *func* as a sequence.""" + # classmethod and staticmethod + f = getattr(func, "__func__", func) + if f.__module__ not in _overload_registry: + return [] + mod_dict = _overload_registry[f.__module__] + if f.__qualname__ not in mod_dict: + return [] + return list(mod_dict[f.__qualname__].values()) + + +def clear_overloads(): + """Clear all overloads in the registry.""" + _overload_registry.clear() + + +def final(f): + """Decorator to indicate final methods and final classes. + + Use this decorator to indicate to type checkers that the decorated + method cannot be overridden, and decorated class cannot be subclassed. + + For example:: + + class Base: + @final + def done(self) -> None: + ... + class Sub(Base): + def done(self) -> None: # Error reported by type checker + ... + + @final + class Leaf: + ... + class Other(Leaf): # Error reported by type checker + ... + + There is no runtime checking of these properties. The decorator + attempts to set the ``__final__`` attribute to ``True`` on the decorated + object to allow runtime introspection. + """ + try: + f.__final__ = True + except (AttributeError, TypeError): + # Skip the attribute silently if it is not writable. + # AttributeError happens if the object has __slots__ or a + # read-only property, TypeError if it's a builtin class. + pass + return f + + +# Some unconstrained type variables. These are used by the container types. +# (These are not for export.) +T = TypeVar('T') # Any type. +KT = TypeVar('KT') # Key type. +VT = TypeVar('VT') # Value type. +T_co = TypeVar('T_co', covariant=True) # Any type covariant containers. +V_co = TypeVar('V_co', covariant=True) # Any type covariant containers. +VT_co = TypeVar('VT_co', covariant=True) # Value type covariant containers. +T_contra = TypeVar('T_contra', contravariant=True) # Ditto contravariant. +# Internal type variable used for Type[]. +CT_co = TypeVar('CT_co', covariant=True, bound=type) + +# A useful type variable with constraints. This represents string types. +# (This one *is* for export!) +AnyStr = TypeVar('AnyStr', bytes, str) + + +# Various ABCs mimicking those in collections.abc. +_alias = _SpecialGenericAlias + +Hashable = _alias(collections.abc.Hashable, 0) # Not generic. +Awaitable = _alias(collections.abc.Awaitable, 1) +Coroutine = _alias(collections.abc.Coroutine, 3) +AsyncIterable = _alias(collections.abc.AsyncIterable, 1) +AsyncIterator = _alias(collections.abc.AsyncIterator, 1) +Iterable = _alias(collections.abc.Iterable, 1) +Iterator = _alias(collections.abc.Iterator, 1) +Reversible = _alias(collections.abc.Reversible, 1) +Sized = _alias(collections.abc.Sized, 0) # Not generic. +Container = _alias(collections.abc.Container, 1) +Collection = _alias(collections.abc.Collection, 1) +Callable = _CallableType(collections.abc.Callable, 2) +Callable.__doc__ = \ + """Deprecated alias to collections.abc.Callable. + + Callable[[int], str] signifies a function that takes a single + parameter of type int and returns a str. + + The subscription syntax must always be used with exactly two + values: the argument list and the return type. + The argument list must be a list of types, a ParamSpec, + Concatenate or ellipsis. The return type must be a single type. + + There is no syntax to indicate optional or keyword arguments; + such function types are rarely used as callback types. + """ +AbstractSet = _alias(collections.abc.Set, 1, name='AbstractSet') +MutableSet = _alias(collections.abc.MutableSet, 1) +# NOTE: Mapping is only covariant in the value type. +Mapping = _alias(collections.abc.Mapping, 2) +MutableMapping = _alias(collections.abc.MutableMapping, 2) +Sequence = _alias(collections.abc.Sequence, 1) +MutableSequence = _alias(collections.abc.MutableSequence, 1) +ByteString = _alias(collections.abc.ByteString, 0) # Not generic +# Tuple accepts variable number of parameters. +Tuple = _TupleType(tuple, -1, inst=False, name='Tuple') +Tuple.__doc__ = \ + """Deprecated alias to builtins.tuple. + + Tuple[X, Y] is the cross-product type of X and Y. + + Example: Tuple[T1, T2] is a tuple of two elements corresponding + to type variables T1 and T2. Tuple[int, float, str] is a tuple + of an int, a float and a string. + + To specify a variable-length tuple of homogeneous type, use Tuple[T, ...]. + """ +List = _alias(list, 1, inst=False, name='List') +Deque = _alias(collections.deque, 1, name='Deque') +Set = _alias(set, 1, inst=False, name='Set') +FrozenSet = _alias(frozenset, 1, inst=False, name='FrozenSet') +MappingView = _alias(collections.abc.MappingView, 1) +KeysView = _alias(collections.abc.KeysView, 1) +ItemsView = _alias(collections.abc.ItemsView, 2) +ValuesView = _alias(collections.abc.ValuesView, 1) +ContextManager = _alias(contextlib.AbstractContextManager, 1, name='ContextManager') +AsyncContextManager = _alias(contextlib.AbstractAsyncContextManager, 1, name='AsyncContextManager') +Dict = _alias(dict, 2, inst=False, name='Dict') +DefaultDict = _alias(collections.defaultdict, 2, name='DefaultDict') +OrderedDict = _alias(collections.OrderedDict, 2) +Counter = _alias(collections.Counter, 1) +ChainMap = _alias(collections.ChainMap, 2) +Generator = _alias(collections.abc.Generator, 3) +AsyncGenerator = _alias(collections.abc.AsyncGenerator, 2) +Type = _alias(type, 1, inst=False, name='Type') +Type.__doc__ = \ + """Deprecated alias to builtins.type. + + builtins.type or typing.Type can be used to annotate class objects. + For example, suppose we have the following classes:: + + class User: ... # Abstract base for User classes + class BasicUser(User): ... + class ProUser(User): ... + class TeamUser(User): ... + + And a function that takes a class argument that's a subclass of + User and returns an instance of the corresponding class:: + + U = TypeVar('U', bound=User) + def new_user(user_class: Type[U]) -> U: + user = user_class() + # (Here we could write the user object to a database) + return user + + joe = new_user(BasicUser) + + At this point the type checker knows that joe has type BasicUser. + """ + + +@runtime_checkable +class SupportsInt(Protocol): + """An ABC with one abstract method __int__.""" + + __slots__ = () + + @abstractmethod + def __int__(self) -> int: + pass + + +@runtime_checkable +class SupportsFloat(Protocol): + """An ABC with one abstract method __float__.""" + + __slots__ = () + + @abstractmethod + def __float__(self) -> float: + pass + + +@runtime_checkable +class SupportsComplex(Protocol): + """An ABC with one abstract method __complex__.""" + + __slots__ = () + + @abstractmethod + def __complex__(self) -> complex: + pass + + +@runtime_checkable +class SupportsBytes(Protocol): + """An ABC with one abstract method __bytes__.""" + + __slots__ = () + + @abstractmethod + def __bytes__(self) -> bytes: + pass + + +@runtime_checkable +class SupportsIndex(Protocol): + """An ABC with one abstract method __index__.""" + + __slots__ = () + + @abstractmethod + def __index__(self) -> int: + pass + + +@runtime_checkable +class SupportsAbs(Protocol[T_co]): + """An ABC with one abstract method __abs__ that is covariant in its return type.""" + + __slots__ = () + + @abstractmethod + def __abs__(self) -> T_co: + pass + + +@runtime_checkable +class SupportsRound(Protocol[T_co]): + """An ABC with one abstract method __round__ that is covariant in its return type.""" + + __slots__ = () + + @abstractmethod + def __round__(self, ndigits: int = 0) -> T_co: + pass + + +def _make_nmtuple(name, types, module, defaults = ()): + fields = [n for n, t in types] + types = {n: _type_check(t, f"field {n} annotation must be a type") + for n, t in types} + nm_tpl = collections.namedtuple(name, fields, + defaults=defaults, module=module) + nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = types + return nm_tpl + + +# attributes prohibited to set in NamedTuple class syntax +_prohibited = frozenset({'__new__', '__init__', '__slots__', '__getnewargs__', + '_fields', '_field_defaults', + '_make', '_replace', '_asdict', '_source'}) + +_special = frozenset({'__module__', '__name__', '__annotations__'}) + + +class NamedTupleMeta(type): + def __new__(cls, typename, bases, ns): + assert _NamedTuple in bases + for base in bases: + if base is not _NamedTuple and base is not Generic: + raise TypeError( + 'can only inherit from a NamedTuple type and Generic') + bases = tuple(tuple if base is _NamedTuple else base for base in bases) + types = ns.get('__annotations__', {}) + default_names = [] + for field_name in types: + if field_name in ns: + default_names.append(field_name) + elif default_names: + raise TypeError(f"Non-default namedtuple field {field_name} " + f"cannot follow default field" + f"{'s' if len(default_names) > 1 else ''} " + f"{', '.join(default_names)}") + nm_tpl = _make_nmtuple(typename, types.items(), + defaults=[ns[n] for n in default_names], + module=ns['__module__']) + nm_tpl.__bases__ = bases + if Generic in bases: + class_getitem = Generic.__class_getitem__.__func__ + nm_tpl.__class_getitem__ = classmethod(class_getitem) + # update from user namespace without overriding special namedtuple attributes + for key in ns: + if key in _prohibited: + raise AttributeError("Cannot overwrite NamedTuple attribute " + key) + elif key not in _special and key not in nm_tpl._fields: + setattr(nm_tpl, key, ns[key]) + if Generic in bases: + nm_tpl.__init_subclass__() + return nm_tpl + + +def NamedTuple(typename, fields=None, /, **kwargs): + """Typed version of namedtuple. + + Usage:: + + class Employee(NamedTuple): + name: str + id: int + + This is equivalent to:: + + Employee = collections.namedtuple('Employee', ['name', 'id']) + + The resulting class has an extra __annotations__ attribute, giving a + dict that maps field names to types. (The field names are also in + the _fields attribute, which is part of the namedtuple API.) + An alternative equivalent functional syntax is also accepted:: + + Employee = NamedTuple('Employee', [('name', str), ('id', int)]) + """ + if fields is None: + fields = kwargs.items() + elif kwargs: + raise TypeError("Either list of fields or keywords" + " can be provided to NamedTuple, not both") + return _make_nmtuple(typename, fields, module=_caller()) + +_NamedTuple = type.__new__(NamedTupleMeta, 'NamedTuple', (), {}) + +def _namedtuple_mro_entries(bases): + assert NamedTuple in bases + return (_NamedTuple,) + +NamedTuple.__mro_entries__ = _namedtuple_mro_entries + + +class _TypedDictMeta(type): + def __new__(cls, name, bases, ns, total=True): + """Create a new typed dict class object. + + This method is called when TypedDict is subclassed, + or when TypedDict is instantiated. This way + TypedDict supports all three syntax forms described in its docstring. + Subclasses and instances of TypedDict return actual dictionaries. + """ + for base in bases: + if type(base) is not _TypedDictMeta and base is not Generic: + raise TypeError('cannot inherit from both a TypedDict type ' + 'and a non-TypedDict base class') + + if any(issubclass(b, Generic) for b in bases): + generic_base = (Generic,) + else: + generic_base = () + + tp_dict = type.__new__(_TypedDictMeta, name, (*generic_base, dict), ns) + + annotations = {} + own_annotations = ns.get('__annotations__', {}) + msg = "TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type" + own_annotations = { + n: _type_check(tp, msg, module=tp_dict.__module__) + for n, tp in own_annotations.items() + } + required_keys = set() + optional_keys = set() + + for base in bases: + annotations.update(base.__dict__.get('__annotations__', {})) + + base_required = base.__dict__.get('__required_keys__', set()) + required_keys |= base_required + optional_keys -= base_required + + base_optional = base.__dict__.get('__optional_keys__', set()) + required_keys -= base_optional + optional_keys |= base_optional + + annotations.update(own_annotations) + for annotation_key, annotation_type in own_annotations.items(): + annotation_origin = get_origin(annotation_type) + if annotation_origin is Annotated: + annotation_args = get_args(annotation_type) + if annotation_args: + annotation_type = annotation_args[0] + annotation_origin = get_origin(annotation_type) + + if annotation_origin is Required: + is_required = True + elif annotation_origin is NotRequired: + is_required = False + else: + is_required = total + + if is_required: + required_keys.add(annotation_key) + optional_keys.discard(annotation_key) + else: + optional_keys.add(annotation_key) + required_keys.discard(annotation_key) + + assert required_keys.isdisjoint(optional_keys), ( + f"Required keys overlap with optional keys in {name}:" + f" {required_keys=}, {optional_keys=}" + ) + tp_dict.__annotations__ = annotations + tp_dict.__required_keys__ = frozenset(required_keys) + tp_dict.__optional_keys__ = frozenset(optional_keys) + if not hasattr(tp_dict, '__total__'): + tp_dict.__total__ = total + return tp_dict + + __call__ = dict # static method + + def __subclasscheck__(cls, other): + # Typed dicts are only for static structural subtyping. + raise TypeError('TypedDict does not support instance and class checks') + + __instancecheck__ = __subclasscheck__ + + +def TypedDict(typename, fields=None, /, *, total=True, **kwargs): + """A simple typed namespace. At runtime it is equivalent to a plain dict. + + TypedDict creates a dictionary type such that a type checker will expect all + instances to have a certain set of keys, where each key is + associated with a value of a consistent type. This expectation + is not checked at runtime. + + Usage:: + + >>> class Point2D(TypedDict): + ... x: int + ... y: int + ... label: str + ... + >>> a: Point2D = {'x': 1, 'y': 2, 'label': 'good'} # OK + >>> b: Point2D = {'z': 3, 'label': 'bad'} # Fails type check + >>> Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first') + True + + The type info can be accessed via the Point2D.__annotations__ dict, and + the Point2D.__required_keys__ and Point2D.__optional_keys__ frozensets. + TypedDict supports an additional equivalent form:: + + Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str}) + + By default, all keys must be present in a TypedDict. It is possible + to override this by specifying totality:: + + class Point2D(TypedDict, total=False): + x: int + y: int + + This means that a Point2D TypedDict can have any of the keys omitted. A type + checker is only expected to support a literal False or True as the value of + the total argument. True is the default, and makes all items defined in the + class body be required. + + The Required and NotRequired special forms can also be used to mark + individual keys as being required or not required:: + + class Point2D(TypedDict): + x: int # the "x" key must always be present (Required is the default) + y: NotRequired[int] # the "y" key can be omitted + + See PEP 655 for more details on Required and NotRequired. + """ + if fields is None: + fields = kwargs + elif kwargs: + raise TypeError("TypedDict takes either a dict or keyword arguments," + " but not both") + if kwargs: + warnings.warn( + "The kwargs-based syntax for TypedDict definitions is deprecated " + "in Python 3.11, will be removed in Python 3.13, and may not be " + "understood by third-party type checkers.", + DeprecationWarning, + stacklevel=2, + ) + + ns = {'__annotations__': dict(fields)} + module = _caller() + if module is not None: + # Setting correct module is necessary to make typed dict classes pickleable. + ns['__module__'] = module + + return _TypedDictMeta(typename, (), ns, total=total) + +_TypedDict = type.__new__(_TypedDictMeta, 'TypedDict', (), {}) +TypedDict.__mro_entries__ = lambda bases: (_TypedDict,) + + +@_SpecialForm +def Required(self, parameters): + """Special typing construct to mark a TypedDict key as required. + + This is mainly useful for total=False TypedDicts. + + For example:: + + class Movie(TypedDict, total=False): + title: Required[str] + year: int + + m = Movie( + title='The Matrix', # typechecker error if key is omitted + year=1999, + ) + + There is no runtime checking that a required key is actually provided + when instantiating a related TypedDict. + """ + item = _type_check(parameters, f'{self._name} accepts only a single type.') + return _GenericAlias(self, (item,)) + + +@_SpecialForm +def NotRequired(self, parameters): + """Special typing construct to mark a TypedDict key as potentially missing. + + For example:: + + class Movie(TypedDict): + title: str + year: NotRequired[int] + + m = Movie( + title='The Matrix', # typechecker error if key is omitted + year=1999, + ) + """ + item = _type_check(parameters, f'{self._name} accepts only a single type.') + return _GenericAlias(self, (item,)) + + +class NewType: + """NewType creates simple unique types with almost zero runtime overhead. + + NewType(name, tp) is considered a subtype of tp + by static type checkers. At runtime, NewType(name, tp) returns + a dummy callable that simply returns its argument. + + Usage:: + + UserId = NewType('UserId', int) + + def name_by_id(user_id: UserId) -> str: + ... + + UserId('user') # Fails type check + + name_by_id(42) # Fails type check + name_by_id(UserId(42)) # OK + + num = UserId(5) + 1 # type: int + """ + + __call__ = _idfunc + + def __init__(self, name, tp): + self.__qualname__ = name + if '.' in name: + name = name.rpartition('.')[-1] + self.__name__ = name + self.__supertype__ = tp + def_mod = _caller() + if def_mod != 'typing': + self.__module__ = def_mod + + def __mro_entries__(self, bases): + # We defined __mro_entries__ to get a better error message + # if a user attempts to subclass a NewType instance. bpo-46170 + superclass_name = self.__name__ + + class Dummy: + def __init_subclass__(cls): + subclass_name = cls.__name__ + raise TypeError( + f"Cannot subclass an instance of NewType. Perhaps you were looking for: " + f"`{subclass_name} = NewType({subclass_name!r}, {superclass_name})`" + ) + + return (Dummy,) + + def __repr__(self): + return f'{self.__module__}.{self.__qualname__}' + + def __reduce__(self): + return self.__qualname__ + + def __or__(self, other): + return Union[self, other] + + def __ror__(self, other): + return Union[other, self] + + +# Python-version-specific alias (Python 2: unicode; Python 3: str) +Text = str + + +# Constant that's True when type checking, but False here. +TYPE_CHECKING = False + + +class IO(Generic[AnyStr]): + """Generic base class for TextIO and BinaryIO. + + This is an abstract, generic version of the return of open(). + + NOTE: This does not distinguish between the different possible + classes (text vs. binary, read vs. write vs. read/write, + append-only, unbuffered). The TextIO and BinaryIO subclasses + below capture the distinctions between text vs. binary, which is + pervasive in the interface; however we currently do not offer a + way to track the other distinctions in the type system. + """ + + __slots__ = () + + @property + @abstractmethod + def mode(self) -> str: + pass + + @property + @abstractmethod + def name(self) -> str: + pass + + @abstractmethod + def close(self) -> None: + pass + + @property + @abstractmethod + def closed(self) -> bool: + pass + + @abstractmethod + def fileno(self) -> int: + pass + + @abstractmethod + def flush(self) -> None: + pass + + @abstractmethod + def isatty(self) -> bool: + pass + + @abstractmethod + def read(self, n: int = -1) -> AnyStr: + pass + + @abstractmethod + def readable(self) -> bool: + pass + + @abstractmethod + def readline(self, limit: int = -1) -> AnyStr: + pass + + @abstractmethod + def readlines(self, hint: int = -1) -> List[AnyStr]: + pass + + @abstractmethod + def seek(self, offset: int, whence: int = 0) -> int: + pass + + @abstractmethod + def seekable(self) -> bool: + pass + + @abstractmethod + def tell(self) -> int: + pass + + @abstractmethod + def truncate(self, size: int = None) -> int: + pass + + @abstractmethod + def writable(self) -> bool: + pass + + @abstractmethod + def write(self, s: AnyStr) -> int: + pass + + @abstractmethod + def writelines(self, lines: List[AnyStr]) -> None: + pass + + @abstractmethod + def __enter__(self) -> 'IO[AnyStr]': + pass + + @abstractmethod + def __exit__(self, type, value, traceback) -> None: + pass + + +class BinaryIO(IO[bytes]): + """Typed version of the return of open() in binary mode.""" + + __slots__ = () + + @abstractmethod + def write(self, s: Union[bytes, bytearray]) -> int: + pass + + @abstractmethod + def __enter__(self) -> 'BinaryIO': + pass + + +class TextIO(IO[str]): + """Typed version of the return of open() in text mode.""" + + __slots__ = () + + @property + @abstractmethod + def buffer(self) -> BinaryIO: + pass + + @property + @abstractmethod + def encoding(self) -> str: + pass + + @property + @abstractmethod + def errors(self) -> Optional[str]: + pass + + @property + @abstractmethod + def line_buffering(self) -> bool: + pass + + @property + @abstractmethod + def newlines(self) -> Any: + pass + + @abstractmethod + def __enter__(self) -> 'TextIO': + pass + + +class _DeprecatedType(type): + def __getattribute__(cls, name): + if name not in {"__dict__", "__module__", "__doc__"} and name in cls.__dict__: + warnings.warn( + f"{cls.__name__} is deprecated, import directly " + f"from typing instead. {cls.__name__} will be removed " + "in Python 3.12.", + DeprecationWarning, + stacklevel=2, + ) + return super().__getattribute__(name) + + +class io(metaclass=_DeprecatedType): + """Wrapper namespace for IO generic classes.""" + + __all__ = ['IO', 'TextIO', 'BinaryIO'] + IO = IO + TextIO = TextIO + BinaryIO = BinaryIO + + +io.__name__ = __name__ + '.io' +sys.modules[io.__name__] = io + +Pattern = _alias(stdlib_re.Pattern, 1) +Match = _alias(stdlib_re.Match, 1) + +class re(metaclass=_DeprecatedType): + """Wrapper namespace for re type aliases.""" + + __all__ = ['Pattern', 'Match'] + Pattern = Pattern + Match = Match + + +re.__name__ = __name__ + '.re' +sys.modules[re.__name__] = re + + +def reveal_type(obj: T, /) -> T: + """Ask a static type checker to reveal the inferred type of an expression. + + When a static type checker encounters a call to ``reveal_type()``, + it will emit the inferred type of the argument:: + + x: int = 1 + reveal_type(x) + + Running a static type checker (e.g., mypy) on this example + will produce output similar to 'Revealed type is "builtins.int"'. + + At runtime, the function prints the runtime type of the + argument and returns the argument unchanged. + """ + print(f"Runtime type is {type(obj).__name__!r}", file=sys.stderr) + return obj + + +def dataclass_transform( + *, + eq_default: bool = True, + order_default: bool = False, + kw_only_default: bool = False, + field_specifiers: tuple[type[Any] | Callable[..., Any], ...] = (), + **kwargs: Any, +) -> Callable[[T], T]: + """Decorator to mark an object as providing dataclass-like behaviour. + + The decorator can be applied to a function, class, or metaclass. + + Example usage with a decorator function:: + + T = TypeVar("T") + + @dataclass_transform() + def create_model(cls: type[T]) -> type[T]: + ... + return cls + + @create_model + class CustomerModel: + id: int + name: str + + On a base class:: + + @dataclass_transform() + class ModelBase: ... + + class CustomerModel(ModelBase): + id: int + name: str + + On a metaclass:: + + @dataclass_transform() + class ModelMeta(type): ... + + class ModelBase(metaclass=ModelMeta): ... + + class CustomerModel(ModelBase): + id: int + name: str + + The ``CustomerModel`` classes defined above will + be treated by type checkers similarly to classes created with + ``@dataclasses.dataclass``. + For example, type checkers will assume these classes have + ``__init__`` methods that accept ``id`` and ``name``. + + The arguments to this decorator can be used to customize this behavior: + - ``eq_default`` indicates whether the ``eq`` parameter is assumed to be + ``True`` or ``False`` if it is omitted by the caller. + - ``order_default`` indicates whether the ``order`` parameter is + assumed to be True or False if it is omitted by the caller. + - ``kw_only_default`` indicates whether the ``kw_only`` parameter is + assumed to be True or False if it is omitted by the caller. + - ``field_specifiers`` specifies a static list of supported classes + or functions that describe fields, similar to ``dataclasses.field()``. + - Arbitrary other keyword arguments are accepted in order to allow for + possible future extensions. + + At runtime, this decorator records its arguments in the + ``__dataclass_transform__`` attribute on the decorated object. + It has no other runtime effect. + + See PEP 681 for more details. + """ + def decorator(cls_or_fn): + cls_or_fn.__dataclass_transform__ = { + "eq_default": eq_default, + "order_default": order_default, + "kw_only_default": kw_only_default, + "field_specifiers": field_specifiers, + "kwargs": kwargs, + } + return cls_or_fn + return decorator diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..005d23f6d00ecbfc766d523f24121ebaf07a9271 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__init__.py @@ -0,0 +1,98 @@ +""" +Python unit testing framework, based on Erich Gamma's JUnit and Kent Beck's +Smalltalk testing framework (used with permission). + +This module contains the core framework classes that form the basis of +specific test cases and suites (TestCase, TestSuite etc.), and also a +text-based utility class for running the tests and reporting the results + (TextTestRunner). + +Simple usage: + + import unittest + + class IntegerArithmeticTestCase(unittest.TestCase): + def testAdd(self): # test method names begin with 'test' + self.assertEqual((1 + 2), 3) + self.assertEqual(0 + 1, 1) + def testMultiply(self): + self.assertEqual((0 * 10), 0) + self.assertEqual((5 * 8), 40) + + if __name__ == '__main__': + unittest.main() + +Further information is available in the bundled documentation, and from + + http://docs.python.org/library/unittest.html + +Copyright (c) 1999-2003 Steve Purcell +Copyright (c) 2003-2010 Python Software Foundation +This module is free software, and you may redistribute it and/or modify +it under the same terms as Python itself, so long as this copyright message +and disclaimer are retained in their original form. + +IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, +SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF +THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGE. + +THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, +AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE, +SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. +""" + +__all__ = ['TestResult', 'TestCase', 'IsolatedAsyncioTestCase', 'TestSuite', + 'TextTestRunner', 'TestLoader', 'FunctionTestCase', 'main', + 'defaultTestLoader', 'SkipTest', 'skip', 'skipIf', 'skipUnless', + 'expectedFailure', 'TextTestResult', 'installHandler', + 'registerResult', 'removeResult', 'removeHandler', + 'addModuleCleanup', 'doModuleCleanups', 'enterModuleContext'] + +# Expose obsolete functions for backwards compatibility +# bpo-5846: Deprecated in Python 3.11, scheduled for removal in Python 3.13. +__all__.extend(['getTestCaseNames', 'makeSuite', 'findTestCases']) + +__unittest = True + +from .result import TestResult +from .case import (addModuleCleanup, TestCase, FunctionTestCase, SkipTest, skip, + skipIf, skipUnless, expectedFailure, doModuleCleanups, + enterModuleContext) +from .suite import BaseTestSuite, TestSuite +from .loader import TestLoader, defaultTestLoader +from .main import TestProgram, main +from .runner import TextTestRunner, TextTestResult +from .signals import installHandler, registerResult, removeResult, removeHandler +# IsolatedAsyncioTestCase will be imported lazily. +from .loader import makeSuite, getTestCaseNames, findTestCases + +# deprecated +_TextTestResult = TextTestResult + + +# There are no tests here, so don't try to run anything discovered from +# introspecting the symbols (e.g. FunctionTestCase). Instead, all our +# tests come from within unittest.test. +def load_tests(loader, tests, pattern): + import os.path + # top level directory cached on loader instance + this_dir = os.path.dirname(__file__) + return loader.discover(start_dir=this_dir, pattern=pattern) + + +# Lazy import of IsolatedAsyncioTestCase from .async_case +# It imports asyncio, which is relatively heavy, but most tests +# do not need it. + +def __dir__(): + return globals().keys() | {'IsolatedAsyncioTestCase'} + +def __getattr__(name): + if name == 'IsolatedAsyncioTestCase': + global IsolatedAsyncioTestCase + from .async_case import IsolatedAsyncioTestCase + return IsolatedAsyncioTestCase + raise AttributeError(f"module {__name__!r} has no attribute {name!r}") diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__main__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..e5876f569b5fa8a1bc1be582e8ba7e433f3efa1c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__main__.py @@ -0,0 +1,18 @@ +"""Main entry point""" + +import sys +if sys.argv[0].endswith("__main__.py"): + import os.path + # We change sys.argv[0] to make help message more useful + # use executable without path, unquoted + # (it's just a hint anyway) + # (if you have spaces in your executable you get what you deserve!) + executable = os.path.basename(sys.executable) + sys.argv[0] = executable + " -m unittest" + del os + +__unittest = True + +from .main import main + +main(module=None) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4dfd85f70535b08c32a1fb9deffcac6c223473a8 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/__main__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/__main__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2d5c669bc8e96fa3b5ee7b71c2391a1ea02ec6d8 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/__main__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/_log.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/_log.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5221c6672335cc63e60756c740a1ece6d66dde02 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/_log.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/async_case.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/async_case.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d2aa46a8c061f56095b850d730df0b43bb4496f7 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/async_case.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/case.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/case.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0f4243c747d3ac2c23898c54c837cc9e8cd789b6 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/case.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/loader.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/loader.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c303c875a1b31cb0bdec288160a7df0520bc34f7 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/loader.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/main.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/main.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eb6d5f14305124066f9d7b9954734fe3389d0c95 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/main.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/mock.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/mock.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7f4c879e67bab44573b52c8bfefd4eaa25eb61af --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/mock.cpython-311.pyc @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9ec8789cd715ee16a03bf7bbdcfdcce5839a95f5e8d2cf0db5a9d476394e6ea6 +size 129442 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/result.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/result.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4fed1c45df2c60c3b9aa22a85ffc68a0b7cec126 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/result.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/runner.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/runner.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..635c14a81597743778f72485951b7e37633d7311 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/runner.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/signals.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/signals.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3b0a7c544b67a524427ec132471e00bb63a9d857 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/signals.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/suite.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/suite.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6cdca4bedfcb521b06b676f2846db7eebeaf673c Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/suite.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/util.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/util.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0e5c8e65c366530a0bf81a36c2faa49f47b3fe5b Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/util.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/_log.py b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/_log.py new file mode 100644 index 0000000000000000000000000000000000000000..94868e5bb95eb35fb17c9bea103f04c7d0fd5433 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/_log.py @@ -0,0 +1,86 @@ +import logging +import collections + +from .case import _BaseTestCaseContext + + +_LoggingWatcher = collections.namedtuple("_LoggingWatcher", + ["records", "output"]) + +class _CapturingHandler(logging.Handler): + """ + A logging handler capturing all (raw and formatted) logging output. + """ + + def __init__(self): + logging.Handler.__init__(self) + self.watcher = _LoggingWatcher([], []) + + def flush(self): + pass + + def emit(self, record): + self.watcher.records.append(record) + msg = self.format(record) + self.watcher.output.append(msg) + + +class _AssertLogsContext(_BaseTestCaseContext): + """A context manager for assertLogs() and assertNoLogs() """ + + LOGGING_FORMAT = "%(levelname)s:%(name)s:%(message)s" + + def __init__(self, test_case, logger_name, level, no_logs): + _BaseTestCaseContext.__init__(self, test_case) + self.logger_name = logger_name + if level: + self.level = logging._nameToLevel.get(level, level) + else: + self.level = logging.INFO + self.msg = None + self.no_logs = no_logs + + def __enter__(self): + if isinstance(self.logger_name, logging.Logger): + logger = self.logger = self.logger_name + else: + logger = self.logger = logging.getLogger(self.logger_name) + formatter = logging.Formatter(self.LOGGING_FORMAT) + handler = _CapturingHandler() + handler.setLevel(self.level) + handler.setFormatter(formatter) + self.watcher = handler.watcher + self.old_handlers = logger.handlers[:] + self.old_level = logger.level + self.old_propagate = logger.propagate + logger.handlers = [handler] + logger.setLevel(self.level) + logger.propagate = False + if self.no_logs: + return + return handler.watcher + + def __exit__(self, exc_type, exc_value, tb): + self.logger.handlers = self.old_handlers + self.logger.propagate = self.old_propagate + self.logger.setLevel(self.old_level) + + if exc_type is not None: + # let unexpected exceptions pass through + return False + + if self.no_logs: + # assertNoLogs + if len(self.watcher.records) > 0: + self._raiseFailure( + "Unexpected logs found: {!r}".format( + self.watcher.output + ) + ) + + else: + # assertLogs + if len(self.watcher.records) == 0: + self._raiseFailure( + "no logs of level {} or higher triggered on {}" + .format(logging.getLevelName(self.level), self.logger.name)) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/async_case.py b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/async_case.py new file mode 100644 index 0000000000000000000000000000000000000000..bd2a471156065bd0a1609ee6b9ed25baecb1bce5 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/async_case.py @@ -0,0 +1,142 @@ +import asyncio +import contextvars +import inspect +import warnings + +from .case import TestCase + + +class IsolatedAsyncioTestCase(TestCase): + # Names intentionally have a long prefix + # to reduce a chance of clashing with user-defined attributes + # from inherited test case + # + # The class doesn't call loop.run_until_complete(self.setUp()) and family + # but uses a different approach: + # 1. create a long-running task that reads self.setUp() + # awaitable from queue along with a future + # 2. await the awaitable object passing in and set the result + # into the future object + # 3. Outer code puts the awaitable and the future object into a queue + # with waiting for the future + # The trick is necessary because every run_until_complete() call + # creates a new task with embedded ContextVar context. + # To share contextvars between setUp(), test and tearDown() we need to execute + # them inside the same task. + + # Note: the test case modifies event loop policy if the policy was not instantiated + # yet. + # asyncio.get_event_loop_policy() creates a default policy on demand but never + # returns None + # I believe this is not an issue in user level tests but python itself for testing + # should reset a policy in every test module + # by calling asyncio.set_event_loop_policy(None) in tearDownModule() + + def __init__(self, methodName='runTest'): + super().__init__(methodName) + self._asyncioRunner = None + self._asyncioTestContext = contextvars.copy_context() + + async def asyncSetUp(self): + pass + + async def asyncTearDown(self): + pass + + def addAsyncCleanup(self, func, /, *args, **kwargs): + # A trivial trampoline to addCleanup() + # the function exists because it has a different semantics + # and signature: + # addCleanup() accepts regular functions + # but addAsyncCleanup() accepts coroutines + # + # We intentionally don't add inspect.iscoroutinefunction() check + # for func argument because there is no way + # to check for async function reliably: + # 1. It can be "async def func()" itself + # 2. Class can implement "async def __call__()" method + # 3. Regular "def func()" that returns awaitable object + self.addCleanup(*(func, *args), **kwargs) + + async def enterAsyncContext(self, cm): + """Enters the supplied asynchronous context manager. + + If successful, also adds its __aexit__ method as a cleanup + function and returns the result of the __aenter__ method. + """ + # We look up the special methods on the type to match the with + # statement. + cls = type(cm) + try: + enter = cls.__aenter__ + exit = cls.__aexit__ + except AttributeError: + raise TypeError(f"'{cls.__module__}.{cls.__qualname__}' object does " + f"not support the asynchronous context manager protocol" + ) from None + result = await enter(cm) + self.addAsyncCleanup(exit, cm, None, None, None) + return result + + def _callSetUp(self): + # Force loop to be initialized and set as the current loop + # so that setUp functions can use get_event_loop() and get the + # correct loop instance. + self._asyncioRunner.get_loop() + self._asyncioTestContext.run(self.setUp) + self._callAsync(self.asyncSetUp) + + def _callTestMethod(self, method): + if self._callMaybeAsync(method) is not None: + warnings.warn(f'It is deprecated to return a value that is not None from a ' + f'test case ({method})', DeprecationWarning, stacklevel=4) + + def _callTearDown(self): + self._callAsync(self.asyncTearDown) + self._asyncioTestContext.run(self.tearDown) + + def _callCleanup(self, function, *args, **kwargs): + self._callMaybeAsync(function, *args, **kwargs) + + def _callAsync(self, func, /, *args, **kwargs): + assert self._asyncioRunner is not None, 'asyncio runner is not initialized' + assert inspect.iscoroutinefunction(func), f'{func!r} is not an async function' + return self._asyncioRunner.run( + func(*args, **kwargs), + context=self._asyncioTestContext + ) + + def _callMaybeAsync(self, func, /, *args, **kwargs): + assert self._asyncioRunner is not None, 'asyncio runner is not initialized' + if inspect.iscoroutinefunction(func): + return self._asyncioRunner.run( + func(*args, **kwargs), + context=self._asyncioTestContext, + ) + else: + return self._asyncioTestContext.run(func, *args, **kwargs) + + def _setupAsyncioRunner(self): + assert self._asyncioRunner is None, 'asyncio runner is already initialized' + runner = asyncio.Runner(debug=True) + self._asyncioRunner = runner + + def _tearDownAsyncioRunner(self): + runner = self._asyncioRunner + runner.close() + + def run(self, result=None): + self._setupAsyncioRunner() + try: + return super().run(result) + finally: + self._tearDownAsyncioRunner() + + def debug(self): + self._setupAsyncioRunner() + super().debug() + self._tearDownAsyncioRunner() + + def __del__(self): + if self._asyncioRunner is not None: + self._tearDownAsyncioRunner() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/case.py b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/case.py new file mode 100644 index 0000000000000000000000000000000000000000..c4aa2d7721966e2058da0913c3b29cb124fed2a8 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/case.py @@ -0,0 +1,1479 @@ +"""Test case implementation""" + +import sys +import functools +import difflib +import pprint +import re +import warnings +import collections +import contextlib +import traceback +import types + +from . import result +from .util import (strclass, safe_repr, _count_diff_all_purpose, + _count_diff_hashable, _common_shorten_repr) + +__unittest = True + +_subtest_msg_sentinel = object() + +DIFF_OMITTED = ('\nDiff is %s characters long. ' + 'Set self.maxDiff to None to see it.') + +class SkipTest(Exception): + """ + Raise this exception in a test to skip it. + + Usually you can use TestCase.skipTest() or one of the skipping decorators + instead of raising this directly. + """ + +class _ShouldStop(Exception): + """ + The test should stop. + """ + +class _UnexpectedSuccess(Exception): + """ + The test was supposed to fail, but it didn't! + """ + + +class _Outcome(object): + def __init__(self, result=None): + self.expecting_failure = False + self.result = result + self.result_supports_subtests = hasattr(result, "addSubTest") + self.success = True + self.expectedFailure = None + + @contextlib.contextmanager + def testPartExecutor(self, test_case, subTest=False): + old_success = self.success + self.success = True + try: + yield + except KeyboardInterrupt: + raise + except SkipTest as e: + self.success = False + _addSkip(self.result, test_case, str(e)) + except _ShouldStop: + pass + except: + exc_info = sys.exc_info() + if self.expecting_failure: + self.expectedFailure = exc_info + else: + self.success = False + if subTest: + self.result.addSubTest(test_case.test_case, test_case, exc_info) + else: + _addError(self.result, test_case, exc_info) + # explicitly break a reference cycle: + # exc_info -> frame -> exc_info + exc_info = None + else: + if subTest and self.success: + self.result.addSubTest(test_case.test_case, test_case, None) + finally: + self.success = self.success and old_success + + +def _addSkip(result, test_case, reason): + addSkip = getattr(result, 'addSkip', None) + if addSkip is not None: + addSkip(test_case, reason) + else: + warnings.warn("TestResult has no addSkip method, skips not reported", + RuntimeWarning, 2) + result.addSuccess(test_case) + +def _addError(result, test, exc_info): + if result is not None and exc_info is not None: + if issubclass(exc_info[0], test.failureException): + result.addFailure(test, exc_info) + else: + result.addError(test, exc_info) + +def _id(obj): + return obj + + +def _enter_context(cm, addcleanup): + # We look up the special methods on the type to match the with + # statement. + cls = type(cm) + try: + enter = cls.__enter__ + exit = cls.__exit__ + except AttributeError: + raise TypeError(f"'{cls.__module__}.{cls.__qualname__}' object does " + f"not support the context manager protocol") from None + result = enter(cm) + addcleanup(exit, cm, None, None, None) + return result + + +_module_cleanups = [] +def addModuleCleanup(function, /, *args, **kwargs): + """Same as addCleanup, except the cleanup items are called even if + setUpModule fails (unlike tearDownModule).""" + _module_cleanups.append((function, args, kwargs)) + +def enterModuleContext(cm): + """Same as enterContext, but module-wide.""" + return _enter_context(cm, addModuleCleanup) + + +def doModuleCleanups(): + """Execute all module cleanup functions. Normally called for you after + tearDownModule.""" + exceptions = [] + while _module_cleanups: + function, args, kwargs = _module_cleanups.pop() + try: + function(*args, **kwargs) + except Exception as exc: + exceptions.append(exc) + if exceptions: + # Swallows all but first exception. If a multi-exception handler + # gets written we should use that here instead. + raise exceptions[0] + + +def skip(reason): + """ + Unconditionally skip a test. + """ + def decorator(test_item): + if not isinstance(test_item, type): + @functools.wraps(test_item) + def skip_wrapper(*args, **kwargs): + raise SkipTest(reason) + test_item = skip_wrapper + + test_item.__unittest_skip__ = True + test_item.__unittest_skip_why__ = reason + return test_item + if isinstance(reason, types.FunctionType): + test_item = reason + reason = '' + return decorator(test_item) + return decorator + +def skipIf(condition, reason): + """ + Skip a test if the condition is true. + """ + if condition: + return skip(reason) + return _id + +def skipUnless(condition, reason): + """ + Skip a test unless the condition is true. + """ + if not condition: + return skip(reason) + return _id + +def expectedFailure(test_item): + test_item.__unittest_expecting_failure__ = True + return test_item + +def _is_subtype(expected, basetype): + if isinstance(expected, tuple): + return all(_is_subtype(e, basetype) for e in expected) + return isinstance(expected, type) and issubclass(expected, basetype) + +class _BaseTestCaseContext: + + def __init__(self, test_case): + self.test_case = test_case + + def _raiseFailure(self, standardMsg): + msg = self.test_case._formatMessage(self.msg, standardMsg) + raise self.test_case.failureException(msg) + +class _AssertRaisesBaseContext(_BaseTestCaseContext): + + def __init__(self, expected, test_case, expected_regex=None): + _BaseTestCaseContext.__init__(self, test_case) + self.expected = expected + self.test_case = test_case + if expected_regex is not None: + expected_regex = re.compile(expected_regex) + self.expected_regex = expected_regex + self.obj_name = None + self.msg = None + + def handle(self, name, args, kwargs): + """ + If args is empty, assertRaises/Warns is being used as a + context manager, so check for a 'msg' kwarg and return self. + If args is not empty, call a callable passing positional and keyword + arguments. + """ + try: + if not _is_subtype(self.expected, self._base_type): + raise TypeError('%s() arg 1 must be %s' % + (name, self._base_type_str)) + if not args: + self.msg = kwargs.pop('msg', None) + if kwargs: + raise TypeError('%r is an invalid keyword argument for ' + 'this function' % (next(iter(kwargs)),)) + return self + + callable_obj, *args = args + try: + self.obj_name = callable_obj.__name__ + except AttributeError: + self.obj_name = str(callable_obj) + with self: + callable_obj(*args, **kwargs) + finally: + # bpo-23890: manually break a reference cycle + self = None + + +class _AssertRaisesContext(_AssertRaisesBaseContext): + """A context manager used to implement TestCase.assertRaises* methods.""" + + _base_type = BaseException + _base_type_str = 'an exception type or tuple of exception types' + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, tb): + if exc_type is None: + try: + exc_name = self.expected.__name__ + except AttributeError: + exc_name = str(self.expected) + if self.obj_name: + self._raiseFailure("{} not raised by {}".format(exc_name, + self.obj_name)) + else: + self._raiseFailure("{} not raised".format(exc_name)) + else: + traceback.clear_frames(tb) + if not issubclass(exc_type, self.expected): + # let unexpected exceptions pass through + return False + # store exception, without traceback, for later retrieval + self.exception = exc_value.with_traceback(None) + if self.expected_regex is None: + return True + + expected_regex = self.expected_regex + if not expected_regex.search(str(exc_value)): + self._raiseFailure('"{}" does not match "{}"'.format( + expected_regex.pattern, str(exc_value))) + return True + + __class_getitem__ = classmethod(types.GenericAlias) + + +class _AssertWarnsContext(_AssertRaisesBaseContext): + """A context manager used to implement TestCase.assertWarns* methods.""" + + _base_type = Warning + _base_type_str = 'a warning type or tuple of warning types' + + def __enter__(self): + # The __warningregistry__'s need to be in a pristine state for tests + # to work properly. + for v in list(sys.modules.values()): + if getattr(v, '__warningregistry__', None): + v.__warningregistry__ = {} + self.warnings_manager = warnings.catch_warnings(record=True) + self.warnings = self.warnings_manager.__enter__() + warnings.simplefilter("always", self.expected) + return self + + def __exit__(self, exc_type, exc_value, tb): + self.warnings_manager.__exit__(exc_type, exc_value, tb) + if exc_type is not None: + # let unexpected exceptions pass through + return + try: + exc_name = self.expected.__name__ + except AttributeError: + exc_name = str(self.expected) + first_matching = None + for m in self.warnings: + w = m.message + if not isinstance(w, self.expected): + continue + if first_matching is None: + first_matching = w + if (self.expected_regex is not None and + not self.expected_regex.search(str(w))): + continue + # store warning for later retrieval + self.warning = w + self.filename = m.filename + self.lineno = m.lineno + return + # Now we simply try to choose a helpful failure message + if first_matching is not None: + self._raiseFailure('"{}" does not match "{}"'.format( + self.expected_regex.pattern, str(first_matching))) + if self.obj_name: + self._raiseFailure("{} not triggered by {}".format(exc_name, + self.obj_name)) + else: + self._raiseFailure("{} not triggered".format(exc_name)) + + +class _OrderedChainMap(collections.ChainMap): + def __iter__(self): + seen = set() + for mapping in self.maps: + for k in mapping: + if k not in seen: + seen.add(k) + yield k + + +class TestCase(object): + """A class whose instances are single test cases. + + By default, the test code itself should be placed in a method named + 'runTest'. + + If the fixture may be used for many test cases, create as + many test methods as are needed. When instantiating such a TestCase + subclass, specify in the constructor arguments the name of the test method + that the instance is to execute. + + Test authors should subclass TestCase for their own tests. Construction + and deconstruction of the test's environment ('fixture') can be + implemented by overriding the 'setUp' and 'tearDown' methods respectively. + + If it is necessary to override the __init__ method, the base class + __init__ method must always be called. It is important that subclasses + should not change the signature of their __init__ method, since instances + of the classes are instantiated automatically by parts of the framework + in order to be run. + + When subclassing TestCase, you can set these attributes: + * failureException: determines which exception will be raised when + the instance's assertion methods fail; test methods raising this + exception will be deemed to have 'failed' rather than 'errored'. + * longMessage: determines whether long messages (including repr of + objects used in assert methods) will be printed on failure in *addition* + to any explicit message passed. + * maxDiff: sets the maximum length of a diff in failure messages + by assert methods using difflib. It is looked up as an instance + attribute so can be configured by individual tests if required. + """ + + failureException = AssertionError + + longMessage = True + + maxDiff = 80*8 + + # If a string is longer than _diffThreshold, use normal comparison instead + # of difflib. See #11763. + _diffThreshold = 2**16 + + def __init_subclass__(cls, *args, **kwargs): + # Attribute used by TestSuite for classSetUp + cls._classSetupFailed = False + cls._class_cleanups = [] + super().__init_subclass__(*args, **kwargs) + + def __init__(self, methodName='runTest'): + """Create an instance of the class that will use the named test + method when executed. Raises a ValueError if the instance does + not have a method with the specified name. + """ + self._testMethodName = methodName + self._outcome = None + self._testMethodDoc = 'No test' + try: + testMethod = getattr(self, methodName) + except AttributeError: + if methodName != 'runTest': + # we allow instantiation with no explicit method name + # but not an *incorrect* or missing method name + raise ValueError("no such test method in %s: %s" % + (self.__class__, methodName)) + else: + self._testMethodDoc = testMethod.__doc__ + self._cleanups = [] + self._subtest = None + + # Map types to custom assertEqual functions that will compare + # instances of said type in more detail to generate a more useful + # error message. + self._type_equality_funcs = {} + self.addTypeEqualityFunc(dict, 'assertDictEqual') + self.addTypeEqualityFunc(list, 'assertListEqual') + self.addTypeEqualityFunc(tuple, 'assertTupleEqual') + self.addTypeEqualityFunc(set, 'assertSetEqual') + self.addTypeEqualityFunc(frozenset, 'assertSetEqual') + self.addTypeEqualityFunc(str, 'assertMultiLineEqual') + + def addTypeEqualityFunc(self, typeobj, function): + """Add a type specific assertEqual style function to compare a type. + + This method is for use by TestCase subclasses that need to register + their own type equality functions to provide nicer error messages. + + Args: + typeobj: The data type to call this function on when both values + are of the same type in assertEqual(). + function: The callable taking two arguments and an optional + msg= argument that raises self.failureException with a + useful error message when the two arguments are not equal. + """ + self._type_equality_funcs[typeobj] = function + + def addCleanup(self, function, /, *args, **kwargs): + """Add a function, with arguments, to be called when the test is + completed. Functions added are called on a LIFO basis and are + called after tearDown on test failure or success. + + Cleanup items are called even if setUp fails (unlike tearDown).""" + self._cleanups.append((function, args, kwargs)) + + def enterContext(self, cm): + """Enters the supplied context manager. + + If successful, also adds its __exit__ method as a cleanup + function and returns the result of the __enter__ method. + """ + return _enter_context(cm, self.addCleanup) + + @classmethod + def addClassCleanup(cls, function, /, *args, **kwargs): + """Same as addCleanup, except the cleanup items are called even if + setUpClass fails (unlike tearDownClass).""" + cls._class_cleanups.append((function, args, kwargs)) + + @classmethod + def enterClassContext(cls, cm): + """Same as enterContext, but class-wide.""" + return _enter_context(cm, cls.addClassCleanup) + + def setUp(self): + "Hook method for setting up the test fixture before exercising it." + pass + + def tearDown(self): + "Hook method for deconstructing the test fixture after testing it." + pass + + @classmethod + def setUpClass(cls): + "Hook method for setting up class fixture before running tests in the class." + + @classmethod + def tearDownClass(cls): + "Hook method for deconstructing the class fixture after running all tests in the class." + + def countTestCases(self): + return 1 + + def defaultTestResult(self): + return result.TestResult() + + def shortDescription(self): + """Returns a one-line description of the test, or None if no + description has been provided. + + The default implementation of this method returns the first line of + the specified test method's docstring. + """ + doc = self._testMethodDoc + return doc.strip().split("\n")[0].strip() if doc else None + + + def id(self): + return "%s.%s" % (strclass(self.__class__), self._testMethodName) + + def __eq__(self, other): + if type(self) is not type(other): + return NotImplemented + + return self._testMethodName == other._testMethodName + + def __hash__(self): + return hash((type(self), self._testMethodName)) + + def __str__(self): + return "%s (%s.%s)" % (self._testMethodName, strclass(self.__class__), self._testMethodName) + + def __repr__(self): + return "<%s testMethod=%s>" % \ + (strclass(self.__class__), self._testMethodName) + + @contextlib.contextmanager + def subTest(self, msg=_subtest_msg_sentinel, **params): + """Return a context manager that will return the enclosed block + of code in a subtest identified by the optional message and + keyword parameters. A failure in the subtest marks the test + case as failed but resumes execution at the end of the enclosed + block, allowing further test code to be executed. + """ + if self._outcome is None or not self._outcome.result_supports_subtests: + yield + return + parent = self._subtest + if parent is None: + params_map = _OrderedChainMap(params) + else: + params_map = parent.params.new_child(params) + self._subtest = _SubTest(self, msg, params_map) + try: + with self._outcome.testPartExecutor(self._subtest, subTest=True): + yield + if not self._outcome.success: + result = self._outcome.result + if result is not None and result.failfast: + raise _ShouldStop + elif self._outcome.expectedFailure: + # If the test is expecting a failure, we really want to + # stop now and register the expected failure. + raise _ShouldStop + finally: + self._subtest = parent + + def _addExpectedFailure(self, result, exc_info): + try: + addExpectedFailure = result.addExpectedFailure + except AttributeError: + warnings.warn("TestResult has no addExpectedFailure method, reporting as passes", + RuntimeWarning) + result.addSuccess(self) + else: + addExpectedFailure(self, exc_info) + + def _addUnexpectedSuccess(self, result): + try: + addUnexpectedSuccess = result.addUnexpectedSuccess + except AttributeError: + warnings.warn("TestResult has no addUnexpectedSuccess method, reporting as failure", + RuntimeWarning) + # We need to pass an actual exception and traceback to addFailure, + # otherwise the legacy result can choke. + try: + raise _UnexpectedSuccess from None + except _UnexpectedSuccess: + result.addFailure(self, sys.exc_info()) + else: + addUnexpectedSuccess(self) + + def _callSetUp(self): + self.setUp() + + def _callTestMethod(self, method): + if method() is not None: + warnings.warn(f'It is deprecated to return a value that is not None from a ' + f'test case ({method})', DeprecationWarning, stacklevel=3) + + def _callTearDown(self): + self.tearDown() + + def _callCleanup(self, function, /, *args, **kwargs): + function(*args, **kwargs) + + def run(self, result=None): + if result is None: + result = self.defaultTestResult() + startTestRun = getattr(result, 'startTestRun', None) + stopTestRun = getattr(result, 'stopTestRun', None) + if startTestRun is not None: + startTestRun() + else: + stopTestRun = None + + result.startTest(self) + try: + testMethod = getattr(self, self._testMethodName) + if (getattr(self.__class__, "__unittest_skip__", False) or + getattr(testMethod, "__unittest_skip__", False)): + # If the class or method was skipped. + skip_why = (getattr(self.__class__, '__unittest_skip_why__', '') + or getattr(testMethod, '__unittest_skip_why__', '')) + _addSkip(result, self, skip_why) + return result + + expecting_failure = ( + getattr(self, "__unittest_expecting_failure__", False) or + getattr(testMethod, "__unittest_expecting_failure__", False) + ) + outcome = _Outcome(result) + try: + self._outcome = outcome + + with outcome.testPartExecutor(self): + self._callSetUp() + if outcome.success: + outcome.expecting_failure = expecting_failure + with outcome.testPartExecutor(self): + self._callTestMethod(testMethod) + outcome.expecting_failure = False + with outcome.testPartExecutor(self): + self._callTearDown() + self.doCleanups() + + if outcome.success: + if expecting_failure: + if outcome.expectedFailure: + self._addExpectedFailure(result, outcome.expectedFailure) + else: + self._addUnexpectedSuccess(result) + else: + result.addSuccess(self) + return result + finally: + # explicitly break reference cycle: + # outcome.expectedFailure -> frame -> outcome -> outcome.expectedFailure + outcome.expectedFailure = None + outcome = None + + # clear the outcome, no more needed + self._outcome = None + + finally: + result.stopTest(self) + if stopTestRun is not None: + stopTestRun() + + def doCleanups(self): + """Execute all cleanup functions. Normally called for you after + tearDown.""" + outcome = self._outcome or _Outcome() + while self._cleanups: + function, args, kwargs = self._cleanups.pop() + with outcome.testPartExecutor(self): + self._callCleanup(function, *args, **kwargs) + + # return this for backwards compatibility + # even though we no longer use it internally + return outcome.success + + @classmethod + def doClassCleanups(cls): + """Execute all class cleanup functions. Normally called for you after + tearDownClass.""" + cls.tearDown_exceptions = [] + while cls._class_cleanups: + function, args, kwargs = cls._class_cleanups.pop() + try: + function(*args, **kwargs) + except Exception: + cls.tearDown_exceptions.append(sys.exc_info()) + + def __call__(self, *args, **kwds): + return self.run(*args, **kwds) + + def debug(self): + """Run the test without collecting errors in a TestResult""" + testMethod = getattr(self, self._testMethodName) + if (getattr(self.__class__, "__unittest_skip__", False) or + getattr(testMethod, "__unittest_skip__", False)): + # If the class or method was skipped. + skip_why = (getattr(self.__class__, '__unittest_skip_why__', '') + or getattr(testMethod, '__unittest_skip_why__', '')) + raise SkipTest(skip_why) + + self._callSetUp() + self._callTestMethod(testMethod) + self._callTearDown() + while self._cleanups: + function, args, kwargs = self._cleanups.pop() + self._callCleanup(function, *args, **kwargs) + + def skipTest(self, reason): + """Skip this test.""" + raise SkipTest(reason) + + def fail(self, msg=None): + """Fail immediately, with the given message.""" + raise self.failureException(msg) + + def assertFalse(self, expr, msg=None): + """Check that the expression is false.""" + if expr: + msg = self._formatMessage(msg, "%s is not false" % safe_repr(expr)) + raise self.failureException(msg) + + def assertTrue(self, expr, msg=None): + """Check that the expression is true.""" + if not expr: + msg = self._formatMessage(msg, "%s is not true" % safe_repr(expr)) + raise self.failureException(msg) + + def _formatMessage(self, msg, standardMsg): + """Honour the longMessage attribute when generating failure messages. + If longMessage is False this means: + * Use only an explicit message if it is provided + * Otherwise use the standard message for the assert + + If longMessage is True: + * Use the standard message + * If an explicit message is provided, plus ' : ' and the explicit message + """ + if not self.longMessage: + return msg or standardMsg + if msg is None: + return standardMsg + try: + # don't switch to '{}' formatting in Python 2.X + # it changes the way unicode input is handled + return '%s : %s' % (standardMsg, msg) + except UnicodeDecodeError: + return '%s : %s' % (safe_repr(standardMsg), safe_repr(msg)) + + def assertRaises(self, expected_exception, *args, **kwargs): + """Fail unless an exception of class expected_exception is raised + by the callable when invoked with specified positional and + keyword arguments. If a different type of exception is + raised, it will not be caught, and the test case will be + deemed to have suffered an error, exactly as for an + unexpected exception. + + If called with the callable and arguments omitted, will return a + context object used like this:: + + with self.assertRaises(SomeException): + do_something() + + An optional keyword argument 'msg' can be provided when assertRaises + is used as a context object. + + The context manager keeps a reference to the exception as + the 'exception' attribute. This allows you to inspect the + exception after the assertion:: + + with self.assertRaises(SomeException) as cm: + do_something() + the_exception = cm.exception + self.assertEqual(the_exception.error_code, 3) + """ + context = _AssertRaisesContext(expected_exception, self) + try: + return context.handle('assertRaises', args, kwargs) + finally: + # bpo-23890: manually break a reference cycle + context = None + + def assertWarns(self, expected_warning, *args, **kwargs): + """Fail unless a warning of class warnClass is triggered + by the callable when invoked with specified positional and + keyword arguments. If a different type of warning is + triggered, it will not be handled: depending on the other + warning filtering rules in effect, it might be silenced, printed + out, or raised as an exception. + + If called with the callable and arguments omitted, will return a + context object used like this:: + + with self.assertWarns(SomeWarning): + do_something() + + An optional keyword argument 'msg' can be provided when assertWarns + is used as a context object. + + The context manager keeps a reference to the first matching + warning as the 'warning' attribute; similarly, the 'filename' + and 'lineno' attributes give you information about the line + of Python code from which the warning was triggered. + This allows you to inspect the warning after the assertion:: + + with self.assertWarns(SomeWarning) as cm: + do_something() + the_warning = cm.warning + self.assertEqual(the_warning.some_attribute, 147) + """ + context = _AssertWarnsContext(expected_warning, self) + return context.handle('assertWarns', args, kwargs) + + def assertLogs(self, logger=None, level=None): + """Fail unless a log message of level *level* or higher is emitted + on *logger_name* or its children. If omitted, *level* defaults to + INFO and *logger* defaults to the root logger. + + This method must be used as a context manager, and will yield + a recording object with two attributes: `output` and `records`. + At the end of the context manager, the `output` attribute will + be a list of the matching formatted log messages and the + `records` attribute will be a list of the corresponding LogRecord + objects. + + Example:: + + with self.assertLogs('foo', level='INFO') as cm: + logging.getLogger('foo').info('first message') + logging.getLogger('foo.bar').error('second message') + self.assertEqual(cm.output, ['INFO:foo:first message', + 'ERROR:foo.bar:second message']) + """ + # Lazy import to avoid importing logging if it is not needed. + from ._log import _AssertLogsContext + return _AssertLogsContext(self, logger, level, no_logs=False) + + def assertNoLogs(self, logger=None, level=None): + """ Fail unless no log messages of level *level* or higher are emitted + on *logger_name* or its children. + + This method must be used as a context manager. + """ + from ._log import _AssertLogsContext + return _AssertLogsContext(self, logger, level, no_logs=True) + + def _getAssertEqualityFunc(self, first, second): + """Get a detailed comparison function for the types of the two args. + + Returns: A callable accepting (first, second, msg=None) that will + raise a failure exception if first != second with a useful human + readable error message for those types. + """ + # + # NOTE(gregory.p.smith): I considered isinstance(first, type(second)) + # and vice versa. I opted for the conservative approach in case + # subclasses are not intended to be compared in detail to their super + # class instances using a type equality func. This means testing + # subtypes won't automagically use the detailed comparison. Callers + # should use their type specific assertSpamEqual method to compare + # subclasses if the detailed comparison is desired and appropriate. + # See the discussion in http://bugs.python.org/issue2578. + # + if type(first) is type(second): + asserter = self._type_equality_funcs.get(type(first)) + if asserter is not None: + if isinstance(asserter, str): + asserter = getattr(self, asserter) + return asserter + + return self._baseAssertEqual + + def _baseAssertEqual(self, first, second, msg=None): + """The default assertEqual implementation, not type specific.""" + if not first == second: + standardMsg = '%s != %s' % _common_shorten_repr(first, second) + msg = self._formatMessage(msg, standardMsg) + raise self.failureException(msg) + + def assertEqual(self, first, second, msg=None): + """Fail if the two objects are unequal as determined by the '==' + operator. + """ + assertion_func = self._getAssertEqualityFunc(first, second) + assertion_func(first, second, msg=msg) + + def assertNotEqual(self, first, second, msg=None): + """Fail if the two objects are equal as determined by the '!=' + operator. + """ + if not first != second: + msg = self._formatMessage(msg, '%s == %s' % (safe_repr(first), + safe_repr(second))) + raise self.failureException(msg) + + def assertAlmostEqual(self, first, second, places=None, msg=None, + delta=None): + """Fail if the two objects are unequal as determined by their + difference rounded to the given number of decimal places + (default 7) and comparing to zero, or by comparing that the + difference between the two objects is more than the given + delta. + + Note that decimal places (from zero) are usually not the same + as significant digits (measured from the most significant digit). + + If the two objects compare equal then they will automatically + compare almost equal. + """ + if first == second: + # shortcut + return + if delta is not None and places is not None: + raise TypeError("specify delta or places not both") + + diff = abs(first - second) + if delta is not None: + if diff <= delta: + return + + standardMsg = '%s != %s within %s delta (%s difference)' % ( + safe_repr(first), + safe_repr(second), + safe_repr(delta), + safe_repr(diff)) + else: + if places is None: + places = 7 + + if round(diff, places) == 0: + return + + standardMsg = '%s != %s within %r places (%s difference)' % ( + safe_repr(first), + safe_repr(second), + places, + safe_repr(diff)) + msg = self._formatMessage(msg, standardMsg) + raise self.failureException(msg) + + def assertNotAlmostEqual(self, first, second, places=None, msg=None, + delta=None): + """Fail if the two objects are equal as determined by their + difference rounded to the given number of decimal places + (default 7) and comparing to zero, or by comparing that the + difference between the two objects is less than the given delta. + + Note that decimal places (from zero) are usually not the same + as significant digits (measured from the most significant digit). + + Objects that are equal automatically fail. + """ + if delta is not None and places is not None: + raise TypeError("specify delta or places not both") + diff = abs(first - second) + if delta is not None: + if not (first == second) and diff > delta: + return + standardMsg = '%s == %s within %s delta (%s difference)' % ( + safe_repr(first), + safe_repr(second), + safe_repr(delta), + safe_repr(diff)) + else: + if places is None: + places = 7 + if not (first == second) and round(diff, places) != 0: + return + standardMsg = '%s == %s within %r places' % (safe_repr(first), + safe_repr(second), + places) + + msg = self._formatMessage(msg, standardMsg) + raise self.failureException(msg) + + def assertSequenceEqual(self, seq1, seq2, msg=None, seq_type=None): + """An equality assertion for ordered sequences (like lists and tuples). + + For the purposes of this function, a valid ordered sequence type is one + which can be indexed, has a length, and has an equality operator. + + Args: + seq1: The first sequence to compare. + seq2: The second sequence to compare. + seq_type: The expected datatype of the sequences, or None if no + datatype should be enforced. + msg: Optional message to use on failure instead of a list of + differences. + """ + if seq_type is not None: + seq_type_name = seq_type.__name__ + if not isinstance(seq1, seq_type): + raise self.failureException('First sequence is not a %s: %s' + % (seq_type_name, safe_repr(seq1))) + if not isinstance(seq2, seq_type): + raise self.failureException('Second sequence is not a %s: %s' + % (seq_type_name, safe_repr(seq2))) + else: + seq_type_name = "sequence" + + differing = None + try: + len1 = len(seq1) + except (TypeError, NotImplementedError): + differing = 'First %s has no length. Non-sequence?' % ( + seq_type_name) + + if differing is None: + try: + len2 = len(seq2) + except (TypeError, NotImplementedError): + differing = 'Second %s has no length. Non-sequence?' % ( + seq_type_name) + + if differing is None: + if seq1 == seq2: + return + + differing = '%ss differ: %s != %s\n' % ( + (seq_type_name.capitalize(),) + + _common_shorten_repr(seq1, seq2)) + + for i in range(min(len1, len2)): + try: + item1 = seq1[i] + except (TypeError, IndexError, NotImplementedError): + differing += ('\nUnable to index element %d of first %s\n' % + (i, seq_type_name)) + break + + try: + item2 = seq2[i] + except (TypeError, IndexError, NotImplementedError): + differing += ('\nUnable to index element %d of second %s\n' % + (i, seq_type_name)) + break + + if item1 != item2: + differing += ('\nFirst differing element %d:\n%s\n%s\n' % + ((i,) + _common_shorten_repr(item1, item2))) + break + else: + if (len1 == len2 and seq_type is None and + type(seq1) != type(seq2)): + # The sequences are the same, but have differing types. + return + + if len1 > len2: + differing += ('\nFirst %s contains %d additional ' + 'elements.\n' % (seq_type_name, len1 - len2)) + try: + differing += ('First extra element %d:\n%s\n' % + (len2, safe_repr(seq1[len2]))) + except (TypeError, IndexError, NotImplementedError): + differing += ('Unable to index element %d ' + 'of first %s\n' % (len2, seq_type_name)) + elif len1 < len2: + differing += ('\nSecond %s contains %d additional ' + 'elements.\n' % (seq_type_name, len2 - len1)) + try: + differing += ('First extra element %d:\n%s\n' % + (len1, safe_repr(seq2[len1]))) + except (TypeError, IndexError, NotImplementedError): + differing += ('Unable to index element %d ' + 'of second %s\n' % (len1, seq_type_name)) + standardMsg = differing + diffMsg = '\n' + '\n'.join( + difflib.ndiff(pprint.pformat(seq1).splitlines(), + pprint.pformat(seq2).splitlines())) + + standardMsg = self._truncateMessage(standardMsg, diffMsg) + msg = self._formatMessage(msg, standardMsg) + self.fail(msg) + + def _truncateMessage(self, message, diff): + max_diff = self.maxDiff + if max_diff is None or len(diff) <= max_diff: + return message + diff + return message + (DIFF_OMITTED % len(diff)) + + def assertListEqual(self, list1, list2, msg=None): + """A list-specific equality assertion. + + Args: + list1: The first list to compare. + list2: The second list to compare. + msg: Optional message to use on failure instead of a list of + differences. + + """ + self.assertSequenceEqual(list1, list2, msg, seq_type=list) + + def assertTupleEqual(self, tuple1, tuple2, msg=None): + """A tuple-specific equality assertion. + + Args: + tuple1: The first tuple to compare. + tuple2: The second tuple to compare. + msg: Optional message to use on failure instead of a list of + differences. + """ + self.assertSequenceEqual(tuple1, tuple2, msg, seq_type=tuple) + + def assertSetEqual(self, set1, set2, msg=None): + """A set-specific equality assertion. + + Args: + set1: The first set to compare. + set2: The second set to compare. + msg: Optional message to use on failure instead of a list of + differences. + + assertSetEqual uses ducktyping to support different types of sets, and + is optimized for sets specifically (parameters must support a + difference method). + """ + try: + difference1 = set1.difference(set2) + except TypeError as e: + self.fail('invalid type when attempting set difference: %s' % e) + except AttributeError as e: + self.fail('first argument does not support set difference: %s' % e) + + try: + difference2 = set2.difference(set1) + except TypeError as e: + self.fail('invalid type when attempting set difference: %s' % e) + except AttributeError as e: + self.fail('second argument does not support set difference: %s' % e) + + if not (difference1 or difference2): + return + + lines = [] + if difference1: + lines.append('Items in the first set but not the second:') + for item in difference1: + lines.append(repr(item)) + if difference2: + lines.append('Items in the second set but not the first:') + for item in difference2: + lines.append(repr(item)) + + standardMsg = '\n'.join(lines) + self.fail(self._formatMessage(msg, standardMsg)) + + def assertIn(self, member, container, msg=None): + """Just like self.assertTrue(a in b), but with a nicer default message.""" + if member not in container: + standardMsg = '%s not found in %s' % (safe_repr(member), + safe_repr(container)) + self.fail(self._formatMessage(msg, standardMsg)) + + def assertNotIn(self, member, container, msg=None): + """Just like self.assertTrue(a not in b), but with a nicer default message.""" + if member in container: + standardMsg = '%s unexpectedly found in %s' % (safe_repr(member), + safe_repr(container)) + self.fail(self._formatMessage(msg, standardMsg)) + + def assertIs(self, expr1, expr2, msg=None): + """Just like self.assertTrue(a is b), but with a nicer default message.""" + if expr1 is not expr2: + standardMsg = '%s is not %s' % (safe_repr(expr1), + safe_repr(expr2)) + self.fail(self._formatMessage(msg, standardMsg)) + + def assertIsNot(self, expr1, expr2, msg=None): + """Just like self.assertTrue(a is not b), but with a nicer default message.""" + if expr1 is expr2: + standardMsg = 'unexpectedly identical: %s' % (safe_repr(expr1),) + self.fail(self._formatMessage(msg, standardMsg)) + + def assertDictEqual(self, d1, d2, msg=None): + self.assertIsInstance(d1, dict, 'First argument is not a dictionary') + self.assertIsInstance(d2, dict, 'Second argument is not a dictionary') + + if d1 != d2: + standardMsg = '%s != %s' % _common_shorten_repr(d1, d2) + diff = ('\n' + '\n'.join(difflib.ndiff( + pprint.pformat(d1).splitlines(), + pprint.pformat(d2).splitlines()))) + standardMsg = self._truncateMessage(standardMsg, diff) + self.fail(self._formatMessage(msg, standardMsg)) + + def assertDictContainsSubset(self, subset, dictionary, msg=None): + """Checks whether dictionary is a superset of subset.""" + warnings.warn('assertDictContainsSubset is deprecated', + DeprecationWarning) + missing = [] + mismatched = [] + for key, value in subset.items(): + if key not in dictionary: + missing.append(key) + elif value != dictionary[key]: + mismatched.append('%s, expected: %s, actual: %s' % + (safe_repr(key), safe_repr(value), + safe_repr(dictionary[key]))) + + if not (missing or mismatched): + return + + standardMsg = '' + if missing: + standardMsg = 'Missing: %s' % ','.join(safe_repr(m) for m in + missing) + if mismatched: + if standardMsg: + standardMsg += '; ' + standardMsg += 'Mismatched values: %s' % ','.join(mismatched) + + self.fail(self._formatMessage(msg, standardMsg)) + + + def assertCountEqual(self, first, second, msg=None): + """Asserts that two iterables have the same elements, the same number of + times, without regard to order. + + self.assertEqual(Counter(list(first)), + Counter(list(second))) + + Example: + - [0, 1, 1] and [1, 0, 1] compare equal. + - [0, 0, 1] and [0, 1] compare unequal. + + """ + first_seq, second_seq = list(first), list(second) + try: + first = collections.Counter(first_seq) + second = collections.Counter(second_seq) + except TypeError: + # Handle case with unhashable elements + differences = _count_diff_all_purpose(first_seq, second_seq) + else: + if first == second: + return + differences = _count_diff_hashable(first_seq, second_seq) + + if differences: + standardMsg = 'Element counts were not equal:\n' + lines = ['First has %d, Second has %d: %r' % diff for diff in differences] + diffMsg = '\n'.join(lines) + standardMsg = self._truncateMessage(standardMsg, diffMsg) + msg = self._formatMessage(msg, standardMsg) + self.fail(msg) + + def assertMultiLineEqual(self, first, second, msg=None): + """Assert that two multi-line strings are equal.""" + self.assertIsInstance(first, str, 'First argument is not a string') + self.assertIsInstance(second, str, 'Second argument is not a string') + + if first != second: + # don't use difflib if the strings are too long + if (len(first) > self._diffThreshold or + len(second) > self._diffThreshold): + self._baseAssertEqual(first, second, msg) + firstlines = first.splitlines(keepends=True) + secondlines = second.splitlines(keepends=True) + if len(firstlines) == 1 and first.strip('\r\n') == first: + firstlines = [first + '\n'] + secondlines = [second + '\n'] + standardMsg = '%s != %s' % _common_shorten_repr(first, second) + diff = '\n' + ''.join(difflib.ndiff(firstlines, secondlines)) + standardMsg = self._truncateMessage(standardMsg, diff) + self.fail(self._formatMessage(msg, standardMsg)) + + def assertLess(self, a, b, msg=None): + """Just like self.assertTrue(a < b), but with a nicer default message.""" + if not a < b: + standardMsg = '%s not less than %s' % (safe_repr(a), safe_repr(b)) + self.fail(self._formatMessage(msg, standardMsg)) + + def assertLessEqual(self, a, b, msg=None): + """Just like self.assertTrue(a <= b), but with a nicer default message.""" + if not a <= b: + standardMsg = '%s not less than or equal to %s' % (safe_repr(a), safe_repr(b)) + self.fail(self._formatMessage(msg, standardMsg)) + + def assertGreater(self, a, b, msg=None): + """Just like self.assertTrue(a > b), but with a nicer default message.""" + if not a > b: + standardMsg = '%s not greater than %s' % (safe_repr(a), safe_repr(b)) + self.fail(self._formatMessage(msg, standardMsg)) + + def assertGreaterEqual(self, a, b, msg=None): + """Just like self.assertTrue(a >= b), but with a nicer default message.""" + if not a >= b: + standardMsg = '%s not greater than or equal to %s' % (safe_repr(a), safe_repr(b)) + self.fail(self._formatMessage(msg, standardMsg)) + + def assertIsNone(self, obj, msg=None): + """Same as self.assertTrue(obj is None), with a nicer default message.""" + if obj is not None: + standardMsg = '%s is not None' % (safe_repr(obj),) + self.fail(self._formatMessage(msg, standardMsg)) + + def assertIsNotNone(self, obj, msg=None): + """Included for symmetry with assertIsNone.""" + if obj is None: + standardMsg = 'unexpectedly None' + self.fail(self._formatMessage(msg, standardMsg)) + + def assertIsInstance(self, obj, cls, msg=None): + """Same as self.assertTrue(isinstance(obj, cls)), with a nicer + default message.""" + if not isinstance(obj, cls): + standardMsg = '%s is not an instance of %r' % (safe_repr(obj), cls) + self.fail(self._formatMessage(msg, standardMsg)) + + def assertNotIsInstance(self, obj, cls, msg=None): + """Included for symmetry with assertIsInstance.""" + if isinstance(obj, cls): + standardMsg = '%s is an instance of %r' % (safe_repr(obj), cls) + self.fail(self._formatMessage(msg, standardMsg)) + + def assertRaisesRegex(self, expected_exception, expected_regex, + *args, **kwargs): + """Asserts that the message in a raised exception matches a regex. + + Args: + expected_exception: Exception class expected to be raised. + expected_regex: Regex (re.Pattern object or string) expected + to be found in error message. + args: Function to be called and extra positional args. + kwargs: Extra kwargs. + msg: Optional message used in case of failure. Can only be used + when assertRaisesRegex is used as a context manager. + """ + context = _AssertRaisesContext(expected_exception, self, expected_regex) + return context.handle('assertRaisesRegex', args, kwargs) + + def assertWarnsRegex(self, expected_warning, expected_regex, + *args, **kwargs): + """Asserts that the message in a triggered warning matches a regexp. + Basic functioning is similar to assertWarns() with the addition + that only warnings whose messages also match the regular expression + are considered successful matches. + + Args: + expected_warning: Warning class expected to be triggered. + expected_regex: Regex (re.Pattern object or string) expected + to be found in error message. + args: Function to be called and extra positional args. + kwargs: Extra kwargs. + msg: Optional message used in case of failure. Can only be used + when assertWarnsRegex is used as a context manager. + """ + context = _AssertWarnsContext(expected_warning, self, expected_regex) + return context.handle('assertWarnsRegex', args, kwargs) + + def assertRegex(self, text, expected_regex, msg=None): + """Fail the test unless the text matches the regular expression.""" + if isinstance(expected_regex, (str, bytes)): + assert expected_regex, "expected_regex must not be empty." + expected_regex = re.compile(expected_regex) + if not expected_regex.search(text): + standardMsg = "Regex didn't match: %r not found in %r" % ( + expected_regex.pattern, text) + # _formatMessage ensures the longMessage option is respected + msg = self._formatMessage(msg, standardMsg) + raise self.failureException(msg) + + def assertNotRegex(self, text, unexpected_regex, msg=None): + """Fail the test if the text matches the regular expression.""" + if isinstance(unexpected_regex, (str, bytes)): + unexpected_regex = re.compile(unexpected_regex) + match = unexpected_regex.search(text) + if match: + standardMsg = 'Regex matched: %r matches %r in %r' % ( + text[match.start() : match.end()], + unexpected_regex.pattern, + text) + # _formatMessage ensures the longMessage option is respected + msg = self._formatMessage(msg, standardMsg) + raise self.failureException(msg) + + + def _deprecate(original_func): + def deprecated_func(*args, **kwargs): + warnings.warn( + 'Please use {0} instead.'.format(original_func.__name__), + DeprecationWarning, 2) + return original_func(*args, **kwargs) + return deprecated_func + + # see #9424 + failUnlessEqual = assertEquals = _deprecate(assertEqual) + failIfEqual = assertNotEquals = _deprecate(assertNotEqual) + failUnlessAlmostEqual = assertAlmostEquals = _deprecate(assertAlmostEqual) + failIfAlmostEqual = assertNotAlmostEquals = _deprecate(assertNotAlmostEqual) + failUnless = assert_ = _deprecate(assertTrue) + failUnlessRaises = _deprecate(assertRaises) + failIf = _deprecate(assertFalse) + assertRaisesRegexp = _deprecate(assertRaisesRegex) + assertRegexpMatches = _deprecate(assertRegex) + assertNotRegexpMatches = _deprecate(assertNotRegex) + + + +class FunctionTestCase(TestCase): + """A test case that wraps a test function. + + This is useful for slipping pre-existing test functions into the + unittest framework. Optionally, set-up and tidy-up functions can be + supplied. As with TestCase, the tidy-up ('tearDown') function will + always be called if the set-up ('setUp') function ran successfully. + """ + + def __init__(self, testFunc, setUp=None, tearDown=None, description=None): + super(FunctionTestCase, self).__init__() + self._setUpFunc = setUp + self._tearDownFunc = tearDown + self._testFunc = testFunc + self._description = description + + def setUp(self): + if self._setUpFunc is not None: + self._setUpFunc() + + def tearDown(self): + if self._tearDownFunc is not None: + self._tearDownFunc() + + def runTest(self): + self._testFunc() + + def id(self): + return self._testFunc.__name__ + + def __eq__(self, other): + if not isinstance(other, self.__class__): + return NotImplemented + + return self._setUpFunc == other._setUpFunc and \ + self._tearDownFunc == other._tearDownFunc and \ + self._testFunc == other._testFunc and \ + self._description == other._description + + def __hash__(self): + return hash((type(self), self._setUpFunc, self._tearDownFunc, + self._testFunc, self._description)) + + def __str__(self): + return "%s (%s)" % (strclass(self.__class__), + self._testFunc.__name__) + + def __repr__(self): + return "<%s tec=%s>" % (strclass(self.__class__), + self._testFunc) + + def shortDescription(self): + if self._description is not None: + return self._description + doc = self._testFunc.__doc__ + return doc and doc.split("\n")[0].strip() or None + + +class _SubTest(TestCase): + + def __init__(self, test_case, message, params): + super().__init__() + self._message = message + self.test_case = test_case + self.params = params + self.failureException = test_case.failureException + + def runTest(self): + raise NotImplementedError("subtests cannot be run directly") + + def _subDescription(self): + parts = [] + if self._message is not _subtest_msg_sentinel: + parts.append("[{}]".format(self._message)) + if self.params: + params_desc = ', '.join( + "{}={!r}".format(k, v) + for (k, v) in self.params.items()) + parts.append("({})".format(params_desc)) + return " ".join(parts) or '()' + + def id(self): + return "{} {}".format(self.test_case.id(), self._subDescription()) + + def shortDescription(self): + """Returns a one-line description of the subtest, or None if no + description has been provided. + """ + return self.test_case.shortDescription() + + def __str__(self): + return "{} {}".format(self.test_case, self._subDescription()) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/loader.py b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/loader.py new file mode 100644 index 0000000000000000000000000000000000000000..f4e3d6e8f275dc5d21fa08753e43cba63c35cb9c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/loader.py @@ -0,0 +1,520 @@ +"""Loading unittests.""" + +import os +import re +import sys +import traceback +import types +import functools +import warnings + +from fnmatch import fnmatch, fnmatchcase + +from . import case, suite, util + +__unittest = True + +# what about .pyc (etc) +# we would need to avoid loading the same tests multiple times +# from '.py', *and* '.pyc' +VALID_MODULE_NAME = re.compile(r'[_a-z]\w*\.py$', re.IGNORECASE) + + +class _FailedTest(case.TestCase): + _testMethodName = None + + def __init__(self, method_name, exception): + self._exception = exception + super(_FailedTest, self).__init__(method_name) + + def __getattr__(self, name): + if name != self._testMethodName: + return super(_FailedTest, self).__getattr__(name) + def testFailure(): + raise self._exception + return testFailure + + +def _make_failed_import_test(name, suiteClass): + message = 'Failed to import test module: %s\n%s' % ( + name, traceback.format_exc()) + return _make_failed_test(name, ImportError(message), suiteClass, message) + +def _make_failed_load_tests(name, exception, suiteClass): + message = 'Failed to call load_tests:\n%s' % (traceback.format_exc(),) + return _make_failed_test( + name, exception, suiteClass, message) + +def _make_failed_test(methodname, exception, suiteClass, message): + test = _FailedTest(methodname, exception) + return suiteClass((test,)), message + +def _make_skipped_test(methodname, exception, suiteClass): + @case.skip(str(exception)) + def testSkipped(self): + pass + attrs = {methodname: testSkipped} + TestClass = type("ModuleSkipped", (case.TestCase,), attrs) + return suiteClass((TestClass(methodname),)) + +def _jython_aware_splitext(path): + if path.lower().endswith('$py.class'): + return path[:-9] + return os.path.splitext(path)[0] + + +class TestLoader(object): + """ + This class is responsible for loading tests according to various criteria + and returning them wrapped in a TestSuite + """ + testMethodPrefix = 'test' + sortTestMethodsUsing = staticmethod(util.three_way_cmp) + testNamePatterns = None + suiteClass = suite.TestSuite + _top_level_dir = None + + def __init__(self): + super(TestLoader, self).__init__() + self.errors = [] + # Tracks packages which we have called into via load_tests, to + # avoid infinite re-entrancy. + self._loading_packages = set() + + def loadTestsFromTestCase(self, testCaseClass): + """Return a suite of all test cases contained in testCaseClass""" + if issubclass(testCaseClass, suite.TestSuite): + raise TypeError("Test cases should not be derived from " + "TestSuite. Maybe you meant to derive from " + "TestCase?") + if testCaseClass in (case.TestCase, case.FunctionTestCase): + # We don't load any tests from base types that should not be loaded. + testCaseNames = [] + else: + testCaseNames = self.getTestCaseNames(testCaseClass) + if not testCaseNames and hasattr(testCaseClass, 'runTest'): + testCaseNames = ['runTest'] + loaded_suite = self.suiteClass(map(testCaseClass, testCaseNames)) + return loaded_suite + + # XXX After Python 3.5, remove backward compatibility hacks for + # use_load_tests deprecation via *args and **kws. See issue 16662. + def loadTestsFromModule(self, module, *args, pattern=None, **kws): + """Return a suite of all test cases contained in the given module""" + # This method used to take an undocumented and unofficial + # use_load_tests argument. For backward compatibility, we still + # accept the argument (which can also be the first position) but we + # ignore it and issue a deprecation warning if it's present. + if len(args) > 0 or 'use_load_tests' in kws: + warnings.warn('use_load_tests is deprecated and ignored', + DeprecationWarning) + kws.pop('use_load_tests', None) + if len(args) > 1: + # Complain about the number of arguments, but don't forget the + # required `module` argument. + complaint = len(args) + 1 + raise TypeError('loadTestsFromModule() takes 1 positional argument but {} were given'.format(complaint)) + if len(kws) != 0: + # Since the keyword arguments are unsorted (see PEP 468), just + # pick the alphabetically sorted first argument to complain about, + # if multiple were given. At least the error message will be + # predictable. + complaint = sorted(kws)[0] + raise TypeError("loadTestsFromModule() got an unexpected keyword argument '{}'".format(complaint)) + tests = [] + for name in dir(module): + obj = getattr(module, name) + if ( + isinstance(obj, type) + and issubclass(obj, case.TestCase) + and obj not in (case.TestCase, case.FunctionTestCase) + ): + tests.append(self.loadTestsFromTestCase(obj)) + + load_tests = getattr(module, 'load_tests', None) + tests = self.suiteClass(tests) + if load_tests is not None: + try: + return load_tests(self, tests, pattern) + except Exception as e: + error_case, error_message = _make_failed_load_tests( + module.__name__, e, self.suiteClass) + self.errors.append(error_message) + return error_case + return tests + + def loadTestsFromName(self, name, module=None): + """Return a suite of all test cases given a string specifier. + + The name may resolve either to a module, a test case class, a + test method within a test case class, or a callable object which + returns a TestCase or TestSuite instance. + + The method optionally resolves the names relative to a given module. + """ + parts = name.split('.') + error_case, error_message = None, None + if module is None: + parts_copy = parts[:] + while parts_copy: + try: + module_name = '.'.join(parts_copy) + module = __import__(module_name) + break + except ImportError: + next_attribute = parts_copy.pop() + # Last error so we can give it to the user if needed. + error_case, error_message = _make_failed_import_test( + next_attribute, self.suiteClass) + if not parts_copy: + # Even the top level import failed: report that error. + self.errors.append(error_message) + return error_case + parts = parts[1:] + obj = module + for part in parts: + try: + parent, obj = obj, getattr(obj, part) + except AttributeError as e: + # We can't traverse some part of the name. + if (getattr(obj, '__path__', None) is not None + and error_case is not None): + # This is a package (no __path__ per importlib docs), and we + # encountered an error importing something. We cannot tell + # the difference between package.WrongNameTestClass and + # package.wrong_module_name so we just report the + # ImportError - it is more informative. + self.errors.append(error_message) + return error_case + else: + # Otherwise, we signal that an AttributeError has occurred. + error_case, error_message = _make_failed_test( + part, e, self.suiteClass, + 'Failed to access attribute:\n%s' % ( + traceback.format_exc(),)) + self.errors.append(error_message) + return error_case + + if isinstance(obj, types.ModuleType): + return self.loadTestsFromModule(obj) + elif ( + isinstance(obj, type) + and issubclass(obj, case.TestCase) + and obj not in (case.TestCase, case.FunctionTestCase) + ): + return self.loadTestsFromTestCase(obj) + elif (isinstance(obj, types.FunctionType) and + isinstance(parent, type) and + issubclass(parent, case.TestCase)): + name = parts[-1] + inst = parent(name) + # static methods follow a different path + if not isinstance(getattr(inst, name), types.FunctionType): + return self.suiteClass([inst]) + elif isinstance(obj, suite.TestSuite): + return obj + if callable(obj): + test = obj() + if isinstance(test, suite.TestSuite): + return test + elif isinstance(test, case.TestCase): + return self.suiteClass([test]) + else: + raise TypeError("calling %s returned %s, not a test" % + (obj, test)) + else: + raise TypeError("don't know how to make test from: %s" % obj) + + def loadTestsFromNames(self, names, module=None): + """Return a suite of all test cases found using the given sequence + of string specifiers. See 'loadTestsFromName()'. + """ + suites = [self.loadTestsFromName(name, module) for name in names] + return self.suiteClass(suites) + + def getTestCaseNames(self, testCaseClass): + """Return a sorted sequence of method names found within testCaseClass + """ + def shouldIncludeMethod(attrname): + if not attrname.startswith(self.testMethodPrefix): + return False + testFunc = getattr(testCaseClass, attrname) + if not callable(testFunc): + return False + fullName = f'%s.%s.%s' % ( + testCaseClass.__module__, testCaseClass.__qualname__, attrname + ) + return self.testNamePatterns is None or \ + any(fnmatchcase(fullName, pattern) for pattern in self.testNamePatterns) + testFnNames = list(filter(shouldIncludeMethod, dir(testCaseClass))) + if self.sortTestMethodsUsing: + testFnNames.sort(key=functools.cmp_to_key(self.sortTestMethodsUsing)) + return testFnNames + + def discover(self, start_dir, pattern='test*.py', top_level_dir=None): + """Find and return all test modules from the specified start + directory, recursing into subdirectories to find them and return all + tests found within them. Only test files that match the pattern will + be loaded. (Using shell style pattern matching.) + + All test modules must be importable from the top level of the project. + If the start directory is not the top level directory then the top + level directory must be specified separately. + + If a test package name (directory with '__init__.py') matches the + pattern then the package will be checked for a 'load_tests' function. If + this exists then it will be called with (loader, tests, pattern) unless + the package has already had load_tests called from the same discovery + invocation, in which case the package module object is not scanned for + tests - this ensures that when a package uses discover to further + discover child tests that infinite recursion does not happen. + + If load_tests exists then discovery does *not* recurse into the package, + load_tests is responsible for loading all tests in the package. + + The pattern is deliberately not stored as a loader attribute so that + packages can continue discovery themselves. top_level_dir is stored so + load_tests does not need to pass this argument in to loader.discover(). + + Paths are sorted before being imported to ensure reproducible execution + order even on filesystems with non-alphabetical ordering like ext3/4. + """ + set_implicit_top = False + if top_level_dir is None and self._top_level_dir is not None: + # make top_level_dir optional if called from load_tests in a package + top_level_dir = self._top_level_dir + elif top_level_dir is None: + set_implicit_top = True + top_level_dir = start_dir + + top_level_dir = os.path.abspath(top_level_dir) + + if not top_level_dir in sys.path: + # all test modules must be importable from the top level directory + # should we *unconditionally* put the start directory in first + # in sys.path to minimise likelihood of conflicts between installed + # modules and development versions? + sys.path.insert(0, top_level_dir) + self._top_level_dir = top_level_dir + + is_not_importable = False + if os.path.isdir(os.path.abspath(start_dir)): + start_dir = os.path.abspath(start_dir) + if start_dir != top_level_dir: + is_not_importable = not os.path.isfile(os.path.join(start_dir, '__init__.py')) + else: + # support for discovery from dotted module names + try: + __import__(start_dir) + except ImportError: + is_not_importable = True + else: + the_module = sys.modules[start_dir] + top_part = start_dir.split('.')[0] + try: + start_dir = os.path.abspath( + os.path.dirname((the_module.__file__))) + except AttributeError: + if the_module.__name__ in sys.builtin_module_names: + # builtin module + raise TypeError('Can not use builtin modules ' + 'as dotted module names') from None + else: + raise TypeError( + f"don't know how to discover from {the_module!r}" + ) from None + + if set_implicit_top: + self._top_level_dir = self._get_directory_containing_module(top_part) + sys.path.remove(top_level_dir) + + if is_not_importable: + raise ImportError('Start directory is not importable: %r' % start_dir) + + tests = list(self._find_tests(start_dir, pattern)) + return self.suiteClass(tests) + + def _get_directory_containing_module(self, module_name): + module = sys.modules[module_name] + full_path = os.path.abspath(module.__file__) + + if os.path.basename(full_path).lower().startswith('__init__.py'): + return os.path.dirname(os.path.dirname(full_path)) + else: + # here we have been given a module rather than a package - so + # all we can do is search the *same* directory the module is in + # should an exception be raised instead + return os.path.dirname(full_path) + + def _get_name_from_path(self, path): + if path == self._top_level_dir: + return '.' + path = _jython_aware_splitext(os.path.normpath(path)) + + _relpath = os.path.relpath(path, self._top_level_dir) + assert not os.path.isabs(_relpath), "Path must be within the project" + assert not _relpath.startswith('..'), "Path must be within the project" + + name = _relpath.replace(os.path.sep, '.') + return name + + def _get_module_from_name(self, name): + __import__(name) + return sys.modules[name] + + def _match_path(self, path, full_path, pattern): + # override this method to use alternative matching strategy + return fnmatch(path, pattern) + + def _find_tests(self, start_dir, pattern): + """Used by discovery. Yields test suites it loads.""" + # Handle the __init__ in this package + name = self._get_name_from_path(start_dir) + # name is '.' when start_dir == top_level_dir (and top_level_dir is by + # definition not a package). + if name != '.' and name not in self._loading_packages: + # name is in self._loading_packages while we have called into + # loadTestsFromModule with name. + tests, should_recurse = self._find_test_path(start_dir, pattern) + if tests is not None: + yield tests + if not should_recurse: + # Either an error occurred, or load_tests was used by the + # package. + return + # Handle the contents. + paths = sorted(os.listdir(start_dir)) + for path in paths: + full_path = os.path.join(start_dir, path) + tests, should_recurse = self._find_test_path(full_path, pattern) + if tests is not None: + yield tests + if should_recurse: + # we found a package that didn't use load_tests. + name = self._get_name_from_path(full_path) + self._loading_packages.add(name) + try: + yield from self._find_tests(full_path, pattern) + finally: + self._loading_packages.discard(name) + + def _find_test_path(self, full_path, pattern): + """Used by discovery. + + Loads tests from a single file, or a directories' __init__.py when + passed the directory. + + Returns a tuple (None_or_tests_from_file, should_recurse). + """ + basename = os.path.basename(full_path) + if os.path.isfile(full_path): + if not VALID_MODULE_NAME.match(basename): + # valid Python identifiers only + return None, False + if not self._match_path(basename, full_path, pattern): + return None, False + # if the test file matches, load it + name = self._get_name_from_path(full_path) + try: + module = self._get_module_from_name(name) + except case.SkipTest as e: + return _make_skipped_test(name, e, self.suiteClass), False + except: + error_case, error_message = \ + _make_failed_import_test(name, self.suiteClass) + self.errors.append(error_message) + return error_case, False + else: + mod_file = os.path.abspath( + getattr(module, '__file__', full_path)) + realpath = _jython_aware_splitext( + os.path.realpath(mod_file)) + fullpath_noext = _jython_aware_splitext( + os.path.realpath(full_path)) + if realpath.lower() != fullpath_noext.lower(): + module_dir = os.path.dirname(realpath) + mod_name = _jython_aware_splitext( + os.path.basename(full_path)) + expected_dir = os.path.dirname(full_path) + msg = ("%r module incorrectly imported from %r. Expected " + "%r. Is this module globally installed?") + raise ImportError( + msg % (mod_name, module_dir, expected_dir)) + return self.loadTestsFromModule(module, pattern=pattern), False + elif os.path.isdir(full_path): + if not os.path.isfile(os.path.join(full_path, '__init__.py')): + return None, False + + load_tests = None + tests = None + name = self._get_name_from_path(full_path) + try: + package = self._get_module_from_name(name) + except case.SkipTest as e: + return _make_skipped_test(name, e, self.suiteClass), False + except: + error_case, error_message = \ + _make_failed_import_test(name, self.suiteClass) + self.errors.append(error_message) + return error_case, False + else: + load_tests = getattr(package, 'load_tests', None) + # Mark this package as being in load_tests (possibly ;)) + self._loading_packages.add(name) + try: + tests = self.loadTestsFromModule(package, pattern=pattern) + if load_tests is not None: + # loadTestsFromModule(package) has loaded tests for us. + return tests, False + return tests, True + finally: + self._loading_packages.discard(name) + else: + return None, False + + +defaultTestLoader = TestLoader() + + +# These functions are considered obsolete for long time. +# They will be removed in Python 3.13. + +def _makeLoader(prefix, sortUsing, suiteClass=None, testNamePatterns=None): + loader = TestLoader() + loader.sortTestMethodsUsing = sortUsing + loader.testMethodPrefix = prefix + loader.testNamePatterns = testNamePatterns + if suiteClass: + loader.suiteClass = suiteClass + return loader + +def getTestCaseNames(testCaseClass, prefix, sortUsing=util.three_way_cmp, testNamePatterns=None): + import warnings + warnings.warn( + "unittest.getTestCaseNames() is deprecated and will be removed in Python 3.13. " + "Please use unittest.TestLoader.getTestCaseNames() instead.", + DeprecationWarning, stacklevel=2 + ) + return _makeLoader(prefix, sortUsing, testNamePatterns=testNamePatterns).getTestCaseNames(testCaseClass) + +def makeSuite(testCaseClass, prefix='test', sortUsing=util.three_way_cmp, + suiteClass=suite.TestSuite): + import warnings + warnings.warn( + "unittest.makeSuite() is deprecated and will be removed in Python 3.13. " + "Please use unittest.TestLoader.loadTestsFromTestCase() instead.", + DeprecationWarning, stacklevel=2 + ) + return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromTestCase( + testCaseClass) + +def findTestCases(module, prefix='test', sortUsing=util.three_way_cmp, + suiteClass=suite.TestSuite): + import warnings + warnings.warn( + "unittest.findTestCases() is deprecated and will be removed in Python 3.13. " + "Please use unittest.TestLoader.loadTestsFromModule() instead.", + DeprecationWarning, stacklevel=2 + ) + return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromModule(\ + module) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/main.py b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/main.py new file mode 100644 index 0000000000000000000000000000000000000000..046fbd3a45dcf8e621cf2b5b15af1357597d5efe --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/main.py @@ -0,0 +1,278 @@ +"""Unittest main program""" + +import sys +import argparse +import os +import warnings + +from . import loader, runner +from .signals import installHandler + +__unittest = True + +MAIN_EXAMPLES = """\ +Examples: + %(prog)s test_module - run tests from test_module + %(prog)s module.TestClass - run tests from module.TestClass + %(prog)s module.Class.test_method - run specified test method + %(prog)s path/to/test_file.py - run tests from test_file.py +""" + +MODULE_EXAMPLES = """\ +Examples: + %(prog)s - run default set of tests + %(prog)s MyTestSuite - run suite 'MyTestSuite' + %(prog)s MyTestCase.testSomething - run MyTestCase.testSomething + %(prog)s MyTestCase - run all 'test*' test methods + in MyTestCase +""" + +def _convert_name(name): + # on Linux / Mac OS X 'foo.PY' is not importable, but on + # Windows it is. Simpler to do a case insensitive match + # a better check would be to check that the name is a + # valid Python module name. + if os.path.isfile(name) and name.lower().endswith('.py'): + if os.path.isabs(name): + rel_path = os.path.relpath(name, os.getcwd()) + if os.path.isabs(rel_path) or rel_path.startswith(os.pardir): + return name + name = rel_path + # on Windows both '\' and '/' are used as path + # separators. Better to replace both than rely on os.path.sep + return os.path.normpath(name)[:-3].replace('\\', '.').replace('/', '.') + return name + +def _convert_names(names): + return [_convert_name(name) for name in names] + + +def _convert_select_pattern(pattern): + if not '*' in pattern: + pattern = '*%s*' % pattern + return pattern + + +class TestProgram(object): + """A command-line program that runs a set of tests; this is primarily + for making test modules conveniently executable. + """ + # defaults for testing + module=None + verbosity = 1 + failfast = catchbreak = buffer = progName = warnings = testNamePatterns = None + _discovery_parser = None + + def __init__(self, module='__main__', defaultTest=None, argv=None, + testRunner=None, testLoader=loader.defaultTestLoader, + exit=True, verbosity=1, failfast=None, catchbreak=None, + buffer=None, warnings=None, *, tb_locals=False): + if isinstance(module, str): + self.module = __import__(module) + for part in module.split('.')[1:]: + self.module = getattr(self.module, part) + else: + self.module = module + if argv is None: + argv = sys.argv + + self.exit = exit + self.failfast = failfast + self.catchbreak = catchbreak + self.verbosity = verbosity + self.buffer = buffer + self.tb_locals = tb_locals + if warnings is None and not sys.warnoptions: + # even if DeprecationWarnings are ignored by default + # print them anyway unless other warnings settings are + # specified by the warnings arg or the -W python flag + self.warnings = 'default' + else: + # here self.warnings is set either to the value passed + # to the warnings args or to None. + # If the user didn't pass a value self.warnings will + # be None. This means that the behavior is unchanged + # and depends on the values passed to -W. + self.warnings = warnings + self.defaultTest = defaultTest + self.testRunner = testRunner + self.testLoader = testLoader + self.progName = os.path.basename(argv[0]) + self.parseArgs(argv) + self.runTests() + + def usageExit(self, msg=None): + warnings.warn("TestProgram.usageExit() is deprecated and will be" + " removed in Python 3.13", DeprecationWarning) + if msg: + print(msg) + if self._discovery_parser is None: + self._initArgParsers() + self._print_help() + sys.exit(2) + + def _print_help(self, *args, **kwargs): + if self.module is None: + print(self._main_parser.format_help()) + print(MAIN_EXAMPLES % {'prog': self.progName}) + self._discovery_parser.print_help() + else: + print(self._main_parser.format_help()) + print(MODULE_EXAMPLES % {'prog': self.progName}) + + def parseArgs(self, argv): + self._initArgParsers() + if self.module is None: + if len(argv) > 1 and argv[1].lower() == 'discover': + self._do_discovery(argv[2:]) + return + self._main_parser.parse_args(argv[1:], self) + if not self.tests: + # this allows "python -m unittest -v" to still work for + # test discovery. + self._do_discovery([]) + return + else: + self._main_parser.parse_args(argv[1:], self) + + if self.tests: + self.testNames = _convert_names(self.tests) + if __name__ == '__main__': + # to support python -m unittest ... + self.module = None + elif self.defaultTest is None: + # createTests will load tests from self.module + self.testNames = None + elif isinstance(self.defaultTest, str): + self.testNames = (self.defaultTest,) + else: + self.testNames = list(self.defaultTest) + self.createTests() + + def createTests(self, from_discovery=False, Loader=None): + if self.testNamePatterns: + self.testLoader.testNamePatterns = self.testNamePatterns + if from_discovery: + loader = self.testLoader if Loader is None else Loader() + self.test = loader.discover(self.start, self.pattern, self.top) + elif self.testNames is None: + self.test = self.testLoader.loadTestsFromModule(self.module) + else: + self.test = self.testLoader.loadTestsFromNames(self.testNames, + self.module) + + def _initArgParsers(self): + parent_parser = self._getParentArgParser() + self._main_parser = self._getMainArgParser(parent_parser) + self._discovery_parser = self._getDiscoveryArgParser(parent_parser) + + def _getParentArgParser(self): + parser = argparse.ArgumentParser(add_help=False) + + parser.add_argument('-v', '--verbose', dest='verbosity', + action='store_const', const=2, + help='Verbose output') + parser.add_argument('-q', '--quiet', dest='verbosity', + action='store_const', const=0, + help='Quiet output') + parser.add_argument('--locals', dest='tb_locals', + action='store_true', + help='Show local variables in tracebacks') + if self.failfast is None: + parser.add_argument('-f', '--failfast', dest='failfast', + action='store_true', + help='Stop on first fail or error') + self.failfast = False + if self.catchbreak is None: + parser.add_argument('-c', '--catch', dest='catchbreak', + action='store_true', + help='Catch Ctrl-C and display results so far') + self.catchbreak = False + if self.buffer is None: + parser.add_argument('-b', '--buffer', dest='buffer', + action='store_true', + help='Buffer stdout and stderr during tests') + self.buffer = False + if self.testNamePatterns is None: + parser.add_argument('-k', dest='testNamePatterns', + action='append', type=_convert_select_pattern, + help='Only run tests which match the given substring') + self.testNamePatterns = [] + + return parser + + def _getMainArgParser(self, parent): + parser = argparse.ArgumentParser(parents=[parent]) + parser.prog = self.progName + parser.print_help = self._print_help + + parser.add_argument('tests', nargs='*', + help='a list of any number of test modules, ' + 'classes and test methods.') + + return parser + + def _getDiscoveryArgParser(self, parent): + parser = argparse.ArgumentParser(parents=[parent]) + parser.prog = '%s discover' % self.progName + parser.epilog = ('For test discovery all test modules must be ' + 'importable from the top level directory of the ' + 'project.') + + parser.add_argument('-s', '--start-directory', dest='start', + help="Directory to start discovery ('.' default)") + parser.add_argument('-p', '--pattern', dest='pattern', + help="Pattern to match tests ('test*.py' default)") + parser.add_argument('-t', '--top-level-directory', dest='top', + help='Top level directory of project (defaults to ' + 'start directory)') + for arg in ('start', 'pattern', 'top'): + parser.add_argument(arg, nargs='?', + default=argparse.SUPPRESS, + help=argparse.SUPPRESS) + + return parser + + def _do_discovery(self, argv, Loader=None): + self.start = '.' + self.pattern = 'test*.py' + self.top = None + if argv is not None: + # handle command line args for test discovery + if self._discovery_parser is None: + # for testing + self._initArgParsers() + self._discovery_parser.parse_args(argv, self) + + self.createTests(from_discovery=True, Loader=Loader) + + def runTests(self): + if self.catchbreak: + installHandler() + if self.testRunner is None: + self.testRunner = runner.TextTestRunner + if isinstance(self.testRunner, type): + try: + try: + testRunner = self.testRunner(verbosity=self.verbosity, + failfast=self.failfast, + buffer=self.buffer, + warnings=self.warnings, + tb_locals=self.tb_locals) + except TypeError: + # didn't accept the tb_locals argument + testRunner = self.testRunner(verbosity=self.verbosity, + failfast=self.failfast, + buffer=self.buffer, + warnings=self.warnings) + except TypeError: + # didn't accept the verbosity, buffer or failfast arguments + testRunner = self.testRunner() + else: + # it is assumed to be a TestRunner instance + testRunner = self.testRunner + self.result = testRunner.run(self.test) + if self.exit: + sys.exit(not self.result.wasSuccessful()) + +main = TestProgram diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/mock.py b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/mock.py new file mode 100644 index 0000000000000000000000000000000000000000..d4307edac741267fe9596795c2c4cdb04e7e4a37 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/mock.py @@ -0,0 +1,2999 @@ +# mock.py +# Test tools for mocking and patching. +# Maintained by Michael Foord +# Backport for other versions of Python available from +# https://pypi.org/project/mock + +__all__ = ( + 'Mock', + 'MagicMock', + 'patch', + 'sentinel', + 'DEFAULT', + 'ANY', + 'call', + 'create_autospec', + 'AsyncMock', + 'FILTER_DIR', + 'NonCallableMock', + 'NonCallableMagicMock', + 'mock_open', + 'PropertyMock', + 'seal', +) + + +import asyncio +import contextlib +import io +import inspect +import pprint +import sys +import builtins +import pkgutil +from asyncio import iscoroutinefunction +from types import CodeType, ModuleType, MethodType +from unittest.util import safe_repr +from functools import wraps, partial +from threading import RLock + + +class InvalidSpecError(Exception): + """Indicates that an invalid value was used as a mock spec.""" + + +_builtins = {name for name in dir(builtins) if not name.startswith('_')} + +FILTER_DIR = True + +# Workaround for issue #12370 +# Without this, the __class__ properties wouldn't be set correctly +_safe_super = super + +def _is_async_obj(obj): + if _is_instance_mock(obj) and not isinstance(obj, AsyncMock): + return False + if hasattr(obj, '__func__'): + obj = getattr(obj, '__func__') + return iscoroutinefunction(obj) or inspect.isawaitable(obj) + + +def _is_async_func(func): + if getattr(func, '__code__', None): + return iscoroutinefunction(func) + else: + return False + + +def _is_instance_mock(obj): + # can't use isinstance on Mock objects because they override __class__ + # The base class for all mocks is NonCallableMock + return issubclass(type(obj), NonCallableMock) + + +def _is_exception(obj): + return ( + isinstance(obj, BaseException) or + isinstance(obj, type) and issubclass(obj, BaseException) + ) + + +def _extract_mock(obj): + # Autospecced functions will return a FunctionType with "mock" attribute + # which is the actual mock object that needs to be used. + if isinstance(obj, FunctionTypes) and hasattr(obj, 'mock'): + return obj.mock + else: + return obj + + +def _get_signature_object(func, as_instance, eat_self): + """ + Given an arbitrary, possibly callable object, try to create a suitable + signature object. + Return a (reduced func, signature) tuple, or None. + """ + if isinstance(func, type) and not as_instance: + # If it's a type and should be modelled as a type, use __init__. + func = func.__init__ + # Skip the `self` argument in __init__ + eat_self = True + elif isinstance(func, (classmethod, staticmethod)): + if isinstance(func, classmethod): + # Skip the `cls` argument of a class method + eat_self = True + # Use the original decorated method to extract the correct function signature + func = func.__func__ + elif not isinstance(func, FunctionTypes): + # If we really want to model an instance of the passed type, + # __call__ should be looked up, not __init__. + try: + func = func.__call__ + except AttributeError: + return None + if eat_self: + sig_func = partial(func, None) + else: + sig_func = func + try: + return func, inspect.signature(sig_func) + except ValueError: + # Certain callable types are not supported by inspect.signature() + return None + + +def _check_signature(func, mock, skipfirst, instance=False): + sig = _get_signature_object(func, instance, skipfirst) + if sig is None: + return + func, sig = sig + def checksig(self, /, *args, **kwargs): + sig.bind(*args, **kwargs) + _copy_func_details(func, checksig) + type(mock)._mock_check_sig = checksig + type(mock).__signature__ = sig + + +def _copy_func_details(func, funcopy): + # we explicitly don't copy func.__dict__ into this copy as it would + # expose original attributes that should be mocked + for attribute in ( + '__name__', '__doc__', '__text_signature__', + '__module__', '__defaults__', '__kwdefaults__', + ): + try: + setattr(funcopy, attribute, getattr(func, attribute)) + except AttributeError: + pass + + +def _callable(obj): + if isinstance(obj, type): + return True + if isinstance(obj, (staticmethod, classmethod, MethodType)): + return _callable(obj.__func__) + if getattr(obj, '__call__', None) is not None: + return True + return False + + +def _is_list(obj): + # checks for list or tuples + # XXXX badly named! + return type(obj) in (list, tuple) + + +def _instance_callable(obj): + """Given an object, return True if the object is callable. + For classes, return True if instances would be callable.""" + if not isinstance(obj, type): + # already an instance + return getattr(obj, '__call__', None) is not None + + # *could* be broken by a class overriding __mro__ or __dict__ via + # a metaclass + for base in (obj,) + obj.__mro__: + if base.__dict__.get('__call__') is not None: + return True + return False + + +def _set_signature(mock, original, instance=False): + # creates a function with signature (*args, **kwargs) that delegates to a + # mock. It still does signature checking by calling a lambda with the same + # signature as the original. + + skipfirst = isinstance(original, type) + result = _get_signature_object(original, instance, skipfirst) + if result is None: + return mock + func, sig = result + def checksig(*args, **kwargs): + sig.bind(*args, **kwargs) + _copy_func_details(func, checksig) + + name = original.__name__ + if not name.isidentifier(): + name = 'funcopy' + context = {'_checksig_': checksig, 'mock': mock} + src = """def %s(*args, **kwargs): + _checksig_(*args, **kwargs) + return mock(*args, **kwargs)""" % name + exec (src, context) + funcopy = context[name] + _setup_func(funcopy, mock, sig) + return funcopy + + +def _setup_func(funcopy, mock, sig): + funcopy.mock = mock + + def assert_called_with(*args, **kwargs): + return mock.assert_called_with(*args, **kwargs) + def assert_called(*args, **kwargs): + return mock.assert_called(*args, **kwargs) + def assert_not_called(*args, **kwargs): + return mock.assert_not_called(*args, **kwargs) + def assert_called_once(*args, **kwargs): + return mock.assert_called_once(*args, **kwargs) + def assert_called_once_with(*args, **kwargs): + return mock.assert_called_once_with(*args, **kwargs) + def assert_has_calls(*args, **kwargs): + return mock.assert_has_calls(*args, **kwargs) + def assert_any_call(*args, **kwargs): + return mock.assert_any_call(*args, **kwargs) + def reset_mock(): + funcopy.method_calls = _CallList() + funcopy.mock_calls = _CallList() + mock.reset_mock() + ret = funcopy.return_value + if _is_instance_mock(ret) and not ret is mock: + ret.reset_mock() + + funcopy.called = False + funcopy.call_count = 0 + funcopy.call_args = None + funcopy.call_args_list = _CallList() + funcopy.method_calls = _CallList() + funcopy.mock_calls = _CallList() + + funcopy.return_value = mock.return_value + funcopy.side_effect = mock.side_effect + funcopy._mock_children = mock._mock_children + + funcopy.assert_called_with = assert_called_with + funcopy.assert_called_once_with = assert_called_once_with + funcopy.assert_has_calls = assert_has_calls + funcopy.assert_any_call = assert_any_call + funcopy.reset_mock = reset_mock + funcopy.assert_called = assert_called + funcopy.assert_not_called = assert_not_called + funcopy.assert_called_once = assert_called_once + funcopy.__signature__ = sig + + mock._mock_delegate = funcopy + + +def _setup_async_mock(mock): + mock._is_coroutine = asyncio.coroutines._is_coroutine + mock.await_count = 0 + mock.await_args = None + mock.await_args_list = _CallList() + + # Mock is not configured yet so the attributes are set + # to a function and then the corresponding mock helper function + # is called when the helper is accessed similar to _setup_func. + def wrapper(attr, /, *args, **kwargs): + return getattr(mock.mock, attr)(*args, **kwargs) + + for attribute in ('assert_awaited', + 'assert_awaited_once', + 'assert_awaited_with', + 'assert_awaited_once_with', + 'assert_any_await', + 'assert_has_awaits', + 'assert_not_awaited'): + + # setattr(mock, attribute, wrapper) causes late binding + # hence attribute will always be the last value in the loop + # Use partial(wrapper, attribute) to ensure the attribute is bound + # correctly. + setattr(mock, attribute, partial(wrapper, attribute)) + + +def _is_magic(name): + return '__%s__' % name[2:-2] == name + + +class _SentinelObject(object): + "A unique, named, sentinel object." + def __init__(self, name): + self.name = name + + def __repr__(self): + return 'sentinel.%s' % self.name + + def __reduce__(self): + return 'sentinel.%s' % self.name + + +class _Sentinel(object): + """Access attributes to return a named object, usable as a sentinel.""" + def __init__(self): + self._sentinels = {} + + def __getattr__(self, name): + if name == '__bases__': + # Without this help(unittest.mock) raises an exception + raise AttributeError + return self._sentinels.setdefault(name, _SentinelObject(name)) + + def __reduce__(self): + return 'sentinel' + + +sentinel = _Sentinel() + +DEFAULT = sentinel.DEFAULT +_missing = sentinel.MISSING +_deleted = sentinel.DELETED + + +_allowed_names = { + 'return_value', '_mock_return_value', 'side_effect', + '_mock_side_effect', '_mock_parent', '_mock_new_parent', + '_mock_name', '_mock_new_name' +} + + +def _delegating_property(name): + _allowed_names.add(name) + _the_name = '_mock_' + name + def _get(self, name=name, _the_name=_the_name): + sig = self._mock_delegate + if sig is None: + return getattr(self, _the_name) + return getattr(sig, name) + def _set(self, value, name=name, _the_name=_the_name): + sig = self._mock_delegate + if sig is None: + self.__dict__[_the_name] = value + else: + setattr(sig, name, value) + + return property(_get, _set) + + + +class _CallList(list): + + def __contains__(self, value): + if not isinstance(value, list): + return list.__contains__(self, value) + len_value = len(value) + len_self = len(self) + if len_value > len_self: + return False + + for i in range(0, len_self - len_value + 1): + sub_list = self[i:i+len_value] + if sub_list == value: + return True + return False + + def __repr__(self): + return pprint.pformat(list(self)) + + +def _check_and_set_parent(parent, value, name, new_name): + value = _extract_mock(value) + + if not _is_instance_mock(value): + return False + if ((value._mock_name or value._mock_new_name) or + (value._mock_parent is not None) or + (value._mock_new_parent is not None)): + return False + + _parent = parent + while _parent is not None: + # setting a mock (value) as a child or return value of itself + # should not modify the mock + if _parent is value: + return False + _parent = _parent._mock_new_parent + + if new_name: + value._mock_new_parent = parent + value._mock_new_name = new_name + if name: + value._mock_parent = parent + value._mock_name = name + return True + +# Internal class to identify if we wrapped an iterator object or not. +class _MockIter(object): + def __init__(self, obj): + self.obj = iter(obj) + def __next__(self): + return next(self.obj) + +class Base(object): + _mock_return_value = DEFAULT + _mock_side_effect = None + def __init__(self, /, *args, **kwargs): + pass + + + +class NonCallableMock(Base): + """A non-callable version of `Mock`""" + + # Store a mutex as a class attribute in order to protect concurrent access + # to mock attributes. Using a class attribute allows all NonCallableMock + # instances to share the mutex for simplicity. + # + # See https://github.com/python/cpython/issues/98624 for why this is + # necessary. + _lock = RLock() + + def __new__(cls, /, *args, **kw): + # every instance has its own class + # so we can create magic methods on the + # class without stomping on other mocks + bases = (cls,) + if not issubclass(cls, AsyncMockMixin): + # Check if spec is an async object or function + bound_args = _MOCK_SIG.bind_partial(cls, *args, **kw).arguments + spec_arg = bound_args.get('spec_set', bound_args.get('spec')) + if spec_arg is not None and _is_async_obj(spec_arg): + bases = (AsyncMockMixin, cls) + new = type(cls.__name__, bases, {'__doc__': cls.__doc__}) + instance = _safe_super(NonCallableMock, cls).__new__(new) + return instance + + + def __init__( + self, spec=None, wraps=None, name=None, spec_set=None, + parent=None, _spec_state=None, _new_name='', _new_parent=None, + _spec_as_instance=False, _eat_self=None, unsafe=False, **kwargs + ): + if _new_parent is None: + _new_parent = parent + + __dict__ = self.__dict__ + __dict__['_mock_parent'] = parent + __dict__['_mock_name'] = name + __dict__['_mock_new_name'] = _new_name + __dict__['_mock_new_parent'] = _new_parent + __dict__['_mock_sealed'] = False + + if spec_set is not None: + spec = spec_set + spec_set = True + if _eat_self is None: + _eat_self = parent is not None + + self._mock_add_spec(spec, spec_set, _spec_as_instance, _eat_self) + + __dict__['_mock_children'] = {} + __dict__['_mock_wraps'] = wraps + __dict__['_mock_delegate'] = None + + __dict__['_mock_called'] = False + __dict__['_mock_call_args'] = None + __dict__['_mock_call_count'] = 0 + __dict__['_mock_call_args_list'] = _CallList() + __dict__['_mock_mock_calls'] = _CallList() + + __dict__['method_calls'] = _CallList() + __dict__['_mock_unsafe'] = unsafe + + if kwargs: + self.configure_mock(**kwargs) + + _safe_super(NonCallableMock, self).__init__( + spec, wraps, name, spec_set, parent, + _spec_state + ) + + + def attach_mock(self, mock, attribute): + """ + Attach a mock as an attribute of this one, replacing its name and + parent. Calls to the attached mock will be recorded in the + `method_calls` and `mock_calls` attributes of this one.""" + inner_mock = _extract_mock(mock) + + inner_mock._mock_parent = None + inner_mock._mock_new_parent = None + inner_mock._mock_name = '' + inner_mock._mock_new_name = None + + setattr(self, attribute, mock) + + + def mock_add_spec(self, spec, spec_set=False): + """Add a spec to a mock. `spec` can either be an object or a + list of strings. Only attributes on the `spec` can be fetched as + attributes from the mock. + + If `spec_set` is True then only attributes on the spec can be set.""" + self._mock_add_spec(spec, spec_set) + + + def _mock_add_spec(self, spec, spec_set, _spec_as_instance=False, + _eat_self=False): + if _is_instance_mock(spec): + raise InvalidSpecError(f'Cannot spec a Mock object. [object={spec!r}]') + + _spec_class = None + _spec_signature = None + _spec_asyncs = [] + + for attr in dir(spec): + if iscoroutinefunction(getattr(spec, attr, None)): + _spec_asyncs.append(attr) + + if spec is not None and not _is_list(spec): + if isinstance(spec, type): + _spec_class = spec + else: + _spec_class = type(spec) + res = _get_signature_object(spec, + _spec_as_instance, _eat_self) + _spec_signature = res and res[1] + + spec = dir(spec) + + __dict__ = self.__dict__ + __dict__['_spec_class'] = _spec_class + __dict__['_spec_set'] = spec_set + __dict__['_spec_signature'] = _spec_signature + __dict__['_mock_methods'] = spec + __dict__['_spec_asyncs'] = _spec_asyncs + + def __get_return_value(self): + ret = self._mock_return_value + if self._mock_delegate is not None: + ret = self._mock_delegate.return_value + + if ret is DEFAULT and self._mock_wraps is None: + ret = self._get_child_mock( + _new_parent=self, _new_name='()' + ) + self.return_value = ret + return ret + + + def __set_return_value(self, value): + if self._mock_delegate is not None: + self._mock_delegate.return_value = value + else: + self._mock_return_value = value + _check_and_set_parent(self, value, None, '()') + + __return_value_doc = "The value to be returned when the mock is called." + return_value = property(__get_return_value, __set_return_value, + __return_value_doc) + + + @property + def __class__(self): + if self._spec_class is None: + return type(self) + return self._spec_class + + called = _delegating_property('called') + call_count = _delegating_property('call_count') + call_args = _delegating_property('call_args') + call_args_list = _delegating_property('call_args_list') + mock_calls = _delegating_property('mock_calls') + + + def __get_side_effect(self): + delegated = self._mock_delegate + if delegated is None: + return self._mock_side_effect + sf = delegated.side_effect + if (sf is not None and not callable(sf) + and not isinstance(sf, _MockIter) and not _is_exception(sf)): + sf = _MockIter(sf) + delegated.side_effect = sf + return sf + + def __set_side_effect(self, value): + value = _try_iter(value) + delegated = self._mock_delegate + if delegated is None: + self._mock_side_effect = value + else: + delegated.side_effect = value + + side_effect = property(__get_side_effect, __set_side_effect) + + + def reset_mock(self, visited=None,*, return_value=False, side_effect=False): + "Restore the mock object to its initial state." + if visited is None: + visited = [] + if id(self) in visited: + return + visited.append(id(self)) + + self.called = False + self.call_args = None + self.call_count = 0 + self.mock_calls = _CallList() + self.call_args_list = _CallList() + self.method_calls = _CallList() + + if return_value: + self._mock_return_value = DEFAULT + if side_effect: + self._mock_side_effect = None + + for child in self._mock_children.values(): + if isinstance(child, _SpecState) or child is _deleted: + continue + child.reset_mock(visited, return_value=return_value, side_effect=side_effect) + + ret = self._mock_return_value + if _is_instance_mock(ret) and ret is not self: + ret.reset_mock(visited) + + + def configure_mock(self, /, **kwargs): + """Set attributes on the mock through keyword arguments. + + Attributes plus return values and side effects can be set on child + mocks using standard dot notation and unpacking a dictionary in the + method call: + + >>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError} + >>> mock.configure_mock(**attrs)""" + for arg, val in sorted(kwargs.items(), + # we sort on the number of dots so that + # attributes are set before we set attributes on + # attributes + key=lambda entry: entry[0].count('.')): + args = arg.split('.') + final = args.pop() + obj = self + for entry in args: + obj = getattr(obj, entry) + setattr(obj, final, val) + + + def __getattr__(self, name): + if name in {'_mock_methods', '_mock_unsafe'}: + raise AttributeError(name) + elif self._mock_methods is not None: + if name not in self._mock_methods or name in _all_magics: + raise AttributeError("Mock object has no attribute %r" % name) + elif _is_magic(name): + raise AttributeError(name) + if not self._mock_unsafe and (not self._mock_methods or name not in self._mock_methods): + if name.startswith(('assert', 'assret', 'asert', 'aseert', 'assrt')): + raise AttributeError( + f"{name!r} is not a valid assertion. Use a spec " + f"for the mock if {name!r} is meant to be an attribute.") + + with NonCallableMock._lock: + result = self._mock_children.get(name) + if result is _deleted: + raise AttributeError(name) + elif result is None: + wraps = None + if self._mock_wraps is not None: + # XXXX should we get the attribute without triggering code + # execution? + wraps = getattr(self._mock_wraps, name) + + result = self._get_child_mock( + parent=self, name=name, wraps=wraps, _new_name=name, + _new_parent=self + ) + self._mock_children[name] = result + + elif isinstance(result, _SpecState): + try: + result = create_autospec( + result.spec, result.spec_set, result.instance, + result.parent, result.name + ) + except InvalidSpecError: + target_name = self.__dict__['_mock_name'] or self + raise InvalidSpecError( + f'Cannot autospec attr {name!r} from target ' + f'{target_name!r} as it has already been mocked out. ' + f'[target={self!r}, attr={result.spec!r}]') + self._mock_children[name] = result + + return result + + + def _extract_mock_name(self): + _name_list = [self._mock_new_name] + _parent = self._mock_new_parent + last = self + + dot = '.' + if _name_list == ['()']: + dot = '' + + while _parent is not None: + last = _parent + + _name_list.append(_parent._mock_new_name + dot) + dot = '.' + if _parent._mock_new_name == '()': + dot = '' + + _parent = _parent._mock_new_parent + + _name_list = list(reversed(_name_list)) + _first = last._mock_name or 'mock' + if len(_name_list) > 1: + if _name_list[1] not in ('()', '().'): + _first += '.' + _name_list[0] = _first + return ''.join(_name_list) + + def __repr__(self): + name = self._extract_mock_name() + + name_string = '' + if name not in ('mock', 'mock.'): + name_string = ' name=%r' % name + + spec_string = '' + if self._spec_class is not None: + spec_string = ' spec=%r' + if self._spec_set: + spec_string = ' spec_set=%r' + spec_string = spec_string % self._spec_class.__name__ + return "<%s%s%s id='%s'>" % ( + type(self).__name__, + name_string, + spec_string, + id(self) + ) + + + def __dir__(self): + """Filter the output of `dir(mock)` to only useful members.""" + if not FILTER_DIR: + return object.__dir__(self) + + extras = self._mock_methods or [] + from_type = dir(type(self)) + from_dict = list(self.__dict__) + from_child_mocks = [ + m_name for m_name, m_value in self._mock_children.items() + if m_value is not _deleted] + + from_type = [e for e in from_type if not e.startswith('_')] + from_dict = [e for e in from_dict if not e.startswith('_') or + _is_magic(e)] + return sorted(set(extras + from_type + from_dict + from_child_mocks)) + + + def __setattr__(self, name, value): + if name in _allowed_names: + # property setters go through here + return object.__setattr__(self, name, value) + elif (self._spec_set and self._mock_methods is not None and + name not in self._mock_methods and + name not in self.__dict__): + raise AttributeError("Mock object has no attribute '%s'" % name) + elif name in _unsupported_magics: + msg = 'Attempting to set unsupported magic method %r.' % name + raise AttributeError(msg) + elif name in _all_magics: + if self._mock_methods is not None and name not in self._mock_methods: + raise AttributeError("Mock object has no attribute '%s'" % name) + + if not _is_instance_mock(value): + setattr(type(self), name, _get_method(name, value)) + original = value + value = lambda *args, **kw: original(self, *args, **kw) + else: + # only set _new_name and not name so that mock_calls is tracked + # but not method calls + _check_and_set_parent(self, value, None, name) + setattr(type(self), name, value) + self._mock_children[name] = value + elif name == '__class__': + self._spec_class = value + return + else: + if _check_and_set_parent(self, value, name, name): + self._mock_children[name] = value + + if self._mock_sealed and not hasattr(self, name): + mock_name = f'{self._extract_mock_name()}.{name}' + raise AttributeError(f'Cannot set {mock_name}') + + return object.__setattr__(self, name, value) + + + def __delattr__(self, name): + if name in _all_magics and name in type(self).__dict__: + delattr(type(self), name) + if name not in self.__dict__: + # for magic methods that are still MagicProxy objects and + # not set on the instance itself + return + + obj = self._mock_children.get(name, _missing) + if name in self.__dict__: + _safe_super(NonCallableMock, self).__delattr__(name) + elif obj is _deleted: + raise AttributeError(name) + if obj is not _missing: + del self._mock_children[name] + self._mock_children[name] = _deleted + + + def _format_mock_call_signature(self, args, kwargs): + name = self._mock_name or 'mock' + return _format_call_signature(name, args, kwargs) + + + def _format_mock_failure_message(self, args, kwargs, action='call'): + message = 'expected %s not found.\nExpected: %s\n Actual: %s' + expected_string = self._format_mock_call_signature(args, kwargs) + call_args = self.call_args + actual_string = self._format_mock_call_signature(*call_args) + return message % (action, expected_string, actual_string) + + + def _get_call_signature_from_name(self, name): + """ + * If call objects are asserted against a method/function like obj.meth1 + then there could be no name for the call object to lookup. Hence just + return the spec_signature of the method/function being asserted against. + * If the name is not empty then remove () and split by '.' to get + list of names to iterate through the children until a potential + match is found. A child mock is created only during attribute access + so if we get a _SpecState then no attributes of the spec were accessed + and can be safely exited. + """ + if not name: + return self._spec_signature + + sig = None + names = name.replace('()', '').split('.') + children = self._mock_children + + for name in names: + child = children.get(name) + if child is None or isinstance(child, _SpecState): + break + else: + # If an autospecced object is attached using attach_mock the + # child would be a function with mock object as attribute from + # which signature has to be derived. + child = _extract_mock(child) + children = child._mock_children + sig = child._spec_signature + + return sig + + + def _call_matcher(self, _call): + """ + Given a call (or simply an (args, kwargs) tuple), return a + comparison key suitable for matching with other calls. + This is a best effort method which relies on the spec's signature, + if available, or falls back on the arguments themselves. + """ + + if isinstance(_call, tuple) and len(_call) > 2: + sig = self._get_call_signature_from_name(_call[0]) + else: + sig = self._spec_signature + + if sig is not None: + if len(_call) == 2: + name = '' + args, kwargs = _call + else: + name, args, kwargs = _call + try: + bound_call = sig.bind(*args, **kwargs) + return call(name, bound_call.args, bound_call.kwargs) + except TypeError as e: + return e.with_traceback(None) + else: + return _call + + def assert_not_called(self): + """assert that the mock was never called. + """ + if self.call_count != 0: + msg = ("Expected '%s' to not have been called. Called %s times.%s" + % (self._mock_name or 'mock', + self.call_count, + self._calls_repr())) + raise AssertionError(msg) + + def assert_called(self): + """assert that the mock was called at least once + """ + if self.call_count == 0: + msg = ("Expected '%s' to have been called." % + (self._mock_name or 'mock')) + raise AssertionError(msg) + + def assert_called_once(self): + """assert that the mock was called only once. + """ + if not self.call_count == 1: + msg = ("Expected '%s' to have been called once. Called %s times.%s" + % (self._mock_name or 'mock', + self.call_count, + self._calls_repr())) + raise AssertionError(msg) + + def assert_called_with(self, /, *args, **kwargs): + """assert that the last call was made with the specified arguments. + + Raises an AssertionError if the args and keyword args passed in are + different to the last call to the mock.""" + if self.call_args is None: + expected = self._format_mock_call_signature(args, kwargs) + actual = 'not called.' + error_message = ('expected call not found.\nExpected: %s\n Actual: %s' + % (expected, actual)) + raise AssertionError(error_message) + + def _error_message(): + msg = self._format_mock_failure_message(args, kwargs) + return msg + expected = self._call_matcher(_Call((args, kwargs), two=True)) + actual = self._call_matcher(self.call_args) + if actual != expected: + cause = expected if isinstance(expected, Exception) else None + raise AssertionError(_error_message()) from cause + + + def assert_called_once_with(self, /, *args, **kwargs): + """assert that the mock was called exactly once and that that call was + with the specified arguments.""" + if not self.call_count == 1: + msg = ("Expected '%s' to be called once. Called %s times.%s" + % (self._mock_name or 'mock', + self.call_count, + self._calls_repr())) + raise AssertionError(msg) + return self.assert_called_with(*args, **kwargs) + + + def assert_has_calls(self, calls, any_order=False): + """assert the mock has been called with the specified calls. + The `mock_calls` list is checked for the calls. + + If `any_order` is False (the default) then the calls must be + sequential. There can be extra calls before or after the + specified calls. + + If `any_order` is True then the calls can be in any order, but + they must all appear in `mock_calls`.""" + expected = [self._call_matcher(c) for c in calls] + cause = next((e for e in expected if isinstance(e, Exception)), None) + all_calls = _CallList(self._call_matcher(c) for c in self.mock_calls) + if not any_order: + if expected not in all_calls: + if cause is None: + problem = 'Calls not found.' + else: + problem = ('Error processing expected calls.\n' + 'Errors: {}').format( + [e if isinstance(e, Exception) else None + for e in expected]) + raise AssertionError( + f'{problem}\n' + f'Expected: {_CallList(calls)}' + f'{self._calls_repr(prefix=" Actual").rstrip(".")}' + ) from cause + return + + all_calls = list(all_calls) + + not_found = [] + for kall in expected: + try: + all_calls.remove(kall) + except ValueError: + not_found.append(kall) + if not_found: + raise AssertionError( + '%r does not contain all of %r in its call list, ' + 'found %r instead' % (self._mock_name or 'mock', + tuple(not_found), all_calls) + ) from cause + + + def assert_any_call(self, /, *args, **kwargs): + """assert the mock has been called with the specified arguments. + + The assert passes if the mock has *ever* been called, unlike + `assert_called_with` and `assert_called_once_with` that only pass if + the call is the most recent one.""" + expected = self._call_matcher(_Call((args, kwargs), two=True)) + cause = expected if isinstance(expected, Exception) else None + actual = [self._call_matcher(c) for c in self.call_args_list] + if cause or expected not in _AnyComparer(actual): + expected_string = self._format_mock_call_signature(args, kwargs) + raise AssertionError( + '%s call not found' % expected_string + ) from cause + + + def _get_child_mock(self, /, **kw): + """Create the child mocks for attributes and return value. + By default child mocks will be the same type as the parent. + Subclasses of Mock may want to override this to customize the way + child mocks are made. + + For non-callable mocks the callable variant will be used (rather than + any custom subclass).""" + if self._mock_sealed: + attribute = f".{kw['name']}" if "name" in kw else "()" + mock_name = self._extract_mock_name() + attribute + raise AttributeError(mock_name) + + _new_name = kw.get("_new_name") + if _new_name in self.__dict__['_spec_asyncs']: + return AsyncMock(**kw) + + _type = type(self) + if issubclass(_type, MagicMock) and _new_name in _async_method_magics: + # Any asynchronous magic becomes an AsyncMock + klass = AsyncMock + elif issubclass(_type, AsyncMockMixin): + if (_new_name in _all_sync_magics or + self._mock_methods and _new_name in self._mock_methods): + # Any synchronous method on AsyncMock becomes a MagicMock + klass = MagicMock + else: + klass = AsyncMock + elif not issubclass(_type, CallableMixin): + if issubclass(_type, NonCallableMagicMock): + klass = MagicMock + elif issubclass(_type, NonCallableMock): + klass = Mock + else: + klass = _type.__mro__[1] + return klass(**kw) + + + def _calls_repr(self, prefix="Calls"): + """Renders self.mock_calls as a string. + + Example: "\nCalls: [call(1), call(2)]." + + If self.mock_calls is empty, an empty string is returned. The + output will be truncated if very long. + """ + if not self.mock_calls: + return "" + return f"\n{prefix}: {safe_repr(self.mock_calls)}." + + +_MOCK_SIG = inspect.signature(NonCallableMock.__init__) + + +class _AnyComparer(list): + """A list which checks if it contains a call which may have an + argument of ANY, flipping the components of item and self from + their traditional locations so that ANY is guaranteed to be on + the left.""" + def __contains__(self, item): + for _call in self: + assert len(item) == len(_call) + if all([ + expected == actual + for expected, actual in zip(item, _call) + ]): + return True + return False + + +def _try_iter(obj): + if obj is None: + return obj + if _is_exception(obj): + return obj + if _callable(obj): + return obj + try: + return iter(obj) + except TypeError: + # XXXX backwards compatibility + # but this will blow up on first call - so maybe we should fail early? + return obj + + +class CallableMixin(Base): + + def __init__(self, spec=None, side_effect=None, return_value=DEFAULT, + wraps=None, name=None, spec_set=None, parent=None, + _spec_state=None, _new_name='', _new_parent=None, **kwargs): + self.__dict__['_mock_return_value'] = return_value + _safe_super(CallableMixin, self).__init__( + spec, wraps, name, spec_set, parent, + _spec_state, _new_name, _new_parent, **kwargs + ) + + self.side_effect = side_effect + + + def _mock_check_sig(self, /, *args, **kwargs): + # stub method that can be replaced with one with a specific signature + pass + + + def __call__(self, /, *args, **kwargs): + # can't use self in-case a function / method we are mocking uses self + # in the signature + self._mock_check_sig(*args, **kwargs) + self._increment_mock_call(*args, **kwargs) + return self._mock_call(*args, **kwargs) + + + def _mock_call(self, /, *args, **kwargs): + return self._execute_mock_call(*args, **kwargs) + + def _increment_mock_call(self, /, *args, **kwargs): + self.called = True + self.call_count += 1 + + # handle call_args + # needs to be set here so assertions on call arguments pass before + # execution in the case of awaited calls + _call = _Call((args, kwargs), two=True) + self.call_args = _call + self.call_args_list.append(_call) + + # initial stuff for method_calls: + do_method_calls = self._mock_parent is not None + method_call_name = self._mock_name + + # initial stuff for mock_calls: + mock_call_name = self._mock_new_name + is_a_call = mock_call_name == '()' + self.mock_calls.append(_Call(('', args, kwargs))) + + # follow up the chain of mocks: + _new_parent = self._mock_new_parent + while _new_parent is not None: + + # handle method_calls: + if do_method_calls: + _new_parent.method_calls.append(_Call((method_call_name, args, kwargs))) + do_method_calls = _new_parent._mock_parent is not None + if do_method_calls: + method_call_name = _new_parent._mock_name + '.' + method_call_name + + # handle mock_calls: + this_mock_call = _Call((mock_call_name, args, kwargs)) + _new_parent.mock_calls.append(this_mock_call) + + if _new_parent._mock_new_name: + if is_a_call: + dot = '' + else: + dot = '.' + is_a_call = _new_parent._mock_new_name == '()' + mock_call_name = _new_parent._mock_new_name + dot + mock_call_name + + # follow the parental chain: + _new_parent = _new_parent._mock_new_parent + + def _execute_mock_call(self, /, *args, **kwargs): + # separate from _increment_mock_call so that awaited functions are + # executed separately from their call, also AsyncMock overrides this method + + effect = self.side_effect + if effect is not None: + if _is_exception(effect): + raise effect + elif not _callable(effect): + result = next(effect) + if _is_exception(result): + raise result + else: + result = effect(*args, **kwargs) + + if result is not DEFAULT: + return result + + if self._mock_return_value is not DEFAULT: + return self.return_value + + if self._mock_delegate and self._mock_delegate.return_value is not DEFAULT: + return self.return_value + + if self._mock_wraps is not None: + return self._mock_wraps(*args, **kwargs) + + return self.return_value + + + +class Mock(CallableMixin, NonCallableMock): + """ + Create a new `Mock` object. `Mock` takes several optional arguments + that specify the behaviour of the Mock object: + + * `spec`: This can be either a list of strings or an existing object (a + class or instance) that acts as the specification for the mock object. If + you pass in an object then a list of strings is formed by calling dir on + the object (excluding unsupported magic attributes and methods). Accessing + any attribute not in this list will raise an `AttributeError`. + + If `spec` is an object (rather than a list of strings) then + `mock.__class__` returns the class of the spec object. This allows mocks + to pass `isinstance` tests. + + * `spec_set`: A stricter variant of `spec`. If used, attempting to *set* + or get an attribute on the mock that isn't on the object passed as + `spec_set` will raise an `AttributeError`. + + * `side_effect`: A function to be called whenever the Mock is called. See + the `side_effect` attribute. Useful for raising exceptions or + dynamically changing return values. The function is called with the same + arguments as the mock, and unless it returns `DEFAULT`, the return + value of this function is used as the return value. + + If `side_effect` is an iterable then each call to the mock will return + the next value from the iterable. If any of the members of the iterable + are exceptions they will be raised instead of returned. + + * `return_value`: The value returned when the mock is called. By default + this is a new Mock (created on first access). See the + `return_value` attribute. + + * `unsafe`: By default, accessing any attribute whose name starts with + *assert*, *assret*, *asert*, *aseert* or *assrt* will raise an + AttributeError. Passing `unsafe=True` will allow access to + these attributes. + + * `wraps`: Item for the mock object to wrap. If `wraps` is not None then + calling the Mock will pass the call through to the wrapped object + (returning the real result). Attribute access on the mock will return a + Mock object that wraps the corresponding attribute of the wrapped object + (so attempting to access an attribute that doesn't exist will raise an + `AttributeError`). + + If the mock has an explicit `return_value` set then calls are not passed + to the wrapped object and the `return_value` is returned instead. + + * `name`: If the mock has a name then it will be used in the repr of the + mock. This can be useful for debugging. The name is propagated to child + mocks. + + Mocks can also be called with arbitrary keyword arguments. These will be + used to set attributes on the mock after it is created. + """ + + +# _check_spec_arg_typos takes kwargs from commands like patch and checks that +# they don't contain common misspellings of arguments related to autospeccing. +def _check_spec_arg_typos(kwargs_to_check): + typos = ("autospect", "auto_spec", "set_spec") + for typo in typos: + if typo in kwargs_to_check: + raise RuntimeError( + f"{typo!r} might be a typo; use unsafe=True if this is intended" + ) + + +class _patch(object): + + attribute_name = None + _active_patches = [] + + def __init__( + self, getter, attribute, new, spec, create, + spec_set, autospec, new_callable, kwargs, *, unsafe=False + ): + if new_callable is not None: + if new is not DEFAULT: + raise ValueError( + "Cannot use 'new' and 'new_callable' together" + ) + if autospec is not None: + raise ValueError( + "Cannot use 'autospec' and 'new_callable' together" + ) + if not unsafe: + _check_spec_arg_typos(kwargs) + if _is_instance_mock(spec): + raise InvalidSpecError( + f'Cannot spec attr {attribute!r} as the spec ' + f'has already been mocked out. [spec={spec!r}]') + if _is_instance_mock(spec_set): + raise InvalidSpecError( + f'Cannot spec attr {attribute!r} as the spec_set ' + f'target has already been mocked out. [spec_set={spec_set!r}]') + + self.getter = getter + self.attribute = attribute + self.new = new + self.new_callable = new_callable + self.spec = spec + self.create = create + self.has_local = False + self.spec_set = spec_set + self.autospec = autospec + self.kwargs = kwargs + self.additional_patchers = [] + + + def copy(self): + patcher = _patch( + self.getter, self.attribute, self.new, self.spec, + self.create, self.spec_set, + self.autospec, self.new_callable, self.kwargs + ) + patcher.attribute_name = self.attribute_name + patcher.additional_patchers = [ + p.copy() for p in self.additional_patchers + ] + return patcher + + + def __call__(self, func): + if isinstance(func, type): + return self.decorate_class(func) + if inspect.iscoroutinefunction(func): + return self.decorate_async_callable(func) + return self.decorate_callable(func) + + + def decorate_class(self, klass): + for attr in dir(klass): + if not attr.startswith(patch.TEST_PREFIX): + continue + + attr_value = getattr(klass, attr) + if not hasattr(attr_value, "__call__"): + continue + + patcher = self.copy() + setattr(klass, attr, patcher(attr_value)) + return klass + + + @contextlib.contextmanager + def decoration_helper(self, patched, args, keywargs): + extra_args = [] + with contextlib.ExitStack() as exit_stack: + for patching in patched.patchings: + arg = exit_stack.enter_context(patching) + if patching.attribute_name is not None: + keywargs.update(arg) + elif patching.new is DEFAULT: + extra_args.append(arg) + + args += tuple(extra_args) + yield (args, keywargs) + + + def decorate_callable(self, func): + # NB. Keep the method in sync with decorate_async_callable() + if hasattr(func, 'patchings'): + func.patchings.append(self) + return func + + @wraps(func) + def patched(*args, **keywargs): + with self.decoration_helper(patched, + args, + keywargs) as (newargs, newkeywargs): + return func(*newargs, **newkeywargs) + + patched.patchings = [self] + return patched + + + def decorate_async_callable(self, func): + # NB. Keep the method in sync with decorate_callable() + if hasattr(func, 'patchings'): + func.patchings.append(self) + return func + + @wraps(func) + async def patched(*args, **keywargs): + with self.decoration_helper(patched, + args, + keywargs) as (newargs, newkeywargs): + return await func(*newargs, **newkeywargs) + + patched.patchings = [self] + return patched + + + def get_original(self): + target = self.getter() + name = self.attribute + + original = DEFAULT + local = False + + try: + original = target.__dict__[name] + except (AttributeError, KeyError): + original = getattr(target, name, DEFAULT) + else: + local = True + + if name in _builtins and isinstance(target, ModuleType): + self.create = True + + if not self.create and original is DEFAULT: + raise AttributeError( + "%s does not have the attribute %r" % (target, name) + ) + return original, local + + + def __enter__(self): + """Perform the patch.""" + new, spec, spec_set = self.new, self.spec, self.spec_set + autospec, kwargs = self.autospec, self.kwargs + new_callable = self.new_callable + self.target = self.getter() + + # normalise False to None + if spec is False: + spec = None + if spec_set is False: + spec_set = None + if autospec is False: + autospec = None + + if spec is not None and autospec is not None: + raise TypeError("Can't specify spec and autospec") + if ((spec is not None or autospec is not None) and + spec_set not in (True, None)): + raise TypeError("Can't provide explicit spec_set *and* spec or autospec") + + original, local = self.get_original() + + if new is DEFAULT and autospec is None: + inherit = False + if spec is True: + # set spec to the object we are replacing + spec = original + if spec_set is True: + spec_set = original + spec = None + elif spec is not None: + if spec_set is True: + spec_set = spec + spec = None + elif spec_set is True: + spec_set = original + + if spec is not None or spec_set is not None: + if original is DEFAULT: + raise TypeError("Can't use 'spec' with create=True") + if isinstance(original, type): + # If we're patching out a class and there is a spec + inherit = True + if spec is None and _is_async_obj(original): + Klass = AsyncMock + else: + Klass = MagicMock + _kwargs = {} + if new_callable is not None: + Klass = new_callable + elif spec is not None or spec_set is not None: + this_spec = spec + if spec_set is not None: + this_spec = spec_set + if _is_list(this_spec): + not_callable = '__call__' not in this_spec + else: + not_callable = not callable(this_spec) + if _is_async_obj(this_spec): + Klass = AsyncMock + elif not_callable: + Klass = NonCallableMagicMock + + if spec is not None: + _kwargs['spec'] = spec + if spec_set is not None: + _kwargs['spec_set'] = spec_set + + # add a name to mocks + if (isinstance(Klass, type) and + issubclass(Klass, NonCallableMock) and self.attribute): + _kwargs['name'] = self.attribute + + _kwargs.update(kwargs) + new = Klass(**_kwargs) + + if inherit and _is_instance_mock(new): + # we can only tell if the instance should be callable if the + # spec is not a list + this_spec = spec + if spec_set is not None: + this_spec = spec_set + if (not _is_list(this_spec) and not + _instance_callable(this_spec)): + Klass = NonCallableMagicMock + + _kwargs.pop('name') + new.return_value = Klass(_new_parent=new, _new_name='()', + **_kwargs) + elif autospec is not None: + # spec is ignored, new *must* be default, spec_set is treated + # as a boolean. Should we check spec is not None and that spec_set + # is a bool? + if new is not DEFAULT: + raise TypeError( + "autospec creates the mock for you. Can't specify " + "autospec and new." + ) + if original is DEFAULT: + raise TypeError("Can't use 'autospec' with create=True") + spec_set = bool(spec_set) + if autospec is True: + autospec = original + + if _is_instance_mock(self.target): + raise InvalidSpecError( + f'Cannot autospec attr {self.attribute!r} as the patch ' + f'target has already been mocked out. ' + f'[target={self.target!r}, attr={autospec!r}]') + if _is_instance_mock(autospec): + target_name = getattr(self.target, '__name__', self.target) + raise InvalidSpecError( + f'Cannot autospec attr {self.attribute!r} from target ' + f'{target_name!r} as it has already been mocked out. ' + f'[target={self.target!r}, attr={autospec!r}]') + + new = create_autospec(autospec, spec_set=spec_set, + _name=self.attribute, **kwargs) + elif kwargs: + # can't set keyword args when we aren't creating the mock + # XXXX If new is a Mock we could call new.configure_mock(**kwargs) + raise TypeError("Can't pass kwargs to a mock we aren't creating") + + new_attr = new + + self.temp_original = original + self.is_local = local + self._exit_stack = contextlib.ExitStack() + try: + setattr(self.target, self.attribute, new_attr) + if self.attribute_name is not None: + extra_args = {} + if self.new is DEFAULT: + extra_args[self.attribute_name] = new + for patching in self.additional_patchers: + arg = self._exit_stack.enter_context(patching) + if patching.new is DEFAULT: + extra_args.update(arg) + return extra_args + + return new + except: + if not self.__exit__(*sys.exc_info()): + raise + + def __exit__(self, *exc_info): + """Undo the patch.""" + if self.is_local and self.temp_original is not DEFAULT: + setattr(self.target, self.attribute, self.temp_original) + else: + delattr(self.target, self.attribute) + if not self.create and (not hasattr(self.target, self.attribute) or + self.attribute in ('__doc__', '__module__', + '__defaults__', '__annotations__', + '__kwdefaults__')): + # needed for proxy objects like django settings + setattr(self.target, self.attribute, self.temp_original) + + del self.temp_original + del self.is_local + del self.target + exit_stack = self._exit_stack + del self._exit_stack + return exit_stack.__exit__(*exc_info) + + + def start(self): + """Activate a patch, returning any created mock.""" + result = self.__enter__() + self._active_patches.append(self) + return result + + + def stop(self): + """Stop an active patch.""" + try: + self._active_patches.remove(self) + except ValueError: + # If the patch hasn't been started this will fail + return None + + return self.__exit__(None, None, None) + + + +def _get_target(target): + try: + target, attribute = target.rsplit('.', 1) + except (TypeError, ValueError, AttributeError): + raise TypeError( + f"Need a valid target to patch. You supplied: {target!r}") + return partial(pkgutil.resolve_name, target), attribute + + +def _patch_object( + target, attribute, new=DEFAULT, spec=None, + create=False, spec_set=None, autospec=None, + new_callable=None, *, unsafe=False, **kwargs + ): + """ + patch the named member (`attribute`) on an object (`target`) with a mock + object. + + `patch.object` can be used as a decorator, class decorator or a context + manager. Arguments `new`, `spec`, `create`, `spec_set`, + `autospec` and `new_callable` have the same meaning as for `patch`. Like + `patch`, `patch.object` takes arbitrary keyword arguments for configuring + the mock object it creates. + + When used as a class decorator `patch.object` honours `patch.TEST_PREFIX` + for choosing which methods to wrap. + """ + if type(target) is str: + raise TypeError( + f"{target!r} must be the actual object to be patched, not a str" + ) + getter = lambda: target + return _patch( + getter, attribute, new, spec, create, + spec_set, autospec, new_callable, kwargs, unsafe=unsafe + ) + + +def _patch_multiple(target, spec=None, create=False, spec_set=None, + autospec=None, new_callable=None, **kwargs): + """Perform multiple patches in a single call. It takes the object to be + patched (either as an object or a string to fetch the object by importing) + and keyword arguments for the patches:: + + with patch.multiple(settings, FIRST_PATCH='one', SECOND_PATCH='two'): + ... + + Use `DEFAULT` as the value if you want `patch.multiple` to create + mocks for you. In this case the created mocks are passed into a decorated + function by keyword, and a dictionary is returned when `patch.multiple` is + used as a context manager. + + `patch.multiple` can be used as a decorator, class decorator or a context + manager. The arguments `spec`, `spec_set`, `create`, + `autospec` and `new_callable` have the same meaning as for `patch`. These + arguments will be applied to *all* patches done by `patch.multiple`. + + When used as a class decorator `patch.multiple` honours `patch.TEST_PREFIX` + for choosing which methods to wrap. + """ + if type(target) is str: + getter = partial(pkgutil.resolve_name, target) + else: + getter = lambda: target + + if not kwargs: + raise ValueError( + 'Must supply at least one keyword argument with patch.multiple' + ) + # need to wrap in a list for python 3, where items is a view + items = list(kwargs.items()) + attribute, new = items[0] + patcher = _patch( + getter, attribute, new, spec, create, spec_set, + autospec, new_callable, {} + ) + patcher.attribute_name = attribute + for attribute, new in items[1:]: + this_patcher = _patch( + getter, attribute, new, spec, create, spec_set, + autospec, new_callable, {} + ) + this_patcher.attribute_name = attribute + patcher.additional_patchers.append(this_patcher) + return patcher + + +def patch( + target, new=DEFAULT, spec=None, create=False, + spec_set=None, autospec=None, new_callable=None, *, unsafe=False, **kwargs + ): + """ + `patch` acts as a function decorator, class decorator or a context + manager. Inside the body of the function or with statement, the `target` + is patched with a `new` object. When the function/with statement exits + the patch is undone. + + If `new` is omitted, then the target is replaced with an + `AsyncMock if the patched object is an async function or a + `MagicMock` otherwise. If `patch` is used as a decorator and `new` is + omitted, the created mock is passed in as an extra argument to the + decorated function. If `patch` is used as a context manager the created + mock is returned by the context manager. + + `target` should be a string in the form `'package.module.ClassName'`. The + `target` is imported and the specified object replaced with the `new` + object, so the `target` must be importable from the environment you are + calling `patch` from. The target is imported when the decorated function + is executed, not at decoration time. + + The `spec` and `spec_set` keyword arguments are passed to the `MagicMock` + if patch is creating one for you. + + In addition you can pass `spec=True` or `spec_set=True`, which causes + patch to pass in the object being mocked as the spec/spec_set object. + + `new_callable` allows you to specify a different class, or callable object, + that will be called to create the `new` object. By default `AsyncMock` is + used for async functions and `MagicMock` for the rest. + + A more powerful form of `spec` is `autospec`. If you set `autospec=True` + then the mock will be created with a spec from the object being replaced. + All attributes of the mock will also have the spec of the corresponding + attribute of the object being replaced. Methods and functions being + mocked will have their arguments checked and will raise a `TypeError` if + they are called with the wrong signature. For mocks replacing a class, + their return value (the 'instance') will have the same spec as the class. + + Instead of `autospec=True` you can pass `autospec=some_object` to use an + arbitrary object as the spec instead of the one being replaced. + + By default `patch` will fail to replace attributes that don't exist. If + you pass in `create=True`, and the attribute doesn't exist, patch will + create the attribute for you when the patched function is called, and + delete it again afterwards. This is useful for writing tests against + attributes that your production code creates at runtime. It is off by + default because it can be dangerous. With it switched on you can write + passing tests against APIs that don't actually exist! + + Patch can be used as a `TestCase` class decorator. It works by + decorating each test method in the class. This reduces the boilerplate + code when your test methods share a common patchings set. `patch` finds + tests by looking for method names that start with `patch.TEST_PREFIX`. + By default this is `test`, which matches the way `unittest` finds tests. + You can specify an alternative prefix by setting `patch.TEST_PREFIX`. + + Patch can be used as a context manager, with the with statement. Here the + patching applies to the indented block after the with statement. If you + use "as" then the patched object will be bound to the name after the + "as"; very useful if `patch` is creating a mock object for you. + + Patch will raise a `RuntimeError` if passed some common misspellings of + the arguments autospec and spec_set. Pass the argument `unsafe` with the + value True to disable that check. + + `patch` takes arbitrary keyword arguments. These will be passed to + `AsyncMock` if the patched object is asynchronous, to `MagicMock` + otherwise or to `new_callable` if specified. + + `patch.dict(...)`, `patch.multiple(...)` and `patch.object(...)` are + available for alternate use-cases. + """ + getter, attribute = _get_target(target) + return _patch( + getter, attribute, new, spec, create, + spec_set, autospec, new_callable, kwargs, unsafe=unsafe + ) + + +class _patch_dict(object): + """ + Patch a dictionary, or dictionary like object, and restore the dictionary + to its original state after the test. + + `in_dict` can be a dictionary or a mapping like container. If it is a + mapping then it must at least support getting, setting and deleting items + plus iterating over keys. + + `in_dict` can also be a string specifying the name of the dictionary, which + will then be fetched by importing it. + + `values` can be a dictionary of values to set in the dictionary. `values` + can also be an iterable of `(key, value)` pairs. + + If `clear` is True then the dictionary will be cleared before the new + values are set. + + `patch.dict` can also be called with arbitrary keyword arguments to set + values in the dictionary:: + + with patch.dict('sys.modules', mymodule=Mock(), other_module=Mock()): + ... + + `patch.dict` can be used as a context manager, decorator or class + decorator. When used as a class decorator `patch.dict` honours + `patch.TEST_PREFIX` for choosing which methods to wrap. + """ + + def __init__(self, in_dict, values=(), clear=False, **kwargs): + self.in_dict = in_dict + # support any argument supported by dict(...) constructor + self.values = dict(values) + self.values.update(kwargs) + self.clear = clear + self._original = None + + + def __call__(self, f): + if isinstance(f, type): + return self.decorate_class(f) + if inspect.iscoroutinefunction(f): + return self.decorate_async_callable(f) + return self.decorate_callable(f) + + + def decorate_callable(self, f): + @wraps(f) + def _inner(*args, **kw): + self._patch_dict() + try: + return f(*args, **kw) + finally: + self._unpatch_dict() + + return _inner + + + def decorate_async_callable(self, f): + @wraps(f) + async def _inner(*args, **kw): + self._patch_dict() + try: + return await f(*args, **kw) + finally: + self._unpatch_dict() + + return _inner + + + def decorate_class(self, klass): + for attr in dir(klass): + attr_value = getattr(klass, attr) + if (attr.startswith(patch.TEST_PREFIX) and + hasattr(attr_value, "__call__")): + decorator = _patch_dict(self.in_dict, self.values, self.clear) + decorated = decorator(attr_value) + setattr(klass, attr, decorated) + return klass + + + def __enter__(self): + """Patch the dict.""" + self._patch_dict() + return self.in_dict + + + def _patch_dict(self): + values = self.values + if isinstance(self.in_dict, str): + self.in_dict = pkgutil.resolve_name(self.in_dict) + in_dict = self.in_dict + clear = self.clear + + try: + original = in_dict.copy() + except AttributeError: + # dict like object with no copy method + # must support iteration over keys + original = {} + for key in in_dict: + original[key] = in_dict[key] + self._original = original + + if clear: + _clear_dict(in_dict) + + try: + in_dict.update(values) + except AttributeError: + # dict like object with no update method + for key in values: + in_dict[key] = values[key] + + + def _unpatch_dict(self): + in_dict = self.in_dict + original = self._original + + _clear_dict(in_dict) + + try: + in_dict.update(original) + except AttributeError: + for key in original: + in_dict[key] = original[key] + + + def __exit__(self, *args): + """Unpatch the dict.""" + if self._original is not None: + self._unpatch_dict() + return False + + + def start(self): + """Activate a patch, returning any created mock.""" + result = self.__enter__() + _patch._active_patches.append(self) + return result + + + def stop(self): + """Stop an active patch.""" + try: + _patch._active_patches.remove(self) + except ValueError: + # If the patch hasn't been started this will fail + return None + + return self.__exit__(None, None, None) + + +def _clear_dict(in_dict): + try: + in_dict.clear() + except AttributeError: + keys = list(in_dict) + for key in keys: + del in_dict[key] + + +def _patch_stopall(): + """Stop all active patches. LIFO to unroll nested patches.""" + for patch in reversed(_patch._active_patches): + patch.stop() + + +patch.object = _patch_object +patch.dict = _patch_dict +patch.multiple = _patch_multiple +patch.stopall = _patch_stopall +patch.TEST_PREFIX = 'test' + +magic_methods = ( + "lt le gt ge eq ne " + "getitem setitem delitem " + "len contains iter " + "hash str sizeof " + "enter exit " + # we added divmod and rdivmod here instead of numerics + # because there is no idivmod + "divmod rdivmod neg pos abs invert " + "complex int float index " + "round trunc floor ceil " + "bool next " + "fspath " + "aiter " +) + +numerics = ( + "add sub mul matmul truediv floordiv mod lshift rshift and xor or pow" +) +inplace = ' '.join('i%s' % n for n in numerics.split()) +right = ' '.join('r%s' % n for n in numerics.split()) + +# not including __prepare__, __instancecheck__, __subclasscheck__ +# (as they are metaclass methods) +# __del__ is not supported at all as it causes problems if it exists + +_non_defaults = { + '__get__', '__set__', '__delete__', '__reversed__', '__missing__', + '__reduce__', '__reduce_ex__', '__getinitargs__', '__getnewargs__', + '__getstate__', '__setstate__', '__getformat__', + '__repr__', '__dir__', '__subclasses__', '__format__', + '__getnewargs_ex__', +} + + +def _get_method(name, func): + "Turns a callable object (like a mock) into a real function" + def method(self, /, *args, **kw): + return func(self, *args, **kw) + method.__name__ = name + return method + + +_magics = { + '__%s__' % method for method in + ' '.join([magic_methods, numerics, inplace, right]).split() +} + +# Magic methods used for async `with` statements +_async_method_magics = {"__aenter__", "__aexit__", "__anext__"} +# Magic methods that are only used with async calls but are synchronous functions themselves +_sync_async_magics = {"__aiter__"} +_async_magics = _async_method_magics | _sync_async_magics + +_all_sync_magics = _magics | _non_defaults +_all_magics = _all_sync_magics | _async_magics + +_unsupported_magics = { + '__getattr__', '__setattr__', + '__init__', '__new__', '__prepare__', + '__instancecheck__', '__subclasscheck__', + '__del__' +} + +_calculate_return_value = { + '__hash__': lambda self: object.__hash__(self), + '__str__': lambda self: object.__str__(self), + '__sizeof__': lambda self: object.__sizeof__(self), + '__fspath__': lambda self: f"{type(self).__name__}/{self._extract_mock_name()}/{id(self)}", +} + +_return_values = { + '__lt__': NotImplemented, + '__gt__': NotImplemented, + '__le__': NotImplemented, + '__ge__': NotImplemented, + '__int__': 1, + '__contains__': False, + '__len__': 0, + '__exit__': False, + '__complex__': 1j, + '__float__': 1.0, + '__bool__': True, + '__index__': 1, + '__aexit__': False, +} + + +def _get_eq(self): + def __eq__(other): + ret_val = self.__eq__._mock_return_value + if ret_val is not DEFAULT: + return ret_val + if self is other: + return True + return NotImplemented + return __eq__ + +def _get_ne(self): + def __ne__(other): + if self.__ne__._mock_return_value is not DEFAULT: + return DEFAULT + if self is other: + return False + return NotImplemented + return __ne__ + +def _get_iter(self): + def __iter__(): + ret_val = self.__iter__._mock_return_value + if ret_val is DEFAULT: + return iter([]) + # if ret_val was already an iterator, then calling iter on it should + # return the iterator unchanged + return iter(ret_val) + return __iter__ + +def _get_async_iter(self): + def __aiter__(): + ret_val = self.__aiter__._mock_return_value + if ret_val is DEFAULT: + return _AsyncIterator(iter([])) + return _AsyncIterator(iter(ret_val)) + return __aiter__ + +_side_effect_methods = { + '__eq__': _get_eq, + '__ne__': _get_ne, + '__iter__': _get_iter, + '__aiter__': _get_async_iter +} + + + +def _set_return_value(mock, method, name): + fixed = _return_values.get(name, DEFAULT) + if fixed is not DEFAULT: + method.return_value = fixed + return + + return_calculator = _calculate_return_value.get(name) + if return_calculator is not None: + return_value = return_calculator(mock) + method.return_value = return_value + return + + side_effector = _side_effect_methods.get(name) + if side_effector is not None: + method.side_effect = side_effector(mock) + + + +class MagicMixin(Base): + def __init__(self, /, *args, **kw): + self._mock_set_magics() # make magic work for kwargs in init + _safe_super(MagicMixin, self).__init__(*args, **kw) + self._mock_set_magics() # fix magic broken by upper level init + + + def _mock_set_magics(self): + orig_magics = _magics | _async_method_magics + these_magics = orig_magics + + if getattr(self, "_mock_methods", None) is not None: + these_magics = orig_magics.intersection(self._mock_methods) + + remove_magics = set() + remove_magics = orig_magics - these_magics + + for entry in remove_magics: + if entry in type(self).__dict__: + # remove unneeded magic methods + delattr(self, entry) + + # don't overwrite existing attributes if called a second time + these_magics = these_magics - set(type(self).__dict__) + + _type = type(self) + for entry in these_magics: + setattr(_type, entry, MagicProxy(entry, self)) + + + +class NonCallableMagicMock(MagicMixin, NonCallableMock): + """A version of `MagicMock` that isn't callable.""" + def mock_add_spec(self, spec, spec_set=False): + """Add a spec to a mock. `spec` can either be an object or a + list of strings. Only attributes on the `spec` can be fetched as + attributes from the mock. + + If `spec_set` is True then only attributes on the spec can be set.""" + self._mock_add_spec(spec, spec_set) + self._mock_set_magics() + + +class AsyncMagicMixin(MagicMixin): + def __init__(self, /, *args, **kw): + self._mock_set_magics() # make magic work for kwargs in init + _safe_super(AsyncMagicMixin, self).__init__(*args, **kw) + self._mock_set_magics() # fix magic broken by upper level init + +class MagicMock(MagicMixin, Mock): + """ + MagicMock is a subclass of Mock with default implementations + of most of the magic methods. You can use MagicMock without having to + configure the magic methods yourself. + + If you use the `spec` or `spec_set` arguments then *only* magic + methods that exist in the spec will be created. + + Attributes and the return value of a `MagicMock` will also be `MagicMocks`. + """ + def mock_add_spec(self, spec, spec_set=False): + """Add a spec to a mock. `spec` can either be an object or a + list of strings. Only attributes on the `spec` can be fetched as + attributes from the mock. + + If `spec_set` is True then only attributes on the spec can be set.""" + self._mock_add_spec(spec, spec_set) + self._mock_set_magics() + + + +class MagicProxy(Base): + def __init__(self, name, parent): + self.name = name + self.parent = parent + + def create_mock(self): + entry = self.name + parent = self.parent + m = parent._get_child_mock(name=entry, _new_name=entry, + _new_parent=parent) + setattr(parent, entry, m) + _set_return_value(parent, m, entry) + return m + + def __get__(self, obj, _type=None): + return self.create_mock() + + +class AsyncMockMixin(Base): + await_count = _delegating_property('await_count') + await_args = _delegating_property('await_args') + await_args_list = _delegating_property('await_args_list') + + def __init__(self, /, *args, **kwargs): + super().__init__(*args, **kwargs) + # iscoroutinefunction() checks _is_coroutine property to say if an + # object is a coroutine. Without this check it looks to see if it is a + # function/method, which in this case it is not (since it is an + # AsyncMock). + # It is set through __dict__ because when spec_set is True, this + # attribute is likely undefined. + self.__dict__['_is_coroutine'] = asyncio.coroutines._is_coroutine + self.__dict__['_mock_await_count'] = 0 + self.__dict__['_mock_await_args'] = None + self.__dict__['_mock_await_args_list'] = _CallList() + code_mock = NonCallableMock(spec_set=CodeType) + code_mock.co_flags = ( + inspect.CO_COROUTINE + + inspect.CO_VARARGS + + inspect.CO_VARKEYWORDS + ) + code_mock.co_argcount = 0 + code_mock.co_varnames = ('args', 'kwargs') + code_mock.co_posonlyargcount = 0 + code_mock.co_kwonlyargcount = 0 + self.__dict__['__code__'] = code_mock + self.__dict__['__name__'] = 'AsyncMock' + self.__dict__['__defaults__'] = tuple() + self.__dict__['__kwdefaults__'] = {} + self.__dict__['__annotations__'] = None + + async def _execute_mock_call(self, /, *args, **kwargs): + # This is nearly just like super(), except for special handling + # of coroutines + + _call = _Call((args, kwargs), two=True) + self.await_count += 1 + self.await_args = _call + self.await_args_list.append(_call) + + effect = self.side_effect + if effect is not None: + if _is_exception(effect): + raise effect + elif not _callable(effect): + try: + result = next(effect) + except StopIteration: + # It is impossible to propagate a StopIteration + # through coroutines because of PEP 479 + raise StopAsyncIteration + if _is_exception(result): + raise result + elif iscoroutinefunction(effect): + result = await effect(*args, **kwargs) + else: + result = effect(*args, **kwargs) + + if result is not DEFAULT: + return result + + if self._mock_return_value is not DEFAULT: + return self.return_value + + if self._mock_wraps is not None: + if iscoroutinefunction(self._mock_wraps): + return await self._mock_wraps(*args, **kwargs) + return self._mock_wraps(*args, **kwargs) + + return self.return_value + + def assert_awaited(self): + """ + Assert that the mock was awaited at least once. + """ + if self.await_count == 0: + msg = f"Expected {self._mock_name or 'mock'} to have been awaited." + raise AssertionError(msg) + + def assert_awaited_once(self): + """ + Assert that the mock was awaited exactly once. + """ + if not self.await_count == 1: + msg = (f"Expected {self._mock_name or 'mock'} to have been awaited once." + f" Awaited {self.await_count} times.") + raise AssertionError(msg) + + def assert_awaited_with(self, /, *args, **kwargs): + """ + Assert that the last await was with the specified arguments. + """ + if self.await_args is None: + expected = self._format_mock_call_signature(args, kwargs) + raise AssertionError(f'Expected await: {expected}\nNot awaited') + + def _error_message(): + msg = self._format_mock_failure_message(args, kwargs, action='await') + return msg + + expected = self._call_matcher(_Call((args, kwargs), two=True)) + actual = self._call_matcher(self.await_args) + if actual != expected: + cause = expected if isinstance(expected, Exception) else None + raise AssertionError(_error_message()) from cause + + def assert_awaited_once_with(self, /, *args, **kwargs): + """ + Assert that the mock was awaited exactly once and with the specified + arguments. + """ + if not self.await_count == 1: + msg = (f"Expected {self._mock_name or 'mock'} to have been awaited once." + f" Awaited {self.await_count} times.") + raise AssertionError(msg) + return self.assert_awaited_with(*args, **kwargs) + + def assert_any_await(self, /, *args, **kwargs): + """ + Assert the mock has ever been awaited with the specified arguments. + """ + expected = self._call_matcher(_Call((args, kwargs), two=True)) + cause = expected if isinstance(expected, Exception) else None + actual = [self._call_matcher(c) for c in self.await_args_list] + if cause or expected not in _AnyComparer(actual): + expected_string = self._format_mock_call_signature(args, kwargs) + raise AssertionError( + '%s await not found' % expected_string + ) from cause + + def assert_has_awaits(self, calls, any_order=False): + """ + Assert the mock has been awaited with the specified calls. + The :attr:`await_args_list` list is checked for the awaits. + + If `any_order` is False (the default) then the awaits must be + sequential. There can be extra calls before or after the + specified awaits. + + If `any_order` is True then the awaits can be in any order, but + they must all appear in :attr:`await_args_list`. + """ + expected = [self._call_matcher(c) for c in calls] + cause = next((e for e in expected if isinstance(e, Exception)), None) + all_awaits = _CallList(self._call_matcher(c) for c in self.await_args_list) + if not any_order: + if expected not in all_awaits: + if cause is None: + problem = 'Awaits not found.' + else: + problem = ('Error processing expected awaits.\n' + 'Errors: {}').format( + [e if isinstance(e, Exception) else None + for e in expected]) + raise AssertionError( + f'{problem}\n' + f'Expected: {_CallList(calls)}\n' + f'Actual: {self.await_args_list}' + ) from cause + return + + all_awaits = list(all_awaits) + + not_found = [] + for kall in expected: + try: + all_awaits.remove(kall) + except ValueError: + not_found.append(kall) + if not_found: + raise AssertionError( + '%r not all found in await list' % (tuple(not_found),) + ) from cause + + def assert_not_awaited(self): + """ + Assert that the mock was never awaited. + """ + if self.await_count != 0: + msg = (f"Expected {self._mock_name or 'mock'} to not have been awaited." + f" Awaited {self.await_count} times.") + raise AssertionError(msg) + + def reset_mock(self, /, *args, **kwargs): + """ + See :func:`.Mock.reset_mock()` + """ + super().reset_mock(*args, **kwargs) + self.await_count = 0 + self.await_args = None + self.await_args_list = _CallList() + + +class AsyncMock(AsyncMockMixin, AsyncMagicMixin, Mock): + """ + Enhance :class:`Mock` with features allowing to mock + an async function. + + The :class:`AsyncMock` object will behave so the object is + recognized as an async function, and the result of a call is an awaitable: + + >>> mock = AsyncMock() + >>> iscoroutinefunction(mock) + True + >>> inspect.isawaitable(mock()) + True + + + The result of ``mock()`` is an async function which will have the outcome + of ``side_effect`` or ``return_value``: + + - if ``side_effect`` is a function, the async function will return the + result of that function, + - if ``side_effect`` is an exception, the async function will raise the + exception, + - if ``side_effect`` is an iterable, the async function will return the + next value of the iterable, however, if the sequence of result is + exhausted, ``StopIteration`` is raised immediately, + - if ``side_effect`` is not defined, the async function will return the + value defined by ``return_value``, hence, by default, the async function + returns a new :class:`AsyncMock` object. + + If the outcome of ``side_effect`` or ``return_value`` is an async function, + the mock async function obtained when the mock object is called will be this + async function itself (and not an async function returning an async + function). + + The test author can also specify a wrapped object with ``wraps``. In this + case, the :class:`Mock` object behavior is the same as with an + :class:`.Mock` object: the wrapped object may have methods + defined as async function functions. + + Based on Martin Richard's asynctest project. + """ + + +class _ANY(object): + "A helper object that compares equal to everything." + + def __eq__(self, other): + return True + + def __ne__(self, other): + return False + + def __repr__(self): + return '' + +ANY = _ANY() + + + +def _format_call_signature(name, args, kwargs): + message = '%s(%%s)' % name + formatted_args = '' + args_string = ', '.join([repr(arg) for arg in args]) + kwargs_string = ', '.join([ + '%s=%r' % (key, value) for key, value in kwargs.items() + ]) + if args_string: + formatted_args = args_string + if kwargs_string: + if formatted_args: + formatted_args += ', ' + formatted_args += kwargs_string + + return message % formatted_args + + + +class _Call(tuple): + """ + A tuple for holding the results of a call to a mock, either in the form + `(args, kwargs)` or `(name, args, kwargs)`. + + If args or kwargs are empty then a call tuple will compare equal to + a tuple without those values. This makes comparisons less verbose:: + + _Call(('name', (), {})) == ('name',) + _Call(('name', (1,), {})) == ('name', (1,)) + _Call(((), {'a': 'b'})) == ({'a': 'b'},) + + The `_Call` object provides a useful shortcut for comparing with call:: + + _Call(((1, 2), {'a': 3})) == call(1, 2, a=3) + _Call(('foo', (1, 2), {'a': 3})) == call.foo(1, 2, a=3) + + If the _Call has no name then it will match any name. + """ + def __new__(cls, value=(), name='', parent=None, two=False, + from_kall=True): + args = () + kwargs = {} + _len = len(value) + if _len == 3: + name, args, kwargs = value + elif _len == 2: + first, second = value + if isinstance(first, str): + name = first + if isinstance(second, tuple): + args = second + else: + kwargs = second + else: + args, kwargs = first, second + elif _len == 1: + value, = value + if isinstance(value, str): + name = value + elif isinstance(value, tuple): + args = value + else: + kwargs = value + + if two: + return tuple.__new__(cls, (args, kwargs)) + + return tuple.__new__(cls, (name, args, kwargs)) + + + def __init__(self, value=(), name=None, parent=None, two=False, + from_kall=True): + self._mock_name = name + self._mock_parent = parent + self._mock_from_kall = from_kall + + + def __eq__(self, other): + try: + len_other = len(other) + except TypeError: + return NotImplemented + + self_name = '' + if len(self) == 2: + self_args, self_kwargs = self + else: + self_name, self_args, self_kwargs = self + + if (getattr(self, '_mock_parent', None) and getattr(other, '_mock_parent', None) + and self._mock_parent != other._mock_parent): + return False + + other_name = '' + if len_other == 0: + other_args, other_kwargs = (), {} + elif len_other == 3: + other_name, other_args, other_kwargs = other + elif len_other == 1: + value, = other + if isinstance(value, tuple): + other_args = value + other_kwargs = {} + elif isinstance(value, str): + other_name = value + other_args, other_kwargs = (), {} + else: + other_args = () + other_kwargs = value + elif len_other == 2: + # could be (name, args) or (name, kwargs) or (args, kwargs) + first, second = other + if isinstance(first, str): + other_name = first + if isinstance(second, tuple): + other_args, other_kwargs = second, {} + else: + other_args, other_kwargs = (), second + else: + other_args, other_kwargs = first, second + else: + return False + + if self_name and other_name != self_name: + return False + + # this order is important for ANY to work! + return (other_args, other_kwargs) == (self_args, self_kwargs) + + + __ne__ = object.__ne__ + + + def __call__(self, /, *args, **kwargs): + if self._mock_name is None: + return _Call(('', args, kwargs), name='()') + + name = self._mock_name + '()' + return _Call((self._mock_name, args, kwargs), name=name, parent=self) + + + def __getattr__(self, attr): + if self._mock_name is None: + return _Call(name=attr, from_kall=False) + name = '%s.%s' % (self._mock_name, attr) + return _Call(name=name, parent=self, from_kall=False) + + + def __getattribute__(self, attr): + if attr in tuple.__dict__: + raise AttributeError + return tuple.__getattribute__(self, attr) + + + def _get_call_arguments(self): + if len(self) == 2: + args, kwargs = self + else: + name, args, kwargs = self + + return args, kwargs + + @property + def args(self): + return self._get_call_arguments()[0] + + @property + def kwargs(self): + return self._get_call_arguments()[1] + + def __repr__(self): + if not self._mock_from_kall: + name = self._mock_name or 'call' + if name.startswith('()'): + name = 'call%s' % name + return name + + if len(self) == 2: + name = 'call' + args, kwargs = self + else: + name, args, kwargs = self + if not name: + name = 'call' + elif not name.startswith('()'): + name = 'call.%s' % name + else: + name = 'call%s' % name + return _format_call_signature(name, args, kwargs) + + + def call_list(self): + """For a call object that represents multiple calls, `call_list` + returns a list of all the intermediate calls as well as the + final call.""" + vals = [] + thing = self + while thing is not None: + if thing._mock_from_kall: + vals.append(thing) + thing = thing._mock_parent + return _CallList(reversed(vals)) + + +call = _Call(from_kall=False) + + +def create_autospec(spec, spec_set=False, instance=False, _parent=None, + _name=None, *, unsafe=False, **kwargs): + """Create a mock object using another object as a spec. Attributes on the + mock will use the corresponding attribute on the `spec` object as their + spec. + + Functions or methods being mocked will have their arguments checked + to check that they are called with the correct signature. + + If `spec_set` is True then attempting to set attributes that don't exist + on the spec object will raise an `AttributeError`. + + If a class is used as a spec then the return value of the mock (the + instance of the class) will have the same spec. You can use a class as the + spec for an instance object by passing `instance=True`. The returned mock + will only be callable if instances of the mock are callable. + + `create_autospec` will raise a `RuntimeError` if passed some common + misspellings of the arguments autospec and spec_set. Pass the argument + `unsafe` with the value True to disable that check. + + `create_autospec` also takes arbitrary keyword arguments that are passed to + the constructor of the created mock.""" + if _is_list(spec): + # can't pass a list instance to the mock constructor as it will be + # interpreted as a list of strings + spec = type(spec) + + is_type = isinstance(spec, type) + if _is_instance_mock(spec): + raise InvalidSpecError(f'Cannot autospec a Mock object. ' + f'[object={spec!r}]') + is_async_func = _is_async_func(spec) + _kwargs = {'spec': spec} + if spec_set: + _kwargs = {'spec_set': spec} + elif spec is None: + # None we mock with a normal mock without a spec + _kwargs = {} + if _kwargs and instance: + _kwargs['_spec_as_instance'] = True + if not unsafe: + _check_spec_arg_typos(kwargs) + + _kwargs.update(kwargs) + + Klass = MagicMock + if inspect.isdatadescriptor(spec): + # descriptors don't have a spec + # because we don't know what type they return + _kwargs = {} + elif is_async_func: + if instance: + raise RuntimeError("Instance can not be True when create_autospec " + "is mocking an async function") + Klass = AsyncMock + elif not _callable(spec): + Klass = NonCallableMagicMock + elif is_type and instance and not _instance_callable(spec): + Klass = NonCallableMagicMock + + _name = _kwargs.pop('name', _name) + + _new_name = _name + if _parent is None: + # for a top level object no _new_name should be set + _new_name = '' + + mock = Klass(parent=_parent, _new_parent=_parent, _new_name=_new_name, + name=_name, **_kwargs) + + if isinstance(spec, FunctionTypes): + # should only happen at the top level because we don't + # recurse for functions + mock = _set_signature(mock, spec) + if is_async_func: + _setup_async_mock(mock) + else: + _check_signature(spec, mock, is_type, instance) + + if _parent is not None and not instance: + _parent._mock_children[_name] = mock + + wrapped = kwargs.get('wraps') + + if is_type and not instance and 'return_value' not in kwargs: + mock.return_value = create_autospec(spec, spec_set, instance=True, + _name='()', _parent=mock, + wraps=wrapped) + + for entry in dir(spec): + if _is_magic(entry): + # MagicMock already does the useful magic methods for us + continue + + # XXXX do we need a better way of getting attributes without + # triggering code execution (?) Probably not - we need the actual + # object to mock it so we would rather trigger a property than mock + # the property descriptor. Likewise we want to mock out dynamically + # provided attributes. + # XXXX what about attributes that raise exceptions other than + # AttributeError on being fetched? + # we could be resilient against it, or catch and propagate the + # exception when the attribute is fetched from the mock + try: + original = getattr(spec, entry) + except AttributeError: + continue + + kwargs = {'spec': original} + # Wrap child attributes also. + if wrapped and hasattr(wrapped, entry): + kwargs.update(wraps=original) + if spec_set: + kwargs = {'spec_set': original} + + if not isinstance(original, FunctionTypes): + new = _SpecState(original, spec_set, mock, entry, instance) + mock._mock_children[entry] = new + else: + parent = mock + if isinstance(spec, FunctionTypes): + parent = mock.mock + + skipfirst = _must_skip(spec, entry, is_type) + kwargs['_eat_self'] = skipfirst + if iscoroutinefunction(original): + child_klass = AsyncMock + else: + child_klass = MagicMock + new = child_klass(parent=parent, name=entry, _new_name=entry, + _new_parent=parent, + **kwargs) + mock._mock_children[entry] = new + _check_signature(original, new, skipfirst=skipfirst) + + # so functions created with _set_signature become instance attributes, + # *plus* their underlying mock exists in _mock_children of the parent + # mock. Adding to _mock_children may be unnecessary where we are also + # setting as an instance attribute? + if isinstance(new, FunctionTypes): + setattr(mock, entry, new) + + return mock + + +def _must_skip(spec, entry, is_type): + """ + Return whether we should skip the first argument on spec's `entry` + attribute. + """ + if not isinstance(spec, type): + if entry in getattr(spec, '__dict__', {}): + # instance attribute - shouldn't skip + return False + spec = spec.__class__ + + for klass in spec.__mro__: + result = klass.__dict__.get(entry, DEFAULT) + if result is DEFAULT: + continue + if isinstance(result, (staticmethod, classmethod)): + return False + elif isinstance(result, FunctionTypes): + # Normal method => skip if looked up on type + # (if looked up on instance, self is already skipped) + return is_type + else: + return False + + # function is a dynamically provided attribute + return is_type + + +class _SpecState(object): + + def __init__(self, spec, spec_set=False, parent=None, + name=None, ids=None, instance=False): + self.spec = spec + self.ids = ids + self.spec_set = spec_set + self.parent = parent + self.instance = instance + self.name = name + + +FunctionTypes = ( + # python function + type(create_autospec), + # instance method + type(ANY.__eq__), +) + + +file_spec = None +open_spec = None + + +def _to_stream(read_data): + if isinstance(read_data, bytes): + return io.BytesIO(read_data) + else: + return io.StringIO(read_data) + + +def mock_open(mock=None, read_data=''): + """ + A helper function to create a mock to replace the use of `open`. It works + for `open` called directly or used as a context manager. + + The `mock` argument is the mock object to configure. If `None` (the + default) then a `MagicMock` will be created for you, with the API limited + to methods or attributes available on standard file handles. + + `read_data` is a string for the `read`, `readline` and `readlines` of the + file handle to return. This is an empty string by default. + """ + _read_data = _to_stream(read_data) + _state = [_read_data, None] + + def _readlines_side_effect(*args, **kwargs): + if handle.readlines.return_value is not None: + return handle.readlines.return_value + return _state[0].readlines(*args, **kwargs) + + def _read_side_effect(*args, **kwargs): + if handle.read.return_value is not None: + return handle.read.return_value + return _state[0].read(*args, **kwargs) + + def _readline_side_effect(*args, **kwargs): + yield from _iter_side_effect() + while True: + yield _state[0].readline(*args, **kwargs) + + def _iter_side_effect(): + if handle.readline.return_value is not None: + while True: + yield handle.readline.return_value + for line in _state[0]: + yield line + + def _next_side_effect(): + if handle.readline.return_value is not None: + return handle.readline.return_value + return next(_state[0]) + + global file_spec + if file_spec is None: + import _io + file_spec = list(set(dir(_io.TextIOWrapper)).union(set(dir(_io.BytesIO)))) + + global open_spec + if open_spec is None: + import _io + open_spec = list(set(dir(_io.open))) + if mock is None: + mock = MagicMock(name='open', spec=open_spec) + + handle = MagicMock(spec=file_spec) + handle.__enter__.return_value = handle + + handle.write.return_value = None + handle.read.return_value = None + handle.readline.return_value = None + handle.readlines.return_value = None + + handle.read.side_effect = _read_side_effect + _state[1] = _readline_side_effect() + handle.readline.side_effect = _state[1] + handle.readlines.side_effect = _readlines_side_effect + handle.__iter__.side_effect = _iter_side_effect + handle.__next__.side_effect = _next_side_effect + + def reset_data(*args, **kwargs): + _state[0] = _to_stream(read_data) + if handle.readline.side_effect == _state[1]: + # Only reset the side effect if the user hasn't overridden it. + _state[1] = _readline_side_effect() + handle.readline.side_effect = _state[1] + return DEFAULT + + mock.side_effect = reset_data + mock.return_value = handle + return mock + + +class PropertyMock(Mock): + """ + A mock intended to be used as a property, or other descriptor, on a class. + `PropertyMock` provides `__get__` and `__set__` methods so you can specify + a return value when it is fetched. + + Fetching a `PropertyMock` instance from an object calls the mock, with + no args. Setting it calls the mock with the value being set. + """ + def _get_child_mock(self, /, **kwargs): + return MagicMock(**kwargs) + + def __get__(self, obj, obj_type=None): + return self() + def __set__(self, obj, val): + self(val) + + +def seal(mock): + """Disable the automatic generation of child mocks. + + Given an input Mock, seals it to ensure no further mocks will be generated + when accessing an attribute that was not already defined. + + The operation recursively seals the mock passed in, meaning that + the mock itself, any mocks generated by accessing one of its attributes, + and all assigned mocks without a name or spec will be sealed. + """ + mock._mock_sealed = True + for attr in dir(mock): + try: + m = getattr(mock, attr) + except AttributeError: + continue + if not isinstance(m, NonCallableMock): + continue + if isinstance(m._mock_children.get(attr), _SpecState): + continue + if m._mock_new_parent is mock: + seal(m) + + +class _AsyncIterator: + """ + Wraps an iterator in an asynchronous iterator. + """ + def __init__(self, iterator): + self.iterator = iterator + code_mock = NonCallableMock(spec_set=CodeType) + code_mock.co_flags = inspect.CO_ITERABLE_COROUTINE + self.__dict__['__code__'] = code_mock + + async def __anext__(self): + try: + return next(self.iterator) + except StopIteration: + pass + raise StopAsyncIteration diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/result.py b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/result.py new file mode 100644 index 0000000000000000000000000000000000000000..5ca4c23238b41985bffaa03a867e46480da86867 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/result.py @@ -0,0 +1,244 @@ +"""Test result object""" + +import io +import sys +import traceback + +from . import util +from functools import wraps + +__unittest = True + +def failfast(method): + @wraps(method) + def inner(self, *args, **kw): + if getattr(self, 'failfast', False): + self.stop() + return method(self, *args, **kw) + return inner + +STDOUT_LINE = '\nStdout:\n%s' +STDERR_LINE = '\nStderr:\n%s' + + +class TestResult(object): + """Holder for test result information. + + Test results are automatically managed by the TestCase and TestSuite + classes, and do not need to be explicitly manipulated by writers of tests. + + Each instance holds the total number of tests run, and collections of + failures and errors that occurred among those test runs. The collections + contain tuples of (testcase, exceptioninfo), where exceptioninfo is the + formatted traceback of the error that occurred. + """ + _previousTestClass = None + _testRunEntered = False + _moduleSetUpFailed = False + def __init__(self, stream=None, descriptions=None, verbosity=None): + self.failfast = False + self.failures = [] + self.errors = [] + self.testsRun = 0 + self.skipped = [] + self.expectedFailures = [] + self.unexpectedSuccesses = [] + self.shouldStop = False + self.buffer = False + self.tb_locals = False + self._stdout_buffer = None + self._stderr_buffer = None + self._original_stdout = sys.stdout + self._original_stderr = sys.stderr + self._mirrorOutput = False + + def printErrors(self): + "Called by TestRunner after test run" + + def startTest(self, test): + "Called when the given test is about to be run" + self.testsRun += 1 + self._mirrorOutput = False + self._setupStdout() + + def _setupStdout(self): + if self.buffer: + if self._stderr_buffer is None: + self._stderr_buffer = io.StringIO() + self._stdout_buffer = io.StringIO() + sys.stdout = self._stdout_buffer + sys.stderr = self._stderr_buffer + + def startTestRun(self): + """Called once before any tests are executed. + + See startTest for a method called before each test. + """ + + def stopTest(self, test): + """Called when the given test has been run""" + self._restoreStdout() + self._mirrorOutput = False + + def _restoreStdout(self): + if self.buffer: + if self._mirrorOutput: + output = sys.stdout.getvalue() + error = sys.stderr.getvalue() + if output: + if not output.endswith('\n'): + output += '\n' + self._original_stdout.write(STDOUT_LINE % output) + if error: + if not error.endswith('\n'): + error += '\n' + self._original_stderr.write(STDERR_LINE % error) + + sys.stdout = self._original_stdout + sys.stderr = self._original_stderr + self._stdout_buffer.seek(0) + self._stdout_buffer.truncate() + self._stderr_buffer.seek(0) + self._stderr_buffer.truncate() + + def stopTestRun(self): + """Called once after all tests are executed. + + See stopTest for a method called after each test. + """ + + @failfast + def addError(self, test, err): + """Called when an error has occurred. 'err' is a tuple of values as + returned by sys.exc_info(). + """ + self.errors.append((test, self._exc_info_to_string(err, test))) + self._mirrorOutput = True + + @failfast + def addFailure(self, test, err): + """Called when an error has occurred. 'err' is a tuple of values as + returned by sys.exc_info().""" + self.failures.append((test, self._exc_info_to_string(err, test))) + self._mirrorOutput = True + + def addSubTest(self, test, subtest, err): + """Called at the end of a subtest. + 'err' is None if the subtest ended successfully, otherwise it's a + tuple of values as returned by sys.exc_info(). + """ + # By default, we don't do anything with successful subtests, but + # more sophisticated test results might want to record them. + if err is not None: + if getattr(self, 'failfast', False): + self.stop() + if issubclass(err[0], test.failureException): + errors = self.failures + else: + errors = self.errors + errors.append((subtest, self._exc_info_to_string(err, test))) + self._mirrorOutput = True + + def addSuccess(self, test): + "Called when a test has completed successfully" + pass + + def addSkip(self, test, reason): + """Called when a test is skipped.""" + self.skipped.append((test, reason)) + + def addExpectedFailure(self, test, err): + """Called when an expected failure/error occurred.""" + self.expectedFailures.append( + (test, self._exc_info_to_string(err, test))) + + @failfast + def addUnexpectedSuccess(self, test): + """Called when a test was expected to fail, but succeed.""" + self.unexpectedSuccesses.append(test) + + def wasSuccessful(self): + """Tells whether or not this result was a success.""" + # The hasattr check is for test_result's OldResult test. That + # way this method works on objects that lack the attribute. + # (where would such result instances come from? old stored pickles?) + return ((len(self.failures) == len(self.errors) == 0) and + (not hasattr(self, 'unexpectedSuccesses') or + len(self.unexpectedSuccesses) == 0)) + + def stop(self): + """Indicates that the tests should be aborted.""" + self.shouldStop = True + + def _exc_info_to_string(self, err, test): + """Converts a sys.exc_info()-style tuple of values into a string.""" + exctype, value, tb = err + tb = self._clean_tracebacks(exctype, value, tb, test) + tb_e = traceback.TracebackException( + exctype, value, tb, + capture_locals=self.tb_locals, compact=True) + msgLines = list(tb_e.format()) + + if self.buffer: + output = sys.stdout.getvalue() + error = sys.stderr.getvalue() + if output: + if not output.endswith('\n'): + output += '\n' + msgLines.append(STDOUT_LINE % output) + if error: + if not error.endswith('\n'): + error += '\n' + msgLines.append(STDERR_LINE % error) + return ''.join(msgLines) + + def _clean_tracebacks(self, exctype, value, tb, test): + ret = None + first = True + excs = [(exctype, value, tb)] + seen = {id(value)} # Detect loops in chained exceptions. + while excs: + (exctype, value, tb) = excs.pop() + # Skip test runner traceback levels + while tb and self._is_relevant_tb_level(tb): + tb = tb.tb_next + + # Skip assert*() traceback levels + if exctype is test.failureException: + self._remove_unittest_tb_frames(tb) + + if first: + ret = tb + first = False + else: + value.__traceback__ = tb + + if value is not None: + for c in (value.__cause__, value.__context__): + if c is not None and id(c) not in seen: + excs.append((type(c), c, c.__traceback__)) + seen.add(id(c)) + return ret + + def _is_relevant_tb_level(self, tb): + return '__unittest' in tb.tb_frame.f_globals + + def _remove_unittest_tb_frames(self, tb): + '''Truncates usercode tb at the first unittest frame. + + If the first frame of the traceback is in user code, + the prefix up to the first unittest frame is returned. + If the first frame is already in the unittest module, + the traceback is not modified. + ''' + prev = None + while tb and not self._is_relevant_tb_level(tb): + prev = tb + tb = tb.tb_next + if prev is not None: + prev.tb_next = None + + def __repr__(self): + return ("<%s run=%i errors=%i failures=%i>" % + (util.strclass(self.__class__), self.testsRun, len(self.errors), + len(self.failures))) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/runner.py b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/runner.py new file mode 100644 index 0000000000000000000000000000000000000000..cb452c7adefb73078086a5071775b7129962bd27 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/runner.py @@ -0,0 +1,263 @@ +"""Running tests""" + +import sys +import time +import warnings + +from . import result +from .case import _SubTest +from .signals import registerResult + +__unittest = True + + +class _WritelnDecorator(object): + """Used to decorate file-like objects with a handy 'writeln' method""" + def __init__(self,stream): + self.stream = stream + + def __getattr__(self, attr): + if attr in ('stream', '__getstate__'): + raise AttributeError(attr) + return getattr(self.stream,attr) + + def writeln(self, arg=None): + if arg: + self.write(arg) + self.write('\n') # text-mode streams translate to \r\n if needed + + +class TextTestResult(result.TestResult): + """A test result class that can print formatted text results to a stream. + + Used by TextTestRunner. + """ + separator1 = '=' * 70 + separator2 = '-' * 70 + + def __init__(self, stream, descriptions, verbosity): + super(TextTestResult, self).__init__(stream, descriptions, verbosity) + self.stream = stream + self.showAll = verbosity > 1 + self.dots = verbosity == 1 + self.descriptions = descriptions + self._newline = True + + def getDescription(self, test): + doc_first_line = test.shortDescription() + if self.descriptions and doc_first_line: + return '\n'.join((str(test), doc_first_line)) + else: + return str(test) + + def startTest(self, test): + super(TextTestResult, self).startTest(test) + if self.showAll: + self.stream.write(self.getDescription(test)) + self.stream.write(" ... ") + self.stream.flush() + self._newline = False + + def _write_status(self, test, status): + is_subtest = isinstance(test, _SubTest) + if is_subtest or self._newline: + if not self._newline: + self.stream.writeln() + if is_subtest: + self.stream.write(" ") + self.stream.write(self.getDescription(test)) + self.stream.write(" ... ") + self.stream.writeln(status) + self.stream.flush() + self._newline = True + + def addSubTest(self, test, subtest, err): + if err is not None: + if self.showAll: + if issubclass(err[0], subtest.failureException): + self._write_status(subtest, "FAIL") + else: + self._write_status(subtest, "ERROR") + elif self.dots: + if issubclass(err[0], subtest.failureException): + self.stream.write('F') + else: + self.stream.write('E') + self.stream.flush() + super(TextTestResult, self).addSubTest(test, subtest, err) + + def addSuccess(self, test): + super(TextTestResult, self).addSuccess(test) + if self.showAll: + self._write_status(test, "ok") + elif self.dots: + self.stream.write('.') + self.stream.flush() + + def addError(self, test, err): + super(TextTestResult, self).addError(test, err) + if self.showAll: + self._write_status(test, "ERROR") + elif self.dots: + self.stream.write('E') + self.stream.flush() + + def addFailure(self, test, err): + super(TextTestResult, self).addFailure(test, err) + if self.showAll: + self._write_status(test, "FAIL") + elif self.dots: + self.stream.write('F') + self.stream.flush() + + def addSkip(self, test, reason): + super(TextTestResult, self).addSkip(test, reason) + if self.showAll: + self._write_status(test, "skipped {0!r}".format(reason)) + elif self.dots: + self.stream.write("s") + self.stream.flush() + + def addExpectedFailure(self, test, err): + super(TextTestResult, self).addExpectedFailure(test, err) + if self.showAll: + self.stream.writeln("expected failure") + self.stream.flush() + elif self.dots: + self.stream.write("x") + self.stream.flush() + + def addUnexpectedSuccess(self, test): + super(TextTestResult, self).addUnexpectedSuccess(test) + if self.showAll: + self.stream.writeln("unexpected success") + self.stream.flush() + elif self.dots: + self.stream.write("u") + self.stream.flush() + + def printErrors(self): + if self.dots or self.showAll: + self.stream.writeln() + self.stream.flush() + self.printErrorList('ERROR', self.errors) + self.printErrorList('FAIL', self.failures) + unexpectedSuccesses = getattr(self, 'unexpectedSuccesses', ()) + if unexpectedSuccesses: + self.stream.writeln(self.separator1) + for test in unexpectedSuccesses: + self.stream.writeln(f"UNEXPECTED SUCCESS: {self.getDescription(test)}") + self.stream.flush() + + def printErrorList(self, flavour, errors): + for test, err in errors: + self.stream.writeln(self.separator1) + self.stream.writeln("%s: %s" % (flavour,self.getDescription(test))) + self.stream.writeln(self.separator2) + self.stream.writeln("%s" % err) + self.stream.flush() + + +class TextTestRunner(object): + """A test runner class that displays results in textual form. + + It prints out the names of tests as they are run, errors as they + occur, and a summary of the results at the end of the test run. + """ + resultclass = TextTestResult + + def __init__(self, stream=None, descriptions=True, verbosity=1, + failfast=False, buffer=False, resultclass=None, warnings=None, + *, tb_locals=False): + """Construct a TextTestRunner. + + Subclasses should accept **kwargs to ensure compatibility as the + interface changes. + """ + if stream is None: + stream = sys.stderr + self.stream = _WritelnDecorator(stream) + self.descriptions = descriptions + self.verbosity = verbosity + self.failfast = failfast + self.buffer = buffer + self.tb_locals = tb_locals + self.warnings = warnings + if resultclass is not None: + self.resultclass = resultclass + + def _makeResult(self): + return self.resultclass(self.stream, self.descriptions, self.verbosity) + + def run(self, test): + "Run the given test case or test suite." + result = self._makeResult() + registerResult(result) + result.failfast = self.failfast + result.buffer = self.buffer + result.tb_locals = self.tb_locals + with warnings.catch_warnings(): + if self.warnings: + # if self.warnings is set, use it to filter all the warnings + warnings.simplefilter(self.warnings) + # if the filter is 'default' or 'always', special-case the + # warnings from the deprecated unittest methods to show them + # no more than once per module, because they can be fairly + # noisy. The -Wd and -Wa flags can be used to bypass this + # only when self.warnings is None. + if self.warnings in ['default', 'always']: + warnings.filterwarnings('module', + category=DeprecationWarning, + message=r'Please use assert\w+ instead.') + startTime = time.perf_counter() + startTestRun = getattr(result, 'startTestRun', None) + if startTestRun is not None: + startTestRun() + try: + test(result) + finally: + stopTestRun = getattr(result, 'stopTestRun', None) + if stopTestRun is not None: + stopTestRun() + stopTime = time.perf_counter() + timeTaken = stopTime - startTime + result.printErrors() + if hasattr(result, 'separator2'): + self.stream.writeln(result.separator2) + run = result.testsRun + self.stream.writeln("Ran %d test%s in %.3fs" % + (run, run != 1 and "s" or "", timeTaken)) + self.stream.writeln() + + expectedFails = unexpectedSuccesses = skipped = 0 + try: + results = map(len, (result.expectedFailures, + result.unexpectedSuccesses, + result.skipped)) + except AttributeError: + pass + else: + expectedFails, unexpectedSuccesses, skipped = results + + infos = [] + if not result.wasSuccessful(): + self.stream.write("FAILED") + failed, errored = len(result.failures), len(result.errors) + if failed: + infos.append("failures=%d" % failed) + if errored: + infos.append("errors=%d" % errored) + else: + self.stream.write("OK") + if skipped: + infos.append("skipped=%d" % skipped) + if expectedFails: + infos.append("expected failures=%d" % expectedFails) + if unexpectedSuccesses: + infos.append("unexpected successes=%d" % unexpectedSuccesses) + if infos: + self.stream.writeln(" (%s)" % (", ".join(infos),)) + else: + self.stream.write("\n") + self.stream.flush() + return result diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/signals.py b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/signals.py new file mode 100644 index 0000000000000000000000000000000000000000..e6a5fc524397121e170bd5a888957374b91ba946 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/signals.py @@ -0,0 +1,71 @@ +import signal +import weakref + +from functools import wraps + +__unittest = True + + +class _InterruptHandler(object): + def __init__(self, default_handler): + self.called = False + self.original_handler = default_handler + if isinstance(default_handler, int): + if default_handler == signal.SIG_DFL: + # Pretend it's signal.default_int_handler instead. + default_handler = signal.default_int_handler + elif default_handler == signal.SIG_IGN: + # Not quite the same thing as SIG_IGN, but the closest we + # can make it: do nothing. + def default_handler(unused_signum, unused_frame): + pass + else: + raise TypeError("expected SIGINT signal handler to be " + "signal.SIG_IGN, signal.SIG_DFL, or a " + "callable object") + self.default_handler = default_handler + + def __call__(self, signum, frame): + installed_handler = signal.getsignal(signal.SIGINT) + if installed_handler is not self: + # if we aren't the installed handler, then delegate immediately + # to the default handler + self.default_handler(signum, frame) + + if self.called: + self.default_handler(signum, frame) + self.called = True + for result in _results.keys(): + result.stop() + +_results = weakref.WeakKeyDictionary() +def registerResult(result): + _results[result] = 1 + +def removeResult(result): + return bool(_results.pop(result, None)) + +_interrupt_handler = None +def installHandler(): + global _interrupt_handler + if _interrupt_handler is None: + default_handler = signal.getsignal(signal.SIGINT) + _interrupt_handler = _InterruptHandler(default_handler) + signal.signal(signal.SIGINT, _interrupt_handler) + + +def removeHandler(method=None): + if method is not None: + @wraps(method) + def inner(*args, **kwargs): + initial = signal.getsignal(signal.SIGINT) + removeHandler() + try: + return method(*args, **kwargs) + finally: + signal.signal(signal.SIGINT, initial) + return inner + + global _interrupt_handler + if _interrupt_handler is not None: + signal.signal(signal.SIGINT, _interrupt_handler.original_handler) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/suite.py b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/suite.py new file mode 100644 index 0000000000000000000000000000000000000000..6f45b6fe5f6039b94725b732e18eab5c01f4494b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/suite.py @@ -0,0 +1,379 @@ +"""TestSuite""" + +import sys + +from . import case +from . import util + +__unittest = True + + +def _call_if_exists(parent, attr): + func = getattr(parent, attr, lambda: None) + func() + + +class BaseTestSuite(object): + """A simple test suite that doesn't provide class or module shared fixtures. + """ + _cleanup = True + + def __init__(self, tests=()): + self._tests = [] + self._removed_tests = 0 + self.addTests(tests) + + def __repr__(self): + return "<%s tests=%s>" % (util.strclass(self.__class__), list(self)) + + def __eq__(self, other): + if not isinstance(other, self.__class__): + return NotImplemented + return list(self) == list(other) + + def __iter__(self): + return iter(self._tests) + + def countTestCases(self): + cases = self._removed_tests + for test in self: + if test: + cases += test.countTestCases() + return cases + + def addTest(self, test): + # sanity checks + if not callable(test): + raise TypeError("{} is not callable".format(repr(test))) + if isinstance(test, type) and issubclass(test, + (case.TestCase, TestSuite)): + raise TypeError("TestCases and TestSuites must be instantiated " + "before passing them to addTest()") + self._tests.append(test) + + def addTests(self, tests): + if isinstance(tests, str): + raise TypeError("tests must be an iterable of tests, not a string") + for test in tests: + self.addTest(test) + + def run(self, result): + for index, test in enumerate(self): + if result.shouldStop: + break + test(result) + if self._cleanup: + self._removeTestAtIndex(index) + return result + + def _removeTestAtIndex(self, index): + """Stop holding a reference to the TestCase at index.""" + try: + test = self._tests[index] + except TypeError: + # support for suite implementations that have overridden self._tests + pass + else: + # Some unittest tests add non TestCase/TestSuite objects to + # the suite. + if hasattr(test, 'countTestCases'): + self._removed_tests += test.countTestCases() + self._tests[index] = None + + def __call__(self, *args, **kwds): + return self.run(*args, **kwds) + + def debug(self): + """Run the tests without collecting errors in a TestResult""" + for test in self: + test.debug() + + +class TestSuite(BaseTestSuite): + """A test suite is a composite test consisting of a number of TestCases. + + For use, create an instance of TestSuite, then add test case instances. + When all tests have been added, the suite can be passed to a test + runner, such as TextTestRunner. It will run the individual test cases + in the order in which they were added, aggregating the results. When + subclassing, do not forget to call the base class constructor. + """ + + def run(self, result, debug=False): + topLevel = False + if getattr(result, '_testRunEntered', False) is False: + result._testRunEntered = topLevel = True + + for index, test in enumerate(self): + if result.shouldStop: + break + + if _isnotsuite(test): + self._tearDownPreviousClass(test, result) + self._handleModuleFixture(test, result) + self._handleClassSetUp(test, result) + result._previousTestClass = test.__class__ + + if (getattr(test.__class__, '_classSetupFailed', False) or + getattr(result, '_moduleSetUpFailed', False)): + continue + + if not debug: + test(result) + else: + test.debug() + + if self._cleanup: + self._removeTestAtIndex(index) + + if topLevel: + self._tearDownPreviousClass(None, result) + self._handleModuleTearDown(result) + result._testRunEntered = False + return result + + def debug(self): + """Run the tests without collecting errors in a TestResult""" + debug = _DebugResult() + self.run(debug, True) + + ################################ + + def _handleClassSetUp(self, test, result): + previousClass = getattr(result, '_previousTestClass', None) + currentClass = test.__class__ + if currentClass == previousClass: + return + if result._moduleSetUpFailed: + return + if getattr(currentClass, "__unittest_skip__", False): + return + + failed = False + try: + currentClass._classSetupFailed = False + except TypeError: + # test may actually be a function + # so its class will be a builtin-type + pass + + setUpClass = getattr(currentClass, 'setUpClass', None) + doClassCleanups = getattr(currentClass, 'doClassCleanups', None) + if setUpClass is not None: + _call_if_exists(result, '_setupStdout') + try: + try: + setUpClass() + except Exception as e: + if isinstance(result, _DebugResult): + raise + failed = True + try: + currentClass._classSetupFailed = True + except TypeError: + pass + className = util.strclass(currentClass) + self._createClassOrModuleLevelException(result, e, + 'setUpClass', + className) + if failed and doClassCleanups is not None: + doClassCleanups() + for exc_info in currentClass.tearDown_exceptions: + self._createClassOrModuleLevelException( + result, exc_info[1], 'setUpClass', className, + info=exc_info) + finally: + _call_if_exists(result, '_restoreStdout') + + def _get_previous_module(self, result): + previousModule = None + previousClass = getattr(result, '_previousTestClass', None) + if previousClass is not None: + previousModule = previousClass.__module__ + return previousModule + + + def _handleModuleFixture(self, test, result): + previousModule = self._get_previous_module(result) + currentModule = test.__class__.__module__ + if currentModule == previousModule: + return + + self._handleModuleTearDown(result) + + + result._moduleSetUpFailed = False + try: + module = sys.modules[currentModule] + except KeyError: + return + setUpModule = getattr(module, 'setUpModule', None) + if setUpModule is not None: + _call_if_exists(result, '_setupStdout') + try: + try: + setUpModule() + except Exception as e: + if isinstance(result, _DebugResult): + raise + result._moduleSetUpFailed = True + self._createClassOrModuleLevelException(result, e, + 'setUpModule', + currentModule) + if result._moduleSetUpFailed: + try: + case.doModuleCleanups() + except Exception as e: + self._createClassOrModuleLevelException(result, e, + 'setUpModule', + currentModule) + finally: + _call_if_exists(result, '_restoreStdout') + + def _createClassOrModuleLevelException(self, result, exc, method_name, + parent, info=None): + errorName = f'{method_name} ({parent})' + self._addClassOrModuleLevelException(result, exc, errorName, info) + + def _addClassOrModuleLevelException(self, result, exception, errorName, + info=None): + error = _ErrorHolder(errorName) + addSkip = getattr(result, 'addSkip', None) + if addSkip is not None and isinstance(exception, case.SkipTest): + addSkip(error, str(exception)) + else: + if not info: + result.addError(error, sys.exc_info()) + else: + result.addError(error, info) + + def _handleModuleTearDown(self, result): + previousModule = self._get_previous_module(result) + if previousModule is None: + return + if result._moduleSetUpFailed: + return + + try: + module = sys.modules[previousModule] + except KeyError: + return + + _call_if_exists(result, '_setupStdout') + try: + tearDownModule = getattr(module, 'tearDownModule', None) + if tearDownModule is not None: + try: + tearDownModule() + except Exception as e: + if isinstance(result, _DebugResult): + raise + self._createClassOrModuleLevelException(result, e, + 'tearDownModule', + previousModule) + try: + case.doModuleCleanups() + except Exception as e: + if isinstance(result, _DebugResult): + raise + self._createClassOrModuleLevelException(result, e, + 'tearDownModule', + previousModule) + finally: + _call_if_exists(result, '_restoreStdout') + + def _tearDownPreviousClass(self, test, result): + previousClass = getattr(result, '_previousTestClass', None) + currentClass = test.__class__ + if currentClass == previousClass or previousClass is None: + return + if getattr(previousClass, '_classSetupFailed', False): + return + if getattr(result, '_moduleSetUpFailed', False): + return + if getattr(previousClass, "__unittest_skip__", False): + return + + tearDownClass = getattr(previousClass, 'tearDownClass', None) + doClassCleanups = getattr(previousClass, 'doClassCleanups', None) + if tearDownClass is None and doClassCleanups is None: + return + + _call_if_exists(result, '_setupStdout') + try: + if tearDownClass is not None: + try: + tearDownClass() + except Exception as e: + if isinstance(result, _DebugResult): + raise + className = util.strclass(previousClass) + self._createClassOrModuleLevelException(result, e, + 'tearDownClass', + className) + if doClassCleanups is not None: + doClassCleanups() + for exc_info in previousClass.tearDown_exceptions: + if isinstance(result, _DebugResult): + raise exc_info[1] + className = util.strclass(previousClass) + self._createClassOrModuleLevelException(result, exc_info[1], + 'tearDownClass', + className, + info=exc_info) + finally: + _call_if_exists(result, '_restoreStdout') + + +class _ErrorHolder(object): + """ + Placeholder for a TestCase inside a result. As far as a TestResult + is concerned, this looks exactly like a unit test. Used to insert + arbitrary errors into a test suite run. + """ + # Inspired by the ErrorHolder from Twisted: + # http://twistedmatrix.com/trac/browser/trunk/twisted/trial/runner.py + + # attribute used by TestResult._exc_info_to_string + failureException = None + + def __init__(self, description): + self.description = description + + def id(self): + return self.description + + def shortDescription(self): + return None + + def __repr__(self): + return "" % (self.description,) + + def __str__(self): + return self.id() + + def run(self, result): + # could call result.addError(...) - but this test-like object + # shouldn't be run anyway + pass + + def __call__(self, result): + return self.run(result) + + def countTestCases(self): + return 0 + +def _isnotsuite(test): + "A crude way to tell apart testcases and suites with duck-typing" + try: + iter(test) + except TypeError: + return True + return False + + +class _DebugResult(object): + "Used by the TestSuite to hold previous class when running in debug." + _previousTestClass = None + _moduleSetUpFailed = False + shouldStop = False diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/util.py b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/util.py new file mode 100644 index 0000000000000000000000000000000000000000..050eaed0b3f58fb09d1797f81c19de44110c511e --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/unittest/util.py @@ -0,0 +1,170 @@ +"""Various utility functions.""" + +from collections import namedtuple, Counter +from os.path import commonprefix + +__unittest = True + +_MAX_LENGTH = 80 +_PLACEHOLDER_LEN = 12 +_MIN_BEGIN_LEN = 5 +_MIN_END_LEN = 5 +_MIN_COMMON_LEN = 5 +_MIN_DIFF_LEN = _MAX_LENGTH - \ + (_MIN_BEGIN_LEN + _PLACEHOLDER_LEN + _MIN_COMMON_LEN + + _PLACEHOLDER_LEN + _MIN_END_LEN) +assert _MIN_DIFF_LEN >= 0 + +def _shorten(s, prefixlen, suffixlen): + skip = len(s) - prefixlen - suffixlen + if skip > _PLACEHOLDER_LEN: + s = '%s[%d chars]%s' % (s[:prefixlen], skip, s[len(s) - suffixlen:]) + return s + +def _common_shorten_repr(*args): + args = tuple(map(safe_repr, args)) + maxlen = max(map(len, args)) + if maxlen <= _MAX_LENGTH: + return args + + prefix = commonprefix(args) + prefixlen = len(prefix) + + common_len = _MAX_LENGTH - \ + (maxlen - prefixlen + _MIN_BEGIN_LEN + _PLACEHOLDER_LEN) + if common_len > _MIN_COMMON_LEN: + assert _MIN_BEGIN_LEN + _PLACEHOLDER_LEN + _MIN_COMMON_LEN + \ + (maxlen - prefixlen) < _MAX_LENGTH + prefix = _shorten(prefix, _MIN_BEGIN_LEN, common_len) + return tuple(prefix + s[prefixlen:] for s in args) + + prefix = _shorten(prefix, _MIN_BEGIN_LEN, _MIN_COMMON_LEN) + return tuple(prefix + _shorten(s[prefixlen:], _MIN_DIFF_LEN, _MIN_END_LEN) + for s in args) + +def safe_repr(obj, short=False): + try: + result = repr(obj) + except Exception: + result = object.__repr__(obj) + if not short or len(result) < _MAX_LENGTH: + return result + return result[:_MAX_LENGTH] + ' [truncated]...' + +def strclass(cls): + return "%s.%s" % (cls.__module__, cls.__qualname__) + +def sorted_list_difference(expected, actual): + """Finds elements in only one or the other of two, sorted input lists. + + Returns a two-element tuple of lists. The first list contains those + elements in the "expected" list but not in the "actual" list, and the + second contains those elements in the "actual" list but not in the + "expected" list. Duplicate elements in either input list are ignored. + """ + i = j = 0 + missing = [] + unexpected = [] + while True: + try: + e = expected[i] + a = actual[j] + if e < a: + missing.append(e) + i += 1 + while expected[i] == e: + i += 1 + elif e > a: + unexpected.append(a) + j += 1 + while actual[j] == a: + j += 1 + else: + i += 1 + try: + while expected[i] == e: + i += 1 + finally: + j += 1 + while actual[j] == a: + j += 1 + except IndexError: + missing.extend(expected[i:]) + unexpected.extend(actual[j:]) + break + return missing, unexpected + + +def unorderable_list_difference(expected, actual): + """Same behavior as sorted_list_difference but + for lists of unorderable items (like dicts). + + As it does a linear search per item (remove) it + has O(n*n) performance.""" + missing = [] + while expected: + item = expected.pop() + try: + actual.remove(item) + except ValueError: + missing.append(item) + + # anything left in actual is unexpected + return missing, actual + +def three_way_cmp(x, y): + """Return -1 if x < y, 0 if x == y and 1 if x > y""" + return (x > y) - (x < y) + +_Mismatch = namedtuple('Mismatch', 'actual expected value') + +def _count_diff_all_purpose(actual, expected): + 'Returns list of (cnt_act, cnt_exp, elem) triples where the counts differ' + # elements need not be hashable + s, t = list(actual), list(expected) + m, n = len(s), len(t) + NULL = object() + result = [] + for i, elem in enumerate(s): + if elem is NULL: + continue + cnt_s = cnt_t = 0 + for j in range(i, m): + if s[j] == elem: + cnt_s += 1 + s[j] = NULL + for j, other_elem in enumerate(t): + if other_elem == elem: + cnt_t += 1 + t[j] = NULL + if cnt_s != cnt_t: + diff = _Mismatch(cnt_s, cnt_t, elem) + result.append(diff) + + for i, elem in enumerate(t): + if elem is NULL: + continue + cnt_t = 0 + for j in range(i, n): + if t[j] == elem: + cnt_t += 1 + t[j] = NULL + diff = _Mismatch(0, cnt_t, elem) + result.append(diff) + return result + +def _count_diff_hashable(actual, expected): + 'Returns list of (cnt_act, cnt_exp, elem) triples where the counts differ' + # elements must be hashable + s, t = Counter(actual), Counter(expected) + result = [] + for elem, cnt_s in s.items(): + cnt_t = t.get(elem, 0) + if cnt_s != cnt_t: + diff = _Mismatch(cnt_s, cnt_t, elem) + result.append(diff) + for elem, cnt_t in t.items(): + if elem not in s: + diff = _Mismatch(0, cnt_t, elem) + result.append(diff) + return result diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1f35ee07f3dc7fc3b0574272f8254b50603e4448 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/error.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/error.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..54c157dbf72bac8e21cd5dbe8821de216b627bfc Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/error.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/parse.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/parse.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4a89e696c029bfa0d971781bcb80ac747d335033 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/parse.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/request.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/request.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af874c509a0c49331e0156e03677e005b83ddb9f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/request.cpython-311.pyc @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a1224e9113221acb520f9851d9f4338adbde9f11b8d3d6115ac8477bc58369e4 +size 127863 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/response.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/response.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..21870d0c3b852637622b8c40539f97085d356294 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/response.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/robotparser.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/robotparser.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b46f8a6b2357636ac5cf312f6e416d4667fcbca Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/robotparser.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/error.py b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/error.py new file mode 100644 index 0000000000000000000000000000000000000000..a9cd1ecadd63f2b09ee4363fc283e8f1f5cbbb3b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/error.py @@ -0,0 +1,74 @@ +"""Exception classes raised by urllib. + +The base exception class is URLError, which inherits from OSError. It +doesn't define any behavior of its own, but is the base class for all +exceptions defined in this package. + +HTTPError is an exception class that is also a valid HTTP response +instance. It behaves this way because HTTP protocol errors are valid +responses, with a status code, headers, and a body. In some contexts, +an application may want to handle an exception like a regular +response. +""" +import io +import urllib.response + +__all__ = ['URLError', 'HTTPError', 'ContentTooShortError'] + + +class URLError(OSError): + # URLError is a sub-type of OSError, but it doesn't share any of + # the implementation. need to override __init__ and __str__. + # It sets self.args for compatibility with other OSError + # subclasses, but args doesn't have the typical format with errno in + # slot 0 and strerror in slot 1. This may be better than nothing. + def __init__(self, reason, filename=None): + self.args = reason, + self.reason = reason + if filename is not None: + self.filename = filename + + def __str__(self): + return '' % self.reason + + +class HTTPError(URLError, urllib.response.addinfourl): + """Raised when HTTP error occurs, but also acts like non-error return""" + __super_init = urllib.response.addinfourl.__init__ + + def __init__(self, url, code, msg, hdrs, fp): + self.code = code + self.msg = msg + self.hdrs = hdrs + self.fp = fp + self.filename = url + if fp is None: + fp = io.BytesIO() + self.__super_init(fp, hdrs, url, code) + + def __str__(self): + return 'HTTP Error %s: %s' % (self.code, self.msg) + + def __repr__(self): + return '' % (self.code, self.msg) + + # since URLError specifies a .reason attribute, HTTPError should also + # provide this attribute. See issue13211 for discussion. + @property + def reason(self): + return self.msg + + @property + def headers(self): + return self.hdrs + + @headers.setter + def headers(self, headers): + self.hdrs = headers + + +class ContentTooShortError(URLError): + """Exception raised when downloaded size does not match content-length.""" + def __init__(self, message, content): + URLError.__init__(self, message) + self.content = content diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/parse.py b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/parse.py new file mode 100644 index 0000000000000000000000000000000000000000..724cce8d39785d5031d68d3fb05857800b3f9c39 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/parse.py @@ -0,0 +1,1243 @@ +"""Parse (absolute and relative) URLs. + +urlparse module is based upon the following RFC specifications. + +RFC 3986 (STD66): "Uniform Resource Identifiers" by T. Berners-Lee, R. Fielding +and L. Masinter, January 2005. + +RFC 2732 : "Format for Literal IPv6 Addresses in URL's by R.Hinden, B.Carpenter +and L.Masinter, December 1999. + +RFC 2396: "Uniform Resource Identifiers (URI)": Generic Syntax by T. +Berners-Lee, R. Fielding, and L. Masinter, August 1998. + +RFC 2368: "The mailto URL scheme", by P.Hoffman , L Masinter, J. Zawinski, July 1998. + +RFC 1808: "Relative Uniform Resource Locators", by R. Fielding, UC Irvine, June +1995. + +RFC 1738: "Uniform Resource Locators (URL)" by T. Berners-Lee, L. Masinter, M. +McCahill, December 1994 + +RFC 3986 is considered the current standard and any future changes to +urlparse module should conform with it. The urlparse module is +currently not entirely compliant with this RFC due to defacto +scenarios for parsing, and for backward compatibility purposes, some +parsing quirks from older RFCs are retained. The testcases in +test_urlparse.py provides a good indicator of parsing behavior. + +The WHATWG URL Parser spec should also be considered. We are not compliant with +it either due to existing user code API behavior expectations (Hyrum's Law). +It serves as a useful guide when making changes. +""" + +from collections import namedtuple +import functools +import re +import sys +import types +import warnings +import ipaddress + +__all__ = ["urlparse", "urlunparse", "urljoin", "urldefrag", + "urlsplit", "urlunsplit", "urlencode", "parse_qs", + "parse_qsl", "quote", "quote_plus", "quote_from_bytes", + "unquote", "unquote_plus", "unquote_to_bytes", + "DefragResult", "ParseResult", "SplitResult", + "DefragResultBytes", "ParseResultBytes", "SplitResultBytes"] + +# A classification of schemes. +# The empty string classifies URLs with no scheme specified, +# being the default value returned by “urlsplit” and “urlparse”. + +uses_relative = ['', 'ftp', 'http', 'gopher', 'nntp', 'imap', + 'wais', 'file', 'https', 'shttp', 'mms', + 'prospero', 'rtsp', 'rtsps', 'rtspu', 'sftp', + 'svn', 'svn+ssh', 'ws', 'wss'] + +uses_netloc = ['', 'ftp', 'http', 'gopher', 'nntp', 'telnet', + 'imap', 'wais', 'file', 'mms', 'https', 'shttp', + 'snews', 'prospero', 'rtsp', 'rtsps', 'rtspu', 'rsync', + 'svn', 'svn+ssh', 'sftp', 'nfs', 'git', 'git+ssh', + 'ws', 'wss'] + +uses_params = ['', 'ftp', 'hdl', 'prospero', 'http', 'imap', + 'https', 'shttp', 'rtsp', 'rtsps', 'rtspu', 'sip', + 'sips', 'mms', 'sftp', 'tel'] + +# These are not actually used anymore, but should stay for backwards +# compatibility. (They are undocumented, but have a public-looking name.) + +non_hierarchical = ['gopher', 'hdl', 'mailto', 'news', + 'telnet', 'wais', 'imap', 'snews', 'sip', 'sips'] + +uses_query = ['', 'http', 'wais', 'imap', 'https', 'shttp', 'mms', + 'gopher', 'rtsp', 'rtsps', 'rtspu', 'sip', 'sips'] + +uses_fragment = ['', 'ftp', 'hdl', 'http', 'gopher', 'news', + 'nntp', 'wais', 'https', 'shttp', 'snews', + 'file', 'prospero'] + +# Characters valid in scheme names +scheme_chars = ('abcdefghijklmnopqrstuvwxyz' + 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + '0123456789' + '+-.') + +# Leading and trailing C0 control and space to be stripped per WHATWG spec. +# == "".join([chr(i) for i in range(0, 0x20 + 1)]) +_WHATWG_C0_CONTROL_OR_SPACE = '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f ' + +# Unsafe bytes to be removed per WHATWG spec +_UNSAFE_URL_BYTES_TO_REMOVE = ['\t', '\r', '\n'] + +def clear_cache(): + """Clear internal performance caches. Undocumented; some tests want it.""" + urlsplit.cache_clear() + _byte_quoter_factory.cache_clear() + +# Helpers for bytes handling +# For 3.2, we deliberately require applications that +# handle improperly quoted URLs to do their own +# decoding and encoding. If valid use cases are +# presented, we may relax this by using latin-1 +# decoding internally for 3.3 +_implicit_encoding = 'ascii' +_implicit_errors = 'strict' + +def _noop(obj): + return obj + +def _encode_result(obj, encoding=_implicit_encoding, + errors=_implicit_errors): + return obj.encode(encoding, errors) + +def _decode_args(args, encoding=_implicit_encoding, + errors=_implicit_errors): + return tuple(x.decode(encoding, errors) if x else '' for x in args) + +def _coerce_args(*args): + # Invokes decode if necessary to create str args + # and returns the coerced inputs along with + # an appropriate result coercion function + # - noop for str inputs + # - encoding function otherwise + str_input = isinstance(args[0], str) + for arg in args[1:]: + # We special-case the empty string to support the + # "scheme=''" default argument to some functions + if arg and isinstance(arg, str) != str_input: + raise TypeError("Cannot mix str and non-str arguments") + if str_input: + return args + (_noop,) + return _decode_args(args) + (_encode_result,) + +# Result objects are more helpful than simple tuples +class _ResultMixinStr(object): + """Standard approach to encoding parsed results from str to bytes""" + __slots__ = () + + def encode(self, encoding='ascii', errors='strict'): + return self._encoded_counterpart(*(x.encode(encoding, errors) for x in self)) + + +class _ResultMixinBytes(object): + """Standard approach to decoding parsed results from bytes to str""" + __slots__ = () + + def decode(self, encoding='ascii', errors='strict'): + return self._decoded_counterpart(*(x.decode(encoding, errors) for x in self)) + + +class _NetlocResultMixinBase(object): + """Shared methods for the parsed result objects containing a netloc element""" + __slots__ = () + + @property + def username(self): + return self._userinfo[0] + + @property + def password(self): + return self._userinfo[1] + + @property + def hostname(self): + hostname = self._hostinfo[0] + if not hostname: + return None + # Scoped IPv6 address may have zone info, which must not be lowercased + # like http://[fe80::822a:a8ff:fe49:470c%tESt]:1234/keys + separator = '%' if isinstance(hostname, str) else b'%' + hostname, percent, zone = hostname.partition(separator) + return hostname.lower() + percent + zone + + @property + def port(self): + port = self._hostinfo[1] + if port is not None: + if port.isdigit() and port.isascii(): + port = int(port) + else: + raise ValueError(f"Port could not be cast to integer value as {port!r}") + if not (0 <= port <= 65535): + raise ValueError("Port out of range 0-65535") + return port + + __class_getitem__ = classmethod(types.GenericAlias) + + +class _NetlocResultMixinStr(_NetlocResultMixinBase, _ResultMixinStr): + __slots__ = () + + @property + def _userinfo(self): + netloc = self.netloc + userinfo, have_info, hostinfo = netloc.rpartition('@') + if have_info: + username, have_password, password = userinfo.partition(':') + if not have_password: + password = None + else: + username = password = None + return username, password + + @property + def _hostinfo(self): + netloc = self.netloc + _, _, hostinfo = netloc.rpartition('@') + _, have_open_br, bracketed = hostinfo.partition('[') + if have_open_br: + hostname, _, port = bracketed.partition(']') + _, _, port = port.partition(':') + else: + hostname, _, port = hostinfo.partition(':') + if not port: + port = None + return hostname, port + + +class _NetlocResultMixinBytes(_NetlocResultMixinBase, _ResultMixinBytes): + __slots__ = () + + @property + def _userinfo(self): + netloc = self.netloc + userinfo, have_info, hostinfo = netloc.rpartition(b'@') + if have_info: + username, have_password, password = userinfo.partition(b':') + if not have_password: + password = None + else: + username = password = None + return username, password + + @property + def _hostinfo(self): + netloc = self.netloc + _, _, hostinfo = netloc.rpartition(b'@') + _, have_open_br, bracketed = hostinfo.partition(b'[') + if have_open_br: + hostname, _, port = bracketed.partition(b']') + _, _, port = port.partition(b':') + else: + hostname, _, port = hostinfo.partition(b':') + if not port: + port = None + return hostname, port + + +_DefragResultBase = namedtuple('DefragResult', 'url fragment') +_SplitResultBase = namedtuple( + 'SplitResult', 'scheme netloc path query fragment') +_ParseResultBase = namedtuple( + 'ParseResult', 'scheme netloc path params query fragment') + +_DefragResultBase.__doc__ = """ +DefragResult(url, fragment) + +A 2-tuple that contains the url without fragment identifier and the fragment +identifier as a separate argument. +""" + +_DefragResultBase.url.__doc__ = """The URL with no fragment identifier.""" + +_DefragResultBase.fragment.__doc__ = """ +Fragment identifier separated from URL, that allows indirect identification of a +secondary resource by reference to a primary resource and additional identifying +information. +""" + +_SplitResultBase.__doc__ = """ +SplitResult(scheme, netloc, path, query, fragment) + +A 5-tuple that contains the different components of a URL. Similar to +ParseResult, but does not split params. +""" + +_SplitResultBase.scheme.__doc__ = """Specifies URL scheme for the request.""" + +_SplitResultBase.netloc.__doc__ = """ +Network location where the request is made to. +""" + +_SplitResultBase.path.__doc__ = """ +The hierarchical path, such as the path to a file to download. +""" + +_SplitResultBase.query.__doc__ = """ +The query component, that contains non-hierarchical data, that along with data +in path component, identifies a resource in the scope of URI's scheme and +network location. +""" + +_SplitResultBase.fragment.__doc__ = """ +Fragment identifier, that allows indirect identification of a secondary resource +by reference to a primary resource and additional identifying information. +""" + +_ParseResultBase.__doc__ = """ +ParseResult(scheme, netloc, path, params, query, fragment) + +A 6-tuple that contains components of a parsed URL. +""" + +_ParseResultBase.scheme.__doc__ = _SplitResultBase.scheme.__doc__ +_ParseResultBase.netloc.__doc__ = _SplitResultBase.netloc.__doc__ +_ParseResultBase.path.__doc__ = _SplitResultBase.path.__doc__ +_ParseResultBase.params.__doc__ = """ +Parameters for last path element used to dereference the URI in order to provide +access to perform some operation on the resource. +""" + +_ParseResultBase.query.__doc__ = _SplitResultBase.query.__doc__ +_ParseResultBase.fragment.__doc__ = _SplitResultBase.fragment.__doc__ + + +# For backwards compatibility, alias _NetlocResultMixinStr +# ResultBase is no longer part of the documented API, but it is +# retained since deprecating it isn't worth the hassle +ResultBase = _NetlocResultMixinStr + +# Structured result objects for string data +class DefragResult(_DefragResultBase, _ResultMixinStr): + __slots__ = () + def geturl(self): + if self.fragment: + return self.url + '#' + self.fragment + else: + return self.url + +class SplitResult(_SplitResultBase, _NetlocResultMixinStr): + __slots__ = () + def geturl(self): + return urlunsplit(self) + +class ParseResult(_ParseResultBase, _NetlocResultMixinStr): + __slots__ = () + def geturl(self): + return urlunparse(self) + +# Structured result objects for bytes data +class DefragResultBytes(_DefragResultBase, _ResultMixinBytes): + __slots__ = () + def geturl(self): + if self.fragment: + return self.url + b'#' + self.fragment + else: + return self.url + +class SplitResultBytes(_SplitResultBase, _NetlocResultMixinBytes): + __slots__ = () + def geturl(self): + return urlunsplit(self) + +class ParseResultBytes(_ParseResultBase, _NetlocResultMixinBytes): + __slots__ = () + def geturl(self): + return urlunparse(self) + +# Set up the encode/decode result pairs +def _fix_result_transcoding(): + _result_pairs = ( + (DefragResult, DefragResultBytes), + (SplitResult, SplitResultBytes), + (ParseResult, ParseResultBytes), + ) + for _decoded, _encoded in _result_pairs: + _decoded._encoded_counterpart = _encoded + _encoded._decoded_counterpart = _decoded + +_fix_result_transcoding() +del _fix_result_transcoding + +def urlparse(url, scheme='', allow_fragments=True): + """Parse a URL into 6 components: + :///;?# + + The result is a named 6-tuple with fields corresponding to the + above. It is either a ParseResult or ParseResultBytes object, + depending on the type of the url parameter. + + The username, password, hostname, and port sub-components of netloc + can also be accessed as attributes of the returned object. + + The scheme argument provides the default value of the scheme + component when no scheme is found in url. + + If allow_fragments is False, no attempt is made to separate the + fragment component from the previous component, which can be either + path or query. + + Note that % escapes are not expanded. + """ + url, scheme, _coerce_result = _coerce_args(url, scheme) + splitresult = urlsplit(url, scheme, allow_fragments) + scheme, netloc, url, query, fragment = splitresult + if scheme in uses_params and ';' in url: + url, params = _splitparams(url) + else: + params = '' + result = ParseResult(scheme, netloc, url, params, query, fragment) + return _coerce_result(result) + +def _splitparams(url): + if '/' in url: + i = url.find(';', url.rfind('/')) + if i < 0: + return url, '' + else: + i = url.find(';') + return url[:i], url[i+1:] + +def _splitnetloc(url, start=0): + delim = len(url) # position of end of domain part of url, default is end + for c in '/?#': # look for delimiters; the order is NOT important + wdelim = url.find(c, start) # find first of this delim + if wdelim >= 0: # if found + delim = min(delim, wdelim) # use earliest delim position + return url[start:delim], url[delim:] # return (domain, rest) + +def _checknetloc(netloc): + if not netloc or netloc.isascii(): + return + # looking for characters like \u2100 that expand to 'a/c' + # IDNA uses NFKC equivalence, so normalize for this check + import unicodedata + n = netloc.replace('@', '') # ignore characters already included + n = n.replace(':', '') # but not the surrounding text + n = n.replace('#', '') + n = n.replace('?', '') + netloc2 = unicodedata.normalize('NFKC', n) + if n == netloc2: + return + for c in '/?#@:': + if c in netloc2: + raise ValueError("netloc '" + netloc + "' contains invalid " + + "characters under NFKC normalization") + +def _check_bracketed_netloc(netloc): + # Note that this function must mirror the splitting + # done in NetlocResultMixins._hostinfo(). + hostname_and_port = netloc.rpartition('@')[2] + before_bracket, have_open_br, bracketed = hostname_and_port.partition('[') + if have_open_br: + # No data is allowed before a bracket. + if before_bracket: + raise ValueError("Invalid IPv6 URL") + hostname, _, port = bracketed.partition(']') + # No data is allowed after the bracket but before the port delimiter. + if port and not port.startswith(":"): + raise ValueError("Invalid IPv6 URL") + else: + hostname, _, port = hostname_and_port.partition(':') + _check_bracketed_host(hostname) + +# Valid bracketed hosts are defined in +# https://www.rfc-editor.org/rfc/rfc3986#page-49 and https://url.spec.whatwg.org/ +def _check_bracketed_host(hostname): + if hostname.startswith('v'): + if not re.match(r"\Av[a-fA-F0-9]+\..+\Z", hostname): + raise ValueError(f"IPvFuture address is invalid") + else: + ip = ipaddress.ip_address(hostname) # Throws Value Error if not IPv6 or IPv4 + if isinstance(ip, ipaddress.IPv4Address): + raise ValueError(f"An IPv4 address cannot be in brackets") + +# typed=True avoids BytesWarnings being emitted during cache key +# comparison since this API supports both bytes and str input. +@functools.lru_cache(typed=True) +def urlsplit(url, scheme='', allow_fragments=True): + """Parse a URL into 5 components: + :///?# + + The result is a named 5-tuple with fields corresponding to the + above. It is either a SplitResult or SplitResultBytes object, + depending on the type of the url parameter. + + The username, password, hostname, and port sub-components of netloc + can also be accessed as attributes of the returned object. + + The scheme argument provides the default value of the scheme + component when no scheme is found in url. + + If allow_fragments is False, no attempt is made to separate the + fragment component from the previous component, which can be either + path or query. + + Note that % escapes are not expanded. + """ + + url, scheme, _coerce_result = _coerce_args(url, scheme) + # Only lstrip url as some applications rely on preserving trailing space. + # (https://url.spec.whatwg.org/#concept-basic-url-parser would strip both) + url = url.lstrip(_WHATWG_C0_CONTROL_OR_SPACE) + scheme = scheme.strip(_WHATWG_C0_CONTROL_OR_SPACE) + + for b in _UNSAFE_URL_BYTES_TO_REMOVE: + url = url.replace(b, "") + scheme = scheme.replace(b, "") + + allow_fragments = bool(allow_fragments) + netloc = query = fragment = '' + i = url.find(':') + if i > 0 and url[0].isascii() and url[0].isalpha(): + for c in url[:i]: + if c not in scheme_chars: + break + else: + scheme, url = url[:i].lower(), url[i+1:] + if url[:2] == '//': + netloc, url = _splitnetloc(url, 2) + if (('[' in netloc and ']' not in netloc) or + (']' in netloc and '[' not in netloc)): + raise ValueError("Invalid IPv6 URL") + if '[' in netloc and ']' in netloc: + _check_bracketed_netloc(netloc) + if allow_fragments and '#' in url: + url, fragment = url.split('#', 1) + if '?' in url: + url, query = url.split('?', 1) + _checknetloc(netloc) + v = SplitResult(scheme, netloc, url, query, fragment) + return _coerce_result(v) + +def urlunparse(components): + """Put a parsed URL back together again. This may result in a + slightly different, but equivalent URL, if the URL that was parsed + originally had redundant delimiters, e.g. a ? with an empty query + (the draft states that these are equivalent).""" + scheme, netloc, url, params, query, fragment, _coerce_result = ( + _coerce_args(*components)) + if params: + url = "%s;%s" % (url, params) + return _coerce_result(urlunsplit((scheme, netloc, url, query, fragment))) + +def urlunsplit(components): + """Combine the elements of a tuple as returned by urlsplit() into a + complete URL as a string. The data argument can be any five-item iterable. + This may result in a slightly different, but equivalent URL, if the URL that + was parsed originally had unnecessary delimiters (for example, a ? with an + empty query; the RFC states that these are equivalent).""" + scheme, netloc, url, query, fragment, _coerce_result = ( + _coerce_args(*components)) + if netloc or (scheme and scheme in uses_netloc) or url[:2] == '//': + if url and url[:1] != '/': url = '/' + url + url = '//' + (netloc or '') + url + if scheme: + url = scheme + ':' + url + if query: + url = url + '?' + query + if fragment: + url = url + '#' + fragment + return _coerce_result(url) + +def urljoin(base, url, allow_fragments=True): + """Join a base URL and a possibly relative URL to form an absolute + interpretation of the latter.""" + if not base: + return url + if not url: + return base + + base, url, _coerce_result = _coerce_args(base, url) + bscheme, bnetloc, bpath, bparams, bquery, bfragment = \ + urlparse(base, '', allow_fragments) + scheme, netloc, path, params, query, fragment = \ + urlparse(url, bscheme, allow_fragments) + + if scheme != bscheme or scheme not in uses_relative: + return _coerce_result(url) + if scheme in uses_netloc: + if netloc: + return _coerce_result(urlunparse((scheme, netloc, path, + params, query, fragment))) + netloc = bnetloc + + if not path and not params: + path = bpath + params = bparams + if not query: + query = bquery + return _coerce_result(urlunparse((scheme, netloc, path, + params, query, fragment))) + + base_parts = bpath.split('/') + if base_parts[-1] != '': + # the last item is not a directory, so will not be taken into account + # in resolving the relative path + del base_parts[-1] + + # for rfc3986, ignore all base path should the first character be root. + if path[:1] == '/': + segments = path.split('/') + else: + segments = base_parts + path.split('/') + # filter out elements that would cause redundant slashes on re-joining + # the resolved_path + segments[1:-1] = filter(None, segments[1:-1]) + + resolved_path = [] + + for seg in segments: + if seg == '..': + try: + resolved_path.pop() + except IndexError: + # ignore any .. segments that would otherwise cause an IndexError + # when popped from resolved_path if resolving for rfc3986 + pass + elif seg == '.': + continue + else: + resolved_path.append(seg) + + if segments[-1] in ('.', '..'): + # do some post-processing here. if the last segment was a relative dir, + # then we need to append the trailing '/' + resolved_path.append('') + + return _coerce_result(urlunparse((scheme, netloc, '/'.join( + resolved_path) or '/', params, query, fragment))) + + +def urldefrag(url): + """Removes any existing fragment from URL. + + Returns a tuple of the defragmented URL and the fragment. If + the URL contained no fragments, the second element is the + empty string. + """ + url, _coerce_result = _coerce_args(url) + if '#' in url: + s, n, p, a, q, frag = urlparse(url) + defrag = urlunparse((s, n, p, a, q, '')) + else: + frag = '' + defrag = url + return _coerce_result(DefragResult(defrag, frag)) + +_hexdig = '0123456789ABCDEFabcdef' +_hextobyte = None + +def unquote_to_bytes(string): + """unquote_to_bytes('abc%20def') -> b'abc def'.""" + # Note: strings are encoded as UTF-8. This is only an issue if it contains + # unescaped non-ASCII characters, which URIs should not. + if not string: + # Is it a string-like object? + string.split + return b'' + if isinstance(string, str): + string = string.encode('utf-8') + bits = string.split(b'%') + if len(bits) == 1: + return string + res = [bits[0]] + append = res.append + # Delay the initialization of the table to not waste memory + # if the function is never called + global _hextobyte + if _hextobyte is None: + _hextobyte = {(a + b).encode(): bytes.fromhex(a + b) + for a in _hexdig for b in _hexdig} + for item in bits[1:]: + try: + append(_hextobyte[item[:2]]) + append(item[2:]) + except KeyError: + append(b'%') + append(item) + return b''.join(res) + +_asciire = re.compile('([\x00-\x7f]+)') + +def unquote(string, encoding='utf-8', errors='replace'): + """Replace %xx escapes by their single-character equivalent. The optional + encoding and errors parameters specify how to decode percent-encoded + sequences into Unicode characters, as accepted by the bytes.decode() + method. + By default, percent-encoded sequences are decoded with UTF-8, and invalid + sequences are replaced by a placeholder character. + + unquote('abc%20def') -> 'abc def'. + """ + if isinstance(string, bytes): + return unquote_to_bytes(string).decode(encoding, errors) + if '%' not in string: + string.split + return string + if encoding is None: + encoding = 'utf-8' + if errors is None: + errors = 'replace' + bits = _asciire.split(string) + res = [bits[0]] + append = res.append + for i in range(1, len(bits), 2): + append(unquote_to_bytes(bits[i]).decode(encoding, errors)) + append(bits[i + 1]) + return ''.join(res) + + +def parse_qs(qs, keep_blank_values=False, strict_parsing=False, + encoding='utf-8', errors='replace', max_num_fields=None, separator='&'): + """Parse a query given as a string argument. + + Arguments: + + qs: percent-encoded query string to be parsed + + keep_blank_values: flag indicating whether blank values in + percent-encoded queries should be treated as blank strings. + A true value indicates that blanks should be retained as + blank strings. The default false value indicates that + blank values are to be ignored and treated as if they were + not included. + + strict_parsing: flag indicating what to do with parsing errors. + If false (the default), errors are silently ignored. + If true, errors raise a ValueError exception. + + encoding and errors: specify how to decode percent-encoded sequences + into Unicode characters, as accepted by the bytes.decode() method. + + max_num_fields: int. If set, then throws a ValueError if there + are more than n fields read by parse_qsl(). + + separator: str. The symbol to use for separating the query arguments. + Defaults to &. + + Returns a dictionary. + """ + parsed_result = {} + pairs = parse_qsl(qs, keep_blank_values, strict_parsing, + encoding=encoding, errors=errors, + max_num_fields=max_num_fields, separator=separator) + for name, value in pairs: + if name in parsed_result: + parsed_result[name].append(value) + else: + parsed_result[name] = [value] + return parsed_result + + +def parse_qsl(qs, keep_blank_values=False, strict_parsing=False, + encoding='utf-8', errors='replace', max_num_fields=None, separator='&'): + """Parse a query given as a string argument. + + Arguments: + + qs: percent-encoded query string to be parsed + + keep_blank_values: flag indicating whether blank values in + percent-encoded queries should be treated as blank strings. + A true value indicates that blanks should be retained as blank + strings. The default false value indicates that blank values + are to be ignored and treated as if they were not included. + + strict_parsing: flag indicating what to do with parsing errors. If + false (the default), errors are silently ignored. If true, + errors raise a ValueError exception. + + encoding and errors: specify how to decode percent-encoded sequences + into Unicode characters, as accepted by the bytes.decode() method. + + max_num_fields: int. If set, then throws a ValueError + if there are more than n fields read by parse_qsl(). + + separator: str. The symbol to use for separating the query arguments. + Defaults to &. + + Returns a list, as G-d intended. + """ + + if not separator or not isinstance(separator, (str, bytes)): + raise ValueError("Separator must be of type string or bytes.") + if isinstance(qs, str): + if not isinstance(separator, str): + separator = str(separator, 'ascii') + eq = '=' + def _unquote(s): + return unquote_plus(s, encoding=encoding, errors=errors) + else: + if not qs: + return [] + # Use memoryview() to reject integers and iterables, + # acceptable by the bytes constructor. + qs = bytes(memoryview(qs)) + if isinstance(separator, str): + separator = bytes(separator, 'ascii') + eq = b'=' + def _unquote(s): + return unquote_to_bytes(s.replace(b'+', b' ')) + + if not qs: + return [] + + # If max_num_fields is defined then check that the number of fields + # is less than max_num_fields. This prevents a memory exhaustion DOS + # attack via post bodies with many fields. + if max_num_fields is not None: + num_fields = 1 + qs.count(separator) + if max_num_fields < num_fields: + raise ValueError('Max number of fields exceeded') + + r = [] + for name_value in qs.split(separator): + if name_value or strict_parsing: + name, has_eq, value = name_value.partition(eq) + if not has_eq and strict_parsing: + raise ValueError("bad query field: %r" % (name_value,)) + if value or keep_blank_values: + name = _unquote(name) + value = _unquote(value) + r.append((name, value)) + return r + +def unquote_plus(string, encoding='utf-8', errors='replace'): + """Like unquote(), but also replace plus signs by spaces, as required for + unquoting HTML form values. + + unquote_plus('%7e/abc+def') -> '~/abc def' + """ + string = string.replace('+', ' ') + return unquote(string, encoding, errors) + +_ALWAYS_SAFE = frozenset(b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + b'abcdefghijklmnopqrstuvwxyz' + b'0123456789' + b'_.-~') +_ALWAYS_SAFE_BYTES = bytes(_ALWAYS_SAFE) + +def __getattr__(name): + if name == 'Quoter': + warnings.warn('Deprecated in 3.11. ' + 'urllib.parse.Quoter will be removed in Python 3.14. ' + 'It was not intended to be a public API.', + DeprecationWarning, stacklevel=2) + return _Quoter + raise AttributeError(f'module {__name__!r} has no attribute {name!r}') + +class _Quoter(dict): + """A mapping from bytes numbers (in range(0,256)) to strings. + + String values are percent-encoded byte values, unless the key < 128, and + in either of the specified safe set, or the always safe set. + """ + # Keeps a cache internally, via __missing__, for efficiency (lookups + # of cached keys don't call Python code at all). + def __init__(self, safe): + """safe: bytes object.""" + self.safe = _ALWAYS_SAFE.union(safe) + + def __repr__(self): + return f"" + + def __missing__(self, b): + # Handle a cache miss. Store quoted string in cache and return. + res = chr(b) if b in self.safe else '%{:02X}'.format(b) + self[b] = res + return res + +def quote(string, safe='/', encoding=None, errors=None): + """quote('abc def') -> 'abc%20def' + + Each part of a URL, e.g. the path info, the query, etc., has a + different set of reserved characters that must be quoted. The + quote function offers a cautious (not minimal) way to quote a + string for most of these parts. + + RFC 3986 Uniform Resource Identifier (URI): Generic Syntax lists + the following (un)reserved characters. + + unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" + reserved = gen-delims / sub-delims + gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@" + sub-delims = "!" / "$" / "&" / "'" / "(" / ")" + / "*" / "+" / "," / ";" / "=" + + Each of the reserved characters is reserved in some component of a URL, + but not necessarily in all of them. + + The quote function %-escapes all characters that are neither in the + unreserved chars ("always safe") nor the additional chars set via the + safe arg. + + The default for the safe arg is '/'. The character is reserved, but in + typical usage the quote function is being called on a path where the + existing slash characters are to be preserved. + + Python 3.7 updates from using RFC 2396 to RFC 3986 to quote URL strings. + Now, "~" is included in the set of unreserved characters. + + string and safe may be either str or bytes objects. encoding and errors + must not be specified if string is a bytes object. + + The optional encoding and errors parameters specify how to deal with + non-ASCII characters, as accepted by the str.encode method. + By default, encoding='utf-8' (characters are encoded with UTF-8), and + errors='strict' (unsupported characters raise a UnicodeEncodeError). + """ + if isinstance(string, str): + if not string: + return string + if encoding is None: + encoding = 'utf-8' + if errors is None: + errors = 'strict' + string = string.encode(encoding, errors) + else: + if encoding is not None: + raise TypeError("quote() doesn't support 'encoding' for bytes") + if errors is not None: + raise TypeError("quote() doesn't support 'errors' for bytes") + return quote_from_bytes(string, safe) + +def quote_plus(string, safe='', encoding=None, errors=None): + """Like quote(), but also replace ' ' with '+', as required for quoting + HTML form values. Plus signs in the original string are escaped unless + they are included in safe. It also does not have safe default to '/'. + """ + # Check if ' ' in string, where string may either be a str or bytes. If + # there are no spaces, the regular quote will produce the right answer. + if ((isinstance(string, str) and ' ' not in string) or + (isinstance(string, bytes) and b' ' not in string)): + return quote(string, safe, encoding, errors) + if isinstance(safe, str): + space = ' ' + else: + space = b' ' + string = quote(string, safe + space, encoding, errors) + return string.replace(' ', '+') + +# Expectation: A typical program is unlikely to create more than 5 of these. +@functools.lru_cache +def _byte_quoter_factory(safe): + return _Quoter(safe).__getitem__ + +def quote_from_bytes(bs, safe='/'): + """Like quote(), but accepts a bytes object rather than a str, and does + not perform string-to-bytes encoding. It always returns an ASCII string. + quote_from_bytes(b'abc def\x3f') -> 'abc%20def%3f' + """ + if not isinstance(bs, (bytes, bytearray)): + raise TypeError("quote_from_bytes() expected bytes") + if not bs: + return '' + if isinstance(safe, str): + # Normalize 'safe' by converting to bytes and removing non-ASCII chars + safe = safe.encode('ascii', 'ignore') + else: + # List comprehensions are faster than generator expressions. + safe = bytes([c for c in safe if c < 128]) + if not bs.rstrip(_ALWAYS_SAFE_BYTES + safe): + return bs.decode() + quoter = _byte_quoter_factory(safe) + return ''.join([quoter(char) for char in bs]) + +def urlencode(query, doseq=False, safe='', encoding=None, errors=None, + quote_via=quote_plus): + """Encode a dict or sequence of two-element tuples into a URL query string. + + If any values in the query arg are sequences and doseq is true, each + sequence element is converted to a separate parameter. + + If the query arg is a sequence of two-element tuples, the order of the + parameters in the output will match the order of parameters in the + input. + + The components of a query arg may each be either a string or a bytes type. + + The safe, encoding, and errors parameters are passed down to the function + specified by quote_via (encoding and errors only if a component is a str). + """ + + if hasattr(query, "items"): + query = query.items() + else: + # It's a bother at times that strings and string-like objects are + # sequences. + try: + # non-sequence items should not work with len() + # non-empty strings will fail this + if len(query) and not isinstance(query[0], tuple): + raise TypeError + # Zero-length sequences of all types will get here and succeed, + # but that's a minor nit. Since the original implementation + # allowed empty dicts that type of behavior probably should be + # preserved for consistency + except TypeError as err: + raise TypeError("not a valid non-string sequence " + "or mapping object") from err + + l = [] + if not doseq: + for k, v in query: + if isinstance(k, bytes): + k = quote_via(k, safe) + else: + k = quote_via(str(k), safe, encoding, errors) + + if isinstance(v, bytes): + v = quote_via(v, safe) + else: + v = quote_via(str(v), safe, encoding, errors) + l.append(k + '=' + v) + else: + for k, v in query: + if isinstance(k, bytes): + k = quote_via(k, safe) + else: + k = quote_via(str(k), safe, encoding, errors) + + if isinstance(v, bytes): + v = quote_via(v, safe) + l.append(k + '=' + v) + elif isinstance(v, str): + v = quote_via(v, safe, encoding, errors) + l.append(k + '=' + v) + else: + try: + # Is this a sufficient test for sequence-ness? + x = len(v) + except TypeError: + # not a sequence + v = quote_via(str(v), safe, encoding, errors) + l.append(k + '=' + v) + else: + # loop over the sequence + for elt in v: + if isinstance(elt, bytes): + elt = quote_via(elt, safe) + else: + elt = quote_via(str(elt), safe, encoding, errors) + l.append(k + '=' + elt) + return '&'.join(l) + + +def to_bytes(url): + warnings.warn("urllib.parse.to_bytes() is deprecated as of 3.8", + DeprecationWarning, stacklevel=2) + return _to_bytes(url) + + +def _to_bytes(url): + """to_bytes(u"URL") --> 'URL'.""" + # Most URL schemes require ASCII. If that changes, the conversion + # can be relaxed. + # XXX get rid of to_bytes() + if isinstance(url, str): + try: + url = url.encode("ASCII").decode() + except UnicodeError: + raise UnicodeError("URL " + repr(url) + + " contains non-ASCII characters") + return url + + +def unwrap(url): + """Transform a string like '' into 'scheme://host/path'. + + The string is returned unchanged if it's not a wrapped URL. + """ + url = str(url).strip() + if url[:1] == '<' and url[-1:] == '>': + url = url[1:-1].strip() + if url[:4] == 'URL:': + url = url[4:].strip() + return url + + +def splittype(url): + warnings.warn("urllib.parse.splittype() is deprecated as of 3.8, " + "use urllib.parse.urlparse() instead", + DeprecationWarning, stacklevel=2) + return _splittype(url) + + +_typeprog = None +def _splittype(url): + """splittype('type:opaquestring') --> 'type', 'opaquestring'.""" + global _typeprog + if _typeprog is None: + _typeprog = re.compile('([^/:]+):(.*)', re.DOTALL) + + match = _typeprog.match(url) + if match: + scheme, data = match.groups() + return scheme.lower(), data + return None, url + + +def splithost(url): + warnings.warn("urllib.parse.splithost() is deprecated as of 3.8, " + "use urllib.parse.urlparse() instead", + DeprecationWarning, stacklevel=2) + return _splithost(url) + + +_hostprog = None +def _splithost(url): + """splithost('//host[:port]/path') --> 'host[:port]', '/path'.""" + global _hostprog + if _hostprog is None: + _hostprog = re.compile('//([^/#?]*)(.*)', re.DOTALL) + + match = _hostprog.match(url) + if match: + host_port, path = match.groups() + if path and path[0] != '/': + path = '/' + path + return host_port, path + return None, url + + +def splituser(host): + warnings.warn("urllib.parse.splituser() is deprecated as of 3.8, " + "use urllib.parse.urlparse() instead", + DeprecationWarning, stacklevel=2) + return _splituser(host) + + +def _splituser(host): + """splituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'.""" + user, delim, host = host.rpartition('@') + return (user if delim else None), host + + +def splitpasswd(user): + warnings.warn("urllib.parse.splitpasswd() is deprecated as of 3.8, " + "use urllib.parse.urlparse() instead", + DeprecationWarning, stacklevel=2) + return _splitpasswd(user) + + +def _splitpasswd(user): + """splitpasswd('user:passwd') -> 'user', 'passwd'.""" + user, delim, passwd = user.partition(':') + return user, (passwd if delim else None) + + +def splitport(host): + warnings.warn("urllib.parse.splitport() is deprecated as of 3.8, " + "use urllib.parse.urlparse() instead", + DeprecationWarning, stacklevel=2) + return _splitport(host) + + +# splittag('/path#tag') --> '/path', 'tag' +_portprog = None +def _splitport(host): + """splitport('host:port') --> 'host', 'port'.""" + global _portprog + if _portprog is None: + _portprog = re.compile('(.*):([0-9]*)', re.DOTALL) + + match = _portprog.fullmatch(host) + if match: + host, port = match.groups() + if port: + return host, port + return host, None + + +def splitnport(host, defport=-1): + warnings.warn("urllib.parse.splitnport() is deprecated as of 3.8, " + "use urllib.parse.urlparse() instead", + DeprecationWarning, stacklevel=2) + return _splitnport(host, defport) + + +def _splitnport(host, defport=-1): + """Split host and port, returning numeric port. + Return given default port if no ':' found; defaults to -1. + Return numerical port if a valid number is found after ':'. + Return None if ':' but not a valid number.""" + host, delim, port = host.rpartition(':') + if not delim: + host = port + elif port: + if port.isdigit() and port.isascii(): + nport = int(port) + else: + nport = None + return host, nport + return host, defport + + +def splitquery(url): + warnings.warn("urllib.parse.splitquery() is deprecated as of 3.8, " + "use urllib.parse.urlparse() instead", + DeprecationWarning, stacklevel=2) + return _splitquery(url) + + +def _splitquery(url): + """splitquery('/path?query') --> '/path', 'query'.""" + path, delim, query = url.rpartition('?') + if delim: + return path, query + return url, None + + +def splittag(url): + warnings.warn("urllib.parse.splittag() is deprecated as of 3.8, " + "use urllib.parse.urlparse() instead", + DeprecationWarning, stacklevel=2) + return _splittag(url) + + +def _splittag(url): + """splittag('/path#tag') --> '/path', 'tag'.""" + path, delim, tag = url.rpartition('#') + if delim: + return path, tag + return url, None + + +def splitattr(url): + warnings.warn("urllib.parse.splitattr() is deprecated as of 3.8, " + "use urllib.parse.urlparse() instead", + DeprecationWarning, stacklevel=2) + return _splitattr(url) + + +def _splitattr(url): + """splitattr('/path;attr1=value1;attr2=value2;...') -> + '/path', ['attr1=value1', 'attr2=value2', ...].""" + words = url.split(';') + return words[0], words[1:] + + +def splitvalue(attr): + warnings.warn("urllib.parse.splitvalue() is deprecated as of 3.8, " + "use urllib.parse.parse_qsl() instead", + DeprecationWarning, stacklevel=2) + return _splitvalue(attr) + + +def _splitvalue(attr): + """splitvalue('attr=value') --> 'attr', 'value'.""" + attr, delim, value = attr.partition('=') + return attr, (value if delim else None) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/request.py b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/request.py new file mode 100644 index 0000000000000000000000000000000000000000..b53cabac2dfa39116a78e76e0acb4fa834d0aafc --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/request.py @@ -0,0 +1,2802 @@ +"""An extensible library for opening URLs using a variety of protocols + +The simplest way to use this module is to call the urlopen function, +which accepts a string containing a URL or a Request object (described +below). It opens the URL and returns the results as file-like +object; the returned object has some extra methods described below. + +The OpenerDirector manages a collection of Handler objects that do +all the actual work. Each Handler implements a particular protocol or +option. The OpenerDirector is a composite object that invokes the +Handlers needed to open the requested URL. For example, the +HTTPHandler performs HTTP GET and POST requests and deals with +non-error returns. The HTTPRedirectHandler automatically deals with +HTTP 301, 302, 303, 307, and 308 redirect errors, and the +HTTPDigestAuthHandler deals with digest authentication. + +urlopen(url, data=None) -- Basic usage is the same as original +urllib. pass the url and optionally data to post to an HTTP URL, and +get a file-like object back. One difference is that you can also pass +a Request instance instead of URL. Raises a URLError (subclass of +OSError); for HTTP errors, raises an HTTPError, which can also be +treated as a valid response. + +build_opener -- Function that creates a new OpenerDirector instance. +Will install the default handlers. Accepts one or more Handlers as +arguments, either instances or Handler classes that it will +instantiate. If one of the argument is a subclass of the default +handler, the argument will be installed instead of the default. + +install_opener -- Installs a new opener as the default opener. + +objects of interest: + +OpenerDirector -- Sets up the User Agent as the Python-urllib client and manages +the Handler classes, while dealing with requests and responses. + +Request -- An object that encapsulates the state of a request. The +state can be as simple as the URL. It can also include extra HTTP +headers, e.g. a User-Agent. + +BaseHandler -- + +internals: +BaseHandler and parent +_call_chain conventions + +Example usage: + +import urllib.request + +# set up authentication info +authinfo = urllib.request.HTTPBasicAuthHandler() +authinfo.add_password(realm='PDQ Application', + uri='https://mahler:8092/site-updates.py', + user='klem', + passwd='geheim$parole') + +proxy_support = urllib.request.ProxyHandler({"http" : "http://ahad-haam:3128"}) + +# build a new opener that adds authentication and caching FTP handlers +opener = urllib.request.build_opener(proxy_support, authinfo, + urllib.request.CacheFTPHandler) + +# install it +urllib.request.install_opener(opener) + +f = urllib.request.urlopen('https://www.python.org/') +""" + +# XXX issues: +# If an authentication error handler that tries to perform +# authentication for some reason but fails, how should the error be +# signalled? The client needs to know the HTTP error code. But if +# the handler knows that the problem was, e.g., that it didn't know +# that hash algo that requested in the challenge, it would be good to +# pass that information along to the client, too. +# ftp errors aren't handled cleanly +# check digest against correct (i.e. non-apache) implementation + +# Possible extensions: +# complex proxies XXX not sure what exactly was meant by this +# abstract factory for opener + +import base64 +import bisect +import email +import hashlib +import http.client +import io +import os +import posixpath +import re +import socket +import string +import sys +import time +import tempfile +import contextlib +import warnings + + +from urllib.error import URLError, HTTPError, ContentTooShortError +from urllib.parse import ( + urlparse, urlsplit, urljoin, unwrap, quote, unquote, + _splittype, _splithost, _splitport, _splituser, _splitpasswd, + _splitattr, _splitquery, _splitvalue, _splittag, _to_bytes, + unquote_to_bytes, urlunparse) +from urllib.response import addinfourl, addclosehook + +# check for SSL +try: + import ssl +except ImportError: + _have_ssl = False +else: + _have_ssl = True + +__all__ = [ + # Classes + 'Request', 'OpenerDirector', 'BaseHandler', 'HTTPDefaultErrorHandler', + 'HTTPRedirectHandler', 'HTTPCookieProcessor', 'ProxyHandler', + 'HTTPPasswordMgr', 'HTTPPasswordMgrWithDefaultRealm', + 'HTTPPasswordMgrWithPriorAuth', 'AbstractBasicAuthHandler', + 'HTTPBasicAuthHandler', 'ProxyBasicAuthHandler', 'AbstractDigestAuthHandler', + 'HTTPDigestAuthHandler', 'ProxyDigestAuthHandler', 'HTTPHandler', + 'FileHandler', 'FTPHandler', 'CacheFTPHandler', 'DataHandler', + 'UnknownHandler', 'HTTPErrorProcessor', + # Functions + 'urlopen', 'install_opener', 'build_opener', + 'pathname2url', 'url2pathname', 'getproxies', + # Legacy interface + 'urlretrieve', 'urlcleanup', 'URLopener', 'FancyURLopener', +] + +# used in User-Agent header sent +__version__ = '%d.%d' % sys.version_info[:2] + +_opener = None +def urlopen(url, data=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT, + *, cafile=None, capath=None, cadefault=False, context=None): + '''Open the URL url, which can be either a string or a Request object. + + *data* must be an object specifying additional data to be sent to + the server, or None if no such data is needed. See Request for + details. + + urllib.request module uses HTTP/1.1 and includes a "Connection:close" + header in its HTTP requests. + + The optional *timeout* parameter specifies a timeout in seconds for + blocking operations like the connection attempt (if not specified, the + global default timeout setting will be used). This only works for HTTP, + HTTPS and FTP connections. + + If *context* is specified, it must be a ssl.SSLContext instance describing + the various SSL options. See HTTPSConnection for more details. + + The optional *cafile* and *capath* parameters specify a set of trusted CA + certificates for HTTPS requests. cafile should point to a single file + containing a bundle of CA certificates, whereas capath should point to a + directory of hashed certificate files. More information can be found in + ssl.SSLContext.load_verify_locations(). + + The *cadefault* parameter is ignored. + + + This function always returns an object which can work as a + context manager and has the properties url, headers, and status. + See urllib.response.addinfourl for more detail on these properties. + + For HTTP and HTTPS URLs, this function returns a http.client.HTTPResponse + object slightly modified. In addition to the three new methods above, the + msg attribute contains the same information as the reason attribute --- + the reason phrase returned by the server --- instead of the response + headers as it is specified in the documentation for HTTPResponse. + + For FTP, file, and data URLs and requests explicitly handled by legacy + URLopener and FancyURLopener classes, this function returns a + urllib.response.addinfourl object. + + Note that None may be returned if no handler handles the request (though + the default installed global OpenerDirector uses UnknownHandler to ensure + this never happens). + + In addition, if proxy settings are detected (for example, when a *_proxy + environment variable like http_proxy is set), ProxyHandler is default + installed and makes sure the requests are handled through the proxy. + + ''' + global _opener + if cafile or capath or cadefault: + import warnings + warnings.warn("cafile, capath and cadefault are deprecated, use a " + "custom context instead.", DeprecationWarning, 2) + if context is not None: + raise ValueError( + "You can't pass both context and any of cafile, capath, and " + "cadefault" + ) + if not _have_ssl: + raise ValueError('SSL support not available') + context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, + cafile=cafile, + capath=capath) + # send ALPN extension to indicate HTTP/1.1 protocol + context.set_alpn_protocols(['http/1.1']) + https_handler = HTTPSHandler(context=context) + opener = build_opener(https_handler) + elif context: + https_handler = HTTPSHandler(context=context) + opener = build_opener(https_handler) + elif _opener is None: + _opener = opener = build_opener() + else: + opener = _opener + return opener.open(url, data, timeout) + +def install_opener(opener): + global _opener + _opener = opener + +_url_tempfiles = [] +def urlretrieve(url, filename=None, reporthook=None, data=None): + """ + Retrieve a URL into a temporary location on disk. + + Requires a URL argument. If a filename is passed, it is used as + the temporary file location. The reporthook argument should be + a callable that accepts a block number, a read size, and the + total file size of the URL target. The data argument should be + valid URL encoded data. + + If a filename is passed and the URL points to a local resource, + the result is a copy from local file to new file. + + Returns a tuple containing the path to the newly created + data file as well as the resulting HTTPMessage object. + """ + url_type, path = _splittype(url) + + with contextlib.closing(urlopen(url, data)) as fp: + headers = fp.info() + + # Just return the local path and the "headers" for file:// + # URLs. No sense in performing a copy unless requested. + if url_type == "file" and not filename: + return os.path.normpath(path), headers + + # Handle temporary file setup. + if filename: + tfp = open(filename, 'wb') + else: + tfp = tempfile.NamedTemporaryFile(delete=False) + filename = tfp.name + _url_tempfiles.append(filename) + + with tfp: + result = filename, headers + bs = 1024*8 + size = -1 + read = 0 + blocknum = 0 + if "content-length" in headers: + size = int(headers["Content-Length"]) + + if reporthook: + reporthook(blocknum, bs, size) + + while True: + block = fp.read(bs) + if not block: + break + read += len(block) + tfp.write(block) + blocknum += 1 + if reporthook: + reporthook(blocknum, bs, size) + + if size >= 0 and read < size: + raise ContentTooShortError( + "retrieval incomplete: got only %i out of %i bytes" + % (read, size), result) + + return result + +def urlcleanup(): + """Clean up temporary files from urlretrieve calls.""" + for temp_file in _url_tempfiles: + try: + os.unlink(temp_file) + except OSError: + pass + + del _url_tempfiles[:] + global _opener + if _opener: + _opener = None + +# copied from cookielib.py +_cut_port_re = re.compile(r":\d+$", re.ASCII) +def request_host(request): + """Return request-host, as defined by RFC 2965. + + Variation from RFC: returned value is lowercased, for convenient + comparison. + + """ + url = request.full_url + host = urlparse(url)[1] + if host == "": + host = request.get_header("Host", "") + + # remove port, if present + host = _cut_port_re.sub("", host, 1) + return host.lower() + +class Request: + + def __init__(self, url, data=None, headers={}, + origin_req_host=None, unverifiable=False, + method=None): + self.full_url = url + self.headers = {} + self.unredirected_hdrs = {} + self._data = None + self.data = data + self._tunnel_host = None + for key, value in headers.items(): + self.add_header(key, value) + if origin_req_host is None: + origin_req_host = request_host(self) + self.origin_req_host = origin_req_host + self.unverifiable = unverifiable + if method: + self.method = method + + @property + def full_url(self): + if self.fragment: + return '{}#{}'.format(self._full_url, self.fragment) + return self._full_url + + @full_url.setter + def full_url(self, url): + # unwrap('') --> 'type://host/path' + self._full_url = unwrap(url) + self._full_url, self.fragment = _splittag(self._full_url) + self._parse() + + @full_url.deleter + def full_url(self): + self._full_url = None + self.fragment = None + self.selector = '' + + @property + def data(self): + return self._data + + @data.setter + def data(self, data): + if data != self._data: + self._data = data + # issue 16464 + # if we change data we need to remove content-length header + # (cause it's most probably calculated for previous value) + if self.has_header("Content-length"): + self.remove_header("Content-length") + + @data.deleter + def data(self): + self.data = None + + def _parse(self): + self.type, rest = _splittype(self._full_url) + if self.type is None: + raise ValueError("unknown url type: %r" % self.full_url) + self.host, self.selector = _splithost(rest) + if self.host: + self.host = unquote(self.host) + + def get_method(self): + """Return a string indicating the HTTP request method.""" + default_method = "POST" if self.data is not None else "GET" + return getattr(self, 'method', default_method) + + def get_full_url(self): + return self.full_url + + def set_proxy(self, host, type): + if self.type == 'https' and not self._tunnel_host: + self._tunnel_host = self.host + else: + self.type= type + self.selector = self.full_url + self.host = host + + def has_proxy(self): + return self.selector == self.full_url + + def add_header(self, key, val): + # useful for something like authentication + self.headers[key.capitalize()] = val + + def add_unredirected_header(self, key, val): + # will not be added to a redirected request + self.unredirected_hdrs[key.capitalize()] = val + + def has_header(self, header_name): + return (header_name in self.headers or + header_name in self.unredirected_hdrs) + + def get_header(self, header_name, default=None): + return self.headers.get( + header_name, + self.unredirected_hdrs.get(header_name, default)) + + def remove_header(self, header_name): + self.headers.pop(header_name, None) + self.unredirected_hdrs.pop(header_name, None) + + def header_items(self): + hdrs = {**self.unredirected_hdrs, **self.headers} + return list(hdrs.items()) + +class OpenerDirector: + def __init__(self): + client_version = "Python-urllib/%s" % __version__ + self.addheaders = [('User-agent', client_version)] + # self.handlers is retained only for backward compatibility + self.handlers = [] + # manage the individual handlers + self.handle_open = {} + self.handle_error = {} + self.process_response = {} + self.process_request = {} + + def add_handler(self, handler): + if not hasattr(handler, "add_parent"): + raise TypeError("expected BaseHandler instance, got %r" % + type(handler)) + + added = False + for meth in dir(handler): + if meth in ["redirect_request", "do_open", "proxy_open"]: + # oops, coincidental match + continue + + i = meth.find("_") + protocol = meth[:i] + condition = meth[i+1:] + + if condition.startswith("error"): + j = condition.find("_") + i + 1 + kind = meth[j+1:] + try: + kind = int(kind) + except ValueError: + pass + lookup = self.handle_error.get(protocol, {}) + self.handle_error[protocol] = lookup + elif condition == "open": + kind = protocol + lookup = self.handle_open + elif condition == "response": + kind = protocol + lookup = self.process_response + elif condition == "request": + kind = protocol + lookup = self.process_request + else: + continue + + handlers = lookup.setdefault(kind, []) + if handlers: + bisect.insort(handlers, handler) + else: + handlers.append(handler) + added = True + + if added: + bisect.insort(self.handlers, handler) + handler.add_parent(self) + + def close(self): + # Only exists for backwards compatibility. + pass + + def _call_chain(self, chain, kind, meth_name, *args): + # Handlers raise an exception if no one else should try to handle + # the request, or return None if they can't but another handler + # could. Otherwise, they return the response. + handlers = chain.get(kind, ()) + for handler in handlers: + func = getattr(handler, meth_name) + result = func(*args) + if result is not None: + return result + + def open(self, fullurl, data=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT): + # accept a URL or a Request object + if isinstance(fullurl, str): + req = Request(fullurl, data) + else: + req = fullurl + if data is not None: + req.data = data + + req.timeout = timeout + protocol = req.type + + # pre-process request + meth_name = protocol+"_request" + for processor in self.process_request.get(protocol, []): + meth = getattr(processor, meth_name) + req = meth(req) + + sys.audit('urllib.Request', req.full_url, req.data, req.headers, req.get_method()) + response = self._open(req, data) + + # post-process response + meth_name = protocol+"_response" + for processor in self.process_response.get(protocol, []): + meth = getattr(processor, meth_name) + response = meth(req, response) + + return response + + def _open(self, req, data=None): + result = self._call_chain(self.handle_open, 'default', + 'default_open', req) + if result: + return result + + protocol = req.type + result = self._call_chain(self.handle_open, protocol, protocol + + '_open', req) + if result: + return result + + return self._call_chain(self.handle_open, 'unknown', + 'unknown_open', req) + + def error(self, proto, *args): + if proto in ('http', 'https'): + # XXX http[s] protocols are special-cased + dict = self.handle_error['http'] # https is not different than http + proto = args[2] # YUCK! + meth_name = 'http_error_%s' % proto + http_err = 1 + orig_args = args + else: + dict = self.handle_error + meth_name = proto + '_error' + http_err = 0 + args = (dict, proto, meth_name) + args + result = self._call_chain(*args) + if result: + return result + + if http_err: + args = (dict, 'default', 'http_error_default') + orig_args + return self._call_chain(*args) + +# XXX probably also want an abstract factory that knows when it makes +# sense to skip a superclass in favor of a subclass and when it might +# make sense to include both + +def build_opener(*handlers): + """Create an opener object from a list of handlers. + + The opener will use several default handlers, including support + for HTTP, FTP and when applicable HTTPS. + + If any of the handlers passed as arguments are subclasses of the + default handlers, the default handlers will not be used. + """ + opener = OpenerDirector() + default_classes = [ProxyHandler, UnknownHandler, HTTPHandler, + HTTPDefaultErrorHandler, HTTPRedirectHandler, + FTPHandler, FileHandler, HTTPErrorProcessor, + DataHandler] + if hasattr(http.client, "HTTPSConnection"): + default_classes.append(HTTPSHandler) + skip = set() + for klass in default_classes: + for check in handlers: + if isinstance(check, type): + if issubclass(check, klass): + skip.add(klass) + elif isinstance(check, klass): + skip.add(klass) + for klass in skip: + default_classes.remove(klass) + + for klass in default_classes: + opener.add_handler(klass()) + + for h in handlers: + if isinstance(h, type): + h = h() + opener.add_handler(h) + return opener + +class BaseHandler: + handler_order = 500 + + def add_parent(self, parent): + self.parent = parent + + def close(self): + # Only exists for backwards compatibility + pass + + def __lt__(self, other): + if not hasattr(other, "handler_order"): + # Try to preserve the old behavior of having custom classes + # inserted after default ones (works only for custom user + # classes which are not aware of handler_order). + return True + return self.handler_order < other.handler_order + + +class HTTPErrorProcessor(BaseHandler): + """Process HTTP error responses.""" + handler_order = 1000 # after all other processing + + def http_response(self, request, response): + code, msg, hdrs = response.code, response.msg, response.info() + + # According to RFC 2616, "2xx" code indicates that the client's + # request was successfully received, understood, and accepted. + if not (200 <= code < 300): + response = self.parent.error( + 'http', request, response, code, msg, hdrs) + + return response + + https_response = http_response + +class HTTPDefaultErrorHandler(BaseHandler): + def http_error_default(self, req, fp, code, msg, hdrs): + raise HTTPError(req.full_url, code, msg, hdrs, fp) + +class HTTPRedirectHandler(BaseHandler): + # maximum number of redirections to any single URL + # this is needed because of the state that cookies introduce + max_repeats = 4 + # maximum total number of redirections (regardless of URL) before + # assuming we're in a loop + max_redirections = 10 + + def redirect_request(self, req, fp, code, msg, headers, newurl): + """Return a Request or None in response to a redirect. + + This is called by the http_error_30x methods when a + redirection response is received. If a redirection should + take place, return a new Request to allow http_error_30x to + perform the redirect. Otherwise, raise HTTPError if no-one + else should try to handle this url. Return None if you can't + but another Handler might. + """ + m = req.get_method() + if (not (code in (301, 302, 303, 307, 308) and m in ("GET", "HEAD") + or code in (301, 302, 303) and m == "POST")): + raise HTTPError(req.full_url, code, msg, headers, fp) + + # Strictly (according to RFC 2616), 301 or 302 in response to + # a POST MUST NOT cause a redirection without confirmation + # from the user (of urllib.request, in this case). In practice, + # essentially all clients do redirect in this case, so we do + # the same. + + # Be conciliant with URIs containing a space. This is mainly + # redundant with the more complete encoding done in http_error_302(), + # but it is kept for compatibility with other callers. + newurl = newurl.replace(' ', '%20') + + CONTENT_HEADERS = ("content-length", "content-type") + newheaders = {k: v for k, v in req.headers.items() + if k.lower() not in CONTENT_HEADERS} + return Request(newurl, + headers=newheaders, + origin_req_host=req.origin_req_host, + unverifiable=True) + + # Implementation note: To avoid the server sending us into an + # infinite loop, the request object needs to track what URLs we + # have already seen. Do this by adding a handler-specific + # attribute to the Request object. + def http_error_302(self, req, fp, code, msg, headers): + # Some servers (incorrectly) return multiple Location headers + # (so probably same goes for URI). Use first header. + if "location" in headers: + newurl = headers["location"] + elif "uri" in headers: + newurl = headers["uri"] + else: + return + + # fix a possible malformed URL + urlparts = urlparse(newurl) + + # For security reasons we don't allow redirection to anything other + # than http, https or ftp. + + if urlparts.scheme not in ('http', 'https', 'ftp', ''): + raise HTTPError( + newurl, code, + "%s - Redirection to url '%s' is not allowed" % (msg, newurl), + headers, fp) + + if not urlparts.path and urlparts.netloc: + urlparts = list(urlparts) + urlparts[2] = "/" + newurl = urlunparse(urlparts) + + # http.client.parse_headers() decodes as ISO-8859-1. Recover the + # original bytes and percent-encode non-ASCII bytes, and any special + # characters such as the space. + newurl = quote( + newurl, encoding="iso-8859-1", safe=string.punctuation) + newurl = urljoin(req.full_url, newurl) + + # XXX Probably want to forget about the state of the current + # request, although that might interact poorly with other + # handlers that also use handler-specific request attributes + new = self.redirect_request(req, fp, code, msg, headers, newurl) + if new is None: + return + + # loop detection + # .redirect_dict has a key url if url was previously visited. + if hasattr(req, 'redirect_dict'): + visited = new.redirect_dict = req.redirect_dict + if (visited.get(newurl, 0) >= self.max_repeats or + len(visited) >= self.max_redirections): + raise HTTPError(req.full_url, code, + self.inf_msg + msg, headers, fp) + else: + visited = new.redirect_dict = req.redirect_dict = {} + visited[newurl] = visited.get(newurl, 0) + 1 + + # Don't close the fp until we are sure that we won't use it + # with HTTPError. + fp.read() + fp.close() + + return self.parent.open(new, timeout=req.timeout) + + http_error_301 = http_error_303 = http_error_307 = http_error_308 = http_error_302 + + inf_msg = "The HTTP server returned a redirect error that would " \ + "lead to an infinite loop.\n" \ + "The last 30x error message was:\n" + + +def _parse_proxy(proxy): + """Return (scheme, user, password, host/port) given a URL or an authority. + + If a URL is supplied, it must have an authority (host:port) component. + According to RFC 3986, having an authority component means the URL must + have two slashes after the scheme. + """ + scheme, r_scheme = _splittype(proxy) + if not r_scheme.startswith("/"): + # authority + scheme = None + authority = proxy + else: + # URL + if not r_scheme.startswith("//"): + raise ValueError("proxy URL with no authority: %r" % proxy) + # We have an authority, so for RFC 3986-compliant URLs (by ss 3. + # and 3.3.), path is empty or starts with '/' + if '@' in r_scheme: + host_separator = r_scheme.find('@') + end = r_scheme.find("/", host_separator) + else: + end = r_scheme.find("/", 2) + if end == -1: + end = None + authority = r_scheme[2:end] + userinfo, hostport = _splituser(authority) + if userinfo is not None: + user, password = _splitpasswd(userinfo) + else: + user = password = None + return scheme, user, password, hostport + +class ProxyHandler(BaseHandler): + # Proxies must be in front + handler_order = 100 + + def __init__(self, proxies=None): + if proxies is None: + proxies = getproxies() + assert hasattr(proxies, 'keys'), "proxies must be a mapping" + self.proxies = proxies + for type, url in proxies.items(): + type = type.lower() + setattr(self, '%s_open' % type, + lambda r, proxy=url, type=type, meth=self.proxy_open: + meth(r, proxy, type)) + + def proxy_open(self, req, proxy, type): + orig_type = req.type + proxy_type, user, password, hostport = _parse_proxy(proxy) + if proxy_type is None: + proxy_type = orig_type + + if req.host and proxy_bypass(req.host): + return None + + if user and password: + user_pass = '%s:%s' % (unquote(user), + unquote(password)) + creds = base64.b64encode(user_pass.encode()).decode("ascii") + req.add_header('Proxy-authorization', 'Basic ' + creds) + hostport = unquote(hostport) + req.set_proxy(hostport, proxy_type) + if orig_type == proxy_type or orig_type == 'https': + # let other handlers take care of it + return None + else: + # need to start over, because the other handlers don't + # grok the proxy's URL type + # e.g. if we have a constructor arg proxies like so: + # {'http': 'ftp://proxy.example.com'}, we may end up turning + # a request for http://acme.example.com/a into one for + # ftp://proxy.example.com/a + return self.parent.open(req, timeout=req.timeout) + +class HTTPPasswordMgr: + + def __init__(self): + self.passwd = {} + + def add_password(self, realm, uri, user, passwd): + # uri could be a single URI or a sequence + if isinstance(uri, str): + uri = [uri] + if realm not in self.passwd: + self.passwd[realm] = {} + for default_port in True, False: + reduced_uri = tuple( + self._reduce_uri_with_scheme(u, default_port) for u in uri) + self.passwd[realm][reduced_uri] = (user, passwd) + + def find_user_password(self, realm, authuri): + domains = self.passwd.get(realm, {}) + for default_port in True, False: + reduced_authuri = self._reduce_uri_with_scheme( + authuri, default_port) + for uris, authinfo in domains.items(): + for uri in uris: + if self._is_suburi_with_scheme(uri, reduced_authuri): + return authinfo + return None, None + + def reduce_uri(self, uri, default_port=True): + """Accept authority or URI and extract only the authority and path.""" + # note HTTP URLs do not have a userinfo component + parts = urlsplit(uri) + if parts[1]: + # URI + scheme = parts[0] + authority = parts[1] + path = parts[2] or '/' + else: + # host or host:port + scheme = None + authority = uri + path = '/' + host, port = _splitport(authority) + if default_port and port is None and scheme is not None: + dport = {"http": 80, + "https": 443, + }.get(scheme) + if dport is not None: + authority = "%s:%d" % (host, dport) + return authority, path + + def _reduce_uri_with_scheme(self, uri, default_port=True): + parts = urlsplit(uri) + scheme = parts[0] if parts[1] else None + return (scheme or None, *self.reduce_uri(uri, default_port)) + + def _is_suburi_with_scheme(self, base, test): + if (base[0] is not None and test[0] is not None and + base[0] != test[0]): + return False + return self.is_suburi(base[1:], test[1:]) + + def is_suburi(self, base, test): + """Check if test is below base in a URI tree + + Both args must be URIs in reduced form. + """ + if base == test: + return True + if base[0] != test[0]: + return False + prefix = base[1] + if prefix[-1:] != '/': + prefix += '/' + return test[1].startswith(prefix) + + +class HTTPPasswordMgrWithDefaultRealm(HTTPPasswordMgr): + + def find_user_password(self, realm, authuri): + user, password = HTTPPasswordMgr.find_user_password(self, realm, + authuri) + if user is not None: + return user, password + return HTTPPasswordMgr.find_user_password(self, None, authuri) + + +class HTTPPasswordMgrWithPriorAuth(HTTPPasswordMgrWithDefaultRealm): + + def __init__(self, *args, **kwargs): + self.authenticated = {} + super().__init__(*args, **kwargs) + + def add_password(self, realm, uri, user, passwd, is_authenticated=False): + self.update_authenticated(uri, is_authenticated) + # Add a default for prior auth requests + if realm is not None: + super().add_password(None, uri, user, passwd) + super().add_password(realm, uri, user, passwd) + + def update_authenticated(self, uri, is_authenticated=False): + # uri could be a single URI or a sequence + if isinstance(uri, str): + uri = [uri] + + for default_port in True, False: + for u in uri: + reduced_uri = self._reduce_uri_with_scheme(u, default_port) + self.authenticated[reduced_uri] = is_authenticated + + def is_authenticated(self, authuri): + for default_port in True, False: + reduced_authuri = self._reduce_uri_with_scheme( + authuri, default_port) + for uri in self.authenticated: + if self._is_suburi_with_scheme(uri, reduced_authuri): + return self.authenticated[uri] + + +class AbstractBasicAuthHandler: + + # XXX this allows for multiple auth-schemes, but will stupidly pick + # the last one with a realm specified. + + # allow for double- and single-quoted realm values + # (single quotes are a violation of the RFC, but appear in the wild) + rx = re.compile('(?:^|,)' # start of the string or ',' + '[ \t]*' # optional whitespaces + '([^ \t,]+)' # scheme like "Basic" + '[ \t]+' # mandatory whitespaces + # realm=xxx + # realm='xxx' + # realm="xxx" + 'realm=(["\']?)([^"\']*)\\2', + re.I) + + # XXX could pre-emptively send auth info already accepted (RFC 2617, + # end of section 2, and section 1.2 immediately after "credentials" + # production). + + def __init__(self, password_mgr=None): + if password_mgr is None: + password_mgr = HTTPPasswordMgr() + self.passwd = password_mgr + self.add_password = self.passwd.add_password + + def _parse_realm(self, header): + # parse WWW-Authenticate header: accept multiple challenges per header + found_challenge = False + for mo in AbstractBasicAuthHandler.rx.finditer(header): + scheme, quote, realm = mo.groups() + if quote not in ['"', "'"]: + warnings.warn("Basic Auth Realm was unquoted", + UserWarning, 3) + + yield (scheme, realm) + + found_challenge = True + + if not found_challenge: + if header: + scheme = header.split()[0] + else: + scheme = '' + yield (scheme, None) + + def http_error_auth_reqed(self, authreq, host, req, headers): + # host may be an authority (without userinfo) or a URL with an + # authority + headers = headers.get_all(authreq) + if not headers: + # no header found + return + + unsupported = None + for header in headers: + for scheme, realm in self._parse_realm(header): + if scheme.lower() != 'basic': + unsupported = scheme + continue + + if realm is not None: + # Use the first matching Basic challenge. + # Ignore following challenges even if they use the Basic + # scheme. + return self.retry_http_basic_auth(host, req, realm) + + if unsupported is not None: + raise ValueError("AbstractBasicAuthHandler does not " + "support the following scheme: %r" + % (scheme,)) + + def retry_http_basic_auth(self, host, req, realm): + user, pw = self.passwd.find_user_password(realm, host) + if pw is not None: + raw = "%s:%s" % (user, pw) + auth = "Basic " + base64.b64encode(raw.encode()).decode("ascii") + if req.get_header(self.auth_header, None) == auth: + return None + req.add_unredirected_header(self.auth_header, auth) + return self.parent.open(req, timeout=req.timeout) + else: + return None + + def http_request(self, req): + if (not hasattr(self.passwd, 'is_authenticated') or + not self.passwd.is_authenticated(req.full_url)): + return req + + if not req.has_header('Authorization'): + user, passwd = self.passwd.find_user_password(None, req.full_url) + credentials = '{0}:{1}'.format(user, passwd).encode() + auth_str = base64.standard_b64encode(credentials).decode() + req.add_unredirected_header('Authorization', + 'Basic {}'.format(auth_str.strip())) + return req + + def http_response(self, req, response): + if hasattr(self.passwd, 'is_authenticated'): + if 200 <= response.code < 300: + self.passwd.update_authenticated(req.full_url, True) + else: + self.passwd.update_authenticated(req.full_url, False) + return response + + https_request = http_request + https_response = http_response + + + +class HTTPBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler): + + auth_header = 'Authorization' + + def http_error_401(self, req, fp, code, msg, headers): + url = req.full_url + response = self.http_error_auth_reqed('www-authenticate', + url, req, headers) + return response + + +class ProxyBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler): + + auth_header = 'Proxy-authorization' + + def http_error_407(self, req, fp, code, msg, headers): + # http_error_auth_reqed requires that there is no userinfo component in + # authority. Assume there isn't one, since urllib.request does not (and + # should not, RFC 3986 s. 3.2.1) support requests for URLs containing + # userinfo. + authority = req.host + response = self.http_error_auth_reqed('proxy-authenticate', + authority, req, headers) + return response + + +# Return n random bytes. +_randombytes = os.urandom + + +class AbstractDigestAuthHandler: + # Digest authentication is specified in RFC 2617. + + # XXX The client does not inspect the Authentication-Info header + # in a successful response. + + # XXX It should be possible to test this implementation against + # a mock server that just generates a static set of challenges. + + # XXX qop="auth-int" supports is shaky + + def __init__(self, passwd=None): + if passwd is None: + passwd = HTTPPasswordMgr() + self.passwd = passwd + self.add_password = self.passwd.add_password + self.retried = 0 + self.nonce_count = 0 + self.last_nonce = None + + def reset_retry_count(self): + self.retried = 0 + + def http_error_auth_reqed(self, auth_header, host, req, headers): + authreq = headers.get(auth_header, None) + if self.retried > 5: + # Don't fail endlessly - if we failed once, we'll probably + # fail a second time. Hm. Unless the Password Manager is + # prompting for the information. Crap. This isn't great + # but it's better than the current 'repeat until recursion + # depth exceeded' approach + raise HTTPError(req.full_url, 401, "digest auth failed", + headers, None) + else: + self.retried += 1 + if authreq: + scheme = authreq.split()[0] + if scheme.lower() == 'digest': + return self.retry_http_digest_auth(req, authreq) + elif scheme.lower() != 'basic': + raise ValueError("AbstractDigestAuthHandler does not support" + " the following scheme: '%s'" % scheme) + + def retry_http_digest_auth(self, req, auth): + token, challenge = auth.split(' ', 1) + chal = parse_keqv_list(filter(None, parse_http_list(challenge))) + auth = self.get_authorization(req, chal) + if auth: + auth_val = 'Digest %s' % auth + if req.headers.get(self.auth_header, None) == auth_val: + return None + req.add_unredirected_header(self.auth_header, auth_val) + resp = self.parent.open(req, timeout=req.timeout) + return resp + + def get_cnonce(self, nonce): + # The cnonce-value is an opaque + # quoted string value provided by the client and used by both client + # and server to avoid chosen plaintext attacks, to provide mutual + # authentication, and to provide some message integrity protection. + # This isn't a fabulous effort, but it's probably Good Enough. + s = "%s:%s:%s:" % (self.nonce_count, nonce, time.ctime()) + b = s.encode("ascii") + _randombytes(8) + dig = hashlib.sha1(b).hexdigest() + return dig[:16] + + def get_authorization(self, req, chal): + try: + realm = chal['realm'] + nonce = chal['nonce'] + qop = chal.get('qop') + algorithm = chal.get('algorithm', 'MD5') + # mod_digest doesn't send an opaque, even though it isn't + # supposed to be optional + opaque = chal.get('opaque', None) + except KeyError: + return None + + H, KD = self.get_algorithm_impls(algorithm) + if H is None: + return None + + user, pw = self.passwd.find_user_password(realm, req.full_url) + if user is None: + return None + + # XXX not implemented yet + if req.data is not None: + entdig = self.get_entity_digest(req.data, chal) + else: + entdig = None + + A1 = "%s:%s:%s" % (user, realm, pw) + A2 = "%s:%s" % (req.get_method(), + # XXX selector: what about proxies and full urls + req.selector) + # NOTE: As per RFC 2617, when server sends "auth,auth-int", the client could use either `auth` + # or `auth-int` to the response back. we use `auth` to send the response back. + if qop is None: + respdig = KD(H(A1), "%s:%s" % (nonce, H(A2))) + elif 'auth' in qop.split(','): + if nonce == self.last_nonce: + self.nonce_count += 1 + else: + self.nonce_count = 1 + self.last_nonce = nonce + ncvalue = '%08x' % self.nonce_count + cnonce = self.get_cnonce(nonce) + noncebit = "%s:%s:%s:%s:%s" % (nonce, ncvalue, cnonce, 'auth', H(A2)) + respdig = KD(H(A1), noncebit) + else: + # XXX handle auth-int. + raise URLError("qop '%s' is not supported." % qop) + + # XXX should the partial digests be encoded too? + + base = 'username="%s", realm="%s", nonce="%s", uri="%s", ' \ + 'response="%s"' % (user, realm, nonce, req.selector, + respdig) + if opaque: + base += ', opaque="%s"' % opaque + if entdig: + base += ', digest="%s"' % entdig + base += ', algorithm="%s"' % algorithm + if qop: + base += ', qop=auth, nc=%s, cnonce="%s"' % (ncvalue, cnonce) + return base + + def get_algorithm_impls(self, algorithm): + # lambdas assume digest modules are imported at the top level + if algorithm == 'MD5': + H = lambda x: hashlib.md5(x.encode("ascii")).hexdigest() + elif algorithm == 'SHA': + H = lambda x: hashlib.sha1(x.encode("ascii")).hexdigest() + # XXX MD5-sess + else: + raise ValueError("Unsupported digest authentication " + "algorithm %r" % algorithm) + KD = lambda s, d: H("%s:%s" % (s, d)) + return H, KD + + def get_entity_digest(self, data, chal): + # XXX not implemented yet + return None + + +class HTTPDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler): + """An authentication protocol defined by RFC 2069 + + Digest authentication improves on basic authentication because it + does not transmit passwords in the clear. + """ + + auth_header = 'Authorization' + handler_order = 490 # before Basic auth + + def http_error_401(self, req, fp, code, msg, headers): + host = urlparse(req.full_url)[1] + retry = self.http_error_auth_reqed('www-authenticate', + host, req, headers) + self.reset_retry_count() + return retry + + +class ProxyDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler): + + auth_header = 'Proxy-Authorization' + handler_order = 490 # before Basic auth + + def http_error_407(self, req, fp, code, msg, headers): + host = req.host + retry = self.http_error_auth_reqed('proxy-authenticate', + host, req, headers) + self.reset_retry_count() + return retry + +class AbstractHTTPHandler(BaseHandler): + + def __init__(self, debuglevel=0): + self._debuglevel = debuglevel + + def set_http_debuglevel(self, level): + self._debuglevel = level + + def _get_content_length(self, request): + return http.client.HTTPConnection._get_content_length( + request.data, + request.get_method()) + + def do_request_(self, request): + host = request.host + if not host: + raise URLError('no host given') + + if request.data is not None: # POST + data = request.data + if isinstance(data, str): + msg = "POST data should be bytes, an iterable of bytes, " \ + "or a file object. It cannot be of type str." + raise TypeError(msg) + if not request.has_header('Content-type'): + request.add_unredirected_header( + 'Content-type', + 'application/x-www-form-urlencoded') + if (not request.has_header('Content-length') + and not request.has_header('Transfer-encoding')): + content_length = self._get_content_length(request) + if content_length is not None: + request.add_unredirected_header( + 'Content-length', str(content_length)) + else: + request.add_unredirected_header( + 'Transfer-encoding', 'chunked') + + sel_host = host + if request.has_proxy(): + scheme, sel = _splittype(request.selector) + sel_host, sel_path = _splithost(sel) + if not request.has_header('Host'): + request.add_unredirected_header('Host', sel_host) + for name, value in self.parent.addheaders: + name = name.capitalize() + if not request.has_header(name): + request.add_unredirected_header(name, value) + + return request + + def do_open(self, http_class, req, **http_conn_args): + """Return an HTTPResponse object for the request, using http_class. + + http_class must implement the HTTPConnection API from http.client. + """ + host = req.host + if not host: + raise URLError('no host given') + + # will parse host:port + h = http_class(host, timeout=req.timeout, **http_conn_args) + h.set_debuglevel(self._debuglevel) + + headers = dict(req.unredirected_hdrs) + headers.update({k: v for k, v in req.headers.items() + if k not in headers}) + + # TODO(jhylton): Should this be redesigned to handle + # persistent connections? + + # We want to make an HTTP/1.1 request, but the addinfourl + # class isn't prepared to deal with a persistent connection. + # It will try to read all remaining data from the socket, + # which will block while the server waits for the next request. + # So make sure the connection gets closed after the (only) + # request. + headers["Connection"] = "close" + headers = {name.title(): val for name, val in headers.items()} + + if req._tunnel_host: + tunnel_headers = {} + proxy_auth_hdr = "Proxy-Authorization" + if proxy_auth_hdr in headers: + tunnel_headers[proxy_auth_hdr] = headers[proxy_auth_hdr] + # Proxy-Authorization should not be sent to origin + # server. + del headers[proxy_auth_hdr] + h.set_tunnel(req._tunnel_host, headers=tunnel_headers) + + try: + try: + h.request(req.get_method(), req.selector, req.data, headers, + encode_chunked=req.has_header('Transfer-encoding')) + except OSError as err: # timeout error + raise URLError(err) + r = h.getresponse() + except: + h.close() + raise + + # If the server does not send us a 'Connection: close' header, + # HTTPConnection assumes the socket should be left open. Manually + # mark the socket to be closed when this response object goes away. + if h.sock: + h.sock.close() + h.sock = None + + r.url = req.get_full_url() + # This line replaces the .msg attribute of the HTTPResponse + # with .headers, because urllib clients expect the response to + # have the reason in .msg. It would be good to mark this + # attribute is deprecated and get then to use info() or + # .headers. + r.msg = r.reason + return r + + +class HTTPHandler(AbstractHTTPHandler): + + def http_open(self, req): + return self.do_open(http.client.HTTPConnection, req) + + http_request = AbstractHTTPHandler.do_request_ + +if hasattr(http.client, 'HTTPSConnection'): + + class HTTPSHandler(AbstractHTTPHandler): + + def __init__(self, debuglevel=0, context=None, check_hostname=None): + AbstractHTTPHandler.__init__(self, debuglevel) + self._context = context + self._check_hostname = check_hostname + + def https_open(self, req): + return self.do_open(http.client.HTTPSConnection, req, + context=self._context, check_hostname=self._check_hostname) + + https_request = AbstractHTTPHandler.do_request_ + + __all__.append('HTTPSHandler') + +class HTTPCookieProcessor(BaseHandler): + def __init__(self, cookiejar=None): + import http.cookiejar + if cookiejar is None: + cookiejar = http.cookiejar.CookieJar() + self.cookiejar = cookiejar + + def http_request(self, request): + self.cookiejar.add_cookie_header(request) + return request + + def http_response(self, request, response): + self.cookiejar.extract_cookies(response, request) + return response + + https_request = http_request + https_response = http_response + +class UnknownHandler(BaseHandler): + def unknown_open(self, req): + type = req.type + raise URLError('unknown url type: %s' % type) + +def parse_keqv_list(l): + """Parse list of key=value strings where keys are not duplicated.""" + parsed = {} + for elt in l: + k, v = elt.split('=', 1) + if v[0] == '"' and v[-1] == '"': + v = v[1:-1] + parsed[k] = v + return parsed + +def parse_http_list(s): + """Parse lists as described by RFC 2068 Section 2. + + In particular, parse comma-separated lists where the elements of + the list may include quoted-strings. A quoted-string could + contain a comma. A non-quoted string could have quotes in the + middle. Neither commas nor quotes count if they are escaped. + Only double-quotes count, not single-quotes. + """ + res = [] + part = '' + + escape = quote = False + for cur in s: + if escape: + part += cur + escape = False + continue + if quote: + if cur == '\\': + escape = True + continue + elif cur == '"': + quote = False + part += cur + continue + + if cur == ',': + res.append(part) + part = '' + continue + + if cur == '"': + quote = True + + part += cur + + # append last part + if part: + res.append(part) + + return [part.strip() for part in res] + +class FileHandler(BaseHandler): + # Use local file or FTP depending on form of URL + def file_open(self, req): + url = req.selector + if url[:2] == '//' and url[2:3] != '/' and (req.host and + req.host != 'localhost'): + if not req.host in self.get_names(): + raise URLError("file:// scheme is supported only on localhost") + else: + return self.open_local_file(req) + + # names for the localhost + names = None + def get_names(self): + if FileHandler.names is None: + try: + FileHandler.names = tuple( + socket.gethostbyname_ex('localhost')[2] + + socket.gethostbyname_ex(socket.gethostname())[2]) + except socket.gaierror: + FileHandler.names = (socket.gethostbyname('localhost'),) + return FileHandler.names + + # not entirely sure what the rules are here + def open_local_file(self, req): + import email.utils + import mimetypes + host = req.host + filename = req.selector + localfile = url2pathname(filename) + try: + stats = os.stat(localfile) + size = stats.st_size + modified = email.utils.formatdate(stats.st_mtime, usegmt=True) + mtype = mimetypes.guess_type(filename)[0] + headers = email.message_from_string( + 'Content-type: %s\nContent-length: %d\nLast-modified: %s\n' % + (mtype or 'text/plain', size, modified)) + if host: + host, port = _splitport(host) + if not host or \ + (not port and _safe_gethostbyname(host) in self.get_names()): + if host: + origurl = 'file://' + host + filename + else: + origurl = 'file://' + filename + return addinfourl(open(localfile, 'rb'), headers, origurl) + except OSError as exp: + raise URLError(exp) + raise URLError('file not on local host') + +def _safe_gethostbyname(host): + try: + return socket.gethostbyname(host) + except socket.gaierror: + return None + +class FTPHandler(BaseHandler): + def ftp_open(self, req): + import ftplib + import mimetypes + host = req.host + if not host: + raise URLError('ftp error: no host given') + host, port = _splitport(host) + if port is None: + port = ftplib.FTP_PORT + else: + port = int(port) + + # username/password handling + user, host = _splituser(host) + if user: + user, passwd = _splitpasswd(user) + else: + passwd = None + host = unquote(host) + user = user or '' + passwd = passwd or '' + + try: + host = socket.gethostbyname(host) + except OSError as msg: + raise URLError(msg) + path, attrs = _splitattr(req.selector) + dirs = path.split('/') + dirs = list(map(unquote, dirs)) + dirs, file = dirs[:-1], dirs[-1] + if dirs and not dirs[0]: + dirs = dirs[1:] + try: + fw = self.connect_ftp(user, passwd, host, port, dirs, req.timeout) + type = file and 'I' or 'D' + for attr in attrs: + attr, value = _splitvalue(attr) + if attr.lower() == 'type' and \ + value in ('a', 'A', 'i', 'I', 'd', 'D'): + type = value.upper() + fp, retrlen = fw.retrfile(file, type) + headers = "" + mtype = mimetypes.guess_type(req.full_url)[0] + if mtype: + headers += "Content-type: %s\n" % mtype + if retrlen is not None and retrlen >= 0: + headers += "Content-length: %d\n" % retrlen + headers = email.message_from_string(headers) + return addinfourl(fp, headers, req.full_url) + except ftplib.all_errors as exp: + raise URLError(exp) from exp + + def connect_ftp(self, user, passwd, host, port, dirs, timeout): + return ftpwrapper(user, passwd, host, port, dirs, timeout, + persistent=False) + +class CacheFTPHandler(FTPHandler): + # XXX would be nice to have pluggable cache strategies + # XXX this stuff is definitely not thread safe + def __init__(self): + self.cache = {} + self.timeout = {} + self.soonest = 0 + self.delay = 60 + self.max_conns = 16 + + def setTimeout(self, t): + self.delay = t + + def setMaxConns(self, m): + self.max_conns = m + + def connect_ftp(self, user, passwd, host, port, dirs, timeout): + key = user, host, port, '/'.join(dirs), timeout + if key in self.cache: + self.timeout[key] = time.time() + self.delay + else: + self.cache[key] = ftpwrapper(user, passwd, host, port, + dirs, timeout) + self.timeout[key] = time.time() + self.delay + self.check_cache() + return self.cache[key] + + def check_cache(self): + # first check for old ones + t = time.time() + if self.soonest <= t: + for k, v in list(self.timeout.items()): + if v < t: + self.cache[k].close() + del self.cache[k] + del self.timeout[k] + self.soonest = min(list(self.timeout.values())) + + # then check the size + if len(self.cache) == self.max_conns: + for k, v in list(self.timeout.items()): + if v == self.soonest: + del self.cache[k] + del self.timeout[k] + break + self.soonest = min(list(self.timeout.values())) + + def clear_cache(self): + for conn in self.cache.values(): + conn.close() + self.cache.clear() + self.timeout.clear() + +class DataHandler(BaseHandler): + def data_open(self, req): + # data URLs as specified in RFC 2397. + # + # ignores POSTed data + # + # syntax: + # dataurl := "data:" [ mediatype ] [ ";base64" ] "," data + # mediatype := [ type "/" subtype ] *( ";" parameter ) + # data := *urlchar + # parameter := attribute "=" value + url = req.full_url + + scheme, data = url.split(":",1) + mediatype, data = data.split(",",1) + + # Disallow control characters within mediatype. + if re.search(r"[\x00-\x1F\x7F]", mediatype): + raise ValueError( + "Control characters not allowed in data: mediatype") + + # even base64 encoded data URLs might be quoted so unquote in any case: + data = unquote_to_bytes(data) + if mediatype.endswith(";base64"): + data = base64.decodebytes(data) + mediatype = mediatype[:-7] + + if not mediatype: + mediatype = "text/plain;charset=US-ASCII" + + headers = email.message_from_string("Content-type: %s\nContent-length: %d\n" % + (mediatype, len(data))) + + return addinfourl(io.BytesIO(data), headers, url) + + +# Code move from the old urllib module + +MAXFTPCACHE = 10 # Trim the ftp cache beyond this size + +# Helper for non-unix systems +if os.name == 'nt': + from nturl2path import url2pathname, pathname2url +else: + def url2pathname(pathname): + """OS-specific conversion from a relative URL of the 'file' scheme + to a file system path; not recommended for general use.""" + return unquote(pathname) + + def pathname2url(pathname): + """OS-specific conversion from a file system path to a relative URL + of the 'file' scheme; not recommended for general use.""" + return quote(pathname) + + +ftpcache = {} + + +class URLopener: + """Class to open URLs. + This is a class rather than just a subroutine because we may need + more than one set of global protocol-specific options. + Note -- this is a base class for those who don't want the + automatic handling of errors type 302 (relocated) and 401 + (authorization needed).""" + + __tempfiles = None + + version = "Python-urllib/%s" % __version__ + + # Constructor + def __init__(self, proxies=None, **x509): + msg = "%(class)s style of invoking requests is deprecated. " \ + "Use newer urlopen functions/methods" % {'class': self.__class__.__name__} + warnings.warn(msg, DeprecationWarning, stacklevel=3) + if proxies is None: + proxies = getproxies() + assert hasattr(proxies, 'keys'), "proxies must be a mapping" + self.proxies = proxies + self.key_file = x509.get('key_file') + self.cert_file = x509.get('cert_file') + self.addheaders = [('User-Agent', self.version), ('Accept', '*/*')] + self.__tempfiles = [] + self.__unlink = os.unlink # See cleanup() + self.tempcache = None + # Undocumented feature: if you assign {} to tempcache, + # it is used to cache files retrieved with + # self.retrieve(). This is not enabled by default + # since it does not work for changing documents (and I + # haven't got the logic to check expiration headers + # yet). + self.ftpcache = ftpcache + # Undocumented feature: you can use a different + # ftp cache by assigning to the .ftpcache member; + # in case you want logically independent URL openers + # XXX This is not threadsafe. Bah. + + def __del__(self): + self.close() + + def close(self): + self.cleanup() + + def cleanup(self): + # This code sometimes runs when the rest of this module + # has already been deleted, so it can't use any globals + # or import anything. + if self.__tempfiles: + for file in self.__tempfiles: + try: + self.__unlink(file) + except OSError: + pass + del self.__tempfiles[:] + if self.tempcache: + self.tempcache.clear() + + def addheader(self, *args): + """Add a header to be used by the HTTP interface only + e.g. u.addheader('Accept', 'sound/basic')""" + self.addheaders.append(args) + + # External interface + def open(self, fullurl, data=None): + """Use URLopener().open(file) instead of open(file, 'r').""" + fullurl = unwrap(_to_bytes(fullurl)) + fullurl = quote(fullurl, safe="%/:=&?~#+!$,;'@()*[]|") + if self.tempcache and fullurl in self.tempcache: + filename, headers = self.tempcache[fullurl] + fp = open(filename, 'rb') + return addinfourl(fp, headers, fullurl) + urltype, url = _splittype(fullurl) + if not urltype: + urltype = 'file' + if urltype in self.proxies: + proxy = self.proxies[urltype] + urltype, proxyhost = _splittype(proxy) + host, selector = _splithost(proxyhost) + url = (host, fullurl) # Signal special case to open_*() + else: + proxy = None + name = 'open_' + urltype + self.type = urltype + name = name.replace('-', '_') + if not hasattr(self, name) or name == 'open_local_file': + if proxy: + return self.open_unknown_proxy(proxy, fullurl, data) + else: + return self.open_unknown(fullurl, data) + try: + if data is None: + return getattr(self, name)(url) + else: + return getattr(self, name)(url, data) + except (HTTPError, URLError): + raise + except OSError as msg: + raise OSError('socket error', msg) from msg + + def open_unknown(self, fullurl, data=None): + """Overridable interface to open unknown URL type.""" + type, url = _splittype(fullurl) + raise OSError('url error', 'unknown url type', type) + + def open_unknown_proxy(self, proxy, fullurl, data=None): + """Overridable interface to open unknown URL type.""" + type, url = _splittype(fullurl) + raise OSError('url error', 'invalid proxy for %s' % type, proxy) + + # External interface + def retrieve(self, url, filename=None, reporthook=None, data=None): + """retrieve(url) returns (filename, headers) for a local object + or (tempfilename, headers) for a remote object.""" + url = unwrap(_to_bytes(url)) + if self.tempcache and url in self.tempcache: + return self.tempcache[url] + type, url1 = _splittype(url) + if filename is None and (not type or type == 'file'): + try: + fp = self.open_local_file(url1) + hdrs = fp.info() + fp.close() + return url2pathname(_splithost(url1)[1]), hdrs + except OSError: + pass + fp = self.open(url, data) + try: + headers = fp.info() + if filename: + tfp = open(filename, 'wb') + else: + garbage, path = _splittype(url) + garbage, path = _splithost(path or "") + path, garbage = _splitquery(path or "") + path, garbage = _splitattr(path or "") + suffix = os.path.splitext(path)[1] + (fd, filename) = tempfile.mkstemp(suffix) + self.__tempfiles.append(filename) + tfp = os.fdopen(fd, 'wb') + try: + result = filename, headers + if self.tempcache is not None: + self.tempcache[url] = result + bs = 1024*8 + size = -1 + read = 0 + blocknum = 0 + if "content-length" in headers: + size = int(headers["Content-Length"]) + if reporthook: + reporthook(blocknum, bs, size) + while 1: + block = fp.read(bs) + if not block: + break + read += len(block) + tfp.write(block) + blocknum += 1 + if reporthook: + reporthook(blocknum, bs, size) + finally: + tfp.close() + finally: + fp.close() + + # raise exception if actual size does not match content-length header + if size >= 0 and read < size: + raise ContentTooShortError( + "retrieval incomplete: got only %i out of %i bytes" + % (read, size), result) + + return result + + # Each method named open_ knows how to open that type of URL + + def _open_generic_http(self, connection_factory, url, data): + """Make an HTTP connection using connection_class. + + This is an internal method that should be called from + open_http() or open_https(). + + Arguments: + - connection_factory should take a host name and return an + HTTPConnection instance. + - url is the url to retrieval or a host, relative-path pair. + - data is payload for a POST request or None. + """ + + user_passwd = None + proxy_passwd= None + if isinstance(url, str): + host, selector = _splithost(url) + if host: + user_passwd, host = _splituser(host) + host = unquote(host) + realhost = host + else: + host, selector = url + # check whether the proxy contains authorization information + proxy_passwd, host = _splituser(host) + # now we proceed with the url we want to obtain + urltype, rest = _splittype(selector) + url = rest + user_passwd = None + if urltype.lower() != 'http': + realhost = None + else: + realhost, rest = _splithost(rest) + if realhost: + user_passwd, realhost = _splituser(realhost) + if user_passwd: + selector = "%s://%s%s" % (urltype, realhost, rest) + if proxy_bypass(realhost): + host = realhost + + if not host: raise OSError('http error', 'no host given') + + if proxy_passwd: + proxy_passwd = unquote(proxy_passwd) + proxy_auth = base64.b64encode(proxy_passwd.encode()).decode('ascii') + else: + proxy_auth = None + + if user_passwd: + user_passwd = unquote(user_passwd) + auth = base64.b64encode(user_passwd.encode()).decode('ascii') + else: + auth = None + http_conn = connection_factory(host) + headers = {} + if proxy_auth: + headers["Proxy-Authorization"] = "Basic %s" % proxy_auth + if auth: + headers["Authorization"] = "Basic %s" % auth + if realhost: + headers["Host"] = realhost + + # Add Connection:close as we don't support persistent connections yet. + # This helps in closing the socket and avoiding ResourceWarning + + headers["Connection"] = "close" + + for header, value in self.addheaders: + headers[header] = value + + if data is not None: + headers["Content-Type"] = "application/x-www-form-urlencoded" + http_conn.request("POST", selector, data, headers) + else: + http_conn.request("GET", selector, headers=headers) + + try: + response = http_conn.getresponse() + except http.client.BadStatusLine: + # something went wrong with the HTTP status line + raise URLError("http protocol error: bad status line") + + # According to RFC 2616, "2xx" code indicates that the client's + # request was successfully received, understood, and accepted. + if 200 <= response.status < 300: + return addinfourl(response, response.msg, "http:" + url, + response.status) + else: + return self.http_error( + url, response.fp, + response.status, response.reason, response.msg, data) + + def open_http(self, url, data=None): + """Use HTTP protocol.""" + return self._open_generic_http(http.client.HTTPConnection, url, data) + + def http_error(self, url, fp, errcode, errmsg, headers, data=None): + """Handle http errors. + + Derived class can override this, or provide specific handlers + named http_error_DDD where DDD is the 3-digit error code.""" + # First check if there's a specific handler for this error + name = 'http_error_%d' % errcode + if hasattr(self, name): + method = getattr(self, name) + if data is None: + result = method(url, fp, errcode, errmsg, headers) + else: + result = method(url, fp, errcode, errmsg, headers, data) + if result: return result + return self.http_error_default(url, fp, errcode, errmsg, headers) + + def http_error_default(self, url, fp, errcode, errmsg, headers): + """Default error handler: close the connection and raise OSError.""" + fp.close() + raise HTTPError(url, errcode, errmsg, headers, None) + + if _have_ssl: + def _https_connection(self, host): + return http.client.HTTPSConnection(host, + key_file=self.key_file, + cert_file=self.cert_file) + + def open_https(self, url, data=None): + """Use HTTPS protocol.""" + return self._open_generic_http(self._https_connection, url, data) + + def open_file(self, url): + """Use local file or FTP depending on form of URL.""" + if not isinstance(url, str): + raise URLError('file error: proxy support for file protocol currently not implemented') + if url[:2] == '//' and url[2:3] != '/' and url[2:12].lower() != 'localhost/': + raise ValueError("file:// scheme is supported only on localhost") + else: + return self.open_local_file(url) + + def open_local_file(self, url): + """Use local file.""" + import email.utils + import mimetypes + host, file = _splithost(url) + localname = url2pathname(file) + try: + stats = os.stat(localname) + except OSError as e: + raise URLError(e.strerror, e.filename) + size = stats.st_size + modified = email.utils.formatdate(stats.st_mtime, usegmt=True) + mtype = mimetypes.guess_type(url)[0] + headers = email.message_from_string( + 'Content-Type: %s\nContent-Length: %d\nLast-modified: %s\n' % + (mtype or 'text/plain', size, modified)) + if not host: + urlfile = file + if file[:1] == '/': + urlfile = 'file://' + file + return addinfourl(open(localname, 'rb'), headers, urlfile) + host, port = _splitport(host) + if (not port + and socket.gethostbyname(host) in ((localhost(),) + thishost())): + urlfile = file + if file[:1] == '/': + urlfile = 'file://' + file + elif file[:2] == './': + raise ValueError("local file url may start with / or file:. Unknown url of type: %s" % url) + return addinfourl(open(localname, 'rb'), headers, urlfile) + raise URLError('local file error: not on local host') + + def open_ftp(self, url): + """Use FTP protocol.""" + if not isinstance(url, str): + raise URLError('ftp error: proxy support for ftp protocol currently not implemented') + import mimetypes + host, path = _splithost(url) + if not host: raise URLError('ftp error: no host given') + host, port = _splitport(host) + user, host = _splituser(host) + if user: user, passwd = _splitpasswd(user) + else: passwd = None + host = unquote(host) + user = unquote(user or '') + passwd = unquote(passwd or '') + host = socket.gethostbyname(host) + if not port: + import ftplib + port = ftplib.FTP_PORT + else: + port = int(port) + path, attrs = _splitattr(path) + path = unquote(path) + dirs = path.split('/') + dirs, file = dirs[:-1], dirs[-1] + if dirs and not dirs[0]: dirs = dirs[1:] + if dirs and not dirs[0]: dirs[0] = '/' + key = user, host, port, '/'.join(dirs) + # XXX thread unsafe! + if len(self.ftpcache) > MAXFTPCACHE: + # Prune the cache, rather arbitrarily + for k in list(self.ftpcache): + if k != key: + v = self.ftpcache[k] + del self.ftpcache[k] + v.close() + try: + if key not in self.ftpcache: + self.ftpcache[key] = \ + ftpwrapper(user, passwd, host, port, dirs) + if not file: type = 'D' + else: type = 'I' + for attr in attrs: + attr, value = _splitvalue(attr) + if attr.lower() == 'type' and \ + value in ('a', 'A', 'i', 'I', 'd', 'D'): + type = value.upper() + (fp, retrlen) = self.ftpcache[key].retrfile(file, type) + mtype = mimetypes.guess_type("ftp:" + url)[0] + headers = "" + if mtype: + headers += "Content-Type: %s\n" % mtype + if retrlen is not None and retrlen >= 0: + headers += "Content-Length: %d\n" % retrlen + headers = email.message_from_string(headers) + return addinfourl(fp, headers, "ftp:" + url) + except ftperrors() as exp: + raise URLError(f'ftp error: {exp}') from exp + + def open_data(self, url, data=None): + """Use "data" URL.""" + if not isinstance(url, str): + raise URLError('data error: proxy support for data protocol currently not implemented') + # ignore POSTed data + # + # syntax of data URLs: + # dataurl := "data:" [ mediatype ] [ ";base64" ] "," data + # mediatype := [ type "/" subtype ] *( ";" parameter ) + # data := *urlchar + # parameter := attribute "=" value + try: + [type, data] = url.split(',', 1) + except ValueError: + raise OSError('data error', 'bad data URL') + if not type: + type = 'text/plain;charset=US-ASCII' + semi = type.rfind(';') + if semi >= 0 and '=' not in type[semi:]: + encoding = type[semi+1:] + type = type[:semi] + else: + encoding = '' + msg = [] + msg.append('Date: %s'%time.strftime('%a, %d %b %Y %H:%M:%S GMT', + time.gmtime(time.time()))) + msg.append('Content-type: %s' % type) + if encoding == 'base64': + # XXX is this encoding/decoding ok? + data = base64.decodebytes(data.encode('ascii')).decode('latin-1') + else: + data = unquote(data) + msg.append('Content-Length: %d' % len(data)) + msg.append('') + msg.append(data) + msg = '\n'.join(msg) + headers = email.message_from_string(msg) + f = io.StringIO(msg) + #f.fileno = None # needed for addinfourl + return addinfourl(f, headers, url) + + +class FancyURLopener(URLopener): + """Derived class with handlers for errors we can handle (perhaps).""" + + def __init__(self, *args, **kwargs): + URLopener.__init__(self, *args, **kwargs) + self.auth_cache = {} + self.tries = 0 + self.maxtries = 10 + + def http_error_default(self, url, fp, errcode, errmsg, headers): + """Default error handling -- don't raise an exception.""" + return addinfourl(fp, headers, "http:" + url, errcode) + + def http_error_302(self, url, fp, errcode, errmsg, headers, data=None): + """Error 302 -- relocated (temporarily).""" + self.tries += 1 + try: + if self.maxtries and self.tries >= self.maxtries: + if hasattr(self, "http_error_500"): + meth = self.http_error_500 + else: + meth = self.http_error_default + return meth(url, fp, 500, + "Internal Server Error: Redirect Recursion", + headers) + result = self.redirect_internal(url, fp, errcode, errmsg, + headers, data) + return result + finally: + self.tries = 0 + + def redirect_internal(self, url, fp, errcode, errmsg, headers, data): + if 'location' in headers: + newurl = headers['location'] + elif 'uri' in headers: + newurl = headers['uri'] + else: + return + fp.close() + + # In case the server sent a relative URL, join with original: + newurl = urljoin(self.type + ":" + url, newurl) + + urlparts = urlparse(newurl) + + # For security reasons, we don't allow redirection to anything other + # than http, https and ftp. + + # We are using newer HTTPError with older redirect_internal method + # This older method will get deprecated in 3.3 + + if urlparts.scheme not in ('http', 'https', 'ftp', ''): + raise HTTPError(newurl, errcode, + errmsg + + " Redirection to url '%s' is not allowed." % newurl, + headers, fp) + + return self.open(newurl) + + def http_error_301(self, url, fp, errcode, errmsg, headers, data=None): + """Error 301 -- also relocated (permanently).""" + return self.http_error_302(url, fp, errcode, errmsg, headers, data) + + def http_error_303(self, url, fp, errcode, errmsg, headers, data=None): + """Error 303 -- also relocated (essentially identical to 302).""" + return self.http_error_302(url, fp, errcode, errmsg, headers, data) + + def http_error_307(self, url, fp, errcode, errmsg, headers, data=None): + """Error 307 -- relocated, but turn POST into error.""" + if data is None: + return self.http_error_302(url, fp, errcode, errmsg, headers, data) + else: + return self.http_error_default(url, fp, errcode, errmsg, headers) + + def http_error_308(self, url, fp, errcode, errmsg, headers, data=None): + """Error 308 -- relocated, but turn POST into error.""" + if data is None: + return self.http_error_301(url, fp, errcode, errmsg, headers, data) + else: + return self.http_error_default(url, fp, errcode, errmsg, headers) + + def http_error_401(self, url, fp, errcode, errmsg, headers, data=None, + retry=False): + """Error 401 -- authentication required. + This function supports Basic authentication only.""" + if 'www-authenticate' not in headers: + URLopener.http_error_default(self, url, fp, + errcode, errmsg, headers) + stuff = headers['www-authenticate'] + match = re.match('[ \t]*([^ \t]+)[ \t]+realm="([^"]*)"', stuff) + if not match: + URLopener.http_error_default(self, url, fp, + errcode, errmsg, headers) + scheme, realm = match.groups() + if scheme.lower() != 'basic': + URLopener.http_error_default(self, url, fp, + errcode, errmsg, headers) + if not retry: + URLopener.http_error_default(self, url, fp, errcode, errmsg, + headers) + name = 'retry_' + self.type + '_basic_auth' + if data is None: + return getattr(self,name)(url, realm) + else: + return getattr(self,name)(url, realm, data) + + def http_error_407(self, url, fp, errcode, errmsg, headers, data=None, + retry=False): + """Error 407 -- proxy authentication required. + This function supports Basic authentication only.""" + if 'proxy-authenticate' not in headers: + URLopener.http_error_default(self, url, fp, + errcode, errmsg, headers) + stuff = headers['proxy-authenticate'] + match = re.match('[ \t]*([^ \t]+)[ \t]+realm="([^"]*)"', stuff) + if not match: + URLopener.http_error_default(self, url, fp, + errcode, errmsg, headers) + scheme, realm = match.groups() + if scheme.lower() != 'basic': + URLopener.http_error_default(self, url, fp, + errcode, errmsg, headers) + if not retry: + URLopener.http_error_default(self, url, fp, errcode, errmsg, + headers) + name = 'retry_proxy_' + self.type + '_basic_auth' + if data is None: + return getattr(self,name)(url, realm) + else: + return getattr(self,name)(url, realm, data) + + def retry_proxy_http_basic_auth(self, url, realm, data=None): + host, selector = _splithost(url) + newurl = 'http://' + host + selector + proxy = self.proxies['http'] + urltype, proxyhost = _splittype(proxy) + proxyhost, proxyselector = _splithost(proxyhost) + i = proxyhost.find('@') + 1 + proxyhost = proxyhost[i:] + user, passwd = self.get_user_passwd(proxyhost, realm, i) + if not (user or passwd): return None + proxyhost = "%s:%s@%s" % (quote(user, safe=''), + quote(passwd, safe=''), proxyhost) + self.proxies['http'] = 'http://' + proxyhost + proxyselector + if data is None: + return self.open(newurl) + else: + return self.open(newurl, data) + + def retry_proxy_https_basic_auth(self, url, realm, data=None): + host, selector = _splithost(url) + newurl = 'https://' + host + selector + proxy = self.proxies['https'] + urltype, proxyhost = _splittype(proxy) + proxyhost, proxyselector = _splithost(proxyhost) + i = proxyhost.find('@') + 1 + proxyhost = proxyhost[i:] + user, passwd = self.get_user_passwd(proxyhost, realm, i) + if not (user or passwd): return None + proxyhost = "%s:%s@%s" % (quote(user, safe=''), + quote(passwd, safe=''), proxyhost) + self.proxies['https'] = 'https://' + proxyhost + proxyselector + if data is None: + return self.open(newurl) + else: + return self.open(newurl, data) + + def retry_http_basic_auth(self, url, realm, data=None): + host, selector = _splithost(url) + i = host.find('@') + 1 + host = host[i:] + user, passwd = self.get_user_passwd(host, realm, i) + if not (user or passwd): return None + host = "%s:%s@%s" % (quote(user, safe=''), + quote(passwd, safe=''), host) + newurl = 'http://' + host + selector + if data is None: + return self.open(newurl) + else: + return self.open(newurl, data) + + def retry_https_basic_auth(self, url, realm, data=None): + host, selector = _splithost(url) + i = host.find('@') + 1 + host = host[i:] + user, passwd = self.get_user_passwd(host, realm, i) + if not (user or passwd): return None + host = "%s:%s@%s" % (quote(user, safe=''), + quote(passwd, safe=''), host) + newurl = 'https://' + host + selector + if data is None: + return self.open(newurl) + else: + return self.open(newurl, data) + + def get_user_passwd(self, host, realm, clear_cache=0): + key = realm + '@' + host.lower() + if key in self.auth_cache: + if clear_cache: + del self.auth_cache[key] + else: + return self.auth_cache[key] + user, passwd = self.prompt_user_passwd(host, realm) + if user or passwd: self.auth_cache[key] = (user, passwd) + return user, passwd + + def prompt_user_passwd(self, host, realm): + """Override this in a GUI environment!""" + import getpass + try: + user = input("Enter username for %s at %s: " % (realm, host)) + passwd = getpass.getpass("Enter password for %s in %s at %s: " % + (user, realm, host)) + return user, passwd + except KeyboardInterrupt: + print() + return None, None + + +# Utility functions + +_localhost = None +def localhost(): + """Return the IP address of the magic hostname 'localhost'.""" + global _localhost + if _localhost is None: + _localhost = socket.gethostbyname('localhost') + return _localhost + +_thishost = None +def thishost(): + """Return the IP addresses of the current host.""" + global _thishost + if _thishost is None: + try: + _thishost = tuple(socket.gethostbyname_ex(socket.gethostname())[2]) + except socket.gaierror: + _thishost = tuple(socket.gethostbyname_ex('localhost')[2]) + return _thishost + +_ftperrors = None +def ftperrors(): + """Return the set of errors raised by the FTP class.""" + global _ftperrors + if _ftperrors is None: + import ftplib + _ftperrors = ftplib.all_errors + return _ftperrors + +_noheaders = None +def noheaders(): + """Return an empty email Message object.""" + global _noheaders + if _noheaders is None: + _noheaders = email.message_from_string("") + return _noheaders + + +# Utility classes + +class ftpwrapper: + """Class used by open_ftp() for cache of open FTP connections.""" + + def __init__(self, user, passwd, host, port, dirs, timeout=None, + persistent=True): + self.user = user + self.passwd = passwd + self.host = host + self.port = port + self.dirs = dirs + self.timeout = timeout + self.refcount = 0 + self.keepalive = persistent + try: + self.init() + except: + self.close() + raise + + def init(self): + import ftplib + self.busy = 0 + self.ftp = ftplib.FTP() + self.ftp.connect(self.host, self.port, self.timeout) + self.ftp.login(self.user, self.passwd) + _target = '/'.join(self.dirs) + self.ftp.cwd(_target) + + def retrfile(self, file, type): + import ftplib + self.endtransfer() + if type in ('d', 'D'): cmd = 'TYPE A'; isdir = 1 + else: cmd = 'TYPE ' + type; isdir = 0 + try: + self.ftp.voidcmd(cmd) + except ftplib.all_errors: + self.init() + self.ftp.voidcmd(cmd) + conn = None + if file and not isdir: + # Try to retrieve as a file + try: + cmd = 'RETR ' + file + conn, retrlen = self.ftp.ntransfercmd(cmd) + except ftplib.error_perm as reason: + if str(reason)[:3] != '550': + raise URLError(f'ftp error: {reason}') from reason + if not conn: + # Set transfer mode to ASCII! + self.ftp.voidcmd('TYPE A') + # Try a directory listing. Verify that directory exists. + if file: + pwd = self.ftp.pwd() + try: + try: + self.ftp.cwd(file) + except ftplib.error_perm as reason: + raise URLError('ftp error: %r' % reason) from reason + finally: + self.ftp.cwd(pwd) + cmd = 'LIST ' + file + else: + cmd = 'LIST' + conn, retrlen = self.ftp.ntransfercmd(cmd) + self.busy = 1 + + ftpobj = addclosehook(conn.makefile('rb'), self.file_close) + self.refcount += 1 + conn.close() + # Pass back both a suitably decorated object and a retrieval length + return (ftpobj, retrlen) + + def endtransfer(self): + if not self.busy: + return + self.busy = 0 + try: + self.ftp.voidresp() + except ftperrors(): + pass + + def close(self): + self.keepalive = False + if self.refcount <= 0: + self.real_close() + + def file_close(self): + self.endtransfer() + self.refcount -= 1 + if self.refcount <= 0 and not self.keepalive: + self.real_close() + + def real_close(self): + self.endtransfer() + try: + self.ftp.close() + except ftperrors(): + pass + +# Proxy handling +def getproxies_environment(): + """Return a dictionary of scheme -> proxy server URL mappings. + + Scan the environment for variables named _proxy; + this seems to be the standard convention. If you need a + different way, you can pass a proxies dictionary to the + [Fancy]URLopener constructor. + + """ + proxies = {} + # in order to prefer lowercase variables, process environment in + # two passes: first matches any, second pass matches lowercase only + for name, value in os.environ.items(): + name = name.lower() + if value and name[-6:] == '_proxy': + proxies[name[:-6]] = value + # CVE-2016-1000110 - If we are running as CGI script, forget HTTP_PROXY + # (non-all-lowercase) as it may be set from the web server by a "Proxy:" + # header from the client + # If "proxy" is lowercase, it will still be used thanks to the next block + if 'REQUEST_METHOD' in os.environ: + proxies.pop('http', None) + for name, value in os.environ.items(): + if name[-6:] == '_proxy': + name = name.lower() + if value: + proxies[name[:-6]] = value + else: + proxies.pop(name[:-6], None) + return proxies + +def proxy_bypass_environment(host, proxies=None): + """Test if proxies should not be used for a particular host. + + Checks the proxy dict for the value of no_proxy, which should + be a list of comma separated DNS suffixes, or '*' for all hosts. + + """ + if proxies is None: + proxies = getproxies_environment() + # don't bypass, if no_proxy isn't specified + try: + no_proxy = proxies['no'] + except KeyError: + return False + # '*' is special case for always bypass + if no_proxy == '*': + return True + host = host.lower() + # strip port off host + hostonly, port = _splitport(host) + # check if the host ends with any of the DNS suffixes + for name in no_proxy.split(','): + name = name.strip() + if name: + name = name.lstrip('.') # ignore leading dots + name = name.lower() + if hostonly == name or host == name: + return True + name = '.' + name + if hostonly.endswith(name) or host.endswith(name): + return True + # otherwise, don't bypass + return False + + +# This code tests an OSX specific data structure but is testable on all +# platforms +def _proxy_bypass_macosx_sysconf(host, proxy_settings): + """ + Return True iff this host shouldn't be accessed using a proxy + + This function uses the MacOSX framework SystemConfiguration + to fetch the proxy information. + + proxy_settings come from _scproxy._get_proxy_settings or get mocked ie: + { 'exclude_simple': bool, + 'exceptions': ['foo.bar', '*.bar.com', '127.0.0.1', '10.1', '10.0/16'] + } + """ + from fnmatch import fnmatch + from ipaddress import AddressValueError, IPv4Address + + hostonly, port = _splitport(host) + + def ip2num(ipAddr): + parts = ipAddr.split('.') + parts = list(map(int, parts)) + if len(parts) != 4: + parts = (parts + [0, 0, 0, 0])[:4] + return (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3] + + # Check for simple host names: + if '.' not in host: + if proxy_settings['exclude_simple']: + return True + + hostIP = None + try: + hostIP = int(IPv4Address(hostonly)) + except AddressValueError: + pass + + for value in proxy_settings.get('exceptions', ()): + # Items in the list are strings like these: *.local, 169.254/16 + if not value: continue + + m = re.match(r"(\d+(?:\.\d+)*)(/\d+)?", value) + if m is not None and hostIP is not None: + base = ip2num(m.group(1)) + mask = m.group(2) + if mask is None: + mask = 8 * (m.group(1).count('.') + 1) + else: + mask = int(mask[1:]) + + if mask < 0 or mask > 32: + # System libraries ignore invalid prefix lengths + continue + + mask = 32 - mask + + if (hostIP >> mask) == (base >> mask): + return True + + elif fnmatch(host, value): + return True + + return False + + +# Same as _proxy_bypass_macosx_sysconf, testable on all platforms +def _proxy_bypass_winreg_override(host, override): + """Return True if the host should bypass the proxy server. + + The proxy override list is obtained from the Windows + Internet settings proxy override registry value. + + An example of a proxy override value is: + "www.example.com;*.example.net; 192.168.0.1" + """ + from fnmatch import fnmatch + + host, _ = _splitport(host) + proxy_override = override.split(';') + for test in proxy_override: + test = test.strip() + # "" should bypass the proxy server for all intranet addresses + if test == '': + if '.' not in host: + return True + elif fnmatch(host, test): + return True + return False + + +if sys.platform == 'darwin': + from _scproxy import _get_proxy_settings, _get_proxies + + def proxy_bypass_macosx_sysconf(host): + proxy_settings = _get_proxy_settings() + return _proxy_bypass_macosx_sysconf(host, proxy_settings) + + def getproxies_macosx_sysconf(): + """Return a dictionary of scheme -> proxy server URL mappings. + + This function uses the MacOSX framework SystemConfiguration + to fetch the proxy information. + """ + return _get_proxies() + + + + def proxy_bypass(host): + """Return True, if host should be bypassed. + + Checks proxy settings gathered from the environment, if specified, + or from the MacOSX framework SystemConfiguration. + + """ + proxies = getproxies_environment() + if proxies: + return proxy_bypass_environment(host, proxies) + else: + return proxy_bypass_macosx_sysconf(host) + + def getproxies(): + return getproxies_environment() or getproxies_macosx_sysconf() + + +elif os.name == 'nt': + def getproxies_registry(): + """Return a dictionary of scheme -> proxy server URL mappings. + + Win32 uses the registry to store proxies. + + """ + proxies = {} + try: + import winreg + except ImportError: + # Std module, so should be around - but you never know! + return proxies + try: + internetSettings = winreg.OpenKey(winreg.HKEY_CURRENT_USER, + r'Software\Microsoft\Windows\CurrentVersion\Internet Settings') + proxyEnable = winreg.QueryValueEx(internetSettings, + 'ProxyEnable')[0] + if proxyEnable: + # Returned as Unicode but problems if not converted to ASCII + proxyServer = str(winreg.QueryValueEx(internetSettings, + 'ProxyServer')[0]) + if '=' not in proxyServer and ';' not in proxyServer: + # Use one setting for all protocols. + proxyServer = 'http={0};https={0};ftp={0}'.format(proxyServer) + for p in proxyServer.split(';'): + protocol, address = p.split('=', 1) + # See if address has a type:// prefix + if not re.match('(?:[^/:]+)://', address): + # Add type:// prefix to address without specifying type + if protocol in ('http', 'https', 'ftp'): + # The default proxy type of Windows is HTTP + address = 'http://' + address + elif protocol == 'socks': + address = 'socks://' + address + proxies[protocol] = address + # Use SOCKS proxy for HTTP(S) protocols + if proxies.get('socks'): + # The default SOCKS proxy type of Windows is SOCKS4 + address = re.sub(r'^socks://', 'socks4://', proxies['socks']) + proxies['http'] = proxies.get('http') or address + proxies['https'] = proxies.get('https') or address + internetSettings.Close() + except (OSError, ValueError, TypeError): + # Either registry key not found etc, or the value in an + # unexpected format. + # proxies already set up to be empty so nothing to do + pass + return proxies + + def getproxies(): + """Return a dictionary of scheme -> proxy server URL mappings. + + Returns settings gathered from the environment, if specified, + or the registry. + + """ + return getproxies_environment() or getproxies_registry() + + def proxy_bypass_registry(host): + try: + import winreg + except ImportError: + # Std modules, so should be around - but you never know! + return False + try: + internetSettings = winreg.OpenKey(winreg.HKEY_CURRENT_USER, + r'Software\Microsoft\Windows\CurrentVersion\Internet Settings') + proxyEnable = winreg.QueryValueEx(internetSettings, + 'ProxyEnable')[0] + proxyOverride = str(winreg.QueryValueEx(internetSettings, + 'ProxyOverride')[0]) + # ^^^^ Returned as Unicode but problems if not converted to ASCII + except OSError: + return False + if not proxyEnable or not proxyOverride: + return False + return _proxy_bypass_winreg_override(host, proxyOverride) + + def proxy_bypass(host): + """Return True, if host should be bypassed. + + Checks proxy settings gathered from the environment, if specified, + or the registry. + + """ + proxies = getproxies_environment() + if proxies: + return proxy_bypass_environment(host, proxies) + else: + return proxy_bypass_registry(host) + +else: + # By default use environment variables + getproxies = getproxies_environment + proxy_bypass = proxy_bypass_environment diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/response.py b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/response.py new file mode 100644 index 0000000000000000000000000000000000000000..5a2c3cc78c395d57de3fbadf7d75b96035b785b6 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/response.py @@ -0,0 +1,84 @@ +"""Response classes used by urllib. + +The base class, addbase, defines a minimal file-like interface, +including read() and readline(). The typical response object is an +addinfourl instance, which defines an info() method that returns +headers and a geturl() method that returns the url. +""" + +import tempfile + +__all__ = ['addbase', 'addclosehook', 'addinfo', 'addinfourl'] + + +class addbase(tempfile._TemporaryFileWrapper): + """Base class for addinfo and addclosehook. Is a good idea for garbage collection.""" + + # XXX Add a method to expose the timeout on the underlying socket? + + def __init__(self, fp): + super(addbase, self).__init__(fp, '', delete=False) + # Keep reference around as this was part of the original API. + self.fp = fp + + def __repr__(self): + return '<%s at %r whose fp = %r>' % (self.__class__.__name__, + id(self), self.file) + + def __enter__(self): + if self.fp.closed: + raise ValueError("I/O operation on closed file") + return self + + def __exit__(self, type, value, traceback): + self.close() + + +class addclosehook(addbase): + """Class to add a close hook to an open file.""" + + def __init__(self, fp, closehook, *hookargs): + super(addclosehook, self).__init__(fp) + self.closehook = closehook + self.hookargs = hookargs + + def close(self): + try: + closehook = self.closehook + hookargs = self.hookargs + if closehook: + self.closehook = None + self.hookargs = None + closehook(*hookargs) + finally: + super(addclosehook, self).close() + + +class addinfo(addbase): + """class to add an info() method to an open file.""" + + def __init__(self, fp, headers): + super(addinfo, self).__init__(fp) + self.headers = headers + + def info(self): + return self.headers + + +class addinfourl(addinfo): + """class to add info() and geturl() methods to an open file.""" + + def __init__(self, fp, headers, url, code=None): + super(addinfourl, self).__init__(fp, headers) + self.url = url + self.code = code + + @property + def status(self): + return self.code + + def getcode(self): + return self.code + + def geturl(self): + return self.url diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/robotparser.py b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/robotparser.py new file mode 100644 index 0000000000000000000000000000000000000000..c58565e39451461f03dc7d9fb652554c96615f00 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/urllib/robotparser.py @@ -0,0 +1,273 @@ +""" robotparser.py + + Copyright (C) 2000 Bastian Kleineidam + + You can choose between two licenses when using this package: + 1) GNU GPLv2 + 2) PSF license for Python 2.2 + + The robots.txt Exclusion Protocol is implemented as specified in + http://www.robotstxt.org/norobots-rfc.txt +""" + +import collections +import urllib.parse +import urllib.request + +__all__ = ["RobotFileParser"] + +RequestRate = collections.namedtuple("RequestRate", "requests seconds") + + +class RobotFileParser: + """ This class provides a set of methods to read, parse and answer + questions about a single robots.txt file. + + """ + + def __init__(self, url=''): + self.entries = [] + self.sitemaps = [] + self.default_entry = None + self.disallow_all = False + self.allow_all = False + self.set_url(url) + self.last_checked = 0 + + def mtime(self): + """Returns the time the robots.txt file was last fetched. + + This is useful for long-running web spiders that need to + check for new robots.txt files periodically. + + """ + return self.last_checked + + def modified(self): + """Sets the time the robots.txt file was last fetched to the + current time. + + """ + import time + self.last_checked = time.time() + + def set_url(self, url): + """Sets the URL referring to a robots.txt file.""" + self.url = url + self.host, self.path = urllib.parse.urlparse(url)[1:3] + + def read(self): + """Reads the robots.txt URL and feeds it to the parser.""" + try: + f = urllib.request.urlopen(self.url) + except urllib.error.HTTPError as err: + if err.code in (401, 403): + self.disallow_all = True + elif err.code >= 400 and err.code < 500: + self.allow_all = True + else: + raw = f.read() + self.parse(raw.decode("utf-8").splitlines()) + + def _add_entry(self, entry): + if "*" in entry.useragents: + # the default entry is considered last + if self.default_entry is None: + # the first default entry wins + self.default_entry = entry + else: + self.entries.append(entry) + + def parse(self, lines): + """Parse the input lines from a robots.txt file. + + We allow that a user-agent: line is not preceded by + one or more blank lines. + """ + # states: + # 0: start state + # 1: saw user-agent line + # 2: saw an allow or disallow line + state = 0 + entry = Entry() + + self.modified() + for line in lines: + if not line: + if state == 1: + entry = Entry() + state = 0 + elif state == 2: + self._add_entry(entry) + entry = Entry() + state = 0 + # remove optional comment and strip line + i = line.find('#') + if i >= 0: + line = line[:i] + line = line.strip() + if not line: + continue + line = line.split(':', 1) + if len(line) == 2: + line[0] = line[0].strip().lower() + line[1] = urllib.parse.unquote(line[1].strip()) + if line[0] == "user-agent": + if state == 2: + self._add_entry(entry) + entry = Entry() + entry.useragents.append(line[1]) + state = 1 + elif line[0] == "disallow": + if state != 0: + entry.rulelines.append(RuleLine(line[1], False)) + state = 2 + elif line[0] == "allow": + if state != 0: + entry.rulelines.append(RuleLine(line[1], True)) + state = 2 + elif line[0] == "crawl-delay": + if state != 0: + # before trying to convert to int we need to make + # sure that robots.txt has valid syntax otherwise + # it will crash + if line[1].strip().isdigit(): + entry.delay = int(line[1]) + state = 2 + elif line[0] == "request-rate": + if state != 0: + numbers = line[1].split('/') + # check if all values are sane + if (len(numbers) == 2 and numbers[0].strip().isdigit() + and numbers[1].strip().isdigit()): + entry.req_rate = RequestRate(int(numbers[0]), int(numbers[1])) + state = 2 + elif line[0] == "sitemap": + # According to http://www.sitemaps.org/protocol.html + # "This directive is independent of the user-agent line, + # so it doesn't matter where you place it in your file." + # Therefore we do not change the state of the parser. + self.sitemaps.append(line[1]) + if state == 2: + self._add_entry(entry) + + def can_fetch(self, useragent, url): + """using the parsed robots.txt decide if useragent can fetch url""" + if self.disallow_all: + return False + if self.allow_all: + return True + # Until the robots.txt file has been read or found not + # to exist, we must assume that no url is allowable. + # This prevents false positives when a user erroneously + # calls can_fetch() before calling read(). + if not self.last_checked: + return False + # search for given user agent matches + # the first match counts + parsed_url = urllib.parse.urlparse(urllib.parse.unquote(url)) + url = urllib.parse.urlunparse(('','',parsed_url.path, + parsed_url.params,parsed_url.query, parsed_url.fragment)) + url = urllib.parse.quote(url) + if not url: + url = "/" + for entry in self.entries: + if entry.applies_to(useragent): + return entry.allowance(url) + # try the default entry last + if self.default_entry: + return self.default_entry.allowance(url) + # agent not found ==> access granted + return True + + def crawl_delay(self, useragent): + if not self.mtime(): + return None + for entry in self.entries: + if entry.applies_to(useragent): + return entry.delay + if self.default_entry: + return self.default_entry.delay + return None + + def request_rate(self, useragent): + if not self.mtime(): + return None + for entry in self.entries: + if entry.applies_to(useragent): + return entry.req_rate + if self.default_entry: + return self.default_entry.req_rate + return None + + def site_maps(self): + if not self.sitemaps: + return None + return self.sitemaps + + def __str__(self): + entries = self.entries + if self.default_entry is not None: + entries = entries + [self.default_entry] + return '\n\n'.join(map(str, entries)) + + +class RuleLine: + """A rule line is a single "Allow:" (allowance==True) or "Disallow:" + (allowance==False) followed by a path.""" + def __init__(self, path, allowance): + if path == '' and not allowance: + # an empty value means allow all + allowance = True + path = urllib.parse.urlunparse(urllib.parse.urlparse(path)) + self.path = urllib.parse.quote(path) + self.allowance = allowance + + def applies_to(self, filename): + return self.path == "*" or filename.startswith(self.path) + + def __str__(self): + return ("Allow" if self.allowance else "Disallow") + ": " + self.path + + +class Entry: + """An entry has one or more user-agents and zero or more rulelines""" + def __init__(self): + self.useragents = [] + self.rulelines = [] + self.delay = None + self.req_rate = None + + def __str__(self): + ret = [] + for agent in self.useragents: + ret.append(f"User-agent: {agent}") + if self.delay is not None: + ret.append(f"Crawl-delay: {self.delay}") + if self.req_rate is not None: + rate = self.req_rate + ret.append(f"Request-rate: {rate.requests}/{rate.seconds}") + ret.extend(map(str, self.rulelines)) + return '\n'.join(ret) + + def applies_to(self, useragent): + """check if this entry applies to the specified agent""" + # split the name token and make it lower case + useragent = useragent.split("/")[0].lower() + for agent in self.useragents: + if agent == '*': + # we have the catch-all agent + return True + agent = agent.lower() + if agent in useragent: + return True + return False + + def allowance(self, filename): + """Preconditions: + - our agent applies to this entry + - filename is URL decoded""" + for line in self.rulelines: + if line.applies_to(filename): + return line.allowance + return True diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/uu.py b/physworld_p1_20261018/envs/p1/lib/python3.11/uu.py new file mode 100644 index 0000000000000000000000000000000000000000..26bb59ae073ec518f1880f534d39feae85dd0a03 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/uu.py @@ -0,0 +1,216 @@ +#! /usr/bin/env python3 + +# Copyright 1994 by Lance Ellinghouse +# Cathedral City, California Republic, United States of America. +# All Rights Reserved +# Permission to use, copy, modify, and distribute this software and its +# documentation for any purpose and without fee is hereby granted, +# provided that the above copyright notice appear in all copies and that +# both that copyright notice and this permission notice appear in +# supporting documentation, and that the name of Lance Ellinghouse +# not be used in advertising or publicity pertaining to distribution +# of the software without specific, written prior permission. +# LANCE ELLINGHOUSE DISCLAIMS ALL WARRANTIES WITH REGARD TO +# THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +# FITNESS, IN NO EVENT SHALL LANCE ELLINGHOUSE CENTRUM BE LIABLE +# FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +# +# Modified by Jack Jansen, CWI, July 1995: +# - Use binascii module to do the actual line-by-line conversion +# between ascii and binary. This results in a 1000-fold speedup. The C +# version is still 5 times faster, though. +# - Arguments more compliant with python standard + +"""Implementation of the UUencode and UUdecode functions. + +encode(in_file, out_file [,name, mode], *, backtick=False) +decode(in_file [, out_file, mode, quiet]) +""" + +import binascii +import os +import sys +import warnings + +warnings._deprecated(__name__, remove=(3, 13)) + +__all__ = ["Error", "encode", "decode"] + +class Error(Exception): + pass + +def encode(in_file, out_file, name=None, mode=None, *, backtick=False): + """Uuencode file""" + # + # If in_file is a pathname open it and change defaults + # + opened_files = [] + try: + if in_file == '-': + in_file = sys.stdin.buffer + elif isinstance(in_file, str): + if name is None: + name = os.path.basename(in_file) + if mode is None: + try: + mode = os.stat(in_file).st_mode + except AttributeError: + pass + in_file = open(in_file, 'rb') + opened_files.append(in_file) + # + # Open out_file if it is a pathname + # + if out_file == '-': + out_file = sys.stdout.buffer + elif isinstance(out_file, str): + out_file = open(out_file, 'wb') + opened_files.append(out_file) + # + # Set defaults for name and mode + # + if name is None: + name = '-' + if mode is None: + mode = 0o666 + + # + # Remove newline chars from name + # + name = name.replace('\n','\\n') + name = name.replace('\r','\\r') + + # + # Write the data + # + out_file.write(('begin %o %s\n' % ((mode & 0o777), name)).encode("ascii")) + data = in_file.read(45) + while len(data) > 0: + out_file.write(binascii.b2a_uu(data, backtick=backtick)) + data = in_file.read(45) + if backtick: + out_file.write(b'`\nend\n') + else: + out_file.write(b' \nend\n') + finally: + for f in opened_files: + f.close() + + +def decode(in_file, out_file=None, mode=None, quiet=False): + """Decode uuencoded file""" + # + # Open the input file, if needed. + # + opened_files = [] + if in_file == '-': + in_file = sys.stdin.buffer + elif isinstance(in_file, str): + in_file = open(in_file, 'rb') + opened_files.append(in_file) + + try: + # + # Read until a begin is encountered or we've exhausted the file + # + while True: + hdr = in_file.readline() + if not hdr: + raise Error('No valid begin line found in input file') + if not hdr.startswith(b'begin'): + continue + hdrfields = hdr.split(b' ', 2) + if len(hdrfields) == 3 and hdrfields[0] == b'begin': + try: + int(hdrfields[1], 8) + break + except ValueError: + pass + if out_file is None: + # If the filename isn't ASCII, what's up with that?!? + out_file = hdrfields[2].rstrip(b' \t\r\n\f').decode("ascii") + if os.path.exists(out_file): + raise Error(f'Cannot overwrite existing file: {out_file}') + if (out_file.startswith(os.sep) or + f'..{os.sep}' in out_file or ( + os.altsep and + (out_file.startswith(os.altsep) or + f'..{os.altsep}' in out_file)) + ): + raise Error(f'Refusing to write to {out_file} due to directory traversal') + if mode is None: + mode = int(hdrfields[1], 8) + # + # Open the output file + # + if out_file == '-': + out_file = sys.stdout.buffer + elif isinstance(out_file, str): + fp = open(out_file, 'wb') + os.chmod(out_file, mode) + out_file = fp + opened_files.append(out_file) + # + # Main decoding loop + # + s = in_file.readline() + while s and s.strip(b' \t\r\n\f') != b'end': + try: + data = binascii.a2b_uu(s) + except binascii.Error as v: + # Workaround for broken uuencoders by /Fredrik Lundh + nbytes = (((s[0]-32) & 63) * 4 + 5) // 3 + data = binascii.a2b_uu(s[:nbytes]) + if not quiet: + sys.stderr.write("Warning: %s\n" % v) + out_file.write(data) + s = in_file.readline() + if not s: + raise Error('Truncated input file') + finally: + for f in opened_files: + f.close() + +def test(): + """uuencode/uudecode main program""" + + import optparse + parser = optparse.OptionParser(usage='usage: %prog [-d] [-t] [input [output]]') + parser.add_option('-d', '--decode', dest='decode', help='Decode (instead of encode)?', default=False, action='store_true') + parser.add_option('-t', '--text', dest='text', help='data is text, encoded format unix-compatible text?', default=False, action='store_true') + + (options, args) = parser.parse_args() + if len(args) > 2: + parser.error('incorrect number of arguments') + sys.exit(1) + + # Use the binary streams underlying stdin/stdout + input = sys.stdin.buffer + output = sys.stdout.buffer + if len(args) > 0: + input = args[0] + if len(args) > 1: + output = args[1] + + if options.decode: + if options.text: + if isinstance(output, str): + output = open(output, 'wb') + else: + print(sys.argv[0], ': cannot do -t to stdout') + sys.exit(1) + decode(input, output) + else: + if options.text: + if isinstance(input, str): + input = open(input, 'rb') + else: + print(sys.argv[0], ': cannot do -t from stdin') + sys.exit(1) + encode(input, output) + +if __name__ == '__main__': + test() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/uuid.py b/physworld_p1_20261018/envs/p1/lib/python3.11/uuid.py new file mode 100644 index 0000000000000000000000000000000000000000..e863b631877f6d854d13ac82789e6cde4273532a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/uuid.py @@ -0,0 +1,736 @@ +r"""UUID objects (universally unique identifiers) according to RFC 4122. + +This module provides immutable UUID objects (class UUID) and the functions +uuid1(), uuid3(), uuid4(), uuid5() for generating version 1, 3, 4, and 5 +UUIDs as specified in RFC 4122. + +If all you want is a unique ID, you should probably call uuid1() or uuid4(). +Note that uuid1() may compromise privacy since it creates a UUID containing +the computer's network address. uuid4() creates a random UUID. + +Typical usage: + + >>> import uuid + + # make a UUID based on the host ID and current time + >>> uuid.uuid1() # doctest: +SKIP + UUID('a8098c1a-f86e-11da-bd1a-00112444be1e') + + # make a UUID using an MD5 hash of a namespace UUID and a name + >>> uuid.uuid3(uuid.NAMESPACE_DNS, 'python.org') + UUID('6fa459ea-ee8a-3ca4-894e-db77e160355e') + + # make a random UUID + >>> uuid.uuid4() # doctest: +SKIP + UUID('16fd2706-8baf-433b-82eb-8c7fada847da') + + # make a UUID using a SHA-1 hash of a namespace UUID and a name + >>> uuid.uuid5(uuid.NAMESPACE_DNS, 'python.org') + UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d') + + # make a UUID from a string of hex digits (braces and hyphens ignored) + >>> x = uuid.UUID('{00010203-0405-0607-0809-0a0b0c0d0e0f}') + + # convert a UUID to a string of hex digits in standard form + >>> str(x) + '00010203-0405-0607-0809-0a0b0c0d0e0f' + + # get the raw 16 bytes of the UUID + >>> x.bytes + b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f' + + # make a UUID from a 16-byte string + >>> uuid.UUID(bytes=x.bytes) + UUID('00010203-0405-0607-0809-0a0b0c0d0e0f') +""" + +import os +import sys + +from enum import Enum, _simple_enum + + +__author__ = 'Ka-Ping Yee ' + +# The recognized platforms - known behaviors +if sys.platform in ('win32', 'darwin'): + _AIX = _LINUX = False +else: + import platform + _platform_system = platform.system() + _AIX = _platform_system == 'AIX' + _LINUX = _platform_system == 'Linux' + +_MAC_DELIM = b':' +_MAC_OMITS_LEADING_ZEROES = False +if _AIX: + _MAC_DELIM = b'.' + _MAC_OMITS_LEADING_ZEROES = True + +RESERVED_NCS, RFC_4122, RESERVED_MICROSOFT, RESERVED_FUTURE = [ + 'reserved for NCS compatibility', 'specified in RFC 4122', + 'reserved for Microsoft compatibility', 'reserved for future definition'] + +int_ = int # The built-in int type +bytes_ = bytes # The built-in bytes type + + +@_simple_enum(Enum) +class SafeUUID: + safe = 0 + unsafe = -1 + unknown = None + + +class UUID: + """Instances of the UUID class represent UUIDs as specified in RFC 4122. + UUID objects are immutable, hashable, and usable as dictionary keys. + Converting a UUID to a string with str() yields something in the form + '12345678-1234-1234-1234-123456789abc'. The UUID constructor accepts + five possible forms: a similar string of hexadecimal digits, or a tuple + of six integer fields (with 32-bit, 16-bit, 16-bit, 8-bit, 8-bit, and + 48-bit values respectively) as an argument named 'fields', or a string + of 16 bytes (with all the integer fields in big-endian order) as an + argument named 'bytes', or a string of 16 bytes (with the first three + fields in little-endian order) as an argument named 'bytes_le', or a + single 128-bit integer as an argument named 'int'. + + UUIDs have these read-only attributes: + + bytes the UUID as a 16-byte string (containing the six + integer fields in big-endian byte order) + + bytes_le the UUID as a 16-byte string (with time_low, time_mid, + and time_hi_version in little-endian byte order) + + fields a tuple of the six integer fields of the UUID, + which are also available as six individual attributes + and two derived attributes: + + time_low the first 32 bits of the UUID + time_mid the next 16 bits of the UUID + time_hi_version the next 16 bits of the UUID + clock_seq_hi_variant the next 8 bits of the UUID + clock_seq_low the next 8 bits of the UUID + node the last 48 bits of the UUID + + time the 60-bit timestamp + clock_seq the 14-bit sequence number + + hex the UUID as a 32-character hexadecimal string + + int the UUID as a 128-bit integer + + urn the UUID as a URN as specified in RFC 4122 + + variant the UUID variant (one of the constants RESERVED_NCS, + RFC_4122, RESERVED_MICROSOFT, or RESERVED_FUTURE) + + version the UUID version number (1 through 5, meaningful only + when the variant is RFC_4122) + + is_safe An enum indicating whether the UUID has been generated in + a way that is safe for multiprocessing applications, via + uuid_generate_time_safe(3). + """ + + __slots__ = ('int', 'is_safe', '__weakref__') + + def __init__(self, hex=None, bytes=None, bytes_le=None, fields=None, + int=None, version=None, + *, is_safe=SafeUUID.unknown): + r"""Create a UUID from either a string of 32 hexadecimal digits, + a string of 16 bytes as the 'bytes' argument, a string of 16 bytes + in little-endian order as the 'bytes_le' argument, a tuple of six + integers (32-bit time_low, 16-bit time_mid, 16-bit time_hi_version, + 8-bit clock_seq_hi_variant, 8-bit clock_seq_low, 48-bit node) as + the 'fields' argument, or a single 128-bit integer as the 'int' + argument. When a string of hex digits is given, curly braces, + hyphens, and a URN prefix are all optional. For example, these + expressions all yield the same UUID: + + UUID('{12345678-1234-5678-1234-567812345678}') + UUID('12345678123456781234567812345678') + UUID('urn:uuid:12345678-1234-5678-1234-567812345678') + UUID(bytes='\x12\x34\x56\x78'*4) + UUID(bytes_le='\x78\x56\x34\x12\x34\x12\x78\x56' + + '\x12\x34\x56\x78\x12\x34\x56\x78') + UUID(fields=(0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x567812345678)) + UUID(int=0x12345678123456781234567812345678) + + Exactly one of 'hex', 'bytes', 'bytes_le', 'fields', or 'int' must + be given. The 'version' argument is optional; if given, the resulting + UUID will have its variant and version set according to RFC 4122, + overriding the given 'hex', 'bytes', 'bytes_le', 'fields', or 'int'. + + is_safe is an enum exposed as an attribute on the instance. It + indicates whether the UUID has been generated in a way that is safe + for multiprocessing applications, via uuid_generate_time_safe(3). + """ + + if [hex, bytes, bytes_le, fields, int].count(None) != 4: + raise TypeError('one of the hex, bytes, bytes_le, fields, ' + 'or int arguments must be given') + if hex is not None: + hex = hex.replace('urn:', '').replace('uuid:', '') + hex = hex.strip('{}').replace('-', '') + if len(hex) != 32: + raise ValueError('badly formed hexadecimal UUID string') + int = int_(hex, 16) + if bytes_le is not None: + if len(bytes_le) != 16: + raise ValueError('bytes_le is not a 16-char string') + bytes = (bytes_le[4-1::-1] + bytes_le[6-1:4-1:-1] + + bytes_le[8-1:6-1:-1] + bytes_le[8:]) + if bytes is not None: + if len(bytes) != 16: + raise ValueError('bytes is not a 16-char string') + assert isinstance(bytes, bytes_), repr(bytes) + int = int_.from_bytes(bytes) # big endian + if fields is not None: + if len(fields) != 6: + raise ValueError('fields is not a 6-tuple') + (time_low, time_mid, time_hi_version, + clock_seq_hi_variant, clock_seq_low, node) = fields + if not 0 <= time_low < 1<<32: + raise ValueError('field 1 out of range (need a 32-bit value)') + if not 0 <= time_mid < 1<<16: + raise ValueError('field 2 out of range (need a 16-bit value)') + if not 0 <= time_hi_version < 1<<16: + raise ValueError('field 3 out of range (need a 16-bit value)') + if not 0 <= clock_seq_hi_variant < 1<<8: + raise ValueError('field 4 out of range (need an 8-bit value)') + if not 0 <= clock_seq_low < 1<<8: + raise ValueError('field 5 out of range (need an 8-bit value)') + if not 0 <= node < 1<<48: + raise ValueError('field 6 out of range (need a 48-bit value)') + clock_seq = (clock_seq_hi_variant << 8) | clock_seq_low + int = ((time_low << 96) | (time_mid << 80) | + (time_hi_version << 64) | (clock_seq << 48) | node) + if int is not None: + if not 0 <= int < 1<<128: + raise ValueError('int is out of range (need a 128-bit value)') + if version is not None: + if not 1 <= version <= 5: + raise ValueError('illegal version number') + # Set the variant to RFC 4122. + int &= ~(0xc000 << 48) + int |= 0x8000 << 48 + # Set the version number. + int &= ~(0xf000 << 64) + int |= version << 76 + object.__setattr__(self, 'int', int) + object.__setattr__(self, 'is_safe', is_safe) + + def __getstate__(self): + d = {'int': self.int} + if self.is_safe != SafeUUID.unknown: + # is_safe is a SafeUUID instance. Return just its value, so that + # it can be un-pickled in older Python versions without SafeUUID. + d['is_safe'] = self.is_safe.value + return d + + def __setstate__(self, state): + object.__setattr__(self, 'int', state['int']) + # is_safe was added in 3.7; it is also omitted when it is "unknown" + object.__setattr__(self, 'is_safe', + SafeUUID(state['is_safe']) + if 'is_safe' in state else SafeUUID.unknown) + + def __eq__(self, other): + if isinstance(other, UUID): + return self.int == other.int + return NotImplemented + + # Q. What's the value of being able to sort UUIDs? + # A. Use them as keys in a B-Tree or similar mapping. + + def __lt__(self, other): + if isinstance(other, UUID): + return self.int < other.int + return NotImplemented + + def __gt__(self, other): + if isinstance(other, UUID): + return self.int > other.int + return NotImplemented + + def __le__(self, other): + if isinstance(other, UUID): + return self.int <= other.int + return NotImplemented + + def __ge__(self, other): + if isinstance(other, UUID): + return self.int >= other.int + return NotImplemented + + def __hash__(self): + return hash(self.int) + + def __int__(self): + return self.int + + def __repr__(self): + return '%s(%r)' % (self.__class__.__name__, str(self)) + + def __setattr__(self, name, value): + raise TypeError('UUID objects are immutable') + + def __str__(self): + hex = '%032x' % self.int + return '%s-%s-%s-%s-%s' % ( + hex[:8], hex[8:12], hex[12:16], hex[16:20], hex[20:]) + + @property + def bytes(self): + return self.int.to_bytes(16) # big endian + + @property + def bytes_le(self): + bytes = self.bytes + return (bytes[4-1::-1] + bytes[6-1:4-1:-1] + bytes[8-1:6-1:-1] + + bytes[8:]) + + @property + def fields(self): + return (self.time_low, self.time_mid, self.time_hi_version, + self.clock_seq_hi_variant, self.clock_seq_low, self.node) + + @property + def time_low(self): + return self.int >> 96 + + @property + def time_mid(self): + return (self.int >> 80) & 0xffff + + @property + def time_hi_version(self): + return (self.int >> 64) & 0xffff + + @property + def clock_seq_hi_variant(self): + return (self.int >> 56) & 0xff + + @property + def clock_seq_low(self): + return (self.int >> 48) & 0xff + + @property + def time(self): + return (((self.time_hi_version & 0x0fff) << 48) | + (self.time_mid << 32) | self.time_low) + + @property + def clock_seq(self): + return (((self.clock_seq_hi_variant & 0x3f) << 8) | + self.clock_seq_low) + + @property + def node(self): + return self.int & 0xffffffffffff + + @property + def hex(self): + return '%032x' % self.int + + @property + def urn(self): + return 'urn:uuid:' + str(self) + + @property + def variant(self): + if not self.int & (0x8000 << 48): + return RESERVED_NCS + elif not self.int & (0x4000 << 48): + return RFC_4122 + elif not self.int & (0x2000 << 48): + return RESERVED_MICROSOFT + else: + return RESERVED_FUTURE + + @property + def version(self): + # The version bits are only meaningful for RFC 4122 UUIDs. + if self.variant == RFC_4122: + return int((self.int >> 76) & 0xf) + + +def _get_command_stdout(command, *args): + import io, os, shutil, subprocess + + try: + path_dirs = os.environ.get('PATH', os.defpath).split(os.pathsep) + path_dirs.extend(['/sbin', '/usr/sbin']) + executable = shutil.which(command, path=os.pathsep.join(path_dirs)) + if executable is None: + return None + # LC_ALL=C to ensure English output, stderr=DEVNULL to prevent output + # on stderr (Note: we don't have an example where the words we search + # for are actually localized, but in theory some system could do so.) + env = dict(os.environ) + env['LC_ALL'] = 'C' + # Empty strings will be quoted by popen so we should just ommit it + if args != ('',): + command = (executable, *args) + else: + command = (executable,) + proc = subprocess.Popen(command, + stdout=subprocess.PIPE, + stderr=subprocess.DEVNULL, + env=env) + if not proc: + return None + stdout, stderr = proc.communicate() + return io.BytesIO(stdout) + except (OSError, subprocess.SubprocessError): + return None + + +# For MAC (a.k.a. IEEE 802, or EUI-48) addresses, the second least significant +# bit of the first octet signifies whether the MAC address is universally (0) +# or locally (1) administered. Network cards from hardware manufacturers will +# always be universally administered to guarantee global uniqueness of the MAC +# address, but any particular machine may have other interfaces which are +# locally administered. An example of the latter is the bridge interface to +# the Touch Bar on MacBook Pros. +# +# This bit works out to be the 42nd bit counting from 1 being the least +# significant, or 1<<41. We'll prefer universally administered MAC addresses +# over locally administered ones since the former are globally unique, but +# we'll return the first of the latter found if that's all the machine has. +# +# See https://en.wikipedia.org/wiki/MAC_address#Universal_vs._local + +def _is_universal(mac): + return not (mac & (1 << 41)) + + +def _find_mac_near_keyword(command, args, keywords, get_word_index): + """Searches a command's output for a MAC address near a keyword. + + Each line of words in the output is case-insensitively searched for + any of the given keywords. Upon a match, get_word_index is invoked + to pick a word from the line, given the index of the match. For + example, lambda i: 0 would get the first word on the line, while + lambda i: i - 1 would get the word preceding the keyword. + """ + stdout = _get_command_stdout(command, args) + if stdout is None: + return None + + first_local_mac = None + for line in stdout: + words = line.lower().rstrip().split() + for i in range(len(words)): + if words[i] in keywords: + try: + word = words[get_word_index(i)] + mac = int(word.replace(_MAC_DELIM, b''), 16) + except (ValueError, IndexError): + # Virtual interfaces, such as those provided by + # VPNs, do not have a colon-delimited MAC address + # as expected, but a 16-byte HWAddr separated by + # dashes. These should be ignored in favor of a + # real MAC address + pass + else: + if _is_universal(mac): + return mac + first_local_mac = first_local_mac or mac + return first_local_mac or None + + +def _parse_mac(word): + # Accept 'HH:HH:HH:HH:HH:HH' MAC address (ex: '52:54:00:9d:0e:67'), + # but reject IPv6 address (ex: 'fe80::5054:ff:fe9' or '123:2:3:4:5:6:7:8'). + # + # Virtual interfaces, such as those provided by VPNs, do not have a + # colon-delimited MAC address as expected, but a 16-byte HWAddr separated + # by dashes. These should be ignored in favor of a real MAC address + parts = word.split(_MAC_DELIM) + if len(parts) != 6: + return + if _MAC_OMITS_LEADING_ZEROES: + # (Only) on AIX the macaddr value given is not prefixed by 0, e.g. + # en0 1500 link#2 fa.bc.de.f7.62.4 110854824 0 160133733 0 0 + # not + # en0 1500 link#2 fa.bc.de.f7.62.04 110854824 0 160133733 0 0 + if not all(1 <= len(part) <= 2 for part in parts): + return + hexstr = b''.join(part.rjust(2, b'0') for part in parts) + else: + if not all(len(part) == 2 for part in parts): + return + hexstr = b''.join(parts) + try: + return int(hexstr, 16) + except ValueError: + return + + +def _find_mac_under_heading(command, args, heading): + """Looks for a MAC address under a heading in a command's output. + + The first line of words in the output is searched for the given + heading. Words at the same word index as the heading in subsequent + lines are then examined to see if they look like MAC addresses. + """ + stdout = _get_command_stdout(command, args) + if stdout is None: + return None + + keywords = stdout.readline().rstrip().split() + try: + column_index = keywords.index(heading) + except ValueError: + return None + + first_local_mac = None + for line in stdout: + words = line.rstrip().split() + try: + word = words[column_index] + except IndexError: + continue + + mac = _parse_mac(word) + if mac is None: + continue + if _is_universal(mac): + return mac + if first_local_mac is None: + first_local_mac = mac + + return first_local_mac + + +# The following functions call external programs to 'get' a macaddr value to +# be used as basis for an uuid +def _ifconfig_getnode(): + """Get the hardware address on Unix by running ifconfig.""" + # This works on Linux ('' or '-a'), Tru64 ('-av'), but not all Unixes. + keywords = (b'hwaddr', b'ether', b'address:', b'lladdr') + for args in ('', '-a', '-av'): + mac = _find_mac_near_keyword('ifconfig', args, keywords, lambda i: i+1) + if mac: + return mac + return None + +def _ip_getnode(): + """Get the hardware address on Unix by running ip.""" + # This works on Linux with iproute2. + mac = _find_mac_near_keyword('ip', 'link', [b'link/ether'], lambda i: i+1) + if mac: + return mac + return None + +def _arp_getnode(): + """Get the hardware address on Unix by running arp.""" + import os, socket + if not hasattr(socket, "gethostbyname"): + return None + try: + ip_addr = socket.gethostbyname(socket.gethostname()) + except OSError: + return None + + # Try getting the MAC addr from arp based on our IP address (Solaris). + mac = _find_mac_near_keyword('arp', '-an', [os.fsencode(ip_addr)], lambda i: -1) + if mac: + return mac + + # This works on OpenBSD + mac = _find_mac_near_keyword('arp', '-an', [os.fsencode(ip_addr)], lambda i: i+1) + if mac: + return mac + + # This works on Linux, FreeBSD and NetBSD + mac = _find_mac_near_keyword('arp', '-an', [os.fsencode('(%s)' % ip_addr)], + lambda i: i+2) + # Return None instead of 0. + if mac: + return mac + return None + +def _lanscan_getnode(): + """Get the hardware address on Unix by running lanscan.""" + # This might work on HP-UX. + return _find_mac_near_keyword('lanscan', '-ai', [b'lan0'], lambda i: 0) + +def _netstat_getnode(): + """Get the hardware address on Unix by running netstat.""" + # This works on AIX and might work on Tru64 UNIX. + return _find_mac_under_heading('netstat', '-ian', b'Address') + +def _ipconfig_getnode(): + """[DEPRECATED] Get the hardware address on Windows.""" + # bpo-40501: UuidCreateSequential() is now the only supported approach + return _windll_getnode() + +def _netbios_getnode(): + """[DEPRECATED] Get the hardware address on Windows.""" + # bpo-40501: UuidCreateSequential() is now the only supported approach + return _windll_getnode() + + +# Import optional C extension at toplevel, to help disabling it when testing +try: + import _uuid + _generate_time_safe = getattr(_uuid, "generate_time_safe", None) + _UuidCreate = getattr(_uuid, "UuidCreate", None) + _has_uuid_generate_time_safe = _uuid.has_uuid_generate_time_safe +except ImportError: + _uuid = None + _generate_time_safe = None + _UuidCreate = None + _has_uuid_generate_time_safe = None + + +def _load_system_functions(): + """[DEPRECATED] Platform-specific functions loaded at import time""" + + +def _unix_getnode(): + """Get the hardware address on Unix using the _uuid extension module.""" + if _generate_time_safe: + uuid_time, _ = _generate_time_safe() + return UUID(bytes=uuid_time).node + +def _windll_getnode(): + """Get the hardware address on Windows using the _uuid extension module.""" + if _UuidCreate: + uuid_bytes = _UuidCreate() + return UUID(bytes_le=uuid_bytes).node + +def _random_getnode(): + """Get a random node ID.""" + # RFC 4122, $4.1.6 says "For systems with no IEEE address, a randomly or + # pseudo-randomly generated value may be used; see Section 4.5. The + # multicast bit must be set in such addresses, in order that they will + # never conflict with addresses obtained from network cards." + # + # The "multicast bit" of a MAC address is defined to be "the least + # significant bit of the first octet". This works out to be the 41st bit + # counting from 1 being the least significant bit, or 1<<40. + # + # See https://en.wikipedia.org/wiki/MAC_address#Unicast_vs._multicast + import random + return random.getrandbits(48) | (1 << 40) + + +# _OS_GETTERS, when known, are targeted for a specific OS or platform. +# The order is by 'common practice' on the specified platform. +# Note: 'posix' and 'windows' _OS_GETTERS are prefixed by a dll/dlload() method +# which, when successful, means none of these "external" methods are called. +# _GETTERS is (also) used by test_uuid.py to SkipUnless(), e.g., +# @unittest.skipUnless(_uuid._ifconfig_getnode in _uuid._GETTERS, ...) +if _LINUX: + _OS_GETTERS = [_ip_getnode, _ifconfig_getnode] +elif sys.platform == 'darwin': + _OS_GETTERS = [_ifconfig_getnode, _arp_getnode, _netstat_getnode] +elif sys.platform == 'win32': + # bpo-40201: _windll_getnode will always succeed, so these are not needed + _OS_GETTERS = [] +elif _AIX: + _OS_GETTERS = [_netstat_getnode] +else: + _OS_GETTERS = [_ifconfig_getnode, _ip_getnode, _arp_getnode, + _netstat_getnode, _lanscan_getnode] +if os.name == 'posix': + _GETTERS = [_unix_getnode] + _OS_GETTERS +elif os.name == 'nt': + _GETTERS = [_windll_getnode] + _OS_GETTERS +else: + _GETTERS = _OS_GETTERS + +_node = None + +def getnode(): + """Get the hardware address as a 48-bit positive integer. + + The first time this runs, it may launch a separate program, which could + be quite slow. If all attempts to obtain the hardware address fail, we + choose a random 48-bit number with its eighth bit set to 1 as recommended + in RFC 4122. + """ + global _node + if _node is not None: + return _node + + for getter in _GETTERS + [_random_getnode]: + try: + _node = getter() + except: + continue + if (_node is not None) and (0 <= _node < (1 << 48)): + return _node + assert False, '_random_getnode() returned invalid value: {}'.format(_node) + + +_last_timestamp = None + +def uuid1(node=None, clock_seq=None): + """Generate a UUID from a host ID, sequence number, and the current time. + If 'node' is not given, getnode() is used to obtain the hardware + address. If 'clock_seq' is given, it is used as the sequence number; + otherwise a random 14-bit sequence number is chosen.""" + + # When the system provides a version-1 UUID generator, use it (but don't + # use UuidCreate here because its UUIDs don't conform to RFC 4122). + if _generate_time_safe is not None and node is clock_seq is None: + uuid_time, safely_generated = _generate_time_safe() + try: + is_safe = SafeUUID(safely_generated) + except ValueError: + is_safe = SafeUUID.unknown + return UUID(bytes=uuid_time, is_safe=is_safe) + + global _last_timestamp + import time + nanoseconds = time.time_ns() + # 0x01b21dd213814000 is the number of 100-ns intervals between the + # UUID epoch 1582-10-15 00:00:00 and the Unix epoch 1970-01-01 00:00:00. + timestamp = nanoseconds // 100 + 0x01b21dd213814000 + if _last_timestamp is not None and timestamp <= _last_timestamp: + timestamp = _last_timestamp + 1 + _last_timestamp = timestamp + if clock_seq is None: + import random + clock_seq = random.getrandbits(14) # instead of stable storage + time_low = timestamp & 0xffffffff + time_mid = (timestamp >> 32) & 0xffff + time_hi_version = (timestamp >> 48) & 0x0fff + clock_seq_low = clock_seq & 0xff + clock_seq_hi_variant = (clock_seq >> 8) & 0x3f + if node is None: + node = getnode() + return UUID(fields=(time_low, time_mid, time_hi_version, + clock_seq_hi_variant, clock_seq_low, node), version=1) + +def uuid3(namespace, name): + """Generate a UUID from the MD5 hash of a namespace UUID and a name.""" + from hashlib import md5 + digest = md5( + namespace.bytes + bytes(name, "utf-8"), + usedforsecurity=False + ).digest() + return UUID(bytes=digest[:16], version=3) + +def uuid4(): + """Generate a random UUID.""" + return UUID(bytes=os.urandom(16), version=4) + +def uuid5(namespace, name): + """Generate a UUID from the SHA-1 hash of a namespace UUID and a name.""" + from hashlib import sha1 + hash = sha1(namespace.bytes + bytes(name, "utf-8")).digest() + return UUID(bytes=hash[:16], version=5) + +# The following standard UUIDs are for use with uuid3() or uuid5(). + +NAMESPACE_DNS = UUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8') +NAMESPACE_URL = UUID('6ba7b811-9dad-11d1-80b4-00c04fd430c8') +NAMESPACE_OID = UUID('6ba7b812-9dad-11d1-80b4-00c04fd430c8') +NAMESPACE_X500 = UUID('6ba7b814-9dad-11d1-80b4-00c04fd430c8') diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/venv/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/venv/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4403f2b1c4ef60c4175ad69d5d9d1eb4b358451b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/venv/__init__.py @@ -0,0 +1,587 @@ +""" +Virtual environment (venv) package for Python. Based on PEP 405. + +Copyright (C) 2011-2014 Vinay Sajip. +Licensed to the PSF under a contributor agreement. +""" +import logging +import os +import shutil +import subprocess +import sys +import sysconfig +import types +import shlex + + +CORE_VENV_DEPS = ('pip', 'setuptools') +logger = logging.getLogger(__name__) + + +class EnvBuilder: + """ + This class exists to allow virtual environment creation to be + customized. The constructor parameters determine the builder's + behaviour when called upon to create a virtual environment. + + By default, the builder makes the system (global) site-packages dir + *un*available to the created environment. + + If invoked using the Python -m option, the default is to use copying + on Windows platforms but symlinks elsewhere. If instantiated some + other way, the default is to *not* use symlinks. + + :param system_site_packages: If True, the system (global) site-packages + dir is available to created environments. + :param clear: If True, delete the contents of the environment directory if + it already exists, before environment creation. + :param symlinks: If True, attempt to symlink rather than copy files into + virtual environment. + :param upgrade: If True, upgrade an existing virtual environment. + :param with_pip: If True, ensure pip is installed in the virtual + environment + :param prompt: Alternative terminal prefix for the environment. + :param upgrade_deps: Update the base venv modules to the latest on PyPI + """ + + def __init__(self, system_site_packages=False, clear=False, + symlinks=False, upgrade=False, with_pip=False, prompt=None, + upgrade_deps=False): + self.system_site_packages = system_site_packages + self.clear = clear + self.symlinks = symlinks + self.upgrade = upgrade + self.with_pip = with_pip + self.orig_prompt = prompt + if prompt == '.': # see bpo-38901 + prompt = os.path.basename(os.getcwd()) + self.prompt = prompt + self.upgrade_deps = upgrade_deps + + def create(self, env_dir): + """ + Create a virtual environment in a directory. + + :param env_dir: The target directory to create an environment in. + + """ + env_dir = os.path.abspath(env_dir) + context = self.ensure_directories(env_dir) + # See issue 24875. We need system_site_packages to be False + # until after pip is installed. + true_system_site_packages = self.system_site_packages + self.system_site_packages = False + self.create_configuration(context) + self.setup_python(context) + if self.with_pip: + self._setup_pip(context) + if not self.upgrade: + self.setup_scripts(context) + self.post_setup(context) + if true_system_site_packages: + # We had set it to False before, now + # restore it and rewrite the configuration + self.system_site_packages = True + self.create_configuration(context) + if self.upgrade_deps: + self.upgrade_dependencies(context) + + def clear_directory(self, path): + for fn in os.listdir(path): + fn = os.path.join(path, fn) + if os.path.islink(fn) or os.path.isfile(fn): + os.remove(fn) + elif os.path.isdir(fn): + shutil.rmtree(fn) + + def _venv_path(self, env_dir, name): + vars = { + 'base': env_dir, + 'platbase': env_dir, + 'installed_base': env_dir, + 'installed_platbase': env_dir, + } + return sysconfig.get_path(name, scheme='venv', vars=vars) + + def ensure_directories(self, env_dir): + """ + Create the directories for the environment. + + Returns a context object which holds paths in the environment, + for use by subsequent logic. + """ + + def create_if_needed(d): + if not os.path.exists(d): + os.makedirs(d) + elif os.path.islink(d) or os.path.isfile(d): + raise ValueError('Unable to create directory %r' % d) + + if os.pathsep in os.fspath(env_dir): + raise ValueError(f'Refusing to create a venv in {env_dir} because ' + f'it contains the PATH separator {os.pathsep}.') + if os.path.exists(env_dir) and self.clear: + self.clear_directory(env_dir) + context = types.SimpleNamespace() + context.env_dir = env_dir + context.env_name = os.path.split(env_dir)[1] + prompt = self.prompt if self.prompt is not None else context.env_name + context.prompt = '(%s) ' % prompt + create_if_needed(env_dir) + executable = sys._base_executable + if not executable: # see gh-96861 + raise ValueError('Unable to determine path to the running ' + 'Python interpreter. Provide an explicit path or ' + 'check that your PATH environment variable is ' + 'correctly set.') + dirname, exename = os.path.split(os.path.abspath(executable)) + context.executable = executable + context.python_dir = dirname + context.python_exe = exename + binpath = self._venv_path(env_dir, 'scripts') + incpath = self._venv_path(env_dir, 'include') + libpath = self._venv_path(env_dir, 'purelib') + + context.inc_path = incpath + create_if_needed(incpath) + create_if_needed(libpath) + # Issue 21197: create lib64 as a symlink to lib on 64-bit non-OS X POSIX + if ((sys.maxsize > 2**32) and (os.name == 'posix') and + (sys.platform != 'darwin')): + link_path = os.path.join(env_dir, 'lib64') + if not os.path.exists(link_path): # Issue #21643 + os.symlink('lib', link_path) + context.bin_path = binpath + context.bin_name = os.path.relpath(binpath, env_dir) + context.env_exe = os.path.join(binpath, exename) + create_if_needed(binpath) + # Assign and update the command to use when launching the newly created + # environment, in case it isn't simply the executable script (e.g. bpo-45337) + context.env_exec_cmd = context.env_exe + if sys.platform == 'win32': + # bpo-45337: Fix up env_exec_cmd to account for file system redirections. + # Some redirects only apply to CreateFile and not CreateProcess + real_env_exe = os.path.realpath(context.env_exe) + if os.path.normcase(real_env_exe) != os.path.normcase(context.env_exe): + logger.warning('Actual environment location may have moved due to ' + 'redirects, links or junctions.\n' + ' Requested location: "%s"\n' + ' Actual location: "%s"', + context.env_exe, real_env_exe) + context.env_exec_cmd = real_env_exe + return context + + def create_configuration(self, context): + """ + Create a configuration file indicating where the environment's Python + was copied from, and whether the system site-packages should be made + available in the environment. + + :param context: The information for the environment creation request + being processed. + """ + context.cfg_path = path = os.path.join(context.env_dir, 'pyvenv.cfg') + with open(path, 'w', encoding='utf-8') as f: + f.write('home = %s\n' % context.python_dir) + if self.system_site_packages: + incl = 'true' + else: + incl = 'false' + f.write('include-system-site-packages = %s\n' % incl) + f.write('version = %d.%d.%d\n' % sys.version_info[:3]) + if self.prompt is not None: + f.write(f'prompt = {self.prompt!r}\n') + f.write('executable = %s\n' % os.path.realpath(sys.executable)) + args = [] + nt = os.name == 'nt' + if nt and self.symlinks: + args.append('--symlinks') + if not nt and not self.symlinks: + args.append('--copies') + if not self.with_pip: + args.append('--without-pip') + if self.system_site_packages: + args.append('--system-site-packages') + if self.clear: + args.append('--clear') + if self.upgrade: + args.append('--upgrade') + if self.upgrade_deps: + args.append('--upgrade-deps') + if self.orig_prompt is not None: + args.append(f'--prompt="{self.orig_prompt}"') + + args.append(context.env_dir) + args = ' '.join(args) + f.write(f'command = {sys.executable} -m venv {args}\n') + + if os.name != 'nt': + def symlink_or_copy(self, src, dst, relative_symlinks_ok=False): + """ + Try symlinking a file, and if that fails, fall back to copying. + """ + force_copy = not self.symlinks + if not force_copy: + try: + if not os.path.islink(dst): # can't link to itself! + if relative_symlinks_ok: + assert os.path.dirname(src) == os.path.dirname(dst) + os.symlink(os.path.basename(src), dst) + else: + os.symlink(src, dst) + except Exception: # may need to use a more specific exception + logger.warning('Unable to symlink %r to %r', src, dst) + force_copy = True + if force_copy: + shutil.copyfile(src, dst) + else: + def symlink_or_copy(self, src, dst, relative_symlinks_ok=False): + """ + Try symlinking a file, and if that fails, fall back to copying. + """ + bad_src = os.path.lexists(src) and not os.path.exists(src) + if self.symlinks and not bad_src and not os.path.islink(dst): + try: + if relative_symlinks_ok: + assert os.path.dirname(src) == os.path.dirname(dst) + os.symlink(os.path.basename(src), dst) + else: + os.symlink(src, dst) + return + except Exception: # may need to use a more specific exception + logger.warning('Unable to symlink %r to %r', src, dst) + + # On Windows, we rewrite symlinks to our base python.exe into + # copies of venvlauncher.exe + basename, ext = os.path.splitext(os.path.basename(src)) + srcfn = os.path.join(os.path.dirname(__file__), + "scripts", + "nt", + basename + ext) + # Builds or venv's from builds need to remap source file + # locations, as we do not put them into Lib/venv/scripts + if sysconfig.is_python_build() or not os.path.isfile(srcfn): + if basename.endswith('_d'): + ext = '_d' + ext + basename = basename[:-2] + if basename == 'python': + basename = 'venvlauncher' + elif basename == 'pythonw': + basename = 'venvwlauncher' + src = os.path.join(os.path.dirname(src), basename + ext) + else: + src = srcfn + if not os.path.exists(src): + if not bad_src: + logger.warning('Unable to copy %r', src) + return + + shutil.copyfile(src, dst) + + def setup_python(self, context): + """ + Set up a Python executable in the environment. + + :param context: The information for the environment creation request + being processed. + """ + binpath = context.bin_path + path = context.env_exe + copier = self.symlink_or_copy + dirname = context.python_dir + if os.name != 'nt': + copier(context.executable, path) + if not os.path.islink(path): + os.chmod(path, 0o755) + for suffix in ('python', 'python3', f'python3.{sys.version_info[1]}'): + path = os.path.join(binpath, suffix) + if not os.path.exists(path): + # Issue 18807: make copies if + # symlinks are not wanted + copier(context.env_exe, path, relative_symlinks_ok=True) + if not os.path.islink(path): + os.chmod(path, 0o755) + else: + if self.symlinks: + # For symlinking, we need a complete copy of the root directory + # If symlinks fail, you'll get unnecessary copies of files, but + # we assume that if you've opted into symlinks on Windows then + # you know what you're doing. + suffixes = [ + f for f in os.listdir(dirname) if + os.path.normcase(os.path.splitext(f)[1]) in ('.exe', '.dll') + ] + if sysconfig.is_python_build(): + suffixes = [ + f for f in suffixes if + os.path.normcase(f).startswith(('python', 'vcruntime')) + ] + else: + suffixes = {'python.exe', 'python_d.exe', 'pythonw.exe', 'pythonw_d.exe'} + base_exe = os.path.basename(context.env_exe) + suffixes.add(base_exe) + + for suffix in suffixes: + src = os.path.join(dirname, suffix) + if os.path.lexists(src): + copier(src, os.path.join(binpath, suffix)) + + if sysconfig.is_python_build(): + # copy init.tcl + for root, dirs, files in os.walk(context.python_dir): + if 'init.tcl' in files: + tcldir = os.path.basename(root) + tcldir = os.path.join(context.env_dir, 'Lib', tcldir) + if not os.path.exists(tcldir): + os.makedirs(tcldir) + src = os.path.join(root, 'init.tcl') + dst = os.path.join(tcldir, 'init.tcl') + shutil.copyfile(src, dst) + break + + def _call_new_python(self, context, *py_args, **kwargs): + """Executes the newly created Python using safe-ish options""" + # gh-98251: We do not want to just use '-I' because that masks + # legitimate user preferences (such as not writing bytecode). All we + # really need is to ensure that the path variables do not overrule + # normal venv handling. + args = [context.env_exec_cmd, *py_args] + kwargs['env'] = env = os.environ.copy() + env['VIRTUAL_ENV'] = context.env_dir + env.pop('PYTHONHOME', None) + env.pop('PYTHONPATH', None) + kwargs['cwd'] = context.env_dir + kwargs['executable'] = context.env_exec_cmd + subprocess.check_output(args, **kwargs) + + def _setup_pip(self, context): + """Installs or upgrades pip in a virtual environment""" + self._call_new_python(context, '-m', 'ensurepip', '--upgrade', + '--default-pip', stderr=subprocess.STDOUT) + + def setup_scripts(self, context): + """ + Set up scripts into the created environment from a directory. + + This method installs the default scripts into the environment + being created. You can prevent the default installation by overriding + this method if you really need to, or if you need to specify + a different location for the scripts to install. By default, the + 'scripts' directory in the venv package is used as the source of + scripts to install. + """ + path = os.path.abspath(os.path.dirname(__file__)) + path = os.path.join(path, 'scripts') + self.install_scripts(context, path) + + def post_setup(self, context): + """ + Hook for post-setup modification of the venv. Subclasses may install + additional packages or scripts here, add activation shell scripts, etc. + + :param context: The information for the environment creation request + being processed. + """ + pass + + def replace_variables(self, text, context): + """ + Replace variable placeholders in script text with context-specific + variables. + + Return the text passed in , but with variables replaced. + + :param text: The text in which to replace placeholder variables. + :param context: The information for the environment creation request + being processed. + """ + replacements = { + '__VENV_DIR__': context.env_dir, + '__VENV_NAME__': context.env_name, + '__VENV_PROMPT__': context.prompt, + '__VENV_BIN_NAME__': context.bin_name, + '__VENV_PYTHON__': context.env_exe, + } + + def quote_ps1(s): + """ + This should satisfy PowerShell quoting rules [1], unless the quoted + string is passed directly to Windows native commands [2]. + [1]: https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules + [2]: https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_parsing#passing-arguments-that-contain-quote-characters + """ + s = s.replace("'", "''") + return f"'{s}'" + + def quote_bat(s): + return s + + # gh-124651: need to quote the template strings properly + quote = shlex.quote + script_path = context.script_path + if script_path.endswith('.ps1'): + quote = quote_ps1 + elif script_path.endswith('.bat'): + quote = quote_bat + else: + # fallbacks to POSIX shell compliant quote + quote = shlex.quote + + replacements = {key: quote(s) for key, s in replacements.items()} + for key, quoted in replacements.items(): + text = text.replace(key, quoted) + return text + + def install_scripts(self, context, path): + """ + Install scripts into the created environment from a directory. + + :param context: The information for the environment creation request + being processed. + :param path: Absolute pathname of a directory containing script. + Scripts in the 'common' subdirectory of this directory, + and those in the directory named for the platform + being run on, are installed in the created environment. + Placeholder variables are replaced with environment- + specific values. + """ + binpath = context.bin_path + plen = len(path) + for root, dirs, files in os.walk(path): + if root == path: # at top-level, remove irrelevant dirs + for d in dirs[:]: + if d not in ('common', os.name): + dirs.remove(d) + continue # ignore files in top level + for f in files: + if (os.name == 'nt' and f.startswith('python') + and f.endswith(('.exe', '.pdb'))): + continue + srcfile = os.path.join(root, f) + suffix = root[plen:].split(os.sep)[2:] + if not suffix: + dstdir = binpath + else: + dstdir = os.path.join(binpath, *suffix) + if not os.path.exists(dstdir): + os.makedirs(dstdir) + dstfile = os.path.join(dstdir, f) + with open(srcfile, 'rb') as f: + data = f.read() + if not srcfile.endswith(('.exe', '.pdb')): + context.script_path = srcfile + try: + data = data.decode('utf-8') + data = self.replace_variables(data, context) + data = data.encode('utf-8') + except UnicodeError as e: + data = None + logger.warning('unable to copy script %r, ' + 'may be binary: %s', srcfile, e) + if data is not None: + with open(dstfile, 'wb') as f: + f.write(data) + shutil.copymode(srcfile, dstfile) + + def upgrade_dependencies(self, context): + logger.debug( + f'Upgrading {CORE_VENV_DEPS} packages in {context.bin_path}' + ) + self._call_new_python(context, '-m', 'pip', 'install', '--upgrade', + *CORE_VENV_DEPS) + + +def create(env_dir, system_site_packages=False, clear=False, + symlinks=False, with_pip=False, prompt=None, upgrade_deps=False): + """Create a virtual environment in a directory.""" + builder = EnvBuilder(system_site_packages=system_site_packages, + clear=clear, symlinks=symlinks, with_pip=with_pip, + prompt=prompt, upgrade_deps=upgrade_deps) + builder.create(env_dir) + +def main(args=None): + compatible = True + if sys.version_info < (3, 3): + compatible = False + elif not hasattr(sys, 'base_prefix'): + compatible = False + if not compatible: + raise ValueError('This script is only for use with Python >= 3.3') + else: + import argparse + + parser = argparse.ArgumentParser(prog=__name__, + description='Creates virtual Python ' + 'environments in one or ' + 'more target ' + 'directories.', + epilog='Once an environment has been ' + 'created, you may wish to ' + 'activate it, e.g. by ' + 'sourcing an activate script ' + 'in its bin directory.') + parser.add_argument('dirs', metavar='ENV_DIR', nargs='+', + help='A directory to create the environment in.') + parser.add_argument('--system-site-packages', default=False, + action='store_true', dest='system_site', + help='Give the virtual environment access to the ' + 'system site-packages dir.') + if os.name == 'nt': + use_symlinks = False + else: + use_symlinks = True + group = parser.add_mutually_exclusive_group() + group.add_argument('--symlinks', default=use_symlinks, + action='store_true', dest='symlinks', + help='Try to use symlinks rather than copies, ' + 'when symlinks are not the default for ' + 'the platform.') + group.add_argument('--copies', default=not use_symlinks, + action='store_false', dest='symlinks', + help='Try to use copies rather than symlinks, ' + 'even when symlinks are the default for ' + 'the platform.') + parser.add_argument('--clear', default=False, action='store_true', + dest='clear', help='Delete the contents of the ' + 'environment directory if it ' + 'already exists, before ' + 'environment creation.') + parser.add_argument('--upgrade', default=False, action='store_true', + dest='upgrade', help='Upgrade the environment ' + 'directory to use this version ' + 'of Python, assuming Python ' + 'has been upgraded in-place.') + parser.add_argument('--without-pip', dest='with_pip', + default=True, action='store_false', + help='Skips installing or upgrading pip in the ' + 'virtual environment (pip is bootstrapped ' + 'by default)') + parser.add_argument('--prompt', + help='Provides an alternative prompt prefix for ' + 'this environment.') + parser.add_argument('--upgrade-deps', default=False, action='store_true', + dest='upgrade_deps', + help='Upgrade core dependencies: {} to the latest ' + 'version in PyPI'.format( + ' '.join(CORE_VENV_DEPS))) + options = parser.parse_args(args) + if options.upgrade and options.clear: + raise ValueError('you cannot supply --upgrade and --clear together.') + builder = EnvBuilder(system_site_packages=options.system_site, + clear=options.clear, + symlinks=options.symlinks, + upgrade=options.upgrade, + with_pip=options.with_pip, + prompt=options.prompt, + upgrade_deps=options.upgrade_deps) + for d in options.dirs: + builder.create(d) + +if __name__ == '__main__': + rc = 1 + try: + main() + rc = 0 + except Exception as e: + print('Error: %s' % e, file=sys.stderr) + sys.exit(rc) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/venv/__main__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/venv/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..912423e4a781988accc165be8f0f6bb2e289482d --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/venv/__main__.py @@ -0,0 +1,10 @@ +import sys +from . import main + +rc = 1 +try: + main() + rc = 0 +except Exception as e: + print('Error: %s' % e, file=sys.stderr) +sys.exit(rc) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/venv/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/venv/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..298eb8add449d38afa667665cc57537ed1c5f5ac Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/venv/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/venv/__pycache__/__main__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/venv/__pycache__/__main__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3620c0fc550ffc44bef734ab9a6ae5d1e22ae1b1 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/venv/__pycache__/__main__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/venv/scripts/common/Activate.ps1 b/physworld_p1_20261018/envs/p1/lib/python3.11/venv/scripts/common/Activate.ps1 new file mode 100644 index 0000000000000000000000000000000000000000..b49d77ba44b24fe6d69f6bbe75139b3b5dc23075 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/venv/scripts/common/Activate.ps1 @@ -0,0 +1,247 @@ +<# +.Synopsis +Activate a Python virtual environment for the current PowerShell session. + +.Description +Pushes the python executable for a virtual environment to the front of the +$Env:PATH environment variable and sets the prompt to signify that you are +in a Python virtual environment. Makes use of the command line switches as +well as the `pyvenv.cfg` file values present in the virtual environment. + +.Parameter VenvDir +Path to the directory that contains the virtual environment to activate. The +default value for this is the parent of the directory that the Activate.ps1 +script is located within. + +.Parameter Prompt +The prompt prefix to display when this virtual environment is activated. By +default, this prompt is the name of the virtual environment folder (VenvDir) +surrounded by parentheses and followed by a single space (ie. '(.venv) '). + +.Example +Activate.ps1 +Activates the Python virtual environment that contains the Activate.ps1 script. + +.Example +Activate.ps1 -Verbose +Activates the Python virtual environment that contains the Activate.ps1 script, +and shows extra information about the activation as it executes. + +.Example +Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv +Activates the Python virtual environment located in the specified location. + +.Example +Activate.ps1 -Prompt "MyPython" +Activates the Python virtual environment that contains the Activate.ps1 script, +and prefixes the current prompt with the specified string (surrounded in +parentheses) while the virtual environment is active. + +.Notes +On Windows, it may be required to enable this Activate.ps1 script by setting the +execution policy for the user. You can do this by issuing the following PowerShell +command: + +PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser + +For more information on Execution Policies: +https://go.microsoft.com/fwlink/?LinkID=135170 + +#> +Param( + [Parameter(Mandatory = $false)] + [String] + $VenvDir, + [Parameter(Mandatory = $false)] + [String] + $Prompt +) + +<# Function declarations --------------------------------------------------- #> + +<# +.Synopsis +Remove all shell session elements added by the Activate script, including the +addition of the virtual environment's Python executable from the beginning of +the PATH variable. + +.Parameter NonDestructive +If present, do not remove this function from the global namespace for the +session. + +#> +function global:deactivate ([switch]$NonDestructive) { + # Revert to original values + + # The prior prompt: + if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) { + Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt + Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT + } + + # The prior PYTHONHOME: + if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) { + Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME + Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME + } + + # The prior PATH: + if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) { + Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH + Remove-Item -Path Env:_OLD_VIRTUAL_PATH + } + + # Just remove the VIRTUAL_ENV altogether: + if (Test-Path -Path Env:VIRTUAL_ENV) { + Remove-Item -Path env:VIRTUAL_ENV + } + + # Just remove VIRTUAL_ENV_PROMPT altogether. + if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) { + Remove-Item -Path env:VIRTUAL_ENV_PROMPT + } + + # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether: + if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) { + Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force + } + + # Leave deactivate function in the global namespace if requested: + if (-not $NonDestructive) { + Remove-Item -Path function:deactivate + } +} + +<# +.Description +Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the +given folder, and returns them in a map. + +For each line in the pyvenv.cfg file, if that line can be parsed into exactly +two strings separated by `=` (with any amount of whitespace surrounding the =) +then it is considered a `key = value` line. The left hand string is the key, +the right hand is the value. + +If the value starts with a `'` or a `"` then the first and last character is +stripped from the value before being captured. + +.Parameter ConfigDir +Path to the directory that contains the `pyvenv.cfg` file. +#> +function Get-PyVenvConfig( + [String] + $ConfigDir +) { + Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg" + + # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue). + $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue + + # An empty map will be returned if no config file is found. + $pyvenvConfig = @{ } + + if ($pyvenvConfigPath) { + + Write-Verbose "File exists, parse `key = value` lines" + $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath + + $pyvenvConfigContent | ForEach-Object { + $keyval = $PSItem -split "\s*=\s*", 2 + if ($keyval[0] -and $keyval[1]) { + $val = $keyval[1] + + # Remove extraneous quotations around a string value. + if ("'""".Contains($val.Substring(0, 1))) { + $val = $val.Substring(1, $val.Length - 2) + } + + $pyvenvConfig[$keyval[0]] = $val + Write-Verbose "Adding Key: '$($keyval[0])'='$val'" + } + } + } + return $pyvenvConfig +} + + +<# Begin Activate script --------------------------------------------------- #> + +# Determine the containing directory of this script +$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition +$VenvExecDir = Get-Item -Path $VenvExecPath + +Write-Verbose "Activation script is located in path: '$VenvExecPath'" +Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)" +Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)" + +# Set values required in priority: CmdLine, ConfigFile, Default +# First, get the location of the virtual environment, it might not be +# VenvExecDir if specified on the command line. +if ($VenvDir) { + Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values" +} +else { + Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir." + $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/") + Write-Verbose "VenvDir=$VenvDir" +} + +# Next, read the `pyvenv.cfg` file to determine any required value such +# as `prompt`. +$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir + +# Next, set the prompt from the command line, or the config file, or +# just use the name of the virtual environment folder. +if ($Prompt) { + Write-Verbose "Prompt specified as argument, using '$Prompt'" +} +else { + Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value" + if ($pyvenvCfg -and $pyvenvCfg['prompt']) { + Write-Verbose " Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'" + $Prompt = $pyvenvCfg['prompt']; + } + else { + Write-Verbose " Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)" + Write-Verbose " Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'" + $Prompt = Split-Path -Path $venvDir -Leaf + } +} + +Write-Verbose "Prompt = '$Prompt'" +Write-Verbose "VenvDir='$VenvDir'" + +# Deactivate any currently active virtual environment, but leave the +# deactivate function in place. +deactivate -nondestructive + +# Now set the environment variable VIRTUAL_ENV, used by many tools to determine +# that there is an activated venv. +$env:VIRTUAL_ENV = $VenvDir + +if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) { + + Write-Verbose "Setting prompt to '$Prompt'" + + # Set the prompt to include the env name + # Make sure _OLD_VIRTUAL_PROMPT is global + function global:_OLD_VIRTUAL_PROMPT { "" } + Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT + New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt + + function global:prompt { + Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) " + _OLD_VIRTUAL_PROMPT + } + $env:VIRTUAL_ENV_PROMPT = $Prompt +} + +# Clear PYTHONHOME +if (Test-Path -Path Env:PYTHONHOME) { + Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME + Remove-Item -Path Env:PYTHONHOME +} + +# Add the venv to the PATH +Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH +$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH" diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/venv/scripts/common/activate b/physworld_p1_20261018/envs/p1/lib/python3.11/venv/scripts/common/activate new file mode 100644 index 0000000000000000000000000000000000000000..e86442b3578342863a85cd834a5014aa3bcd0f80 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/venv/scripts/common/activate @@ -0,0 +1,63 @@ +# This file must be used with "source bin/activate" *from bash* +# you cannot run it directly + +deactivate () { + # reset old environment variables + if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then + PATH="${_OLD_VIRTUAL_PATH:-}" + export PATH + unset _OLD_VIRTUAL_PATH + fi + if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then + PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}" + export PYTHONHOME + unset _OLD_VIRTUAL_PYTHONHOME + fi + + # Call hash to forget past commands. Without forgetting + # past commands the $PATH changes we made may not be respected + hash -r 2> /dev/null + + if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then + PS1="${_OLD_VIRTUAL_PS1:-}" + export PS1 + unset _OLD_VIRTUAL_PS1 + fi + + unset VIRTUAL_ENV + unset VIRTUAL_ENV_PROMPT + if [ ! "${1:-}" = "nondestructive" ] ; then + # Self destruct! + unset -f deactivate + fi +} + +# unset irrelevant variables +deactivate nondestructive + +VIRTUAL_ENV=__VENV_DIR__ +export VIRTUAL_ENV + +_OLD_VIRTUAL_PATH="$PATH" +PATH="$VIRTUAL_ENV/"__VENV_BIN_NAME__":$PATH" +export PATH + +# unset PYTHONHOME if set +# this will fail if PYTHONHOME is set to the empty string (which is bad anyway) +# could use `if (set -u; : $PYTHONHOME) ;` in bash +if [ -n "${PYTHONHOME:-}" ] ; then + _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}" + unset PYTHONHOME +fi + +if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then + _OLD_VIRTUAL_PS1="${PS1:-}" + PS1=__VENV_PROMPT__"${PS1:-}" + export PS1 + VIRTUAL_ENV_PROMPT=__VENV_PROMPT__ + export VIRTUAL_ENV_PROMPT +fi + +# Call hash to forget past commands. Without forgetting +# past commands the $PATH changes we made may not be respected +hash -r 2> /dev/null diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/venv/scripts/posix/activate.csh b/physworld_p1_20261018/envs/p1/lib/python3.11/venv/scripts/posix/activate.csh new file mode 100644 index 0000000000000000000000000000000000000000..c47702127eff712cd64972d55be5a7dd66c06274 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/venv/scripts/posix/activate.csh @@ -0,0 +1,26 @@ +# This file must be used with "source bin/activate.csh" *from csh*. +# You cannot run it directly. +# Created by Davide Di Blasi . +# Ported to Python 3.3 venv by Andrew Svetlov + +alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate' + +# Unset irrelevant variables. +deactivate nondestructive + +setenv VIRTUAL_ENV __VENV_DIR__ + +set _OLD_VIRTUAL_PATH="$PATH" +setenv PATH "$VIRTUAL_ENV/"__VENV_BIN_NAME__":$PATH" + + +set _OLD_VIRTUAL_PROMPT="$prompt" + +if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then + set prompt = __VENV_PROMPT__"$prompt" + setenv VIRTUAL_ENV_PROMPT __VENV_PROMPT__ +endif + +alias pydoc python -m pydoc + +rehash diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/venv/scripts/posix/activate.fish b/physworld_p1_20261018/envs/p1/lib/python3.11/venv/scripts/posix/activate.fish new file mode 100644 index 0000000000000000000000000000000000000000..dc3a6c88270c182800d0594d062ba94b8d83205e --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/venv/scripts/posix/activate.fish @@ -0,0 +1,69 @@ +# This file must be used with "source /bin/activate.fish" *from fish* +# (https://fishshell.com/); you cannot run it directly. + +function deactivate -d "Exit virtual environment and return to normal shell environment" + # reset old environment variables + if test -n "$_OLD_VIRTUAL_PATH" + set -gx PATH $_OLD_VIRTUAL_PATH + set -e _OLD_VIRTUAL_PATH + end + if test -n "$_OLD_VIRTUAL_PYTHONHOME" + set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME + set -e _OLD_VIRTUAL_PYTHONHOME + end + + if test -n "$_OLD_FISH_PROMPT_OVERRIDE" + set -e _OLD_FISH_PROMPT_OVERRIDE + # prevents error when using nested fish instances (Issue #93858) + if functions -q _old_fish_prompt + functions -e fish_prompt + functions -c _old_fish_prompt fish_prompt + functions -e _old_fish_prompt + end + end + + set -e VIRTUAL_ENV + set -e VIRTUAL_ENV_PROMPT + if test "$argv[1]" != "nondestructive" + # Self-destruct! + functions -e deactivate + end +end + +# Unset irrelevant variables. +deactivate nondestructive + +set -gx VIRTUAL_ENV __VENV_DIR__ + +set -gx _OLD_VIRTUAL_PATH $PATH +set -gx PATH "$VIRTUAL_ENV/"__VENV_BIN_NAME__ $PATH + +# Unset PYTHONHOME if set. +if set -q PYTHONHOME + set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME + set -e PYTHONHOME +end + +if test -z "$VIRTUAL_ENV_DISABLE_PROMPT" + # fish uses a function instead of an env var to generate the prompt. + + # Save the current fish_prompt function as the function _old_fish_prompt. + functions -c fish_prompt _old_fish_prompt + + # With the original prompt function renamed, we can override with our own. + function fish_prompt + # Save the return status of the last command. + set -l old_status $status + + # Output the venv prompt; color taken from the blue of the Python logo. + printf "%s%s%s" (set_color 4B8BBE) __VENV_PROMPT__ (set_color normal) + + # Restore the return status of the previous command. + echo "exit $old_status" | . + # Output the original/"old" prompt. + _old_fish_prompt + end + + set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV" + set -gx VIRTUAL_ENV_PROMPT __VENV_PROMPT__ +end diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/warnings.py b/physworld_p1_20261018/envs/p1/lib/python3.11/warnings.py new file mode 100644 index 0000000000000000000000000000000000000000..7c8a0943b8179e0f69e0beb8d8fab6656b9d2e35 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/warnings.py @@ -0,0 +1,581 @@ +"""Python part of the warnings subsystem.""" + +import sys + + +__all__ = ["warn", "warn_explicit", "showwarning", + "formatwarning", "filterwarnings", "simplefilter", + "resetwarnings", "catch_warnings"] + +def showwarning(message, category, filename, lineno, file=None, line=None): + """Hook to write a warning to a file; replace if you like.""" + msg = WarningMessage(message, category, filename, lineno, file, line) + _showwarnmsg_impl(msg) + +def formatwarning(message, category, filename, lineno, line=None): + """Function to format a warning the standard way.""" + msg = WarningMessage(message, category, filename, lineno, None, line) + return _formatwarnmsg_impl(msg) + +def _showwarnmsg_impl(msg): + file = msg.file + if file is None: + file = sys.stderr + if file is None: + # sys.stderr is None when run with pythonw.exe: + # warnings get lost + return + text = _formatwarnmsg(msg) + try: + file.write(text) + except OSError: + # the file (probably stderr) is invalid - this warning gets lost. + pass + +def _formatwarnmsg_impl(msg): + category = msg.category.__name__ + s = f"{msg.filename}:{msg.lineno}: {category}: {msg.message}\n" + + if msg.line is None: + try: + import linecache + line = linecache.getline(msg.filename, msg.lineno) + except Exception: + # When a warning is logged during Python shutdown, linecache + # and the import machinery don't work anymore + line = None + linecache = None + else: + line = msg.line + if line: + line = line.strip() + s += " %s\n" % line + + if msg.source is not None: + try: + import tracemalloc + # Logging a warning should not raise a new exception: + # catch Exception, not only ImportError and RecursionError. + except Exception: + # don't suggest to enable tracemalloc if it's not available + suggest_tracemalloc = False + tb = None + else: + try: + suggest_tracemalloc = not tracemalloc.is_tracing() + tb = tracemalloc.get_object_traceback(msg.source) + except Exception: + # When a warning is logged during Python shutdown, tracemalloc + # and the import machinery don't work anymore + suggest_tracemalloc = False + tb = None + + if tb is not None: + s += 'Object allocated at (most recent call last):\n' + for frame in tb: + s += (' File "%s", lineno %s\n' + % (frame.filename, frame.lineno)) + + try: + if linecache is not None: + line = linecache.getline(frame.filename, frame.lineno) + else: + line = None + except Exception: + line = None + if line: + line = line.strip() + s += ' %s\n' % line + elif suggest_tracemalloc: + s += (f'{category}: Enable tracemalloc to get the object ' + f'allocation traceback\n') + return s + +# Keep a reference to check if the function was replaced +_showwarning_orig = showwarning + +def _showwarnmsg(msg): + """Hook to write a warning to a file; replace if you like.""" + try: + sw = showwarning + except NameError: + pass + else: + if sw is not _showwarning_orig: + # warnings.showwarning() was replaced + if not callable(sw): + raise TypeError("warnings.showwarning() must be set to a " + "function or method") + + sw(msg.message, msg.category, msg.filename, msg.lineno, + msg.file, msg.line) + return + _showwarnmsg_impl(msg) + +# Keep a reference to check if the function was replaced +_formatwarning_orig = formatwarning + +def _formatwarnmsg(msg): + """Function to format a warning the standard way.""" + try: + fw = formatwarning + except NameError: + pass + else: + if fw is not _formatwarning_orig: + # warnings.formatwarning() was replaced + return fw(msg.message, msg.category, + msg.filename, msg.lineno, msg.line) + return _formatwarnmsg_impl(msg) + +def filterwarnings(action, message="", category=Warning, module="", lineno=0, + append=False): + """Insert an entry into the list of warnings filters (at the front). + + 'action' -- one of "error", "ignore", "always", "default", "module", + or "once" + 'message' -- a regex that the warning message must match + 'category' -- a class that the warning must be a subclass of + 'module' -- a regex that the module name must match + 'lineno' -- an integer line number, 0 matches all warnings + 'append' -- if true, append to the list of filters + """ + assert action in ("error", "ignore", "always", "default", "module", + "once"), "invalid action: %r" % (action,) + assert isinstance(message, str), "message must be a string" + assert isinstance(category, type), "category must be a class" + assert issubclass(category, Warning), "category must be a Warning subclass" + assert isinstance(module, str), "module must be a string" + assert isinstance(lineno, int) and lineno >= 0, \ + "lineno must be an int >= 0" + + if message or module: + import re + + if message: + message = re.compile(message, re.I) + else: + message = None + if module: + module = re.compile(module) + else: + module = None + + _add_filter(action, message, category, module, lineno, append=append) + +def simplefilter(action, category=Warning, lineno=0, append=False): + """Insert a simple entry into the list of warnings filters (at the front). + + A simple filter matches all modules and messages. + 'action' -- one of "error", "ignore", "always", "default", "module", + or "once" + 'category' -- a class that the warning must be a subclass of + 'lineno' -- an integer line number, 0 matches all warnings + 'append' -- if true, append to the list of filters + """ + assert action in ("error", "ignore", "always", "default", "module", + "once"), "invalid action: %r" % (action,) + assert isinstance(lineno, int) and lineno >= 0, \ + "lineno must be an int >= 0" + _add_filter(action, None, category, None, lineno, append=append) + +def _add_filter(*item, append): + # Remove possible duplicate filters, so new one will be placed + # in correct place. If append=True and duplicate exists, do nothing. + if not append: + try: + filters.remove(item) + except ValueError: + pass + filters.insert(0, item) + else: + if item not in filters: + filters.append(item) + _filters_mutated() + +def resetwarnings(): + """Clear the list of warning filters, so that no filters are active.""" + filters[:] = [] + _filters_mutated() + +class _OptionError(Exception): + """Exception used by option processing helpers.""" + pass + +# Helper to process -W options passed via sys.warnoptions +def _processoptions(args): + for arg in args: + try: + _setoption(arg) + except _OptionError as msg: + print("Invalid -W option ignored:", msg, file=sys.stderr) + +# Helper for _processoptions() +def _setoption(arg): + parts = arg.split(':') + if len(parts) > 5: + raise _OptionError("too many fields (max 5): %r" % (arg,)) + while len(parts) < 5: + parts.append('') + action, message, category, module, lineno = [s.strip() + for s in parts] + action = _getaction(action) + category = _getcategory(category) + if message or module: + import re + if message: + message = re.escape(message) + if module: + module = re.escape(module) + r'\Z' + if lineno: + try: + lineno = int(lineno) + if lineno < 0: + raise ValueError + except (ValueError, OverflowError): + raise _OptionError("invalid lineno %r" % (lineno,)) from None + else: + lineno = 0 + filterwarnings(action, message, category, module, lineno) + +# Helper for _setoption() +def _getaction(action): + if not action: + return "default" + if action == "all": return "always" # Alias + for a in ('default', 'always', 'ignore', 'module', 'once', 'error'): + if a.startswith(action): + return a + raise _OptionError("invalid action: %r" % (action,)) + +# Helper for _setoption() +def _getcategory(category): + if not category: + return Warning + if '.' not in category: + import builtins as m + klass = category + else: + module, _, klass = category.rpartition('.') + try: + m = __import__(module, None, None, [klass]) + except ImportError: + raise _OptionError("invalid module name: %r" % (module,)) from None + try: + cat = getattr(m, klass) + except AttributeError: + raise _OptionError("unknown warning category: %r" % (category,)) from None + if not issubclass(cat, Warning): + raise _OptionError("invalid warning category: %r" % (category,)) + return cat + + +def _is_internal_frame(frame): + """Signal whether the frame is an internal CPython implementation detail.""" + filename = frame.f_code.co_filename + return 'importlib' in filename and '_bootstrap' in filename + + +def _next_external_frame(frame): + """Find the next frame that doesn't involve CPython internals.""" + frame = frame.f_back + while frame is not None and _is_internal_frame(frame): + frame = frame.f_back + return frame + + +# Code typically replaced by _warnings +def warn(message, category=None, stacklevel=1, source=None): + """Issue a warning, or maybe ignore it or raise an exception.""" + # Check if message is already a Warning object + if isinstance(message, Warning): + category = message.__class__ + # Check category argument + if category is None: + category = UserWarning + if not (isinstance(category, type) and issubclass(category, Warning)): + raise TypeError("category must be a Warning subclass, " + "not '{:s}'".format(type(category).__name__)) + # Get context information + try: + if stacklevel <= 1 or _is_internal_frame(sys._getframe(1)): + # If frame is too small to care or if the warning originated in + # internal code, then do not try to hide any frames. + frame = sys._getframe(stacklevel) + else: + frame = sys._getframe(1) + # Look for one frame less since the above line starts us off. + for x in range(stacklevel-1): + frame = _next_external_frame(frame) + if frame is None: + raise ValueError + except ValueError: + globals = sys.__dict__ + filename = "sys" + lineno = 1 + else: + globals = frame.f_globals + filename = frame.f_code.co_filename + lineno = frame.f_lineno + if '__name__' in globals: + module = globals['__name__'] + else: + module = "" + registry = globals.setdefault("__warningregistry__", {}) + warn_explicit(message, category, filename, lineno, module, registry, + globals, source) + +def warn_explicit(message, category, filename, lineno, + module=None, registry=None, module_globals=None, + source=None): + lineno = int(lineno) + if module is None: + module = filename or "" + if module[-3:].lower() == ".py": + module = module[:-3] # XXX What about leading pathname? + if registry is None: + registry = {} + if registry.get('version', 0) != _filters_version: + registry.clear() + registry['version'] = _filters_version + if isinstance(message, Warning): + text = str(message) + category = message.__class__ + else: + text = message + message = category(message) + key = (text, category, lineno) + # Quick test for common case + if registry.get(key): + return + # Search the filters + for item in filters: + action, msg, cat, mod, ln = item + if ((msg is None or msg.match(text)) and + issubclass(category, cat) and + (mod is None or mod.match(module)) and + (ln == 0 or lineno == ln)): + break + else: + action = defaultaction + # Early exit actions + if action == "ignore": + return + + # Prime the linecache for formatting, in case the + # "file" is actually in a zipfile or something. + import linecache + linecache.getlines(filename, module_globals) + + if action == "error": + raise message + # Other actions + if action == "once": + registry[key] = 1 + oncekey = (text, category) + if onceregistry.get(oncekey): + return + onceregistry[oncekey] = 1 + elif action == "always": + pass + elif action == "module": + registry[key] = 1 + altkey = (text, category, 0) + if registry.get(altkey): + return + registry[altkey] = 1 + elif action == "default": + registry[key] = 1 + else: + # Unrecognized actions are errors + raise RuntimeError( + "Unrecognized action (%r) in warnings.filters:\n %s" % + (action, item)) + # Print message and context + msg = WarningMessage(message, category, filename, lineno, source) + _showwarnmsg(msg) + + +class WarningMessage(object): + + _WARNING_DETAILS = ("message", "category", "filename", "lineno", "file", + "line", "source") + + def __init__(self, message, category, filename, lineno, file=None, + line=None, source=None): + self.message = message + self.category = category + self.filename = filename + self.lineno = lineno + self.file = file + self.line = line + self.source = source + self._category_name = category.__name__ if category else None + + def __str__(self): + return ("{message : %r, category : %r, filename : %r, lineno : %s, " + "line : %r}" % (self.message, self._category_name, + self.filename, self.lineno, self.line)) + + +class catch_warnings(object): + + """A context manager that copies and restores the warnings filter upon + exiting the context. + + The 'record' argument specifies whether warnings should be captured by a + custom implementation of warnings.showwarning() and be appended to a list + returned by the context manager. Otherwise None is returned by the context + manager. The objects appended to the list are arguments whose attributes + mirror the arguments to showwarning(). + + The 'module' argument is to specify an alternative module to the module + named 'warnings' and imported under that name. This argument is only useful + when testing the warnings module itself. + + If the 'action' argument is not None, the remaining arguments are passed + to warnings.simplefilter() as if it were called immediately on entering the + context. + """ + + def __init__(self, *, record=False, module=None, + action=None, category=Warning, lineno=0, append=False): + """Specify whether to record warnings and if an alternative module + should be used other than sys.modules['warnings']. + + For compatibility with Python 3.0, please consider all arguments to be + keyword-only. + + """ + self._record = record + self._module = sys.modules['warnings'] if module is None else module + self._entered = False + if action is None: + self._filter = None + else: + self._filter = (action, category, lineno, append) + + def __repr__(self): + args = [] + if self._record: + args.append("record=True") + if self._module is not sys.modules['warnings']: + args.append("module=%r" % self._module) + name = type(self).__name__ + return "%s(%s)" % (name, ", ".join(args)) + + def __enter__(self): + if self._entered: + raise RuntimeError("Cannot enter %r twice" % self) + self._entered = True + self._filters = self._module.filters + self._module.filters = self._filters[:] + self._module._filters_mutated() + self._showwarning = self._module.showwarning + self._showwarnmsg_impl = self._module._showwarnmsg_impl + if self._filter is not None: + simplefilter(*self._filter) + if self._record: + log = [] + self._module._showwarnmsg_impl = log.append + # Reset showwarning() to the default implementation to make sure + # that _showwarnmsg() calls _showwarnmsg_impl() + self._module.showwarning = self._module._showwarning_orig + return log + else: + return None + + def __exit__(self, *exc_info): + if not self._entered: + raise RuntimeError("Cannot exit %r without entering first" % self) + self._module.filters = self._filters + self._module._filters_mutated() + self._module.showwarning = self._showwarning + self._module._showwarnmsg_impl = self._showwarnmsg_impl + + +_DEPRECATED_MSG = "{name!r} is deprecated and slated for removal in Python {remove}" + +def _deprecated(name, message=_DEPRECATED_MSG, *, remove, _version=sys.version_info): + """Warn that *name* is deprecated or should be removed. + + RuntimeError is raised if *remove* specifies a major/minor tuple older than + the current Python version or the same version but past the alpha. + + The *message* argument is formatted with *name* and *remove* as a Python + version (e.g. "3.11"). + + """ + remove_formatted = f"{remove[0]}.{remove[1]}" + if (_version[:2] > remove) or (_version[:2] == remove and _version[3] != "alpha"): + msg = f"{name!r} was slated for removal after Python {remove_formatted} alpha" + raise RuntimeError(msg) + else: + msg = message.format(name=name, remove=remove_formatted) + warn(msg, DeprecationWarning, stacklevel=3) + + +# Private utility function called by _PyErr_WarnUnawaitedCoroutine +def _warn_unawaited_coroutine(coro): + msg_lines = [ + f"coroutine '{coro.__qualname__}' was never awaited\n" + ] + if coro.cr_origin is not None: + import linecache, traceback + def extract(): + for filename, lineno, funcname in reversed(coro.cr_origin): + line = linecache.getline(filename, lineno) + yield (filename, lineno, funcname, line) + msg_lines.append("Coroutine created at (most recent call last)\n") + msg_lines += traceback.format_list(list(extract())) + msg = "".join(msg_lines).rstrip("\n") + # Passing source= here means that if the user happens to have tracemalloc + # enabled and tracking where the coroutine was created, the warning will + # contain that traceback. This does mean that if they have *both* + # coroutine origin tracking *and* tracemalloc enabled, they'll get two + # partially-redundant tracebacks. If we wanted to be clever we could + # probably detect this case and avoid it, but for now we don't bother. + warn(msg, category=RuntimeWarning, stacklevel=2, source=coro) + + +# filters contains a sequence of filter 5-tuples +# The components of the 5-tuple are: +# - an action: error, ignore, always, default, module, or once +# - a compiled regex that must match the warning message +# - a class representing the warning category +# - a compiled regex that must match the module that is being warned +# - a line number for the line being warning, or 0 to mean any line +# If either if the compiled regexs are None, match anything. +try: + from _warnings import (filters, _defaultaction, _onceregistry, + warn, warn_explicit, _filters_mutated) + defaultaction = _defaultaction + onceregistry = _onceregistry + _warnings_defaults = True +except ImportError: + filters = [] + defaultaction = "default" + onceregistry = {} + + _filters_version = 1 + + def _filters_mutated(): + global _filters_version + _filters_version += 1 + + _warnings_defaults = False + + +# Module initialization +_processoptions(sys.warnoptions) +if not _warnings_defaults: + # Several warning categories are ignored by default in regular builds + if not hasattr(sys, 'gettotalrefcount'): + filterwarnings("default", category=DeprecationWarning, + module="__main__", append=1) + simplefilter("ignore", category=DeprecationWarning, append=1) + simplefilter("ignore", category=PendingDeprecationWarning, append=1) + simplefilter("ignore", category=ImportWarning, append=1) + simplefilter("ignore", category=ResourceWarning, append=1) + +del _warnings_defaults diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/wave.py b/physworld_p1_20261018/envs/p1/lib/python3.11/wave.py new file mode 100644 index 0000000000000000000000000000000000000000..bcacbac4e7bac702bb780a62f0346b7ff6117b8f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/wave.py @@ -0,0 +1,635 @@ +"""Stuff to parse WAVE files. + +Usage. + +Reading WAVE files: + f = wave.open(file, 'r') +where file is either the name of a file or an open file pointer. +The open file pointer must have methods read(), seek(), and close(). +When the setpos() and rewind() methods are not used, the seek() +method is not necessary. + +This returns an instance of a class with the following public methods: + getnchannels() -- returns number of audio channels (1 for + mono, 2 for stereo) + getsampwidth() -- returns sample width in bytes + getframerate() -- returns sampling frequency + getnframes() -- returns number of audio frames + getcomptype() -- returns compression type ('NONE' for linear samples) + getcompname() -- returns human-readable version of + compression type ('not compressed' linear samples) + getparams() -- returns a namedtuple consisting of all of the + above in the above order + getmarkers() -- returns None (for compatibility with the + aifc module) + getmark(id) -- raises an error since the mark does not + exist (for compatibility with the aifc module) + readframes(n) -- returns at most n frames of audio + rewind() -- rewind to the beginning of the audio stream + setpos(pos) -- seek to the specified position + tell() -- return the current position + close() -- close the instance (make it unusable) +The position returned by tell() and the position given to setpos() +are compatible and have nothing to do with the actual position in the +file. +The close() method is called automatically when the class instance +is destroyed. + +Writing WAVE files: + f = wave.open(file, 'w') +where file is either the name of a file or an open file pointer. +The open file pointer must have methods write(), tell(), seek(), and +close(). + +This returns an instance of a class with the following public methods: + setnchannels(n) -- set the number of channels + setsampwidth(n) -- set the sample width + setframerate(n) -- set the frame rate + setnframes(n) -- set the number of frames + setcomptype(type, name) + -- set the compression type and the + human-readable compression type + setparams(tuple) + -- set all parameters at once + tell() -- return current position in output file + writeframesraw(data) + -- write audio frames without patching up the + file header + writeframes(data) + -- write audio frames and patch up the file header + close() -- patch up the file header and close the + output file +You should set the parameters before the first writeframesraw or +writeframes. The total number of frames does not need to be set, +but when it is set to the correct value, the header does not have to +be patched up. +It is best to first set all parameters, perhaps possibly the +compression type, and then write audio frames using writeframesraw. +When all frames have been written, either call writeframes(b'') or +close() to patch up the sizes in the header. +The close() method is called automatically when the class instance +is destroyed. +""" + +from collections import namedtuple +import builtins +import struct +import sys + + +__all__ = ["open", "Error", "Wave_read", "Wave_write"] + +class Error(Exception): + pass + +WAVE_FORMAT_PCM = 0x0001 + +_array_fmts = None, 'b', 'h', None, 'i' + +_wave_params = namedtuple('_wave_params', + 'nchannels sampwidth framerate nframes comptype compname') + + +def _byteswap(data, width): + swapped_data = bytearray(len(data)) + + for i in range(0, len(data), width): + for j in range(width): + swapped_data[i + width - 1 - j] = data[i + j] + + return bytes(swapped_data) + + +class _Chunk: + def __init__(self, file, align=True, bigendian=True, inclheader=False): + self.closed = False + self.align = align # whether to align to word (2-byte) boundaries + if bigendian: + strflag = '>' + else: + strflag = '<' + self.file = file + self.chunkname = file.read(4) + if len(self.chunkname) < 4: + raise EOFError + try: + self.chunksize = struct.unpack_from(strflag+'L', file.read(4))[0] + except struct.error: + raise EOFError from None + if inclheader: + self.chunksize = self.chunksize - 8 # subtract header + self.size_read = 0 + try: + self.offset = self.file.tell() + except (AttributeError, OSError): + self.seekable = False + else: + self.seekable = True + + def getname(self): + """Return the name (ID) of the current chunk.""" + return self.chunkname + + def close(self): + if not self.closed: + try: + self.skip() + finally: + self.closed = True + + def seek(self, pos, whence=0): + """Seek to specified position into the chunk. + Default position is 0 (start of chunk). + If the file is not seekable, this will result in an error. + """ + + if self.closed: + raise ValueError("I/O operation on closed file") + if not self.seekable: + raise OSError("cannot seek") + if whence == 1: + pos = pos + self.size_read + elif whence == 2: + pos = pos + self.chunksize + if pos < 0 or pos > self.chunksize: + raise RuntimeError + self.file.seek(self.offset + pos, 0) + self.size_read = pos + + def tell(self): + if self.closed: + raise ValueError("I/O operation on closed file") + return self.size_read + + def read(self, size=-1): + """Read at most size bytes from the chunk. + If size is omitted or negative, read until the end + of the chunk. + """ + + if self.closed: + raise ValueError("I/O operation on closed file") + if self.size_read >= self.chunksize: + return b'' + if size < 0: + size = self.chunksize - self.size_read + if size > self.chunksize - self.size_read: + size = self.chunksize - self.size_read + data = self.file.read(size) + self.size_read = self.size_read + len(data) + if self.size_read == self.chunksize and \ + self.align and \ + (self.chunksize & 1): + dummy = self.file.read(1) + self.size_read = self.size_read + len(dummy) + return data + + def skip(self): + """Skip the rest of the chunk. + If you are not interested in the contents of the chunk, + this method should be called so that the file points to + the start of the next chunk. + """ + + if self.closed: + raise ValueError("I/O operation on closed file") + if self.seekable: + try: + n = self.chunksize - self.size_read + # maybe fix alignment + if self.align and (self.chunksize & 1): + n = n + 1 + self.file.seek(n, 1) + self.size_read = self.size_read + n + return + except OSError: + pass + while self.size_read < self.chunksize: + n = min(8192, self.chunksize - self.size_read) + dummy = self.read(n) + if not dummy: + raise EOFError + + +class Wave_read: + """Variables used in this class: + + These variables are available to the user though appropriate + methods of this class: + _file -- the open file with methods read(), close(), and seek() + set through the __init__() method + _nchannels -- the number of audio channels + available through the getnchannels() method + _nframes -- the number of audio frames + available through the getnframes() method + _sampwidth -- the number of bytes per audio sample + available through the getsampwidth() method + _framerate -- the sampling frequency + available through the getframerate() method + _comptype -- the AIFF-C compression type ('NONE' if AIFF) + available through the getcomptype() method + _compname -- the human-readable AIFF-C compression type + available through the getcomptype() method + _soundpos -- the position in the audio stream + available through the tell() method, set through the + setpos() method + + These variables are used internally only: + _fmt_chunk_read -- 1 iff the FMT chunk has been read + _data_seek_needed -- 1 iff positioned correctly in audio + file for readframes() + _data_chunk -- instantiation of a chunk class for the DATA chunk + _framesize -- size of one frame in the file + """ + + def initfp(self, file): + self._convert = None + self._soundpos = 0 + self._file = _Chunk(file, bigendian = 0) + if self._file.getname() != b'RIFF': + raise Error('file does not start with RIFF id') + if self._file.read(4) != b'WAVE': + raise Error('not a WAVE file') + self._fmt_chunk_read = 0 + self._data_chunk = None + while 1: + self._data_seek_needed = 1 + try: + chunk = _Chunk(self._file, bigendian = 0) + except EOFError: + break + chunkname = chunk.getname() + if chunkname == b'fmt ': + self._read_fmt_chunk(chunk) + self._fmt_chunk_read = 1 + elif chunkname == b'data': + if not self._fmt_chunk_read: + raise Error('data chunk before fmt chunk') + self._data_chunk = chunk + self._nframes = chunk.chunksize // self._framesize + self._data_seek_needed = 0 + break + chunk.skip() + if not self._fmt_chunk_read or not self._data_chunk: + raise Error('fmt chunk and/or data chunk missing') + + def __init__(self, f): + self._i_opened_the_file = None + if isinstance(f, str): + f = builtins.open(f, 'rb') + self._i_opened_the_file = f + # else, assume it is an open file object already + try: + self.initfp(f) + except: + if self._i_opened_the_file: + f.close() + raise + + def __del__(self): + self.close() + + def __enter__(self): + return self + + def __exit__(self, *args): + self.close() + + # + # User visible methods. + # + def getfp(self): + return self._file + + def rewind(self): + self._data_seek_needed = 1 + self._soundpos = 0 + + def close(self): + self._file = None + file = self._i_opened_the_file + if file: + self._i_opened_the_file = None + file.close() + + def tell(self): + return self._soundpos + + def getnchannels(self): + return self._nchannels + + def getnframes(self): + return self._nframes + + def getsampwidth(self): + return self._sampwidth + + def getframerate(self): + return self._framerate + + def getcomptype(self): + return self._comptype + + def getcompname(self): + return self._compname + + def getparams(self): + return _wave_params(self.getnchannels(), self.getsampwidth(), + self.getframerate(), self.getnframes(), + self.getcomptype(), self.getcompname()) + + def getmarkers(self): + return None + + def getmark(self, id): + raise Error('no marks') + + def setpos(self, pos): + if pos < 0 or pos > self._nframes: + raise Error('position not in range') + self._soundpos = pos + self._data_seek_needed = 1 + + def readframes(self, nframes): + if self._data_seek_needed: + self._data_chunk.seek(0, 0) + pos = self._soundpos * self._framesize + if pos: + self._data_chunk.seek(pos, 0) + self._data_seek_needed = 0 + if nframes == 0: + return b'' + data = self._data_chunk.read(nframes * self._framesize) + if self._sampwidth != 1 and sys.byteorder == 'big': + data = _byteswap(data, self._sampwidth) + if self._convert and data: + data = self._convert(data) + self._soundpos = self._soundpos + len(data) // (self._nchannels * self._sampwidth) + return data + + # + # Internal methods. + # + + def _read_fmt_chunk(self, chunk): + try: + wFormatTag, self._nchannels, self._framerate, dwAvgBytesPerSec, wBlockAlign = struct.unpack_from(' 4: + raise Error('bad sample width') + self._sampwidth = sampwidth + + def getsampwidth(self): + if not self._sampwidth: + raise Error('sample width not set') + return self._sampwidth + + def setframerate(self, framerate): + if self._datawritten: + raise Error('cannot change parameters after starting to write') + if framerate <= 0: + raise Error('bad frame rate') + self._framerate = int(round(framerate)) + + def getframerate(self): + if not self._framerate: + raise Error('frame rate not set') + return self._framerate + + def setnframes(self, nframes): + if self._datawritten: + raise Error('cannot change parameters after starting to write') + self._nframes = nframes + + def getnframes(self): + return self._nframeswritten + + def setcomptype(self, comptype, compname): + if self._datawritten: + raise Error('cannot change parameters after starting to write') + if comptype not in ('NONE',): + raise Error('unsupported compression type') + self._comptype = comptype + self._compname = compname + + def getcomptype(self): + return self._comptype + + def getcompname(self): + return self._compname + + def setparams(self, params): + nchannels, sampwidth, framerate, nframes, comptype, compname = params + if self._datawritten: + raise Error('cannot change parameters after starting to write') + self.setnchannels(nchannels) + self.setsampwidth(sampwidth) + self.setframerate(framerate) + self.setnframes(nframes) + self.setcomptype(comptype, compname) + + def getparams(self): + if not self._nchannels or not self._sampwidth or not self._framerate: + raise Error('not all parameters set') + return _wave_params(self._nchannels, self._sampwidth, self._framerate, + self._nframes, self._comptype, self._compname) + + def setmark(self, id, pos, name): + raise Error('setmark() not supported') + + def getmark(self, id): + raise Error('no marks') + + def getmarkers(self): + return None + + def tell(self): + return self._nframeswritten + + def writeframesraw(self, data): + if not isinstance(data, (bytes, bytearray)): + data = memoryview(data).cast('B') + self._ensure_header_written(len(data)) + nframes = len(data) // (self._sampwidth * self._nchannels) + if self._convert: + data = self._convert(data) + if self._sampwidth != 1 and sys.byteorder == 'big': + data = _byteswap(data, self._sampwidth) + self._file.write(data) + self._datawritten += len(data) + self._nframeswritten = self._nframeswritten + nframes + + def writeframes(self, data): + self.writeframesraw(data) + if self._datalength != self._datawritten: + self._patchheader() + + def close(self): + try: + if self._file: + self._ensure_header_written(0) + if self._datalength != self._datawritten: + self._patchheader() + self._file.flush() + finally: + self._file = None + file = self._i_opened_the_file + if file: + self._i_opened_the_file = None + file.close() + + # + # Internal methods. + # + + def _ensure_header_written(self, datasize): + if not self._headerwritten: + if not self._nchannels: + raise Error('# channels not specified') + if not self._sampwidth: + raise Error('sample width not specified') + if not self._framerate: + raise Error('sampling rate not specified') + self._write_header(datasize) + + def _write_header(self, initlength): + assert not self._headerwritten + self._file.write(b'RIFF') + if not self._nframes: + self._nframes = initlength // (self._nchannels * self._sampwidth) + self._datalength = self._nframes * self._nchannels * self._sampwidth + try: + self._form_length_pos = self._file.tell() + except (AttributeError, OSError): + self._form_length_pos = None + self._file.write(struct.pack('" % (self.__class__.__name__, id(self)) + + def __setitem__(self, key, value): + if self._pending_removals: + self._commit_removals() + self.data[key] = KeyedRef(value, self._remove, key) + + def copy(self): + if self._pending_removals: + self._commit_removals() + new = WeakValueDictionary() + with _IterationGuard(self): + for key, wr in self.data.items(): + o = wr() + if o is not None: + new[key] = o + return new + + __copy__ = copy + + def __deepcopy__(self, memo): + from copy import deepcopy + if self._pending_removals: + self._commit_removals() + new = self.__class__() + with _IterationGuard(self): + for key, wr in self.data.items(): + o = wr() + if o is not None: + new[deepcopy(key, memo)] = o + return new + + def get(self, key, default=None): + if self._pending_removals: + self._commit_removals() + try: + wr = self.data[key] + except KeyError: + return default + else: + o = wr() + if o is None: + # This should only happen + return default + else: + return o + + def items(self): + if self._pending_removals: + self._commit_removals() + with _IterationGuard(self): + for k, wr in self.data.items(): + v = wr() + if v is not None: + yield k, v + + def keys(self): + if self._pending_removals: + self._commit_removals() + with _IterationGuard(self): + for k, wr in self.data.items(): + if wr() is not None: + yield k + + __iter__ = keys + + def itervaluerefs(self): + """Return an iterator that yields the weak references to the values. + + The references are not guaranteed to be 'live' at the time + they are used, so the result of calling the references needs + to be checked before being used. This can be used to avoid + creating references that will cause the garbage collector to + keep the values around longer than needed. + + """ + if self._pending_removals: + self._commit_removals() + with _IterationGuard(self): + yield from self.data.values() + + def values(self): + if self._pending_removals: + self._commit_removals() + with _IterationGuard(self): + for wr in self.data.values(): + obj = wr() + if obj is not None: + yield obj + + def popitem(self): + if self._pending_removals: + self._commit_removals() + while True: + key, wr = self.data.popitem() + o = wr() + if o is not None: + return key, o + + def pop(self, key, *args): + if self._pending_removals: + self._commit_removals() + try: + o = self.data.pop(key)() + except KeyError: + o = None + if o is None: + if args: + return args[0] + else: + raise KeyError(key) + else: + return o + + def setdefault(self, key, default=None): + try: + o = self.data[key]() + except KeyError: + o = None + if o is None: + if self._pending_removals: + self._commit_removals() + self.data[key] = KeyedRef(default, self._remove, key) + return default + else: + return o + + def update(self, other=None, /, **kwargs): + if self._pending_removals: + self._commit_removals() + d = self.data + if other is not None: + if not hasattr(other, "items"): + other = dict(other) + for key, o in other.items(): + d[key] = KeyedRef(o, self._remove, key) + for key, o in kwargs.items(): + d[key] = KeyedRef(o, self._remove, key) + + def valuerefs(self): + """Return a list of weak references to the values. + + The references are not guaranteed to be 'live' at the time + they are used, so the result of calling the references needs + to be checked before being used. This can be used to avoid + creating references that will cause the garbage collector to + keep the values around longer than needed. + + """ + if self._pending_removals: + self._commit_removals() + return list(self.data.values()) + + def __ior__(self, other): + self.update(other) + return self + + def __or__(self, other): + if isinstance(other, _collections_abc.Mapping): + c = self.copy() + c.update(other) + return c + return NotImplemented + + def __ror__(self, other): + if isinstance(other, _collections_abc.Mapping): + c = self.__class__() + c.update(other) + c.update(self) + return c + return NotImplemented + + +class KeyedRef(ref): + """Specialized reference that includes a key corresponding to the value. + + This is used in the WeakValueDictionary to avoid having to create + a function object for each key stored in the mapping. A shared + callback object can use the 'key' attribute of a KeyedRef instead + of getting a reference to the key from an enclosing scope. + + """ + + __slots__ = "key", + + def __new__(type, ob, callback, key): + self = ref.__new__(type, ob, callback) + self.key = key + return self + + def __init__(self, ob, callback, key): + super().__init__(ob, callback) + + +class WeakKeyDictionary(_collections_abc.MutableMapping): + """ Mapping class that references keys weakly. + + Entries in the dictionary will be discarded when there is no + longer a strong reference to the key. This can be used to + associate additional data with an object owned by other parts of + an application without adding attributes to those objects. This + can be especially useful with objects that override attribute + accesses. + """ + + def __init__(self, dict=None): + self.data = {} + def remove(k, selfref=ref(self)): + self = selfref() + if self is not None: + if self._iterating: + self._pending_removals.append(k) + else: + try: + del self.data[k] + except KeyError: + pass + self._remove = remove + # A list of dead weakrefs (keys to be removed) + self._pending_removals = [] + self._iterating = set() + self._dirty_len = False + if dict is not None: + self.update(dict) + + def _commit_removals(self): + # NOTE: We don't need to call this method before mutating the dict, + # because a dead weakref never compares equal to a live weakref, + # even if they happened to refer to equal objects. + # However, it means keys may already have been removed. + pop = self._pending_removals.pop + d = self.data + while True: + try: + key = pop() + except IndexError: + return + + try: + del d[key] + except KeyError: + pass + + def _scrub_removals(self): + d = self.data + self._pending_removals = [k for k in self._pending_removals if k in d] + self._dirty_len = False + + def __delitem__(self, key): + self._dirty_len = True + del self.data[ref(key)] + + def __getitem__(self, key): + return self.data[ref(key)] + + def __len__(self): + if self._dirty_len and self._pending_removals: + # self._pending_removals may still contain keys which were + # explicitly removed, we have to scrub them (see issue #21173). + self._scrub_removals() + return len(self.data) - len(self._pending_removals) + + def __repr__(self): + return "<%s at %#x>" % (self.__class__.__name__, id(self)) + + def __setitem__(self, key, value): + self.data[ref(key, self._remove)] = value + + def copy(self): + new = WeakKeyDictionary() + with _IterationGuard(self): + for key, value in self.data.items(): + o = key() + if o is not None: + new[o] = value + return new + + __copy__ = copy + + def __deepcopy__(self, memo): + from copy import deepcopy + new = self.__class__() + with _IterationGuard(self): + for key, value in self.data.items(): + o = key() + if o is not None: + new[o] = deepcopy(value, memo) + return new + + def get(self, key, default=None): + return self.data.get(ref(key),default) + + def __contains__(self, key): + try: + wr = ref(key) + except TypeError: + return False + return wr in self.data + + def items(self): + with _IterationGuard(self): + for wr, value in self.data.items(): + key = wr() + if key is not None: + yield key, value + + def keys(self): + with _IterationGuard(self): + for wr in self.data: + obj = wr() + if obj is not None: + yield obj + + __iter__ = keys + + def values(self): + with _IterationGuard(self): + for wr, value in self.data.items(): + if wr() is not None: + yield value + + def keyrefs(self): + """Return a list of weak references to the keys. + + The references are not guaranteed to be 'live' at the time + they are used, so the result of calling the references needs + to be checked before being used. This can be used to avoid + creating references that will cause the garbage collector to + keep the keys around longer than needed. + + """ + return list(self.data) + + def popitem(self): + self._dirty_len = True + while True: + key, value = self.data.popitem() + o = key() + if o is not None: + return o, value + + def pop(self, key, *args): + self._dirty_len = True + return self.data.pop(ref(key), *args) + + def setdefault(self, key, default=None): + return self.data.setdefault(ref(key, self._remove),default) + + def update(self, dict=None, /, **kwargs): + d = self.data + if dict is not None: + if not hasattr(dict, "items"): + dict = type({})(dict) + for key, value in dict.items(): + d[ref(key, self._remove)] = value + if len(kwargs): + self.update(kwargs) + + def __ior__(self, other): + self.update(other) + return self + + def __or__(self, other): + if isinstance(other, _collections_abc.Mapping): + c = self.copy() + c.update(other) + return c + return NotImplemented + + def __ror__(self, other): + if isinstance(other, _collections_abc.Mapping): + c = self.__class__() + c.update(other) + c.update(self) + return c + return NotImplemented + + +class finalize: + """Class for finalization of weakrefable objects + + finalize(obj, func, *args, **kwargs) returns a callable finalizer + object which will be called when obj is garbage collected. The + first time the finalizer is called it evaluates func(*arg, **kwargs) + and returns the result. After this the finalizer is dead, and + calling it just returns None. + + When the program exits any remaining finalizers for which the + atexit attribute is true will be run in reverse order of creation. + By default atexit is true. + """ + + # Finalizer objects don't have any state of their own. They are + # just used as keys to lookup _Info objects in the registry. This + # ensures that they cannot be part of a ref-cycle. + + __slots__ = () + _registry = {} + _shutdown = False + _index_iter = itertools.count() + _dirty = False + _registered_with_atexit = False + + class _Info: + __slots__ = ("weakref", "func", "args", "kwargs", "atexit", "index") + + def __init__(self, obj, func, /, *args, **kwargs): + if not self._registered_with_atexit: + # We may register the exit function more than once because + # of a thread race, but that is harmless + import atexit + atexit.register(self._exitfunc) + finalize._registered_with_atexit = True + info = self._Info() + info.weakref = ref(obj, self) + info.func = func + info.args = args + info.kwargs = kwargs or None + info.atexit = True + info.index = next(self._index_iter) + self._registry[self] = info + finalize._dirty = True + + def __call__(self, _=None): + """If alive then mark as dead and return func(*args, **kwargs); + otherwise return None""" + info = self._registry.pop(self, None) + if info and not self._shutdown: + return info.func(*info.args, **(info.kwargs or {})) + + def detach(self): + """If alive then mark as dead and return (obj, func, args, kwargs); + otherwise return None""" + info = self._registry.get(self) + obj = info and info.weakref() + if obj is not None and self._registry.pop(self, None): + return (obj, info.func, info.args, info.kwargs or {}) + + def peek(self): + """If alive then return (obj, func, args, kwargs); + otherwise return None""" + info = self._registry.get(self) + obj = info and info.weakref() + if obj is not None: + return (obj, info.func, info.args, info.kwargs or {}) + + @property + def alive(self): + """Whether finalizer is alive""" + return self in self._registry + + @property + def atexit(self): + """Whether finalizer should be called at exit""" + info = self._registry.get(self) + return bool(info) and info.atexit + + @atexit.setter + def atexit(self, value): + info = self._registry.get(self) + if info: + info.atexit = bool(value) + + def __repr__(self): + info = self._registry.get(self) + obj = info and info.weakref() + if obj is None: + return '<%s object at %#x; dead>' % (type(self).__name__, id(self)) + else: + return '<%s object at %#x; for %r at %#x>' % \ + (type(self).__name__, id(self), type(obj).__name__, id(obj)) + + @classmethod + def _select_for_exit(cls): + # Return live finalizers marked for exit, oldest first + L = [(f,i) for (f,i) in cls._registry.items() if i.atexit] + L.sort(key=lambda item:item[1].index) + return [f for (f,i) in L] + + @classmethod + def _exitfunc(cls): + # At shutdown invoke finalizers for which atexit is true. + # This is called once all other non-daemonic threads have been + # joined. + reenable_gc = False + try: + if cls._registry: + import gc + if gc.isenabled(): + reenable_gc = True + gc.disable() + pending = None + while True: + if pending is None or finalize._dirty: + pending = cls._select_for_exit() + finalize._dirty = False + if not pending: + break + f = pending.pop() + try: + # gc is disabled, so (assuming no daemonic + # threads) the following is the only line in + # this function which might trigger creation + # of a new finalizer + f() + except Exception: + sys.excepthook(*sys.exc_info()) + assert f not in cls._registry + finally: + # prevent any more finalizers from executing during shutdown + finalize._shutdown = True + if reenable_gc: + gc.enable() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/webbrowser.py b/physworld_p1_20261018/envs/p1/lib/python3.11/webbrowser.py new file mode 100644 index 0000000000000000000000000000000000000000..9819a4ecf6d43e8854a8da42f6cd55a4d41286c6 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/webbrowser.py @@ -0,0 +1,751 @@ +#! /usr/bin/env python3 +"""Interfaces for launching and remotely controlling web browsers.""" +# Maintained by Georg Brandl. + +import os +import shlex +import shutil +import sys +import subprocess +import threading +import warnings + +__all__ = ["Error", "open", "open_new", "open_new_tab", "get", "register"] + +class Error(Exception): + pass + +_lock = threading.RLock() +_browsers = {} # Dictionary of available browser controllers +_tryorder = None # Preference order of available browsers +_os_preferred_browser = None # The preferred browser + +def register(name, klass, instance=None, *, preferred=False): + """Register a browser connector.""" + with _lock: + if _tryorder is None: + register_standard_browsers() + _browsers[name.lower()] = [klass, instance] + + # Preferred browsers go to the front of the list. + # Need to match to the default browser returned by xdg-settings, which + # may be of the form e.g. "firefox.desktop". + if preferred or (_os_preferred_browser and name in _os_preferred_browser): + _tryorder.insert(0, name) + else: + _tryorder.append(name) + +def get(using=None): + """Return a browser launcher instance appropriate for the environment.""" + if _tryorder is None: + with _lock: + if _tryorder is None: + register_standard_browsers() + if using is not None: + alternatives = [using] + else: + alternatives = _tryorder + for browser in alternatives: + if '%s' in browser: + # User gave us a command line, split it into name and args + browser = shlex.split(browser) + if browser[-1] == '&': + return BackgroundBrowser(browser[:-1]) + else: + return GenericBrowser(browser) + else: + # User gave us a browser name or path. + try: + command = _browsers[browser.lower()] + except KeyError: + command = _synthesize(browser) + if command[1] is not None: + return command[1] + elif command[0] is not None: + return command[0]() + raise Error("could not locate runnable browser") + +# Please note: the following definition hides a builtin function. +# It is recommended one does "import webbrowser" and uses webbrowser.open(url) +# instead of "from webbrowser import *". + +def open(url, new=0, autoraise=True): + """Display url using the default browser. + + If possible, open url in a location determined by new. + - 0: the same browser window (the default). + - 1: a new browser window. + - 2: a new browser page ("tab"). + If possible, autoraise raises the window (the default) or not. + """ + if _tryorder is None: + with _lock: + if _tryorder is None: + register_standard_browsers() + for name in _tryorder: + browser = get(name) + if browser.open(url, new, autoraise): + return True + return False + +def open_new(url): + """Open url in a new window of the default browser. + + If not possible, then open url in the only browser window. + """ + return open(url, 1) + +def open_new_tab(url): + """Open url in a new page ("tab") of the default browser. + + If not possible, then the behavior becomes equivalent to open_new(). + """ + return open(url, 2) + + +def _synthesize(browser, *, preferred=False): + """Attempt to synthesize a controller based on existing controllers. + + This is useful to create a controller when a user specifies a path to + an entry in the BROWSER environment variable -- we can copy a general + controller to operate using a specific installation of the desired + browser in this way. + + If we can't create a controller in this way, or if there is no + executable for the requested browser, return [None, None]. + + """ + cmd = browser.split()[0] + if not shutil.which(cmd): + return [None, None] + name = os.path.basename(cmd) + try: + command = _browsers[name.lower()] + except KeyError: + return [None, None] + # now attempt to clone to fit the new name: + controller = command[1] + if controller and name.lower() == controller.basename: + import copy + controller = copy.copy(controller) + controller.name = browser + controller.basename = os.path.basename(browser) + register(browser, None, instance=controller, preferred=preferred) + return [None, controller] + return [None, None] + + +# General parent classes + +class BaseBrowser(object): + """Parent class for all browsers. Do not use directly.""" + + args = ['%s'] + + def __init__(self, name=""): + self.name = name + self.basename = name + + def open(self, url, new=0, autoraise=True): + raise NotImplementedError + + def open_new(self, url): + return self.open(url, 1) + + def open_new_tab(self, url): + return self.open(url, 2) + + @staticmethod + def _check_url(url): + """Ensures that the URL is safe to pass to subprocesses as a parameter""" + if url and url.lstrip().startswith("-"): + raise ValueError(f"Invalid URL (leading dash disallowed): {url!r}") + + +class GenericBrowser(BaseBrowser): + """Class for all browsers started with a command + and without remote functionality.""" + + def __init__(self, name): + if isinstance(name, str): + self.name = name + self.args = ["%s"] + else: + # name should be a list with arguments + self.name = name[0] + self.args = name[1:] + self.basename = os.path.basename(self.name) + + def open(self, url, new=0, autoraise=True): + sys.audit("webbrowser.open", url) + self._check_url(url) + cmdline = [self.name] + [arg.replace("%s", url) + for arg in self.args] + try: + if sys.platform[:3] == 'win': + p = subprocess.Popen(cmdline) + else: + p = subprocess.Popen(cmdline, close_fds=True) + return not p.wait() + except OSError: + return False + + +class BackgroundBrowser(GenericBrowser): + """Class for all browsers which are to be started in the + background.""" + + def open(self, url, new=0, autoraise=True): + cmdline = [self.name] + [arg.replace("%s", url) + for arg in self.args] + sys.audit("webbrowser.open", url) + self._check_url(url) + try: + if sys.platform[:3] == 'win': + p = subprocess.Popen(cmdline) + else: + p = subprocess.Popen(cmdline, close_fds=True, + start_new_session=True) + return (p.poll() is None) + except OSError: + return False + + +class UnixBrowser(BaseBrowser): + """Parent class for all Unix browsers with remote functionality.""" + + raise_opts = None + background = False + redirect_stdout = True + # In remote_args, %s will be replaced with the requested URL. %action will + # be replaced depending on the value of 'new' passed to open. + # remote_action is used for new=0 (open). If newwin is not None, it is + # used for new=1 (open_new). If newtab is not None, it is used for + # new=3 (open_new_tab). After both substitutions are made, any empty + # strings in the transformed remote_args list will be removed. + remote_args = ['%action', '%s'] + remote_action = None + remote_action_newwin = None + remote_action_newtab = None + + def _invoke(self, args, remote, autoraise, url=None): + raise_opt = [] + if remote and self.raise_opts: + # use autoraise argument only for remote invocation + autoraise = int(autoraise) + opt = self.raise_opts[autoraise] + if opt: raise_opt = [opt] + + cmdline = [self.name] + raise_opt + args + + if remote or self.background: + inout = subprocess.DEVNULL + else: + # for TTY browsers, we need stdin/out + inout = None + p = subprocess.Popen(cmdline, close_fds=True, stdin=inout, + stdout=(self.redirect_stdout and inout or None), + stderr=inout, start_new_session=True) + if remote: + # wait at most five seconds. If the subprocess is not finished, the + # remote invocation has (hopefully) started a new instance. + try: + rc = p.wait(5) + # if remote call failed, open() will try direct invocation + return not rc + except subprocess.TimeoutExpired: + return True + elif self.background: + if p.poll() is None: + return True + else: + return False + else: + return not p.wait() + + def open(self, url, new=0, autoraise=True): + sys.audit("webbrowser.open", url) + if new == 0: + action = self.remote_action + elif new == 1: + action = self.remote_action_newwin + elif new == 2: + if self.remote_action_newtab is None: + action = self.remote_action_newwin + else: + action = self.remote_action_newtab + else: + raise Error("Bad 'new' parameter to open(); " + + "expected 0, 1, or 2, got %s" % new) + + self._check_url(url.replace("%action", action)) + + args = [arg.replace("%action", action).replace("%s", url) + for arg in self.remote_args] + args = [arg for arg in args if arg] + success = self._invoke(args, True, autoraise, url) + if not success: + # remote invocation failed, try straight way + args = [arg.replace("%s", url) for arg in self.args] + return self._invoke(args, False, False) + else: + return True + + +class Mozilla(UnixBrowser): + """Launcher class for Mozilla browsers.""" + + remote_args = ['%action', '%s'] + remote_action = "" + remote_action_newwin = "-new-window" + remote_action_newtab = "-new-tab" + background = True + + +class Netscape(UnixBrowser): + """Launcher class for Netscape browser.""" + + raise_opts = ["-noraise", "-raise"] + remote_args = ['-remote', 'openURL(%s%action)'] + remote_action = "" + remote_action_newwin = ",new-window" + remote_action_newtab = ",new-tab" + background = True + + +class Galeon(UnixBrowser): + """Launcher class for Galeon/Epiphany browsers.""" + + raise_opts = ["-noraise", ""] + remote_args = ['%action', '%s'] + remote_action = "-n" + remote_action_newwin = "-w" + background = True + + +class Chrome(UnixBrowser): + "Launcher class for Google Chrome browser." + + remote_args = ['%action', '%s'] + remote_action = "" + remote_action_newwin = "--new-window" + remote_action_newtab = "" + background = True + +Chromium = Chrome + + +class Opera(UnixBrowser): + "Launcher class for Opera browser." + + remote_args = ['%action', '%s'] + remote_action = "" + remote_action_newwin = "--new-window" + remote_action_newtab = "" + background = True + + +class Elinks(UnixBrowser): + "Launcher class for Elinks browsers." + + remote_args = ['-remote', 'openURL(%s%action)'] + remote_action = "" + remote_action_newwin = ",new-window" + remote_action_newtab = ",new-tab" + background = False + + # elinks doesn't like its stdout to be redirected - + # it uses redirected stdout as a signal to do -dump + redirect_stdout = False + + +class Konqueror(BaseBrowser): + """Controller for the KDE File Manager (kfm, or Konqueror). + + See the output of ``kfmclient --commands`` + for more information on the Konqueror remote-control interface. + """ + + def open(self, url, new=0, autoraise=True): + sys.audit("webbrowser.open", url) + self._check_url(url) + # XXX Currently I know no way to prevent KFM from opening a new win. + if new == 2: + action = "newTab" + else: + action = "openURL" + + devnull = subprocess.DEVNULL + + try: + p = subprocess.Popen(["kfmclient", action, url], + close_fds=True, stdin=devnull, + stdout=devnull, stderr=devnull) + except OSError: + # fall through to next variant + pass + else: + p.wait() + # kfmclient's return code unfortunately has no meaning as it seems + return True + + try: + p = subprocess.Popen(["konqueror", "--silent", url], + close_fds=True, stdin=devnull, + stdout=devnull, stderr=devnull, + start_new_session=True) + except OSError: + # fall through to next variant + pass + else: + if p.poll() is None: + # Should be running now. + return True + + try: + p = subprocess.Popen(["kfm", "-d", url], + close_fds=True, stdin=devnull, + stdout=devnull, stderr=devnull, + start_new_session=True) + except OSError: + return False + else: + return (p.poll() is None) + + +class Grail(BaseBrowser): + # There should be a way to maintain a connection to Grail, but the + # Grail remote control protocol doesn't really allow that at this + # point. It probably never will! + def _find_grail_rc(self): + import glob + import pwd + import socket + import tempfile + tempdir = os.path.join(tempfile.gettempdir(), + ".grail-unix") + user = pwd.getpwuid(os.getuid())[0] + filename = os.path.join(glob.escape(tempdir), glob.escape(user) + "-*") + maybes = glob.glob(filename) + if not maybes: + return None + s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + for fn in maybes: + # need to PING each one until we find one that's live + try: + s.connect(fn) + except OSError: + # no good; attempt to clean it out, but don't fail: + try: + os.unlink(fn) + except OSError: + pass + else: + return s + + def _remote(self, action): + s = self._find_grail_rc() + if not s: + return 0 + s.send(action) + s.close() + return 1 + + def open(self, url, new=0, autoraise=True): + sys.audit("webbrowser.open", url) + self._check_url(url) + if new: + ok = self._remote("LOADNEW " + url) + else: + ok = self._remote("LOAD " + url) + return ok + + +# +# Platform support for Unix +# + +# These are the right tests because all these Unix browsers require either +# a console terminal or an X display to run. + +def register_X_browsers(): + + # use xdg-open if around + if shutil.which("xdg-open"): + register("xdg-open", None, BackgroundBrowser("xdg-open")) + + # Opens an appropriate browser for the URL scheme according to + # freedesktop.org settings (GNOME, KDE, XFCE, etc.) + if shutil.which("gio"): + register("gio", None, BackgroundBrowser(["gio", "open", "--", "%s"])) + + # Equivalent of gio open before 2015 + if "GNOME_DESKTOP_SESSION_ID" in os.environ and shutil.which("gvfs-open"): + register("gvfs-open", None, BackgroundBrowser("gvfs-open")) + + # The default KDE browser + if "KDE_FULL_SESSION" in os.environ and shutil.which("kfmclient"): + register("kfmclient", Konqueror, Konqueror("kfmclient")) + + if shutil.which("x-www-browser"): + register("x-www-browser", None, BackgroundBrowser("x-www-browser")) + + # The Mozilla browsers + for browser in ("firefox", "iceweasel", "iceape", "seamonkey"): + if shutil.which(browser): + register(browser, None, Mozilla(browser)) + + # The Netscape and old Mozilla browsers + for browser in ("mozilla-firefox", + "mozilla-firebird", "firebird", + "mozilla", "netscape"): + if shutil.which(browser): + register(browser, None, Netscape(browser)) + + # Konqueror/kfm, the KDE browser. + if shutil.which("kfm"): + register("kfm", Konqueror, Konqueror("kfm")) + elif shutil.which("konqueror"): + register("konqueror", Konqueror, Konqueror("konqueror")) + + # Gnome's Galeon and Epiphany + for browser in ("galeon", "epiphany"): + if shutil.which(browser): + register(browser, None, Galeon(browser)) + + # Skipstone, another Gtk/Mozilla based browser + if shutil.which("skipstone"): + register("skipstone", None, BackgroundBrowser("skipstone")) + + # Google Chrome/Chromium browsers + for browser in ("google-chrome", "chrome", "chromium", "chromium-browser"): + if shutil.which(browser): + register(browser, None, Chrome(browser)) + + # Opera, quite popular + if shutil.which("opera"): + register("opera", None, Opera("opera")) + + # Next, Mosaic -- old but still in use. + if shutil.which("mosaic"): + register("mosaic", None, BackgroundBrowser("mosaic")) + + # Grail, the Python browser. Does anybody still use it? + if shutil.which("grail"): + register("grail", Grail, None) + +def register_standard_browsers(): + global _tryorder + _tryorder = [] + + if sys.platform == 'darwin': + register("MacOSX", None, MacOSXOSAScript('default')) + register("chrome", None, MacOSXOSAScript('chrome')) + register("firefox", None, MacOSXOSAScript('firefox')) + register("safari", None, MacOSXOSAScript('safari')) + # OS X can use below Unix support (but we prefer using the OS X + # specific stuff) + + if sys.platform == "serenityos": + # SerenityOS webbrowser, simply called "Browser". + register("Browser", None, BackgroundBrowser("Browser")) + + if sys.platform[:3] == "win": + # First try to use the default Windows browser + register("windows-default", WindowsDefault) + + # Detect some common Windows browsers, fallback to IE + iexplore = os.path.join(os.environ.get("PROGRAMFILES", "C:\\Program Files"), + "Internet Explorer\\IEXPLORE.EXE") + for browser in ("firefox", "firebird", "seamonkey", "mozilla", + "netscape", "opera", iexplore): + if shutil.which(browser): + register(browser, None, BackgroundBrowser(browser)) + else: + # Prefer X browsers if present + if os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY"): + try: + cmd = "xdg-settings get default-web-browser".split() + raw_result = subprocess.check_output(cmd, stderr=subprocess.DEVNULL) + result = raw_result.decode().strip() + except (FileNotFoundError, subprocess.CalledProcessError, PermissionError, NotADirectoryError) : + pass + else: + global _os_preferred_browser + _os_preferred_browser = result + + register_X_browsers() + + # Also try console browsers + if os.environ.get("TERM"): + if shutil.which("www-browser"): + register("www-browser", None, GenericBrowser("www-browser")) + # The Links/elinks browsers + if shutil.which("links"): + register("links", None, GenericBrowser("links")) + if shutil.which("elinks"): + register("elinks", None, Elinks("elinks")) + # The Lynx browser , + if shutil.which("lynx"): + register("lynx", None, GenericBrowser("lynx")) + # The w3m browser + if shutil.which("w3m"): + register("w3m", None, GenericBrowser("w3m")) + + # OK, now that we know what the default preference orders for each + # platform are, allow user to override them with the BROWSER variable. + if "BROWSER" in os.environ: + userchoices = os.environ["BROWSER"].split(os.pathsep) + userchoices.reverse() + + # Treat choices in same way as if passed into get() but do register + # and prepend to _tryorder + for cmdline in userchoices: + if cmdline != '': + cmd = _synthesize(cmdline, preferred=True) + if cmd[1] is None: + register(cmdline, None, GenericBrowser(cmdline), preferred=True) + + # what to do if _tryorder is now empty? + + +# +# Platform support for Windows +# + +if sys.platform[:3] == "win": + class WindowsDefault(BaseBrowser): + def open(self, url, new=0, autoraise=True): + sys.audit("webbrowser.open", url) + self._check_url(url) + try: + os.startfile(url) + except OSError: + # [Error 22] No application is associated with the specified + # file for this operation: '' + return False + else: + return True + +# +# Platform support for MacOS +# + +if sys.platform == 'darwin': + # Adapted from patch submitted to SourceForge by Steven J. Burr + class MacOSX(BaseBrowser): + """Launcher class for Aqua browsers on Mac OS X + + Optionally specify a browser name on instantiation. Note that this + will not work for Aqua browsers if the user has moved the application + package after installation. + + If no browser is specified, the default browser, as specified in the + Internet System Preferences panel, will be used. + """ + def __init__(self, name): + warnings.warn(f'{self.__class__.__name__} is deprecated in 3.11' + ' use MacOSXOSAScript instead.', DeprecationWarning, stacklevel=2) + self.name = name + + def open(self, url, new=0, autoraise=True): + sys.audit("webbrowser.open", url) + self._check_url(url) + assert "'" not in url + # hack for local urls + if not ':' in url: + url = 'file:'+url + + # new must be 0 or 1 + new = int(bool(new)) + if self.name == "default": + # User called open, open_new or get without a browser parameter + script = 'open location "%s"' % url.replace('"', '%22') # opens in default browser + else: + # User called get and chose a browser + if self.name == "OmniWeb": + toWindow = "" + else: + # Include toWindow parameter of OpenURL command for browsers + # that support it. 0 == new window; -1 == existing + toWindow = "toWindow %d" % (new - 1) + cmd = 'OpenURL "%s"' % url.replace('"', '%22') + script = '''tell application "%s" + activate + %s %s + end tell''' % (self.name, cmd, toWindow) + # Open pipe to AppleScript through osascript command + osapipe = os.popen("osascript", "w") + if osapipe is None: + return False + # Write script to osascript's stdin + osapipe.write(script) + rc = osapipe.close() + return not rc + + class MacOSXOSAScript(BaseBrowser): + def __init__(self, name='default'): + super().__init__(name) + + @property + def _name(self): + warnings.warn(f'{self.__class__.__name__}._name is deprecated in 3.11' + f' use {self.__class__.__name__}.name instead.', + DeprecationWarning, stacklevel=2) + return self.name + + @_name.setter + def _name(self, val): + warnings.warn(f'{self.__class__.__name__}._name is deprecated in 3.11' + f' use {self.__class__.__name__}.name instead.', + DeprecationWarning, stacklevel=2) + self.name = val + + def open(self, url, new=0, autoraise=True): + sys.audit("webbrowser.open", url) + self._check_url(url) + if self.name == 'default': + script = 'open location "%s"' % url.replace('"', '%22') # opens in default browser + else: + script = f''' + tell application "%s" + activate + open location "%s" + end + '''%(self.name, url.replace('"', '%22')) + + osapipe = os.popen("/usr/bin/osascript", "w") + if osapipe is None: + return False + + osapipe.write(script) + rc = osapipe.close() + return not rc + + +def main(): + import getopt + usage = """Usage: %s [-n | -t] url + -n: open new window + -t: open new tab""" % sys.argv[0] + try: + opts, args = getopt.getopt(sys.argv[1:], 'ntd') + except getopt.error as msg: + print(msg, file=sys.stderr) + print(usage, file=sys.stderr) + sys.exit(1) + new_win = 0 + for o, a in opts: + if o == '-n': new_win = 1 + elif o == '-t': new_win = 2 + if len(args) != 1: + print(usage, file=sys.stderr) + sys.exit(1) + + url = args[0] + open(url, new_win) + + print("\a") + +if __name__ == "__main__": + main() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..59ee48fddec232b485a3559f7ccc80585616dfd7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__init__.py @@ -0,0 +1,25 @@ +"""wsgiref -- a WSGI (PEP 3333) Reference Library + +Current Contents: + +* util -- Miscellaneous useful functions and wrappers + +* headers -- Manage response headers + +* handlers -- base classes for server/gateway implementations + +* simple_server -- a simple BaseHTTPServer that supports WSGI + +* validate -- validation wrapper that sits between an app and a server + to detect errors in either + +* types -- collection of WSGI-related types for static type checking + +To-Do: + +* cgi_gateway -- Run WSGI apps under CGI (pending a deployment standard) + +* cgi_wrapper -- Run CGI apps under WSGI + +* router -- a simple middleware component that handles URL traversal +""" diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5cf5c1dfb27f57c69c61e673aea8eb70a631e196 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/handlers.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/handlers.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a3c709108a26871a538a9661b91d1a47a28bbf47 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/handlers.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/headers.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/headers.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..744b812dc3d74f0fbf5103430b3a5ea9b8a880f3 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/headers.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/simple_server.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/simple_server.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fd46fed58a3d4ce78d36aeaffacf5cb4e4ab6c34 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/simple_server.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/types.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/types.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..52015e43f8744ad3e24186cf8ab345ff8144911f Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/types.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/util.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/util.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7cafc60b4a9bd8461ccf296fa4f3d0ead2fa541c Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/util.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/validate.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/validate.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b5163d32fc97bda131cbd2e46796c3d3306c8cbc Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/__pycache__/validate.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/handlers.py b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/handlers.py new file mode 100644 index 0000000000000000000000000000000000000000..49ffd7bdd55f67ad75e5a266fe6daeec52857ae7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/handlers.py @@ -0,0 +1,572 @@ +"""Base classes for server/gateway implementations""" + +from .util import FileWrapper, guess_scheme, is_hop_by_hop +from .headers import Headers, _name_disallowed_re + +import sys, os, time + +__all__ = [ + 'BaseHandler', 'SimpleHandler', 'BaseCGIHandler', 'CGIHandler', + 'IISCGIHandler', 'read_environ' +] + +# Weekday and month names for HTTP date/time formatting; always English! +_weekdayname = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"] +_monthname = [None, # Dummy so we can use 1-based month numbers + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] + +def format_date_time(timestamp): + year, month, day, hh, mm, ss, wd, y, z = time.gmtime(timestamp) + return "%s, %02d %3s %4d %02d:%02d:%02d GMT" % ( + _weekdayname[wd], day, _monthname[month], year, hh, mm, ss + ) + +_is_request = { + 'SCRIPT_NAME', 'PATH_INFO', 'QUERY_STRING', 'REQUEST_METHOD', 'AUTH_TYPE', + 'CONTENT_TYPE', 'CONTENT_LENGTH', 'HTTPS', 'REMOTE_USER', 'REMOTE_IDENT', +}.__contains__ + +def _needs_transcode(k): + return _is_request(k) or k.startswith('HTTP_') or k.startswith('SSL_') \ + or (k.startswith('REDIRECT_') and _needs_transcode(k[9:])) + +def read_environ(): + """Read environment, fixing HTTP variables""" + enc = sys.getfilesystemencoding() + esc = 'surrogateescape' + try: + ''.encode('utf-8', esc) + except LookupError: + esc = 'replace' + environ = {} + + # Take the basic environment from native-unicode os.environ. Attempt to + # fix up the variables that come from the HTTP request to compensate for + # the bytes->unicode decoding step that will already have taken place. + for k, v in os.environ.items(): + if _needs_transcode(k): + + # On win32, the os.environ is natively Unicode. Different servers + # decode the request bytes using different encodings. + if sys.platform == 'win32': + software = os.environ.get('SERVER_SOFTWARE', '').lower() + + # On IIS, the HTTP request will be decoded as UTF-8 as long + # as the input is a valid UTF-8 sequence. Otherwise it is + # decoded using the system code page (mbcs), with no way to + # detect this has happened. Because UTF-8 is the more likely + # encoding, and mbcs is inherently unreliable (an mbcs string + # that happens to be valid UTF-8 will not be decoded as mbcs) + # always recreate the original bytes as UTF-8. + if software.startswith('microsoft-iis/'): + v = v.encode('utf-8').decode('iso-8859-1') + + # Apache mod_cgi writes bytes-as-unicode (as if ISO-8859-1) direct + # to the Unicode environ. No modification needed. + elif software.startswith('apache/'): + pass + + # Python 3's http.server.CGIHTTPRequestHandler decodes + # using the urllib.unquote default of UTF-8, amongst other + # issues. + elif ( + software.startswith('simplehttp/') + and 'python/3' in software + ): + v = v.encode('utf-8').decode('iso-8859-1') + + # For other servers, guess that they have written bytes to + # the environ using stdio byte-oriented interfaces, ending up + # with the system code page. + else: + v = v.encode(enc, 'replace').decode('iso-8859-1') + + # Recover bytes from unicode environ, using surrogate escapes + # where available (Python 3.1+). + else: + v = v.encode(enc, esc).decode('iso-8859-1') + + environ[k] = v + return environ + + +class BaseHandler: + """Manage the invocation of a WSGI application""" + + # Configuration parameters; can override per-subclass or per-instance + wsgi_version = (1,0) + wsgi_multithread = True + wsgi_multiprocess = True + wsgi_run_once = False + + origin_server = True # We are transmitting direct to client + http_version = "1.0" # Version that should be used for response + server_software = None # String name of server software, if any + + # os_environ is used to supply configuration from the OS environment: + # by default it's a copy of 'os.environ' as of import time, but you can + # override this in e.g. your __init__ method. + os_environ= read_environ() + + # Collaborator classes + wsgi_file_wrapper = FileWrapper # set to None to disable + headers_class = Headers # must be a Headers-like class + + # Error handling (also per-subclass or per-instance) + traceback_limit = None # Print entire traceback to self.get_stderr() + error_status = "500 Internal Server Error" + error_headers = [('Content-Type','text/plain')] + error_body = b"A server error occurred. Please contact the administrator." + + # State variables (don't mess with these) + status = result = None + headers_sent = False + headers = None + bytes_sent = 0 + + def run(self, application): + """Invoke the application""" + # Note to self: don't move the close()! Asynchronous servers shouldn't + # call close() from finish_response(), so if you close() anywhere but + # the double-error branch here, you'll break asynchronous servers by + # prematurely closing. Async servers must return from 'run()' without + # closing if there might still be output to iterate over. + try: + self.setup_environ() + self.result = application(self.environ, self.start_response) + self.finish_response() + except (ConnectionAbortedError, BrokenPipeError, ConnectionResetError): + # We expect the client to close the connection abruptly from time + # to time. + return + except: + try: + self.handle_error() + except: + # If we get an error handling an error, just give up already! + self.close() + raise # ...and let the actual server figure it out. + + + def setup_environ(self): + """Set up the environment for one request""" + + env = self.environ = self.os_environ.copy() + self.add_cgi_vars() + + env['wsgi.input'] = self.get_stdin() + env['wsgi.errors'] = self.get_stderr() + env['wsgi.version'] = self.wsgi_version + env['wsgi.run_once'] = self.wsgi_run_once + env['wsgi.url_scheme'] = self.get_scheme() + env['wsgi.multithread'] = self.wsgi_multithread + env['wsgi.multiprocess'] = self.wsgi_multiprocess + + if self.wsgi_file_wrapper is not None: + env['wsgi.file_wrapper'] = self.wsgi_file_wrapper + + if self.origin_server and self.server_software: + env.setdefault('SERVER_SOFTWARE',self.server_software) + + + def finish_response(self): + """Send any iterable data, then close self and the iterable + + Subclasses intended for use in asynchronous servers will + want to redefine this method, such that it sets up callbacks + in the event loop to iterate over the data, and to call + 'self.close()' once the response is finished. + """ + try: + if not self.result_is_file() or not self.sendfile(): + for data in self.result: + self.write(data) + self.finish_content() + except: + # Call close() on the iterable returned by the WSGI application + # in case of an exception. + if hasattr(self.result, 'close'): + self.result.close() + raise + else: + # We only call close() when no exception is raised, because it + # will set status, result, headers, and environ fields to None. + # See bpo-29183 for more details. + self.close() + + + def get_scheme(self): + """Return the URL scheme being used""" + return guess_scheme(self.environ) + + + def set_content_length(self): + """Compute Content-Length or switch to chunked encoding if possible""" + try: + blocks = len(self.result) + except (TypeError,AttributeError,NotImplementedError): + pass + else: + if blocks==1: + self.headers['Content-Length'] = str(self.bytes_sent) + return + # XXX Try for chunked encoding if origin server and client is 1.1 + + + def cleanup_headers(self): + """Make any necessary header changes or defaults + + Subclasses can extend this to add other defaults. + """ + if 'Content-Length' not in self.headers: + self.set_content_length() + + def start_response(self, status, headers,exc_info=None): + """'start_response()' callable as specified by PEP 3333""" + + if exc_info: + try: + if self.headers_sent: + raise + finally: + exc_info = None # avoid dangling circular ref + elif self.headers is not None: + raise AssertionError("Headers already set!") + + self.status = status + self.headers = self.headers_class(headers) + status = self._convert_string_type(status, "Status") + if _name_disallowed_re.search(status): + raise ValueError("Control characters are not allowed in status") + assert len(status)>=4,"Status must be at least 4 characters" + assert status[:3].isdigit(), "Status message must begin w/3-digit code" + assert status[3]==" ", "Status message must have a space after code" + + if __debug__: + for name, val in headers: + name = self._convert_string_type(name, "Header name") + val = self._convert_string_type(val, "Header value") + assert not is_hop_by_hop(name),\ + f"Hop-by-hop header, '{name}: {val}', not allowed" + + return self.write + + def _convert_string_type(self, value, title): + """Convert/check value type.""" + if type(value) is str: + return value + raise AssertionError( + "{0} must be of type str (got {1})".format(title, repr(value)) + ) + + def send_preamble(self): + """Transmit version/status/date/server, via self._write()""" + if self.origin_server: + if self.client_is_modern(): + self._write(('HTTP/%s %s\r\n' % (self.http_version,self.status)).encode('iso-8859-1')) + if 'Date' not in self.headers: + self._write( + ('Date: %s\r\n' % format_date_time(time.time())).encode('iso-8859-1') + ) + if self.server_software and 'Server' not in self.headers: + self._write(('Server: %s\r\n' % self.server_software).encode('iso-8859-1')) + else: + self._write(('Status: %s\r\n' % self.status).encode('iso-8859-1')) + + def write(self, data): + """'write()' callable as specified by PEP 3333""" + + assert type(data) is bytes, \ + "write() argument must be a bytes instance" + + if not self.status: + raise AssertionError("write() before start_response()") + + elif not self.headers_sent: + # Before the first output, send the stored headers + self.bytes_sent = len(data) # make sure we know content-length + self.send_headers() + else: + self.bytes_sent += len(data) + + # XXX check Content-Length and truncate if too many bytes written? + self._write(data) + self._flush() + + + def sendfile(self): + """Platform-specific file transmission + + Override this method in subclasses to support platform-specific + file transmission. It is only called if the application's + return iterable ('self.result') is an instance of + 'self.wsgi_file_wrapper'. + + This method should return a true value if it was able to actually + transmit the wrapped file-like object using a platform-specific + approach. It should return a false value if normal iteration + should be used instead. An exception can be raised to indicate + that transmission was attempted, but failed. + + NOTE: this method should call 'self.send_headers()' if + 'self.headers_sent' is false and it is going to attempt direct + transmission of the file. + """ + return False # No platform-specific transmission by default + + + def finish_content(self): + """Ensure headers and content have both been sent""" + if not self.headers_sent: + # Only zero Content-Length if not set by the application (so + # that HEAD requests can be satisfied properly, see #3839) + self.headers.setdefault('Content-Length', "0") + self.send_headers() + else: + pass # XXX check if content-length was too short? + + def close(self): + """Close the iterable (if needed) and reset all instance vars + + Subclasses may want to also drop the client connection. + """ + try: + if hasattr(self.result,'close'): + self.result.close() + finally: + self.result = self.headers = self.status = self.environ = None + self.bytes_sent = 0; self.headers_sent = False + + + def send_headers(self): + """Transmit headers to the client, via self._write()""" + self.cleanup_headers() + self.headers_sent = True + if not self.origin_server or self.client_is_modern(): + self.send_preamble() + self._write(bytes(self.headers)) + + + def result_is_file(self): + """True if 'self.result' is an instance of 'self.wsgi_file_wrapper'""" + wrapper = self.wsgi_file_wrapper + return wrapper is not None and isinstance(self.result,wrapper) + + + def client_is_modern(self): + """True if client can accept status and headers""" + return self.environ['SERVER_PROTOCOL'].upper() != 'HTTP/0.9' + + + def log_exception(self,exc_info): + """Log the 'exc_info' tuple in the server log + + Subclasses may override to retarget the output or change its format. + """ + try: + from traceback import print_exception + stderr = self.get_stderr() + print_exception( + exc_info[0], exc_info[1], exc_info[2], + self.traceback_limit, stderr + ) + stderr.flush() + finally: + exc_info = None + + def handle_error(self): + """Log current error, and send error output to client if possible""" + self.log_exception(sys.exc_info()) + if not self.headers_sent: + self.result = self.error_output(self.environ, self.start_response) + self.finish_response() + # XXX else: attempt advanced recovery techniques for HTML or text? + + def error_output(self, environ, start_response): + """WSGI mini-app to create error output + + By default, this just uses the 'error_status', 'error_headers', + and 'error_body' attributes to generate an output page. It can + be overridden in a subclass to dynamically generate diagnostics, + choose an appropriate message for the user's preferred language, etc. + + Note, however, that it's not recommended from a security perspective to + spit out diagnostics to any old user; ideally, you should have to do + something special to enable diagnostic output, which is why we don't + include any here! + """ + start_response(self.error_status,self.error_headers[:],sys.exc_info()) + return [self.error_body] + + + # Pure abstract methods; *must* be overridden in subclasses + + def _write(self,data): + """Override in subclass to buffer data for send to client + + It's okay if this method actually transmits the data; BaseHandler + just separates write and flush operations for greater efficiency + when the underlying system actually has such a distinction. + """ + raise NotImplementedError + + def _flush(self): + """Override in subclass to force sending of recent '_write()' calls + + It's okay if this method is a no-op (i.e., if '_write()' actually + sends the data. + """ + raise NotImplementedError + + def get_stdin(self): + """Override in subclass to return suitable 'wsgi.input'""" + raise NotImplementedError + + def get_stderr(self): + """Override in subclass to return suitable 'wsgi.errors'""" + raise NotImplementedError + + def add_cgi_vars(self): + """Override in subclass to insert CGI variables in 'self.environ'""" + raise NotImplementedError + + +class SimpleHandler(BaseHandler): + """Handler that's just initialized with streams, environment, etc. + + This handler subclass is intended for synchronous HTTP/1.0 origin servers, + and handles sending the entire response output, given the correct inputs. + + Usage:: + + handler = SimpleHandler( + inp,out,err,env, multithread=False, multiprocess=True + ) + handler.run(app)""" + + def __init__(self,stdin,stdout,stderr,environ, + multithread=True, multiprocess=False + ): + self.stdin = stdin + self.stdout = stdout + self.stderr = stderr + self.base_env = environ + self.wsgi_multithread = multithread + self.wsgi_multiprocess = multiprocess + + def get_stdin(self): + return self.stdin + + def get_stderr(self): + return self.stderr + + def add_cgi_vars(self): + self.environ.update(self.base_env) + + def _write(self,data): + result = self.stdout.write(data) + if result is None or result == len(data): + return + from warnings import warn + warn("SimpleHandler.stdout.write() should not do partial writes", + DeprecationWarning) + while True: + data = data[result:] + if not data: + break + result = self.stdout.write(data) + + def _flush(self): + self.stdout.flush() + self._flush = self.stdout.flush + + +class BaseCGIHandler(SimpleHandler): + + """CGI-like systems using input/output/error streams and environ mapping + + Usage:: + + handler = BaseCGIHandler(inp,out,err,env) + handler.run(app) + + This handler class is useful for gateway protocols like ReadyExec and + FastCGI, that have usable input/output/error streams and an environment + mapping. It's also the base class for CGIHandler, which just uses + sys.stdin, os.environ, and so on. + + The constructor also takes keyword arguments 'multithread' and + 'multiprocess' (defaulting to 'True' and 'False' respectively) to control + the configuration sent to the application. It sets 'origin_server' to + False (to enable CGI-like output), and assumes that 'wsgi.run_once' is + False. + """ + + origin_server = False + + +class CGIHandler(BaseCGIHandler): + + """CGI-based invocation via sys.stdin/stdout/stderr and os.environ + + Usage:: + + CGIHandler().run(app) + + The difference between this class and BaseCGIHandler is that it always + uses 'wsgi.run_once' of 'True', 'wsgi.multithread' of 'False', and + 'wsgi.multiprocess' of 'True'. It does not take any initialization + parameters, but always uses 'sys.stdin', 'os.environ', and friends. + + If you need to override any of these parameters, use BaseCGIHandler + instead. + """ + + wsgi_run_once = True + # Do not allow os.environ to leak between requests in Google App Engine + # and other multi-run CGI use cases. This is not easily testable. + # See http://bugs.python.org/issue7250 + os_environ = {} + + def __init__(self): + BaseCGIHandler.__init__( + self, sys.stdin.buffer, sys.stdout.buffer, sys.stderr, + read_environ(), multithread=False, multiprocess=True + ) + + +class IISCGIHandler(BaseCGIHandler): + """CGI-based invocation with workaround for IIS path bug + + This handler should be used in preference to CGIHandler when deploying on + Microsoft IIS without having set the config allowPathInfo option (IIS>=7) + or metabase allowPathInfoForScriptMappings (IIS<7). + """ + wsgi_run_once = True + os_environ = {} + + # By default, IIS gives a PATH_INFO that duplicates the SCRIPT_NAME at + # the front, causing problems for WSGI applications that wish to implement + # routing. This handler strips any such duplicated path. + + # IIS can be configured to pass the correct PATH_INFO, but this causes + # another bug where PATH_TRANSLATED is wrong. Luckily this variable is + # rarely used and is not guaranteed by WSGI. On IIS<7, though, the + # setting can only be made on a vhost level, affecting all other script + # mappings, many of which break when exposed to the PATH_TRANSLATED bug. + # For this reason IIS<7 is almost never deployed with the fix. (Even IIS7 + # rarely uses it because there is still no UI for it.) + + # There is no way for CGI code to tell whether the option was set, so a + # separate handler class is provided. + def __init__(self): + environ= read_environ() + path = environ.get('PATH_INFO', '') + script = environ.get('SCRIPT_NAME', '') + if (path+'/').startswith(script+'/'): + environ['PATH_INFO'] = path[len(script):] + BaseCGIHandler.__init__( + self, sys.stdin.buffer, sys.stdout.buffer, sys.stderr, + environ, multithread=False, multiprocess=True + ) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/headers.py b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/headers.py new file mode 100644 index 0000000000000000000000000000000000000000..17559b0a37bd201bb9c3872fc9cc4a6c4163f0d7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/headers.py @@ -0,0 +1,192 @@ +"""Manage HTTP Response Headers + +Much of this module is red-handedly pilfered from email.message in the stdlib, +so portions are Copyright (C) 2001,2002 Python Software Foundation, and were +written by Barry Warsaw. +""" + +# Regular expression that matches `special' characters in parameters, the +# existence of which force quoting of the parameter value. +import re +tspecials = re.compile(r'[ \(\)<>@,;:\\"/\[\]\?=]') +# Disallowed characters for headers and values. +# HTAB (\x09) is allowed in header values, but +# not in header names. (RFC 9110 Section 5.5) +_name_disallowed_re = re.compile(r'[\x00-\x1F\x7F]') +_value_disallowed_re = re.compile(r'[\x00-\x08\x0A-\x1F\x7F]') + +def _formatparam(param, value=None, quote=1): + """Convenience function to format and return a key=value pair. + + This will quote the value if needed or if quote is true. + """ + if value is not None and len(value) > 0: + if quote or tspecials.search(value): + value = value.replace('\\', '\\\\').replace('"', r'\"') + return '%s="%s"' % (param, value) + else: + return '%s=%s' % (param, value) + else: + return param + + +class Headers: + """Manage a collection of HTTP response headers""" + + def __init__(self, headers=None): + headers = headers if headers is not None else [] + if type(headers) is not list: + raise TypeError("Headers must be a list of name/value tuples") + self._headers = headers + if __debug__: + for k, v in headers: + self._convert_string_type(k, name=True) + self._convert_string_type(v, name=False) + + def _convert_string_type(self, value, *, name): + """Convert/check value type.""" + if type(value) is str: + regex = (_name_disallowed_re if name else _value_disallowed_re) + if regex.search(value): + raise ValueError("Control characters not allowed in headers") + return value + raise AssertionError("Header names/values must be" + " of type str (got {0})".format(repr(value))) + + def __len__(self): + """Return the total number of headers, including duplicates.""" + return len(self._headers) + + def __setitem__(self, name, val): + """Set the value of a header.""" + del self[name] + self._headers.append( + (self._convert_string_type(name, name=True), self._convert_string_type(val, name=False))) + + def __delitem__(self,name): + """Delete all occurrences of a header, if present. + + Does *not* raise an exception if the header is missing. + """ + name = self._convert_string_type(name.lower(), name=True) + self._headers[:] = [kv for kv in self._headers if kv[0].lower() != name] + + def __getitem__(self,name): + """Get the first header value for 'name' + + Return None if the header is missing instead of raising an exception. + + Note that if the header appeared multiple times, the first exactly which + occurrence gets returned is undefined. Use getall() to get all + the values matching a header field name. + """ + return self.get(name) + + def __contains__(self, name): + """Return true if the message contains the header.""" + return self.get(name) is not None + + + def get_all(self, name): + """Return a list of all the values for the named field. + + These will be sorted in the order they appeared in the original header + list or were added to this instance, and may contain duplicates. Any + fields deleted and re-inserted are always appended to the header list. + If no fields exist with the given name, returns an empty list. + """ + name = self._convert_string_type(name.lower(), name=True) + return [kv[1] for kv in self._headers if kv[0].lower()==name] + + + def get(self,name,default=None): + """Get the first header value for 'name', or return 'default'""" + name = self._convert_string_type(name.lower(), name=True) + for k,v in self._headers: + if k.lower()==name: + return v + return default + + + def keys(self): + """Return a list of all the header field names. + + These will be sorted in the order they appeared in the original header + list, or were added to this instance, and may contain duplicates. + Any fields deleted and re-inserted are always appended to the header + list. + """ + return [k for k, v in self._headers] + + def values(self): + """Return a list of all header values. + + These will be sorted in the order they appeared in the original header + list, or were added to this instance, and may contain duplicates. + Any fields deleted and re-inserted are always appended to the header + list. + """ + return [v for k, v in self._headers] + + def items(self): + """Get all the header fields and values. + + These will be sorted in the order they were in the original header + list, or were added to this instance, and may contain duplicates. + Any fields deleted and re-inserted are always appended to the header + list. + """ + return self._headers[:] + + def __repr__(self): + return "%s(%r)" % (self.__class__.__name__, self._headers) + + def __str__(self): + """str() returns the formatted headers, complete with end line, + suitable for direct HTTP transmission.""" + return '\r\n'.join(["%s: %s" % kv for kv in self._headers]+['','']) + + def __bytes__(self): + return str(self).encode('iso-8859-1') + + def setdefault(self,name,value): + """Return first matching header value for 'name', or 'value' + + If there is no header named 'name', add a new header with name 'name' + and value 'value'.""" + result = self.get(name) + if result is None: + self._headers.append((self._convert_string_type(name, name=True), + self._convert_string_type(value, name=False))) + return value + else: + return result + + def add_header(self, _name, _value, **_params): + """Extended header setting. + + _name is the header field to add. keyword arguments can be used to set + additional parameters for the header field, with underscores converted + to dashes. Normally the parameter will be added as key="value" unless + value is None, in which case only the key will be added. + + Example: + + h.add_header('content-disposition', 'attachment', filename='bud.gif') + + Note that unlike the corresponding 'email.message' method, this does + *not* handle '(charset, language, value)' tuples: all values must be + strings or None. + """ + parts = [] + if _value is not None: + _value = self._convert_string_type(_value, name=False) + parts.append(_value) + for k, v in _params.items(): + k = self._convert_string_type(k, name=True) + if v is None: + parts.append(k.replace('_', '-')) + else: + v = self._convert_string_type(v, name=False) + parts.append(_formatparam(k.replace('_', '-'), v)) + self._headers.append((self._convert_string_type(_name, name=True), "; ".join(parts))) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/simple_server.py b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/simple_server.py new file mode 100644 index 0000000000000000000000000000000000000000..93d01a863adf59e4dcf2e23d65e025526c273e6e --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/simple_server.py @@ -0,0 +1,165 @@ +"""BaseHTTPServer that implements the Python WSGI protocol (PEP 3333) + +This is both an example of how WSGI can be implemented, and a basis for running +simple web applications on a local machine, such as might be done when testing +or debugging an application. It has not been reviewed for security issues, +however, and we strongly recommend that you use a "real" web server for +production use. + +For example usage, see the 'if __name__=="__main__"' block at the end of the +module. See also the BaseHTTPServer module docs for other API information. +""" + +from http.server import BaseHTTPRequestHandler, HTTPServer +import sys +import urllib.parse +from wsgiref.handlers import SimpleHandler +from platform import python_implementation + +__version__ = "0.2" +__all__ = ['WSGIServer', 'WSGIRequestHandler', 'demo_app', 'make_server'] + + +server_version = "WSGIServer/" + __version__ +sys_version = python_implementation() + "/" + sys.version.split()[0] +software_version = server_version + ' ' + sys_version + + +class ServerHandler(SimpleHandler): + + server_software = software_version + + def close(self): + try: + self.request_handler.log_request( + self.status.split(' ',1)[0], self.bytes_sent + ) + finally: + SimpleHandler.close(self) + + + +class WSGIServer(HTTPServer): + + """BaseHTTPServer that implements the Python WSGI protocol""" + + application = None + + def server_bind(self): + """Override server_bind to store the server name.""" + HTTPServer.server_bind(self) + self.setup_environ() + + def setup_environ(self): + # Set up base environment + env = self.base_environ = {} + env['SERVER_NAME'] = self.server_name + env['GATEWAY_INTERFACE'] = 'CGI/1.1' + env['SERVER_PORT'] = str(self.server_port) + env['REMOTE_HOST']='' + env['CONTENT_LENGTH']='' + env['SCRIPT_NAME'] = '' + + def get_app(self): + return self.application + + def set_app(self,application): + self.application = application + + + +class WSGIRequestHandler(BaseHTTPRequestHandler): + + server_version = "WSGIServer/" + __version__ + + def get_environ(self): + env = self.server.base_environ.copy() + env['SERVER_PROTOCOL'] = self.request_version + env['SERVER_SOFTWARE'] = self.server_version + env['REQUEST_METHOD'] = self.command + if '?' in self.path: + path,query = self.path.split('?',1) + else: + path,query = self.path,'' + + env['PATH_INFO'] = urllib.parse.unquote(path, 'iso-8859-1') + env['QUERY_STRING'] = query + + host = self.address_string() + if host != self.client_address[0]: + env['REMOTE_HOST'] = host + env['REMOTE_ADDR'] = self.client_address[0] + + if self.headers.get('content-type') is None: + env['CONTENT_TYPE'] = self.headers.get_content_type() + else: + env['CONTENT_TYPE'] = self.headers['content-type'] + + length = self.headers.get('content-length') + if length: + env['CONTENT_LENGTH'] = length + + for k, v in self.headers.items(): + k=k.replace('-','_').upper(); v=v.strip() + if k in env: + continue # skip content length, type,etc. + if 'HTTP_'+k in env: + env['HTTP_'+k] += ','+v # comma-separate multiple headers + else: + env['HTTP_'+k] = v + return env + + def get_stderr(self): + return sys.stderr + + def handle(self): + """Handle a single HTTP request""" + + self.raw_requestline = self.rfile.readline(65537) + if len(self.raw_requestline) > 65536: + self.requestline = '' + self.request_version = '' + self.command = '' + self.send_error(414) + return + + if not self.parse_request(): # An error code has been sent, just exit + return + + handler = ServerHandler( + self.rfile, self.wfile, self.get_stderr(), self.get_environ(), + multithread=False, + ) + handler.request_handler = self # backpointer for logging + handler.run(self.server.get_app()) + + + +def demo_app(environ,start_response): + from io import StringIO + stdout = StringIO() + print("Hello world!", file=stdout) + print(file=stdout) + h = sorted(environ.items()) + for k,v in h: + print(k,'=',repr(v), file=stdout) + start_response("200 OK", [('Content-Type','text/plain; charset=utf-8')]) + return [stdout.getvalue().encode("utf-8")] + + +def make_server( + host, port, app, server_class=WSGIServer, handler_class=WSGIRequestHandler +): + """Create a new WSGI server listening on `host` and `port` for `app`""" + server = server_class((host, port), handler_class) + server.set_app(app) + return server + + +if __name__ == '__main__': + with make_server('', 8000, demo_app) as httpd: + sa = httpd.socket.getsockname() + print("Serving HTTP on", sa[0], "port", sa[1], "...") + import webbrowser + webbrowser.open('http://localhost:8000/xyz?abc') + httpd.handle_request() # serve one request, then exit diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/types.py b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/types.py new file mode 100644 index 0000000000000000000000000000000000000000..ef0aead5b28b647bd1ad49fef80a490fbd2dc1a8 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/types.py @@ -0,0 +1,54 @@ +"""WSGI-related types for static type checking""" + +from collections.abc import Callable, Iterable, Iterator +from types import TracebackType +from typing import Any, Protocol, TypeAlias + +__all__ = [ + "StartResponse", + "WSGIEnvironment", + "WSGIApplication", + "InputStream", + "ErrorStream", + "FileWrapper", +] + +_ExcInfo: TypeAlias = tuple[type[BaseException], BaseException, TracebackType] +_OptExcInfo: TypeAlias = _ExcInfo | tuple[None, None, None] + +class StartResponse(Protocol): + """start_response() callable as defined in PEP 3333""" + def __call__( + self, + status: str, + headers: list[tuple[str, str]], + exc_info: _OptExcInfo | None = ..., + /, + ) -> Callable[[bytes], object]: ... + +WSGIEnvironment: TypeAlias = dict[str, Any] +WSGIApplication: TypeAlias = Callable[[WSGIEnvironment, StartResponse], + Iterable[bytes]] + +class InputStream(Protocol): + """WSGI input stream as defined in PEP 3333""" + def read(self, size: int = ..., /) -> bytes: ... + def readline(self, size: int = ..., /) -> bytes: ... + def readlines(self, hint: int = ..., /) -> list[bytes]: ... + def __iter__(self) -> Iterator[bytes]: ... + +class ErrorStream(Protocol): + """WSGI error stream as defined in PEP 3333""" + def flush(self) -> object: ... + def write(self, s: str, /) -> object: ... + def writelines(self, seq: list[str], /) -> object: ... + +class _Readable(Protocol): + def read(self, size: int = ..., /) -> bytes: ... + # Optional: def close(self) -> object: ... + +class FileWrapper(Protocol): + """WSGI file wrapper as defined in PEP 3333""" + def __call__( + self, file: _Readable, block_size: int = ..., /, + ) -> Iterable[bytes]: ... diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/util.py b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/util.py new file mode 100644 index 0000000000000000000000000000000000000000..cbbe094cba1624c89e24acdd43bd9ae619f09fc8 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/util.py @@ -0,0 +1,159 @@ +"""Miscellaneous WSGI-related Utilities""" + +import posixpath + +__all__ = [ + 'FileWrapper', 'guess_scheme', 'application_uri', 'request_uri', + 'shift_path_info', 'setup_testing_defaults', +] + + +class FileWrapper: + """Wrapper to convert file-like objects to iterables""" + + def __init__(self, filelike, blksize=8192): + self.filelike = filelike + self.blksize = blksize + if hasattr(filelike,'close'): + self.close = filelike.close + + def __iter__(self): + return self + + def __next__(self): + data = self.filelike.read(self.blksize) + if data: + return data + raise StopIteration + +def guess_scheme(environ): + """Return a guess for whether 'wsgi.url_scheme' should be 'http' or 'https' + """ + if environ.get("HTTPS") in ('yes','on','1'): + return 'https' + else: + return 'http' + +def application_uri(environ): + """Return the application's base URI (no PATH_INFO or QUERY_STRING)""" + url = environ['wsgi.url_scheme']+'://' + from urllib.parse import quote + + if environ.get('HTTP_HOST'): + url += environ['HTTP_HOST'] + else: + url += environ['SERVER_NAME'] + + if environ['wsgi.url_scheme'] == 'https': + if environ['SERVER_PORT'] != '443': + url += ':' + environ['SERVER_PORT'] + else: + if environ['SERVER_PORT'] != '80': + url += ':' + environ['SERVER_PORT'] + + url += quote(environ.get('SCRIPT_NAME') or '/', encoding='latin1') + return url + +def request_uri(environ, include_query=True): + """Return the full request URI, optionally including the query string""" + url = application_uri(environ) + from urllib.parse import quote + path_info = quote(environ.get('PATH_INFO',''), safe='/;=,', encoding='latin1') + if not environ.get('SCRIPT_NAME'): + url += path_info[1:] + else: + url += path_info + if include_query and environ.get('QUERY_STRING'): + url += '?' + environ['QUERY_STRING'] + return url + +def shift_path_info(environ): + """Shift a name from PATH_INFO to SCRIPT_NAME, returning it + + If there are no remaining path segments in PATH_INFO, return None. + Note: 'environ' is modified in-place; use a copy if you need to keep + the original PATH_INFO or SCRIPT_NAME. + + Note: when PATH_INFO is just a '/', this returns '' and appends a trailing + '/' to SCRIPT_NAME, even though empty path segments are normally ignored, + and SCRIPT_NAME doesn't normally end in a '/'. This is intentional + behavior, to ensure that an application can tell the difference between + '/x' and '/x/' when traversing to objects. + """ + path_info = environ.get('PATH_INFO','') + if not path_info: + return None + + path_parts = path_info.split('/') + path_parts[1:-1] = [p for p in path_parts[1:-1] if p and p != '.'] + name = path_parts[1] + del path_parts[1] + + script_name = environ.get('SCRIPT_NAME','') + script_name = posixpath.normpath(script_name+'/'+name) + if script_name.endswith('/'): + script_name = script_name[:-1] + if not name and not script_name.endswith('/'): + script_name += '/' + + environ['SCRIPT_NAME'] = script_name + environ['PATH_INFO'] = '/'.join(path_parts) + + # Special case: '/.' on PATH_INFO doesn't get stripped, + # because we don't strip the last element of PATH_INFO + # if there's only one path part left. Instead of fixing this + # above, we fix it here so that PATH_INFO gets normalized to + # an empty string in the environ. + if name=='.': + name = None + return name + +def setup_testing_defaults(environ): + """Update 'environ' with trivial defaults for testing purposes + + This adds various parameters required for WSGI, including HTTP_HOST, + SERVER_NAME, SERVER_PORT, REQUEST_METHOD, SCRIPT_NAME, PATH_INFO, + and all of the wsgi.* variables. It only supplies default values, + and does not replace any existing settings for these variables. + + This routine is intended to make it easier for unit tests of WSGI + servers and applications to set up dummy environments. It should *not* + be used by actual WSGI servers or applications, since the data is fake! + """ + + environ.setdefault('SERVER_NAME','127.0.0.1') + environ.setdefault('SERVER_PROTOCOL','HTTP/1.0') + + environ.setdefault('HTTP_HOST',environ['SERVER_NAME']) + environ.setdefault('REQUEST_METHOD','GET') + + if 'SCRIPT_NAME' not in environ and 'PATH_INFO' not in environ: + environ.setdefault('SCRIPT_NAME','') + environ.setdefault('PATH_INFO','/') + + environ.setdefault('wsgi.version', (1,0)) + environ.setdefault('wsgi.run_once', 0) + environ.setdefault('wsgi.multithread', 0) + environ.setdefault('wsgi.multiprocess', 0) + + from io import StringIO, BytesIO + environ.setdefault('wsgi.input', BytesIO()) + environ.setdefault('wsgi.errors', StringIO()) + environ.setdefault('wsgi.url_scheme',guess_scheme(environ)) + + if environ['wsgi.url_scheme']=='http': + environ.setdefault('SERVER_PORT', '80') + elif environ['wsgi.url_scheme']=='https': + environ.setdefault('SERVER_PORT', '443') + + + +_hoppish = { + 'connection', 'keep-alive', 'proxy-authenticate', + 'proxy-authorization', 'te', 'trailers', 'transfer-encoding', + 'upgrade' +}.__contains__ + +def is_hop_by_hop(header_name): + """Return true if 'header_name' is an HTTP/1.1 "Hop-by-Hop" header""" + return _hoppish(header_name.lower()) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/validate.py b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/validate.py new file mode 100644 index 0000000000000000000000000000000000000000..6044e320a474c644820a95a52d94de90fa10797a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/wsgiref/validate.py @@ -0,0 +1,441 @@ +# (c) 2005 Ian Bicking and contributors; written for Paste (http://pythonpaste.org) +# Licensed under the MIT license: https://opensource.org/licenses/mit-license.php +# Also licenced under the Apache License, 2.0: https://opensource.org/licenses/apache2.0.php +# Licensed to PSF under a Contributor Agreement +""" +Middleware to check for obedience to the WSGI specification. + +Some of the things this checks: + +* Signature of the application and start_response (including that + keyword arguments are not used). + +* Environment checks: + + - Environment is a dictionary (and not a subclass). + + - That all the required keys are in the environment: REQUEST_METHOD, + SERVER_NAME, SERVER_PORT, wsgi.version, wsgi.input, wsgi.errors, + wsgi.multithread, wsgi.multiprocess, wsgi.run_once + + - That HTTP_CONTENT_TYPE and HTTP_CONTENT_LENGTH are not in the + environment (these headers should appear as CONTENT_LENGTH and + CONTENT_TYPE). + + - Warns if QUERY_STRING is missing, as the cgi module acts + unpredictably in that case. + + - That CGI-style variables (that don't contain a .) have + (non-unicode) string values + + - That wsgi.version is a tuple + + - That wsgi.url_scheme is 'http' or 'https' (@@: is this too + restrictive?) + + - Warns if the REQUEST_METHOD is not known (@@: probably too + restrictive). + + - That SCRIPT_NAME and PATH_INFO are empty or start with / + + - That at least one of SCRIPT_NAME or PATH_INFO are set. + + - That CONTENT_LENGTH is a positive integer. + + - That SCRIPT_NAME is not '/' (it should be '', and PATH_INFO should + be '/'). + + - That wsgi.input has the methods read, readline, readlines, and + __iter__ + + - That wsgi.errors has the methods flush, write, writelines + +* The status is a string, contains a space, starts with an integer, + and that integer is in range (> 100). + +* That the headers is a list (not a subclass, not another kind of + sequence). + +* That the items of the headers are tuples of strings. + +* That there is no 'status' header (that is used in CGI, but not in + WSGI). + +* That the headers don't contain newlines or colons, end in _ or -, or + contain characters codes below 037. + +* That Content-Type is given if there is content (CGI often has a + default content type, but WSGI does not). + +* That no Content-Type is given when there is no content (@@: is this + too restrictive?) + +* That the exc_info argument to start_response is a tuple or None. + +* That all calls to the writer are with strings, and no other methods + on the writer are accessed. + +* That wsgi.input is used properly: + + - .read() is called with exactly one argument + + - That it returns a string + + - That readline, readlines, and __iter__ return strings + + - That .close() is not called + + - No other methods are provided + +* That wsgi.errors is used properly: + + - .write() and .writelines() is called with a string + + - That .close() is not called, and no other methods are provided. + +* The response iterator: + + - That it is not a string (it should be a list of a single string; a + string will work, but perform horribly). + + - That .__next__() returns a string + + - That the iterator is not iterated over until start_response has + been called (that can signal either a server or application + error). + + - That .close() is called (doesn't raise exception, only prints to + sys.stderr, because we only know it isn't called when the object + is garbage collected). +""" +__all__ = ['validator'] + + +import re +import sys +import warnings + +header_re = re.compile(r'^[a-zA-Z][a-zA-Z0-9\-_]*$') +bad_header_value_re = re.compile(r'[\000-\037]') + +class WSGIWarning(Warning): + """ + Raised in response to WSGI-spec-related warnings + """ + +def assert_(cond, *args): + if not cond: + raise AssertionError(*args) + +def check_string_type(value, title): + if type (value) is str: + return value + raise AssertionError( + "{0} must be of type str (got {1})".format(title, repr(value))) + +def validator(application): + + """ + When applied between a WSGI server and a WSGI application, this + middleware will check for WSGI compliance on a number of levels. + This middleware does not modify the request or response in any + way, but will raise an AssertionError if anything seems off + (except for a failure to close the application iterator, which + will be printed to stderr -- there's no way to raise an exception + at that point). + """ + + def lint_app(*args, **kw): + assert_(len(args) == 2, "Two arguments required") + assert_(not kw, "No keyword arguments allowed") + environ, start_response = args + + check_environ(environ) + + # We use this to check if the application returns without + # calling start_response: + start_response_started = [] + + def start_response_wrapper(*args, **kw): + assert_(len(args) == 2 or len(args) == 3, ( + "Invalid number of arguments: %s" % (args,))) + assert_(not kw, "No keyword arguments allowed") + status = args[0] + headers = args[1] + if len(args) == 3: + exc_info = args[2] + else: + exc_info = None + + check_status(status) + check_headers(headers) + check_content_type(status, headers) + check_exc_info(exc_info) + + start_response_started.append(None) + return WriteWrapper(start_response(*args)) + + environ['wsgi.input'] = InputWrapper(environ['wsgi.input']) + environ['wsgi.errors'] = ErrorWrapper(environ['wsgi.errors']) + + iterator = application(environ, start_response_wrapper) + assert_(iterator is not None and iterator != False, + "The application must return an iterator, if only an empty list") + + check_iterator(iterator) + + return IteratorWrapper(iterator, start_response_started) + + return lint_app + +class InputWrapper: + + def __init__(self, wsgi_input): + self.input = wsgi_input + + def read(self, *args): + assert_(len(args) == 1) + v = self.input.read(*args) + assert_(type(v) is bytes) + return v + + def readline(self, *args): + assert_(len(args) <= 1) + v = self.input.readline(*args) + assert_(type(v) is bytes) + return v + + def readlines(self, *args): + assert_(len(args) <= 1) + lines = self.input.readlines(*args) + assert_(type(lines) is list) + for line in lines: + assert_(type(line) is bytes) + return lines + + def __iter__(self): + while 1: + line = self.readline() + if not line: + return + yield line + + def close(self): + assert_(0, "input.close() must not be called") + +class ErrorWrapper: + + def __init__(self, wsgi_errors): + self.errors = wsgi_errors + + def write(self, s): + assert_(type(s) is str) + self.errors.write(s) + + def flush(self): + self.errors.flush() + + def writelines(self, seq): + for line in seq: + self.write(line) + + def close(self): + assert_(0, "errors.close() must not be called") + +class WriteWrapper: + + def __init__(self, wsgi_writer): + self.writer = wsgi_writer + + def __call__(self, s): + assert_(type(s) is bytes) + self.writer(s) + +class PartialIteratorWrapper: + + def __init__(self, wsgi_iterator): + self.iterator = wsgi_iterator + + def __iter__(self): + # We want to make sure __iter__ is called + return IteratorWrapper(self.iterator, None) + +class IteratorWrapper: + + def __init__(self, wsgi_iterator, check_start_response): + self.original_iterator = wsgi_iterator + self.iterator = iter(wsgi_iterator) + self.closed = False + self.check_start_response = check_start_response + + def __iter__(self): + return self + + def __next__(self): + assert_(not self.closed, + "Iterator read after closed") + v = next(self.iterator) + if type(v) is not bytes: + assert_(False, "Iterator yielded non-bytestring (%r)" % (v,)) + if self.check_start_response is not None: + assert_(self.check_start_response, + "The application returns and we started iterating over its body, but start_response has not yet been called") + self.check_start_response = None + return v + + def close(self): + self.closed = True + if hasattr(self.original_iterator, 'close'): + self.original_iterator.close() + + def __del__(self): + if not self.closed: + sys.stderr.write( + "Iterator garbage collected without being closed") + assert_(self.closed, + "Iterator garbage collected without being closed") + +def check_environ(environ): + assert_(type(environ) is dict, + "Environment is not of the right type: %r (environment: %r)" + % (type(environ), environ)) + + for key in ['REQUEST_METHOD', 'SERVER_NAME', 'SERVER_PORT', + 'wsgi.version', 'wsgi.input', 'wsgi.errors', + 'wsgi.multithread', 'wsgi.multiprocess', + 'wsgi.run_once']: + assert_(key in environ, + "Environment missing required key: %r" % (key,)) + + for key in ['HTTP_CONTENT_TYPE', 'HTTP_CONTENT_LENGTH']: + assert_(key not in environ, + "Environment should not have the key: %s " + "(use %s instead)" % (key, key[5:])) + + if 'QUERY_STRING' not in environ: + warnings.warn( + 'QUERY_STRING is not in the WSGI environment; the cgi ' + 'module will use sys.argv when this variable is missing, ' + 'so application errors are more likely', + WSGIWarning) + + for key in environ.keys(): + if '.' in key: + # Extension, we don't care about its type + continue + assert_(type(environ[key]) is str, + "Environmental variable %s is not a string: %r (value: %r)" + % (key, type(environ[key]), environ[key])) + + assert_(type(environ['wsgi.version']) is tuple, + "wsgi.version should be a tuple (%r)" % (environ['wsgi.version'],)) + assert_(environ['wsgi.url_scheme'] in ('http', 'https'), + "wsgi.url_scheme unknown: %r" % environ['wsgi.url_scheme']) + + check_input(environ['wsgi.input']) + check_errors(environ['wsgi.errors']) + + # @@: these need filling out: + if environ['REQUEST_METHOD'] not in ( + 'GET', 'HEAD', 'POST', 'OPTIONS', 'PATCH', 'PUT', 'DELETE', 'TRACE'): + warnings.warn( + "Unknown REQUEST_METHOD: %r" % environ['REQUEST_METHOD'], + WSGIWarning) + + assert_(not environ.get('SCRIPT_NAME') + or environ['SCRIPT_NAME'].startswith('/'), + "SCRIPT_NAME doesn't start with /: %r" % environ['SCRIPT_NAME']) + assert_(not environ.get('PATH_INFO') + or environ['PATH_INFO'].startswith('/'), + "PATH_INFO doesn't start with /: %r" % environ['PATH_INFO']) + if environ.get('CONTENT_LENGTH'): + assert_(int(environ['CONTENT_LENGTH']) >= 0, + "Invalid CONTENT_LENGTH: %r" % environ['CONTENT_LENGTH']) + + if not environ.get('SCRIPT_NAME'): + assert_('PATH_INFO' in environ, + "One of SCRIPT_NAME or PATH_INFO are required (PATH_INFO " + "should at least be '/' if SCRIPT_NAME is empty)") + assert_(environ.get('SCRIPT_NAME') != '/', + "SCRIPT_NAME cannot be '/'; it should instead be '', and " + "PATH_INFO should be '/'") + +def check_input(wsgi_input): + for attr in ['read', 'readline', 'readlines', '__iter__']: + assert_(hasattr(wsgi_input, attr), + "wsgi.input (%r) doesn't have the attribute %s" + % (wsgi_input, attr)) + +def check_errors(wsgi_errors): + for attr in ['flush', 'write', 'writelines']: + assert_(hasattr(wsgi_errors, attr), + "wsgi.errors (%r) doesn't have the attribute %s" + % (wsgi_errors, attr)) + +def check_status(status): + status = check_string_type(status, "Status") + # Implicitly check that we can turn it into an integer: + status_code = status.split(None, 1)[0] + assert_(len(status_code) == 3, + "Status codes must be three characters: %r" % status_code) + status_int = int(status_code) + assert_(status_int >= 100, "Status code is invalid: %r" % status_int) + if len(status) < 4 or status[3] != ' ': + warnings.warn( + "The status string (%r) should be a three-digit integer " + "followed by a single space and a status explanation" + % status, WSGIWarning) + +def check_headers(headers): + assert_(type(headers) is list, + "Headers (%r) must be of type list: %r" + % (headers, type(headers))) + for item in headers: + assert_(type(item) is tuple, + "Individual headers (%r) must be of type tuple: %r" + % (item, type(item))) + assert_(len(item) == 2) + name, value = item + name = check_string_type(name, "Header name") + value = check_string_type(value, "Header value") + assert_(name.lower() != 'status', + "The Status header cannot be used; it conflicts with CGI " + "script, and HTTP status is not given through headers " + "(value: %r)." % value) + assert_('\n' not in name and ':' not in name, + "Header names may not contain ':' or '\\n': %r" % name) + assert_(header_re.search(name), "Bad header name: %r" % name) + assert_(not name.endswith('-') and not name.endswith('_'), + "Names may not end in '-' or '_': %r" % name) + if bad_header_value_re.search(value): + assert_(0, "Bad header value: %r (bad char: %r)" + % (value, bad_header_value_re.search(value).group(0))) + +def check_content_type(status, headers): + status = check_string_type(status, "Status") + code = int(status.split(None, 1)[0]) + # @@: need one more person to verify this interpretation of RFC 2616 + # http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html + NO_MESSAGE_BODY = (204, 304) + for name, value in headers: + name = check_string_type(name, "Header name") + if name.lower() == 'content-type': + if code not in NO_MESSAGE_BODY: + return + assert_(0, ("Content-Type header found in a %s response, " + "which must not return content.") % code) + if code not in NO_MESSAGE_BODY: + assert_(0, "No Content-Type header found in headers (%s)" % headers) + +def check_exc_info(exc_info): + assert_(exc_info is None or type(exc_info) is tuple, + "exc_info (%r) is not a tuple: %r" % (exc_info, type(exc_info))) + # More exc_info checks? + +def check_iterator(iterator): + # Technically a bytestring is legal, which is why it's a really bad + # idea, because it may cause the response to be returned + # character-by-character + assert_(not isinstance(iterator, (str, bytes)), + "You should not return a string as your application iterator, " + "instead return a single-item list containing a bytestring.") diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xdrlib.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xdrlib.py new file mode 100644 index 0000000000000000000000000000000000000000..b56ffa59b73dcba1241ba0b181f2dd593389945a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xdrlib.py @@ -0,0 +1,244 @@ +"""Implements (a subset of) Sun XDR -- eXternal Data Representation. + +See: RFC 1014 + +""" + +import struct +from io import BytesIO +from functools import wraps +import warnings + +warnings._deprecated(__name__, remove=(3, 13)) + +__all__ = ["Error", "Packer", "Unpacker", "ConversionError"] + +# exceptions +class Error(Exception): + """Exception class for this module. Use: + + except xdrlib.Error as var: + # var has the Error instance for the exception + + Public ivars: + msg -- contains the message + + """ + def __init__(self, msg): + self.msg = msg + def __repr__(self): + return repr(self.msg) + def __str__(self): + return str(self.msg) + + +class ConversionError(Error): + pass + +def raise_conversion_error(function): + """ Wrap any raised struct.errors in a ConversionError. """ + + @wraps(function) + def result(self, value): + try: + return function(self, value) + except struct.error as e: + raise ConversionError(e.args[0]) from None + return result + + +class Packer: + """Pack various data representations into a buffer.""" + + def __init__(self): + self.reset() + + def reset(self): + self.__buf = BytesIO() + + def get_buffer(self): + return self.__buf.getvalue() + # backwards compatibility + get_buf = get_buffer + + @raise_conversion_error + def pack_uint(self, x): + self.__buf.write(struct.pack('>L', x)) + + @raise_conversion_error + def pack_int(self, x): + self.__buf.write(struct.pack('>l', x)) + + pack_enum = pack_int + + def pack_bool(self, x): + if x: self.__buf.write(b'\0\0\0\1') + else: self.__buf.write(b'\0\0\0\0') + + def pack_uhyper(self, x): + try: + self.pack_uint(x>>32 & 0xffffffff) + except (TypeError, struct.error) as e: + raise ConversionError(e.args[0]) from None + try: + self.pack_uint(x & 0xffffffff) + except (TypeError, struct.error) as e: + raise ConversionError(e.args[0]) from None + + pack_hyper = pack_uhyper + + @raise_conversion_error + def pack_float(self, x): + self.__buf.write(struct.pack('>f', x)) + + @raise_conversion_error + def pack_double(self, x): + self.__buf.write(struct.pack('>d', x)) + + def pack_fstring(self, n, s): + if n < 0: + raise ValueError('fstring size must be nonnegative') + data = s[:n] + n = ((n+3)//4)*4 + data = data + (n - len(data)) * b'\0' + self.__buf.write(data) + + pack_fopaque = pack_fstring + + def pack_string(self, s): + n = len(s) + self.pack_uint(n) + self.pack_fstring(n, s) + + pack_opaque = pack_string + pack_bytes = pack_string + + def pack_list(self, list, pack_item): + for item in list: + self.pack_uint(1) + pack_item(item) + self.pack_uint(0) + + def pack_farray(self, n, list, pack_item): + if len(list) != n: + raise ValueError('wrong array size') + for item in list: + pack_item(item) + + def pack_array(self, list, pack_item): + n = len(list) + self.pack_uint(n) + self.pack_farray(n, list, pack_item) + + + +class Unpacker: + """Unpacks various data representations from the given buffer.""" + + def __init__(self, data): + self.reset(data) + + def reset(self, data): + self.__buf = data + self.__pos = 0 + + def get_position(self): + return self.__pos + + def set_position(self, position): + self.__pos = position + + def get_buffer(self): + return self.__buf + + def done(self): + if self.__pos < len(self.__buf): + raise Error('unextracted data remains') + + def unpack_uint(self): + i = self.__pos + self.__pos = j = i+4 + data = self.__buf[i:j] + if len(data) < 4: + raise EOFError + return struct.unpack('>L', data)[0] + + def unpack_int(self): + i = self.__pos + self.__pos = j = i+4 + data = self.__buf[i:j] + if len(data) < 4: + raise EOFError + return struct.unpack('>l', data)[0] + + unpack_enum = unpack_int + + def unpack_bool(self): + return bool(self.unpack_int()) + + def unpack_uhyper(self): + hi = self.unpack_uint() + lo = self.unpack_uint() + return int(hi)<<32 | lo + + def unpack_hyper(self): + x = self.unpack_uhyper() + if x >= 0x8000000000000000: + x = x - 0x10000000000000000 + return x + + def unpack_float(self): + i = self.__pos + self.__pos = j = i+4 + data = self.__buf[i:j] + if len(data) < 4: + raise EOFError + return struct.unpack('>f', data)[0] + + def unpack_double(self): + i = self.__pos + self.__pos = j = i+8 + data = self.__buf[i:j] + if len(data) < 8: + raise EOFError + return struct.unpack('>d', data)[0] + + def unpack_fstring(self, n): + if n < 0: + raise ValueError('fstring size must be nonnegative') + i = self.__pos + j = i + (n+3)//4*4 + if j > len(self.__buf): + raise EOFError + self.__pos = j + return self.__buf[i:i+n] + + unpack_fopaque = unpack_fstring + + def unpack_string(self): + n = self.unpack_uint() + return self.unpack_fstring(n) + + unpack_opaque = unpack_string + unpack_bytes = unpack_string + + def unpack_list(self, unpack_item): + list = [] + while 1: + x = self.unpack_uint() + if x == 0: break + if x != 1: + raise ConversionError('0 or 1 expected, got %r' % (x,)) + item = unpack_item() + list.append(item) + return list + + def unpack_farray(self, n, unpack_item): + list = [] + for i in range(n): + list.append(unpack_item()) + return list + + def unpack_array(self, unpack_item): + n = self.unpack_uint() + return self.unpack_farray(n, unpack_item) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..bf6d8ddfd04c934003004472d7f03bfa3f06b5f5 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/__init__.py @@ -0,0 +1,20 @@ +"""Core XML support for Python. + +This package contains four sub-packages: + +dom -- The W3C Document Object Model. This supports DOM Level 1 + + Namespaces. + +parsers -- Python wrappers for XML parsers (currently only supports Expat). + +sax -- The Simple API for XML, developed by XML-Dev, led by David + Megginson and ported to Python by Lars Marius Garshol. This + supports the SAX 2 API. + +etree -- The ElementTree XML library. This is a subset of the full + ElementTree XML release. + +""" + + +__all__ = ["dom", "parsers", "sax", "etree"] diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cd9df4fccde2a6074bfd952f4190dff21201f5e0 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/NodeFilter.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/NodeFilter.py new file mode 100644 index 0000000000000000000000000000000000000000..640e0bfd246ca5f9b61fd7ca79ad7b3e560a2a2d --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/NodeFilter.py @@ -0,0 +1,27 @@ +# This is the Python mapping for interface NodeFilter from +# DOM2-Traversal-Range. It contains only constants. + +class NodeFilter: + """ + This is the DOM2 NodeFilter interface. It contains only constants. + """ + FILTER_ACCEPT = 1 + FILTER_REJECT = 2 + FILTER_SKIP = 3 + + SHOW_ALL = 0xFFFFFFFF + SHOW_ELEMENT = 0x00000001 + SHOW_ATTRIBUTE = 0x00000002 + SHOW_TEXT = 0x00000004 + SHOW_CDATA_SECTION = 0x00000008 + SHOW_ENTITY_REFERENCE = 0x00000010 + SHOW_ENTITY = 0x00000020 + SHOW_PROCESSING_INSTRUCTION = 0x00000040 + SHOW_COMMENT = 0x00000080 + SHOW_DOCUMENT = 0x00000100 + SHOW_DOCUMENT_TYPE = 0x00000200 + SHOW_DOCUMENT_FRAGMENT = 0x00000400 + SHOW_NOTATION = 0x00000800 + + def acceptNode(self, node): + raise NotImplementedError diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..97cf9a6429993d97e26e1867b038d433055cf419 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__init__.py @@ -0,0 +1,140 @@ +"""W3C Document Object Model implementation for Python. + +The Python mapping of the Document Object Model is documented in the +Python Library Reference in the section on the xml.dom package. + +This package contains the following modules: + +minidom -- A simple implementation of the Level 1 DOM with namespace + support added (based on the Level 2 specification) and other + minor Level 2 functionality. + +pulldom -- DOM builder supporting on-demand tree-building for selected + subtrees of the document. + +""" + + +class Node: + """Class giving the NodeType constants.""" + __slots__ = () + + # DOM implementations may use this as a base class for their own + # Node implementations. If they don't, the constants defined here + # should still be used as the canonical definitions as they match + # the values given in the W3C recommendation. Client code can + # safely refer to these values in all tests of Node.nodeType + # values. + + ELEMENT_NODE = 1 + ATTRIBUTE_NODE = 2 + TEXT_NODE = 3 + CDATA_SECTION_NODE = 4 + ENTITY_REFERENCE_NODE = 5 + ENTITY_NODE = 6 + PROCESSING_INSTRUCTION_NODE = 7 + COMMENT_NODE = 8 + DOCUMENT_NODE = 9 + DOCUMENT_TYPE_NODE = 10 + DOCUMENT_FRAGMENT_NODE = 11 + NOTATION_NODE = 12 + + +#ExceptionCode +INDEX_SIZE_ERR = 1 +DOMSTRING_SIZE_ERR = 2 +HIERARCHY_REQUEST_ERR = 3 +WRONG_DOCUMENT_ERR = 4 +INVALID_CHARACTER_ERR = 5 +NO_DATA_ALLOWED_ERR = 6 +NO_MODIFICATION_ALLOWED_ERR = 7 +NOT_FOUND_ERR = 8 +NOT_SUPPORTED_ERR = 9 +INUSE_ATTRIBUTE_ERR = 10 +INVALID_STATE_ERR = 11 +SYNTAX_ERR = 12 +INVALID_MODIFICATION_ERR = 13 +NAMESPACE_ERR = 14 +INVALID_ACCESS_ERR = 15 +VALIDATION_ERR = 16 + + +class DOMException(Exception): + """Abstract base class for DOM exceptions. + Exceptions with specific codes are specializations of this class.""" + + def __init__(self, *args, **kw): + if self.__class__ is DOMException: + raise RuntimeError( + "DOMException should not be instantiated directly") + Exception.__init__(self, *args, **kw) + + def _get_code(self): + return self.code + + +class IndexSizeErr(DOMException): + code = INDEX_SIZE_ERR + +class DomstringSizeErr(DOMException): + code = DOMSTRING_SIZE_ERR + +class HierarchyRequestErr(DOMException): + code = HIERARCHY_REQUEST_ERR + +class WrongDocumentErr(DOMException): + code = WRONG_DOCUMENT_ERR + +class InvalidCharacterErr(DOMException): + code = INVALID_CHARACTER_ERR + +class NoDataAllowedErr(DOMException): + code = NO_DATA_ALLOWED_ERR + +class NoModificationAllowedErr(DOMException): + code = NO_MODIFICATION_ALLOWED_ERR + +class NotFoundErr(DOMException): + code = NOT_FOUND_ERR + +class NotSupportedErr(DOMException): + code = NOT_SUPPORTED_ERR + +class InuseAttributeErr(DOMException): + code = INUSE_ATTRIBUTE_ERR + +class InvalidStateErr(DOMException): + code = INVALID_STATE_ERR + +class SyntaxErr(DOMException): + code = SYNTAX_ERR + +class InvalidModificationErr(DOMException): + code = INVALID_MODIFICATION_ERR + +class NamespaceErr(DOMException): + code = NAMESPACE_ERR + +class InvalidAccessErr(DOMException): + code = INVALID_ACCESS_ERR + +class ValidationErr(DOMException): + code = VALIDATION_ERR + +class UserDataHandler: + """Class giving the operation constants for UserDataHandler.handle().""" + + # Based on DOM Level 3 (WD 9 April 2002) + + NODE_CLONED = 1 + NODE_IMPORTED = 2 + NODE_DELETED = 3 + NODE_RENAMED = 4 + +XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace" +XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/" +XHTML_NAMESPACE = "http://www.w3.org/1999/xhtml" +EMPTY_NAMESPACE = None +EMPTY_PREFIX = None + +from .domreg import getDOMImplementation, registerDOMImplementation diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/NodeFilter.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/NodeFilter.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4f9c6ba16a7b5af0b81a0d85b9b1a57e8e71ca2c Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/NodeFilter.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d0d33f54f91d48f2529cdd86dcdc9db682f62aa8 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/domreg.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/domreg.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..afb2764e04504bccee38e8a0bd2fc713c949b5d3 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/domreg.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/expatbuilder.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/expatbuilder.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4ba036101fda9e5d23c4c83114667973403aa4ef Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/expatbuilder.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/minicompat.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/minicompat.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8923b05400ffadbdbd8400ac7f9ac28be78674ff Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/minicompat.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/minidom.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/minidom.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9433d6cf71f0c1c5b2a29dfc790993f7e1203054 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/minidom.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/pulldom.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/pulldom.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7023446e92fb44fea10bc18e261d9c567b78b14b Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/pulldom.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/xmlbuilder.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/xmlbuilder.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..086914ec5648d9e5ced24018accb2b1dea8c6f83 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/__pycache__/xmlbuilder.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/domreg.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/domreg.py new file mode 100644 index 0000000000000000000000000000000000000000..69c17eebb265daad3243e62018409d72942a93af --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/domreg.py @@ -0,0 +1,99 @@ +"""Registration facilities for DOM. This module should not be used +directly. Instead, the functions getDOMImplementation and +registerDOMImplementation should be imported from xml.dom.""" + +# This is a list of well-known implementations. Well-known names +# should be published by posting to xml-sig@python.org, and are +# subsequently recorded in this file. + +import sys + +well_known_implementations = { + 'minidom':'xml.dom.minidom', + '4DOM': 'xml.dom.DOMImplementation', + } + +# DOM implementations not officially registered should register +# themselves with their + +registered = {} + +def registerDOMImplementation(name, factory): + """registerDOMImplementation(name, factory) + + Register the factory function with the name. The factory function + should return an object which implements the DOMImplementation + interface. The factory function can either return the same object, + or a new one (e.g. if that implementation supports some + customization).""" + + registered[name] = factory + +def _good_enough(dom, features): + "_good_enough(dom, features) -> Return 1 if the dom offers the features" + for f,v in features: + if not dom.hasFeature(f,v): + return 0 + return 1 + +def getDOMImplementation(name=None, features=()): + """getDOMImplementation(name = None, features = ()) -> DOM implementation. + + Return a suitable DOM implementation. The name is either + well-known, the module name of a DOM implementation, or None. If + it is not None, imports the corresponding module and returns + DOMImplementation object if the import succeeds. + + If name is not given, consider the available implementations to + find one with the required feature set. If no implementation can + be found, raise an ImportError. The features list must be a sequence + of (feature, version) pairs which are passed to hasFeature.""" + + import os + creator = None + mod = well_known_implementations.get(name) + if mod: + mod = __import__(mod, {}, {}, ['getDOMImplementation']) + return mod.getDOMImplementation() + elif name: + return registered[name]() + elif not sys.flags.ignore_environment and "PYTHON_DOM" in os.environ: + return getDOMImplementation(name = os.environ["PYTHON_DOM"]) + + # User did not specify a name, try implementations in arbitrary + # order, returning the one that has the required features + if isinstance(features, str): + features = _parse_feature_string(features) + for creator in registered.values(): + dom = creator() + if _good_enough(dom, features): + return dom + + for creator in well_known_implementations.keys(): + try: + dom = getDOMImplementation(name = creator) + except Exception: # typically ImportError, or AttributeError + continue + if _good_enough(dom, features): + return dom + + raise ImportError("no suitable DOM implementation found") + +def _parse_feature_string(s): + features = [] + parts = s.split() + i = 0 + length = len(parts) + while i < length: + feature = parts[i] + if feature[0] in "0123456789": + raise ValueError("bad feature name: %r" % (feature,)) + i = i + 1 + version = None + if i < length: + v = parts[i] + if v[0] in "0123456789": + i = i + 1 + version = v + features.append((feature, version)) + return tuple(features) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/expatbuilder.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/expatbuilder.py new file mode 100644 index 0000000000000000000000000000000000000000..199c22d0af347e15bf53005f74b5359ce0f0e904 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/expatbuilder.py @@ -0,0 +1,965 @@ +"""Facility to use the Expat parser to load a minidom instance +from a string or file. + +This avoids all the overhead of SAX and pulldom to gain performance. +""" + +# Warning! +# +# This module is tightly bound to the implementation details of the +# minidom DOM and can't be used with other DOM implementations. This +# is due, in part, to a lack of appropriate methods in the DOM (there is +# no way to create Entity and Notation nodes via the DOM Level 2 +# interface), and for performance. The latter is the cause of some fairly +# cryptic code. +# +# Performance hacks: +# +# - .character_data_handler() has an extra case in which continuing +# data is appended to an existing Text node; this can be a +# speedup since pyexpat can break up character data into multiple +# callbacks even though we set the buffer_text attribute on the +# parser. This also gives us the advantage that we don't need a +# separate normalization pass. +# +# - Determining that a node exists is done using an identity comparison +# with None rather than a truth test; this avoids searching for and +# calling any methods on the node object if it exists. (A rather +# nice speedup is achieved this way as well!) + +from xml.dom import xmlbuilder, minidom, Node +from xml.dom import EMPTY_NAMESPACE, EMPTY_PREFIX, XMLNS_NAMESPACE +from xml.parsers import expat +from xml.dom.minidom import _append_child, _set_attribute_node +from xml.dom.NodeFilter import NodeFilter + +TEXT_NODE = Node.TEXT_NODE +CDATA_SECTION_NODE = Node.CDATA_SECTION_NODE +DOCUMENT_NODE = Node.DOCUMENT_NODE + +FILTER_ACCEPT = xmlbuilder.DOMBuilderFilter.FILTER_ACCEPT +FILTER_REJECT = xmlbuilder.DOMBuilderFilter.FILTER_REJECT +FILTER_SKIP = xmlbuilder.DOMBuilderFilter.FILTER_SKIP +FILTER_INTERRUPT = xmlbuilder.DOMBuilderFilter.FILTER_INTERRUPT + +theDOMImplementation = minidom.getDOMImplementation() + +# Expat typename -> TypeInfo +_typeinfo_map = { + "CDATA": minidom.TypeInfo(None, "cdata"), + "ENUM": minidom.TypeInfo(None, "enumeration"), + "ENTITY": minidom.TypeInfo(None, "entity"), + "ENTITIES": minidom.TypeInfo(None, "entities"), + "ID": minidom.TypeInfo(None, "id"), + "IDREF": minidom.TypeInfo(None, "idref"), + "IDREFS": minidom.TypeInfo(None, "idrefs"), + "NMTOKEN": minidom.TypeInfo(None, "nmtoken"), + "NMTOKENS": minidom.TypeInfo(None, "nmtokens"), + } + +class ElementInfo(object): + __slots__ = '_attr_info', '_model', 'tagName' + + def __init__(self, tagName, model=None): + self.tagName = tagName + self._attr_info = [] + self._model = model + + def __getstate__(self): + return self._attr_info, self._model, self.tagName + + def __setstate__(self, state): + self._attr_info, self._model, self.tagName = state + + def getAttributeType(self, aname): + for info in self._attr_info: + if info[1] == aname: + t = info[-2] + if t[0] == "(": + return _typeinfo_map["ENUM"] + else: + return _typeinfo_map[info[-2]] + return minidom._no_type + + def getAttributeTypeNS(self, namespaceURI, localName): + return minidom._no_type + + def isElementContent(self): + if self._model: + type = self._model[0] + return type not in (expat.model.XML_CTYPE_ANY, + expat.model.XML_CTYPE_MIXED) + else: + return False + + def isEmpty(self): + if self._model: + return self._model[0] == expat.model.XML_CTYPE_EMPTY + else: + return False + + def isId(self, aname): + for info in self._attr_info: + if info[1] == aname: + return info[-2] == "ID" + return False + + def isIdNS(self, euri, ename, auri, aname): + # not sure this is meaningful + return self.isId((auri, aname)) + +def _intern(builder, s): + return builder._intern_setdefault(s, s) + +def _parse_ns_name(builder, name): + assert ' ' in name + parts = name.split(' ') + intern = builder._intern_setdefault + if len(parts) == 3: + uri, localname, prefix = parts + prefix = intern(prefix, prefix) + qname = "%s:%s" % (prefix, localname) + qname = intern(qname, qname) + localname = intern(localname, localname) + elif len(parts) == 2: + uri, localname = parts + prefix = EMPTY_PREFIX + qname = localname = intern(localname, localname) + else: + raise ValueError("Unsupported syntax: spaces in URIs not supported: %r" % name) + return intern(uri, uri), localname, prefix, qname + + +class ExpatBuilder: + """Document builder that uses Expat to build a ParsedXML.DOM document + instance.""" + + def __init__(self, options=None): + if options is None: + options = xmlbuilder.Options() + self._options = options + if self._options.filter is not None: + self._filter = FilterVisibilityController(self._options.filter) + else: + self._filter = None + # This *really* doesn't do anything in this case, so + # override it with something fast & minimal. + self._finish_start_element = id + self._parser = None + self.reset() + + def createParser(self): + """Create a new parser object.""" + return expat.ParserCreate() + + def getParser(self): + """Return the parser object, creating a new one if needed.""" + if not self._parser: + self._parser = self.createParser() + self._intern_setdefault = self._parser.intern.setdefault + self._parser.buffer_text = True + self._parser.ordered_attributes = True + self._parser.specified_attributes = True + self.install(self._parser) + return self._parser + + def reset(self): + """Free all data structures used during DOM construction.""" + self.document = theDOMImplementation.createDocument( + EMPTY_NAMESPACE, None, None) + self.curNode = self.document + self._elem_info = self.document._elem_info + self._cdata = False + + def install(self, parser): + """Install the callbacks needed to build the DOM into the parser.""" + # This creates circular references! + parser.StartDoctypeDeclHandler = self.start_doctype_decl_handler + parser.StartElementHandler = self.first_element_handler + parser.EndElementHandler = self.end_element_handler + parser.ProcessingInstructionHandler = self.pi_handler + if self._options.entities: + parser.EntityDeclHandler = self.entity_decl_handler + parser.NotationDeclHandler = self.notation_decl_handler + if self._options.comments: + parser.CommentHandler = self.comment_handler + if self._options.cdata_sections: + parser.StartCdataSectionHandler = self.start_cdata_section_handler + parser.EndCdataSectionHandler = self.end_cdata_section_handler + parser.CharacterDataHandler = self.character_data_handler_cdata + else: + parser.CharacterDataHandler = self.character_data_handler + parser.ExternalEntityRefHandler = self.external_entity_ref_handler + parser.XmlDeclHandler = self.xml_decl_handler + parser.ElementDeclHandler = self.element_decl_handler + parser.AttlistDeclHandler = self.attlist_decl_handler + + def parseFile(self, file): + """Parse a document from a file object, returning the document + node.""" + parser = self.getParser() + first_buffer = True + try: + while 1: + buffer = file.read(16*1024) + if not buffer: + break + parser.Parse(buffer, False) + if first_buffer and self.document.documentElement: + self._setup_subset(buffer) + first_buffer = False + parser.Parse(b"", True) + except ParseEscape: + pass + doc = self.document + self.reset() + self._parser = None + return doc + + def parseString(self, string): + """Parse a document from a string, returning the document node.""" + parser = self.getParser() + try: + parser.Parse(string, True) + self._setup_subset(string) + except ParseEscape: + pass + doc = self.document + self.reset() + self._parser = None + return doc + + def _setup_subset(self, buffer): + """Load the internal subset if there might be one.""" + if self.document.doctype: + extractor = InternalSubsetExtractor() + extractor.parseString(buffer) + subset = extractor.getSubset() + self.document.doctype.internalSubset = subset + + def start_doctype_decl_handler(self, doctypeName, systemId, publicId, + has_internal_subset): + doctype = self.document.implementation.createDocumentType( + doctypeName, publicId, systemId) + doctype.ownerDocument = self.document + _append_child(self.document, doctype) + self.document.doctype = doctype + if self._filter and self._filter.acceptNode(doctype) == FILTER_REJECT: + self.document.doctype = None + del self.document.childNodes[-1] + doctype = None + self._parser.EntityDeclHandler = None + self._parser.NotationDeclHandler = None + if has_internal_subset: + if doctype is not None: + doctype.entities._seq = [] + doctype.notations._seq = [] + self._parser.CommentHandler = None + self._parser.ProcessingInstructionHandler = None + self._parser.EndDoctypeDeclHandler = self.end_doctype_decl_handler + + def end_doctype_decl_handler(self): + if self._options.comments: + self._parser.CommentHandler = self.comment_handler + self._parser.ProcessingInstructionHandler = self.pi_handler + if not (self._elem_info or self._filter): + self._finish_end_element = id + + def pi_handler(self, target, data): + node = self.document.createProcessingInstruction(target, data) + _append_child(self.curNode, node) + if self._filter and self._filter.acceptNode(node) == FILTER_REJECT: + self.curNode.removeChild(node) + + def character_data_handler_cdata(self, data): + childNodes = self.curNode.childNodes + if self._cdata: + if ( self._cdata_continue + and childNodes[-1].nodeType == CDATA_SECTION_NODE): + childNodes[-1].appendData(data) + return + node = self.document.createCDATASection(data) + self._cdata_continue = True + elif childNodes and childNodes[-1].nodeType == TEXT_NODE: + node = childNodes[-1] + value = node.data + data + node.data = value + return + else: + node = minidom.Text() + node.data = data + node.ownerDocument = self.document + _append_child(self.curNode, node) + + def character_data_handler(self, data): + childNodes = self.curNode.childNodes + if childNodes and childNodes[-1].nodeType == TEXT_NODE: + node = childNodes[-1] + node.data = node.data + data + return + node = minidom.Text() + node.data = node.data + data + node.ownerDocument = self.document + _append_child(self.curNode, node) + + def entity_decl_handler(self, entityName, is_parameter_entity, value, + base, systemId, publicId, notationName): + if is_parameter_entity: + # we don't care about parameter entities for the DOM + return + if not self._options.entities: + return + node = self.document._create_entity(entityName, publicId, + systemId, notationName) + if value is not None: + # internal entity + # node *should* be readonly, but we'll cheat + child = self.document.createTextNode(value) + node.childNodes.append(child) + self.document.doctype.entities._seq.append(node) + if self._filter and self._filter.acceptNode(node) == FILTER_REJECT: + del self.document.doctype.entities._seq[-1] + + def notation_decl_handler(self, notationName, base, systemId, publicId): + node = self.document._create_notation(notationName, publicId, systemId) + self.document.doctype.notations._seq.append(node) + if self._filter and self._filter.acceptNode(node) == FILTER_ACCEPT: + del self.document.doctype.notations._seq[-1] + + def comment_handler(self, data): + node = self.document.createComment(data) + _append_child(self.curNode, node) + if self._filter and self._filter.acceptNode(node) == FILTER_REJECT: + self.curNode.removeChild(node) + + def start_cdata_section_handler(self): + self._cdata = True + self._cdata_continue = False + + def end_cdata_section_handler(self): + self._cdata = False + self._cdata_continue = False + + def external_entity_ref_handler(self, context, base, systemId, publicId): + return 1 + + def first_element_handler(self, name, attributes): + if self._filter is None and not self._elem_info: + self._finish_end_element = id + self.getParser().StartElementHandler = self.start_element_handler + self.start_element_handler(name, attributes) + + def start_element_handler(self, name, attributes): + node = self.document.createElement(name) + _append_child(self.curNode, node) + self.curNode = node + + if attributes: + for i in range(0, len(attributes), 2): + a = minidom.Attr(attributes[i], EMPTY_NAMESPACE, + None, EMPTY_PREFIX) + value = attributes[i+1] + a.value = value + a.ownerDocument = self.document + _set_attribute_node(node, a) + + if node is not self.document.documentElement: + self._finish_start_element(node) + + def _finish_start_element(self, node): + if self._filter: + # To be general, we'd have to call isSameNode(), but this + # is sufficient for minidom: + if node is self.document.documentElement: + return + filt = self._filter.startContainer(node) + if filt == FILTER_REJECT: + # ignore this node & all descendents + Rejecter(self) + elif filt == FILTER_SKIP: + # ignore this node, but make it's children become + # children of the parent node + Skipper(self) + else: + return + self.curNode = node.parentNode + node.parentNode.removeChild(node) + node.unlink() + + # If this ever changes, Namespaces.end_element_handler() needs to + # be changed to match. + # + def end_element_handler(self, name): + curNode = self.curNode + self.curNode = curNode.parentNode + self._finish_end_element(curNode) + + def _finish_end_element(self, curNode): + info = self._elem_info.get(curNode.tagName) + if info: + self._handle_white_text_nodes(curNode, info) + if self._filter: + if curNode is self.document.documentElement: + return + if self._filter.acceptNode(curNode) == FILTER_REJECT: + self.curNode.removeChild(curNode) + curNode.unlink() + + def _handle_white_text_nodes(self, node, info): + if (self._options.whitespace_in_element_content + or not info.isElementContent()): + return + + # We have element type information and should remove ignorable + # whitespace; identify for text nodes which contain only + # whitespace. + L = [] + for child in node.childNodes: + if child.nodeType == TEXT_NODE and not child.data.strip(): + L.append(child) + + # Remove ignorable whitespace from the tree. + for child in L: + node.removeChild(child) + + def element_decl_handler(self, name, model): + info = self._elem_info.get(name) + if info is None: + self._elem_info[name] = ElementInfo(name, model) + else: + assert info._model is None + info._model = model + + def attlist_decl_handler(self, elem, name, type, default, required): + info = self._elem_info.get(elem) + if info is None: + info = ElementInfo(elem) + self._elem_info[elem] = info + info._attr_info.append( + [None, name, None, None, default, 0, type, required]) + + def xml_decl_handler(self, version, encoding, standalone): + self.document.version = version + self.document.encoding = encoding + # This is still a little ugly, thanks to the pyexpat API. ;-( + if standalone >= 0: + if standalone: + self.document.standalone = True + else: + self.document.standalone = False + + +# Don't include FILTER_INTERRUPT, since that's checked separately +# where allowed. +_ALLOWED_FILTER_RETURNS = (FILTER_ACCEPT, FILTER_REJECT, FILTER_SKIP) + +class FilterVisibilityController(object): + """Wrapper around a DOMBuilderFilter which implements the checks + to make the whatToShow filter attribute work.""" + + __slots__ = 'filter', + + def __init__(self, filter): + self.filter = filter + + def startContainer(self, node): + mask = self._nodetype_mask[node.nodeType] + if self.filter.whatToShow & mask: + val = self.filter.startContainer(node) + if val == FILTER_INTERRUPT: + raise ParseEscape + if val not in _ALLOWED_FILTER_RETURNS: + raise ValueError( + "startContainer() returned illegal value: " + repr(val)) + return val + else: + return FILTER_ACCEPT + + def acceptNode(self, node): + mask = self._nodetype_mask[node.nodeType] + if self.filter.whatToShow & mask: + val = self.filter.acceptNode(node) + if val == FILTER_INTERRUPT: + raise ParseEscape + if val == FILTER_SKIP: + # move all child nodes to the parent, and remove this node + parent = node.parentNode + for child in node.childNodes[:]: + parent.appendChild(child) + # node is handled by the caller + return FILTER_REJECT + if val not in _ALLOWED_FILTER_RETURNS: + raise ValueError( + "acceptNode() returned illegal value: " + repr(val)) + return val + else: + return FILTER_ACCEPT + + _nodetype_mask = { + Node.ELEMENT_NODE: NodeFilter.SHOW_ELEMENT, + Node.ATTRIBUTE_NODE: NodeFilter.SHOW_ATTRIBUTE, + Node.TEXT_NODE: NodeFilter.SHOW_TEXT, + Node.CDATA_SECTION_NODE: NodeFilter.SHOW_CDATA_SECTION, + Node.ENTITY_REFERENCE_NODE: NodeFilter.SHOW_ENTITY_REFERENCE, + Node.ENTITY_NODE: NodeFilter.SHOW_ENTITY, + Node.PROCESSING_INSTRUCTION_NODE: NodeFilter.SHOW_PROCESSING_INSTRUCTION, + Node.COMMENT_NODE: NodeFilter.SHOW_COMMENT, + Node.DOCUMENT_NODE: NodeFilter.SHOW_DOCUMENT, + Node.DOCUMENT_TYPE_NODE: NodeFilter.SHOW_DOCUMENT_TYPE, + Node.DOCUMENT_FRAGMENT_NODE: NodeFilter.SHOW_DOCUMENT_FRAGMENT, + Node.NOTATION_NODE: NodeFilter.SHOW_NOTATION, + } + + +class FilterCrutch(object): + __slots__ = '_builder', '_level', '_old_start', '_old_end' + + def __init__(self, builder): + self._level = 0 + self._builder = builder + parser = builder._parser + self._old_start = parser.StartElementHandler + self._old_end = parser.EndElementHandler + parser.StartElementHandler = self.start_element_handler + parser.EndElementHandler = self.end_element_handler + +class Rejecter(FilterCrutch): + __slots__ = () + + def __init__(self, builder): + FilterCrutch.__init__(self, builder) + parser = builder._parser + for name in ("ProcessingInstructionHandler", + "CommentHandler", + "CharacterDataHandler", + "StartCdataSectionHandler", + "EndCdataSectionHandler", + "ExternalEntityRefHandler", + ): + setattr(parser, name, None) + + def start_element_handler(self, *args): + self._level = self._level + 1 + + def end_element_handler(self, *args): + if self._level == 0: + # restore the old handlers + parser = self._builder._parser + self._builder.install(parser) + parser.StartElementHandler = self._old_start + parser.EndElementHandler = self._old_end + else: + self._level = self._level - 1 + +class Skipper(FilterCrutch): + __slots__ = () + + def start_element_handler(self, *args): + node = self._builder.curNode + self._old_start(*args) + if self._builder.curNode is not node: + self._level = self._level + 1 + + def end_element_handler(self, *args): + if self._level == 0: + # We're popping back out of the node we're skipping, so we + # shouldn't need to do anything but reset the handlers. + self._builder._parser.StartElementHandler = self._old_start + self._builder._parser.EndElementHandler = self._old_end + self._builder = None + else: + self._level = self._level - 1 + self._old_end(*args) + + +# framework document used by the fragment builder. +# Takes a string for the doctype, subset string, and namespace attrs string. + +_FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID = \ + "http://xml.python.org/entities/fragment-builder/internal" + +_FRAGMENT_BUILDER_TEMPLATE = ( + '''\ + +%%s +]> +&fragment-builder-internal;''' + % _FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID) + + +class FragmentBuilder(ExpatBuilder): + """Builder which constructs document fragments given XML source + text and a context node. + + The context node is expected to provide information about the + namespace declarations which are in scope at the start of the + fragment. + """ + + def __init__(self, context, options=None): + if context.nodeType == DOCUMENT_NODE: + self.originalDocument = context + self.context = context + else: + self.originalDocument = context.ownerDocument + self.context = context + ExpatBuilder.__init__(self, options) + + def reset(self): + ExpatBuilder.reset(self) + self.fragment = None + + def parseFile(self, file): + """Parse a document fragment from a file object, returning the + fragment node.""" + return self.parseString(file.read()) + + def parseString(self, string): + """Parse a document fragment from a string, returning the + fragment node.""" + self._source = string + parser = self.getParser() + doctype = self.originalDocument.doctype + ident = "" + if doctype: + subset = doctype.internalSubset or self._getDeclarations() + if doctype.publicId: + ident = ('PUBLIC "%s" "%s"' + % (doctype.publicId, doctype.systemId)) + elif doctype.systemId: + ident = 'SYSTEM "%s"' % doctype.systemId + else: + subset = "" + nsattrs = self._getNSattrs() # get ns decls from node's ancestors + document = _FRAGMENT_BUILDER_TEMPLATE % (ident, subset, nsattrs) + try: + parser.Parse(document, True) + except: + self.reset() + raise + fragment = self.fragment + self.reset() +## self._parser = None + return fragment + + def _getDeclarations(self): + """Re-create the internal subset from the DocumentType node. + + This is only needed if we don't already have the + internalSubset as a string. + """ + doctype = self.context.ownerDocument.doctype + s = "" + if doctype: + for i in range(doctype.notations.length): + notation = doctype.notations.item(i) + if s: + s = s + "\n " + s = "%s' \ + % (s, notation.publicId, notation.systemId) + else: + s = '%s SYSTEM "%s">' % (s, notation.systemId) + for i in range(doctype.entities.length): + entity = doctype.entities.item(i) + if s: + s = s + "\n " + s = "%s" + return s + + def _getNSattrs(self): + return "" + + def external_entity_ref_handler(self, context, base, systemId, publicId): + if systemId == _FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID: + # this entref is the one that we made to put the subtree + # in; all of our given input is parsed in here. + old_document = self.document + old_cur_node = self.curNode + parser = self._parser.ExternalEntityParserCreate(context) + # put the real document back, parse into the fragment to return + self.document = self.originalDocument + self.fragment = self.document.createDocumentFragment() + self.curNode = self.fragment + try: + parser.Parse(self._source, True) + finally: + self.curNode = old_cur_node + self.document = old_document + self._source = None + return -1 + else: + return ExpatBuilder.external_entity_ref_handler( + self, context, base, systemId, publicId) + + +class Namespaces: + """Mix-in class for builders; adds support for namespaces.""" + + def _initNamespaces(self): + # list of (prefix, uri) ns declarations. Namespace attrs are + # constructed from this and added to the element's attrs. + self._ns_ordered_prefixes = [] + + def createParser(self): + """Create a new namespace-handling parser.""" + parser = expat.ParserCreate(namespace_separator=" ") + parser.namespace_prefixes = True + return parser + + def install(self, parser): + """Insert the namespace-handlers onto the parser.""" + ExpatBuilder.install(self, parser) + if self._options.namespace_declarations: + parser.StartNamespaceDeclHandler = ( + self.start_namespace_decl_handler) + + def start_namespace_decl_handler(self, prefix, uri): + """Push this namespace declaration on our storage.""" + self._ns_ordered_prefixes.append((prefix, uri)) + + def start_element_handler(self, name, attributes): + if ' ' in name: + uri, localname, prefix, qname = _parse_ns_name(self, name) + else: + uri = EMPTY_NAMESPACE + qname = name + localname = None + prefix = EMPTY_PREFIX + node = minidom.Element(qname, uri, prefix, localname) + node.ownerDocument = self.document + _append_child(self.curNode, node) + self.curNode = node + + if self._ns_ordered_prefixes: + for prefix, uri in self._ns_ordered_prefixes: + if prefix: + a = minidom.Attr(_intern(self, 'xmlns:' + prefix), + XMLNS_NAMESPACE, prefix, "xmlns") + else: + a = minidom.Attr("xmlns", XMLNS_NAMESPACE, + "xmlns", EMPTY_PREFIX) + a.value = uri + a.ownerDocument = self.document + _set_attribute_node(node, a) + del self._ns_ordered_prefixes[:] + + if attributes: + node._ensure_attributes() + _attrs = node._attrs + _attrsNS = node._attrsNS + for i in range(0, len(attributes), 2): + aname = attributes[i] + value = attributes[i+1] + if ' ' in aname: + uri, localname, prefix, qname = _parse_ns_name(self, aname) + a = minidom.Attr(qname, uri, localname, prefix) + _attrs[qname] = a + _attrsNS[(uri, localname)] = a + else: + a = minidom.Attr(aname, EMPTY_NAMESPACE, + aname, EMPTY_PREFIX) + _attrs[aname] = a + _attrsNS[(EMPTY_NAMESPACE, aname)] = a + a.ownerDocument = self.document + a.value = value + a.ownerElement = node + + if __debug__: + # This only adds some asserts to the original + # end_element_handler(), so we only define this when -O is not + # used. If changing one, be sure to check the other to see if + # it needs to be changed as well. + # + def end_element_handler(self, name): + curNode = self.curNode + if ' ' in name: + uri, localname, prefix, qname = _parse_ns_name(self, name) + assert (curNode.namespaceURI == uri + and curNode.localName == localname + and curNode.prefix == prefix), \ + "element stack messed up! (namespace)" + else: + assert curNode.nodeName == name, \ + "element stack messed up - bad nodeName" + assert curNode.namespaceURI == EMPTY_NAMESPACE, \ + "element stack messed up - bad namespaceURI" + self.curNode = curNode.parentNode + self._finish_end_element(curNode) + + +class ExpatBuilderNS(Namespaces, ExpatBuilder): + """Document builder that supports namespaces.""" + + def reset(self): + ExpatBuilder.reset(self) + self._initNamespaces() + + +class FragmentBuilderNS(Namespaces, FragmentBuilder): + """Fragment builder that supports namespaces.""" + + def reset(self): + FragmentBuilder.reset(self) + self._initNamespaces() + + def _getNSattrs(self): + """Return string of namespace attributes from this element and + ancestors.""" + # XXX This needs to be re-written to walk the ancestors of the + # context to build up the namespace information from + # declarations, elements, and attributes found in context. + # Otherwise we have to store a bunch more data on the DOM + # (though that *might* be more reliable -- not clear). + attrs = "" + context = self.context + L = [] + while context: + if hasattr(context, '_ns_prefix_uri'): + for prefix, uri in context._ns_prefix_uri.items(): + # add every new NS decl from context to L and attrs string + if prefix in L: + continue + L.append(prefix) + if prefix: + declname = "xmlns:" + prefix + else: + declname = "xmlns" + if attrs: + attrs = "%s\n %s='%s'" % (attrs, declname, uri) + else: + attrs = " %s='%s'" % (declname, uri) + context = context.parentNode + return attrs + + +class ParseEscape(Exception): + """Exception raised to short-circuit parsing in InternalSubsetExtractor.""" + pass + +class InternalSubsetExtractor(ExpatBuilder): + """XML processor which can rip out the internal document type subset.""" + + subset = None + + def getSubset(self): + """Return the internal subset as a string.""" + return self.subset + + def parseFile(self, file): + try: + ExpatBuilder.parseFile(self, file) + except ParseEscape: + pass + + def parseString(self, string): + try: + ExpatBuilder.parseString(self, string) + except ParseEscape: + pass + + def install(self, parser): + parser.StartDoctypeDeclHandler = self.start_doctype_decl_handler + parser.StartElementHandler = self.start_element_handler + + def start_doctype_decl_handler(self, name, publicId, systemId, + has_internal_subset): + if has_internal_subset: + parser = self.getParser() + self.subset = [] + parser.DefaultHandler = self.subset.append + parser.EndDoctypeDeclHandler = self.end_doctype_decl_handler + else: + raise ParseEscape() + + def end_doctype_decl_handler(self): + s = ''.join(self.subset).replace('\r\n', '\n').replace('\r', '\n') + self.subset = s + raise ParseEscape() + + def start_element_handler(self, name, attrs): + raise ParseEscape() + + +def parse(file, namespaces=True): + """Parse a document, returning the resulting Document node. + + 'file' may be either a file name or an open file object. + """ + if namespaces: + builder = ExpatBuilderNS() + else: + builder = ExpatBuilder() + + if isinstance(file, str): + with open(file, 'rb') as fp: + result = builder.parseFile(fp) + else: + result = builder.parseFile(file) + return result + + +def parseString(string, namespaces=True): + """Parse a document from a string, returning the resulting + Document node. + """ + if namespaces: + builder = ExpatBuilderNS() + else: + builder = ExpatBuilder() + return builder.parseString(string) + + +def parseFragment(file, context, namespaces=True): + """Parse a fragment of a document, given the context from which it + was originally extracted. context should be the parent of the + node(s) which are in the fragment. + + 'file' may be either a file name or an open file object. + """ + if namespaces: + builder = FragmentBuilderNS(context) + else: + builder = FragmentBuilder(context) + + if isinstance(file, str): + with open(file, 'rb') as fp: + result = builder.parseFile(fp) + else: + result = builder.parseFile(file) + return result + + +def parseFragmentString(string, context, namespaces=True): + """Parse a fragment of a document from a string, given the context + from which it was originally extracted. context should be the + parent of the node(s) which are in the fragment. + """ + if namespaces: + builder = FragmentBuilderNS(context) + else: + builder = FragmentBuilder(context) + return builder.parseString(string) + + +def makeBuilder(options): + """Create a builder based on an Options object.""" + if options.namespaces: + return ExpatBuilderNS(options) + else: + return ExpatBuilder(options) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/minicompat.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/minicompat.py new file mode 100644 index 0000000000000000000000000000000000000000..5d6fae9a2575bf502999b3c59aeecb7b93a37385 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/minicompat.py @@ -0,0 +1,109 @@ +"""Python version compatibility support for minidom. + +This module contains internal implementation details and +should not be imported; use xml.dom.minidom instead. +""" + +# This module should only be imported using "import *". +# +# The following names are defined: +# +# NodeList -- lightest possible NodeList implementation +# +# EmptyNodeList -- lightest possible NodeList that is guaranteed to +# remain empty (immutable) +# +# StringTypes -- tuple of defined string types +# +# defproperty -- function used in conjunction with GetattrMagic; +# using these together is needed to make them work +# as efficiently as possible in both Python 2.2+ +# and older versions. For example: +# +# class MyClass(GetattrMagic): +# def _get_myattr(self): +# return something +# +# defproperty(MyClass, "myattr", +# "return some value") +# +# For Python 2.2 and newer, this will construct a +# property object on the class, which avoids +# needing to override __getattr__(). It will only +# work for read-only attributes. +# +# For older versions of Python, inheriting from +# GetattrMagic will use the traditional +# __getattr__() hackery to achieve the same effect, +# but less efficiently. +# +# defproperty() should be used for each version of +# the relevant _get_() function. + +__all__ = ["NodeList", "EmptyNodeList", "StringTypes", "defproperty"] + +import xml.dom + +StringTypes = (str,) + + +class NodeList(list): + __slots__ = () + + def item(self, index): + if 0 <= index < len(self): + return self[index] + + def _get_length(self): + return len(self) + + def _set_length(self, value): + raise xml.dom.NoModificationAllowedErr( + "attempt to modify read-only attribute 'length'") + + length = property(_get_length, _set_length, + doc="The number of nodes in the NodeList.") + + # For backward compatibility + def __setstate__(self, state): + if state is None: + state = [] + self[:] = state + + +class EmptyNodeList(tuple): + __slots__ = () + + def __add__(self, other): + NL = NodeList() + NL.extend(other) + return NL + + def __radd__(self, other): + NL = NodeList() + NL.extend(other) + return NL + + def item(self, index): + return None + + def _get_length(self): + return 0 + + def _set_length(self, value): + raise xml.dom.NoModificationAllowedErr( + "attempt to modify read-only attribute 'length'") + + length = property(_get_length, _set_length, + doc="The number of nodes in the NodeList.") + + +def defproperty(klass, name, doc): + get = getattr(klass, ("_get_" + name)) + def set(self, value, name=name): + raise xml.dom.NoModificationAllowedErr( + "attempt to modify read-only attribute " + repr(name)) + assert not hasattr(klass, "_set_" + name), \ + "expected not to find _set_" + name + prop = property(get, set, doc=doc) + setattr(klass, name, prop) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/minidom.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/minidom.py new file mode 100644 index 0000000000000000000000000000000000000000..cada981f39f3ee979840b94257ca27747f9776b7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/minidom.py @@ -0,0 +1,2008 @@ +"""Simple implementation of the Level 1 DOM. + +Namespaces and other minor Level 2 features are also supported. + +parse("foo.xml") + +parseString("") + +Todo: +===== + * convenience methods for getting elements and text. + * more testing + * bring some of the writer and linearizer code into conformance with this + interface + * SAX 2 namespaces +""" + +import io +import xml.dom + +from xml.dom import EMPTY_NAMESPACE, EMPTY_PREFIX, XMLNS_NAMESPACE, domreg +from xml.dom.minicompat import * +from xml.dom.xmlbuilder import DOMImplementationLS, DocumentLS + +# This is used by the ID-cache invalidation checks; the list isn't +# actually complete, since the nodes being checked will never be the +# DOCUMENT_NODE or DOCUMENT_FRAGMENT_NODE. (The node being checked is +# the node being added or removed, not the node being modified.) +# +_nodeTypes_with_children = (xml.dom.Node.ELEMENT_NODE, + xml.dom.Node.ENTITY_REFERENCE_NODE) + + +class Node(xml.dom.Node): + namespaceURI = None # this is non-null only for elements and attributes + parentNode = None + ownerDocument = None + nextSibling = None + previousSibling = None + + prefix = EMPTY_PREFIX # non-null only for NS elements and attributes + + def __bool__(self): + return True + + def toxml(self, encoding=None, standalone=None): + return self.toprettyxml("", "", encoding, standalone) + + def toprettyxml(self, indent="\t", newl="\n", encoding=None, + standalone=None): + if encoding is None: + writer = io.StringIO() + else: + writer = io.TextIOWrapper(io.BytesIO(), + encoding=encoding, + errors="xmlcharrefreplace", + newline='\n') + if self.nodeType == Node.DOCUMENT_NODE: + # Can pass encoding only to document, to put it into XML header + self.writexml(writer, "", indent, newl, encoding, standalone) + else: + self.writexml(writer, "", indent, newl) + if encoding is None: + return writer.getvalue() + else: + return writer.detach().getvalue() + + def hasChildNodes(self): + return bool(self.childNodes) + + def _get_childNodes(self): + return self.childNodes + + def _get_firstChild(self): + if self.childNodes: + return self.childNodes[0] + + def _get_lastChild(self): + if self.childNodes: + return self.childNodes[-1] + + def insertBefore(self, newChild, refChild): + if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE: + for c in tuple(newChild.childNodes): + self.insertBefore(c, refChild) + ### The DOM does not clearly specify what to return in this case + return newChild + if newChild.nodeType not in self._child_node_types: + raise xml.dom.HierarchyRequestErr( + "%s cannot be child of %s" % (repr(newChild), repr(self))) + if newChild.parentNode is not None: + newChild.parentNode.removeChild(newChild) + if refChild is None: + self.appendChild(newChild) + else: + try: + index = self.childNodes.index(refChild) + except ValueError: + raise xml.dom.NotFoundErr() + if newChild.nodeType in _nodeTypes_with_children: + _clear_id_cache(self) + self.childNodes.insert(index, newChild) + newChild.nextSibling = refChild + refChild.previousSibling = newChild + if index: + node = self.childNodes[index-1] + node.nextSibling = newChild + newChild.previousSibling = node + else: + newChild.previousSibling = None + newChild.parentNode = self + return newChild + + def appendChild(self, node): + if node.nodeType == self.DOCUMENT_FRAGMENT_NODE: + for c in tuple(node.childNodes): + self.appendChild(c) + ### The DOM does not clearly specify what to return in this case + return node + if node.nodeType not in self._child_node_types: + raise xml.dom.HierarchyRequestErr( + "%s cannot be child of %s" % (repr(node), repr(self))) + elif node.nodeType in _nodeTypes_with_children: + _clear_id_cache(self) + if node.parentNode is not None: + node.parentNode.removeChild(node) + _append_child(self, node) + node.nextSibling = None + return node + + def replaceChild(self, newChild, oldChild): + if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE: + refChild = oldChild.nextSibling + self.removeChild(oldChild) + return self.insertBefore(newChild, refChild) + if newChild.nodeType not in self._child_node_types: + raise xml.dom.HierarchyRequestErr( + "%s cannot be child of %s" % (repr(newChild), repr(self))) + if newChild is oldChild: + return + if newChild.parentNode is not None: + newChild.parentNode.removeChild(newChild) + try: + index = self.childNodes.index(oldChild) + except ValueError: + raise xml.dom.NotFoundErr() + self.childNodes[index] = newChild + newChild.parentNode = self + oldChild.parentNode = None + if (newChild.nodeType in _nodeTypes_with_children + or oldChild.nodeType in _nodeTypes_with_children): + _clear_id_cache(self) + newChild.nextSibling = oldChild.nextSibling + newChild.previousSibling = oldChild.previousSibling + oldChild.nextSibling = None + oldChild.previousSibling = None + if newChild.previousSibling: + newChild.previousSibling.nextSibling = newChild + if newChild.nextSibling: + newChild.nextSibling.previousSibling = newChild + return oldChild + + def removeChild(self, oldChild): + try: + self.childNodes.remove(oldChild) + except ValueError: + raise xml.dom.NotFoundErr() + if oldChild.nextSibling is not None: + oldChild.nextSibling.previousSibling = oldChild.previousSibling + if oldChild.previousSibling is not None: + oldChild.previousSibling.nextSibling = oldChild.nextSibling + oldChild.nextSibling = oldChild.previousSibling = None + if oldChild.nodeType in _nodeTypes_with_children: + _clear_id_cache(self) + + oldChild.parentNode = None + return oldChild + + def normalize(self): + L = [] + for child in self.childNodes: + if child.nodeType == Node.TEXT_NODE: + if not child.data: + # empty text node; discard + if L: + L[-1].nextSibling = child.nextSibling + if child.nextSibling: + child.nextSibling.previousSibling = child.previousSibling + child.unlink() + elif L and L[-1].nodeType == child.nodeType: + # collapse text node + node = L[-1] + node.data = node.data + child.data + node.nextSibling = child.nextSibling + if child.nextSibling: + child.nextSibling.previousSibling = node + child.unlink() + else: + L.append(child) + else: + L.append(child) + if child.nodeType == Node.ELEMENT_NODE: + child.normalize() + self.childNodes[:] = L + + def cloneNode(self, deep): + return _clone_node(self, deep, self.ownerDocument or self) + + def isSupported(self, feature, version): + return self.ownerDocument.implementation.hasFeature(feature, version) + + def _get_localName(self): + # Overridden in Element and Attr where localName can be Non-Null + return None + + # Node interfaces from Level 3 (WD 9 April 2002) + + def isSameNode(self, other): + return self is other + + def getInterface(self, feature): + if self.isSupported(feature, None): + return self + else: + return None + + # The "user data" functions use a dictionary that is only present + # if some user data has been set, so be careful not to assume it + # exists. + + def getUserData(self, key): + try: + return self._user_data[key][0] + except (AttributeError, KeyError): + return None + + def setUserData(self, key, data, handler): + old = None + try: + d = self._user_data + except AttributeError: + d = {} + self._user_data = d + if key in d: + old = d[key][0] + if data is None: + # ignore handlers passed for None + handler = None + if old is not None: + del d[key] + else: + d[key] = (data, handler) + return old + + def _call_user_data_handler(self, operation, src, dst): + if hasattr(self, "_user_data"): + for key, (data, handler) in list(self._user_data.items()): + if handler is not None: + handler.handle(operation, key, data, src, dst) + + # minidom-specific API: + + def unlink(self): + self.parentNode = self.ownerDocument = None + if self.childNodes: + for child in self.childNodes: + child.unlink() + self.childNodes = NodeList() + self.previousSibling = None + self.nextSibling = None + + # A Node is its own context manager, to ensure that an unlink() call occurs. + # This is similar to how a file object works. + def __enter__(self): + return self + + def __exit__(self, et, ev, tb): + self.unlink() + +defproperty(Node, "firstChild", doc="First child node, or None.") +defproperty(Node, "lastChild", doc="Last child node, or None.") +defproperty(Node, "localName", doc="Namespace-local name of this node.") + + +def _append_child(self, node): + # fast path with less checks; usable by DOM builders if careful + childNodes = self.childNodes + if childNodes: + last = childNodes[-1] + node.previousSibling = last + last.nextSibling = node + childNodes.append(node) + node.parentNode = self + + +def _write_data(writer, data): + "Writes datachars to writer." + if data: + data = data.replace("&", "&").replace("<", "<"). \ + replace("\"", """).replace(">", ">") + writer.write(data) + +def _get_elements_by_tagName_helper(parent, name, rc): + for node in parent.childNodes: + if node.nodeType == Node.ELEMENT_NODE and \ + (name == "*" or node.tagName == name): + rc.append(node) + _get_elements_by_tagName_helper(node, name, rc) + return rc + +def _get_elements_by_tagName_ns_helper(parent, nsURI, localName, rc): + for node in parent.childNodes: + if node.nodeType == Node.ELEMENT_NODE: + if ((localName == "*" or node.localName == localName) and + (nsURI == "*" or node.namespaceURI == nsURI)): + rc.append(node) + _get_elements_by_tagName_ns_helper(node, nsURI, localName, rc) + return rc + +class DocumentFragment(Node): + nodeType = Node.DOCUMENT_FRAGMENT_NODE + nodeName = "#document-fragment" + nodeValue = None + attributes = None + parentNode = None + _child_node_types = (Node.ELEMENT_NODE, + Node.TEXT_NODE, + Node.CDATA_SECTION_NODE, + Node.ENTITY_REFERENCE_NODE, + Node.PROCESSING_INSTRUCTION_NODE, + Node.COMMENT_NODE, + Node.NOTATION_NODE) + + def __init__(self): + self.childNodes = NodeList() + + +class Attr(Node): + __slots__=('_name', '_value', 'namespaceURI', + '_prefix', 'childNodes', '_localName', 'ownerDocument', 'ownerElement') + nodeType = Node.ATTRIBUTE_NODE + attributes = None + specified = False + _is_id = False + + _child_node_types = (Node.TEXT_NODE, Node.ENTITY_REFERENCE_NODE) + + def __init__(self, qName, namespaceURI=EMPTY_NAMESPACE, localName=None, + prefix=None): + self.ownerElement = None + self.ownerDocument = None + self._name = qName + self.namespaceURI = namespaceURI + self._prefix = prefix + if localName is not None: + self._localName = localName + self.childNodes = NodeList() + + # Add the single child node that represents the value of the attr + self.childNodes.append(Text()) + + # nodeValue and value are set elsewhere + + def _get_localName(self): + try: + return self._localName + except AttributeError: + return self.nodeName.split(":", 1)[-1] + + def _get_specified(self): + return self.specified + + def _get_name(self): + return self._name + + def _set_name(self, value): + self._name = value + if self.ownerElement is not None: + _clear_id_cache(self.ownerElement) + + nodeName = name = property(_get_name, _set_name) + + def _get_value(self): + return self._value + + def _set_value(self, value): + self._value = value + self.childNodes[0].data = value + if self.ownerElement is not None: + _clear_id_cache(self.ownerElement) + self.childNodes[0].data = value + + nodeValue = value = property(_get_value, _set_value) + + def _get_prefix(self): + return self._prefix + + def _set_prefix(self, prefix): + nsuri = self.namespaceURI + if prefix == "xmlns": + if nsuri and nsuri != XMLNS_NAMESPACE: + raise xml.dom.NamespaceErr( + "illegal use of 'xmlns' prefix for the wrong namespace") + self._prefix = prefix + if prefix is None: + newName = self.localName + else: + newName = "%s:%s" % (prefix, self.localName) + if self.ownerElement: + _clear_id_cache(self.ownerElement) + self.name = newName + + prefix = property(_get_prefix, _set_prefix) + + def unlink(self): + # This implementation does not call the base implementation + # since most of that is not needed, and the expense of the + # method call is not warranted. We duplicate the removal of + # children, but that's all we needed from the base class. + elem = self.ownerElement + if elem is not None: + del elem._attrs[self.nodeName] + del elem._attrsNS[(self.namespaceURI, self.localName)] + if self._is_id: + self._is_id = False + elem._magic_id_nodes -= 1 + self.ownerDocument._magic_id_count -= 1 + for child in self.childNodes: + child.unlink() + del self.childNodes[:] + + def _get_isId(self): + if self._is_id: + return True + doc = self.ownerDocument + elem = self.ownerElement + if doc is None or elem is None: + return False + + info = doc._get_elem_info(elem) + if info is None: + return False + if self.namespaceURI: + return info.isIdNS(self.namespaceURI, self.localName) + else: + return info.isId(self.nodeName) + + def _get_schemaType(self): + doc = self.ownerDocument + elem = self.ownerElement + if doc is None or elem is None: + return _no_type + + info = doc._get_elem_info(elem) + if info is None: + return _no_type + if self.namespaceURI: + return info.getAttributeTypeNS(self.namespaceURI, self.localName) + else: + return info.getAttributeType(self.nodeName) + +defproperty(Attr, "isId", doc="True if this attribute is an ID.") +defproperty(Attr, "localName", doc="Namespace-local name of this attribute.") +defproperty(Attr, "schemaType", doc="Schema type for this attribute.") + + +class NamedNodeMap(object): + """The attribute list is a transient interface to the underlying + dictionaries. Mutations here will change the underlying element's + dictionary. + + Ordering is imposed artificially and does not reflect the order of + attributes as found in an input document. + """ + + __slots__ = ('_attrs', '_attrsNS', '_ownerElement') + + def __init__(self, attrs, attrsNS, ownerElement): + self._attrs = attrs + self._attrsNS = attrsNS + self._ownerElement = ownerElement + + def _get_length(self): + return len(self._attrs) + + def item(self, index): + try: + return self[list(self._attrs.keys())[index]] + except IndexError: + return None + + def items(self): + L = [] + for node in self._attrs.values(): + L.append((node.nodeName, node.value)) + return L + + def itemsNS(self): + L = [] + for node in self._attrs.values(): + L.append(((node.namespaceURI, node.localName), node.value)) + return L + + def __contains__(self, key): + if isinstance(key, str): + return key in self._attrs + else: + return key in self._attrsNS + + def keys(self): + return self._attrs.keys() + + def keysNS(self): + return self._attrsNS.keys() + + def values(self): + return self._attrs.values() + + def get(self, name, value=None): + return self._attrs.get(name, value) + + __len__ = _get_length + + def _cmp(self, other): + if self._attrs is getattr(other, "_attrs", None): + return 0 + else: + return (id(self) > id(other)) - (id(self) < id(other)) + + def __eq__(self, other): + return self._cmp(other) == 0 + + def __ge__(self, other): + return self._cmp(other) >= 0 + + def __gt__(self, other): + return self._cmp(other) > 0 + + def __le__(self, other): + return self._cmp(other) <= 0 + + def __lt__(self, other): + return self._cmp(other) < 0 + + def __getitem__(self, attname_or_tuple): + if isinstance(attname_or_tuple, tuple): + return self._attrsNS[attname_or_tuple] + else: + return self._attrs[attname_or_tuple] + + # same as set + def __setitem__(self, attname, value): + if isinstance(value, str): + try: + node = self._attrs[attname] + except KeyError: + node = Attr(attname) + node.ownerDocument = self._ownerElement.ownerDocument + self.setNamedItem(node) + node.value = value + else: + if not isinstance(value, Attr): + raise TypeError("value must be a string or Attr object") + node = value + self.setNamedItem(node) + + def getNamedItem(self, name): + try: + return self._attrs[name] + except KeyError: + return None + + def getNamedItemNS(self, namespaceURI, localName): + try: + return self._attrsNS[(namespaceURI, localName)] + except KeyError: + return None + + def removeNamedItem(self, name): + n = self.getNamedItem(name) + if n is not None: + _clear_id_cache(self._ownerElement) + del self._attrs[n.nodeName] + del self._attrsNS[(n.namespaceURI, n.localName)] + if hasattr(n, 'ownerElement'): + n.ownerElement = None + return n + else: + raise xml.dom.NotFoundErr() + + def removeNamedItemNS(self, namespaceURI, localName): + n = self.getNamedItemNS(namespaceURI, localName) + if n is not None: + _clear_id_cache(self._ownerElement) + del self._attrsNS[(n.namespaceURI, n.localName)] + del self._attrs[n.nodeName] + if hasattr(n, 'ownerElement'): + n.ownerElement = None + return n + else: + raise xml.dom.NotFoundErr() + + def setNamedItem(self, node): + if not isinstance(node, Attr): + raise xml.dom.HierarchyRequestErr( + "%s cannot be child of %s" % (repr(node), repr(self))) + old = self._attrs.get(node.name) + if old: + old.unlink() + self._attrs[node.name] = node + self._attrsNS[(node.namespaceURI, node.localName)] = node + node.ownerElement = self._ownerElement + _clear_id_cache(node.ownerElement) + return old + + def setNamedItemNS(self, node): + return self.setNamedItem(node) + + def __delitem__(self, attname_or_tuple): + node = self[attname_or_tuple] + _clear_id_cache(node.ownerElement) + node.unlink() + + def __getstate__(self): + return self._attrs, self._attrsNS, self._ownerElement + + def __setstate__(self, state): + self._attrs, self._attrsNS, self._ownerElement = state + +defproperty(NamedNodeMap, "length", + doc="Number of nodes in the NamedNodeMap.") + +AttributeList = NamedNodeMap + + +class TypeInfo(object): + __slots__ = 'namespace', 'name' + + def __init__(self, namespace, name): + self.namespace = namespace + self.name = name + + def __repr__(self): + if self.namespace: + return "<%s %r (from %r)>" % (self.__class__.__name__, self.name, + self.namespace) + else: + return "<%s %r>" % (self.__class__.__name__, self.name) + + def _get_name(self): + return self.name + + def _get_namespace(self): + return self.namespace + +_no_type = TypeInfo(None, None) + +class Element(Node): + __slots__=('ownerDocument', 'parentNode', 'tagName', 'nodeName', 'prefix', + 'namespaceURI', '_localName', 'childNodes', '_attrs', '_attrsNS', + 'nextSibling', 'previousSibling') + nodeType = Node.ELEMENT_NODE + nodeValue = None + schemaType = _no_type + + _magic_id_nodes = 0 + + _child_node_types = (Node.ELEMENT_NODE, + Node.PROCESSING_INSTRUCTION_NODE, + Node.COMMENT_NODE, + Node.TEXT_NODE, + Node.CDATA_SECTION_NODE, + Node.ENTITY_REFERENCE_NODE) + + def __init__(self, tagName, namespaceURI=EMPTY_NAMESPACE, prefix=None, + localName=None): + self.ownerDocument = None + self.parentNode = None + self.tagName = self.nodeName = tagName + self.prefix = prefix + self.namespaceURI = namespaceURI + self.childNodes = NodeList() + self.nextSibling = self.previousSibling = None + + # Attribute dictionaries are lazily created + # attributes are double-indexed: + # tagName -> Attribute + # URI,localName -> Attribute + # in the future: consider lazy generation + # of attribute objects this is too tricky + # for now because of headaches with + # namespaces. + self._attrs = None + self._attrsNS = None + + def _ensure_attributes(self): + if self._attrs is None: + self._attrs = {} + self._attrsNS = {} + + def _get_localName(self): + try: + return self._localName + except AttributeError: + return self.tagName.split(":", 1)[-1] + + def _get_tagName(self): + return self.tagName + + def unlink(self): + if self._attrs is not None: + for attr in list(self._attrs.values()): + attr.unlink() + self._attrs = None + self._attrsNS = None + Node.unlink(self) + + def getAttribute(self, attname): + """Returns the value of the specified attribute. + + Returns the value of the element's attribute named attname as + a string. An empty string is returned if the element does not + have such an attribute. Note that an empty string may also be + returned as an explicitly given attribute value, use the + hasAttribute method to distinguish these two cases. + """ + if self._attrs is None: + return "" + try: + return self._attrs[attname].value + except KeyError: + return "" + + def getAttributeNS(self, namespaceURI, localName): + if self._attrsNS is None: + return "" + try: + return self._attrsNS[(namespaceURI, localName)].value + except KeyError: + return "" + + def setAttribute(self, attname, value): + attr = self.getAttributeNode(attname) + if attr is None: + attr = Attr(attname) + attr.value = value # also sets nodeValue + attr.ownerDocument = self.ownerDocument + self.setAttributeNode(attr) + elif value != attr.value: + attr.value = value + if attr.isId: + _clear_id_cache(self) + + def setAttributeNS(self, namespaceURI, qualifiedName, value): + prefix, localname = _nssplit(qualifiedName) + attr = self.getAttributeNodeNS(namespaceURI, localname) + if attr is None: + attr = Attr(qualifiedName, namespaceURI, localname, prefix) + attr.value = value + attr.ownerDocument = self.ownerDocument + self.setAttributeNode(attr) + else: + if value != attr.value: + attr.value = value + if attr.isId: + _clear_id_cache(self) + if attr.prefix != prefix: + attr.prefix = prefix + attr.nodeName = qualifiedName + + def getAttributeNode(self, attrname): + if self._attrs is None: + return None + return self._attrs.get(attrname) + + def getAttributeNodeNS(self, namespaceURI, localName): + if self._attrsNS is None: + return None + return self._attrsNS.get((namespaceURI, localName)) + + def setAttributeNode(self, attr): + if attr.ownerElement not in (None, self): + raise xml.dom.InuseAttributeErr("attribute node already owned") + self._ensure_attributes() + old1 = self._attrs.get(attr.name, None) + if old1 is not None: + self.removeAttributeNode(old1) + old2 = self._attrsNS.get((attr.namespaceURI, attr.localName), None) + if old2 is not None and old2 is not old1: + self.removeAttributeNode(old2) + _set_attribute_node(self, attr) + + if old1 is not attr: + # It might have already been part of this node, in which case + # it doesn't represent a change, and should not be returned. + return old1 + if old2 is not attr: + return old2 + + setAttributeNodeNS = setAttributeNode + + def removeAttribute(self, name): + if self._attrsNS is None: + raise xml.dom.NotFoundErr() + try: + attr = self._attrs[name] + except KeyError: + raise xml.dom.NotFoundErr() + self.removeAttributeNode(attr) + + def removeAttributeNS(self, namespaceURI, localName): + if self._attrsNS is None: + raise xml.dom.NotFoundErr() + try: + attr = self._attrsNS[(namespaceURI, localName)] + except KeyError: + raise xml.dom.NotFoundErr() + self.removeAttributeNode(attr) + + def removeAttributeNode(self, node): + if node is None: + raise xml.dom.NotFoundErr() + try: + self._attrs[node.name] + except KeyError: + raise xml.dom.NotFoundErr() + _clear_id_cache(self) + node.unlink() + # Restore this since the node is still useful and otherwise + # unlinked + node.ownerDocument = self.ownerDocument + return node + + removeAttributeNodeNS = removeAttributeNode + + def hasAttribute(self, name): + """Checks whether the element has an attribute with the specified name. + + Returns True if the element has an attribute with the specified name. + Otherwise, returns False. + """ + if self._attrs is None: + return False + return name in self._attrs + + def hasAttributeNS(self, namespaceURI, localName): + if self._attrsNS is None: + return False + return (namespaceURI, localName) in self._attrsNS + + def getElementsByTagName(self, name): + """Returns all descendant elements with the given tag name. + + Returns the list of all descendant elements (not direct children + only) with the specified tag name. + """ + return _get_elements_by_tagName_helper(self, name, NodeList()) + + def getElementsByTagNameNS(self, namespaceURI, localName): + return _get_elements_by_tagName_ns_helper( + self, namespaceURI, localName, NodeList()) + + def __repr__(self): + return "" % (self.tagName, id(self)) + + def writexml(self, writer, indent="", addindent="", newl=""): + """Write an XML element to a file-like object + + Write the element to the writer object that must provide + a write method (e.g. a file or StringIO object). + """ + # indent = current indentation + # addindent = indentation to add to higher levels + # newl = newline string + writer.write(indent+"<" + self.tagName) + + attrs = self._get_attributes() + + for a_name in attrs.keys(): + writer.write(" %s=\"" % a_name) + _write_data(writer, attrs[a_name].value) + writer.write("\"") + if self.childNodes: + writer.write(">") + if (len(self.childNodes) == 1 and + self.childNodes[0].nodeType in ( + Node.TEXT_NODE, Node.CDATA_SECTION_NODE)): + self.childNodes[0].writexml(writer, '', '', '') + else: + writer.write(newl) + for node in self.childNodes: + node.writexml(writer, indent+addindent, addindent, newl) + writer.write(indent) + writer.write("%s" % (self.tagName, newl)) + else: + writer.write("/>%s"%(newl)) + + def _get_attributes(self): + self._ensure_attributes() + return NamedNodeMap(self._attrs, self._attrsNS, self) + + def hasAttributes(self): + if self._attrs: + return True + else: + return False + + # DOM Level 3 attributes, based on the 22 Oct 2002 draft + + def setIdAttribute(self, name): + idAttr = self.getAttributeNode(name) + self.setIdAttributeNode(idAttr) + + def setIdAttributeNS(self, namespaceURI, localName): + idAttr = self.getAttributeNodeNS(namespaceURI, localName) + self.setIdAttributeNode(idAttr) + + def setIdAttributeNode(self, idAttr): + if idAttr is None or not self.isSameNode(idAttr.ownerElement): + raise xml.dom.NotFoundErr() + if _get_containing_entref(self) is not None: + raise xml.dom.NoModificationAllowedErr() + if not idAttr._is_id: + idAttr._is_id = True + self._magic_id_nodes += 1 + self.ownerDocument._magic_id_count += 1 + _clear_id_cache(self) + +defproperty(Element, "attributes", + doc="NamedNodeMap of attributes on the element.") +defproperty(Element, "localName", + doc="Namespace-local name of this element.") + + +def _set_attribute_node(element, attr): + _clear_id_cache(element) + element._ensure_attributes() + element._attrs[attr.name] = attr + element._attrsNS[(attr.namespaceURI, attr.localName)] = attr + + # This creates a circular reference, but Element.unlink() + # breaks the cycle since the references to the attribute + # dictionaries are tossed. + attr.ownerElement = element + +class Childless: + """Mixin that makes childless-ness easy to implement and avoids + the complexity of the Node methods that deal with children. + """ + __slots__ = () + + attributes = None + childNodes = EmptyNodeList() + firstChild = None + lastChild = None + + def _get_firstChild(self): + return None + + def _get_lastChild(self): + return None + + def appendChild(self, node): + raise xml.dom.HierarchyRequestErr( + self.nodeName + " nodes cannot have children") + + def hasChildNodes(self): + return False + + def insertBefore(self, newChild, refChild): + raise xml.dom.HierarchyRequestErr( + self.nodeName + " nodes do not have children") + + def removeChild(self, oldChild): + raise xml.dom.NotFoundErr( + self.nodeName + " nodes do not have children") + + def normalize(self): + # For childless nodes, normalize() has nothing to do. + pass + + def replaceChild(self, newChild, oldChild): + raise xml.dom.HierarchyRequestErr( + self.nodeName + " nodes do not have children") + + +class ProcessingInstruction(Childless, Node): + nodeType = Node.PROCESSING_INSTRUCTION_NODE + __slots__ = ('target', 'data') + + def __init__(self, target, data): + self.target = target + self.data = data + + # nodeValue is an alias for data + def _get_nodeValue(self): + return self.data + def _set_nodeValue(self, value): + self.data = value + nodeValue = property(_get_nodeValue, _set_nodeValue) + + # nodeName is an alias for target + def _get_nodeName(self): + return self.target + def _set_nodeName(self, value): + self.target = value + nodeName = property(_get_nodeName, _set_nodeName) + + def writexml(self, writer, indent="", addindent="", newl=""): + writer.write("%s%s" % (indent,self.target, self.data, newl)) + + +class CharacterData(Childless, Node): + __slots__=('_data', 'ownerDocument','parentNode', 'previousSibling', 'nextSibling') + + def __init__(self): + self.ownerDocument = self.parentNode = None + self.previousSibling = self.nextSibling = None + self._data = '' + Node.__init__(self) + + def _get_length(self): + return len(self.data) + __len__ = _get_length + + def _get_data(self): + return self._data + def _set_data(self, data): + self._data = data + + data = nodeValue = property(_get_data, _set_data) + + def __repr__(self): + data = self.data + if len(data) > 10: + dotdotdot = "..." + else: + dotdotdot = "" + return '' % ( + self.__class__.__name__, data[0:10], dotdotdot) + + def substringData(self, offset, count): + if offset < 0: + raise xml.dom.IndexSizeErr("offset cannot be negative") + if offset >= len(self.data): + raise xml.dom.IndexSizeErr("offset cannot be beyond end of data") + if count < 0: + raise xml.dom.IndexSizeErr("count cannot be negative") + return self.data[offset:offset+count] + + def appendData(self, arg): + self.data = self.data + arg + + def insertData(self, offset, arg): + if offset < 0: + raise xml.dom.IndexSizeErr("offset cannot be negative") + if offset >= len(self.data): + raise xml.dom.IndexSizeErr("offset cannot be beyond end of data") + if arg: + self.data = "%s%s%s" % ( + self.data[:offset], arg, self.data[offset:]) + + def deleteData(self, offset, count): + if offset < 0: + raise xml.dom.IndexSizeErr("offset cannot be negative") + if offset >= len(self.data): + raise xml.dom.IndexSizeErr("offset cannot be beyond end of data") + if count < 0: + raise xml.dom.IndexSizeErr("count cannot be negative") + if count: + self.data = self.data[:offset] + self.data[offset+count:] + + def replaceData(self, offset, count, arg): + if offset < 0: + raise xml.dom.IndexSizeErr("offset cannot be negative") + if offset >= len(self.data): + raise xml.dom.IndexSizeErr("offset cannot be beyond end of data") + if count < 0: + raise xml.dom.IndexSizeErr("count cannot be negative") + if count: + self.data = "%s%s%s" % ( + self.data[:offset], arg, self.data[offset+count:]) + +defproperty(CharacterData, "length", doc="Length of the string data.") + + +class Text(CharacterData): + __slots__ = () + + nodeType = Node.TEXT_NODE + nodeName = "#text" + attributes = None + + def splitText(self, offset): + if offset < 0 or offset > len(self.data): + raise xml.dom.IndexSizeErr("illegal offset value") + newText = self.__class__() + newText.data = self.data[offset:] + newText.ownerDocument = self.ownerDocument + next = self.nextSibling + if self.parentNode and self in self.parentNode.childNodes: + if next is None: + self.parentNode.appendChild(newText) + else: + self.parentNode.insertBefore(newText, next) + self.data = self.data[:offset] + return newText + + def writexml(self, writer, indent="", addindent="", newl=""): + _write_data(writer, "%s%s%s" % (indent, self.data, newl)) + + # DOM Level 3 (WD 9 April 2002) + + def _get_wholeText(self): + L = [self.data] + n = self.previousSibling + while n is not None: + if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE): + L.insert(0, n.data) + n = n.previousSibling + else: + break + n = self.nextSibling + while n is not None: + if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE): + L.append(n.data) + n = n.nextSibling + else: + break + return ''.join(L) + + def replaceWholeText(self, content): + # XXX This needs to be seriously changed if minidom ever + # supports EntityReference nodes. + parent = self.parentNode + n = self.previousSibling + while n is not None: + if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE): + next = n.previousSibling + parent.removeChild(n) + n = next + else: + break + n = self.nextSibling + if not content: + parent.removeChild(self) + while n is not None: + if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE): + next = n.nextSibling + parent.removeChild(n) + n = next + else: + break + if content: + self.data = content + return self + else: + return None + + def _get_isWhitespaceInElementContent(self): + if self.data.strip(): + return False + elem = _get_containing_element(self) + if elem is None: + return False + info = self.ownerDocument._get_elem_info(elem) + if info is None: + return False + else: + return info.isElementContent() + +defproperty(Text, "isWhitespaceInElementContent", + doc="True iff this text node contains only whitespace" + " and is in element content.") +defproperty(Text, "wholeText", + doc="The text of all logically-adjacent text nodes.") + + +def _get_containing_element(node): + c = node.parentNode + while c is not None: + if c.nodeType == Node.ELEMENT_NODE: + return c + c = c.parentNode + return None + +def _get_containing_entref(node): + c = node.parentNode + while c is not None: + if c.nodeType == Node.ENTITY_REFERENCE_NODE: + return c + c = c.parentNode + return None + + +class Comment(CharacterData): + nodeType = Node.COMMENT_NODE + nodeName = "#comment" + + def __init__(self, data): + CharacterData.__init__(self) + self._data = data + + def writexml(self, writer, indent="", addindent="", newl=""): + if "--" in self.data: + raise ValueError("'--' is not allowed in a comment node") + writer.write("%s%s" % (indent, self.data, newl)) + + +class CDATASection(Text): + __slots__ = () + + nodeType = Node.CDATA_SECTION_NODE + nodeName = "#cdata-section" + + def writexml(self, writer, indent="", addindent="", newl=""): + if self.data.find("]]>") >= 0: + raise ValueError("']]>' not allowed in a CDATA section") + writer.write("" % self.data) + + +class ReadOnlySequentialNamedNodeMap(object): + __slots__ = '_seq', + + def __init__(self, seq=()): + # seq should be a list or tuple + self._seq = seq + + def __len__(self): + return len(self._seq) + + def _get_length(self): + return len(self._seq) + + def getNamedItem(self, name): + for n in self._seq: + if n.nodeName == name: + return n + + def getNamedItemNS(self, namespaceURI, localName): + for n in self._seq: + if n.namespaceURI == namespaceURI and n.localName == localName: + return n + + def __getitem__(self, name_or_tuple): + if isinstance(name_or_tuple, tuple): + node = self.getNamedItemNS(*name_or_tuple) + else: + node = self.getNamedItem(name_or_tuple) + if node is None: + raise KeyError(name_or_tuple) + return node + + def item(self, index): + if index < 0: + return None + try: + return self._seq[index] + except IndexError: + return None + + def removeNamedItem(self, name): + raise xml.dom.NoModificationAllowedErr( + "NamedNodeMap instance is read-only") + + def removeNamedItemNS(self, namespaceURI, localName): + raise xml.dom.NoModificationAllowedErr( + "NamedNodeMap instance is read-only") + + def setNamedItem(self, node): + raise xml.dom.NoModificationAllowedErr( + "NamedNodeMap instance is read-only") + + def setNamedItemNS(self, node): + raise xml.dom.NoModificationAllowedErr( + "NamedNodeMap instance is read-only") + + def __getstate__(self): + return [self._seq] + + def __setstate__(self, state): + self._seq = state[0] + +defproperty(ReadOnlySequentialNamedNodeMap, "length", + doc="Number of entries in the NamedNodeMap.") + + +class Identified: + """Mix-in class that supports the publicId and systemId attributes.""" + + __slots__ = 'publicId', 'systemId' + + def _identified_mixin_init(self, publicId, systemId): + self.publicId = publicId + self.systemId = systemId + + def _get_publicId(self): + return self.publicId + + def _get_systemId(self): + return self.systemId + +class DocumentType(Identified, Childless, Node): + nodeType = Node.DOCUMENT_TYPE_NODE + nodeValue = None + name = None + publicId = None + systemId = None + internalSubset = None + + def __init__(self, qualifiedName): + self.entities = ReadOnlySequentialNamedNodeMap() + self.notations = ReadOnlySequentialNamedNodeMap() + if qualifiedName: + prefix, localname = _nssplit(qualifiedName) + self.name = localname + self.nodeName = self.name + + def _get_internalSubset(self): + return self.internalSubset + + def cloneNode(self, deep): + if self.ownerDocument is None: + # it's ok + clone = DocumentType(None) + clone.name = self.name + clone.nodeName = self.name + operation = xml.dom.UserDataHandler.NODE_CLONED + if deep: + clone.entities._seq = [] + clone.notations._seq = [] + for n in self.notations._seq: + notation = Notation(n.nodeName, n.publicId, n.systemId) + clone.notations._seq.append(notation) + n._call_user_data_handler(operation, n, notation) + for e in self.entities._seq: + entity = Entity(e.nodeName, e.publicId, e.systemId, + e.notationName) + entity.actualEncoding = e.actualEncoding + entity.encoding = e.encoding + entity.version = e.version + clone.entities._seq.append(entity) + e._call_user_data_handler(operation, e, entity) + self._call_user_data_handler(operation, self, clone) + return clone + else: + return None + + def writexml(self, writer, indent="", addindent="", newl=""): + writer.write(""+newl) + +class Entity(Identified, Node): + attributes = None + nodeType = Node.ENTITY_NODE + nodeValue = None + + actualEncoding = None + encoding = None + version = None + + def __init__(self, name, publicId, systemId, notation): + self.nodeName = name + self.notationName = notation + self.childNodes = NodeList() + self._identified_mixin_init(publicId, systemId) + + def _get_actualEncoding(self): + return self.actualEncoding + + def _get_encoding(self): + return self.encoding + + def _get_version(self): + return self.version + + def appendChild(self, newChild): + raise xml.dom.HierarchyRequestErr( + "cannot append children to an entity node") + + def insertBefore(self, newChild, refChild): + raise xml.dom.HierarchyRequestErr( + "cannot insert children below an entity node") + + def removeChild(self, oldChild): + raise xml.dom.HierarchyRequestErr( + "cannot remove children from an entity node") + + def replaceChild(self, newChild, oldChild): + raise xml.dom.HierarchyRequestErr( + "cannot replace children of an entity node") + +class Notation(Identified, Childless, Node): + nodeType = Node.NOTATION_NODE + nodeValue = None + + def __init__(self, name, publicId, systemId): + self.nodeName = name + self._identified_mixin_init(publicId, systemId) + + +class DOMImplementation(DOMImplementationLS): + _features = [("core", "1.0"), + ("core", "2.0"), + ("core", None), + ("xml", "1.0"), + ("xml", "2.0"), + ("xml", None), + ("ls-load", "3.0"), + ("ls-load", None), + ] + + def hasFeature(self, feature, version): + if version == "": + version = None + return (feature.lower(), version) in self._features + + def createDocument(self, namespaceURI, qualifiedName, doctype): + if doctype and doctype.parentNode is not None: + raise xml.dom.WrongDocumentErr( + "doctype object owned by another DOM tree") + doc = self._create_document() + + add_root_element = not (namespaceURI is None + and qualifiedName is None + and doctype is None) + + if not qualifiedName and add_root_element: + # The spec is unclear what to raise here; SyntaxErr + # would be the other obvious candidate. Since Xerces raises + # InvalidCharacterErr, and since SyntaxErr is not listed + # for createDocument, that seems to be the better choice. + # XXX: need to check for illegal characters here and in + # createElement. + + # DOM Level III clears this up when talking about the return value + # of this function. If namespaceURI, qName and DocType are + # Null the document is returned without a document element + # Otherwise if doctype or namespaceURI are not None + # Then we go back to the above problem + raise xml.dom.InvalidCharacterErr("Element with no name") + + if add_root_element: + prefix, localname = _nssplit(qualifiedName) + if prefix == "xml" \ + and namespaceURI != "http://www.w3.org/XML/1998/namespace": + raise xml.dom.NamespaceErr("illegal use of 'xml' prefix") + if prefix and not namespaceURI: + raise xml.dom.NamespaceErr( + "illegal use of prefix without namespaces") + element = doc.createElementNS(namespaceURI, qualifiedName) + if doctype: + doc.appendChild(doctype) + doc.appendChild(element) + + if doctype: + doctype.parentNode = doctype.ownerDocument = doc + + doc.doctype = doctype + doc.implementation = self + return doc + + def createDocumentType(self, qualifiedName, publicId, systemId): + doctype = DocumentType(qualifiedName) + doctype.publicId = publicId + doctype.systemId = systemId + return doctype + + # DOM Level 3 (WD 9 April 2002) + + def getInterface(self, feature): + if self.hasFeature(feature, None): + return self + else: + return None + + # internal + def _create_document(self): + return Document() + +class ElementInfo(object): + """Object that represents content-model information for an element. + + This implementation is not expected to be used in practice; DOM + builders should provide implementations which do the right thing + using information available to it. + + """ + + __slots__ = 'tagName', + + def __init__(self, name): + self.tagName = name + + def getAttributeType(self, aname): + return _no_type + + def getAttributeTypeNS(self, namespaceURI, localName): + return _no_type + + def isElementContent(self): + return False + + def isEmpty(self): + """Returns true iff this element is declared to have an EMPTY + content model.""" + return False + + def isId(self, aname): + """Returns true iff the named attribute is a DTD-style ID.""" + return False + + def isIdNS(self, namespaceURI, localName): + """Returns true iff the identified attribute is a DTD-style ID.""" + return False + + def __getstate__(self): + return self.tagName + + def __setstate__(self, state): + self.tagName = state + +def _clear_id_cache(node): + if node.nodeType == Node.DOCUMENT_NODE: + node._id_cache.clear() + node._id_search_stack = None + elif node.ownerDocument: + node.ownerDocument._id_cache.clear() + node.ownerDocument._id_search_stack= None + +class Document(Node, DocumentLS): + __slots__ = ('_elem_info', 'doctype', + '_id_search_stack', 'childNodes', '_id_cache') + _child_node_types = (Node.ELEMENT_NODE, Node.PROCESSING_INSTRUCTION_NODE, + Node.COMMENT_NODE, Node.DOCUMENT_TYPE_NODE) + + implementation = DOMImplementation() + nodeType = Node.DOCUMENT_NODE + nodeName = "#document" + nodeValue = None + attributes = None + parentNode = None + previousSibling = nextSibling = None + + + # Document attributes from Level 3 (WD 9 April 2002) + + actualEncoding = None + encoding = None + standalone = None + version = None + strictErrorChecking = False + errorHandler = None + documentURI = None + + _magic_id_count = 0 + + def __init__(self): + self.doctype = None + self.childNodes = NodeList() + # mapping of (namespaceURI, localName) -> ElementInfo + # and tagName -> ElementInfo + self._elem_info = {} + self._id_cache = {} + self._id_search_stack = None + + def _get_elem_info(self, element): + if element.namespaceURI: + key = element.namespaceURI, element.localName + else: + key = element.tagName + return self._elem_info.get(key) + + def _get_actualEncoding(self): + return self.actualEncoding + + def _get_doctype(self): + return self.doctype + + def _get_documentURI(self): + return self.documentURI + + def _get_encoding(self): + return self.encoding + + def _get_errorHandler(self): + return self.errorHandler + + def _get_standalone(self): + return self.standalone + + def _get_strictErrorChecking(self): + return self.strictErrorChecking + + def _get_version(self): + return self.version + + def appendChild(self, node): + if node.nodeType not in self._child_node_types: + raise xml.dom.HierarchyRequestErr( + "%s cannot be child of %s" % (repr(node), repr(self))) + if node.parentNode is not None: + # This needs to be done before the next test since this + # may *be* the document element, in which case it should + # end up re-ordered to the end. + node.parentNode.removeChild(node) + + if node.nodeType == Node.ELEMENT_NODE \ + and self._get_documentElement(): + raise xml.dom.HierarchyRequestErr( + "two document elements disallowed") + return Node.appendChild(self, node) + + def removeChild(self, oldChild): + try: + self.childNodes.remove(oldChild) + except ValueError: + raise xml.dom.NotFoundErr() + oldChild.nextSibling = oldChild.previousSibling = None + oldChild.parentNode = None + if self.documentElement is oldChild: + self.documentElement = None + + return oldChild + + def _get_documentElement(self): + for node in self.childNodes: + if node.nodeType == Node.ELEMENT_NODE: + return node + + def unlink(self): + if self.doctype is not None: + self.doctype.unlink() + self.doctype = None + Node.unlink(self) + + def cloneNode(self, deep): + if not deep: + return None + clone = self.implementation.createDocument(None, None, None) + clone.encoding = self.encoding + clone.standalone = self.standalone + clone.version = self.version + for n in self.childNodes: + childclone = _clone_node(n, deep, clone) + assert childclone.ownerDocument.isSameNode(clone) + clone.childNodes.append(childclone) + if childclone.nodeType == Node.DOCUMENT_NODE: + assert clone.documentElement is None + elif childclone.nodeType == Node.DOCUMENT_TYPE_NODE: + assert clone.doctype is None + clone.doctype = childclone + childclone.parentNode = clone + self._call_user_data_handler(xml.dom.UserDataHandler.NODE_CLONED, + self, clone) + return clone + + def createDocumentFragment(self): + d = DocumentFragment() + d.ownerDocument = self + return d + + def createElement(self, tagName): + e = Element(tagName) + e.ownerDocument = self + return e + + def createTextNode(self, data): + if not isinstance(data, str): + raise TypeError("node contents must be a string") + t = Text() + t.data = data + t.ownerDocument = self + return t + + def createCDATASection(self, data): + if not isinstance(data, str): + raise TypeError("node contents must be a string") + c = CDATASection() + c.data = data + c.ownerDocument = self + return c + + def createComment(self, data): + c = Comment(data) + c.ownerDocument = self + return c + + def createProcessingInstruction(self, target, data): + p = ProcessingInstruction(target, data) + p.ownerDocument = self + return p + + def createAttribute(self, qName): + a = Attr(qName) + a.ownerDocument = self + a.value = "" + return a + + def createElementNS(self, namespaceURI, qualifiedName): + prefix, localName = _nssplit(qualifiedName) + e = Element(qualifiedName, namespaceURI, prefix) + e.ownerDocument = self + return e + + def createAttributeNS(self, namespaceURI, qualifiedName): + prefix, localName = _nssplit(qualifiedName) + a = Attr(qualifiedName, namespaceURI, localName, prefix) + a.ownerDocument = self + a.value = "" + return a + + # A couple of implementation-specific helpers to create node types + # not supported by the W3C DOM specs: + + def _create_entity(self, name, publicId, systemId, notationName): + e = Entity(name, publicId, systemId, notationName) + e.ownerDocument = self + return e + + def _create_notation(self, name, publicId, systemId): + n = Notation(name, publicId, systemId) + n.ownerDocument = self + return n + + def getElementById(self, id): + if id in self._id_cache: + return self._id_cache[id] + if not (self._elem_info or self._magic_id_count): + return None + + stack = self._id_search_stack + if stack is None: + # we never searched before, or the cache has been cleared + stack = [self.documentElement] + self._id_search_stack = stack + elif not stack: + # Previous search was completed and cache is still valid; + # no matching node. + return None + + result = None + while stack: + node = stack.pop() + # add child elements to stack for continued searching + stack.extend([child for child in node.childNodes + if child.nodeType in _nodeTypes_with_children]) + # check this node + info = self._get_elem_info(node) + if info: + # We have to process all ID attributes before + # returning in order to get all the attributes set to + # be IDs using Element.setIdAttribute*(). + for attr in node.attributes.values(): + if attr.namespaceURI: + if info.isIdNS(attr.namespaceURI, attr.localName): + self._id_cache[attr.value] = node + if attr.value == id: + result = node + elif not node._magic_id_nodes: + break + elif info.isId(attr.name): + self._id_cache[attr.value] = node + if attr.value == id: + result = node + elif not node._magic_id_nodes: + break + elif attr._is_id: + self._id_cache[attr.value] = node + if attr.value == id: + result = node + elif node._magic_id_nodes == 1: + break + elif node._magic_id_nodes: + for attr in node.attributes.values(): + if attr._is_id: + self._id_cache[attr.value] = node + if attr.value == id: + result = node + if result is not None: + break + return result + + def getElementsByTagName(self, name): + return _get_elements_by_tagName_helper(self, name, NodeList()) + + def getElementsByTagNameNS(self, namespaceURI, localName): + return _get_elements_by_tagName_ns_helper( + self, namespaceURI, localName, NodeList()) + + def isSupported(self, feature, version): + return self.implementation.hasFeature(feature, version) + + def importNode(self, node, deep): + if node.nodeType == Node.DOCUMENT_NODE: + raise xml.dom.NotSupportedErr("cannot import document nodes") + elif node.nodeType == Node.DOCUMENT_TYPE_NODE: + raise xml.dom.NotSupportedErr("cannot import document type nodes") + return _clone_node(node, deep, self) + + def writexml(self, writer, indent="", addindent="", newl="", encoding=None, + standalone=None): + declarations = [] + + if encoding: + declarations.append(f'encoding="{encoding}"') + if standalone is not None: + declarations.append(f'standalone="{"yes" if standalone else "no"}"') + + writer.write(f'{newl}') + + for node in self.childNodes: + node.writexml(writer, indent, addindent, newl) + + # DOM Level 3 (WD 9 April 2002) + + def renameNode(self, n, namespaceURI, name): + if n.ownerDocument is not self: + raise xml.dom.WrongDocumentErr( + "cannot rename nodes from other documents;\n" + "expected %s,\nfound %s" % (self, n.ownerDocument)) + if n.nodeType not in (Node.ELEMENT_NODE, Node.ATTRIBUTE_NODE): + raise xml.dom.NotSupportedErr( + "renameNode() only applies to element and attribute nodes") + if namespaceURI != EMPTY_NAMESPACE: + if ':' in name: + prefix, localName = name.split(':', 1) + if ( prefix == "xmlns" + and namespaceURI != xml.dom.XMLNS_NAMESPACE): + raise xml.dom.NamespaceErr( + "illegal use of 'xmlns' prefix") + else: + if ( name == "xmlns" + and namespaceURI != xml.dom.XMLNS_NAMESPACE + and n.nodeType == Node.ATTRIBUTE_NODE): + raise xml.dom.NamespaceErr( + "illegal use of the 'xmlns' attribute") + prefix = None + localName = name + else: + prefix = None + localName = None + if n.nodeType == Node.ATTRIBUTE_NODE: + element = n.ownerElement + if element is not None: + is_id = n._is_id + element.removeAttributeNode(n) + else: + element = None + n.prefix = prefix + n._localName = localName + n.namespaceURI = namespaceURI + n.nodeName = name + if n.nodeType == Node.ELEMENT_NODE: + n.tagName = name + else: + # attribute node + n.name = name + if element is not None: + element.setAttributeNode(n) + if is_id: + element.setIdAttributeNode(n) + # It's not clear from a semantic perspective whether we should + # call the user data handlers for the NODE_RENAMED event since + # we're re-using the existing node. The draft spec has been + # interpreted as meaning "no, don't call the handler unless a + # new node is created." + return n + +defproperty(Document, "documentElement", + doc="Top-level element of this document.") + + +def _clone_node(node, deep, newOwnerDocument): + """ + Clone a node and give it the new owner document. + Called by Node.cloneNode and Document.importNode + """ + if node.ownerDocument.isSameNode(newOwnerDocument): + operation = xml.dom.UserDataHandler.NODE_CLONED + else: + operation = xml.dom.UserDataHandler.NODE_IMPORTED + if node.nodeType == Node.ELEMENT_NODE: + clone = newOwnerDocument.createElementNS(node.namespaceURI, + node.nodeName) + for attr in node.attributes.values(): + clone.setAttributeNS(attr.namespaceURI, attr.nodeName, attr.value) + a = clone.getAttributeNodeNS(attr.namespaceURI, attr.localName) + a.specified = attr.specified + + if deep: + for child in node.childNodes: + c = _clone_node(child, deep, newOwnerDocument) + clone.appendChild(c) + + elif node.nodeType == Node.DOCUMENT_FRAGMENT_NODE: + clone = newOwnerDocument.createDocumentFragment() + if deep: + for child in node.childNodes: + c = _clone_node(child, deep, newOwnerDocument) + clone.appendChild(c) + + elif node.nodeType == Node.TEXT_NODE: + clone = newOwnerDocument.createTextNode(node.data) + elif node.nodeType == Node.CDATA_SECTION_NODE: + clone = newOwnerDocument.createCDATASection(node.data) + elif node.nodeType == Node.PROCESSING_INSTRUCTION_NODE: + clone = newOwnerDocument.createProcessingInstruction(node.target, + node.data) + elif node.nodeType == Node.COMMENT_NODE: + clone = newOwnerDocument.createComment(node.data) + elif node.nodeType == Node.ATTRIBUTE_NODE: + clone = newOwnerDocument.createAttributeNS(node.namespaceURI, + node.nodeName) + clone.specified = True + clone.value = node.value + elif node.nodeType == Node.DOCUMENT_TYPE_NODE: + assert node.ownerDocument is not newOwnerDocument + operation = xml.dom.UserDataHandler.NODE_IMPORTED + clone = newOwnerDocument.implementation.createDocumentType( + node.name, node.publicId, node.systemId) + clone.ownerDocument = newOwnerDocument + if deep: + clone.entities._seq = [] + clone.notations._seq = [] + for n in node.notations._seq: + notation = Notation(n.nodeName, n.publicId, n.systemId) + notation.ownerDocument = newOwnerDocument + clone.notations._seq.append(notation) + if hasattr(n, '_call_user_data_handler'): + n._call_user_data_handler(operation, n, notation) + for e in node.entities._seq: + entity = Entity(e.nodeName, e.publicId, e.systemId, + e.notationName) + entity.actualEncoding = e.actualEncoding + entity.encoding = e.encoding + entity.version = e.version + entity.ownerDocument = newOwnerDocument + clone.entities._seq.append(entity) + if hasattr(e, '_call_user_data_handler'): + e._call_user_data_handler(operation, e, entity) + else: + # Note the cloning of Document and DocumentType nodes is + # implementation specific. minidom handles those cases + # directly in the cloneNode() methods. + raise xml.dom.NotSupportedErr("Cannot clone node %s" % repr(node)) + + # Check for _call_user_data_handler() since this could conceivably + # used with other DOM implementations (one of the FourThought + # DOMs, perhaps?). + if hasattr(node, '_call_user_data_handler'): + node._call_user_data_handler(operation, node, clone) + return clone + + +def _nssplit(qualifiedName): + fields = qualifiedName.split(':', 1) + if len(fields) == 2: + return fields + else: + return (None, fields[0]) + + +def _do_pulldom_parse(func, args, kwargs): + events = func(*args, **kwargs) + toktype, rootNode = events.getEvent() + events.expandNode(rootNode) + events.clear() + return rootNode + +def parse(file, parser=None, bufsize=None): + """Parse a file into a DOM by filename or file object.""" + if parser is None and not bufsize: + from xml.dom import expatbuilder + return expatbuilder.parse(file) + else: + from xml.dom import pulldom + return _do_pulldom_parse(pulldom.parse, (file,), + {'parser': parser, 'bufsize': bufsize}) + +def parseString(string, parser=None): + """Parse a file into a DOM from a string.""" + if parser is None: + from xml.dom import expatbuilder + return expatbuilder.parseString(string) + else: + from xml.dom import pulldom + return _do_pulldom_parse(pulldom.parseString, (string,), + {'parser': parser}) + +def getDOMImplementation(features=None): + if features: + if isinstance(features, str): + features = domreg._parse_feature_string(features) + for f, v in features: + if not Document.implementation.hasFeature(f, v): + return None + return Document.implementation diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/pulldom.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/pulldom.py new file mode 100644 index 0000000000000000000000000000000000000000..913141cd7ef3cebbb28683c6be6b33cd477b4bf3 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/pulldom.py @@ -0,0 +1,336 @@ +import xml.sax +import xml.sax.handler + +START_ELEMENT = "START_ELEMENT" +END_ELEMENT = "END_ELEMENT" +COMMENT = "COMMENT" +START_DOCUMENT = "START_DOCUMENT" +END_DOCUMENT = "END_DOCUMENT" +PROCESSING_INSTRUCTION = "PROCESSING_INSTRUCTION" +IGNORABLE_WHITESPACE = "IGNORABLE_WHITESPACE" +CHARACTERS = "CHARACTERS" + +class PullDOM(xml.sax.ContentHandler): + _locator = None + document = None + + def __init__(self, documentFactory=None): + from xml.dom import XML_NAMESPACE + self.documentFactory = documentFactory + self.firstEvent = [None, None] + self.lastEvent = self.firstEvent + self.elementStack = [] + self.push = self.elementStack.append + try: + self.pop = self.elementStack.pop + except AttributeError: + # use class' pop instead + pass + self._ns_contexts = [{XML_NAMESPACE:'xml'}] # contains uri -> prefix dicts + self._current_context = self._ns_contexts[-1] + self.pending_events = [] + + def pop(self): + result = self.elementStack[-1] + del self.elementStack[-1] + return result + + def setDocumentLocator(self, locator): + self._locator = locator + + def startPrefixMapping(self, prefix, uri): + if not hasattr(self, '_xmlns_attrs'): + self._xmlns_attrs = [] + self._xmlns_attrs.append((prefix or 'xmlns', uri)) + self._ns_contexts.append(self._current_context.copy()) + self._current_context[uri] = prefix or None + + def endPrefixMapping(self, prefix): + self._current_context = self._ns_contexts.pop() + + def startElementNS(self, name, tagName , attrs): + # Retrieve xml namespace declaration attributes. + xmlns_uri = 'http://www.w3.org/2000/xmlns/' + xmlns_attrs = getattr(self, '_xmlns_attrs', None) + if xmlns_attrs is not None: + for aname, value in xmlns_attrs: + attrs._attrs[(xmlns_uri, aname)] = value + self._xmlns_attrs = [] + uri, localname = name + if uri: + # When using namespaces, the reader may or may not + # provide us with the original name. If not, create + # *a* valid tagName from the current context. + if tagName is None: + prefix = self._current_context[uri] + if prefix: + tagName = prefix + ":" + localname + else: + tagName = localname + if self.document: + node = self.document.createElementNS(uri, tagName) + else: + node = self.buildDocument(uri, tagName) + else: + # When the tagname is not prefixed, it just appears as + # localname + if self.document: + node = self.document.createElement(localname) + else: + node = self.buildDocument(None, localname) + + for aname,value in attrs.items(): + a_uri, a_localname = aname + if a_uri == xmlns_uri: + if a_localname == 'xmlns': + qname = a_localname + else: + qname = 'xmlns:' + a_localname + attr = self.document.createAttributeNS(a_uri, qname) + node.setAttributeNodeNS(attr) + elif a_uri: + prefix = self._current_context[a_uri] + if prefix: + qname = prefix + ":" + a_localname + else: + qname = a_localname + attr = self.document.createAttributeNS(a_uri, qname) + node.setAttributeNodeNS(attr) + else: + attr = self.document.createAttribute(a_localname) + node.setAttributeNode(attr) + attr.value = value + + self.lastEvent[1] = [(START_ELEMENT, node), None] + self.lastEvent = self.lastEvent[1] + self.push(node) + + def endElementNS(self, name, tagName): + self.lastEvent[1] = [(END_ELEMENT, self.pop()), None] + self.lastEvent = self.lastEvent[1] + + def startElement(self, name, attrs): + if self.document: + node = self.document.createElement(name) + else: + node = self.buildDocument(None, name) + + for aname,value in attrs.items(): + attr = self.document.createAttribute(aname) + attr.value = value + node.setAttributeNode(attr) + + self.lastEvent[1] = [(START_ELEMENT, node), None] + self.lastEvent = self.lastEvent[1] + self.push(node) + + def endElement(self, name): + self.lastEvent[1] = [(END_ELEMENT, self.pop()), None] + self.lastEvent = self.lastEvent[1] + + def comment(self, s): + if self.document: + node = self.document.createComment(s) + self.lastEvent[1] = [(COMMENT, node), None] + self.lastEvent = self.lastEvent[1] + else: + event = [(COMMENT, s), None] + self.pending_events.append(event) + + def processingInstruction(self, target, data): + if self.document: + node = self.document.createProcessingInstruction(target, data) + self.lastEvent[1] = [(PROCESSING_INSTRUCTION, node), None] + self.lastEvent = self.lastEvent[1] + else: + event = [(PROCESSING_INSTRUCTION, target, data), None] + self.pending_events.append(event) + + def ignorableWhitespace(self, chars): + node = self.document.createTextNode(chars) + self.lastEvent[1] = [(IGNORABLE_WHITESPACE, node), None] + self.lastEvent = self.lastEvent[1] + + def characters(self, chars): + node = self.document.createTextNode(chars) + self.lastEvent[1] = [(CHARACTERS, node), None] + self.lastEvent = self.lastEvent[1] + + def startDocument(self): + if self.documentFactory is None: + import xml.dom.minidom + self.documentFactory = xml.dom.minidom.Document.implementation + + def buildDocument(self, uri, tagname): + # Can't do that in startDocument, since we need the tagname + # XXX: obtain DocumentType + node = self.documentFactory.createDocument(uri, tagname, None) + self.document = node + self.lastEvent[1] = [(START_DOCUMENT, node), None] + self.lastEvent = self.lastEvent[1] + self.push(node) + # Put everything we have seen so far into the document + for e in self.pending_events: + if e[0][0] == PROCESSING_INSTRUCTION: + _,target,data = e[0] + n = self.document.createProcessingInstruction(target, data) + e[0] = (PROCESSING_INSTRUCTION, n) + elif e[0][0] == COMMENT: + n = self.document.createComment(e[0][1]) + e[0] = (COMMENT, n) + else: + raise AssertionError("Unknown pending event ",e[0][0]) + self.lastEvent[1] = e + self.lastEvent = e + self.pending_events = None + return node.firstChild + + def endDocument(self): + self.lastEvent[1] = [(END_DOCUMENT, self.document), None] + self.pop() + + def clear(self): + "clear(): Explicitly release parsing structures" + self.document = None + +class ErrorHandler: + def warning(self, exception): + print(exception) + def error(self, exception): + raise exception + def fatalError(self, exception): + raise exception + +class DOMEventStream: + def __init__(self, stream, parser, bufsize): + self.stream = stream + self.parser = parser + self.bufsize = bufsize + if not hasattr(self.parser, 'feed'): + self.getEvent = self._slurp + self.reset() + + def reset(self): + self.pulldom = PullDOM() + # This content handler relies on namespace support + self.parser.setFeature(xml.sax.handler.feature_namespaces, 1) + self.parser.setContentHandler(self.pulldom) + + def __next__(self): + rc = self.getEvent() + if rc: + return rc + raise StopIteration + + def __iter__(self): + return self + + def expandNode(self, node): + event = self.getEvent() + parents = [node] + while event: + token, cur_node = event + if cur_node is node: + return + if token != END_ELEMENT: + parents[-1].appendChild(cur_node) + if token == START_ELEMENT: + parents.append(cur_node) + elif token == END_ELEMENT: + del parents[-1] + event = self.getEvent() + + def getEvent(self): + # use IncrementalParser interface, so we get the desired + # pull effect + if not self.pulldom.firstEvent[1]: + self.pulldom.lastEvent = self.pulldom.firstEvent + while not self.pulldom.firstEvent[1]: + buf = self.stream.read(self.bufsize) + if not buf: + self.parser.close() + return None + self.parser.feed(buf) + rc = self.pulldom.firstEvent[1][0] + self.pulldom.firstEvent[1] = self.pulldom.firstEvent[1][1] + return rc + + def _slurp(self): + """ Fallback replacement for getEvent() using the + standard SAX2 interface, which means we slurp the + SAX events into memory (no performance gain, but + we are compatible to all SAX parsers). + """ + self.parser.parse(self.stream) + self.getEvent = self._emit + return self._emit() + + def _emit(self): + """ Fallback replacement for getEvent() that emits + the events that _slurp() read previously. + """ + rc = self.pulldom.firstEvent[1][0] + self.pulldom.firstEvent[1] = self.pulldom.firstEvent[1][1] + return rc + + def clear(self): + """clear(): Explicitly release parsing objects""" + self.pulldom.clear() + del self.pulldom + self.parser = None + self.stream = None + +class SAX2DOM(PullDOM): + + def startElementNS(self, name, tagName , attrs): + PullDOM.startElementNS(self, name, tagName, attrs) + curNode = self.elementStack[-1] + parentNode = self.elementStack[-2] + parentNode.appendChild(curNode) + + def startElement(self, name, attrs): + PullDOM.startElement(self, name, attrs) + curNode = self.elementStack[-1] + parentNode = self.elementStack[-2] + parentNode.appendChild(curNode) + + def processingInstruction(self, target, data): + PullDOM.processingInstruction(self, target, data) + node = self.lastEvent[0][1] + parentNode = self.elementStack[-1] + parentNode.appendChild(node) + + def ignorableWhitespace(self, chars): + PullDOM.ignorableWhitespace(self, chars) + node = self.lastEvent[0][1] + parentNode = self.elementStack[-1] + parentNode.appendChild(node) + + def characters(self, chars): + PullDOM.characters(self, chars) + node = self.lastEvent[0][1] + parentNode = self.elementStack[-1] + parentNode.appendChild(node) + + +default_bufsize = (2 ** 14) - 20 + +def parse(stream_or_string, parser=None, bufsize=None): + if bufsize is None: + bufsize = default_bufsize + if isinstance(stream_or_string, str): + stream = open(stream_or_string, 'rb') + else: + stream = stream_or_string + if not parser: + parser = xml.sax.make_parser() + return DOMEventStream(stream, parser, bufsize) + +def parseString(string, parser=None): + from io import StringIO + + bufsize = len(string) + buf = StringIO(string) + if not parser: + parser = xml.sax.make_parser() + return DOMEventStream(buf, parser, bufsize) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/xmlbuilder.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/xmlbuilder.py new file mode 100644 index 0000000000000000000000000000000000000000..8a200263497b8927e7630ec5d8c14cfd8d8f5a19 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/dom/xmlbuilder.py @@ -0,0 +1,387 @@ +"""Implementation of the DOM Level 3 'LS-Load' feature.""" + +import copy +import xml.dom + +from xml.dom.NodeFilter import NodeFilter + + +__all__ = ["DOMBuilder", "DOMEntityResolver", "DOMInputSource"] + + +class Options: + """Features object that has variables set for each DOMBuilder feature. + + The DOMBuilder class uses an instance of this class to pass settings to + the ExpatBuilder class. + """ + + # Note that the DOMBuilder class in LoadSave constrains which of these + # values can be set using the DOM Level 3 LoadSave feature. + + namespaces = 1 + namespace_declarations = True + validation = False + external_parameter_entities = True + external_general_entities = True + external_dtd_subset = True + validate_if_schema = False + validate = False + datatype_normalization = False + create_entity_ref_nodes = True + entities = True + whitespace_in_element_content = True + cdata_sections = True + comments = True + charset_overrides_xml_encoding = True + infoset = False + supported_mediatypes_only = False + + errorHandler = None + filter = None + + +class DOMBuilder: + entityResolver = None + errorHandler = None + filter = None + + ACTION_REPLACE = 1 + ACTION_APPEND_AS_CHILDREN = 2 + ACTION_INSERT_AFTER = 3 + ACTION_INSERT_BEFORE = 4 + + _legal_actions = (ACTION_REPLACE, ACTION_APPEND_AS_CHILDREN, + ACTION_INSERT_AFTER, ACTION_INSERT_BEFORE) + + def __init__(self): + self._options = Options() + + def _get_entityResolver(self): + return self.entityResolver + def _set_entityResolver(self, entityResolver): + self.entityResolver = entityResolver + + def _get_errorHandler(self): + return self.errorHandler + def _set_errorHandler(self, errorHandler): + self.errorHandler = errorHandler + + def _get_filter(self): + return self.filter + def _set_filter(self, filter): + self.filter = filter + + def setFeature(self, name, state): + if self.supportsFeature(name): + state = state and 1 or 0 + try: + settings = self._settings[(_name_xform(name), state)] + except KeyError: + raise xml.dom.NotSupportedErr( + "unsupported feature: %r" % (name,)) from None + else: + for name, value in settings: + setattr(self._options, name, value) + else: + raise xml.dom.NotFoundErr("unknown feature: " + repr(name)) + + def supportsFeature(self, name): + return hasattr(self._options, _name_xform(name)) + + def canSetFeature(self, name, state): + key = (_name_xform(name), state and 1 or 0) + return key in self._settings + + # This dictionary maps from (feature,value) to a list of + # (option,value) pairs that should be set on the Options object. + # If a (feature,value) setting is not in this dictionary, it is + # not supported by the DOMBuilder. + # + _settings = { + ("namespace_declarations", 0): [ + ("namespace_declarations", 0)], + ("namespace_declarations", 1): [ + ("namespace_declarations", 1)], + ("validation", 0): [ + ("validation", 0)], + ("external_general_entities", 0): [ + ("external_general_entities", 0)], + ("external_general_entities", 1): [ + ("external_general_entities", 1)], + ("external_parameter_entities", 0): [ + ("external_parameter_entities", 0)], + ("external_parameter_entities", 1): [ + ("external_parameter_entities", 1)], + ("validate_if_schema", 0): [ + ("validate_if_schema", 0)], + ("create_entity_ref_nodes", 0): [ + ("create_entity_ref_nodes", 0)], + ("create_entity_ref_nodes", 1): [ + ("create_entity_ref_nodes", 1)], + ("entities", 0): [ + ("create_entity_ref_nodes", 0), + ("entities", 0)], + ("entities", 1): [ + ("entities", 1)], + ("whitespace_in_element_content", 0): [ + ("whitespace_in_element_content", 0)], + ("whitespace_in_element_content", 1): [ + ("whitespace_in_element_content", 1)], + ("cdata_sections", 0): [ + ("cdata_sections", 0)], + ("cdata_sections", 1): [ + ("cdata_sections", 1)], + ("comments", 0): [ + ("comments", 0)], + ("comments", 1): [ + ("comments", 1)], + ("charset_overrides_xml_encoding", 0): [ + ("charset_overrides_xml_encoding", 0)], + ("charset_overrides_xml_encoding", 1): [ + ("charset_overrides_xml_encoding", 1)], + ("infoset", 0): [], + ("infoset", 1): [ + ("namespace_declarations", 0), + ("validate_if_schema", 0), + ("create_entity_ref_nodes", 0), + ("entities", 0), + ("cdata_sections", 0), + ("datatype_normalization", 1), + ("whitespace_in_element_content", 1), + ("comments", 1), + ("charset_overrides_xml_encoding", 1)], + ("supported_mediatypes_only", 0): [ + ("supported_mediatypes_only", 0)], + ("namespaces", 0): [ + ("namespaces", 0)], + ("namespaces", 1): [ + ("namespaces", 1)], + } + + def getFeature(self, name): + xname = _name_xform(name) + try: + return getattr(self._options, xname) + except AttributeError: + if name == "infoset": + options = self._options + return (options.datatype_normalization + and options.whitespace_in_element_content + and options.comments + and options.charset_overrides_xml_encoding + and not (options.namespace_declarations + or options.validate_if_schema + or options.create_entity_ref_nodes + or options.entities + or options.cdata_sections)) + raise xml.dom.NotFoundErr("feature %s not known" % repr(name)) + + def parseURI(self, uri): + if self.entityResolver: + input = self.entityResolver.resolveEntity(None, uri) + else: + input = DOMEntityResolver().resolveEntity(None, uri) + return self.parse(input) + + def parse(self, input): + options = copy.copy(self._options) + options.filter = self.filter + options.errorHandler = self.errorHandler + fp = input.byteStream + if fp is None and options.systemId: + import urllib.request + fp = urllib.request.urlopen(input.systemId) + return self._parse_bytestream(fp, options) + + def parseWithContext(self, input, cnode, action): + if action not in self._legal_actions: + raise ValueError("not a legal action") + raise NotImplementedError("Haven't written this yet...") + + def _parse_bytestream(self, stream, options): + import xml.dom.expatbuilder + builder = xml.dom.expatbuilder.makeBuilder(options) + return builder.parseFile(stream) + + +def _name_xform(name): + return name.lower().replace('-', '_') + + +class DOMEntityResolver(object): + __slots__ = '_opener', + + def resolveEntity(self, publicId, systemId): + assert systemId is not None + source = DOMInputSource() + source.publicId = publicId + source.systemId = systemId + source.byteStream = self._get_opener().open(systemId) + + # determine the encoding if the transport provided it + source.encoding = self._guess_media_encoding(source) + + # determine the base URI is we can + import posixpath, urllib.parse + parts = urllib.parse.urlparse(systemId) + scheme, netloc, path, params, query, fragment = parts + # XXX should we check the scheme here as well? + if path and not path.endswith("/"): + path = posixpath.dirname(path) + "/" + parts = scheme, netloc, path, params, query, fragment + source.baseURI = urllib.parse.urlunparse(parts) + + return source + + def _get_opener(self): + try: + return self._opener + except AttributeError: + self._opener = self._create_opener() + return self._opener + + def _create_opener(self): + import urllib.request + return urllib.request.build_opener() + + def _guess_media_encoding(self, source): + info = source.byteStream.info() + if "Content-Type" in info: + for param in info.getplist(): + if param.startswith("charset="): + return param.split("=", 1)[1].lower() + + +class DOMInputSource(object): + __slots__ = ('byteStream', 'characterStream', 'stringData', + 'encoding', 'publicId', 'systemId', 'baseURI') + + def __init__(self): + self.byteStream = None + self.characterStream = None + self.stringData = None + self.encoding = None + self.publicId = None + self.systemId = None + self.baseURI = None + + def _get_byteStream(self): + return self.byteStream + def _set_byteStream(self, byteStream): + self.byteStream = byteStream + + def _get_characterStream(self): + return self.characterStream + def _set_characterStream(self, characterStream): + self.characterStream = characterStream + + def _get_stringData(self): + return self.stringData + def _set_stringData(self, data): + self.stringData = data + + def _get_encoding(self): + return self.encoding + def _set_encoding(self, encoding): + self.encoding = encoding + + def _get_publicId(self): + return self.publicId + def _set_publicId(self, publicId): + self.publicId = publicId + + def _get_systemId(self): + return self.systemId + def _set_systemId(self, systemId): + self.systemId = systemId + + def _get_baseURI(self): + return self.baseURI + def _set_baseURI(self, uri): + self.baseURI = uri + + +class DOMBuilderFilter: + """Element filter which can be used to tailor construction of + a DOM instance. + """ + + # There's really no need for this class; concrete implementations + # should just implement the endElement() and startElement() + # methods as appropriate. Using this makes it easy to only + # implement one of them. + + FILTER_ACCEPT = 1 + FILTER_REJECT = 2 + FILTER_SKIP = 3 + FILTER_INTERRUPT = 4 + + whatToShow = NodeFilter.SHOW_ALL + + def _get_whatToShow(self): + return self.whatToShow + + def acceptNode(self, element): + return self.FILTER_ACCEPT + + def startContainer(self, element): + return self.FILTER_ACCEPT + +del NodeFilter + + +class DocumentLS: + """Mixin to create documents that conform to the load/save spec.""" + + async_ = False + + def _get_async(self): + return False + + def _set_async(self, flag): + if flag: + raise xml.dom.NotSupportedErr( + "asynchronous document loading is not supported") + + def abort(self): + # What does it mean to "clear" a document? Does the + # documentElement disappear? + raise NotImplementedError( + "haven't figured out what this means yet") + + def load(self, uri): + raise NotImplementedError("haven't written this yet") + + def loadXML(self, source): + raise NotImplementedError("haven't written this yet") + + def saveXML(self, snode): + if snode is None: + snode = self + elif snode.ownerDocument is not self: + raise xml.dom.WrongDocumentErr() + return snode.toxml() + + +class DOMImplementationLS: + MODE_SYNCHRONOUS = 1 + MODE_ASYNCHRONOUS = 2 + + def createDOMBuilder(self, mode, schemaType): + if schemaType is not None: + raise xml.dom.NotSupportedErr( + "schemaType not yet supported") + if mode == self.MODE_SYNCHRONOUS: + return DOMBuilder() + if mode == self.MODE_ASYNCHRONOUS: + raise xml.dom.NotSupportedErr( + "asynchronous builders are not supported") + raise ValueError("unknown value for mode") + + def createDOMWriter(self): + raise NotImplementedError( + "the writer interface hasn't been written yet!") + + def createDOMInputSource(self): + return DOMInputSource() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/ElementInclude.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/ElementInclude.py new file mode 100644 index 0000000000000000000000000000000000000000..40a9b22292479fc43e8895a27e22b6846bc9abfe --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/ElementInclude.py @@ -0,0 +1,185 @@ +# +# ElementTree +# $Id: ElementInclude.py 3375 2008-02-13 08:05:08Z fredrik $ +# +# limited xinclude support for element trees +# +# history: +# 2003-08-15 fl created +# 2003-11-14 fl fixed default loader +# +# Copyright (c) 2003-2004 by Fredrik Lundh. All rights reserved. +# +# fredrik@pythonware.com +# http://www.pythonware.com +# +# -------------------------------------------------------------------- +# The ElementTree toolkit is +# +# Copyright (c) 1999-2008 by Fredrik Lundh +# +# By obtaining, using, and/or copying this software and/or its +# associated documentation, you agree that you have read, understood, +# and will comply with the following terms and conditions: +# +# Permission to use, copy, modify, and distribute this software and +# its associated documentation for any purpose and without fee is +# hereby granted, provided that the above copyright notice appears in +# all copies, and that both that copyright notice and this permission +# notice appear in supporting documentation, and that the name of +# Secret Labs AB or the author not be used in advertising or publicity +# pertaining to distribution of the software without specific, written +# prior permission. +# +# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD +# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT- +# ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR +# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY +# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS +# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE +# OF THIS SOFTWARE. +# -------------------------------------------------------------------- + +# Licensed to PSF under a Contributor Agreement. +# See https://www.python.org/psf/license for licensing details. + +## +# Limited XInclude support for the ElementTree package. +## + +import copy +from . import ElementTree +from urllib.parse import urljoin + +XINCLUDE = "{http://www.w3.org/2001/XInclude}" + +XINCLUDE_INCLUDE = XINCLUDE + "include" +XINCLUDE_FALLBACK = XINCLUDE + "fallback" + +# For security reasons, the inclusion depth is limited to this read-only value by default. +DEFAULT_MAX_INCLUSION_DEPTH = 6 + + +## +# Fatal include error. + +class FatalIncludeError(SyntaxError): + pass + + +class LimitedRecursiveIncludeError(FatalIncludeError): + pass + + +## +# Default loader. This loader reads an included resource from disk. +# +# @param href Resource reference. +# @param parse Parse mode. Either "xml" or "text". +# @param encoding Optional text encoding (UTF-8 by default for "text"). +# @return The expanded resource. If the parse mode is "xml", this +# is an ElementTree instance. If the parse mode is "text", this +# is a Unicode string. If the loader fails, it can return None +# or raise an OSError exception. +# @throws OSError If the loader fails to load the resource. + +def default_loader(href, parse, encoding=None): + if parse == "xml": + with open(href, 'rb') as file: + data = ElementTree.parse(file).getroot() + else: + if not encoding: + encoding = 'UTF-8' + with open(href, 'r', encoding=encoding) as file: + data = file.read() + return data + +## +# Expand XInclude directives. +# +# @param elem Root element. +# @param loader Optional resource loader. If omitted, it defaults +# to {@link default_loader}. If given, it should be a callable +# that implements the same interface as default_loader. +# @param base_url The base URL of the original file, to resolve +# relative include file references. +# @param max_depth The maximum number of recursive inclusions. +# Limited to reduce the risk of malicious content explosion. +# Pass a negative value to disable the limitation. +# @throws LimitedRecursiveIncludeError If the {@link max_depth} was exceeded. +# @throws FatalIncludeError If the function fails to include a given +# resource, or if the tree contains malformed XInclude elements. +# @throws IOError If the function fails to load a given resource. +# @returns the node or its replacement if it was an XInclude node + +def include(elem, loader=None, base_url=None, + max_depth=DEFAULT_MAX_INCLUSION_DEPTH): + if max_depth is None: + max_depth = -1 + elif max_depth < 0: + raise ValueError("expected non-negative depth or None for 'max_depth', got %r" % max_depth) + + if hasattr(elem, 'getroot'): + elem = elem.getroot() + if loader is None: + loader = default_loader + + _include(elem, loader, base_url, max_depth, set()) + + +def _include(elem, loader, base_url, max_depth, _parent_hrefs): + # look for xinclude elements + i = 0 + while i < len(elem): + e = elem[i] + if e.tag == XINCLUDE_INCLUDE: + # process xinclude directive + href = e.get("href") + if base_url: + href = urljoin(base_url, href) + parse = e.get("parse", "xml") + if parse == "xml": + if href in _parent_hrefs: + raise FatalIncludeError("recursive include of %s" % href) + if max_depth == 0: + raise LimitedRecursiveIncludeError( + "maximum xinclude depth reached when including file %s" % href) + _parent_hrefs.add(href) + node = loader(href, parse) + if node is None: + raise FatalIncludeError( + "cannot load %r as %r" % (href, parse) + ) + node = copy.copy(node) # FIXME: this makes little sense with recursive includes + _include(node, loader, href, max_depth - 1, _parent_hrefs) + _parent_hrefs.remove(href) + if e.tail: + node.tail = (node.tail or "") + e.tail + elem[i] = node + elif parse == "text": + text = loader(href, parse, e.get("encoding")) + if text is None: + raise FatalIncludeError( + "cannot load %r as %r" % (href, parse) + ) + if e.tail: + text += e.tail + if i: + node = elem[i-1] + node.tail = (node.tail or "") + text + else: + elem.text = (elem.text or "") + text + del elem[i] + continue + else: + raise FatalIncludeError( + "unknown parse type in xi:include tag (%r)" % parse + ) + elif e.tag == XINCLUDE_FALLBACK: + raise FatalIncludeError( + "xi:fallback tag must be child of xi:include (%r)" % e.tag + ) + else: + _include(e, loader, base_url, max_depth, _parent_hrefs) + i += 1 diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/ElementPath.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/ElementPath.py new file mode 100644 index 0000000000000000000000000000000000000000..de1fd203ff6a0f6755412e767ff844223d363e62 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/ElementPath.py @@ -0,0 +1,430 @@ +# +# ElementTree +# $Id: ElementPath.py 3375 2008-02-13 08:05:08Z fredrik $ +# +# limited xpath support for element trees +# +# history: +# 2003-05-23 fl created +# 2003-05-28 fl added support for // etc +# 2003-08-27 fl fixed parsing of periods in element names +# 2007-09-10 fl new selection engine +# 2007-09-12 fl fixed parent selector +# 2007-09-13 fl added iterfind; changed findall to return a list +# 2007-11-30 fl added namespaces support +# 2009-10-30 fl added child element value filter +# +# Copyright (c) 2003-2009 by Fredrik Lundh. All rights reserved. +# +# fredrik@pythonware.com +# http://www.pythonware.com +# +# -------------------------------------------------------------------- +# The ElementTree toolkit is +# +# Copyright (c) 1999-2009 by Fredrik Lundh +# +# By obtaining, using, and/or copying this software and/or its +# associated documentation, you agree that you have read, understood, +# and will comply with the following terms and conditions: +# +# Permission to use, copy, modify, and distribute this software and +# its associated documentation for any purpose and without fee is +# hereby granted, provided that the above copyright notice appears in +# all copies, and that both that copyright notice and this permission +# notice appear in supporting documentation, and that the name of +# Secret Labs AB or the author not be used in advertising or publicity +# pertaining to distribution of the software without specific, written +# prior permission. +# +# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD +# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT- +# ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR +# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY +# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS +# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE +# OF THIS SOFTWARE. +# -------------------------------------------------------------------- + +# Licensed to PSF under a Contributor Agreement. +# See https://www.python.org/psf/license for licensing details. + +## +# Implementation module for XPath support. There's usually no reason +# to import this module directly; the ElementTree does this for +# you, if needed. +## + +import re + +xpath_tokenizer_re = re.compile( + r"(" + r"'[^']*'|\"[^\"]*\"|" + r"::|" + r"//?|" + r"\.\.|" + r"\(\)|" + r"!=|" + r"[/.*:\[\]\(\)@=])|" + r"((?:\{[^}]+\})?[^/\[\]\(\)@!=\s]+)|" + r"\s+" + ) + +def xpath_tokenizer(pattern, namespaces=None): + default_namespace = namespaces.get('') if namespaces else None + parsing_attribute = False + for token in xpath_tokenizer_re.findall(pattern): + ttype, tag = token + if tag and tag[0] != "{": + if ":" in tag: + prefix, uri = tag.split(":", 1) + try: + if not namespaces: + raise KeyError + yield ttype, "{%s}%s" % (namespaces[prefix], uri) + except KeyError: + raise SyntaxError("prefix %r not found in prefix map" % prefix) from None + elif default_namespace and not parsing_attribute: + yield ttype, "{%s}%s" % (default_namespace, tag) + else: + yield token + parsing_attribute = False + else: + yield token + parsing_attribute = ttype == '@' + + +def get_parent_map(context): + parent_map = context.parent_map + if parent_map is None: + context.parent_map = parent_map = {} + for p in context.root.iter(): + for e in p: + parent_map[e] = p + return parent_map + + +def _is_wildcard_tag(tag): + return tag[:3] == '{*}' or tag[-2:] == '}*' + + +def _prepare_tag(tag): + _isinstance, _str = isinstance, str + if tag == '{*}*': + # Same as '*', but no comments or processing instructions. + # It can be a surprise that '*' includes those, but there is no + # justification for '{*}*' doing the same. + def select(context, result): + for elem in result: + if _isinstance(elem.tag, _str): + yield elem + elif tag == '{}*': + # Any tag that is not in a namespace. + def select(context, result): + for elem in result: + el_tag = elem.tag + if _isinstance(el_tag, _str) and el_tag[0] != '{': + yield elem + elif tag[:3] == '{*}': + # The tag in any (or no) namespace. + suffix = tag[2:] # '}name' + no_ns = slice(-len(suffix), None) + tag = tag[3:] + def select(context, result): + for elem in result: + el_tag = elem.tag + if el_tag == tag or _isinstance(el_tag, _str) and el_tag[no_ns] == suffix: + yield elem + elif tag[-2:] == '}*': + # Any tag in the given namespace. + ns = tag[:-1] + ns_only = slice(None, len(ns)) + def select(context, result): + for elem in result: + el_tag = elem.tag + if _isinstance(el_tag, _str) and el_tag[ns_only] == ns: + yield elem + else: + raise RuntimeError(f"internal parser error, got {tag}") + return select + + +def prepare_child(next, token): + tag = token[1] + if _is_wildcard_tag(tag): + select_tag = _prepare_tag(tag) + def select(context, result): + def select_child(result): + for elem in result: + yield from elem + return select_tag(context, select_child(result)) + else: + if tag[:2] == '{}': + tag = tag[2:] # '{}tag' == 'tag' + def select(context, result): + for elem in result: + for e in elem: + if e.tag == tag: + yield e + return select + +def prepare_star(next, token): + def select(context, result): + for elem in result: + yield from elem + return select + +def prepare_self(next, token): + def select(context, result): + yield from result + return select + +def prepare_descendant(next, token): + try: + token = next() + except StopIteration: + return + if token[0] == "*": + tag = "*" + elif not token[0]: + tag = token[1] + else: + raise SyntaxError("invalid descendant") + + if _is_wildcard_tag(tag): + select_tag = _prepare_tag(tag) + def select(context, result): + def select_child(result): + for elem in result: + for e in elem.iter(): + if e is not elem: + yield e + return select_tag(context, select_child(result)) + else: + if tag[:2] == '{}': + tag = tag[2:] # '{}tag' == 'tag' + def select(context, result): + for elem in result: + for e in elem.iter(tag): + if e is not elem: + yield e + return select + +def prepare_parent(next, token): + def select(context, result): + # FIXME: raise error if .. is applied at toplevel? + parent_map = get_parent_map(context) + result_map = {} + for elem in result: + if elem in parent_map: + parent = parent_map[elem] + if parent not in result_map: + result_map[parent] = None + yield parent + return select + +def prepare_predicate(next, token): + # FIXME: replace with real parser!!! refs: + # http://javascript.crockford.com/tdop/tdop.html + signature = [] + predicate = [] + while 1: + try: + token = next() + except StopIteration: + return + if token[0] == "]": + break + if token == ('', ''): + # ignore whitespace + continue + if token[0] and token[0][:1] in "'\"": + token = "'", token[0][1:-1] + signature.append(token[0] or "-") + predicate.append(token[1]) + signature = "".join(signature) + # use signature to determine predicate type + if signature == "@-": + # [@attribute] predicate + key = predicate[1] + def select(context, result): + for elem in result: + if elem.get(key) is not None: + yield elem + return select + if signature == "@-='" or signature == "@-!='": + # [@attribute='value'] or [@attribute!='value'] + key = predicate[1] + value = predicate[-1] + def select(context, result): + for elem in result: + if elem.get(key) == value: + yield elem + def select_negated(context, result): + for elem in result: + if (attr_value := elem.get(key)) is not None and attr_value != value: + yield elem + return select_negated if '!=' in signature else select + if signature == "-" and not re.match(r"\-?\d+$", predicate[0]): + # [tag] + tag = predicate[0] + def select(context, result): + for elem in result: + if elem.find(tag) is not None: + yield elem + return select + if signature == ".='" or signature == ".!='" or ( + (signature == "-='" or signature == "-!='") + and not re.match(r"\-?\d+$", predicate[0])): + # [.='value'] or [tag='value'] or [.!='value'] or [tag!='value'] + tag = predicate[0] + value = predicate[-1] + if tag: + def select(context, result): + for elem in result: + for e in elem.findall(tag): + if "".join(e.itertext()) == value: + yield elem + break + def select_negated(context, result): + for elem in result: + for e in elem.iterfind(tag): + if "".join(e.itertext()) != value: + yield elem + break + else: + def select(context, result): + for elem in result: + if "".join(elem.itertext()) == value: + yield elem + def select_negated(context, result): + for elem in result: + if "".join(elem.itertext()) != value: + yield elem + return select_negated if '!=' in signature else select + if signature == "-" or signature == "-()" or signature == "-()-": + # [index] or [last()] or [last()-index] + if signature == "-": + # [index] + index = int(predicate[0]) - 1 + if index < 0: + raise SyntaxError("XPath position >= 1 expected") + else: + if predicate[0] != "last": + raise SyntaxError("unsupported function") + if signature == "-()-": + try: + index = int(predicate[2]) - 1 + except ValueError: + raise SyntaxError("unsupported expression") + if index > -2: + raise SyntaxError("XPath offset from last() must be negative") + else: + index = -1 + def select(context, result): + parent_map = get_parent_map(context) + cache = {} + for elem in result: + try: + parent = parent_map[elem] + except KeyError: + continue + key = (parent, elem.tag) + if key not in cache: + # FIXME: what if the selector is "*" ? + elems = parent.findall(elem.tag) + try: + cache[key] = elems[index] + except IndexError: + cache[key] = None + if cache[key] is elem: + yield elem + return select + raise SyntaxError("invalid predicate") + +ops = { + "": prepare_child, + "*": prepare_star, + ".": prepare_self, + "..": prepare_parent, + "//": prepare_descendant, + "[": prepare_predicate, + } + +_cache = {} + +class _SelectorContext: + parent_map = None + def __init__(self, root): + self.root = root + +# -------------------------------------------------------------------- + +## +# Generate all matching objects. + +def iterfind(elem, path, namespaces=None): + # compile selector pattern + if path[-1:] == "/": + path = path + "*" # implicit all (FIXME: keep this?) + + cache_key = (path,) + if namespaces: + cache_key += tuple(sorted(namespaces.items())) + + try: + selector = _cache[cache_key] + except KeyError: + if len(_cache) > 100: + _cache.clear() + if path[:1] == "/": + raise SyntaxError("cannot use absolute path on element") + next = iter(xpath_tokenizer(path, namespaces)).__next__ + try: + token = next() + except StopIteration: + return + selector = [] + while 1: + try: + selector.append(ops[token[0]](next, token)) + except StopIteration: + raise SyntaxError("invalid path") from None + try: + token = next() + if token[0] == "/": + token = next() + except StopIteration: + break + _cache[cache_key] = selector + # execute selector pattern + result = [elem] + context = _SelectorContext(elem) + for select in selector: + result = select(context, result) + return result + +## +# Find first matching object. + +def find(elem, path, namespaces=None): + return next(iterfind(elem, path, namespaces), None) + +## +# Find all matching objects. + +def findall(elem, path, namespaces=None): + return list(iterfind(elem, path, namespaces)) + +## +# Find text for first matching object. + +def findtext(elem, path, default=None, namespaces=None): + try: + elem = next(iterfind(elem, path, namespaces)) + if elem.text is None: + return "" + return elem.text + except StopIteration: + return default diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/ElementTree.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/ElementTree.py new file mode 100644 index 0000000000000000000000000000000000000000..5f32649c7fde83937bc212eb51ae8304915e3c5e --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/ElementTree.py @@ -0,0 +1,2100 @@ +"""Lightweight XML support for Python. + + XML is an inherently hierarchical data format, and the most natural way to + represent it is with a tree. This module has two classes for this purpose: + + 1. ElementTree represents the whole XML document as a tree and + + 2. Element represents a single node in this tree. + + Interactions with the whole document (reading and writing to/from files) are + usually done on the ElementTree level. Interactions with a single XML element + and its sub-elements are done on the Element level. + + Element is a flexible container object designed to store hierarchical data + structures in memory. It can be described as a cross between a list and a + dictionary. Each Element has a number of properties associated with it: + + 'tag' - a string containing the element's name. + + 'attributes' - a Python dictionary storing the element's attributes. + + 'text' - a string containing the element's text content. + + 'tail' - an optional string containing text after the element's end tag. + + And a number of child elements stored in a Python sequence. + + To create an element instance, use the Element constructor, + or the SubElement factory function. + + You can also use the ElementTree class to wrap an element structure + and convert it to and from XML. + +""" + +#--------------------------------------------------------------------- +# Licensed to PSF under a Contributor Agreement. +# See https://www.python.org/psf/license for licensing details. +# +# ElementTree +# Copyright (c) 1999-2008 by Fredrik Lundh. All rights reserved. +# +# fredrik@pythonware.com +# http://www.pythonware.com +# -------------------------------------------------------------------- +# The ElementTree toolkit is +# +# Copyright (c) 1999-2008 by Fredrik Lundh +# +# By obtaining, using, and/or copying this software and/or its +# associated documentation, you agree that you have read, understood, +# and will comply with the following terms and conditions: +# +# Permission to use, copy, modify, and distribute this software and +# its associated documentation for any purpose and without fee is +# hereby granted, provided that the above copyright notice appears in +# all copies, and that both that copyright notice and this permission +# notice appear in supporting documentation, and that the name of +# Secret Labs AB or the author not be used in advertising or publicity +# pertaining to distribution of the software without specific, written +# prior permission. +# +# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD +# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT- +# ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR +# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY +# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS +# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE +# OF THIS SOFTWARE. +# -------------------------------------------------------------------- + +__all__ = [ + # public symbols + "Comment", + "dump", + "Element", "ElementTree", + "fromstring", "fromstringlist", + "indent", "iselement", "iterparse", + "parse", "ParseError", + "PI", "ProcessingInstruction", + "QName", + "SubElement", + "tostring", "tostringlist", + "TreeBuilder", + "VERSION", + "XML", "XMLID", + "XMLParser", "XMLPullParser", + "register_namespace", + "canonicalize", "C14NWriterTarget", + ] + +VERSION = "1.3.0" + +import sys +import re +import warnings +import io +import collections +import collections.abc +import contextlib +import weakref + +from . import ElementPath + + +class ParseError(SyntaxError): + """An error when parsing an XML document. + + In addition to its exception value, a ParseError contains + two extra attributes: + 'code' - the specific exception code + 'position' - the line and column of the error + + """ + pass + +# -------------------------------------------------------------------- + + +def iselement(element): + """Return True if *element* appears to be an Element.""" + return hasattr(element, 'tag') + + +class Element: + """An XML element. + + This class is the reference implementation of the Element interface. + + An element's length is its number of subelements. That means if you + want to check if an element is truly empty, you should check BOTH + its length AND its text attribute. + + The element tag, attribute names, and attribute values can be either + bytes or strings. + + *tag* is the element name. *attrib* is an optional dictionary containing + element attributes. *extra* are additional element attributes given as + keyword arguments. + + Example form: + text...tail + + """ + + tag = None + """The element's name.""" + + attrib = None + """Dictionary of the element's attributes.""" + + text = None + """ + Text before first subelement. This is either a string or the value None. + Note that if there is no text, this attribute may be either + None or the empty string, depending on the parser. + + """ + + tail = None + """ + Text after this element's end tag, but before the next sibling element's + start tag. This is either a string or the value None. Note that if there + was no text, this attribute may be either None or an empty string, + depending on the parser. + + """ + + def __init__(self, tag, attrib={}, **extra): + if not isinstance(attrib, dict): + raise TypeError("attrib must be dict, not %s" % ( + attrib.__class__.__name__,)) + self.tag = tag + self.attrib = {**attrib, **extra} + self._children = [] + + def __repr__(self): + return "<%s %r at %#x>" % (self.__class__.__name__, self.tag, id(self)) + + def makeelement(self, tag, attrib): + """Create a new element with the same type. + + *tag* is a string containing the element name. + *attrib* is a dictionary containing the element attributes. + + Do not call this method, use the SubElement factory function instead. + + """ + return self.__class__(tag, attrib) + + def copy(self): + """Return copy of current element. + + This creates a shallow copy. Subelements will be shared with the + original tree. + + """ + warnings.warn( + "elem.copy() is deprecated. Use copy.copy(elem) instead.", + DeprecationWarning + ) + return self.__copy__() + + def __copy__(self): + elem = self.makeelement(self.tag, self.attrib) + elem.text = self.text + elem.tail = self.tail + elem[:] = self + return elem + + def __len__(self): + return len(self._children) + + def __bool__(self): + warnings.warn( + "The behavior of this method will change in future versions. " + "Use specific 'len(elem)' or 'elem is not None' test instead.", + FutureWarning, stacklevel=2 + ) + return len(self._children) != 0 # emulate old behaviour, for now + + def __getitem__(self, index): + return self._children[index] + + def __setitem__(self, index, element): + if isinstance(index, slice): + for elt in element: + self._assert_is_element(elt) + else: + self._assert_is_element(element) + self._children[index] = element + + def __delitem__(self, index): + del self._children[index] + + def append(self, subelement): + """Add *subelement* to the end of this element. + + The new element will appear in document order after the last existing + subelement (or directly after the text, if it's the first subelement), + but before the end tag for this element. + + """ + self._assert_is_element(subelement) + self._children.append(subelement) + + def extend(self, elements): + """Append subelements from a sequence. + + *elements* is a sequence with zero or more elements. + + """ + for element in elements: + self._assert_is_element(element) + self._children.append(element) + + def insert(self, index, subelement): + """Insert *subelement* at position *index*.""" + self._assert_is_element(subelement) + self._children.insert(index, subelement) + + def _assert_is_element(self, e): + # Need to refer to the actual Python implementation, not the + # shadowing C implementation. + if not isinstance(e, _Element_Py): + raise TypeError('expected an Element, not %s' % type(e).__name__) + + def remove(self, subelement): + """Remove matching subelement. + + Unlike the find methods, this method compares elements based on + identity, NOT ON tag value or contents. To remove subelements by + other means, the easiest way is to use a list comprehension to + select what elements to keep, and then use slice assignment to update + the parent element. + + ValueError is raised if a matching element could not be found. + + """ + # assert iselement(element) + self._children.remove(subelement) + + def find(self, path, namespaces=None): + """Find first matching element by tag name or path. + + *path* is a string having either an element tag or an XPath, + *namespaces* is an optional mapping from namespace prefix to full name. + + Return the first matching element, or None if no element was found. + + """ + return ElementPath.find(self, path, namespaces) + + def findtext(self, path, default=None, namespaces=None): + """Find text for first matching element by tag name or path. + + *path* is a string having either an element tag or an XPath, + *default* is the value to return if the element was not found, + *namespaces* is an optional mapping from namespace prefix to full name. + + Return text content of first matching element, or default value if + none was found. Note that if an element is found having no text + content, the empty string is returned. + + """ + return ElementPath.findtext(self, path, default, namespaces) + + def findall(self, path, namespaces=None): + """Find all matching subelements by tag name or path. + + *path* is a string having either an element tag or an XPath, + *namespaces* is an optional mapping from namespace prefix to full name. + + Returns list containing all matching elements in document order. + + """ + return ElementPath.findall(self, path, namespaces) + + def iterfind(self, path, namespaces=None): + """Find all matching subelements by tag name or path. + + *path* is a string having either an element tag or an XPath, + *namespaces* is an optional mapping from namespace prefix to full name. + + Return an iterable yielding all matching elements in document order. + + """ + return ElementPath.iterfind(self, path, namespaces) + + def clear(self): + """Reset element. + + This function removes all subelements, clears all attributes, and sets + the text and tail attributes to None. + + """ + self.attrib.clear() + self._children = [] + self.text = self.tail = None + + def get(self, key, default=None): + """Get element attribute. + + Equivalent to attrib.get, but some implementations may handle this a + bit more efficiently. *key* is what attribute to look for, and + *default* is what to return if the attribute was not found. + + Returns a string containing the attribute value, or the default if + attribute was not found. + + """ + return self.attrib.get(key, default) + + def set(self, key, value): + """Set element attribute. + + Equivalent to attrib[key] = value, but some implementations may handle + this a bit more efficiently. *key* is what attribute to set, and + *value* is the attribute value to set it to. + + """ + self.attrib[key] = value + + def keys(self): + """Get list of attribute names. + + Names are returned in an arbitrary order, just like an ordinary + Python dict. Equivalent to attrib.keys() + + """ + return self.attrib.keys() + + def items(self): + """Get element attributes as a sequence. + + The attributes are returned in arbitrary order. Equivalent to + attrib.items(). + + Return a list of (name, value) tuples. + + """ + return self.attrib.items() + + def iter(self, tag=None): + """Create tree iterator. + + The iterator loops over the element and all subelements in document + order, returning all elements with a matching tag. + + If the tree structure is modified during iteration, new or removed + elements may or may not be included. To get a stable set, use the + list() function on the iterator, and loop over the resulting list. + + *tag* is what tags to look for (default is to return all elements) + + Return an iterator containing all the matching elements. + + """ + if tag == "*": + tag = None + if tag is None or self.tag == tag: + yield self + for e in self._children: + yield from e.iter(tag) + + def itertext(self): + """Create text iterator. + + The iterator loops over the element and all subelements in document + order, returning all inner text. + + """ + tag = self.tag + if not isinstance(tag, str) and tag is not None: + return + t = self.text + if t: + yield t + for e in self: + yield from e.itertext() + t = e.tail + if t: + yield t + + +def SubElement(parent, tag, attrib={}, **extra): + """Subelement factory which creates an element instance, and appends it + to an existing parent. + + The element tag, attribute names, and attribute values can be either + bytes or Unicode strings. + + *parent* is the parent element, *tag* is the subelements name, *attrib* is + an optional directory containing element attributes, *extra* are + additional attributes given as keyword arguments. + + """ + attrib = {**attrib, **extra} + element = parent.makeelement(tag, attrib) + parent.append(element) + return element + + +def Comment(text=None): + """Comment element factory. + + This function creates a special element which the standard serializer + serializes as an XML comment. + + *text* is a string containing the comment string. + + """ + element = Element(Comment) + element.text = text + return element + + +def ProcessingInstruction(target, text=None): + """Processing Instruction element factory. + + This function creates a special element which the standard serializer + serializes as an XML comment. + + *target* is a string containing the processing instruction, *text* is a + string containing the processing instruction contents, if any. + + """ + element = Element(ProcessingInstruction) + element.text = target + if text: + element.text = element.text + " " + text + return element + +PI = ProcessingInstruction + + +class QName: + """Qualified name wrapper. + + This class can be used to wrap a QName attribute value in order to get + proper namespace handing on output. + + *text_or_uri* is a string containing the QName value either in the form + {uri}local, or if the tag argument is given, the URI part of a QName. + + *tag* is an optional argument which if given, will make the first + argument (text_or_uri) be interpreted as a URI, and this argument (tag) + be interpreted as a local name. + + """ + def __init__(self, text_or_uri, tag=None): + if tag: + text_or_uri = "{%s}%s" % (text_or_uri, tag) + self.text = text_or_uri + def __str__(self): + return self.text + def __repr__(self): + return '<%s %r>' % (self.__class__.__name__, self.text) + def __hash__(self): + return hash(self.text) + def __le__(self, other): + if isinstance(other, QName): + return self.text <= other.text + return self.text <= other + def __lt__(self, other): + if isinstance(other, QName): + return self.text < other.text + return self.text < other + def __ge__(self, other): + if isinstance(other, QName): + return self.text >= other.text + return self.text >= other + def __gt__(self, other): + if isinstance(other, QName): + return self.text > other.text + return self.text > other + def __eq__(self, other): + if isinstance(other, QName): + return self.text == other.text + return self.text == other + +# -------------------------------------------------------------------- + + +class ElementTree: + """An XML element hierarchy. + + This class also provides support for serialization to and from + standard XML. + + *element* is an optional root element node, + *file* is an optional file handle or file name of an XML file whose + contents will be used to initialize the tree with. + + """ + def __init__(self, element=None, file=None): + # assert element is None or iselement(element) + self._root = element # first node + if file: + self.parse(file) + + def getroot(self): + """Return root element of this tree.""" + return self._root + + def _setroot(self, element): + """Replace root element of this tree. + + This will discard the current contents of the tree and replace it + with the given element. Use with care! + + """ + # assert iselement(element) + self._root = element + + def parse(self, source, parser=None): + """Load external XML document into element tree. + + *source* is a file name or file object, *parser* is an optional parser + instance that defaults to XMLParser. + + ParseError is raised if the parser fails to parse the document. + + Returns the root element of the given source document. + + """ + close_source = False + if not hasattr(source, "read"): + source = open(source, "rb") + close_source = True + try: + if parser is None: + # If no parser was specified, create a default XMLParser + parser = XMLParser() + if hasattr(parser, '_parse_whole'): + # The default XMLParser, when it comes from an accelerator, + # can define an internal _parse_whole API for efficiency. + # It can be used to parse the whole source without feeding + # it with chunks. + self._root = parser._parse_whole(source) + return self._root + while True: + data = source.read(65536) + if not data: + break + parser.feed(data) + self._root = parser.close() + return self._root + finally: + if close_source: + source.close() + + def iter(self, tag=None): + """Create and return tree iterator for the root element. + + The iterator loops over all elements in this tree, in document order. + + *tag* is a string with the tag name to iterate over + (default is to return all elements). + + """ + # assert self._root is not None + return self._root.iter(tag) + + def find(self, path, namespaces=None): + """Find first matching element by tag name or path. + + Same as getroot().find(path), which is Element.find() + + *path* is a string having either an element tag or an XPath, + *namespaces* is an optional mapping from namespace prefix to full name. + + Return the first matching element, or None if no element was found. + + """ + # assert self._root is not None + if path[:1] == "/": + path = "." + path + warnings.warn( + "This search is broken in 1.3 and earlier, and will be " + "fixed in a future version. If you rely on the current " + "behaviour, change it to %r" % path, + FutureWarning, stacklevel=2 + ) + return self._root.find(path, namespaces) + + def findtext(self, path, default=None, namespaces=None): + """Find first matching element by tag name or path. + + Same as getroot().findtext(path), which is Element.findtext() + + *path* is a string having either an element tag or an XPath, + *namespaces* is an optional mapping from namespace prefix to full name. + + Return the first matching element, or None if no element was found. + + """ + # assert self._root is not None + if path[:1] == "/": + path = "." + path + warnings.warn( + "This search is broken in 1.3 and earlier, and will be " + "fixed in a future version. If you rely on the current " + "behaviour, change it to %r" % path, + FutureWarning, stacklevel=2 + ) + return self._root.findtext(path, default, namespaces) + + def findall(self, path, namespaces=None): + """Find all matching subelements by tag name or path. + + Same as getroot().findall(path), which is Element.findall(). + + *path* is a string having either an element tag or an XPath, + *namespaces* is an optional mapping from namespace prefix to full name. + + Return list containing all matching elements in document order. + + """ + # assert self._root is not None + if path[:1] == "/": + path = "." + path + warnings.warn( + "This search is broken in 1.3 and earlier, and will be " + "fixed in a future version. If you rely on the current " + "behaviour, change it to %r" % path, + FutureWarning, stacklevel=2 + ) + return self._root.findall(path, namespaces) + + def iterfind(self, path, namespaces=None): + """Find all matching subelements by tag name or path. + + Same as getroot().iterfind(path), which is element.iterfind() + + *path* is a string having either an element tag or an XPath, + *namespaces* is an optional mapping from namespace prefix to full name. + + Return an iterable yielding all matching elements in document order. + + """ + # assert self._root is not None + if path[:1] == "/": + path = "." + path + warnings.warn( + "This search is broken in 1.3 and earlier, and will be " + "fixed in a future version. If you rely on the current " + "behaviour, change it to %r" % path, + FutureWarning, stacklevel=2 + ) + return self._root.iterfind(path, namespaces) + + def write(self, file_or_filename, + encoding=None, + xml_declaration=None, + default_namespace=None, + method=None, *, + short_empty_elements=True): + """Write element tree to a file as XML. + + Arguments: + *file_or_filename* -- file name or a file object opened for writing + + *encoding* -- the output encoding (default: US-ASCII) + + *xml_declaration* -- bool indicating if an XML declaration should be + added to the output. If None, an XML declaration + is added if encoding IS NOT either of: + US-ASCII, UTF-8, or Unicode + + *default_namespace* -- sets the default XML namespace (for "xmlns") + + *method* -- either "xml" (default), "html, "text", or "c14n" + + *short_empty_elements* -- controls the formatting of elements + that contain no content. If True (default) + they are emitted as a single self-closed + tag, otherwise they are emitted as a pair + of start/end tags + + """ + if not method: + method = "xml" + elif method not in _serialize: + raise ValueError("unknown method %r" % method) + if not encoding: + if method == "c14n": + encoding = "utf-8" + else: + encoding = "us-ascii" + with _get_writer(file_or_filename, encoding) as (write, declared_encoding): + if method == "xml" and (xml_declaration or + (xml_declaration is None and + encoding.lower() != "unicode" and + declared_encoding.lower() not in ("utf-8", "us-ascii"))): + write("\n" % ( + declared_encoding,)) + if method == "text": + _serialize_text(write, self._root) + else: + qnames, namespaces = _namespaces(self._root, default_namespace) + serialize = _serialize[method] + serialize(write, self._root, qnames, namespaces, + short_empty_elements=short_empty_elements) + + def write_c14n(self, file): + # lxml.etree compatibility. use output method instead + return self.write(file, method="c14n") + +# -------------------------------------------------------------------- +# serialization support + +@contextlib.contextmanager +def _get_writer(file_or_filename, encoding): + # returns text write method and release all resources after using + try: + write = file_or_filename.write + except AttributeError: + # file_or_filename is a file name + if encoding.lower() == "unicode": + encoding="utf-8" + with open(file_or_filename, "w", encoding=encoding, + errors="xmlcharrefreplace") as file: + yield file.write, encoding + else: + # file_or_filename is a file-like object + # encoding determines if it is a text or binary writer + if encoding.lower() == "unicode": + # use a text writer as is + yield write, getattr(file_or_filename, "encoding", None) or "utf-8" + else: + # wrap a binary writer with TextIOWrapper + with contextlib.ExitStack() as stack: + if isinstance(file_or_filename, io.BufferedIOBase): + file = file_or_filename + elif isinstance(file_or_filename, io.RawIOBase): + file = io.BufferedWriter(file_or_filename) + # Keep the original file open when the BufferedWriter is + # destroyed + stack.callback(file.detach) + else: + # This is to handle passed objects that aren't in the + # IOBase hierarchy, but just have a write method + file = io.BufferedIOBase() + file.writable = lambda: True + file.write = write + try: + # TextIOWrapper uses this methods to determine + # if BOM (for UTF-16, etc) should be added + file.seekable = file_or_filename.seekable + file.tell = file_or_filename.tell + except AttributeError: + pass + file = io.TextIOWrapper(file, + encoding=encoding, + errors="xmlcharrefreplace", + newline="\n") + # Keep the original file open when the TextIOWrapper is + # destroyed + stack.callback(file.detach) + yield file.write, encoding + +def _namespaces(elem, default_namespace=None): + # identify namespaces used in this tree + + # maps qnames to *encoded* prefix:local names + qnames = {None: None} + + # maps uri:s to prefixes + namespaces = {} + if default_namespace: + namespaces[default_namespace] = "" + + def add_qname(qname): + # calculate serialized qname representation + try: + if qname[:1] == "{": + uri, tag = qname[1:].rsplit("}", 1) + prefix = namespaces.get(uri) + if prefix is None: + prefix = _namespace_map.get(uri) + if prefix is None: + prefix = "ns%d" % len(namespaces) + if prefix != "xml": + namespaces[uri] = prefix + if prefix: + qnames[qname] = "%s:%s" % (prefix, tag) + else: + qnames[qname] = tag # default element + else: + if default_namespace: + # FIXME: can this be handled in XML 1.0? + raise ValueError( + "cannot use non-qualified names with " + "default_namespace option" + ) + qnames[qname] = qname + except TypeError: + _raise_serialization_error(qname) + + # populate qname and namespaces table + for elem in elem.iter(): + tag = elem.tag + if isinstance(tag, QName): + if tag.text not in qnames: + add_qname(tag.text) + elif isinstance(tag, str): + if tag not in qnames: + add_qname(tag) + elif tag is not None and tag is not Comment and tag is not PI: + _raise_serialization_error(tag) + for key, value in elem.items(): + if isinstance(key, QName): + key = key.text + if key not in qnames: + add_qname(key) + if isinstance(value, QName) and value.text not in qnames: + add_qname(value.text) + text = elem.text + if isinstance(text, QName) and text.text not in qnames: + add_qname(text.text) + return qnames, namespaces + +def _serialize_xml(write, elem, qnames, namespaces, + short_empty_elements, **kwargs): + tag = elem.tag + text = elem.text + if tag is Comment: + write("" % text) + elif tag is ProcessingInstruction: + write("" % text) + else: + tag = qnames[tag] + if tag is None: + if text: + write(_escape_cdata(text)) + for e in elem: + _serialize_xml(write, e, qnames, None, + short_empty_elements=short_empty_elements) + else: + write("<" + tag) + items = list(elem.items()) + if items or namespaces: + if namespaces: + for v, k in sorted(namespaces.items(), + key=lambda x: x[1]): # sort on prefix + if k: + k = ":" + k + write(" xmlns%s=\"%s\"" % ( + k, + _escape_attrib(v) + )) + for k, v in items: + if isinstance(k, QName): + k = k.text + if isinstance(v, QName): + v = qnames[v.text] + else: + v = _escape_attrib(v) + write(" %s=\"%s\"" % (qnames[k], v)) + if text or len(elem) or not short_empty_elements: + write(">") + if text: + write(_escape_cdata(text)) + for e in elem: + _serialize_xml(write, e, qnames, None, + short_empty_elements=short_empty_elements) + write("") + else: + write(" />") + if elem.tail: + write(_escape_cdata(elem.tail)) + +HTML_EMPTY = {"area", "base", "basefont", "br", "col", "embed", "frame", "hr", + "img", "input", "isindex", "link", "meta", "param", "source", + "track", "wbr"} + +def _serialize_html(write, elem, qnames, namespaces, **kwargs): + tag = elem.tag + text = elem.text + if tag is Comment: + write("" % _escape_cdata(text)) + elif tag is ProcessingInstruction: + write("" % _escape_cdata(text)) + else: + tag = qnames[tag] + if tag is None: + if text: + write(_escape_cdata(text)) + for e in elem: + _serialize_html(write, e, qnames, None) + else: + write("<" + tag) + items = list(elem.items()) + if items or namespaces: + if namespaces: + for v, k in sorted(namespaces.items(), + key=lambda x: x[1]): # sort on prefix + if k: + k = ":" + k + write(" xmlns%s=\"%s\"" % ( + k, + _escape_attrib(v) + )) + for k, v in items: + if isinstance(k, QName): + k = k.text + if isinstance(v, QName): + v = qnames[v.text] + else: + v = _escape_attrib_html(v) + # FIXME: handle boolean attributes + write(" %s=\"%s\"" % (qnames[k], v)) + write(">") + ltag = tag.lower() + if text: + if ltag == "script" or ltag == "style": + write(text) + else: + write(_escape_cdata(text)) + for e in elem: + _serialize_html(write, e, qnames, None) + if ltag not in HTML_EMPTY: + write("") + if elem.tail: + write(_escape_cdata(elem.tail)) + +def _serialize_text(write, elem): + for part in elem.itertext(): + write(part) + if elem.tail: + write(elem.tail) + +_serialize = { + "xml": _serialize_xml, + "html": _serialize_html, + "text": _serialize_text, +# this optional method is imported at the end of the module +# "c14n": _serialize_c14n, +} + + +def register_namespace(prefix, uri): + """Register a namespace prefix. + + The registry is global, and any existing mapping for either the + given prefix or the namespace URI will be removed. + + *prefix* is the namespace prefix, *uri* is a namespace uri. Tags and + attributes in this namespace will be serialized with prefix if possible. + + ValueError is raised if prefix is reserved or is invalid. + + """ + if re.match(r"ns\d+$", prefix): + raise ValueError("Prefix format reserved for internal use") + for k, v in list(_namespace_map.items()): + if k == uri or v == prefix: + del _namespace_map[k] + _namespace_map[uri] = prefix + +_namespace_map = { + # "well-known" namespace prefixes + "http://www.w3.org/XML/1998/namespace": "xml", + "http://www.w3.org/1999/xhtml": "html", + "http://www.w3.org/1999/02/22-rdf-syntax-ns#": "rdf", + "http://schemas.xmlsoap.org/wsdl/": "wsdl", + # xml schema + "http://www.w3.org/2001/XMLSchema": "xs", + "http://www.w3.org/2001/XMLSchema-instance": "xsi", + # dublin core + "http://purl.org/dc/elements/1.1/": "dc", +} +# For tests and troubleshooting +register_namespace._namespace_map = _namespace_map + +def _raise_serialization_error(text): + raise TypeError( + "cannot serialize %r (type %s)" % (text, type(text).__name__) + ) + +def _escape_cdata(text): + # escape character data + try: + # it's worth avoiding do-nothing calls for strings that are + # shorter than 500 characters, or so. assume that's, by far, + # the most common case in most applications. + if "&" in text: + text = text.replace("&", "&") + if "<" in text: + text = text.replace("<", "<") + if ">" in text: + text = text.replace(">", ">") + return text + except (TypeError, AttributeError): + _raise_serialization_error(text) + +def _escape_attrib(text): + # escape attribute value + try: + if "&" in text: + text = text.replace("&", "&") + if "<" in text: + text = text.replace("<", "<") + if ">" in text: + text = text.replace(">", ">") + if "\"" in text: + text = text.replace("\"", """) + # Although section 2.11 of the XML specification states that CR or + # CR LN should be replaced with just LN, it applies only to EOLNs + # which take part of organizing file into lines. Within attributes, + # we are replacing these with entity numbers, so they do not count. + # http://www.w3.org/TR/REC-xml/#sec-line-ends + # The current solution, contained in following six lines, was + # discussed in issue 17582 and 39011. + if "\r" in text: + text = text.replace("\r", " ") + if "\n" in text: + text = text.replace("\n", " ") + if "\t" in text: + text = text.replace("\t", " ") + return text + except (TypeError, AttributeError): + _raise_serialization_error(text) + +def _escape_attrib_html(text): + # escape attribute value + try: + if "&" in text: + text = text.replace("&", "&") + if ">" in text: + text = text.replace(">", ">") + if "\"" in text: + text = text.replace("\"", """) + return text + except (TypeError, AttributeError): + _raise_serialization_error(text) + +# -------------------------------------------------------------------- + +def tostring(element, encoding=None, method=None, *, + xml_declaration=None, default_namespace=None, + short_empty_elements=True): + """Generate string representation of XML element. + + All subelements are included. If encoding is "unicode", a string + is returned. Otherwise a bytestring is returned. + + *element* is an Element instance, *encoding* is an optional output + encoding defaulting to US-ASCII, *method* is an optional output which can + be one of "xml" (default), "html", "text" or "c14n", *default_namespace* + sets the default XML namespace (for "xmlns"). + + Returns an (optionally) encoded string containing the XML data. + + """ + stream = io.StringIO() if encoding == 'unicode' else io.BytesIO() + ElementTree(element).write(stream, encoding, + xml_declaration=xml_declaration, + default_namespace=default_namespace, + method=method, + short_empty_elements=short_empty_elements) + return stream.getvalue() + +class _ListDataStream(io.BufferedIOBase): + """An auxiliary stream accumulating into a list reference.""" + def __init__(self, lst): + self.lst = lst + + def writable(self): + return True + + def seekable(self): + return True + + def write(self, b): + self.lst.append(b) + + def tell(self): + return len(self.lst) + +def tostringlist(element, encoding=None, method=None, *, + xml_declaration=None, default_namespace=None, + short_empty_elements=True): + lst = [] + stream = _ListDataStream(lst) + ElementTree(element).write(stream, encoding, + xml_declaration=xml_declaration, + default_namespace=default_namespace, + method=method, + short_empty_elements=short_empty_elements) + return lst + + +def dump(elem): + """Write element tree or element structure to sys.stdout. + + This function should be used for debugging only. + + *elem* is either an ElementTree, or a single Element. The exact output + format is implementation dependent. In this version, it's written as an + ordinary XML file. + + """ + # debugging + if not isinstance(elem, ElementTree): + elem = ElementTree(elem) + elem.write(sys.stdout, encoding="unicode") + tail = elem.getroot().tail + if not tail or tail[-1] != "\n": + sys.stdout.write("\n") + + +def indent(tree, space=" ", level=0): + """Indent an XML document by inserting newlines and indentation space + after elements. + + *tree* is the ElementTree or Element to modify. The (root) element + itself will not be changed, but the tail text of all elements in its + subtree will be adapted. + + *space* is the whitespace to insert for each indentation level, two + space characters by default. + + *level* is the initial indentation level. Setting this to a higher + value than 0 can be used for indenting subtrees that are more deeply + nested inside of a document. + """ + if isinstance(tree, ElementTree): + tree = tree.getroot() + if level < 0: + raise ValueError(f"Initial indentation level must be >= 0, got {level}") + if not len(tree): + return + + # Reduce the memory consumption by reusing indentation strings. + indentations = ["\n" + level * space] + + def _indent_children(elem, level): + # Start a new indentation level for the first child. + child_level = level + 1 + try: + child_indentation = indentations[child_level] + except IndexError: + child_indentation = indentations[level] + space + indentations.append(child_indentation) + + if not elem.text or not elem.text.strip(): + elem.text = child_indentation + + for child in elem: + if len(child): + _indent_children(child, child_level) + if not child.tail or not child.tail.strip(): + child.tail = child_indentation + + # Dedent after the last child by overwriting the previous indentation. + if not child.tail.strip(): + child.tail = indentations[level] + + _indent_children(tree, 0) + + +# -------------------------------------------------------------------- +# parsing + + +def parse(source, parser=None): + """Parse XML document into element tree. + + *source* is a filename or file object containing XML data, + *parser* is an optional parser instance defaulting to XMLParser. + + Return an ElementTree instance. + + """ + tree = ElementTree() + tree.parse(source, parser) + return tree + + +def iterparse(source, events=None, parser=None): + """Incrementally parse XML document into ElementTree. + + This class also reports what's going on to the user based on the + *events* it is initialized with. The supported events are the strings + "start", "end", "start-ns" and "end-ns" (the "ns" events are used to get + detailed namespace information). If *events* is omitted, only + "end" events are reported. + + *source* is a filename or file object containing XML data, *events* is + a list of events to report back, *parser* is an optional parser instance. + + Returns an iterator providing (event, elem) pairs. + + """ + # Use the internal, undocumented _parser argument for now; When the + # parser argument of iterparse is removed, this can be killed. + pullparser = XMLPullParser(events=events, _parser=parser) + + if not hasattr(source, "read"): + source = open(source, "rb") + close_source = True + else: + close_source = False + + def iterator(source): + try: + while True: + yield from pullparser.read_events() + # load event buffer + data = source.read(16 * 1024) + if not data: + break + pullparser.feed(data) + root = pullparser._close_and_return_root() + yield from pullparser.read_events() + it = wr() + if it is not None: + it.root = root + finally: + if close_source: + source.close() + + class IterParseIterator(collections.abc.Iterator): + __next__ = iterator(source).__next__ + + def __del__(self): + if close_source: + source.close() + + it = IterParseIterator() + it.root = None + wr = weakref.ref(it) + return it + + +class XMLPullParser: + + def __init__(self, events=None, *, _parser=None): + # The _parser argument is for internal use only and must not be relied + # upon in user code. It will be removed in a future release. + # See https://bugs.python.org/issue17741 for more details. + + self._events_queue = collections.deque() + self._parser = _parser or XMLParser(target=TreeBuilder()) + # wire up the parser for event reporting + if events is None: + events = ("end",) + self._parser._setevents(self._events_queue, events) + + def feed(self, data): + """Feed encoded data to parser.""" + if self._parser is None: + raise ValueError("feed() called after end of stream") + if data: + try: + self._parser.feed(data) + except SyntaxError as exc: + self._events_queue.append(exc) + + def _close_and_return_root(self): + # iterparse needs this to set its root attribute properly :( + root = self._parser.close() + self._parser = None + return root + + def close(self): + """Finish feeding data to parser. + + Unlike XMLParser, does not return the root element. Use + read_events() to consume elements from XMLPullParser. + """ + self._close_and_return_root() + + def read_events(self): + """Return an iterator over currently available (event, elem) pairs. + + Events are consumed from the internal event queue as they are + retrieved from the iterator. + """ + events = self._events_queue + while events: + event = events.popleft() + if isinstance(event, Exception): + raise event + else: + yield event + + def flush(self): + if self._parser is None: + raise ValueError("flush() called after end of stream") + self._parser.flush() + + +def XML(text, parser=None): + """Parse XML document from string constant. + + This function can be used to embed "XML Literals" in Python code. + + *text* is a string containing XML data, *parser* is an + optional parser instance, defaulting to the standard XMLParser. + + Returns an Element instance. + + """ + if not parser: + parser = XMLParser(target=TreeBuilder()) + parser.feed(text) + return parser.close() + + +def XMLID(text, parser=None): + """Parse XML document from string constant for its IDs. + + *text* is a string containing XML data, *parser* is an + optional parser instance, defaulting to the standard XMLParser. + + Returns an (Element, dict) tuple, in which the + dict maps element id:s to elements. + + """ + if not parser: + parser = XMLParser(target=TreeBuilder()) + parser.feed(text) + tree = parser.close() + ids = {} + for elem in tree.iter(): + id = elem.get("id") + if id: + ids[id] = elem + return tree, ids + +# Parse XML document from string constant. Alias for XML(). +fromstring = XML + +def fromstringlist(sequence, parser=None): + """Parse XML document from sequence of string fragments. + + *sequence* is a list of other sequence, *parser* is an optional parser + instance, defaulting to the standard XMLParser. + + Returns an Element instance. + + """ + if not parser: + parser = XMLParser(target=TreeBuilder()) + for text in sequence: + parser.feed(text) + return parser.close() + +# -------------------------------------------------------------------- + + +class TreeBuilder: + """Generic element structure builder. + + This builder converts a sequence of start, data, and end method + calls to a well-formed element structure. + + You can use this class to build an element structure using a custom XML + parser, or a parser for some other XML-like format. + + *element_factory* is an optional element factory which is called + to create new Element instances, as necessary. + + *comment_factory* is a factory to create comments to be used instead of + the standard factory. If *insert_comments* is false (the default), + comments will not be inserted into the tree. + + *pi_factory* is a factory to create processing instructions to be used + instead of the standard factory. If *insert_pis* is false (the default), + processing instructions will not be inserted into the tree. + """ + def __init__(self, element_factory=None, *, + comment_factory=None, pi_factory=None, + insert_comments=False, insert_pis=False): + self._data = [] # data collector + self._elem = [] # element stack + self._last = None # last element + self._root = None # root element + self._tail = None # true if we're after an end tag + if comment_factory is None: + comment_factory = Comment + self._comment_factory = comment_factory + self.insert_comments = insert_comments + if pi_factory is None: + pi_factory = ProcessingInstruction + self._pi_factory = pi_factory + self.insert_pis = insert_pis + if element_factory is None: + element_factory = Element + self._factory = element_factory + + def close(self): + """Flush builder buffers and return toplevel document Element.""" + assert len(self._elem) == 0, "missing end tags" + assert self._root is not None, "missing toplevel element" + return self._root + + def _flush(self): + if self._data: + if self._last is not None: + text = "".join(self._data) + if self._tail: + assert self._last.tail is None, "internal error (tail)" + self._last.tail = text + else: + assert self._last.text is None, "internal error (text)" + self._last.text = text + self._data = [] + + def data(self, data): + """Add text to current element.""" + self._data.append(data) + + def start(self, tag, attrs): + """Open new element and return it. + + *tag* is the element name, *attrs* is a dict containing element + attributes. + + """ + self._flush() + self._last = elem = self._factory(tag, attrs) + if self._elem: + self._elem[-1].append(elem) + elif self._root is None: + self._root = elem + self._elem.append(elem) + self._tail = 0 + return elem + + def end(self, tag): + """Close and return current Element. + + *tag* is the element name. + + """ + self._flush() + self._last = self._elem.pop() + assert self._last.tag == tag,\ + "end tag mismatch (expected %s, got %s)" % ( + self._last.tag, tag) + self._tail = 1 + return self._last + + def comment(self, text): + """Create a comment using the comment_factory. + + *text* is the text of the comment. + """ + return self._handle_single( + self._comment_factory, self.insert_comments, text) + + def pi(self, target, text=None): + """Create a processing instruction using the pi_factory. + + *target* is the target name of the processing instruction. + *text* is the data of the processing instruction, or ''. + """ + return self._handle_single( + self._pi_factory, self.insert_pis, target, text) + + def _handle_single(self, factory, insert, *args): + elem = factory(*args) + if insert: + self._flush() + self._last = elem + if self._elem: + self._elem[-1].append(elem) + self._tail = 1 + return elem + + +# also see ElementTree and TreeBuilder +class XMLParser: + """Element structure builder for XML source data based on the expat parser. + + *target* is an optional target object which defaults to an instance of the + standard TreeBuilder class, *encoding* is an optional encoding string + which if given, overrides the encoding specified in the XML file: + http://www.iana.org/assignments/character-sets + + """ + + def __init__(self, *, target=None, encoding=None): + try: + from xml.parsers import expat + except ImportError: + try: + import pyexpat as expat + except ImportError: + raise ImportError( + "No module named expat; use SimpleXMLTreeBuilder instead" + ) + parser = expat.ParserCreate(encoding, "}") + if target is None: + target = TreeBuilder() + # underscored names are provided for compatibility only + self.parser = self._parser = parser + self.target = self._target = target + self._error = expat.error + self._names = {} # name memo cache + # main callbacks + parser.DefaultHandlerExpand = self._default + if hasattr(target, 'start'): + parser.StartElementHandler = self._start + if hasattr(target, 'end'): + parser.EndElementHandler = self._end + if hasattr(target, 'start_ns'): + parser.StartNamespaceDeclHandler = self._start_ns + if hasattr(target, 'end_ns'): + parser.EndNamespaceDeclHandler = self._end_ns + if hasattr(target, 'data'): + parser.CharacterDataHandler = target.data + # miscellaneous callbacks + if hasattr(target, 'comment'): + parser.CommentHandler = target.comment + if hasattr(target, 'pi'): + parser.ProcessingInstructionHandler = target.pi + # Configure pyexpat: buffering, new-style attribute handling. + parser.buffer_text = 1 + parser.ordered_attributes = 1 + self._doctype = None + self.entity = {} + try: + self.version = "Expat %d.%d.%d" % expat.version_info + except AttributeError: + pass # unknown + + def _setevents(self, events_queue, events_to_report): + # Internal API for XMLPullParser + # events_to_report: a list of events to report during parsing (same as + # the *events* of XMLPullParser's constructor. + # events_queue: a list of actual parsing events that will be populated + # by the underlying parser. + # + parser = self._parser + append = events_queue.append + for event_name in events_to_report: + if event_name == "start": + parser.ordered_attributes = 1 + def handler(tag, attrib_in, event=event_name, append=append, + start=self._start): + append((event, start(tag, attrib_in))) + parser.StartElementHandler = handler + elif event_name == "end": + def handler(tag, event=event_name, append=append, + end=self._end): + append((event, end(tag))) + parser.EndElementHandler = handler + elif event_name == "start-ns": + # TreeBuilder does not implement .start_ns() + if hasattr(self.target, "start_ns"): + def handler(prefix, uri, event=event_name, append=append, + start_ns=self._start_ns): + append((event, start_ns(prefix, uri))) + else: + def handler(prefix, uri, event=event_name, append=append): + append((event, (prefix or '', uri or ''))) + parser.StartNamespaceDeclHandler = handler + elif event_name == "end-ns": + # TreeBuilder does not implement .end_ns() + if hasattr(self.target, "end_ns"): + def handler(prefix, event=event_name, append=append, + end_ns=self._end_ns): + append((event, end_ns(prefix))) + else: + def handler(prefix, event=event_name, append=append): + append((event, None)) + parser.EndNamespaceDeclHandler = handler + elif event_name == 'comment': + def handler(text, event=event_name, append=append, self=self): + append((event, self.target.comment(text))) + parser.CommentHandler = handler + elif event_name == 'pi': + def handler(pi_target, data, event=event_name, append=append, + self=self): + append((event, self.target.pi(pi_target, data))) + parser.ProcessingInstructionHandler = handler + else: + raise ValueError("unknown event %r" % event_name) + + def _raiseerror(self, value): + err = ParseError(value) + err.code = value.code + err.position = value.lineno, value.offset + raise err + + def _fixname(self, key): + # expand qname, and convert name string to ascii, if possible + try: + name = self._names[key] + except KeyError: + name = key + if "}" in name: + name = "{" + name + self._names[key] = name + return name + + def _start_ns(self, prefix, uri): + return self.target.start_ns(prefix or '', uri or '') + + def _end_ns(self, prefix): + return self.target.end_ns(prefix or '') + + def _start(self, tag, attr_list): + # Handler for expat's StartElementHandler. Since ordered_attributes + # is set, the attributes are reported as a list of alternating + # attribute name,value. + fixname = self._fixname + tag = fixname(tag) + attrib = {} + if attr_list: + for i in range(0, len(attr_list), 2): + attrib[fixname(attr_list[i])] = attr_list[i+1] + return self.target.start(tag, attrib) + + def _end(self, tag): + return self.target.end(self._fixname(tag)) + + def _default(self, text): + prefix = text[:1] + if prefix == "&": + # deal with undefined entities + try: + data_handler = self.target.data + except AttributeError: + return + try: + data_handler(self.entity[text[1:-1]]) + except KeyError: + from xml.parsers import expat + err = expat.error( + "undefined entity %s: line %d, column %d" % + (text, self.parser.ErrorLineNumber, + self.parser.ErrorColumnNumber) + ) + err.code = 11 # XML_ERROR_UNDEFINED_ENTITY + err.lineno = self.parser.ErrorLineNumber + err.offset = self.parser.ErrorColumnNumber + raise err + elif prefix == "<" and text[:9] == "": + self._doctype = None + return + text = text.strip() + if not text: + return + self._doctype.append(text) + n = len(self._doctype) + if n > 2: + type = self._doctype[1] + if type == "PUBLIC" and n == 4: + name, type, pubid, system = self._doctype + if pubid: + pubid = pubid[1:-1] + elif type == "SYSTEM" and n == 3: + name, type, system = self._doctype + pubid = None + else: + return + if hasattr(self.target, "doctype"): + self.target.doctype(name, pubid, system[1:-1]) + elif hasattr(self, "doctype"): + warnings.warn( + "The doctype() method of XMLParser is ignored. " + "Define doctype() method on the TreeBuilder target.", + RuntimeWarning) + + self._doctype = None + + def feed(self, data): + """Feed encoded data to parser.""" + try: + self.parser.Parse(data, False) + except self._error as v: + self._raiseerror(v) + + def close(self): + """Finish feeding data to parser and return element structure.""" + try: + self.parser.Parse(b"", True) # end of data + except self._error as v: + self._raiseerror(v) + try: + close_handler = self.target.close + except AttributeError: + pass + else: + return close_handler() + finally: + # get rid of circular references + del self.parser, self._parser + del self.target, self._target + + def flush(self): + was_enabled = self.parser.GetReparseDeferralEnabled() + try: + self.parser.SetReparseDeferralEnabled(False) + self.parser.Parse(b"", False) + except self._error as v: + self._raiseerror(v) + finally: + self.parser.SetReparseDeferralEnabled(was_enabled) + +# -------------------------------------------------------------------- +# C14N 2.0 + +def canonicalize(xml_data=None, *, out=None, from_file=None, **options): + """Convert XML to its C14N 2.0 serialised form. + + If *out* is provided, it must be a file or file-like object that receives + the serialised canonical XML output (text, not bytes) through its ``.write()`` + method. To write to a file, open it in text mode with encoding "utf-8". + If *out* is not provided, this function returns the output as text string. + + Either *xml_data* (an XML string) or *from_file* (a file path or + file-like object) must be provided as input. + + The configuration options are the same as for the ``C14NWriterTarget``. + """ + if xml_data is None and from_file is None: + raise ValueError("Either 'xml_data' or 'from_file' must be provided as input") + sio = None + if out is None: + sio = out = io.StringIO() + + parser = XMLParser(target=C14NWriterTarget(out.write, **options)) + + if xml_data is not None: + parser.feed(xml_data) + parser.close() + elif from_file is not None: + parse(from_file, parser=parser) + + return sio.getvalue() if sio is not None else None + + +_looks_like_prefix_name = re.compile(r'^\w+:\w+$', re.UNICODE).match + + +class C14NWriterTarget: + """ + Canonicalization writer target for the XMLParser. + + Serialises parse events to XML C14N 2.0. + + The *write* function is used for writing out the resulting data stream + as text (not bytes). To write to a file, open it in text mode with encoding + "utf-8" and pass its ``.write`` method. + + Configuration options: + + - *with_comments*: set to true to include comments + - *strip_text*: set to true to strip whitespace before and after text content + - *rewrite_prefixes*: set to true to replace namespace prefixes by "n{number}" + - *qname_aware_tags*: a set of qname aware tag names in which prefixes + should be replaced in text content + - *qname_aware_attrs*: a set of qname aware attribute names in which prefixes + should be replaced in text content + - *exclude_attrs*: a set of attribute names that should not be serialised + - *exclude_tags*: a set of tag names that should not be serialised + """ + def __init__(self, write, *, + with_comments=False, strip_text=False, rewrite_prefixes=False, + qname_aware_tags=None, qname_aware_attrs=None, + exclude_attrs=None, exclude_tags=None): + self._write = write + self._data = [] + self._with_comments = with_comments + self._strip_text = strip_text + self._exclude_attrs = set(exclude_attrs) if exclude_attrs else None + self._exclude_tags = set(exclude_tags) if exclude_tags else None + + self._rewrite_prefixes = rewrite_prefixes + if qname_aware_tags: + self._qname_aware_tags = set(qname_aware_tags) + else: + self._qname_aware_tags = None + if qname_aware_attrs: + self._find_qname_aware_attrs = set(qname_aware_attrs).intersection + else: + self._find_qname_aware_attrs = None + + # Stack with globally and newly declared namespaces as (uri, prefix) pairs. + self._declared_ns_stack = [[ + ("http://www.w3.org/XML/1998/namespace", "xml"), + ]] + # Stack with user declared namespace prefixes as (uri, prefix) pairs. + self._ns_stack = [] + if not rewrite_prefixes: + self._ns_stack.append(list(_namespace_map.items())) + self._ns_stack.append([]) + self._prefix_map = {} + self._preserve_space = [False] + self._pending_start = None + self._root_seen = False + self._root_done = False + self._ignored_depth = 0 + + def _iter_namespaces(self, ns_stack, _reversed=reversed): + for namespaces in _reversed(ns_stack): + if namespaces: # almost no element declares new namespaces + yield from namespaces + + def _resolve_prefix_name(self, prefixed_name): + prefix, name = prefixed_name.split(':', 1) + for uri, p in self._iter_namespaces(self._ns_stack): + if p == prefix: + return f'{{{uri}}}{name}' + raise ValueError(f'Prefix {prefix} of QName "{prefixed_name}" is not declared in scope') + + def _qname(self, qname, uri=None): + if uri is None: + uri, tag = qname[1:].rsplit('}', 1) if qname[:1] == '{' else ('', qname) + else: + tag = qname + + prefixes_seen = set() + for u, prefix in self._iter_namespaces(self._declared_ns_stack): + if u == uri and prefix not in prefixes_seen: + return f'{prefix}:{tag}' if prefix else tag, tag, uri + prefixes_seen.add(prefix) + + # Not declared yet => add new declaration. + if self._rewrite_prefixes: + if uri in self._prefix_map: + prefix = self._prefix_map[uri] + else: + prefix = self._prefix_map[uri] = f'n{len(self._prefix_map)}' + self._declared_ns_stack[-1].append((uri, prefix)) + return f'{prefix}:{tag}', tag, uri + + if not uri and '' not in prefixes_seen: + # No default namespace declared => no prefix needed. + return tag, tag, uri + + for u, prefix in self._iter_namespaces(self._ns_stack): + if u == uri: + self._declared_ns_stack[-1].append((uri, prefix)) + return f'{prefix}:{tag}' if prefix else tag, tag, uri + + if not uri: + # As soon as a default namespace is defined, + # anything that has no namespace (and thus, no prefix) goes there. + return tag, tag, uri + + raise ValueError(f'Namespace "{uri}" is not declared in scope') + + def data(self, data): + if not self._ignored_depth: + self._data.append(data) + + def _flush(self, _join_text=''.join): + data = _join_text(self._data) + del self._data[:] + if self._strip_text and not self._preserve_space[-1]: + data = data.strip() + if self._pending_start is not None: + args, self._pending_start = self._pending_start, None + qname_text = data if data and _looks_like_prefix_name(data) else None + self._start(*args, qname_text) + if qname_text is not None: + return + if data and self._root_seen: + self._write(_escape_cdata_c14n(data)) + + def start_ns(self, prefix, uri): + if self._ignored_depth: + return + # we may have to resolve qnames in text content + if self._data: + self._flush() + self._ns_stack[-1].append((uri, prefix)) + + def start(self, tag, attrs): + if self._exclude_tags is not None and ( + self._ignored_depth or tag in self._exclude_tags): + self._ignored_depth += 1 + return + if self._data: + self._flush() + + new_namespaces = [] + self._declared_ns_stack.append(new_namespaces) + + if self._qname_aware_tags is not None and tag in self._qname_aware_tags: + # Need to parse text first to see if it requires a prefix declaration. + self._pending_start = (tag, attrs, new_namespaces) + return + self._start(tag, attrs, new_namespaces) + + def _start(self, tag, attrs, new_namespaces, qname_text=None): + if self._exclude_attrs is not None and attrs: + attrs = {k: v for k, v in attrs.items() if k not in self._exclude_attrs} + + qnames = {tag, *attrs} + resolved_names = {} + + # Resolve prefixes in attribute and tag text. + if qname_text is not None: + qname = resolved_names[qname_text] = self._resolve_prefix_name(qname_text) + qnames.add(qname) + if self._find_qname_aware_attrs is not None and attrs: + qattrs = self._find_qname_aware_attrs(attrs) + if qattrs: + for attr_name in qattrs: + value = attrs[attr_name] + if _looks_like_prefix_name(value): + qname = resolved_names[value] = self._resolve_prefix_name(value) + qnames.add(qname) + else: + qattrs = None + else: + qattrs = None + + # Assign prefixes in lexicographical order of used URIs. + parse_qname = self._qname + parsed_qnames = {n: parse_qname(n) for n in sorted( + qnames, key=lambda n: n.split('}', 1))} + + # Write namespace declarations in prefix order ... + if new_namespaces: + attr_list = [ + ('xmlns:' + prefix if prefix else 'xmlns', uri) + for uri, prefix in new_namespaces + ] + attr_list.sort() + else: + # almost always empty + attr_list = [] + + # ... followed by attributes in URI+name order + if attrs: + for k, v in sorted(attrs.items()): + if qattrs is not None and k in qattrs and v in resolved_names: + v = parsed_qnames[resolved_names[v]][0] + attr_qname, attr_name, uri = parsed_qnames[k] + # No prefix for attributes in default ('') namespace. + attr_list.append((attr_qname if uri else attr_name, v)) + + # Honour xml:space attributes. + space_behaviour = attrs.get('{http://www.w3.org/XML/1998/namespace}space') + self._preserve_space.append( + space_behaviour == 'preserve' if space_behaviour + else self._preserve_space[-1]) + + # Write the tag. + write = self._write + write('<' + parsed_qnames[tag][0]) + if attr_list: + write(''.join([f' {k}="{_escape_attrib_c14n(v)}"' for k, v in attr_list])) + write('>') + + # Write the resolved qname text content. + if qname_text is not None: + write(_escape_cdata_c14n(parsed_qnames[resolved_names[qname_text]][0])) + + self._root_seen = True + self._ns_stack.append([]) + + def end(self, tag): + if self._ignored_depth: + self._ignored_depth -= 1 + return + if self._data: + self._flush() + self._write(f'') + self._preserve_space.pop() + self._root_done = len(self._preserve_space) == 1 + self._declared_ns_stack.pop() + self._ns_stack.pop() + + def comment(self, text): + if not self._with_comments: + return + if self._ignored_depth: + return + if self._root_done: + self._write('\n') + elif self._root_seen and self._data: + self._flush() + self._write(f'') + if not self._root_seen: + self._write('\n') + + def pi(self, target, data): + if self._ignored_depth: + return + if self._root_done: + self._write('\n') + elif self._root_seen and self._data: + self._flush() + self._write( + f'' if data else f'') + if not self._root_seen: + self._write('\n') + + +def _escape_cdata_c14n(text): + # escape character data + try: + # it's worth avoiding do-nothing calls for strings that are + # shorter than 500 character, or so. assume that's, by far, + # the most common case in most applications. + if '&' in text: + text = text.replace('&', '&') + if '<' in text: + text = text.replace('<', '<') + if '>' in text: + text = text.replace('>', '>') + if '\r' in text: + text = text.replace('\r', ' ') + return text + except (TypeError, AttributeError): + _raise_serialization_error(text) + + +def _escape_attrib_c14n(text): + # escape attribute value + try: + if '&' in text: + text = text.replace('&', '&') + if '<' in text: + text = text.replace('<', '<') + if '"' in text: + text = text.replace('"', '"') + if '\t' in text: + text = text.replace('\t', ' ') + if '\n' in text: + text = text.replace('\n', ' ') + if '\r' in text: + text = text.replace('\r', ' ') + return text + except (TypeError, AttributeError): + _raise_serialization_error(text) + + +# -------------------------------------------------------------------- + +# Import the C accelerators +try: + # Element is going to be shadowed by the C implementation. We need to keep + # the Python version of it accessible for some "creative" by external code + # (see tests) + _Element_Py = Element + + # Element, SubElement, ParseError, TreeBuilder, XMLParser, _set_factories + from _elementtree import * + from _elementtree import _set_factories +except ImportError: + pass +else: + _set_factories(Comment, ProcessingInstruction) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e2ec53421d3f70267ddc34436eec6a30ee9f1855 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__init__.py @@ -0,0 +1,33 @@ +# $Id: __init__.py 3375 2008-02-13 08:05:08Z fredrik $ +# elementtree package + +# -------------------------------------------------------------------- +# The ElementTree toolkit is +# +# Copyright (c) 1999-2008 by Fredrik Lundh +# +# By obtaining, using, and/or copying this software and/or its +# associated documentation, you agree that you have read, understood, +# and will comply with the following terms and conditions: +# +# Permission to use, copy, modify, and distribute this software and +# its associated documentation for any purpose and without fee is +# hereby granted, provided that the above copyright notice appears in +# all copies, and that both that copyright notice and this permission +# notice appear in supporting documentation, and that the name of +# Secret Labs AB or the author not be used in advertising or publicity +# pertaining to distribution of the software without specific, written +# prior permission. +# +# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD +# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT- +# ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR +# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY +# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS +# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE +# OF THIS SOFTWARE. +# -------------------------------------------------------------------- + +# Licensed to PSF under a Contributor Agreement. +# See https://www.python.org/psf/license for licensing details. diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__pycache__/ElementInclude.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__pycache__/ElementInclude.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a5894998dd8866d4bcd4cdb162455da16b231869 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__pycache__/ElementInclude.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__pycache__/ElementPath.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__pycache__/ElementPath.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..77033e415020300f5369d0b125b06cba694ff1a9 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__pycache__/ElementPath.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__pycache__/ElementTree.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__pycache__/ElementTree.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..961180f747e472177ebaadad8ed3df458380d583 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__pycache__/ElementTree.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b744be94570168844b59adbf7f234b2b8cd9fefb Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__pycache__/cElementTree.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__pycache__/cElementTree.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03c8431112b48034fb8c913a268881e2a4c768de Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/__pycache__/cElementTree.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/cElementTree.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/cElementTree.py new file mode 100644 index 0000000000000000000000000000000000000000..368e679189582990ab92cd73b8b820e74df253a7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/etree/cElementTree.py @@ -0,0 +1,3 @@ +# Deprecated alias for xml.etree.ElementTree + +from xml.etree.ElementTree import * diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/parsers/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/parsers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..eb314a3b40573763835ad959acff985fad014537 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/parsers/__init__.py @@ -0,0 +1,8 @@ +"""Python interfaces to XML parsers. + +This package contains one module: + +expat -- Python wrapper for James Clark's Expat parser, with namespace + support. + +""" diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/parsers/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/parsers/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..870c0e01b9767e4e5560bcae7346ee64a32f6ba8 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/parsers/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/parsers/__pycache__/expat.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/parsers/__pycache__/expat.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a74a775c9d663d6650cc91f050809abad134d0a8 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/parsers/__pycache__/expat.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/parsers/expat.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/parsers/expat.py new file mode 100644 index 0000000000000000000000000000000000000000..bcbe9fb1f8f00e568f76fce02fdbe7528012b622 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/parsers/expat.py @@ -0,0 +1,8 @@ +"""Interface to the Expat non-validating XML parser.""" +import sys + +from pyexpat import * + +# provide pyexpat submodules as xml.parsers.expat submodules +sys.modules['xml.parsers.expat.model'] = model +sys.modules['xml.parsers.expat.errors'] = errors diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..17b75879ebaafad86c812bee53b4b24e01c18802 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__init__.py @@ -0,0 +1,107 @@ +"""Simple API for XML (SAX) implementation for Python. + +This module provides an implementation of the SAX 2 interface; +information about the Java version of the interface can be found at +http://www.megginson.com/SAX/. The Python version of the interface is +documented at <...>. + +This package contains the following modules: + +handler -- Base classes and constants which define the SAX 2 API for + the 'client-side' of SAX for Python. + +saxutils -- Implementation of the convenience classes commonly used to + work with SAX. + +xmlreader -- Base classes and constants which define the SAX 2 API for + the parsers used with SAX for Python. + +expatreader -- Driver that allows use of the Expat parser with SAX. +""" + +from .xmlreader import InputSource +from .handler import ContentHandler, ErrorHandler +from ._exceptions import SAXException, SAXNotRecognizedException, \ + SAXParseException, SAXNotSupportedException, \ + SAXReaderNotAvailable + + +def parse(source, handler, errorHandler=ErrorHandler()): + parser = make_parser() + parser.setContentHandler(handler) + parser.setErrorHandler(errorHandler) + parser.parse(source) + +def parseString(string, handler, errorHandler=ErrorHandler()): + import io + if errorHandler is None: + errorHandler = ErrorHandler() + parser = make_parser() + parser.setContentHandler(handler) + parser.setErrorHandler(errorHandler) + + inpsrc = InputSource() + if isinstance(string, str): + inpsrc.setCharacterStream(io.StringIO(string)) + else: + inpsrc.setByteStream(io.BytesIO(string)) + parser.parse(inpsrc) + +# this is the parser list used by the make_parser function if no +# alternatives are given as parameters to the function + +default_parser_list = ["xml.sax.expatreader"] + +# tell modulefinder that importing sax potentially imports expatreader +_false = 0 +if _false: + import xml.sax.expatreader + +import os, sys +if not sys.flags.ignore_environment and "PY_SAX_PARSER" in os.environ: + default_parser_list = os.environ["PY_SAX_PARSER"].split(",") +del os + +_key = "python.xml.sax.parser" +if sys.platform[:4] == "java" and sys.registry.containsKey(_key): + default_parser_list = sys.registry.getProperty(_key).split(",") + + +def make_parser(parser_list=()): + """Creates and returns a SAX parser. + + Creates the first parser it is able to instantiate of the ones + given in the iterable created by chaining parser_list and + default_parser_list. The iterables must contain the names of Python + modules containing both a SAX parser and a create_parser function.""" + + for parser_name in list(parser_list) + default_parser_list: + try: + return _create_parser(parser_name) + except ImportError: + import sys + if parser_name in sys.modules: + # The parser module was found, but importing it + # failed unexpectedly, pass this exception through + raise + except SAXReaderNotAvailable: + # The parser module detected that it won't work properly, + # so try the next one + pass + + raise SAXReaderNotAvailable("No parsers found", None) + +# --- Internal utility methods used by make_parser + +if sys.platform[ : 4] == "java": + def _create_parser(parser_name): + from org.python.core import imp + drv_module = imp.importName(parser_name, 0, globals()) + return drv_module.create_parser() + +else: + def _create_parser(parser_name): + drv_module = __import__(parser_name,{},{},['create_parser']) + return drv_module.create_parser() + +del sys diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fe98e37f1be46b34a552899e5736d9df4bd9d806 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/_exceptions.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/_exceptions.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..abe8021e7d58cc0dc8dc30b87b05c471b8904325 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/_exceptions.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/expatreader.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/expatreader.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5285fd33bb4ffe02f514fe46ae0287568be5dd13 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/expatreader.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/handler.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/handler.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eedc4a3bc730391545527e6164fb94b2141e2ccb Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/handler.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/saxutils.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/saxutils.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..35599269bfe7efdf11167ee2584e7a4aa68ff693 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/saxutils.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/xmlreader.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/xmlreader.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3c6f494980f115eee4c9a3cb03bc192428c0f759 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/__pycache__/xmlreader.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/_exceptions.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/_exceptions.py new file mode 100644 index 0000000000000000000000000000000000000000..a9b2ba35c6a22b2e393b6a898780f025a9e15e0f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/_exceptions.py @@ -0,0 +1,131 @@ +"""Different kinds of SAX Exceptions""" +import sys +if sys.platform[:4] == "java": + from java.lang import Exception +del sys + +# ===== SAXEXCEPTION ===== + +class SAXException(Exception): + """Encapsulate an XML error or warning. This class can contain + basic error or warning information from either the XML parser or + the application: you can subclass it to provide additional + functionality, or to add localization. Note that although you will + receive a SAXException as the argument to the handlers in the + ErrorHandler interface, you are not actually required to raise + the exception; instead, you can simply read the information in + it.""" + + def __init__(self, msg, exception=None): + """Creates an exception. The message is required, but the exception + is optional.""" + self._msg = msg + self._exception = exception + Exception.__init__(self, msg) + + def getMessage(self): + "Return a message for this exception." + return self._msg + + def getException(self): + "Return the embedded exception, or None if there was none." + return self._exception + + def __str__(self): + "Create a string representation of the exception." + return self._msg + + def __getitem__(self, ix): + """Avoids weird error messages if someone does exception[ix] by + mistake, since Exception has __getitem__ defined.""" + raise AttributeError("__getitem__") + + +# ===== SAXPARSEEXCEPTION ===== + +class SAXParseException(SAXException): + """Encapsulate an XML parse error or warning. + + This exception will include information for locating the error in + the original XML document. Note that although the application will + receive a SAXParseException as the argument to the handlers in the + ErrorHandler interface, the application is not actually required + to raise the exception; instead, it can simply read the + information in it and take a different action. + + Since this exception is a subclass of SAXException, it inherits + the ability to wrap another exception.""" + + def __init__(self, msg, exception, locator): + "Creates the exception. The exception parameter is allowed to be None." + SAXException.__init__(self, msg, exception) + self._locator = locator + + # We need to cache this stuff at construction time. + # If this exception is raised, the objects through which we must + # traverse to get this information may be deleted by the time + # it gets caught. + self._systemId = self._locator.getSystemId() + self._colnum = self._locator.getColumnNumber() + self._linenum = self._locator.getLineNumber() + + def getColumnNumber(self): + """The column number of the end of the text where the exception + occurred.""" + return self._colnum + + def getLineNumber(self): + "The line number of the end of the text where the exception occurred." + return self._linenum + + def getPublicId(self): + "Get the public identifier of the entity where the exception occurred." + return self._locator.getPublicId() + + def getSystemId(self): + "Get the system identifier of the entity where the exception occurred." + return self._systemId + + def __str__(self): + "Create a string representation of the exception." + sysid = self.getSystemId() + if sysid is None: + sysid = "" + linenum = self.getLineNumber() + if linenum is None: + linenum = "?" + colnum = self.getColumnNumber() + if colnum is None: + colnum = "?" + return "%s:%s:%s: %s" % (sysid, linenum, colnum, self._msg) + + +# ===== SAXNOTRECOGNIZEDEXCEPTION ===== + +class SAXNotRecognizedException(SAXException): + """Exception class for an unrecognized identifier. + + An XMLReader will raise this exception when it is confronted with an + unrecognized feature or property. SAX applications and extensions may + use this class for similar purposes.""" + + +# ===== SAXNOTSUPPORTEDEXCEPTION ===== + +class SAXNotSupportedException(SAXException): + """Exception class for an unsupported operation. + + An XMLReader will raise this exception when a service it cannot + perform is requested (specifically setting a state or value). SAX + applications and extensions may use this class for similar + purposes.""" + +# ===== SAXNOTSUPPORTEDEXCEPTION ===== + +class SAXReaderNotAvailable(SAXNotSupportedException): + """Exception class for a missing driver. + + An XMLReader module (driver) should raise this exception when it + is first imported, e.g. when a support module cannot be imported. + It also may be raised during parsing, e.g. if executing an external + program is not permitted.""" diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/expatreader.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/expatreader.py new file mode 100644 index 0000000000000000000000000000000000000000..2f7c87b126c9933a4071dc19ec797e2472f28e42 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/expatreader.py @@ -0,0 +1,460 @@ +""" +SAX driver for the pyexpat C module. This driver works with +pyexpat.__version__ == '2.22'. +""" + +version = "0.20" + +from xml.sax._exceptions import * +from xml.sax.handler import feature_validation, feature_namespaces +from xml.sax.handler import feature_namespace_prefixes +from xml.sax.handler import feature_external_ges, feature_external_pes +from xml.sax.handler import feature_string_interning +from xml.sax.handler import property_xml_string, property_interning_dict + +# xml.parsers.expat does not raise ImportError in Jython +import sys +if sys.platform[:4] == "java": + raise SAXReaderNotAvailable("expat not available in Java", None) +del sys + +try: + from xml.parsers import expat +except ImportError: + raise SAXReaderNotAvailable("expat not supported", None) +else: + if not hasattr(expat, "ParserCreate"): + raise SAXReaderNotAvailable("expat not supported", None) +from xml.sax import xmlreader, saxutils, handler + +AttributesImpl = xmlreader.AttributesImpl +AttributesNSImpl = xmlreader.AttributesNSImpl + +# If we're using a sufficiently recent version of Python, we can use +# weak references to avoid cycles between the parser and content +# handler, otherwise we'll just have to pretend. +try: + import _weakref +except ImportError: + def _mkproxy(o): + return o +else: + import weakref + _mkproxy = weakref.proxy + del weakref, _weakref + +class _ClosedParser: + pass + +# --- ExpatLocator + +class ExpatLocator(xmlreader.Locator): + """Locator for use with the ExpatParser class. + + This uses a weak reference to the parser object to avoid creating + a circular reference between the parser and the content handler. + """ + def __init__(self, parser): + self._ref = _mkproxy(parser) + + def getColumnNumber(self): + parser = self._ref + if parser._parser is None: + return None + return parser._parser.ErrorColumnNumber + + def getLineNumber(self): + parser = self._ref + if parser._parser is None: + return 1 + return parser._parser.ErrorLineNumber + + def getPublicId(self): + parser = self._ref + if parser is None: + return None + return parser._source.getPublicId() + + def getSystemId(self): + parser = self._ref + if parser is None: + return None + return parser._source.getSystemId() + + +# --- ExpatParser + +class ExpatParser(xmlreader.IncrementalParser, xmlreader.Locator): + """SAX driver for the pyexpat C module.""" + + def __init__(self, namespaceHandling=0, bufsize=2**16-20): + xmlreader.IncrementalParser.__init__(self, bufsize) + self._source = xmlreader.InputSource() + self._parser = None + self._namespaces = namespaceHandling + self._lex_handler_prop = None + self._parsing = False + self._entity_stack = [] + self._external_ges = 0 + self._interning = None + + # XMLReader methods + + def parse(self, source): + "Parse an XML document from a URL or an InputSource." + source = saxutils.prepare_input_source(source) + + self._source = source + try: + self.reset() + self._cont_handler.setDocumentLocator(ExpatLocator(self)) + xmlreader.IncrementalParser.parse(self, source) + except: + # bpo-30264: Close the source on error to not leak resources: + # xml.sax.parse() doesn't give access to the underlying parser + # to the caller + self._close_source() + raise + + def prepareParser(self, source): + if source.getSystemId() is not None: + self._parser.SetBase(source.getSystemId()) + + # Redefined setContentHandler to allow changing handlers during parsing + + def setContentHandler(self, handler): + xmlreader.IncrementalParser.setContentHandler(self, handler) + if self._parsing: + self._reset_cont_handler() + + def getFeature(self, name): + if name == feature_namespaces: + return self._namespaces + elif name == feature_string_interning: + return self._interning is not None + elif name in (feature_validation, feature_external_pes, + feature_namespace_prefixes): + return 0 + elif name == feature_external_ges: + return self._external_ges + raise SAXNotRecognizedException("Feature '%s' not recognized" % name) + + def setFeature(self, name, state): + if self._parsing: + raise SAXNotSupportedException("Cannot set features while parsing") + + if name == feature_namespaces: + self._namespaces = state + elif name == feature_external_ges: + self._external_ges = state + elif name == feature_string_interning: + if state: + if self._interning is None: + self._interning = {} + else: + self._interning = None + elif name == feature_validation: + if state: + raise SAXNotSupportedException( + "expat does not support validation") + elif name == feature_external_pes: + if state: + raise SAXNotSupportedException( + "expat does not read external parameter entities") + elif name == feature_namespace_prefixes: + if state: + raise SAXNotSupportedException( + "expat does not report namespace prefixes") + else: + raise SAXNotRecognizedException( + "Feature '%s' not recognized" % name) + + def getProperty(self, name): + if name == handler.property_lexical_handler: + return self._lex_handler_prop + elif name == property_interning_dict: + return self._interning + elif name == property_xml_string: + if self._parser: + if hasattr(self._parser, "GetInputContext"): + return self._parser.GetInputContext() + else: + raise SAXNotRecognizedException( + "This version of expat does not support getting" + " the XML string") + else: + raise SAXNotSupportedException( + "XML string cannot be returned when not parsing") + raise SAXNotRecognizedException("Property '%s' not recognized" % name) + + def setProperty(self, name, value): + if name == handler.property_lexical_handler: + self._lex_handler_prop = value + if self._parsing: + self._reset_lex_handler_prop() + elif name == property_interning_dict: + self._interning = value + elif name == property_xml_string: + raise SAXNotSupportedException("Property '%s' cannot be set" % + name) + else: + raise SAXNotRecognizedException("Property '%s' not recognized" % + name) + + # IncrementalParser methods + + def feed(self, data, isFinal=False): + if not self._parsing: + self.reset() + self._parsing = True + self._cont_handler.startDocument() + + try: + # The isFinal parameter is internal to the expat reader. + # If it is set to true, expat will check validity of the entire + # document. When feeding chunks, they are not normally final - + # except when invoked from close. + self._parser.Parse(data, isFinal) + except expat.error as e: + exc = SAXParseException(expat.ErrorString(e.code), e, self) + # FIXME: when to invoke error()? + self._err_handler.fatalError(exc) + + def flush(self): + if self._parser is None: + return + + was_enabled = self._parser.GetReparseDeferralEnabled() + try: + self._parser.SetReparseDeferralEnabled(False) + self._parser.Parse(b"", False) + except expat.error as e: + exc = SAXParseException(expat.ErrorString(e.code), e, self) + self._err_handler.fatalError(exc) + finally: + self._parser.SetReparseDeferralEnabled(was_enabled) + + def _close_source(self): + source = self._source + try: + file = source.getCharacterStream() + if file is not None: + file.close() + finally: + file = source.getByteStream() + if file is not None: + file.close() + + def close(self): + if (self._entity_stack or self._parser is None or + isinstance(self._parser, _ClosedParser)): + # If we are completing an external entity, do nothing here + return + try: + self.feed(b"", isFinal=True) + self._cont_handler.endDocument() + self._parsing = False + # break cycle created by expat handlers pointing to our methods + self._parser = None + finally: + self._parsing = False + if self._parser is not None: + # Keep ErrorColumnNumber and ErrorLineNumber after closing. + parser = _ClosedParser() + parser.ErrorColumnNumber = self._parser.ErrorColumnNumber + parser.ErrorLineNumber = self._parser.ErrorLineNumber + self._parser = parser + self._close_source() + + def _reset_cont_handler(self): + self._parser.ProcessingInstructionHandler = \ + self._cont_handler.processingInstruction + self._parser.CharacterDataHandler = self._cont_handler.characters + + def _reset_lex_handler_prop(self): + lex = self._lex_handler_prop + parser = self._parser + if lex is None: + parser.CommentHandler = None + parser.StartCdataSectionHandler = None + parser.EndCdataSectionHandler = None + parser.StartDoctypeDeclHandler = None + parser.EndDoctypeDeclHandler = None + else: + parser.CommentHandler = lex.comment + parser.StartCdataSectionHandler = lex.startCDATA + parser.EndCdataSectionHandler = lex.endCDATA + parser.StartDoctypeDeclHandler = self.start_doctype_decl + parser.EndDoctypeDeclHandler = lex.endDTD + + def reset(self): + if self._namespaces: + self._parser = expat.ParserCreate(self._source.getEncoding(), " ", + intern=self._interning) + self._parser.namespace_prefixes = 1 + self._parser.StartElementHandler = self.start_element_ns + self._parser.EndElementHandler = self.end_element_ns + else: + self._parser = expat.ParserCreate(self._source.getEncoding(), + intern = self._interning) + self._parser.StartElementHandler = self.start_element + self._parser.EndElementHandler = self.end_element + + self._reset_cont_handler() + self._parser.UnparsedEntityDeclHandler = self.unparsed_entity_decl + self._parser.NotationDeclHandler = self.notation_decl + self._parser.StartNamespaceDeclHandler = self.start_namespace_decl + self._parser.EndNamespaceDeclHandler = self.end_namespace_decl + + self._decl_handler_prop = None + if self._lex_handler_prop: + self._reset_lex_handler_prop() +# self._parser.DefaultHandler = +# self._parser.DefaultHandlerExpand = +# self._parser.NotStandaloneHandler = + self._parser.ExternalEntityRefHandler = self.external_entity_ref + try: + self._parser.SkippedEntityHandler = self.skipped_entity_handler + except AttributeError: + # This pyexpat does not support SkippedEntity + pass + self._parser.SetParamEntityParsing( + expat.XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE) + + self._parsing = False + self._entity_stack = [] + + # Locator methods + + def getColumnNumber(self): + if self._parser is None: + return None + return self._parser.ErrorColumnNumber + + def getLineNumber(self): + if self._parser is None: + return 1 + return self._parser.ErrorLineNumber + + def getPublicId(self): + return self._source.getPublicId() + + def getSystemId(self): + return self._source.getSystemId() + + # event handlers + def start_element(self, name, attrs): + self._cont_handler.startElement(name, AttributesImpl(attrs)) + + def end_element(self, name): + self._cont_handler.endElement(name) + + def start_element_ns(self, name, attrs): + pair = name.split() + if len(pair) == 1: + # no namespace + pair = (None, name) + elif len(pair) == 3: + pair = pair[0], pair[1] + else: + # default namespace + pair = tuple(pair) + + newattrs = {} + qnames = {} + for (aname, value) in attrs.items(): + parts = aname.split() + length = len(parts) + if length == 1: + # no namespace + qname = aname + apair = (None, aname) + elif length == 3: + qname = "%s:%s" % (parts[2], parts[1]) + apair = parts[0], parts[1] + else: + # default namespace + qname = parts[1] + apair = tuple(parts) + + newattrs[apair] = value + qnames[apair] = qname + + self._cont_handler.startElementNS(pair, None, + AttributesNSImpl(newattrs, qnames)) + + def end_element_ns(self, name): + pair = name.split() + if len(pair) == 1: + pair = (None, name) + elif len(pair) == 3: + pair = pair[0], pair[1] + else: + pair = tuple(pair) + + self._cont_handler.endElementNS(pair, None) + + # this is not used (call directly to ContentHandler) + def processing_instruction(self, target, data): + self._cont_handler.processingInstruction(target, data) + + # this is not used (call directly to ContentHandler) + def character_data(self, data): + self._cont_handler.characters(data) + + def start_namespace_decl(self, prefix, uri): + self._cont_handler.startPrefixMapping(prefix, uri) + + def end_namespace_decl(self, prefix): + self._cont_handler.endPrefixMapping(prefix) + + def start_doctype_decl(self, name, sysid, pubid, has_internal_subset): + self._lex_handler_prop.startDTD(name, pubid, sysid) + + def unparsed_entity_decl(self, name, base, sysid, pubid, notation_name): + self._dtd_handler.unparsedEntityDecl(name, pubid, sysid, notation_name) + + def notation_decl(self, name, base, sysid, pubid): + self._dtd_handler.notationDecl(name, pubid, sysid) + + def external_entity_ref(self, context, base, sysid, pubid): + if not self._external_ges: + return 1 + + source = self._ent_handler.resolveEntity(pubid, sysid) + source = saxutils.prepare_input_source(source, + self._source.getSystemId() or + "") + + self._entity_stack.append((self._parser, self._source)) + self._parser = self._parser.ExternalEntityParserCreate(context) + self._source = source + + try: + xmlreader.IncrementalParser.parse(self, source) + except: + return 0 # FIXME: save error info here? + + (self._parser, self._source) = self._entity_stack[-1] + del self._entity_stack[-1] + return 1 + + def skipped_entity_handler(self, name, is_pe): + if is_pe: + # The SAX spec requires to report skipped PEs with a '%' + name = '%'+name + self._cont_handler.skippedEntity(name) + +# --- + +def create_parser(*args, **kwargs): + return ExpatParser(*args, **kwargs) + +# --- + +if __name__ == "__main__": + import xml.sax.saxutils + p = create_parser() + p.setContentHandler(xml.sax.saxutils.XMLGenerator()) + p.setErrorHandler(xml.sax.ErrorHandler()) + p.parse("http://www.ibiblio.org/xml/examples/shakespeare/hamlet.xml") diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/handler.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/handler.py new file mode 100644 index 0000000000000000000000000000000000000000..e8d417e51942329cbe111e458de3fa0788601ccc --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/handler.py @@ -0,0 +1,387 @@ +""" +This module contains the core classes of version 2.0 of SAX for Python. +This file provides only default classes with absolutely minimum +functionality, from which drivers and applications can be subclassed. + +Many of these classes are empty and are included only as documentation +of the interfaces. + +$Id$ +""" + +version = '2.0beta' + +#============================================================================ +# +# HANDLER INTERFACES +# +#============================================================================ + +# ===== ERRORHANDLER ===== + +class ErrorHandler: + """Basic interface for SAX error handlers. + + If you create an object that implements this interface, then + register the object with your XMLReader, the parser will call the + methods in your object to report all warnings and errors. There + are three levels of errors available: warnings, (possibly) + recoverable errors, and unrecoverable errors. All methods take a + SAXParseException as the only parameter.""" + + def error(self, exception): + "Handle a recoverable error." + raise exception + + def fatalError(self, exception): + "Handle a non-recoverable error." + raise exception + + def warning(self, exception): + "Handle a warning." + print(exception) + + +# ===== CONTENTHANDLER ===== + +class ContentHandler: + """Interface for receiving logical document content events. + + This is the main callback interface in SAX, and the one most + important to applications. The order of events in this interface + mirrors the order of the information in the document.""" + + def __init__(self): + self._locator = None + + def setDocumentLocator(self, locator): + """Called by the parser to give the application a locator for + locating the origin of document events. + + SAX parsers are strongly encouraged (though not absolutely + required) to supply a locator: if it does so, it must supply + the locator to the application by invoking this method before + invoking any of the other methods in the DocumentHandler + interface. + + The locator allows the application to determine the end + position of any document-related event, even if the parser is + not reporting an error. Typically, the application will use + this information for reporting its own errors (such as + character content that does not match an application's + business rules). The information returned by the locator is + probably not sufficient for use with a search engine. + + Note that the locator will return correct information only + during the invocation of the events in this interface. The + application should not attempt to use it at any other time.""" + self._locator = locator + + def startDocument(self): + """Receive notification of the beginning of a document. + + The SAX parser will invoke this method only once, before any + other methods in this interface or in DTDHandler (except for + setDocumentLocator).""" + + def endDocument(self): + """Receive notification of the end of a document. + + The SAX parser will invoke this method only once, and it will + be the last method invoked during the parse. The parser shall + not invoke this method until it has either abandoned parsing + (because of an unrecoverable error) or reached the end of + input.""" + + def startPrefixMapping(self, prefix, uri): + """Begin the scope of a prefix-URI Namespace mapping. + + The information from this event is not necessary for normal + Namespace processing: the SAX XML reader will automatically + replace prefixes for element and attribute names when the + http://xml.org/sax/features/namespaces feature is true (the + default). + + There are cases, however, when applications need to use + prefixes in character data or in attribute values, where they + cannot safely be expanded automatically; the + start/endPrefixMapping event supplies the information to the + application to expand prefixes in those contexts itself, if + necessary. + + Note that start/endPrefixMapping events are not guaranteed to + be properly nested relative to each-other: all + startPrefixMapping events will occur before the corresponding + startElement event, and all endPrefixMapping events will occur + after the corresponding endElement event, but their order is + not guaranteed.""" + + def endPrefixMapping(self, prefix): + """End the scope of a prefix-URI mapping. + + See startPrefixMapping for details. This event will always + occur after the corresponding endElement event, but the order + of endPrefixMapping events is not otherwise guaranteed.""" + + def startElement(self, name, attrs): + """Signals the start of an element in non-namespace mode. + + The name parameter contains the raw XML 1.0 name of the + element type as a string and the attrs parameter holds an + instance of the Attributes class containing the attributes of + the element.""" + + def endElement(self, name): + """Signals the end of an element in non-namespace mode. + + The name parameter contains the name of the element type, just + as with the startElement event.""" + + def startElementNS(self, name, qname, attrs): + """Signals the start of an element in namespace mode. + + The name parameter contains the name of the element type as a + (uri, localname) tuple, the qname parameter the raw XML 1.0 + name used in the source document, and the attrs parameter + holds an instance of the Attributes class containing the + attributes of the element. + + The uri part of the name tuple is None for elements which have + no namespace.""" + + def endElementNS(self, name, qname): + """Signals the end of an element in namespace mode. + + The name parameter contains the name of the element type, just + as with the startElementNS event.""" + + def characters(self, content): + """Receive notification of character data. + + The Parser will call this method to report each chunk of + character data. SAX parsers may return all contiguous + character data in a single chunk, or they may split it into + several chunks; however, all of the characters in any single + event must come from the same external entity so that the + Locator provides useful information.""" + + def ignorableWhitespace(self, whitespace): + """Receive notification of ignorable whitespace in element content. + + Validating Parsers must use this method to report each chunk + of ignorable whitespace (see the W3C XML 1.0 recommendation, + section 2.10): non-validating parsers may also use this method + if they are capable of parsing and using content models. + + SAX parsers may return all contiguous whitespace in a single + chunk, or they may split it into several chunks; however, all + of the characters in any single event must come from the same + external entity, so that the Locator provides useful + information.""" + + def processingInstruction(self, target, data): + """Receive notification of a processing instruction. + + The Parser will invoke this method once for each processing + instruction found: note that processing instructions may occur + before or after the main document element. + + A SAX parser should never report an XML declaration (XML 1.0, + section 2.8) or a text declaration (XML 1.0, section 4.3.1) + using this method.""" + + def skippedEntity(self, name): + """Receive notification of a skipped entity. + + The Parser will invoke this method once for each entity + skipped. Non-validating processors may skip entities if they + have not seen the declarations (because, for example, the + entity was declared in an external DTD subset). All processors + may skip external entities, depending on the values of the + http://xml.org/sax/features/external-general-entities and the + http://xml.org/sax/features/external-parameter-entities + properties.""" + + +# ===== DTDHandler ===== + +class DTDHandler: + """Handle DTD events. + + This interface specifies only those DTD events required for basic + parsing (unparsed entities and attributes).""" + + def notationDecl(self, name, publicId, systemId): + "Handle a notation declaration event." + + def unparsedEntityDecl(self, name, publicId, systemId, ndata): + "Handle an unparsed entity declaration event." + + +# ===== ENTITYRESOLVER ===== + +class EntityResolver: + """Basic interface for resolving entities. If you create an object + implementing this interface, then register the object with your + Parser, the parser will call the method in your object to + resolve all external entities. Note that DefaultHandler implements + this interface with the default behaviour.""" + + def resolveEntity(self, publicId, systemId): + """Resolve the system identifier of an entity and return either + the system identifier to read from as a string, or an InputSource + to read from.""" + return systemId + + +#============================================================================ +# +# CORE FEATURES +# +#============================================================================ + +feature_namespaces = "http://xml.org/sax/features/namespaces" +# true: Perform Namespace processing (default). +# false: Optionally do not perform Namespace processing +# (implies namespace-prefixes). +# access: (parsing) read-only; (not parsing) read/write + +feature_namespace_prefixes = "http://xml.org/sax/features/namespace-prefixes" +# true: Report the original prefixed names and attributes used for Namespace +# declarations. +# false: Do not report attributes used for Namespace declarations, and +# optionally do not report original prefixed names (default). +# access: (parsing) read-only; (not parsing) read/write + +feature_string_interning = "http://xml.org/sax/features/string-interning" +# true: All element names, prefixes, attribute names, Namespace URIs, and +# local names are interned using the built-in intern function. +# false: Names are not necessarily interned, although they may be (default). +# access: (parsing) read-only; (not parsing) read/write + +feature_validation = "http://xml.org/sax/features/validation" +# true: Report all validation errors (implies external-general-entities and +# external-parameter-entities). +# false: Do not report validation errors. +# access: (parsing) read-only; (not parsing) read/write + +feature_external_ges = "http://xml.org/sax/features/external-general-entities" +# true: Include all external general (text) entities. +# false: Do not include external general entities. +# access: (parsing) read-only; (not parsing) read/write + +feature_external_pes = "http://xml.org/sax/features/external-parameter-entities" +# true: Include all external parameter entities, including the external +# DTD subset. +# false: Do not include any external parameter entities, even the external +# DTD subset. +# access: (parsing) read-only; (not parsing) read/write + +all_features = [feature_namespaces, + feature_namespace_prefixes, + feature_string_interning, + feature_validation, + feature_external_ges, + feature_external_pes] + + +#============================================================================ +# +# CORE PROPERTIES +# +#============================================================================ + +property_lexical_handler = "http://xml.org/sax/properties/lexical-handler" +# data type: xml.sax.sax2lib.LexicalHandler +# description: An optional extension handler for lexical events like comments. +# access: read/write + +property_declaration_handler = "http://xml.org/sax/properties/declaration-handler" +# data type: xml.sax.sax2lib.DeclHandler +# description: An optional extension handler for DTD-related events other +# than notations and unparsed entities. +# access: read/write + +property_dom_node = "http://xml.org/sax/properties/dom-node" +# data type: org.w3c.dom.Node +# description: When parsing, the current DOM node being visited if this is +# a DOM iterator; when not parsing, the root DOM node for +# iteration. +# access: (parsing) read-only; (not parsing) read/write + +property_xml_string = "http://xml.org/sax/properties/xml-string" +# data type: String +# description: The literal string of characters that was the source for +# the current event. +# access: read-only + +property_encoding = "http://www.python.org/sax/properties/encoding" +# data type: String +# description: The name of the encoding to assume for input data. +# access: write: set the encoding, e.g. established by a higher-level +# protocol. May change during parsing (e.g. after +# processing a META tag) +# read: return the current encoding (possibly established through +# auto-detection. +# initial value: UTF-8 +# + +property_interning_dict = "http://www.python.org/sax/properties/interning-dict" +# data type: Dictionary +# description: The dictionary used to intern common strings in the document +# access: write: Request that the parser uses a specific dictionary, to +# allow interning across different documents +# read: return the current interning dictionary, or None +# + +all_properties = [property_lexical_handler, + property_dom_node, + property_declaration_handler, + property_xml_string, + property_encoding, + property_interning_dict] + + +class LexicalHandler: + """Optional SAX2 handler for lexical events. + + This handler is used to obtain lexical information about an XML + document, that is, information about how the document was encoded + (as opposed to what it contains, which is reported to the + ContentHandler), such as comments and CDATA marked section + boundaries. + + To set the LexicalHandler of an XMLReader, use the setProperty + method with the property identifier + 'http://xml.org/sax/properties/lexical-handler'.""" + + def comment(self, content): + """Reports a comment anywhere in the document (including the + DTD and outside the document element). + + content is a string that holds the contents of the comment.""" + + def startDTD(self, name, public_id, system_id): + """Report the start of the DTD declarations, if the document + has an associated DTD. + + A startEntity event will be reported before declaration events + from the external DTD subset are reported, and this can be + used to infer from which subset DTD declarations derive. + + name is the name of the document element type, public_id the + public identifier of the DTD (or None if none were supplied) + and system_id the system identfier of the external subset (or + None if none were supplied).""" + + def endDTD(self): + """Signals the end of DTD declarations.""" + + def startCDATA(self): + """Reports the beginning of a CDATA marked section. + + The contents of the CDATA marked section will be reported + through the characters event.""" + + def endCDATA(self): + """Reports the end of a CDATA marked section.""" diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/saxutils.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/saxutils.py new file mode 100644 index 0000000000000000000000000000000000000000..c1612ea1cebc5d064280e7d2d617d0fc2cf1f0f0 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/saxutils.py @@ -0,0 +1,369 @@ +"""\ +A library of useful helper classes to the SAX classes, for the +convenience of application and driver writers. +""" + +import os, urllib.parse, urllib.request +import io +import codecs +from . import handler +from . import xmlreader + +def __dict_replace(s, d): + """Replace substrings of a string using a dictionary.""" + for key, value in d.items(): + s = s.replace(key, value) + return s + +def escape(data, entities={}): + """Escape &, <, and > in a string of data. + + You can escape other strings of data by passing a dictionary as + the optional entities parameter. The keys and values must all be + strings; each key will be replaced with its corresponding value. + """ + + # must do ampersand first + data = data.replace("&", "&") + data = data.replace(">", ">") + data = data.replace("<", "<") + if entities: + data = __dict_replace(data, entities) + return data + +def unescape(data, entities={}): + """Unescape &, <, and > in a string of data. + + You can unescape other strings of data by passing a dictionary as + the optional entities parameter. The keys and values must all be + strings; each key will be replaced with its corresponding value. + """ + data = data.replace("<", "<") + data = data.replace(">", ">") + if entities: + data = __dict_replace(data, entities) + # must do ampersand last + return data.replace("&", "&") + +def quoteattr(data, entities={}): + """Escape and quote an attribute value. + + Escape &, <, and > in a string of data, then quote it for use as + an attribute value. The \" character will be escaped as well, if + necessary. + + You can escape other strings of data by passing a dictionary as + the optional entities parameter. The keys and values must all be + strings; each key will be replaced with its corresponding value. + """ + entities = {**entities, '\n': ' ', '\r': ' ', '\t':' '} + data = escape(data, entities) + if '"' in data: + if "'" in data: + data = '"%s"' % data.replace('"', """) + else: + data = "'%s'" % data + else: + data = '"%s"' % data + return data + + +def _gettextwriter(out, encoding): + if out is None: + import sys + return sys.stdout + + if isinstance(out, io.TextIOBase): + # use a text writer as is + return out + + if isinstance(out, (codecs.StreamWriter, codecs.StreamReaderWriter)): + # use a codecs stream writer as is + return out + + # wrap a binary writer with TextIOWrapper + if isinstance(out, io.RawIOBase): + # Keep the original file open when the TextIOWrapper is + # destroyed + class _wrapper: + __class__ = out.__class__ + def __getattr__(self, name): + return getattr(out, name) + buffer = _wrapper() + buffer.close = lambda: None + else: + # This is to handle passed objects that aren't in the + # IOBase hierarchy, but just have a write method + buffer = io.BufferedIOBase() + buffer.writable = lambda: True + buffer.write = out.write + try: + # TextIOWrapper uses this methods to determine + # if BOM (for UTF-16, etc) should be added + buffer.seekable = out.seekable + buffer.tell = out.tell + except AttributeError: + pass + return io.TextIOWrapper(buffer, encoding=encoding, + errors='xmlcharrefreplace', + newline='\n', + write_through=True) + +class XMLGenerator(handler.ContentHandler): + + def __init__(self, out=None, encoding="iso-8859-1", short_empty_elements=False): + handler.ContentHandler.__init__(self) + out = _gettextwriter(out, encoding) + self._write = out.write + self._flush = out.flush + self._ns_contexts = [{}] # contains uri -> prefix dicts + self._current_context = self._ns_contexts[-1] + self._undeclared_ns_maps = [] + self._encoding = encoding + self._short_empty_elements = short_empty_elements + self._pending_start_element = False + + def _qname(self, name): + """Builds a qualified name from a (ns_url, localname) pair""" + if name[0]: + # Per http://www.w3.org/XML/1998/namespace, The 'xml' prefix is + # bound by definition to http://www.w3.org/XML/1998/namespace. It + # does not need to be declared and will not usually be found in + # self._current_context. + if 'http://www.w3.org/XML/1998/namespace' == name[0]: + return 'xml:' + name[1] + # The name is in a non-empty namespace + prefix = self._current_context[name[0]] + if prefix: + # If it is not the default namespace, prepend the prefix + return prefix + ":" + name[1] + # Return the unqualified name + return name[1] + + def _finish_pending_start_element(self,endElement=False): + if self._pending_start_element: + self._write('>') + self._pending_start_element = False + + # ContentHandler methods + + def startDocument(self): + self._write('\n' % + self._encoding) + + def endDocument(self): + self._flush() + + def startPrefixMapping(self, prefix, uri): + self._ns_contexts.append(self._current_context.copy()) + self._current_context[uri] = prefix + self._undeclared_ns_maps.append((prefix, uri)) + + def endPrefixMapping(self, prefix): + self._current_context = self._ns_contexts[-1] + del self._ns_contexts[-1] + + def startElement(self, name, attrs): + self._finish_pending_start_element() + self._write('<' + name) + for (name, value) in attrs.items(): + self._write(' %s=%s' % (name, quoteattr(value))) + if self._short_empty_elements: + self._pending_start_element = True + else: + self._write(">") + + def endElement(self, name): + if self._pending_start_element: + self._write('/>') + self._pending_start_element = False + else: + self._write('' % name) + + def startElementNS(self, name, qname, attrs): + self._finish_pending_start_element() + self._write('<' + self._qname(name)) + + for prefix, uri in self._undeclared_ns_maps: + if prefix: + self._write(' xmlns:%s="%s"' % (prefix, uri)) + else: + self._write(' xmlns="%s"' % uri) + self._undeclared_ns_maps = [] + + for (name, value) in attrs.items(): + self._write(' %s=%s' % (self._qname(name), quoteattr(value))) + if self._short_empty_elements: + self._pending_start_element = True + else: + self._write(">") + + def endElementNS(self, name, qname): + if self._pending_start_element: + self._write('/>') + self._pending_start_element = False + else: + self._write('' % self._qname(name)) + + def characters(self, content): + if content: + self._finish_pending_start_element() + if not isinstance(content, str): + content = str(content, self._encoding) + self._write(escape(content)) + + def ignorableWhitespace(self, content): + if content: + self._finish_pending_start_element() + if not isinstance(content, str): + content = str(content, self._encoding) + self._write(content) + + def processingInstruction(self, target, data): + self._finish_pending_start_element() + self._write('' % (target, data)) + + +class XMLFilterBase(xmlreader.XMLReader): + """This class is designed to sit between an XMLReader and the + client application's event handlers. By default, it does nothing + but pass requests up to the reader and events on to the handlers + unmodified, but subclasses can override specific methods to modify + the event stream or the configuration requests as they pass + through.""" + + def __init__(self, parent = None): + xmlreader.XMLReader.__init__(self) + self._parent = parent + + # ErrorHandler methods + + def error(self, exception): + self._err_handler.error(exception) + + def fatalError(self, exception): + self._err_handler.fatalError(exception) + + def warning(self, exception): + self._err_handler.warning(exception) + + # ContentHandler methods + + def setDocumentLocator(self, locator): + self._cont_handler.setDocumentLocator(locator) + + def startDocument(self): + self._cont_handler.startDocument() + + def endDocument(self): + self._cont_handler.endDocument() + + def startPrefixMapping(self, prefix, uri): + self._cont_handler.startPrefixMapping(prefix, uri) + + def endPrefixMapping(self, prefix): + self._cont_handler.endPrefixMapping(prefix) + + def startElement(self, name, attrs): + self._cont_handler.startElement(name, attrs) + + def endElement(self, name): + self._cont_handler.endElement(name) + + def startElementNS(self, name, qname, attrs): + self._cont_handler.startElementNS(name, qname, attrs) + + def endElementNS(self, name, qname): + self._cont_handler.endElementNS(name, qname) + + def characters(self, content): + self._cont_handler.characters(content) + + def ignorableWhitespace(self, chars): + self._cont_handler.ignorableWhitespace(chars) + + def processingInstruction(self, target, data): + self._cont_handler.processingInstruction(target, data) + + def skippedEntity(self, name): + self._cont_handler.skippedEntity(name) + + # DTDHandler methods + + def notationDecl(self, name, publicId, systemId): + self._dtd_handler.notationDecl(name, publicId, systemId) + + def unparsedEntityDecl(self, name, publicId, systemId, ndata): + self._dtd_handler.unparsedEntityDecl(name, publicId, systemId, ndata) + + # EntityResolver methods + + def resolveEntity(self, publicId, systemId): + return self._ent_handler.resolveEntity(publicId, systemId) + + # XMLReader methods + + def parse(self, source): + self._parent.setContentHandler(self) + self._parent.setErrorHandler(self) + self._parent.setEntityResolver(self) + self._parent.setDTDHandler(self) + self._parent.parse(source) + + def setLocale(self, locale): + self._parent.setLocale(locale) + + def getFeature(self, name): + return self._parent.getFeature(name) + + def setFeature(self, name, state): + self._parent.setFeature(name, state) + + def getProperty(self, name): + return self._parent.getProperty(name) + + def setProperty(self, name, value): + self._parent.setProperty(name, value) + + # XMLFilter methods + + def getParent(self): + return self._parent + + def setParent(self, parent): + self._parent = parent + +# --- Utility functions + +def prepare_input_source(source, base=""): + """This function takes an InputSource and an optional base URL and + returns a fully resolved InputSource object ready for reading.""" + + if isinstance(source, os.PathLike): + source = os.fspath(source) + if isinstance(source, str): + source = xmlreader.InputSource(source) + elif hasattr(source, "read"): + f = source + source = xmlreader.InputSource() + if isinstance(f.read(0), str): + source.setCharacterStream(f) + else: + source.setByteStream(f) + if hasattr(f, "name") and isinstance(f.name, str): + source.setSystemId(f.name) + + if source.getCharacterStream() is None and source.getByteStream() is None: + sysid = source.getSystemId() + basehead = os.path.dirname(os.path.normpath(base)) + sysidfilename = os.path.join(basehead, sysid) + if os.path.isfile(sysidfilename): + source.setSystemId(sysidfilename) + f = open(sysidfilename, "rb") + else: + source.setSystemId(urllib.parse.urljoin(base, sysid)) + f = urllib.request.urlopen(source.getSystemId()) + + source.setByteStream(f) + + return source diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/xmlreader.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/xmlreader.py new file mode 100644 index 0000000000000000000000000000000000000000..716f22840414e604ab38661f91eb07f094309833 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xml/sax/xmlreader.py @@ -0,0 +1,380 @@ +"""An XML Reader is the SAX 2 name for an XML parser. XML Parsers +should be based on this code. """ + +from . import handler + +from ._exceptions import SAXNotSupportedException, SAXNotRecognizedException + + +# ===== XMLREADER ===== + +class XMLReader: + """Interface for reading an XML document using callbacks. + + XMLReader is the interface that an XML parser's SAX2 driver must + implement. This interface allows an application to set and query + features and properties in the parser, to register event handlers + for document processing, and to initiate a document parse. + + All SAX interfaces are assumed to be synchronous: the parse + methods must not return until parsing is complete, and readers + must wait for an event-handler callback to return before reporting + the next event.""" + + def __init__(self): + self._cont_handler = handler.ContentHandler() + self._dtd_handler = handler.DTDHandler() + self._ent_handler = handler.EntityResolver() + self._err_handler = handler.ErrorHandler() + + def parse(self, source): + "Parse an XML document from a system identifier or an InputSource." + raise NotImplementedError("This method must be implemented!") + + def getContentHandler(self): + "Returns the current ContentHandler." + return self._cont_handler + + def setContentHandler(self, handler): + "Registers a new object to receive document content events." + self._cont_handler = handler + + def getDTDHandler(self): + "Returns the current DTD handler." + return self._dtd_handler + + def setDTDHandler(self, handler): + "Register an object to receive basic DTD-related events." + self._dtd_handler = handler + + def getEntityResolver(self): + "Returns the current EntityResolver." + return self._ent_handler + + def setEntityResolver(self, resolver): + "Register an object to resolve external entities." + self._ent_handler = resolver + + def getErrorHandler(self): + "Returns the current ErrorHandler." + return self._err_handler + + def setErrorHandler(self, handler): + "Register an object to receive error-message events." + self._err_handler = handler + + def setLocale(self, locale): + """Allow an application to set the locale for errors and warnings. + + SAX parsers are not required to provide localization for errors + and warnings; if they cannot support the requested locale, + however, they must raise a SAX exception. Applications may + request a locale change in the middle of a parse.""" + raise SAXNotSupportedException("Locale support not implemented") + + def getFeature(self, name): + "Looks up and returns the state of a SAX2 feature." + raise SAXNotRecognizedException("Feature '%s' not recognized" % name) + + def setFeature(self, name, state): + "Sets the state of a SAX2 feature." + raise SAXNotRecognizedException("Feature '%s' not recognized" % name) + + def getProperty(self, name): + "Looks up and returns the value of a SAX2 property." + raise SAXNotRecognizedException("Property '%s' not recognized" % name) + + def setProperty(self, name, value): + "Sets the value of a SAX2 property." + raise SAXNotRecognizedException("Property '%s' not recognized" % name) + +class IncrementalParser(XMLReader): + """This interface adds three extra methods to the XMLReader + interface that allow XML parsers to support incremental + parsing. Support for this interface is optional, since not all + underlying XML parsers support this functionality. + + When the parser is instantiated it is ready to begin accepting + data from the feed method immediately. After parsing has been + finished with a call to close the reset method must be called to + make the parser ready to accept new data, either from feed or + using the parse method. + + Note that these methods must _not_ be called during parsing, that + is, after parse has been called and before it returns. + + By default, the class also implements the parse method of the XMLReader + interface using the feed, close and reset methods of the + IncrementalParser interface as a convenience to SAX 2.0 driver + writers.""" + + def __init__(self, bufsize=2**16): + self._bufsize = bufsize + XMLReader.__init__(self) + + def parse(self, source): + from . import saxutils + source = saxutils.prepare_input_source(source) + + self.prepareParser(source) + file = source.getCharacterStream() + if file is None: + file = source.getByteStream() + buffer = file.read(self._bufsize) + while buffer: + self.feed(buffer) + buffer = file.read(self._bufsize) + self.close() + + def feed(self, data): + """This method gives the raw XML data in the data parameter to + the parser and makes it parse the data, emitting the + corresponding events. It is allowed for XML constructs to be + split across several calls to feed. + + feed may raise SAXException.""" + raise NotImplementedError("This method must be implemented!") + + def prepareParser(self, source): + """This method is called by the parse implementation to allow + the SAX 2.0 driver to prepare itself for parsing.""" + raise NotImplementedError("prepareParser must be overridden!") + + def close(self): + """This method is called when the entire XML document has been + passed to the parser through the feed method, to notify the + parser that there are no more data. This allows the parser to + do the final checks on the document and empty the internal + data buffer. + + The parser will not be ready to parse another document until + the reset method has been called. + + close may raise SAXException.""" + raise NotImplementedError("This method must be implemented!") + + def reset(self): + """This method is called after close has been called to reset + the parser so that it is ready to parse new documents. The + results of calling parse or feed after close without calling + reset are undefined.""" + raise NotImplementedError("This method must be implemented!") + +# ===== LOCATOR ===== + +class Locator: + """Interface for associating a SAX event with a document + location. A locator object will return valid results only during + calls to DocumentHandler methods; at any other time, the + results are unpredictable.""" + + def getColumnNumber(self): + "Return the column number where the current event ends." + return -1 + + def getLineNumber(self): + "Return the line number where the current event ends." + return -1 + + def getPublicId(self): + "Return the public identifier for the current event." + return None + + def getSystemId(self): + "Return the system identifier for the current event." + return None + +# ===== INPUTSOURCE ===== + +class InputSource: + """Encapsulation of the information needed by the XMLReader to + read entities. + + This class may include information about the public identifier, + system identifier, byte stream (possibly with character encoding + information) and/or the character stream of an entity. + + Applications will create objects of this class for use in the + XMLReader.parse method and for returning from + EntityResolver.resolveEntity. + + An InputSource belongs to the application, the XMLReader is not + allowed to modify InputSource objects passed to it from the + application, although it may make copies and modify those.""" + + def __init__(self, system_id = None): + self.__system_id = system_id + self.__public_id = None + self.__encoding = None + self.__bytefile = None + self.__charfile = None + + def setPublicId(self, public_id): + "Sets the public identifier of this InputSource." + self.__public_id = public_id + + def getPublicId(self): + "Returns the public identifier of this InputSource." + return self.__public_id + + def setSystemId(self, system_id): + "Sets the system identifier of this InputSource." + self.__system_id = system_id + + def getSystemId(self): + "Returns the system identifier of this InputSource." + return self.__system_id + + def setEncoding(self, encoding): + """Sets the character encoding of this InputSource. + + The encoding must be a string acceptable for an XML encoding + declaration (see section 4.3.3 of the XML recommendation). + + The encoding attribute of the InputSource is ignored if the + InputSource also contains a character stream.""" + self.__encoding = encoding + + def getEncoding(self): + "Get the character encoding of this InputSource." + return self.__encoding + + def setByteStream(self, bytefile): + """Set the byte stream (a Python file-like object which does + not perform byte-to-character conversion) for this input + source. + + The SAX parser will ignore this if there is also a character + stream specified, but it will use a byte stream in preference + to opening a URI connection itself. + + If the application knows the character encoding of the byte + stream, it should set it with the setEncoding method.""" + self.__bytefile = bytefile + + def getByteStream(self): + """Get the byte stream for this input source. + + The getEncoding method will return the character encoding for + this byte stream, or None if unknown.""" + return self.__bytefile + + def setCharacterStream(self, charfile): + """Set the character stream for this input source. (The stream + must be a Python 2.0 Unicode-wrapped file-like that performs + conversion to Unicode strings.) + + If there is a character stream specified, the SAX parser will + ignore any byte stream and will not attempt to open a URI + connection to the system identifier.""" + self.__charfile = charfile + + def getCharacterStream(self): + "Get the character stream for this input source." + return self.__charfile + +# ===== ATTRIBUTESIMPL ===== + +class AttributesImpl: + + def __init__(self, attrs): + """Non-NS-aware implementation. + + attrs should be of the form {name : value}.""" + self._attrs = attrs + + def getLength(self): + return len(self._attrs) + + def getType(self, name): + return "CDATA" + + def getValue(self, name): + return self._attrs[name] + + def getValueByQName(self, name): + return self._attrs[name] + + def getNameByQName(self, name): + if name not in self._attrs: + raise KeyError(name) + return name + + def getQNameByName(self, name): + if name not in self._attrs: + raise KeyError(name) + return name + + def getNames(self): + return list(self._attrs.keys()) + + def getQNames(self): + return list(self._attrs.keys()) + + def __len__(self): + return len(self._attrs) + + def __getitem__(self, name): + return self._attrs[name] + + def keys(self): + return list(self._attrs.keys()) + + def __contains__(self, name): + return name in self._attrs + + def get(self, name, alternative=None): + return self._attrs.get(name, alternative) + + def copy(self): + return self.__class__(self._attrs) + + def items(self): + return list(self._attrs.items()) + + def values(self): + return list(self._attrs.values()) + +# ===== ATTRIBUTESNSIMPL ===== + +class AttributesNSImpl(AttributesImpl): + + def __init__(self, attrs, qnames): + """NS-aware implementation. + + attrs should be of the form {(ns_uri, lname): value, ...}. + qnames of the form {(ns_uri, lname): qname, ...}.""" + self._attrs = attrs + self._qnames = qnames + + def getValueByQName(self, name): + for (nsname, qname) in self._qnames.items(): + if qname == name: + return self._attrs[nsname] + + raise KeyError(name) + + def getNameByQName(self, name): + for (nsname, qname) in self._qnames.items(): + if qname == name: + return nsname + + raise KeyError(name) + + def getQNameByName(self, name): + return self._qnames[name] + + def getQNames(self): + return list(self._qnames.values()) + + def copy(self): + return self.__class__(self._attrs, self._qnames) + + +def _test(): + XMLReader() + IncrementalParser() + Locator() + +if __name__ == "__main__": + _test() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..196d3788575993eb403588b01ac6b0a3fbba13da --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/__init__.py @@ -0,0 +1 @@ +# This directory is a Python package. diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b8b024dda1dcc1816fa8d7422eaad85841482b11 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/__pycache__/client.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/__pycache__/client.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4c9f4834ed1106e6e7fa1df458a1a30579c420f3 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/__pycache__/client.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/__pycache__/server.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/__pycache__/server.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bd0f3803737a417d5c9a958fe52c7a023cf996a8 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/__pycache__/server.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/client.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/client.py new file mode 100644 index 0000000000000000000000000000000000000000..a614cef6ab2f1a52b3ece45f9a3c2e6920802e15 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/client.py @@ -0,0 +1,1532 @@ +# +# XML-RPC CLIENT LIBRARY +# $Id$ +# +# an XML-RPC client interface for Python. +# +# the marshalling and response parser code can also be used to +# implement XML-RPC servers. +# +# Notes: +# this version is designed to work with Python 2.1 or newer. +# +# History: +# 1999-01-14 fl Created +# 1999-01-15 fl Changed dateTime to use localtime +# 1999-01-16 fl Added Binary/base64 element, default to RPC2 service +# 1999-01-19 fl Fixed array data element (from Skip Montanaro) +# 1999-01-21 fl Fixed dateTime constructor, etc. +# 1999-02-02 fl Added fault handling, handle empty sequences, etc. +# 1999-02-10 fl Fixed problem with empty responses (from Skip Montanaro) +# 1999-06-20 fl Speed improvements, pluggable parsers/transports (0.9.8) +# 2000-11-28 fl Changed boolean to check the truth value of its argument +# 2001-02-24 fl Added encoding/Unicode/SafeTransport patches +# 2001-02-26 fl Added compare support to wrappers (0.9.9/1.0b1) +# 2001-03-28 fl Make sure response tuple is a singleton +# 2001-03-29 fl Don't require empty params element (from Nicholas Riley) +# 2001-06-10 fl Folded in _xmlrpclib accelerator support (1.0b2) +# 2001-08-20 fl Base xmlrpclib.Error on built-in Exception (from Paul Prescod) +# 2001-09-03 fl Allow Transport subclass to override getparser +# 2001-09-10 fl Lazy import of urllib, cgi, xmllib (20x import speedup) +# 2001-10-01 fl Remove containers from memo cache when done with them +# 2001-10-01 fl Use faster escape method (80% dumps speedup) +# 2001-10-02 fl More dumps microtuning +# 2001-10-04 fl Make sure import expat gets a parser (from Guido van Rossum) +# 2001-10-10 sm Allow long ints to be passed as ints if they don't overflow +# 2001-10-17 sm Test for int and long overflow (allows use on 64-bit systems) +# 2001-11-12 fl Use repr() to marshal doubles (from Paul Felix) +# 2002-03-17 fl Avoid buffered read when possible (from James Rucker) +# 2002-04-07 fl Added pythondoc comments +# 2002-04-16 fl Added __str__ methods to datetime/binary wrappers +# 2002-05-15 fl Added error constants (from Andrew Kuchling) +# 2002-06-27 fl Merged with Python CVS version +# 2002-10-22 fl Added basic authentication (based on code from Phillip Eby) +# 2003-01-22 sm Add support for the bool type +# 2003-02-27 gvr Remove apply calls +# 2003-04-24 sm Use cStringIO if available +# 2003-04-25 ak Add support for nil +# 2003-06-15 gn Add support for time.struct_time +# 2003-07-12 gp Correct marshalling of Faults +# 2003-10-31 mvl Add multicall support +# 2004-08-20 mvl Bump minimum supported Python version to 2.1 +# 2014-12-02 ch/doko Add workaround for gzip bomb vulnerability +# +# Copyright (c) 1999-2002 by Secret Labs AB. +# Copyright (c) 1999-2002 by Fredrik Lundh. +# +# info@pythonware.com +# http://www.pythonware.com +# +# -------------------------------------------------------------------- +# The XML-RPC client interface is +# +# Copyright (c) 1999-2002 by Secret Labs AB +# Copyright (c) 1999-2002 by Fredrik Lundh +# +# By obtaining, using, and/or copying this software and/or its +# associated documentation, you agree that you have read, understood, +# and will comply with the following terms and conditions: +# +# Permission to use, copy, modify, and distribute this software and +# its associated documentation for any purpose and without fee is +# hereby granted, provided that the above copyright notice appears in +# all copies, and that both that copyright notice and this permission +# notice appear in supporting documentation, and that the name of +# Secret Labs AB or the author not be used in advertising or publicity +# pertaining to distribution of the software without specific, written +# prior permission. +# +# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD +# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT- +# ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR +# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY +# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS +# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE +# OF THIS SOFTWARE. +# -------------------------------------------------------------------- + +""" +An XML-RPC client interface for Python. + +The marshalling and response parser code can also be used to +implement XML-RPC servers. + +Exported exceptions: + + Error Base class for client errors + ProtocolError Indicates an HTTP protocol error + ResponseError Indicates a broken response package + Fault Indicates an XML-RPC fault package + +Exported classes: + + ServerProxy Represents a logical connection to an XML-RPC server + + MultiCall Executor of boxcared xmlrpc requests + DateTime dateTime wrapper for an ISO 8601 string or time tuple or + localtime integer value to generate a "dateTime.iso8601" + XML-RPC value + Binary binary data wrapper + + Marshaller Generate an XML-RPC params chunk from a Python data structure + Unmarshaller Unmarshal an XML-RPC response from incoming XML event message + Transport Handles an HTTP transaction to an XML-RPC server + SafeTransport Handles an HTTPS transaction to an XML-RPC server + +Exported constants: + + (none) + +Exported functions: + + getparser Create instance of the fastest available parser & attach + to an unmarshalling object + dumps Convert an argument tuple or a Fault instance to an XML-RPC + request (or response, if the methodresponse option is used). + loads Convert an XML-RPC packet to unmarshalled data plus a method + name (None if not present). +""" + +import base64 +import sys +import time +from datetime import datetime +from decimal import Decimal +import http.client +import urllib.parse +from xml.parsers import expat +import errno +from io import BytesIO +try: + import gzip +except ImportError: + gzip = None #python can be built without zlib/gzip support + +# -------------------------------------------------------------------- +# Internal stuff + +def escape(s): + s = s.replace("&", "&") + s = s.replace("<", "<") + return s.replace(">", ">",) + +# used in User-Agent header sent +__version__ = '%d.%d' % sys.version_info[:2] + +# xmlrpc integer limits +MAXINT = 2**31-1 +MININT = -2**31 + +# -------------------------------------------------------------------- +# Error constants (from Dan Libby's specification at +# http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php) + +# Ranges of errors +PARSE_ERROR = -32700 +SERVER_ERROR = -32600 +APPLICATION_ERROR = -32500 +SYSTEM_ERROR = -32400 +TRANSPORT_ERROR = -32300 + +# Specific errors +NOT_WELLFORMED_ERROR = -32700 +UNSUPPORTED_ENCODING = -32701 +INVALID_ENCODING_CHAR = -32702 +INVALID_XMLRPC = -32600 +METHOD_NOT_FOUND = -32601 +INVALID_METHOD_PARAMS = -32602 +INTERNAL_ERROR = -32603 + +# -------------------------------------------------------------------- +# Exceptions + +## +# Base class for all kinds of client-side errors. + +class Error(Exception): + """Base class for client errors.""" + __str__ = object.__str__ + +## +# Indicates an HTTP-level protocol error. This is raised by the HTTP +# transport layer, if the server returns an error code other than 200 +# (OK). +# +# @param url The target URL. +# @param errcode The HTTP error code. +# @param errmsg The HTTP error message. +# @param headers The HTTP header dictionary. + +class ProtocolError(Error): + """Indicates an HTTP protocol error.""" + def __init__(self, url, errcode, errmsg, headers): + Error.__init__(self) + self.url = url + self.errcode = errcode + self.errmsg = errmsg + self.headers = headers + def __repr__(self): + return ( + "<%s for %s: %s %s>" % + (self.__class__.__name__, self.url, self.errcode, self.errmsg) + ) + +## +# Indicates a broken XML-RPC response package. This exception is +# raised by the unmarshalling layer, if the XML-RPC response is +# malformed. + +class ResponseError(Error): + """Indicates a broken response package.""" + pass + +## +# Indicates an XML-RPC fault response package. This exception is +# raised by the unmarshalling layer, if the XML-RPC response contains +# a fault string. This exception can also be used as a class, to +# generate a fault XML-RPC message. +# +# @param faultCode The XML-RPC fault code. +# @param faultString The XML-RPC fault string. + +class Fault(Error): + """Indicates an XML-RPC fault package.""" + def __init__(self, faultCode, faultString, **extra): + Error.__init__(self) + self.faultCode = faultCode + self.faultString = faultString + def __repr__(self): + return "<%s %s: %r>" % (self.__class__.__name__, + self.faultCode, self.faultString) + +# -------------------------------------------------------------------- +# Special values + +## +# Backwards compatibility + +boolean = Boolean = bool + +## +# Wrapper for XML-RPC DateTime values. This converts a time value to +# the format used by XML-RPC. +#

+# The value can be given as a datetime object, as a string in the +# format "yyyymmddThh:mm:ss", as a 9-item time tuple (as returned by +# time.localtime()), or an integer value (as returned by time.time()). +# The wrapper uses time.localtime() to convert an integer to a time +# tuple. +# +# @param value The time, given as a datetime object, an ISO 8601 string, +# a time tuple, or an integer time value. + + +# Issue #13305: different format codes across platforms +_day0 = datetime(1, 1, 1) +def _try(fmt): + try: + return _day0.strftime(fmt) == '0001' + except ValueError: + return False +if _try('%Y'): # Mac OS X + def _iso8601_format(value): + return value.strftime("%Y%m%dT%H:%M:%S") +elif _try('%4Y'): # Linux + def _iso8601_format(value): + return value.strftime("%4Y%m%dT%H:%M:%S") +else: + def _iso8601_format(value): + return value.strftime("%Y%m%dT%H:%M:%S").zfill(17) +del _day0 +del _try + + +def _strftime(value): + if isinstance(value, datetime): + return _iso8601_format(value) + + if not isinstance(value, (tuple, time.struct_time)): + if value == 0: + value = time.time() + value = time.localtime(value) + + return "%04d%02d%02dT%02d:%02d:%02d" % value[:6] + +class DateTime: + """DateTime wrapper for an ISO 8601 string or time tuple or + localtime integer value to generate 'dateTime.iso8601' XML-RPC + value. + """ + + def __init__(self, value=0): + if isinstance(value, str): + self.value = value + else: + self.value = _strftime(value) + + def make_comparable(self, other): + if isinstance(other, DateTime): + s = self.value + o = other.value + elif isinstance(other, datetime): + s = self.value + o = _iso8601_format(other) + elif isinstance(other, str): + s = self.value + o = other + elif hasattr(other, "timetuple"): + s = self.timetuple() + o = other.timetuple() + else: + s = self + o = NotImplemented + return s, o + + def __lt__(self, other): + s, o = self.make_comparable(other) + if o is NotImplemented: + return NotImplemented + return s < o + + def __le__(self, other): + s, o = self.make_comparable(other) + if o is NotImplemented: + return NotImplemented + return s <= o + + def __gt__(self, other): + s, o = self.make_comparable(other) + if o is NotImplemented: + return NotImplemented + return s > o + + def __ge__(self, other): + s, o = self.make_comparable(other) + if o is NotImplemented: + return NotImplemented + return s >= o + + def __eq__(self, other): + s, o = self.make_comparable(other) + if o is NotImplemented: + return NotImplemented + return s == o + + def timetuple(self): + return time.strptime(self.value, "%Y%m%dT%H:%M:%S") + + ## + # Get date/time value. + # + # @return Date/time value, as an ISO 8601 string. + + def __str__(self): + return self.value + + def __repr__(self): + return "<%s %r at %#x>" % (self.__class__.__name__, self.value, id(self)) + + def decode(self, data): + self.value = str(data).strip() + + def encode(self, out): + out.write("") + out.write(self.value) + out.write("\n") + +def _datetime(data): + # decode xml element contents into a DateTime structure. + value = DateTime() + value.decode(data) + return value + +def _datetime_type(data): + return datetime.strptime(data, "%Y%m%dT%H:%M:%S") + +## +# Wrapper for binary data. This can be used to transport any kind +# of binary data over XML-RPC, using BASE64 encoding. +# +# @param data An 8-bit string containing arbitrary data. + +class Binary: + """Wrapper for binary data.""" + + def __init__(self, data=None): + if data is None: + data = b"" + else: + if not isinstance(data, (bytes, bytearray)): + raise TypeError("expected bytes or bytearray, not %s" % + data.__class__.__name__) + data = bytes(data) # Make a copy of the bytes! + self.data = data + + ## + # Get buffer contents. + # + # @return Buffer contents, as an 8-bit string. + + def __str__(self): + return str(self.data, "latin-1") # XXX encoding?! + + def __eq__(self, other): + if isinstance(other, Binary): + other = other.data + return self.data == other + + def decode(self, data): + self.data = base64.decodebytes(data) + + def encode(self, out): + out.write("\n") + encoded = base64.encodebytes(self.data) + out.write(encoded.decode('ascii')) + out.write("\n") + +def _binary(data): + # decode xml element contents into a Binary structure + value = Binary() + value.decode(data) + return value + +WRAPPERS = (DateTime, Binary) + +# -------------------------------------------------------------------- +# XML parsers + +class ExpatParser: + # fast expat parser for Python 2.0 and later. + def __init__(self, target): + self._parser = parser = expat.ParserCreate(None, None) + self._target = target + parser.StartElementHandler = target.start + parser.EndElementHandler = target.end + parser.CharacterDataHandler = target.data + encoding = None + target.xml(encoding, None) + + def feed(self, data): + self._parser.Parse(data, False) + + def close(self): + try: + parser = self._parser + except AttributeError: + pass + else: + del self._target, self._parser # get rid of circular references + parser.Parse(b"", True) # end of data + +# -------------------------------------------------------------------- +# XML-RPC marshalling and unmarshalling code + +## +# XML-RPC marshaller. +# +# @param encoding Default encoding for 8-bit strings. The default +# value is None (interpreted as UTF-8). +# @see dumps + +class Marshaller: + """Generate an XML-RPC params chunk from a Python data structure. + + Create a Marshaller instance for each set of parameters, and use + the "dumps" method to convert your data (represented as a tuple) + to an XML-RPC params chunk. To write a fault response, pass a + Fault instance instead. You may prefer to use the "dumps" module + function for this purpose. + """ + + # by the way, if you don't understand what's going on in here, + # that's perfectly ok. + + def __init__(self, encoding=None, allow_none=False): + self.memo = {} + self.data = None + self.encoding = encoding + self.allow_none = allow_none + + dispatch = {} + + def dumps(self, values): + out = [] + write = out.append + dump = self.__dump + if isinstance(values, Fault): + # fault instance + write("\n") + dump({'faultCode': values.faultCode, + 'faultString': values.faultString}, + write) + write("\n") + else: + # parameter block + # FIXME: the xml-rpc specification allows us to leave out + # the entire block if there are no parameters. + # however, changing this may break older code (including + # old versions of xmlrpclib.py), so this is better left as + # is for now. See @XMLRPC3 for more information. /F + write("\n") + for v in values: + write("\n") + dump(v, write) + write("\n") + write("\n") + result = "".join(out) + return result + + def __dump(self, value, write): + try: + f = self.dispatch[type(value)] + except KeyError: + # check if this object can be marshalled as a structure + if not hasattr(value, '__dict__'): + raise TypeError("cannot marshal %s objects" % type(value)) + # check if this class is a sub-class of a basic type, + # because we don't know how to marshal these types + # (e.g. a string sub-class) + for type_ in type(value).__mro__: + if type_ in self.dispatch.keys(): + raise TypeError("cannot marshal %s objects" % type(value)) + # XXX(twouters): using "_arbitrary_instance" as key as a quick-fix + # for the p3yk merge, this should probably be fixed more neatly. + f = self.dispatch["_arbitrary_instance"] + f(self, value, write) + + def dump_nil (self, value, write): + if not self.allow_none: + raise TypeError("cannot marshal None unless allow_none is enabled") + write("") + dispatch[type(None)] = dump_nil + + def dump_bool(self, value, write): + write("") + write(value and "1" or "0") + write("\n") + dispatch[bool] = dump_bool + + def dump_long(self, value, write): + if value > MAXINT or value < MININT: + raise OverflowError("int exceeds XML-RPC limits") + write("") + write(str(int(value))) + write("\n") + dispatch[int] = dump_long + + # backward compatible + dump_int = dump_long + + def dump_double(self, value, write): + write("") + write(repr(value)) + write("\n") + dispatch[float] = dump_double + + def dump_unicode(self, value, write, escape=escape): + write("") + write(escape(value)) + write("\n") + dispatch[str] = dump_unicode + + def dump_bytes(self, value, write): + write("\n") + encoded = base64.encodebytes(value) + write(encoded.decode('ascii')) + write("\n") + dispatch[bytes] = dump_bytes + dispatch[bytearray] = dump_bytes + + def dump_array(self, value, write): + i = id(value) + if i in self.memo: + raise TypeError("cannot marshal recursive sequences") + self.memo[i] = None + dump = self.__dump + write("\n") + for v in value: + dump(v, write) + write("\n") + del self.memo[i] + dispatch[tuple] = dump_array + dispatch[list] = dump_array + + def dump_struct(self, value, write, escape=escape): + i = id(value) + if i in self.memo: + raise TypeError("cannot marshal recursive dictionaries") + self.memo[i] = None + dump = self.__dump + write("\n") + for k, v in value.items(): + write("\n") + if not isinstance(k, str): + raise TypeError("dictionary key must be string") + write("%s\n" % escape(k)) + dump(v, write) + write("\n") + write("\n") + del self.memo[i] + dispatch[dict] = dump_struct + + def dump_datetime(self, value, write): + write("") + write(_strftime(value)) + write("\n") + dispatch[datetime] = dump_datetime + + def dump_instance(self, value, write): + # check for special wrappers + if value.__class__ in WRAPPERS: + self.write = write + value.encode(self) + del self.write + else: + # store instance attributes as a struct (really?) + self.dump_struct(value.__dict__, write) + dispatch[DateTime] = dump_instance + dispatch[Binary] = dump_instance + # XXX(twouters): using "_arbitrary_instance" as key as a quick-fix + # for the p3yk merge, this should probably be fixed more neatly. + dispatch["_arbitrary_instance"] = dump_instance + +## +# XML-RPC unmarshaller. +# +# @see loads + +class Unmarshaller: + """Unmarshal an XML-RPC response, based on incoming XML event + messages (start, data, end). Call close() to get the resulting + data structure. + + Note that this reader is fairly tolerant, and gladly accepts bogus + XML-RPC data without complaining (but not bogus XML). + """ + + # and again, if you don't understand what's going on in here, + # that's perfectly ok. + + def __init__(self, use_datetime=False, use_builtin_types=False): + self._type = None + self._stack = [] + self._marks = [] + self._data = [] + self._value = False + self._methodname = None + self._encoding = "utf-8" + self.append = self._stack.append + self._use_datetime = use_builtin_types or use_datetime + self._use_bytes = use_builtin_types + + def close(self): + # return response tuple and target method + if self._type is None or self._marks: + raise ResponseError() + if self._type == "fault": + raise Fault(**self._stack[0]) + return tuple(self._stack) + + def getmethodname(self): + return self._methodname + + # + # event handlers + + def xml(self, encoding, standalone): + self._encoding = encoding + # FIXME: assert standalone == 1 ??? + + def start(self, tag, attrs): + # prepare to handle this element + if ':' in tag: + tag = tag.split(':')[-1] + if tag == "array" or tag == "struct": + self._marks.append(len(self._stack)) + self._data = [] + if self._value and tag not in self.dispatch: + raise ResponseError("unknown tag %r" % tag) + self._value = (tag == "value") + + def data(self, text): + self._data.append(text) + + def end(self, tag): + # call the appropriate end tag handler + try: + f = self.dispatch[tag] + except KeyError: + if ':' not in tag: + return # unknown tag ? + try: + f = self.dispatch[tag.split(':')[-1]] + except KeyError: + return # unknown tag ? + return f(self, "".join(self._data)) + + # + # accelerator support + + def end_dispatch(self, tag, data): + # dispatch data + try: + f = self.dispatch[tag] + except KeyError: + if ':' not in tag: + return # unknown tag ? + try: + f = self.dispatch[tag.split(':')[-1]] + except KeyError: + return # unknown tag ? + return f(self, data) + + # + # element decoders + + dispatch = {} + + def end_nil (self, data): + self.append(None) + self._value = 0 + dispatch["nil"] = end_nil + + def end_boolean(self, data): + if data == "0": + self.append(False) + elif data == "1": + self.append(True) + else: + raise TypeError("bad boolean value") + self._value = 0 + dispatch["boolean"] = end_boolean + + def end_int(self, data): + self.append(int(data)) + self._value = 0 + dispatch["i1"] = end_int + dispatch["i2"] = end_int + dispatch["i4"] = end_int + dispatch["i8"] = end_int + dispatch["int"] = end_int + dispatch["biginteger"] = end_int + + def end_double(self, data): + self.append(float(data)) + self._value = 0 + dispatch["double"] = end_double + dispatch["float"] = end_double + + def end_bigdecimal(self, data): + self.append(Decimal(data)) + self._value = 0 + dispatch["bigdecimal"] = end_bigdecimal + + def end_string(self, data): + if self._encoding: + data = data.decode(self._encoding) + self.append(data) + self._value = 0 + dispatch["string"] = end_string + dispatch["name"] = end_string # struct keys are always strings + + def end_array(self, data): + mark = self._marks.pop() + # map arrays to Python lists + self._stack[mark:] = [self._stack[mark:]] + self._value = 0 + dispatch["array"] = end_array + + def end_struct(self, data): + mark = self._marks.pop() + # map structs to Python dictionaries + dict = {} + items = self._stack[mark:] + for i in range(0, len(items), 2): + dict[items[i]] = items[i+1] + self._stack[mark:] = [dict] + self._value = 0 + dispatch["struct"] = end_struct + + def end_base64(self, data): + value = Binary() + value.decode(data.encode("ascii")) + if self._use_bytes: + value = value.data + self.append(value) + self._value = 0 + dispatch["base64"] = end_base64 + + def end_dateTime(self, data): + value = DateTime() + value.decode(data) + if self._use_datetime: + value = _datetime_type(data) + self.append(value) + dispatch["dateTime.iso8601"] = end_dateTime + + def end_value(self, data): + # if we stumble upon a value element with no internal + # elements, treat it as a string element + if self._value: + self.end_string(data) + dispatch["value"] = end_value + + def end_params(self, data): + self._type = "params" + dispatch["params"] = end_params + + def end_fault(self, data): + self._type = "fault" + dispatch["fault"] = end_fault + + def end_methodName(self, data): + if self._encoding: + data = data.decode(self._encoding) + self._methodname = data + self._type = "methodName" # no params + dispatch["methodName"] = end_methodName + +## Multicall support +# + +class _MultiCallMethod: + # some lesser magic to store calls made to a MultiCall object + # for batch execution + def __init__(self, call_list, name): + self.__call_list = call_list + self.__name = name + def __getattr__(self, name): + return _MultiCallMethod(self.__call_list, "%s.%s" % (self.__name, name)) + def __call__(self, *args): + self.__call_list.append((self.__name, args)) + +class MultiCallIterator: + """Iterates over the results of a multicall. Exceptions are + raised in response to xmlrpc faults.""" + + def __init__(self, results): + self.results = results + + def __getitem__(self, i): + item = self.results[i] + if type(item) == type({}): + raise Fault(item['faultCode'], item['faultString']) + elif type(item) == type([]): + return item[0] + else: + raise ValueError("unexpected type in multicall result") + +class MultiCall: + """server -> an object used to boxcar method calls + + server should be a ServerProxy object. + + Methods can be added to the MultiCall using normal + method call syntax e.g.: + + multicall = MultiCall(server_proxy) + multicall.add(2,3) + multicall.get_address("Guido") + + To execute the multicall, call the MultiCall object e.g.: + + add_result, address = multicall() + """ + + def __init__(self, server): + self.__server = server + self.__call_list = [] + + def __repr__(self): + return "<%s at %#x>" % (self.__class__.__name__, id(self)) + + def __getattr__(self, name): + return _MultiCallMethod(self.__call_list, name) + + def __call__(self): + marshalled_list = [] + for name, args in self.__call_list: + marshalled_list.append({'methodName' : name, 'params' : args}) + + return MultiCallIterator(self.__server.system.multicall(marshalled_list)) + +# -------------------------------------------------------------------- +# convenience functions + +FastMarshaller = FastParser = FastUnmarshaller = None + +## +# Create a parser object, and connect it to an unmarshalling instance. +# This function picks the fastest available XML parser. +# +# return A (parser, unmarshaller) tuple. + +def getparser(use_datetime=False, use_builtin_types=False): + """getparser() -> parser, unmarshaller + + Create an instance of the fastest available parser, and attach it + to an unmarshalling object. Return both objects. + """ + if FastParser and FastUnmarshaller: + if use_builtin_types: + mkdatetime = _datetime_type + mkbytes = base64.decodebytes + elif use_datetime: + mkdatetime = _datetime_type + mkbytes = _binary + else: + mkdatetime = _datetime + mkbytes = _binary + target = FastUnmarshaller(True, False, mkbytes, mkdatetime, Fault) + parser = FastParser(target) + else: + target = Unmarshaller(use_datetime=use_datetime, use_builtin_types=use_builtin_types) + if FastParser: + parser = FastParser(target) + else: + parser = ExpatParser(target) + return parser, target + +## +# Convert a Python tuple or a Fault instance to an XML-RPC packet. +# +# @def dumps(params, **options) +# @param params A tuple or Fault instance. +# @keyparam methodname If given, create a methodCall request for +# this method name. +# @keyparam methodresponse If given, create a methodResponse packet. +# If used with a tuple, the tuple must be a singleton (that is, +# it must contain exactly one element). +# @keyparam encoding The packet encoding. +# @return A string containing marshalled data. + +def dumps(params, methodname=None, methodresponse=None, encoding=None, + allow_none=False): + """data [,options] -> marshalled data + + Convert an argument tuple or a Fault instance to an XML-RPC + request (or response, if the methodresponse option is used). + + In addition to the data object, the following options can be given + as keyword arguments: + + methodname: the method name for a methodCall packet + + methodresponse: true to create a methodResponse packet. + If this option is used with a tuple, the tuple must be + a singleton (i.e. it can contain only one element). + + encoding: the packet encoding (default is UTF-8) + + All byte strings in the data structure are assumed to use the + packet encoding. Unicode strings are automatically converted, + where necessary. + """ + + assert isinstance(params, (tuple, Fault)), "argument must be tuple or Fault instance" + if isinstance(params, Fault): + methodresponse = 1 + elif methodresponse and isinstance(params, tuple): + assert len(params) == 1, "response tuple must be a singleton" + + if not encoding: + encoding = "utf-8" + + if FastMarshaller: + m = FastMarshaller(encoding) + else: + m = Marshaller(encoding, allow_none) + + data = m.dumps(params) + + if encoding != "utf-8": + xmlheader = "\n" % str(encoding) + else: + xmlheader = "\n" # utf-8 is default + + # standard XML-RPC wrappings + if methodname: + # a method call + data = ( + xmlheader, + "\n" + "", methodname, "\n", + data, + "\n" + ) + elif methodresponse: + # a method response, or a fault structure + data = ( + xmlheader, + "\n", + data, + "\n" + ) + else: + return data # return as is + return "".join(data) + +## +# Convert an XML-RPC packet to a Python object. If the XML-RPC packet +# represents a fault condition, this function raises a Fault exception. +# +# @param data An XML-RPC packet, given as an 8-bit string. +# @return A tuple containing the unpacked data, and the method name +# (None if not present). +# @see Fault + +def loads(data, use_datetime=False, use_builtin_types=False): + """data -> unmarshalled data, method name + + Convert an XML-RPC packet to unmarshalled data plus a method + name (None if not present). + + If the XML-RPC packet represents a fault condition, this function + raises a Fault exception. + """ + p, u = getparser(use_datetime=use_datetime, use_builtin_types=use_builtin_types) + p.feed(data) + p.close() + return u.close(), u.getmethodname() + +## +# Encode a string using the gzip content encoding such as specified by the +# Content-Encoding: gzip +# in the HTTP header, as described in RFC 1952 +# +# @param data the unencoded data +# @return the encoded data + +def gzip_encode(data): + """data -> gzip encoded data + + Encode data using the gzip content encoding as described in RFC 1952 + """ + if not gzip: + raise NotImplementedError + f = BytesIO() + with gzip.GzipFile(mode="wb", fileobj=f, compresslevel=1) as gzf: + gzf.write(data) + return f.getvalue() + +## +# Decode a string using the gzip content encoding such as specified by the +# Content-Encoding: gzip +# in the HTTP header, as described in RFC 1952 +# +# @param data The encoded data +# @keyparam max_decode Maximum bytes to decode (20 MiB default), use negative +# values for unlimited decoding +# @return the unencoded data +# @raises ValueError if data is not correctly coded. +# @raises ValueError if max gzipped payload length exceeded + +def gzip_decode(data, max_decode=20971520): + """gzip encoded data -> unencoded data + + Decode data using the gzip content encoding as described in RFC 1952 + """ + if not gzip: + raise NotImplementedError + with gzip.GzipFile(mode="rb", fileobj=BytesIO(data)) as gzf: + try: + if max_decode < 0: # no limit + decoded = gzf.read() + else: + decoded = gzf.read(max_decode + 1) + except OSError: + raise ValueError("invalid data") + if max_decode >= 0 and len(decoded) > max_decode: + raise ValueError("max gzipped payload length exceeded") + return decoded + +## +# Return a decoded file-like object for the gzip encoding +# as described in RFC 1952. +# +# @param response A stream supporting a read() method +# @return a file-like object that the decoded data can be read() from + +class GzipDecodedResponse(gzip.GzipFile if gzip else object): + """a file-like object to decode a response encoded with the gzip + method, as described in RFC 1952. + """ + def __init__(self, response): + #response doesn't support tell() and read(), required by + #GzipFile + if not gzip: + raise NotImplementedError + self.io = BytesIO(response.read()) + gzip.GzipFile.__init__(self, mode="rb", fileobj=self.io) + + def close(self): + try: + gzip.GzipFile.close(self) + finally: + self.io.close() + + +# -------------------------------------------------------------------- +# request dispatcher + +class _Method: + # some magic to bind an XML-RPC method to an RPC server. + # supports "nested" methods (e.g. examples.getStateName) + def __init__(self, send, name): + self.__send = send + self.__name = name + def __getattr__(self, name): + return _Method(self.__send, "%s.%s" % (self.__name, name)) + def __call__(self, *args): + return self.__send(self.__name, args) + +## +# Standard transport class for XML-RPC over HTTP. +#

+# You can create custom transports by subclassing this method, and +# overriding selected methods. + +class Transport: + """Handles an HTTP transaction to an XML-RPC server.""" + + # client identifier (may be overridden) + user_agent = "Python-xmlrpc/%s" % __version__ + + #if true, we'll request gzip encoding + accept_gzip_encoding = True + + # if positive, encode request using gzip if it exceeds this threshold + # note that many servers will get confused, so only use it if you know + # that they can decode such a request + encode_threshold = None #None = don't encode + + def __init__(self, use_datetime=False, use_builtin_types=False, + *, headers=()): + self._use_datetime = use_datetime + self._use_builtin_types = use_builtin_types + self._connection = (None, None) + self._headers = list(headers) + self._extra_headers = [] + + ## + # Send a complete request, and parse the response. + # Retry request if a cached connection has disconnected. + # + # @param host Target host. + # @param handler Target PRC handler. + # @param request_body XML-RPC request body. + # @param verbose Debugging flag. + # @return Parsed response. + + def request(self, host, handler, request_body, verbose=False): + #retry request once if cached connection has gone cold + for i in (0, 1): + try: + return self.single_request(host, handler, request_body, verbose) + except http.client.RemoteDisconnected: + if i: + raise + except OSError as e: + if i or e.errno not in (errno.ECONNRESET, errno.ECONNABORTED, + errno.EPIPE): + raise + + def single_request(self, host, handler, request_body, verbose=False): + # issue XML-RPC request + try: + http_conn = self.send_request(host, handler, request_body, verbose) + resp = http_conn.getresponse() + if resp.status == 200: + self.verbose = verbose + return self.parse_response(resp) + + except Fault: + raise + except Exception: + #All unexpected errors leave connection in + # a strange state, so we clear it. + self.close() + raise + + #We got an error response. + #Discard any response data and raise exception + if resp.getheader("content-length", ""): + resp.read() + raise ProtocolError( + host + handler, + resp.status, resp.reason, + dict(resp.getheaders()) + ) + + + ## + # Create parser. + # + # @return A 2-tuple containing a parser and an unmarshaller. + + def getparser(self): + # get parser and unmarshaller + return getparser(use_datetime=self._use_datetime, + use_builtin_types=self._use_builtin_types) + + ## + # Get authorization info from host parameter + # Host may be a string, or a (host, x509-dict) tuple; if a string, + # it is checked for a "user:pw@host" format, and a "Basic + # Authentication" header is added if appropriate. + # + # @param host Host descriptor (URL or (URL, x509 info) tuple). + # @return A 3-tuple containing (actual host, extra headers, + # x509 info). The header and x509 fields may be None. + + def get_host_info(self, host): + + x509 = {} + if isinstance(host, tuple): + host, x509 = host + + auth, host = urllib.parse._splituser(host) + + if auth: + auth = urllib.parse.unquote_to_bytes(auth) + auth = base64.encodebytes(auth).decode("utf-8") + auth = "".join(auth.split()) # get rid of whitespace + extra_headers = [ + ("Authorization", "Basic " + auth) + ] + else: + extra_headers = [] + + return host, extra_headers, x509 + + ## + # Connect to server. + # + # @param host Target host. + # @return An HTTPConnection object + + def make_connection(self, host): + #return an existing connection if possible. This allows + #HTTP/1.1 keep-alive. + if self._connection and host == self._connection[0]: + return self._connection[1] + # create a HTTP connection object from a host descriptor + chost, self._extra_headers, x509 = self.get_host_info(host) + self._connection = host, http.client.HTTPConnection(chost) + return self._connection[1] + + ## + # Clear any cached connection object. + # Used in the event of socket errors. + # + def close(self): + host, connection = self._connection + if connection: + self._connection = (None, None) + connection.close() + + ## + # Send HTTP request. + # + # @param host Host descriptor (URL or (URL, x509 info) tuple). + # @param handler Target RPC handler (a path relative to host) + # @param request_body The XML-RPC request body + # @param debug Enable debugging if debug is true. + # @return An HTTPConnection. + + def send_request(self, host, handler, request_body, debug): + connection = self.make_connection(host) + headers = self._headers + self._extra_headers + if debug: + connection.set_debuglevel(1) + if self.accept_gzip_encoding and gzip: + connection.putrequest("POST", handler, skip_accept_encoding=True) + headers.append(("Accept-Encoding", "gzip")) + else: + connection.putrequest("POST", handler) + headers.append(("Content-Type", "text/xml")) + headers.append(("User-Agent", self.user_agent)) + self.send_headers(connection, headers) + self.send_content(connection, request_body) + return connection + + ## + # Send request headers. + # This function provides a useful hook for subclassing + # + # @param connection httpConnection. + # @param headers list of key,value pairs for HTTP headers + + def send_headers(self, connection, headers): + for key, val in headers: + connection.putheader(key, val) + + ## + # Send request body. + # This function provides a useful hook for subclassing + # + # @param connection httpConnection. + # @param request_body XML-RPC request body. + + def send_content(self, connection, request_body): + #optionally encode the request + if (self.encode_threshold is not None and + self.encode_threshold < len(request_body) and + gzip): + connection.putheader("Content-Encoding", "gzip") + request_body = gzip_encode(request_body) + + connection.putheader("Content-Length", str(len(request_body))) + connection.endheaders(request_body) + + ## + # Parse response. + # + # @param file Stream. + # @return Response tuple and target method. + + def parse_response(self, response): + # read response data from httpresponse, and parse it + # Check for new http response object, otherwise it is a file object. + if hasattr(response, 'getheader'): + if response.getheader("Content-Encoding", "") == "gzip": + stream = GzipDecodedResponse(response) + else: + stream = response + else: + stream = response + + p, u = self.getparser() + + while 1: + data = stream.read(1024) + if not data: + break + if self.verbose: + print("body:", repr(data)) + p.feed(data) + + if stream is not response: + stream.close() + p.close() + + return u.close() + +## +# Standard transport class for XML-RPC over HTTPS. + +class SafeTransport(Transport): + """Handles an HTTPS transaction to an XML-RPC server.""" + + def __init__(self, use_datetime=False, use_builtin_types=False, + *, headers=(), context=None): + super().__init__(use_datetime=use_datetime, + use_builtin_types=use_builtin_types, + headers=headers) + self.context = context + + # FIXME: mostly untested + + def make_connection(self, host): + if self._connection and host == self._connection[0]: + return self._connection[1] + + if not hasattr(http.client, "HTTPSConnection"): + raise NotImplementedError( + "your version of http.client doesn't support HTTPS") + # create a HTTPS connection object from a host descriptor + # host may be a string, or a (host, x509-dict) tuple + chost, self._extra_headers, x509 = self.get_host_info(host) + self._connection = host, http.client.HTTPSConnection(chost, + None, context=self.context, **(x509 or {})) + return self._connection[1] + +## +# Standard server proxy. This class establishes a virtual connection +# to an XML-RPC server. +#

+# This class is available as ServerProxy and Server. New code should +# use ServerProxy, to avoid confusion. +# +# @def ServerProxy(uri, **options) +# @param uri The connection point on the server. +# @keyparam transport A transport factory, compatible with the +# standard transport class. +# @keyparam encoding The default encoding used for 8-bit strings +# (default is UTF-8). +# @keyparam verbose Use a true value to enable debugging output. +# (printed to standard output). +# @see Transport + +class ServerProxy: + """uri [,options] -> a logical connection to an XML-RPC server + + uri is the connection point on the server, given as + scheme://host/target. + + The standard implementation always supports the "http" scheme. If + SSL socket support is available (Python 2.0), it also supports + "https". + + If the target part and the slash preceding it are both omitted, + "/RPC2" is assumed. + + The following options can be given as keyword arguments: + + transport: a transport factory + encoding: the request encoding (default is UTF-8) + + All 8-bit strings passed to the server proxy are assumed to use + the given encoding. + """ + + def __init__(self, uri, transport=None, encoding=None, verbose=False, + allow_none=False, use_datetime=False, use_builtin_types=False, + *, headers=(), context=None): + # establish a "logical" server connection + + # get the url + p = urllib.parse.urlsplit(uri) + if p.scheme not in ("http", "https"): + raise OSError("unsupported XML-RPC protocol") + self.__host = p.netloc + self.__handler = urllib.parse.urlunsplit(["", "", *p[2:]]) + if not self.__handler: + self.__handler = "/RPC2" + + if transport is None: + if p.scheme == "https": + handler = SafeTransport + extra_kwargs = {"context": context} + else: + handler = Transport + extra_kwargs = {} + transport = handler(use_datetime=use_datetime, + use_builtin_types=use_builtin_types, + headers=headers, + **extra_kwargs) + self.__transport = transport + + self.__encoding = encoding or 'utf-8' + self.__verbose = verbose + self.__allow_none = allow_none + + def __close(self): + self.__transport.close() + + def __request(self, methodname, params): + # call a method on the remote server + + request = dumps(params, methodname, encoding=self.__encoding, + allow_none=self.__allow_none).encode(self.__encoding, 'xmlcharrefreplace') + + response = self.__transport.request( + self.__host, + self.__handler, + request, + verbose=self.__verbose + ) + + if len(response) == 1: + response = response[0] + + return response + + def __repr__(self): + return ( + "<%s for %s%s>" % + (self.__class__.__name__, self.__host, self.__handler) + ) + + def __getattr__(self, name): + # magic method dispatcher + return _Method(self.__request, name) + + # note: to call a remote object with a non-standard name, use + # result getattr(server, "strange-python-name")(args) + + def __call__(self, attr): + """A workaround to get special attributes on the ServerProxy + without interfering with the magic __getattr__ + """ + if attr == "close": + return self.__close + elif attr == "transport": + return self.__transport + raise AttributeError("Attribute %r not found" % (attr,)) + + def __enter__(self): + return self + + def __exit__(self, *args): + self.__close() + +# compatibility + +Server = ServerProxy + +# -------------------------------------------------------------------- +# test code + +if __name__ == "__main__": + + # simple test program (from the XML-RPC specification) + + # local server, available from Lib/xmlrpc/server.py + server = ServerProxy("http://localhost:8000") + + try: + print(server.currentTime.getCurrentTime()) + except Error as v: + print("ERROR", v) + + multi = MultiCall(server) + multi.getData() + multi.pow(2,9) + multi.add(1,2) + try: + for response in multi(): + print(response) + except Error as v: + print("ERROR", v) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/server.py b/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/server.py new file mode 100644 index 0000000000000000000000000000000000000000..0c4b558045a9f43b022f4c025063a47f7b4caff3 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/xmlrpc/server.py @@ -0,0 +1,1004 @@ +r"""XML-RPC Servers. + +This module can be used to create simple XML-RPC servers +by creating a server and either installing functions, a +class instance, or by extending the SimpleXMLRPCServer +class. + +It can also be used to handle XML-RPC requests in a CGI +environment using CGIXMLRPCRequestHandler. + +The Doc* classes can be used to create XML-RPC servers that +serve pydoc-style documentation in response to HTTP +GET requests. This documentation is dynamically generated +based on the functions and methods registered with the +server. + +A list of possible usage patterns follows: + +1. Install functions: + +server = SimpleXMLRPCServer(("localhost", 8000)) +server.register_function(pow) +server.register_function(lambda x,y: x+y, 'add') +server.serve_forever() + +2. Install an instance: + +class MyFuncs: + def __init__(self): + # make all of the sys functions available through sys.func_name + import sys + self.sys = sys + def _listMethods(self): + # implement this method so that system.listMethods + # knows to advertise the sys methods + return list_public_methods(self) + \ + ['sys.' + method for method in list_public_methods(self.sys)] + def pow(self, x, y): return pow(x, y) + def add(self, x, y) : return x + y + +server = SimpleXMLRPCServer(("localhost", 8000)) +server.register_introspection_functions() +server.register_instance(MyFuncs()) +server.serve_forever() + +3. Install an instance with custom dispatch method: + +class Math: + def _listMethods(self): + # this method must be present for system.listMethods + # to work + return ['add', 'pow'] + def _methodHelp(self, method): + # this method must be present for system.methodHelp + # to work + if method == 'add': + return "add(2,3) => 5" + elif method == 'pow': + return "pow(x, y[, z]) => number" + else: + # By convention, return empty + # string if no help is available + return "" + def _dispatch(self, method, params): + if method == 'pow': + return pow(*params) + elif method == 'add': + return params[0] + params[1] + else: + raise ValueError('bad method') + +server = SimpleXMLRPCServer(("localhost", 8000)) +server.register_introspection_functions() +server.register_instance(Math()) +server.serve_forever() + +4. Subclass SimpleXMLRPCServer: + +class MathServer(SimpleXMLRPCServer): + def _dispatch(self, method, params): + try: + # We are forcing the 'export_' prefix on methods that are + # callable through XML-RPC to prevent potential security + # problems + func = getattr(self, 'export_' + method) + except AttributeError: + raise Exception('method "%s" is not supported' % method) + else: + return func(*params) + + def export_add(self, x, y): + return x + y + +server = MathServer(("localhost", 8000)) +server.serve_forever() + +5. CGI script: + +server = CGIXMLRPCRequestHandler() +server.register_function(pow) +server.handle_request() +""" + +# Written by Brian Quinlan (brian@sweetapp.com). +# Based on code written by Fredrik Lundh. + +from xmlrpc.client import Fault, dumps, loads, gzip_encode, gzip_decode +from http.server import BaseHTTPRequestHandler +from functools import partial +from inspect import signature +import html +import http.server +import socketserver +import sys +import os +import re +import pydoc +import traceback +try: + import fcntl +except ImportError: + fcntl = None + +def resolve_dotted_attribute(obj, attr, allow_dotted_names=True): + """resolve_dotted_attribute(a, 'b.c.d') => a.b.c.d + + Resolves a dotted attribute name to an object. Raises + an AttributeError if any attribute in the chain starts with a '_'. + + If the optional allow_dotted_names argument is false, dots are not + supported and this function operates similar to getattr(obj, attr). + """ + + if allow_dotted_names: + attrs = attr.split('.') + else: + attrs = [attr] + + for i in attrs: + if i.startswith('_'): + raise AttributeError( + 'attempt to access private attribute "%s"' % i + ) + else: + obj = getattr(obj,i) + return obj + +def list_public_methods(obj): + """Returns a list of attribute strings, found in the specified + object, which represent callable attributes""" + + return [member for member in dir(obj) + if not member.startswith('_') and + callable(getattr(obj, member))] + +class SimpleXMLRPCDispatcher: + """Mix-in class that dispatches XML-RPC requests. + + This class is used to register XML-RPC method handlers + and then to dispatch them. This class doesn't need to be + instanced directly when used by SimpleXMLRPCServer but it + can be instanced when used by the MultiPathXMLRPCServer + """ + + def __init__(self, allow_none=False, encoding=None, + use_builtin_types=False): + self.funcs = {} + self.instance = None + self.allow_none = allow_none + self.encoding = encoding or 'utf-8' + self.use_builtin_types = use_builtin_types + + def register_instance(self, instance, allow_dotted_names=False): + """Registers an instance to respond to XML-RPC requests. + + Only one instance can be installed at a time. + + If the registered instance has a _dispatch method then that + method will be called with the name of the XML-RPC method and + its parameters as a tuple + e.g. instance._dispatch('add',(2,3)) + + If the registered instance does not have a _dispatch method + then the instance will be searched to find a matching method + and, if found, will be called. Methods beginning with an '_' + are considered private and will not be called by + SimpleXMLRPCServer. + + If a registered function matches an XML-RPC request, then it + will be called instead of the registered instance. + + If the optional allow_dotted_names argument is true and the + instance does not have a _dispatch method, method names + containing dots are supported and resolved, as long as none of + the name segments start with an '_'. + + *** SECURITY WARNING: *** + + Enabling the allow_dotted_names options allows intruders + to access your module's global variables and may allow + intruders to execute arbitrary code on your machine. Only + use this option on a secure, closed network. + + """ + + self.instance = instance + self.allow_dotted_names = allow_dotted_names + + def register_function(self, function=None, name=None): + """Registers a function to respond to XML-RPC requests. + + The optional name argument can be used to set a Unicode name + for the function. + """ + # decorator factory + if function is None: + return partial(self.register_function, name=name) + + if name is None: + name = function.__name__ + self.funcs[name] = function + + return function + + def register_introspection_functions(self): + """Registers the XML-RPC introspection methods in the system + namespace. + + see http://xmlrpc.usefulinc.com/doc/reserved.html + """ + + self.funcs.update({'system.listMethods' : self.system_listMethods, + 'system.methodSignature' : self.system_methodSignature, + 'system.methodHelp' : self.system_methodHelp}) + + def register_multicall_functions(self): + """Registers the XML-RPC multicall method in the system + namespace. + + see http://www.xmlrpc.com/discuss/msgReader$1208""" + + self.funcs.update({'system.multicall' : self.system_multicall}) + + def _marshaled_dispatch(self, data, dispatch_method = None, path = None): + """Dispatches an XML-RPC method from marshalled (XML) data. + + XML-RPC methods are dispatched from the marshalled (XML) data + using the _dispatch method and the result is returned as + marshalled data. For backwards compatibility, a dispatch + function can be provided as an argument (see comment in + SimpleXMLRPCRequestHandler.do_POST) but overriding the + existing method through subclassing is the preferred means + of changing method dispatch behavior. + """ + + try: + params, method = loads(data, use_builtin_types=self.use_builtin_types) + + # generate response + if dispatch_method is not None: + response = dispatch_method(method, params) + else: + response = self._dispatch(method, params) + # wrap response in a singleton tuple + response = (response,) + response = dumps(response, methodresponse=1, + allow_none=self.allow_none, encoding=self.encoding) + except Fault as fault: + response = dumps(fault, allow_none=self.allow_none, + encoding=self.encoding) + except BaseException as exc: + response = dumps( + Fault(1, "%s:%s" % (type(exc), exc)), + encoding=self.encoding, allow_none=self.allow_none, + ) + + return response.encode(self.encoding, 'xmlcharrefreplace') + + def system_listMethods(self): + """system.listMethods() => ['add', 'subtract', 'multiple'] + + Returns a list of the methods supported by the server.""" + + methods = set(self.funcs.keys()) + if self.instance is not None: + # Instance can implement _listMethod to return a list of + # methods + if hasattr(self.instance, '_listMethods'): + methods |= set(self.instance._listMethods()) + # if the instance has a _dispatch method then we + # don't have enough information to provide a list + # of methods + elif not hasattr(self.instance, '_dispatch'): + methods |= set(list_public_methods(self.instance)) + return sorted(methods) + + def system_methodSignature(self, method_name): + """system.methodSignature('add') => [double, int, int] + + Returns a list describing the signature of the method. In the + above example, the add method takes two integers as arguments + and returns a double result. + + This server does NOT support system.methodSignature.""" + + # See http://xmlrpc.usefulinc.com/doc/sysmethodsig.html + + return 'signatures not supported' + + def system_methodHelp(self, method_name): + """system.methodHelp('add') => "Adds two integers together" + + Returns a string containing documentation for the specified method.""" + + method = None + if method_name in self.funcs: + method = self.funcs[method_name] + elif self.instance is not None: + # Instance can implement _methodHelp to return help for a method + if hasattr(self.instance, '_methodHelp'): + return self.instance._methodHelp(method_name) + # if the instance has a _dispatch method then we + # don't have enough information to provide help + elif not hasattr(self.instance, '_dispatch'): + try: + method = resolve_dotted_attribute( + self.instance, + method_name, + self.allow_dotted_names + ) + except AttributeError: + pass + + # Note that we aren't checking that the method actually + # be a callable object of some kind + if method is None: + return "" + else: + return pydoc.getdoc(method) + + def system_multicall(self, call_list): + """system.multicall([{'methodName': 'add', 'params': [2, 2]}, ...]) => \ +[[4], ...] + + Allows the caller to package multiple XML-RPC calls into a single + request. + + See http://www.xmlrpc.com/discuss/msgReader$1208 + """ + + results = [] + for call in call_list: + method_name = call['methodName'] + params = call['params'] + + try: + # XXX A marshalling error in any response will fail the entire + # multicall. If someone cares they should fix this. + results.append([self._dispatch(method_name, params)]) + except Fault as fault: + results.append( + {'faultCode' : fault.faultCode, + 'faultString' : fault.faultString} + ) + except BaseException as exc: + results.append( + {'faultCode' : 1, + 'faultString' : "%s:%s" % (type(exc), exc)} + ) + return results + + def _dispatch(self, method, params): + """Dispatches the XML-RPC method. + + XML-RPC calls are forwarded to a registered function that + matches the called XML-RPC method name. If no such function + exists then the call is forwarded to the registered instance, + if available. + + If the registered instance has a _dispatch method then that + method will be called with the name of the XML-RPC method and + its parameters as a tuple + e.g. instance._dispatch('add',(2,3)) + + If the registered instance does not have a _dispatch method + then the instance will be searched to find a matching method + and, if found, will be called. + + Methods beginning with an '_' are considered private and will + not be called. + """ + + try: + # call the matching registered function + func = self.funcs[method] + except KeyError: + pass + else: + if func is not None: + return func(*params) + raise Exception('method "%s" is not supported' % method) + + if self.instance is not None: + if hasattr(self.instance, '_dispatch'): + # call the `_dispatch` method on the instance + return self.instance._dispatch(method, params) + + # call the instance's method directly + try: + func = resolve_dotted_attribute( + self.instance, + method, + self.allow_dotted_names + ) + except AttributeError: + pass + else: + if func is not None: + return func(*params) + + raise Exception('method "%s" is not supported' % method) + +class SimpleXMLRPCRequestHandler(BaseHTTPRequestHandler): + """Simple XML-RPC request handler class. + + Handles all HTTP POST requests and attempts to decode them as + XML-RPC requests. + """ + + # Class attribute listing the accessible path components; + # paths not on this list will result in a 404 error. + rpc_paths = ('/', '/RPC2', '/pydoc.css') + + #if not None, encode responses larger than this, if possible + encode_threshold = 1400 #a common MTU + + #Override form StreamRequestHandler: full buffering of output + #and no Nagle. + wbufsize = -1 + disable_nagle_algorithm = True + + # a re to match a gzip Accept-Encoding + aepattern = re.compile(r""" + \s* ([^\s;]+) \s* #content-coding + (;\s* q \s*=\s* ([0-9\.]+))? #q + """, re.VERBOSE | re.IGNORECASE) + + def accept_encodings(self): + r = {} + ae = self.headers.get("Accept-Encoding", "") + for e in ae.split(","): + match = self.aepattern.match(e) + if match: + v = match.group(3) + v = float(v) if v else 1.0 + r[match.group(1)] = v + return r + + def is_rpc_path_valid(self): + if self.rpc_paths: + return self.path in self.rpc_paths + else: + # If .rpc_paths is empty, just assume all paths are legal + return True + + def do_POST(self): + """Handles the HTTP POST request. + + Attempts to interpret all HTTP POST requests as XML-RPC calls, + which are forwarded to the server's _dispatch method for handling. + """ + + # Check that the path is legal + if not self.is_rpc_path_valid(): + self.report_404() + return + + try: + # Get arguments by reading body of request. + # We read this in chunks to avoid straining + # socket.read(); around the 10 or 15Mb mark, some platforms + # begin to have problems (bug #792570). + max_chunk_size = 10*1024*1024 + size_remaining = int(self.headers["content-length"]) + L = [] + while size_remaining: + chunk_size = min(size_remaining, max_chunk_size) + chunk = self.rfile.read(chunk_size) + if not chunk: + break + L.append(chunk) + size_remaining -= len(L[-1]) + data = b''.join(L) + + data = self.decode_request_content(data) + if data is None: + return #response has been sent + + # In previous versions of SimpleXMLRPCServer, _dispatch + # could be overridden in this class, instead of in + # SimpleXMLRPCDispatcher. To maintain backwards compatibility, + # check to see if a subclass implements _dispatch and dispatch + # using that method if present. + response = self.server._marshaled_dispatch( + data, getattr(self, '_dispatch', None), self.path + ) + except Exception as e: # This should only happen if the module is buggy + # internal error, report as HTTP server error + self.send_response(500) + + # Send information about the exception if requested + if hasattr(self.server, '_send_traceback_header') and \ + self.server._send_traceback_header: + self.send_header("X-exception", str(e)) + trace = traceback.format_exc() + trace = str(trace.encode('ASCII', 'backslashreplace'), 'ASCII') + self.send_header("X-traceback", trace) + + self.send_header("Content-length", "0") + self.end_headers() + else: + self.send_response(200) + self.send_header("Content-type", "text/xml") + if self.encode_threshold is not None: + if len(response) > self.encode_threshold: + q = self.accept_encodings().get("gzip", 0) + if q: + try: + response = gzip_encode(response) + self.send_header("Content-Encoding", "gzip") + except NotImplementedError: + pass + self.send_header("Content-length", str(len(response))) + self.end_headers() + self.wfile.write(response) + + def decode_request_content(self, data): + #support gzip encoding of request + encoding = self.headers.get("content-encoding", "identity").lower() + if encoding == "identity": + return data + if encoding == "gzip": + try: + return gzip_decode(data) + except NotImplementedError: + self.send_response(501, "encoding %r not supported" % encoding) + except ValueError: + self.send_response(400, "error decoding gzip content") + else: + self.send_response(501, "encoding %r not supported" % encoding) + self.send_header("Content-length", "0") + self.end_headers() + + def report_404 (self): + # Report a 404 error + self.send_response(404) + response = b'No such page' + self.send_header("Content-type", "text/plain") + self.send_header("Content-length", str(len(response))) + self.end_headers() + self.wfile.write(response) + + def log_request(self, code='-', size='-'): + """Selectively log an accepted request.""" + + if self.server.logRequests: + BaseHTTPRequestHandler.log_request(self, code, size) + +class SimpleXMLRPCServer(socketserver.TCPServer, + SimpleXMLRPCDispatcher): + """Simple XML-RPC server. + + Simple XML-RPC server that allows functions and a single instance + to be installed to handle requests. The default implementation + attempts to dispatch XML-RPC calls to the functions or instance + installed in the server. Override the _dispatch method inherited + from SimpleXMLRPCDispatcher to change this behavior. + """ + + allow_reuse_address = True + + # Warning: this is for debugging purposes only! Never set this to True in + # production code, as will be sending out sensitive information (exception + # and stack trace details) when exceptions are raised inside + # SimpleXMLRPCRequestHandler.do_POST + _send_traceback_header = False + + def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler, + logRequests=True, allow_none=False, encoding=None, + bind_and_activate=True, use_builtin_types=False): + self.logRequests = logRequests + + SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding, use_builtin_types) + socketserver.TCPServer.__init__(self, addr, requestHandler, bind_and_activate) + + +class MultiPathXMLRPCServer(SimpleXMLRPCServer): + """Multipath XML-RPC Server + This specialization of SimpleXMLRPCServer allows the user to create + multiple Dispatcher instances and assign them to different + HTTP request paths. This makes it possible to run two or more + 'virtual XML-RPC servers' at the same port. + Make sure that the requestHandler accepts the paths in question. + """ + def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler, + logRequests=True, allow_none=False, encoding=None, + bind_and_activate=True, use_builtin_types=False): + + SimpleXMLRPCServer.__init__(self, addr, requestHandler, logRequests, allow_none, + encoding, bind_and_activate, use_builtin_types) + self.dispatchers = {} + self.allow_none = allow_none + self.encoding = encoding or 'utf-8' + + def add_dispatcher(self, path, dispatcher): + self.dispatchers[path] = dispatcher + return dispatcher + + def get_dispatcher(self, path): + return self.dispatchers[path] + + def _marshaled_dispatch(self, data, dispatch_method = None, path = None): + try: + response = self.dispatchers[path]._marshaled_dispatch( + data, dispatch_method, path) + except BaseException as exc: + # report low level exception back to server + # (each dispatcher should have handled their own + # exceptions) + response = dumps( + Fault(1, "%s:%s" % (type(exc), exc)), + encoding=self.encoding, allow_none=self.allow_none) + response = response.encode(self.encoding, 'xmlcharrefreplace') + return response + +class CGIXMLRPCRequestHandler(SimpleXMLRPCDispatcher): + """Simple handler for XML-RPC data passed through CGI.""" + + def __init__(self, allow_none=False, encoding=None, use_builtin_types=False): + SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding, use_builtin_types) + + def handle_xmlrpc(self, request_text): + """Handle a single XML-RPC request""" + + response = self._marshaled_dispatch(request_text) + + print('Content-Type: text/xml') + print('Content-Length: %d' % len(response)) + print() + sys.stdout.flush() + sys.stdout.buffer.write(response) + sys.stdout.buffer.flush() + + def handle_get(self): + """Handle a single HTTP GET request. + + Default implementation indicates an error because + XML-RPC uses the POST method. + """ + + code = 400 + message, explain = BaseHTTPRequestHandler.responses[code] + + response = http.server.DEFAULT_ERROR_MESSAGE % \ + { + 'code' : code, + 'message' : message, + 'explain' : explain + } + response = response.encode('utf-8') + print('Status: %d %s' % (code, message)) + print('Content-Type: %s' % http.server.DEFAULT_ERROR_CONTENT_TYPE) + print('Content-Length: %d' % len(response)) + print() + sys.stdout.flush() + sys.stdout.buffer.write(response) + sys.stdout.buffer.flush() + + def handle_request(self, request_text=None): + """Handle a single XML-RPC request passed through a CGI post method. + + If no XML data is given then it is read from stdin. The resulting + XML-RPC response is printed to stdout along with the correct HTTP + headers. + """ + + if request_text is None and \ + os.environ.get('REQUEST_METHOD', None) == 'GET': + self.handle_get() + else: + # POST data is normally available through stdin + try: + length = int(os.environ.get('CONTENT_LENGTH', None)) + except (ValueError, TypeError): + length = -1 + if request_text is None: + request_text = sys.stdin.read(length) + + self.handle_xmlrpc(request_text) + + +# ----------------------------------------------------------------------------- +# Self documenting XML-RPC Server. + +class ServerHTMLDoc(pydoc.HTMLDoc): + """Class used to generate pydoc HTML document for a server""" + + def markup(self, text, escape=None, funcs={}, classes={}, methods={}): + """Mark up some plain text, given a context of symbols to look for. + Each context dictionary maps object names to anchor names.""" + escape = escape or self.escape + results = [] + here = 0 + + # XXX Note that this regular expression does not allow for the + # hyperlinking of arbitrary strings being used as method + # names. Only methods with names consisting of word characters + # and '.'s are hyperlinked. + pattern = re.compile(r'\b((http|https|ftp)://\S+[\w/]|' + r'RFC[- ]?(\d+)|' + r'PEP[- ]?(\d+)|' + r'(self\.)?((?:\w|\.)+))\b') + while 1: + match = pattern.search(text, here) + if not match: break + start, end = match.span() + results.append(escape(text[here:start])) + + all, scheme, rfc, pep, selfdot, name = match.groups() + if scheme: + url = escape(all).replace('"', '"') + results.append('%s' % (url, url)) + elif rfc: + url = 'https://www.rfc-editor.org/rfc/rfc%d.txt' % int(rfc) + results.append('%s' % (url, escape(all))) + elif pep: + url = 'https://peps.python.org/pep-%04d/' % int(pep) + results.append('%s' % (url, escape(all))) + elif text[end:end+1] == '(': + results.append(self.namelink(name, methods, funcs, classes)) + elif selfdot: + results.append('self.%s' % name) + else: + results.append(self.namelink(name, classes)) + here = end + results.append(escape(text[here:])) + return ''.join(results) + + def docroutine(self, object, name, mod=None, + funcs={}, classes={}, methods={}, cl=None): + """Produce HTML documentation for a function or method object.""" + + anchor = (cl and cl.__name__ or '') + '-' + name + note = '' + + title = '%s' % ( + self.escape(anchor), self.escape(name)) + + if callable(object): + argspec = str(signature(object)) + else: + argspec = '(...)' + + if isinstance(object, tuple): + argspec = object[0] or argspec + docstring = object[1] or "" + else: + docstring = pydoc.getdoc(object) + + decl = title + argspec + (note and self.grey( + '%s' % note)) + + doc = self.markup( + docstring, self.preformat, funcs, classes, methods) + doc = doc and '

%s
' % doc + return '
%s
%s
\n' % (decl, doc) + + def docserver(self, server_name, package_documentation, methods): + """Produce HTML documentation for an XML-RPC server.""" + + fdict = {} + for key, value in methods.items(): + fdict[key] = '#-' + key + fdict[value] = fdict[key] + + server_name = self.escape(server_name) + head = '%s' % server_name + result = self.heading(head) + + doc = self.markup(package_documentation, self.preformat, fdict) + doc = doc and '%s' % doc + result = result + '

%s

\n' % doc + + contents = [] + method_items = sorted(methods.items()) + for key, value in method_items: + contents.append(self.docroutine(value, key, funcs=fdict)) + result = result + self.bigsection( + 'Methods', 'functions', ''.join(contents)) + + return result + + + def page(self, title, contents): + """Format an HTML page.""" + css_path = "/pydoc.css" + css_link = ( + '' % + css_path) + return '''\ + + + + +Python: %s +%s%s''' % (title, css_link, contents) + +class XMLRPCDocGenerator: + """Generates documentation for an XML-RPC server. + + This class is designed as mix-in and should not + be constructed directly. + """ + + def __init__(self): + # setup variables used for HTML documentation + self.server_name = 'XML-RPC Server Documentation' + self.server_documentation = \ + "This server exports the following methods through the XML-RPC "\ + "protocol." + self.server_title = 'XML-RPC Server Documentation' + + def set_server_title(self, server_title): + """Set the HTML title of the generated server documentation""" + + self.server_title = server_title + + def set_server_name(self, server_name): + """Set the name of the generated HTML server documentation""" + + self.server_name = server_name + + def set_server_documentation(self, server_documentation): + """Set the documentation string for the entire server.""" + + self.server_documentation = server_documentation + + def generate_html_documentation(self): + """generate_html_documentation() => html documentation for the server + + Generates HTML documentation for the server using introspection for + installed functions and instances that do not implement the + _dispatch method. Alternatively, instances can choose to implement + the _get_method_argstring(method_name) method to provide the + argument string used in the documentation and the + _methodHelp(method_name) method to provide the help text used + in the documentation.""" + + methods = {} + + for method_name in self.system_listMethods(): + if method_name in self.funcs: + method = self.funcs[method_name] + elif self.instance is not None: + method_info = [None, None] # argspec, documentation + if hasattr(self.instance, '_get_method_argstring'): + method_info[0] = self.instance._get_method_argstring(method_name) + if hasattr(self.instance, '_methodHelp'): + method_info[1] = self.instance._methodHelp(method_name) + + method_info = tuple(method_info) + if method_info != (None, None): + method = method_info + elif not hasattr(self.instance, '_dispatch'): + try: + method = resolve_dotted_attribute( + self.instance, + method_name + ) + except AttributeError: + method = method_info + else: + method = method_info + else: + assert 0, "Could not find method in self.functions and no "\ + "instance installed" + + methods[method_name] = method + + documenter = ServerHTMLDoc() + documentation = documenter.docserver( + self.server_name, + self.server_documentation, + methods + ) + + return documenter.page(html.escape(self.server_title), documentation) + +class DocXMLRPCRequestHandler(SimpleXMLRPCRequestHandler): + """XML-RPC and documentation request handler class. + + Handles all HTTP POST requests and attempts to decode them as + XML-RPC requests. + + Handles all HTTP GET requests and interprets them as requests + for documentation. + """ + + def _get_css(self, url): + path_here = os.path.dirname(os.path.realpath(__file__)) + css_path = os.path.join(path_here, "..", "pydoc_data", "_pydoc.css") + with open(css_path, mode="rb") as fp: + return fp.read() + + def do_GET(self): + """Handles the HTTP GET request. + + Interpret all HTTP GET requests as requests for server + documentation. + """ + # Check that the path is legal + if not self.is_rpc_path_valid(): + self.report_404() + return + + if self.path.endswith('.css'): + content_type = 'text/css' + response = self._get_css(self.path) + else: + content_type = 'text/html' + response = self.server.generate_html_documentation().encode('utf-8') + + self.send_response(200) + self.send_header('Content-Type', '%s; charset=UTF-8' % content_type) + self.send_header("Content-length", str(len(response))) + self.end_headers() + self.wfile.write(response) + +class DocXMLRPCServer( SimpleXMLRPCServer, + XMLRPCDocGenerator): + """XML-RPC and HTML documentation server. + + Adds the ability to serve server documentation to the capabilities + of SimpleXMLRPCServer. + """ + + def __init__(self, addr, requestHandler=DocXMLRPCRequestHandler, + logRequests=True, allow_none=False, encoding=None, + bind_and_activate=True, use_builtin_types=False): + SimpleXMLRPCServer.__init__(self, addr, requestHandler, logRequests, + allow_none, encoding, bind_and_activate, + use_builtin_types) + XMLRPCDocGenerator.__init__(self) + +class DocCGIXMLRPCRequestHandler( CGIXMLRPCRequestHandler, + XMLRPCDocGenerator): + """Handler for XML-RPC data and documentation requests passed through + CGI""" + + def handle_get(self): + """Handles the HTTP GET request. + + Interpret all HTTP GET requests as requests for server + documentation. + """ + + response = self.generate_html_documentation().encode('utf-8') + + print('Content-Type: text/html') + print('Content-Length: %d' % len(response)) + print() + sys.stdout.flush() + sys.stdout.buffer.write(response) + sys.stdout.buffer.flush() + + def __init__(self): + CGIXMLRPCRequestHandler.__init__(self) + XMLRPCDocGenerator.__init__(self) + + +if __name__ == '__main__': + import datetime + + class ExampleService: + def getData(self): + return '42' + + class currentTime: + @staticmethod + def getCurrentTime(): + return datetime.datetime.now() + + with SimpleXMLRPCServer(("localhost", 8000)) as server: + server.register_function(pow) + server.register_function(lambda x,y: x+y, 'add') + server.register_instance(ExampleService(), allow_dotted_names=True) + server.register_multicall_functions() + print('Serving XML-RPC on localhost port 8000') + print('It is advisable to run this example server within a secure, closed network.') + try: + server.serve_forever() + except KeyboardInterrupt: + print("\nKeyboard interrupt received, exiting.") + sys.exit(0) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/zipapp.py b/physworld_p1_20261018/envs/p1/lib/python3.11/zipapp.py new file mode 100644 index 0000000000000000000000000000000000000000..ce77632516c646ecc11e231a1d855e3a48670a71 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/zipapp.py @@ -0,0 +1,206 @@ +import contextlib +import os +import pathlib +import shutil +import stat +import sys +import zipfile + +__all__ = ['ZipAppError', 'create_archive', 'get_interpreter'] + + +# The __main__.py used if the users specifies "-m module:fn". +# Note that this will always be written as UTF-8 (module and +# function names can be non-ASCII in Python 3). +# We add a coding cookie even though UTF-8 is the default in Python 3 +# because the resulting archive may be intended to be run under Python 2. +MAIN_TEMPLATE = """\ +# -*- coding: utf-8 -*- +import {module} +{module}.{fn}() +""" + + +# The Windows launcher defaults to UTF-8 when parsing shebang lines if the +# file has no BOM. So use UTF-8 on Windows. +# On Unix, use the filesystem encoding. +if sys.platform.startswith('win'): + shebang_encoding = 'utf-8' +else: + shebang_encoding = sys.getfilesystemencoding() + + +class ZipAppError(ValueError): + pass + + +@contextlib.contextmanager +def _maybe_open(archive, mode): + if isinstance(archive, (str, os.PathLike)): + with open(archive, mode) as f: + yield f + else: + yield archive + + +def _write_file_prefix(f, interpreter): + """Write a shebang line.""" + if interpreter: + shebang = b'#!' + interpreter.encode(shebang_encoding) + b'\n' + f.write(shebang) + + +def _copy_archive(archive, new_archive, interpreter=None): + """Copy an application archive, modifying the shebang line.""" + with _maybe_open(archive, 'rb') as src: + # Skip the shebang line from the source. + # Read 2 bytes of the source and check if they are #!. + first_2 = src.read(2) + if first_2 == b'#!': + # Discard the initial 2 bytes and the rest of the shebang line. + first_2 = b'' + src.readline() + + with _maybe_open(new_archive, 'wb') as dst: + _write_file_prefix(dst, interpreter) + # If there was no shebang, "first_2" contains the first 2 bytes + # of the source file, so write them before copying the rest + # of the file. + dst.write(first_2) + shutil.copyfileobj(src, dst) + + if interpreter and isinstance(new_archive, str): + os.chmod(new_archive, os.stat(new_archive).st_mode | stat.S_IEXEC) + + +def create_archive(source, target=None, interpreter=None, main=None, + filter=None, compressed=False): + """Create an application archive from SOURCE. + + The SOURCE can be the name of a directory, or a filename or a file-like + object referring to an existing archive. + + The content of SOURCE is packed into an application archive in TARGET, + which can be a filename or a file-like object. If SOURCE is a directory, + TARGET can be omitted and will default to the name of SOURCE with .pyz + appended. + + The created application archive will have a shebang line specifying + that it should run with INTERPRETER (there will be no shebang line if + INTERPRETER is None), and a __main__.py which runs MAIN (if MAIN is + not specified, an existing __main__.py will be used). It is an error + to specify MAIN for anything other than a directory source with no + __main__.py, and it is an error to omit MAIN if the directory has no + __main__.py. + """ + # Are we copying an existing archive? + source_is_file = False + if hasattr(source, 'read') and hasattr(source, 'readline'): + source_is_file = True + else: + source = pathlib.Path(source) + if source.is_file(): + source_is_file = True + + if source_is_file: + _copy_archive(source, target, interpreter) + return + + # We are creating a new archive from a directory. + if not source.exists(): + raise ZipAppError("Source does not exist") + has_main = (source / '__main__.py').is_file() + if main and has_main: + raise ZipAppError( + "Cannot specify entry point if the source has __main__.py") + if not (main or has_main): + raise ZipAppError("Archive has no entry point") + + main_py = None + if main: + # Check that main has the right format. + mod, sep, fn = main.partition(':') + mod_ok = all(part.isidentifier() for part in mod.split('.')) + fn_ok = all(part.isidentifier() for part in fn.split('.')) + if not (sep == ':' and mod_ok and fn_ok): + raise ZipAppError("Invalid entry point: " + main) + main_py = MAIN_TEMPLATE.format(module=mod, fn=fn) + + if target is None: + target = source.with_suffix('.pyz') + elif not hasattr(target, 'write'): + target = pathlib.Path(target) + + with _maybe_open(target, 'wb') as fd: + _write_file_prefix(fd, interpreter) + compression = (zipfile.ZIP_DEFLATED if compressed else + zipfile.ZIP_STORED) + with zipfile.ZipFile(fd, 'w', compression=compression) as z: + for child in source.rglob('*'): + arcname = child.relative_to(source) + if filter is None or filter(arcname): + z.write(child, arcname.as_posix()) + if main_py: + z.writestr('__main__.py', main_py.encode('utf-8')) + + if interpreter and not hasattr(target, 'write'): + target.chmod(target.stat().st_mode | stat.S_IEXEC) + + +def get_interpreter(archive): + with _maybe_open(archive, 'rb') as f: + if f.read(2) == b'#!': + return f.readline().strip().decode(shebang_encoding) + + +def main(args=None): + """Run the zipapp command line interface. + + The ARGS parameter lets you specify the argument list directly. + Omitting ARGS (or setting it to None) works as for argparse, using + sys.argv[1:] as the argument list. + """ + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument('--output', '-o', default=None, + help="The name of the output archive. " + "Required if SOURCE is an archive.") + parser.add_argument('--python', '-p', default=None, + help="The name of the Python interpreter to use " + "(default: no shebang line).") + parser.add_argument('--main', '-m', default=None, + help="The main function of the application " + "(default: use an existing __main__.py).") + parser.add_argument('--compress', '-c', action='store_true', + help="Compress files with the deflate method. " + "Files are stored uncompressed by default.") + parser.add_argument('--info', default=False, action='store_true', + help="Display the interpreter from the archive.") + parser.add_argument('source', + help="Source directory (or existing archive).") + + args = parser.parse_args(args) + + # Handle `python -m zipapp archive.pyz --info`. + if args.info: + if not os.path.isfile(args.source): + raise SystemExit("Can only get info for an archive file") + interpreter = get_interpreter(args.source) + print("Interpreter: {}".format(interpreter or "")) + sys.exit(0) + + if os.path.isfile(args.source): + if args.output is None or (os.path.exists(args.output) and + os.path.samefile(args.source, args.output)): + raise SystemExit("In-place editing of archives is not supported") + if args.main: + raise SystemExit("Cannot change the main function when copying") + + create_archive(args.source, args.output, + interpreter=args.python, main=args.main, + compressed=args.compress) + + +if __name__ == '__main__': + main() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/zipfile.py b/physworld_p1_20261018/envs/p1/lib/python3.11/zipfile.py new file mode 100644 index 0000000000000000000000000000000000000000..f06dd2e3a4065cb27a1f49fa900fbdd2709917df --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/zipfile.py @@ -0,0 +1,2642 @@ +""" +Read and write ZIP files. + +XXX references to utf-8 need further investigation. +""" +import binascii +import importlib.util +import io +import itertools +import os +import posixpath +import re +import shutil +import stat +import struct +import sys +import threading +import time +import contextlib +import pathlib + +try: + import zlib # We may need its compression method + crc32 = zlib.crc32 +except ImportError: + zlib = None + crc32 = binascii.crc32 + +try: + import bz2 # We may need its compression method +except ImportError: + bz2 = None + +try: + import lzma # We may need its compression method +except ImportError: + lzma = None + +__all__ = ["BadZipFile", "BadZipfile", "error", + "ZIP_STORED", "ZIP_DEFLATED", "ZIP_BZIP2", "ZIP_LZMA", + "is_zipfile", "ZipInfo", "ZipFile", "PyZipFile", "LargeZipFile", + "Path"] + +class BadZipFile(Exception): + pass + + +class LargeZipFile(Exception): + """ + Raised when writing a zipfile, the zipfile requires ZIP64 extensions + and those extensions are disabled. + """ + +error = BadZipfile = BadZipFile # Pre-3.2 compatibility names + + +ZIP64_LIMIT = (1 << 31) - 1 +ZIP_FILECOUNT_LIMIT = (1 << 16) - 1 +ZIP_MAX_COMMENT = (1 << 16) - 1 + +# constants for Zip file compression methods +ZIP_STORED = 0 +ZIP_DEFLATED = 8 +ZIP_BZIP2 = 12 +ZIP_LZMA = 14 +# Other ZIP compression methods not supported + +DEFAULT_VERSION = 20 +ZIP64_VERSION = 45 +BZIP2_VERSION = 46 +LZMA_VERSION = 63 +# we recognize (but not necessarily support) all features up to that version +MAX_EXTRACT_VERSION = 63 + +# Below are some formats and associated data for reading/writing headers using +# the struct module. The names and structures of headers/records are those used +# in the PKWARE description of the ZIP file format: +# http://www.pkware.com/documents/casestudies/APPNOTE.TXT +# (URL valid as of January 2008) + +# The "end of central directory" structure, magic number, size, and indices +# (section V.I in the format document) +structEndArchive = b"<4s4H2LH" +stringEndArchive = b"PK\005\006" +sizeEndCentDir = struct.calcsize(structEndArchive) + +_ECD_SIGNATURE = 0 +_ECD_DISK_NUMBER = 1 +_ECD_DISK_START = 2 +_ECD_ENTRIES_THIS_DISK = 3 +_ECD_ENTRIES_TOTAL = 4 +_ECD_SIZE = 5 +_ECD_OFFSET = 6 +_ECD_COMMENT_SIZE = 7 +# These last two indices are not part of the structure as defined in the +# spec, but they are used internally by this module as a convenience +_ECD_COMMENT = 8 +_ECD_LOCATION = 9 + +# The "central directory" structure, magic number, size, and indices +# of entries in the structure (section V.F in the format document) +structCentralDir = "<4s4B4HL2L5H2L" +stringCentralDir = b"PK\001\002" +sizeCentralDir = struct.calcsize(structCentralDir) + +# indexes of entries in the central directory structure +_CD_SIGNATURE = 0 +_CD_CREATE_VERSION = 1 +_CD_CREATE_SYSTEM = 2 +_CD_EXTRACT_VERSION = 3 +_CD_EXTRACT_SYSTEM = 4 +_CD_FLAG_BITS = 5 +_CD_COMPRESS_TYPE = 6 +_CD_TIME = 7 +_CD_DATE = 8 +_CD_CRC = 9 +_CD_COMPRESSED_SIZE = 10 +_CD_UNCOMPRESSED_SIZE = 11 +_CD_FILENAME_LENGTH = 12 +_CD_EXTRA_FIELD_LENGTH = 13 +_CD_COMMENT_LENGTH = 14 +_CD_DISK_NUMBER_START = 15 +_CD_INTERNAL_FILE_ATTRIBUTES = 16 +_CD_EXTERNAL_FILE_ATTRIBUTES = 17 +_CD_LOCAL_HEADER_OFFSET = 18 + +# General purpose bit flags +# Zip Appnote: 4.4.4 general purpose bit flag: (2 bytes) +_MASK_ENCRYPTED = 1 << 0 +# Bits 1 and 2 have different meanings depending on the compression used. +_MASK_COMPRESS_OPTION_1 = 1 << 1 +# _MASK_COMPRESS_OPTION_2 = 1 << 2 +# _MASK_USE_DATA_DESCRIPTOR: If set, crc-32, compressed size and uncompressed +# size are zero in the local header and the real values are written in the data +# descriptor immediately following the compressed data. +_MASK_USE_DATA_DESCRIPTOR = 1 << 3 +# Bit 4: Reserved for use with compression method 8, for enhanced deflating. +# _MASK_RESERVED_BIT_4 = 1 << 4 +_MASK_COMPRESSED_PATCH = 1 << 5 +_MASK_STRONG_ENCRYPTION = 1 << 6 +# _MASK_UNUSED_BIT_7 = 1 << 7 +# _MASK_UNUSED_BIT_8 = 1 << 8 +# _MASK_UNUSED_BIT_9 = 1 << 9 +# _MASK_UNUSED_BIT_10 = 1 << 10 +_MASK_UTF_FILENAME = 1 << 11 +# Bit 12: Reserved by PKWARE for enhanced compression. +# _MASK_RESERVED_BIT_12 = 1 << 12 +# _MASK_ENCRYPTED_CENTRAL_DIR = 1 << 13 +# Bit 14, 15: Reserved by PKWARE +# _MASK_RESERVED_BIT_14 = 1 << 14 +# _MASK_RESERVED_BIT_15 = 1 << 15 + +# The "local file header" structure, magic number, size, and indices +# (section V.A in the format document) +structFileHeader = "<4s2B4HL2L2H" +stringFileHeader = b"PK\003\004" +sizeFileHeader = struct.calcsize(structFileHeader) + +_FH_SIGNATURE = 0 +_FH_EXTRACT_VERSION = 1 +_FH_EXTRACT_SYSTEM = 2 +_FH_GENERAL_PURPOSE_FLAG_BITS = 3 +_FH_COMPRESSION_METHOD = 4 +_FH_LAST_MOD_TIME = 5 +_FH_LAST_MOD_DATE = 6 +_FH_CRC = 7 +_FH_COMPRESSED_SIZE = 8 +_FH_UNCOMPRESSED_SIZE = 9 +_FH_FILENAME_LENGTH = 10 +_FH_EXTRA_FIELD_LENGTH = 11 + +# The "Zip64 end of central directory locator" structure, magic number, and size +structEndArchive64Locator = "<4sLQL" +stringEndArchive64Locator = b"PK\x06\x07" +sizeEndCentDir64Locator = struct.calcsize(structEndArchive64Locator) + +# The "Zip64 end of central directory" record, magic number, size, and indices +# (section V.G in the format document) +structEndArchive64 = "<4sQ2H2L4Q" +stringEndArchive64 = b"PK\x06\x06" +sizeEndCentDir64 = struct.calcsize(structEndArchive64) + +_CD64_SIGNATURE = 0 +_CD64_DIRECTORY_RECSIZE = 1 +_CD64_CREATE_VERSION = 2 +_CD64_EXTRACT_VERSION = 3 +_CD64_DISK_NUMBER = 4 +_CD64_DISK_NUMBER_START = 5 +_CD64_NUMBER_ENTRIES_THIS_DISK = 6 +_CD64_NUMBER_ENTRIES_TOTAL = 7 +_CD64_DIRECTORY_SIZE = 8 +_CD64_OFFSET_START_CENTDIR = 9 + +_DD_SIGNATURE = 0x08074b50 + +_EXTRA_FIELD_STRUCT = struct.Struct(' 1: + raise BadZipFile("zipfiles that span multiple disks are not supported") + + offset -= sizeEndCentDir64 + if reloff > offset: + raise BadZipFile("Corrupt zip64 end of central directory locator") + # First, check the assumption that there is no prepended data. + fpin.seek(reloff) + extrasz = offset - reloff + data = fpin.read(sizeEndCentDir64) + if len(data) != sizeEndCentDir64: + raise OSError("Unknown I/O error") + if not data.startswith(stringEndArchive64) and reloff != offset: + # Since we already have seen the Zip64 EOCD Locator, it's + # possible we got here because there is prepended data. + # Assume no 'zip64 extensible data' + fpin.seek(offset) + extrasz = 0 + data = fpin.read(sizeEndCentDir64) + if len(data) != sizeEndCentDir64: + raise OSError("Unknown I/O error") + if not data.startswith(stringEndArchive64): + raise BadZipFile("Zip64 end of central directory record not found") + + sig, sz, create_version, read_version, disk_num, disk_dir, \ + dircount, dircount2, dirsize, diroffset = \ + struct.unpack(structEndArchive64, data) + if (diroffset + dirsize != reloff or + sz + 12 != sizeEndCentDir64 + extrasz): + raise BadZipFile("Corrupt zip64 end of central directory record") + + # Update the original endrec using data from the ZIP64 record + endrec[_ECD_SIGNATURE] = sig + endrec[_ECD_DISK_NUMBER] = disk_num + endrec[_ECD_DISK_START] = disk_dir + endrec[_ECD_ENTRIES_THIS_DISK] = dircount + endrec[_ECD_ENTRIES_TOTAL] = dircount2 + endrec[_ECD_SIZE] = dirsize + endrec[_ECD_OFFSET] = diroffset + endrec[_ECD_LOCATION] = offset - extrasz + return endrec + + +def _EndRecData(fpin): + """Return data from the "End of Central Directory" record, or None. + + The data is a list of the nine items in the ZIP "End of central dir" + record followed by a tenth item, the file seek offset of this record.""" + + # Determine file size + fpin.seek(0, 2) + filesize = fpin.tell() + + # Check to see if this is ZIP file with no archive comment (the + # "end of central directory" structure should be the last item in the + # file if this is the case). + try: + fpin.seek(-sizeEndCentDir, 2) + except OSError: + return None + data = fpin.read() + if (len(data) == sizeEndCentDir and + data[0:4] == stringEndArchive and + data[-2:] == b"\000\000"): + # the signature is correct and there's no comment, unpack structure + endrec = struct.unpack(structEndArchive, data) + endrec=list(endrec) + + # Append a blank comment and record start offset + endrec.append(b"") + endrec.append(filesize - sizeEndCentDir) + + # Try to read the "Zip64 end of central directory" structure + return _EndRecData64(fpin, filesize - sizeEndCentDir, endrec) + + # Either this is not a ZIP file, or it is a ZIP file with an archive + # comment. Search the end of the file for the "end of central directory" + # record signature. The comment is the last item in the ZIP file and may be + # up to 64K long. It is assumed that the "end of central directory" magic + # number does not appear in the comment. + maxCommentStart = max(filesize - (1 << 16) - sizeEndCentDir, 0) + fpin.seek(maxCommentStart, 0) + data = fpin.read() + start = data.rfind(stringEndArchive) + if start >= 0: + # found the magic number; attempt to unpack and interpret + recData = data[start:start+sizeEndCentDir] + if len(recData) != sizeEndCentDir: + # Zip file is corrupted. + return None + endrec = list(struct.unpack(structEndArchive, recData)) + commentSize = endrec[_ECD_COMMENT_SIZE] #as claimed by the zip file + comment = data[start+sizeEndCentDir:start+sizeEndCentDir+commentSize] + endrec.append(comment) + endrec.append(maxCommentStart + start) + + # Try to read the "Zip64 end of central directory" structure + return _EndRecData64(fpin, maxCommentStart + start, endrec) + + # Unable to find a valid end of central directory structure + return None + + +class ZipInfo (object): + """Class with attributes describing each file in the ZIP archive.""" + + __slots__ = ( + 'orig_filename', + 'filename', + 'date_time', + 'compress_type', + '_compresslevel', + 'comment', + 'extra', + 'create_system', + 'create_version', + 'extract_version', + 'reserved', + 'flag_bits', + 'volume', + 'internal_attr', + 'external_attr', + 'header_offset', + 'CRC', + 'compress_size', + 'file_size', + '_raw_time', + '_end_offset', + ) + + def __init__(self, filename="NoName", date_time=(1980,1,1,0,0,0)): + self.orig_filename = filename # Original file name in archive + + # Terminate the file name at the first null byte. Null bytes in file + # names are used as tricks by viruses in archives. + null_byte = filename.find(chr(0)) + if null_byte >= 0: + filename = filename[0:null_byte] + # This is used to ensure paths in generated ZIP files always use + # forward slashes as the directory separator, as required by the + # ZIP format specification. + if os.sep != "/" and os.sep in filename: + filename = filename.replace(os.sep, "/") + + self.filename = filename # Normalized file name + self.date_time = date_time # year, month, day, hour, min, sec + + if date_time[0] < 1980: + raise ValueError('ZIP does not support timestamps before 1980') + + # Standard values: + self.compress_type = ZIP_STORED # Type of compression for the file + self._compresslevel = None # Level for the compressor + self.comment = b"" # Comment for each file + self.extra = b"" # ZIP extra data + if sys.platform == 'win32': + self.create_system = 0 # System which created ZIP archive + else: + # Assume everything else is unix-y + self.create_system = 3 # System which created ZIP archive + self.create_version = DEFAULT_VERSION # Version which created ZIP archive + self.extract_version = DEFAULT_VERSION # Version needed to extract archive + self.reserved = 0 # Must be zero + self.flag_bits = 0 # ZIP flag bits + self.volume = 0 # Volume number of file header + self.internal_attr = 0 # Internal attributes + self.external_attr = 0 # External file attributes + self.compress_size = 0 # Size of the compressed file + self.file_size = 0 # Size of the uncompressed file + self._end_offset = None # Start of the next local header or central directory + # Other attributes are set by class ZipFile: + # header_offset Byte offset to the file header + # CRC CRC-32 of the uncompressed file + + def __repr__(self): + result = ['<%s filename=%r' % (self.__class__.__name__, self.filename)] + if self.compress_type != ZIP_STORED: + result.append(' compress_type=%s' % + compressor_names.get(self.compress_type, + self.compress_type)) + hi = self.external_attr >> 16 + lo = self.external_attr & 0xFFFF + if hi: + result.append(' filemode=%r' % stat.filemode(hi)) + if lo: + result.append(' external_attr=%#x' % lo) + isdir = self.is_dir() + if not isdir or self.file_size: + result.append(' file_size=%r' % self.file_size) + if ((not isdir or self.compress_size) and + (self.compress_type != ZIP_STORED or + self.file_size != self.compress_size)): + result.append(' compress_size=%r' % self.compress_size) + result.append('>') + return ''.join(result) + + def FileHeader(self, zip64=None): + """Return the per-file header as a bytes object. + + When the optional zip64 arg is None rather than a bool, we will + decide based upon the file_size and compress_size, if known, + False otherwise. + """ + dt = self.date_time + dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2] + dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2) + if self.flag_bits & _MASK_USE_DATA_DESCRIPTOR: + # Set these to zero because we write them after the file data + CRC = compress_size = file_size = 0 + else: + CRC = self.CRC + compress_size = self.compress_size + file_size = self.file_size + + extra = self.extra + + min_version = 0 + if zip64 is None: + # We always explicitly pass zip64 within this module.... This + # remains for anyone using ZipInfo.FileHeader as a public API. + zip64 = file_size > ZIP64_LIMIT or compress_size > ZIP64_LIMIT + if zip64: + fmt = '= 4: + tp, ln = unpack(' len(extra): + raise BadZipFile("Corrupt extra field %04x (size=%d)" % (tp, ln)) + if tp == 0x0001: + data = extra[4:ln+4] + # ZIP64 extension (large files and/or large archives) + try: + if self.file_size in (0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF): + field = "File size" + self.file_size, = unpack(' 2107: + date_time = (2107, 12, 31, 23, 59, 59) + # Create ZipInfo instance to store file information + if arcname is None: + arcname = filename + arcname = os.path.normpath(os.path.splitdrive(arcname)[1]) + while arcname[0] in (os.sep, os.altsep): + arcname = arcname[1:] + if isdir: + arcname += '/' + zinfo = cls(arcname, date_time) + zinfo.external_attr = (st.st_mode & 0xFFFF) << 16 # Unix attributes + if isdir: + zinfo.file_size = 0 + zinfo.external_attr |= 0x10 # MS-DOS directory flag + else: + zinfo.file_size = st.st_size + + return zinfo + + def is_dir(self): + """Return True if this archive member is a directory.""" + if self.filename.endswith('/'): + return True + # The ZIP format specification requires to use forward slashes + # as the directory separator, but in practice some ZIP files + # created on Windows can use backward slashes. For compatibility + # with the extraction code which already handles this: + if os.path.altsep: + return self.filename.endswith((os.path.sep, os.path.altsep)) + return False + + +# ZIP encryption uses the CRC32 one-byte primitive for scrambling some +# internal keys. We noticed that a direct implementation is faster than +# relying on binascii.crc32(). + +_crctable = None +def _gen_crc(crc): + for j in range(8): + if crc & 1: + crc = (crc >> 1) ^ 0xEDB88320 + else: + crc >>= 1 + return crc + +# ZIP supports a password-based form of encryption. Even though known +# plaintext attacks have been found against it, it is still useful +# to be able to get data out of such a file. +# +# Usage: +# zd = _ZipDecrypter(mypwd) +# plain_bytes = zd(cypher_bytes) + +def _ZipDecrypter(pwd): + key0 = 305419896 + key1 = 591751049 + key2 = 878082192 + + global _crctable + if _crctable is None: + _crctable = list(map(_gen_crc, range(256))) + crctable = _crctable + + def crc32(ch, crc): + """Compute the CRC32 primitive on one byte.""" + return (crc >> 8) ^ crctable[(crc ^ ch) & 0xFF] + + def update_keys(c): + nonlocal key0, key1, key2 + key0 = crc32(c, key0) + key1 = (key1 + (key0 & 0xFF)) & 0xFFFFFFFF + key1 = (key1 * 134775813 + 1) & 0xFFFFFFFF + key2 = crc32(key1 >> 24, key2) + + for p in pwd: + update_keys(p) + + def decrypter(data): + """Decrypt a bytes object.""" + result = bytearray() + append = result.append + for c in data: + k = key2 | 2 + c ^= ((k * (k^1)) >> 8) & 0xFF + update_keys(c) + append(c) + return bytes(result) + + return decrypter + + +class LZMACompressor: + + def __init__(self): + self._comp = None + + def _init(self): + props = lzma._encode_filter_properties({'id': lzma.FILTER_LZMA1}) + self._comp = lzma.LZMACompressor(lzma.FORMAT_RAW, filters=[ + lzma._decode_filter_properties(lzma.FILTER_LZMA1, props) + ]) + return struct.pack('> 8) & 0xff + else: + # compare against the CRC otherwise + check_byte = (zipinfo.CRC >> 24) & 0xff + h = self._init_decrypter() + if h != check_byte: + raise RuntimeError("Bad password for file %r" % zipinfo.orig_filename) + + + def _init_decrypter(self): + self._decrypter = _ZipDecrypter(self._pwd) + # The first 12 bytes in the cypher stream is an encryption header + # used to strengthen the algorithm. The first 11 bytes are + # completely random, while the 12th contains the MSB of the CRC, + # or the MSB of the file time depending on the header type + # and is used to check the correctness of the password. + header = self._fileobj.read(12) + self._compress_left -= 12 + return self._decrypter(header)[11] + + def __repr__(self): + result = ['<%s.%s' % (self.__class__.__module__, + self.__class__.__qualname__)] + if not self.closed: + result.append(' name=%r mode=%r' % (self.name, self.mode)) + if self._compress_type != ZIP_STORED: + result.append(' compress_type=%s' % + compressor_names.get(self._compress_type, + self._compress_type)) + else: + result.append(' [closed]') + result.append('>') + return ''.join(result) + + def readline(self, limit=-1): + """Read and return a line from the stream. + + If limit is specified, at most limit bytes will be read. + """ + + if limit < 0: + # Shortcut common case - newline found in buffer. + i = self._readbuffer.find(b'\n', self._offset) + 1 + if i > 0: + line = self._readbuffer[self._offset: i] + self._offset = i + return line + + return io.BufferedIOBase.readline(self, limit) + + def peek(self, n=1): + """Returns buffered bytes without advancing the position.""" + if n > len(self._readbuffer) - self._offset: + chunk = self.read(n) + if len(chunk) > self._offset: + self._readbuffer = chunk + self._readbuffer[self._offset:] + self._offset = 0 + else: + self._offset -= len(chunk) + + # Return up to 512 bytes to reduce allocation overhead for tight loops. + return self._readbuffer[self._offset: self._offset + 512] + + def readable(self): + if self.closed: + raise ValueError("I/O operation on closed file.") + return True + + def read(self, n=-1): + """Read and return up to n bytes. + If the argument is omitted, None, or negative, data is read and returned until EOF is reached. + """ + if self.closed: + raise ValueError("read from closed file.") + if n is None or n < 0: + buf = self._readbuffer[self._offset:] + self._readbuffer = b'' + self._offset = 0 + while not self._eof: + buf += self._read1(self.MAX_N) + return buf + + end = n + self._offset + if end < len(self._readbuffer): + buf = self._readbuffer[self._offset:end] + self._offset = end + return buf + + n = end - len(self._readbuffer) + buf = self._readbuffer[self._offset:] + self._readbuffer = b'' + self._offset = 0 + while n > 0 and not self._eof: + data = self._read1(n) + if n < len(data): + self._readbuffer = data + self._offset = n + buf += data[:n] + break + buf += data + n -= len(data) + return buf + + def _update_crc(self, newdata): + # Update the CRC using the given data. + if self._expected_crc is None: + # No need to compute the CRC if we don't have a reference value + return + self._running_crc = crc32(newdata, self._running_crc) + # Check the CRC if we're at the end of the file + if self._eof and self._running_crc != self._expected_crc: + raise BadZipFile("Bad CRC-32 for file %r" % self.name) + + def read1(self, n): + """Read up to n bytes with at most one read() system call.""" + + if n is None or n < 0: + buf = self._readbuffer[self._offset:] + self._readbuffer = b'' + self._offset = 0 + while not self._eof: + data = self._read1(self.MAX_N) + if data: + buf += data + break + return buf + + end = n + self._offset + if end < len(self._readbuffer): + buf = self._readbuffer[self._offset:end] + self._offset = end + return buf + + n = end - len(self._readbuffer) + buf = self._readbuffer[self._offset:] + self._readbuffer = b'' + self._offset = 0 + if n > 0: + while not self._eof: + data = self._read1(n) + if n < len(data): + self._readbuffer = data + self._offset = n + buf += data[:n] + break + if data: + buf += data + break + return buf + + def _read1(self, n): + # Read up to n compressed bytes with at most one read() system call, + # decrypt and decompress them. + if self._eof or n <= 0: + return b'' + + # Read from file. + if self._compress_type == ZIP_DEFLATED: + ## Handle unconsumed data. + data = self._decompressor.unconsumed_tail + if n > len(data): + data += self._read2(n - len(data)) + elif self._compress_type == ZIP_STORED: + data = self._read2(n) + else: + # bzip2/lzma/zstd: a bounded decompress() call may leave input + # buffered inside the decompressor; drain that before reading more. + if getattr(self._decompressor, "needs_input", True): + data = self._read2(n) + else: + data = b'' + + if self._compress_type == ZIP_STORED: + self._eof = self._compress_left <= 0 + elif self._compress_type == ZIP_DEFLATED: + n = max(n, self.MIN_READ_SIZE) + data = self._decompressor.decompress(data, n) + self._eof = (self._decompressor.eof or + self._compress_left <= 0 and + not self._decompressor.unconsumed_tail) + if self._eof: + data += self._decompressor.flush() + else: + # Bound the output of a single decompress() call (mirroring the + # DEFLATE path above) so that a small compressed member cannot + # expand into one unbounded read. + try: + data = self._decompressor.decompress(data, max(n, self.MIN_READ_SIZE)) + except TypeError: + # See MonkeypatchedDecompressorTests in test_core.py + data = self._decompressor.decompress(data) + self._eof = (self._decompressor.eof or + self._compress_left <= 0 and + getattr(self._decompressor, "needs_input", True)) + + data = data[:self._left] + self._left -= len(data) + if self._left <= 0: + self._eof = True + self._update_crc(data) + return data + + def _read2(self, n): + if self._compress_left <= 0: + return b'' + + n = max(n, self.MIN_READ_SIZE) + n = min(n, self._compress_left) + + data = self._fileobj.read(n) + self._compress_left -= len(data) + if not data: + raise EOFError + + if self._decrypter is not None: + data = self._decrypter(data) + return data + + def close(self): + try: + if self._close_fileobj: + self._fileobj.close() + finally: + super().close() + + def seekable(self): + if self.closed: + raise ValueError("I/O operation on closed file.") + return self._seekable + + def seek(self, offset, whence=0): + if self.closed: + raise ValueError("seek on closed file.") + if not self._seekable: + raise io.UnsupportedOperation("underlying stream is not seekable") + curr_pos = self.tell() + if whence == 0: # Seek from start of file + new_pos = offset + elif whence == 1: # Seek from current position + new_pos = curr_pos + offset + elif whence == 2: # Seek from EOF + new_pos = self._orig_file_size + offset + else: + raise ValueError("whence must be os.SEEK_SET (0), " + "os.SEEK_CUR (1), or os.SEEK_END (2)") + + if new_pos > self._orig_file_size: + new_pos = self._orig_file_size + + if new_pos < 0: + new_pos = 0 + + read_offset = new_pos - curr_pos + buff_offset = read_offset + self._offset + + if buff_offset >= 0 and buff_offset < len(self._readbuffer): + # Just move the _offset index if the new position is in the _readbuffer + self._offset = buff_offset + read_offset = 0 + elif read_offset < 0: + # Position is before the current position. Reset the ZipExtFile + self._fileobj.seek(self._orig_compress_start) + self._running_crc = self._orig_start_crc + self._compress_left = self._orig_compress_size + self._left = self._orig_file_size + self._readbuffer = b'' + self._offset = 0 + self._decompressor = _get_decompressor(self._compress_type) + self._eof = False + read_offset = new_pos + if self._decrypter is not None: + self._init_decrypter() + + while read_offset > 0: + read_len = min(self.MAX_SEEK_READ, read_offset) + self.read(read_len) + read_offset -= read_len + + return self.tell() + + def tell(self): + if self.closed: + raise ValueError("tell on closed file.") + if not self._seekable: + raise io.UnsupportedOperation("underlying stream is not seekable") + filepos = self._orig_file_size - self._left - len(self._readbuffer) + self._offset + return filepos + + +class _ZipWriteFile(io.BufferedIOBase): + def __init__(self, zf, zinfo, zip64): + self._zinfo = zinfo + self._zip64 = zip64 + self._zipfile = zf + self._compressor = _get_compressor(zinfo.compress_type, + zinfo._compresslevel) + self._file_size = 0 + self._compress_size = 0 + self._crc = 0 + + @property + def _fileobj(self): + return self._zipfile.fp + + def writable(self): + return True + + def write(self, data): + if self.closed: + raise ValueError('I/O operation on closed file.') + + # Accept any data that supports the buffer protocol + if isinstance(data, (bytes, bytearray)): + nbytes = len(data) + else: + data = memoryview(data) + nbytes = data.nbytes + self._file_size += nbytes + + self._crc = crc32(data, self._crc) + if self._compressor: + data = self._compressor.compress(data) + self._compress_size += len(data) + self._fileobj.write(data) + return nbytes + + def close(self): + if self.closed: + return + try: + super().close() + # Flush any data from the compressor, and update header info + if self._compressor: + buf = self._compressor.flush() + self._compress_size += len(buf) + self._fileobj.write(buf) + self._zinfo.compress_size = self._compress_size + else: + self._zinfo.compress_size = self._file_size + self._zinfo.CRC = self._crc + self._zinfo.file_size = self._file_size + + if not self._zip64: + if self._file_size > ZIP64_LIMIT: + raise RuntimeError("File size too large, try using force_zip64") + if self._compress_size > ZIP64_LIMIT: + raise RuntimeError("Compressed size too large, try using force_zip64") + + # Write updated header info + if self._zinfo.flag_bits & _MASK_USE_DATA_DESCRIPTOR: + # Write CRC and file sizes after the file data + fmt = '') + return ''.join(result) + + def _RealGetContents(self): + """Read in the table of contents for the ZIP file.""" + fp = self.fp + try: + endrec = _EndRecData(fp) + except OSError: + raise BadZipFile("File is not a zip file") + if not endrec: + raise BadZipFile("File is not a zip file") + if self.debug > 1: + print(endrec) + size_cd = endrec[_ECD_SIZE] # bytes in central directory + offset_cd = endrec[_ECD_OFFSET] # offset of central directory + self._comment = endrec[_ECD_COMMENT] # archive comment + + # "concat" is zero, unless zip was concatenated to another file + concat = endrec[_ECD_LOCATION] - size_cd - offset_cd + + if self.debug > 2: + inferred = concat + offset_cd + print("given, inferred, offset", offset_cd, inferred, concat) + # self.start_dir: Position of start of central directory + self.start_dir = offset_cd + concat + if self.start_dir < 0: + raise BadZipFile("Bad offset for central directory") + fp.seek(self.start_dir, 0) + data = fp.read(size_cd) + fp = io.BytesIO(data) + total = 0 + while total < size_cd: + centdir = fp.read(sizeCentralDir) + if len(centdir) != sizeCentralDir: + raise BadZipFile("Truncated central directory") + centdir = struct.unpack(structCentralDir, centdir) + if centdir[_CD_SIGNATURE] != stringCentralDir: + raise BadZipFile("Bad magic number for central directory") + if self.debug > 2: + print(centdir) + filename = fp.read(centdir[_CD_FILENAME_LENGTH]) + flags = centdir[_CD_FLAG_BITS] + if flags & _MASK_UTF_FILENAME: + # UTF-8 file names extension + filename = filename.decode('utf-8') + else: + # Historical ZIP filename encoding + filename = filename.decode(self.metadata_encoding or 'cp437') + # Create ZipInfo instance to store file information + x = ZipInfo(filename) + x.extra = fp.read(centdir[_CD_EXTRA_FIELD_LENGTH]) + x.comment = fp.read(centdir[_CD_COMMENT_LENGTH]) + x.header_offset = centdir[_CD_LOCAL_HEADER_OFFSET] + (x.create_version, x.create_system, x.extract_version, x.reserved, + x.flag_bits, x.compress_type, t, d, + x.CRC, x.compress_size, x.file_size) = centdir[1:12] + if x.extract_version > MAX_EXTRACT_VERSION: + raise NotImplementedError("zip file version %.1f" % + (x.extract_version / 10)) + x.volume, x.internal_attr, x.external_attr = centdir[15:18] + # Convert date/time code to (year, month, day, hour, min, sec) + x._raw_time = t + x.date_time = ( (d>>9)+1980, (d>>5)&0xF, d&0x1F, + t>>11, (t>>5)&0x3F, (t&0x1F) * 2 ) + + x._decodeExtra() + x.header_offset = x.header_offset + concat + self.filelist.append(x) + self.NameToInfo[x.filename] = x + + # update total bytes read from central directory + total = (total + sizeCentralDir + centdir[_CD_FILENAME_LENGTH] + + centdir[_CD_EXTRA_FIELD_LENGTH] + + centdir[_CD_COMMENT_LENGTH]) + + if self.debug > 2: + print("total", total) + + end_offset = self.start_dir + for zinfo in sorted(self.filelist, + key=lambda zinfo: zinfo.header_offset, + reverse=True): + zinfo._end_offset = end_offset + end_offset = zinfo.header_offset + + def namelist(self): + """Return a list of file names in the archive.""" + return [data.filename for data in self.filelist] + + def infolist(self): + """Return a list of class ZipInfo instances for files in the + archive.""" + return self.filelist + + def printdir(self, file=None): + """Print a table of contents for the zip file.""" + print("%-46s %19s %12s" % ("File Name", "Modified ", "Size"), + file=file) + for zinfo in self.filelist: + date = "%d-%02d-%02d %02d:%02d:%02d" % zinfo.date_time[:6] + print("%-46s %s %12d" % (zinfo.filename, date, zinfo.file_size), + file=file) + + def testzip(self): + """Read all the files and check the CRC.""" + chunk_size = 2 ** 20 + for zinfo in self.filelist: + try: + # Read by chunks, to avoid an OverflowError or a + # MemoryError with very large embedded files. + with self.open(zinfo.filename, "r") as f: + while f.read(chunk_size): # Check CRC-32 + pass + except BadZipFile: + return zinfo.filename + + def getinfo(self, name): + """Return the instance of ZipInfo given 'name'.""" + info = self.NameToInfo.get(name) + if info is None: + raise KeyError( + 'There is no item named %r in the archive' % name) + + return info + + def setpassword(self, pwd): + """Set default password for encrypted files.""" + if pwd and not isinstance(pwd, bytes): + raise TypeError("pwd: expected bytes, got %s" % type(pwd).__name__) + if pwd: + self.pwd = pwd + else: + self.pwd = None + + @property + def comment(self): + """The comment text associated with the ZIP file.""" + return self._comment + + @comment.setter + def comment(self, comment): + if not isinstance(comment, bytes): + raise TypeError("comment: expected bytes, got %s" % type(comment).__name__) + # check for valid comment length + if len(comment) > ZIP_MAX_COMMENT: + import warnings + warnings.warn('Archive comment is too long; truncating to %d bytes' + % ZIP_MAX_COMMENT, stacklevel=2) + comment = comment[:ZIP_MAX_COMMENT] + self._comment = comment + self._didModify = True + + def read(self, name, pwd=None): + """Return file bytes for name.""" + with self.open(name, "r", pwd) as fp: + return fp.read() + + def open(self, name, mode="r", pwd=None, *, force_zip64=False): + """Return file-like object for 'name'. + + name is a string for the file name within the ZIP file, or a ZipInfo + object. + + mode should be 'r' to read a file already in the ZIP file, or 'w' to + write to a file newly added to the archive. + + pwd is the password to decrypt files (only used for reading). + + When writing, if the file size is not known in advance but may exceed + 2 GiB, pass force_zip64 to use the ZIP64 format, which can handle large + files. If the size is known in advance, it is best to pass a ZipInfo + instance for name, with zinfo.file_size set. + """ + if mode not in {"r", "w"}: + raise ValueError('open() requires mode "r" or "w"') + if pwd and (mode == "w"): + raise ValueError("pwd is only supported for reading files") + if not self.fp: + raise ValueError( + "Attempt to use ZIP archive that was already closed") + + # Make sure we have an info object + if isinstance(name, ZipInfo): + # 'name' is already an info object + zinfo = name + elif mode == 'w': + zinfo = ZipInfo(name) + zinfo.compress_type = self.compression + zinfo._compresslevel = self.compresslevel + else: + # Get info object for name + zinfo = self.getinfo(name) + + if mode == 'w': + return self._open_to_write(zinfo, force_zip64=force_zip64) + + if self._writing: + raise ValueError("Can't read from the ZIP file while there " + "is an open writing handle on it. " + "Close the writing handle before trying to read.") + + # Open for reading: + self._fileRefCnt += 1 + zef_file = _SharedFile(self.fp, zinfo.header_offset, + self._fpclose, self._lock, lambda: self._writing) + try: + # Skip the file header: + fheader = zef_file.read(sizeFileHeader) + if len(fheader) != sizeFileHeader: + raise BadZipFile("Truncated file header") + fheader = struct.unpack(structFileHeader, fheader) + if fheader[_FH_SIGNATURE] != stringFileHeader: + raise BadZipFile("Bad magic number for file header") + + fname = zef_file.read(fheader[_FH_FILENAME_LENGTH]) + if fheader[_FH_EXTRA_FIELD_LENGTH]: + zef_file.read(fheader[_FH_EXTRA_FIELD_LENGTH]) + + if zinfo.flag_bits & _MASK_COMPRESSED_PATCH: + # Zip 2.7: compressed patched data + raise NotImplementedError("compressed patched data (flag bit 5)") + + if zinfo.flag_bits & _MASK_STRONG_ENCRYPTION: + # strong encryption + raise NotImplementedError("strong encryption (flag bit 6)") + + if fheader[_FH_GENERAL_PURPOSE_FLAG_BITS] & _MASK_UTF_FILENAME: + # UTF-8 filename + fname_str = fname.decode("utf-8") + else: + fname_str = fname.decode(self.metadata_encoding or "cp437") + + if fname_str != zinfo.orig_filename: + raise BadZipFile( + 'File name in directory %r and header %r differ.' + % (zinfo.orig_filename, fname)) + + if (zinfo._end_offset is not None and + zef_file.tell() + zinfo.compress_size > zinfo._end_offset): + raise BadZipFile(f"Overlapped entries: {zinfo.orig_filename!r} (possible zip bomb)") + + # check for encrypted flag & handle password + is_encrypted = zinfo.flag_bits & _MASK_ENCRYPTED + if is_encrypted: + if not pwd: + pwd = self.pwd + if pwd and not isinstance(pwd, bytes): + raise TypeError("pwd: expected bytes, got %s" % type(pwd).__name__) + if not pwd: + raise RuntimeError("File %r is encrypted, password " + "required for extraction" % name) + else: + pwd = None + + return ZipExtFile(zef_file, mode, zinfo, pwd, True) + except: + zef_file.close() + raise + + def _open_to_write(self, zinfo, force_zip64=False): + if force_zip64 and not self._allowZip64: + raise ValueError( + "force_zip64 is True, but allowZip64 was False when opening " + "the ZIP file." + ) + if self._writing: + raise ValueError("Can't write to the ZIP file while there is " + "another write handle open on it. " + "Close the first handle before opening another.") + + # Size and CRC are overwritten with correct data after processing the file + zinfo.compress_size = 0 + zinfo.CRC = 0 + + zinfo.flag_bits = 0x00 + if zinfo.compress_type == ZIP_LZMA: + # Compressed data includes an end-of-stream (EOS) marker + zinfo.flag_bits |= _MASK_COMPRESS_OPTION_1 + if not self._seekable: + zinfo.flag_bits |= _MASK_USE_DATA_DESCRIPTOR + + if not zinfo.external_attr: + zinfo.external_attr = 0o600 << 16 # permissions: ?rw------- + + # Compressed size can be larger than uncompressed size + zip64 = force_zip64 or (zinfo.file_size * 1.05 > ZIP64_LIMIT) + if not self._allowZip64 and zip64: + raise LargeZipFile("Filesize would require ZIP64 extensions") + + if self._seekable: + self.fp.seek(self.start_dir) + zinfo.header_offset = self.fp.tell() + + self._writecheck(zinfo) + self._didModify = True + + self.fp.write(zinfo.FileHeader(zip64)) + + self._writing = True + return _ZipWriteFile(self, zinfo, zip64) + + def extract(self, member, path=None, pwd=None): + """Extract a member from the archive to the current working directory, + using its full name. Its file information is extracted as accurately + as possible. `member' may be a filename or a ZipInfo object. You can + specify a different directory using `path'. + """ + if path is None: + path = os.getcwd() + else: + path = os.fspath(path) + + return self._extract_member(member, path, pwd) + + def extractall(self, path=None, members=None, pwd=None): + """Extract all members from the archive to the current working + directory. `path' specifies a different directory to extract to. + `members' is optional and must be a subset of the list returned + by namelist(). + """ + if members is None: + members = self.namelist() + + if path is None: + path = os.getcwd() + else: + path = os.fspath(path) + + for zipinfo in members: + self._extract_member(zipinfo, path, pwd) + + @classmethod + def _sanitize_windows_name(cls, arcname, pathsep): + """Replace bad characters and remove trailing dots from parts.""" + table = cls._windows_illegal_name_trans_table + if not table: + illegal = ':<>|"?*' + table = str.maketrans(illegal, '_' * len(illegal)) + cls._windows_illegal_name_trans_table = table + arcname = arcname.translate(table) + # remove trailing dots + arcname = (x.rstrip('.') for x in arcname.split(pathsep)) + # rejoin, removing empty parts. + arcname = pathsep.join(x for x in arcname if x) + return arcname + + def _extract_member(self, member, targetpath, pwd): + """Extract the ZipInfo object 'member' to a physical + file on the path targetpath. + """ + if not isinstance(member, ZipInfo): + member = self.getinfo(member) + + # build the destination pathname, replacing + # forward slashes to platform specific separators. + arcname = member.filename + if os.path.sep != '/': + arcname = arcname.replace('/', os.path.sep) + if os.path.altsep and os.path.altsep != '/': + arcname = arcname.replace(os.path.altsep, os.path.sep) + # interpret absolute pathname as relative, remove drive letter or + # UNC path, redundant separators, "." and ".." components. + drive, arcname = os.path.splitdrive(arcname) + if self._ignore_invalid_names and (drive or arcname.startswith(os.path.sep)): + return None + if self._ignore_invalid_names and os.path.pardir in arcname.split(os.path.sep): + return None + invalid_path_parts = ('', os.path.curdir, os.path.pardir) + arcname = os.path.sep.join(x for x in arcname.split(os.path.sep) + if x not in invalid_path_parts) + if os.path.sep == '\\': + # filter illegal characters on Windows + arcname2 = self._sanitize_windows_name(arcname, os.path.sep) + if self._ignore_invalid_names and arcname2 != arcname: + return None + arcname = arcname2 + + targetpath = os.path.join(targetpath, arcname) + targetpath = os.path.normpath(targetpath) + + # Create all upper directories if necessary. + upperdirs = os.path.dirname(targetpath) + if upperdirs and not os.path.exists(upperdirs): + os.makedirs(upperdirs) + + if member.is_dir(): + if not os.path.isdir(targetpath): + os.mkdir(targetpath) + return targetpath + + with self.open(member, pwd=pwd) as source, \ + open(targetpath, "wb") as target: + shutil.copyfileobj(source, target) + + return targetpath + + def _writecheck(self, zinfo): + """Check for errors before writing a file to the archive.""" + if zinfo.filename in self.NameToInfo: + import warnings + warnings.warn('Duplicate name: %r' % zinfo.filename, stacklevel=3) + if self.mode not in ('w', 'x', 'a'): + raise ValueError("write() requires mode 'w', 'x', or 'a'") + if not self.fp: + raise ValueError( + "Attempt to write ZIP archive that was already closed") + _check_compression(zinfo.compress_type) + if not self._allowZip64: + requires_zip64 = None + if len(self.filelist) >= ZIP_FILECOUNT_LIMIT: + requires_zip64 = "Files count" + elif zinfo.file_size > ZIP64_LIMIT: + requires_zip64 = "Filesize" + elif zinfo.header_offset > ZIP64_LIMIT: + requires_zip64 = "Zipfile size" + if requires_zip64: + raise LargeZipFile(requires_zip64 + + " would require ZIP64 extensions") + + def write(self, filename, arcname=None, + compress_type=None, compresslevel=None): + """Put the bytes from filename into the archive under the name + arcname.""" + if not self.fp: + raise ValueError( + "Attempt to write to ZIP archive that was already closed") + if self._writing: + raise ValueError( + "Can't write to ZIP archive while an open writing handle exists" + ) + + zinfo = ZipInfo.from_file(filename, arcname, + strict_timestamps=self._strict_timestamps) + + if zinfo.is_dir(): + zinfo.compress_size = 0 + zinfo.CRC = 0 + self.mkdir(zinfo) + else: + if compress_type is not None: + zinfo.compress_type = compress_type + else: + zinfo.compress_type = self.compression + + if compresslevel is not None: + zinfo._compresslevel = compresslevel + else: + zinfo._compresslevel = self.compresslevel + + with open(filename, "rb") as src, self.open(zinfo, 'w') as dest: + shutil.copyfileobj(src, dest, 1024*8) + + def writestr(self, zinfo_or_arcname, data, + compress_type=None, compresslevel=None): + """Write a file into the archive. The contents is 'data', which + may be either a 'str' or a 'bytes' instance; if it is a 'str', + it is encoded as UTF-8 first. + 'zinfo_or_arcname' is either a ZipInfo instance or + the name of the file in the archive.""" + if isinstance(data, str): + data = data.encode("utf-8") + if not isinstance(zinfo_or_arcname, ZipInfo): + zinfo = ZipInfo(filename=zinfo_or_arcname, + date_time=time.localtime(time.time())[:6]) + zinfo.compress_type = self.compression + zinfo._compresslevel = self.compresslevel + if zinfo.filename[-1] == '/': + zinfo.external_attr = 0o40775 << 16 # drwxrwxr-x + zinfo.external_attr |= 0x10 # MS-DOS directory flag + else: + zinfo.external_attr = 0o600 << 16 # ?rw------- + else: + zinfo = zinfo_or_arcname + + if not self.fp: + raise ValueError( + "Attempt to write to ZIP archive that was already closed") + if self._writing: + raise ValueError( + "Can't write to ZIP archive while an open writing handle exists." + ) + + if compress_type is not None: + zinfo.compress_type = compress_type + + if compresslevel is not None: + zinfo._compresslevel = compresslevel + + zinfo.file_size = len(data) # Uncompressed size + with self._lock: + with self.open(zinfo, mode='w') as dest: + dest.write(data) + + def mkdir(self, zinfo_or_directory_name, mode=511): + """Creates a directory inside the zip archive.""" + if isinstance(zinfo_or_directory_name, ZipInfo): + zinfo = zinfo_or_directory_name + if not zinfo.is_dir(): + raise ValueError("The given ZipInfo does not describe a directory") + elif isinstance(zinfo_or_directory_name, str): + directory_name = zinfo_or_directory_name + if not directory_name.endswith("/"): + directory_name += "/" + zinfo = ZipInfo(directory_name) + zinfo.compress_size = 0 + zinfo.CRC = 0 + zinfo.external_attr = ((0o40000 | mode) & 0xFFFF) << 16 + zinfo.file_size = 0 + zinfo.external_attr |= 0x10 + else: + raise TypeError("Expected type str or ZipInfo") + + with self._lock: + if self._seekable: + self.fp.seek(self.start_dir) + zinfo.header_offset = self.fp.tell() # Start of header bytes + if zinfo.compress_type == ZIP_LZMA: + # Compressed data includes an end-of-stream (EOS) marker + zinfo.flag_bits |= _MASK_COMPRESS_OPTION_1 + + self._writecheck(zinfo) + self._didModify = True + + self.filelist.append(zinfo) + self.NameToInfo[zinfo.filename] = zinfo + self.fp.write(zinfo.FileHeader(False)) + self.start_dir = self.fp.tell() + + def __del__(self): + """Call the "close()" method in case the user forgot.""" + self.close() + + def close(self): + """Close the file, and for mode 'w', 'x' and 'a' write the ending + records.""" + if self.fp is None: + return + + if self._writing: + raise ValueError("Can't close the ZIP file while there is " + "an open writing handle on it. " + "Close the writing handle before closing the zip.") + + try: + if self.mode in ('w', 'x', 'a') and self._didModify: # write ending records + with self._lock: + if self._seekable: + self.fp.seek(self.start_dir) + self._write_end_record() + finally: + fp = self.fp + self.fp = None + self._fpclose(fp) + + def _write_end_record(self): + for zinfo in self.filelist: # write central directory + dt = zinfo.date_time + dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2] + dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2) + extra = [] + if zinfo.file_size > ZIP64_LIMIT \ + or zinfo.compress_size > ZIP64_LIMIT: + extra.append(zinfo.file_size) + extra.append(zinfo.compress_size) + file_size = 0xffffffff + compress_size = 0xffffffff + else: + file_size = zinfo.file_size + compress_size = zinfo.compress_size + + if zinfo.header_offset > ZIP64_LIMIT: + extra.append(zinfo.header_offset) + header_offset = 0xffffffff + else: + header_offset = zinfo.header_offset + + extra_data = zinfo.extra + min_version = 0 + if extra: + # Append a ZIP64 field to the extra's + extra_data = _strip_extra(extra_data, (1,)) + extra_data = struct.pack( + ' ZIP_FILECOUNT_LIMIT: + requires_zip64 = "Files count" + elif centDirOffset > ZIP64_LIMIT: + requires_zip64 = "Central directory offset" + elif centDirSize > ZIP64_LIMIT: + requires_zip64 = "Central directory size" + if requires_zip64: + # Need to write the ZIP64 end-of-archive records + if not self._allowZip64: + raise LargeZipFile(requires_zip64 + + " would require ZIP64 extensions") + zip64endrec = struct.pack( + structEndArchive64, stringEndArchive64, + sizeEndCentDir64 - 12, 45, 45, 0, 0, centDirCount, centDirCount, + centDirSize, centDirOffset) + self.fp.write(zip64endrec) + + zip64locrec = struct.pack( + structEndArchive64Locator, + stringEndArchive64Locator, 0, pos2, 1) + self.fp.write(zip64locrec) + centDirCount = min(centDirCount, 0xFFFF) + centDirSize = min(centDirSize, 0xFFFFFFFF) + centDirOffset = min(centDirOffset, 0xFFFFFFFF) + + endrec = struct.pack(structEndArchive, stringEndArchive, + 0, 0, centDirCount, centDirCount, + centDirSize, centDirOffset, len(self._comment)) + self.fp.write(endrec) + self.fp.write(self._comment) + if self.mode == "a": + self.fp.truncate() + self.fp.flush() + + def _fpclose(self, fp): + assert self._fileRefCnt > 0 + self._fileRefCnt -= 1 + if not self._fileRefCnt and not self._filePassed: + fp.close() + + +class PyZipFile(ZipFile): + """Class to create ZIP archives with Python library files and packages.""" + + def __init__(self, file, mode="r", compression=ZIP_STORED, + allowZip64=True, optimize=-1): + ZipFile.__init__(self, file, mode=mode, compression=compression, + allowZip64=allowZip64) + self._optimize = optimize + + def writepy(self, pathname, basename="", filterfunc=None): + """Add all files from "pathname" to the ZIP archive. + + If pathname is a package directory, search the directory and + all package subdirectories recursively for all *.py and enter + the modules into the archive. If pathname is a plain + directory, listdir *.py and enter all modules. Else, pathname + must be a Python *.py file and the module will be put into the + archive. Added modules are always module.pyc. + This method will compile the module.py into module.pyc if + necessary. + If filterfunc(pathname) is given, it is called with every argument. + When it is False, the file or directory is skipped. + """ + pathname = os.fspath(pathname) + if filterfunc and not filterfunc(pathname): + if self.debug: + label = 'path' if os.path.isdir(pathname) else 'file' + print('%s %r skipped by filterfunc' % (label, pathname)) + return + dir, name = os.path.split(pathname) + if os.path.isdir(pathname): + initname = os.path.join(pathname, "__init__.py") + if os.path.isfile(initname): + # This is a package directory, add it + if basename: + basename = "%s/%s" % (basename, name) + else: + basename = name + if self.debug: + print("Adding package in", pathname, "as", basename) + fname, arcname = self._get_codename(initname[0:-3], basename) + if self.debug: + print("Adding", arcname) + self.write(fname, arcname) + dirlist = sorted(os.listdir(pathname)) + dirlist.remove("__init__.py") + # Add all *.py files and package subdirectories + for filename in dirlist: + path = os.path.join(pathname, filename) + root, ext = os.path.splitext(filename) + if os.path.isdir(path): + if os.path.isfile(os.path.join(path, "__init__.py")): + # This is a package directory, add it + self.writepy(path, basename, + filterfunc=filterfunc) # Recursive call + elif ext == ".py": + if filterfunc and not filterfunc(path): + if self.debug: + print('file %r skipped by filterfunc' % path) + continue + fname, arcname = self._get_codename(path[0:-3], + basename) + if self.debug: + print("Adding", arcname) + self.write(fname, arcname) + else: + # This is NOT a package directory, add its files at top level + if self.debug: + print("Adding files from directory", pathname) + for filename in sorted(os.listdir(pathname)): + path = os.path.join(pathname, filename) + root, ext = os.path.splitext(filename) + if ext == ".py": + if filterfunc and not filterfunc(path): + if self.debug: + print('file %r skipped by filterfunc' % path) + continue + fname, arcname = self._get_codename(path[0:-3], + basename) + if self.debug: + print("Adding", arcname) + self.write(fname, arcname) + else: + if pathname[-3:] != ".py": + raise RuntimeError( + 'Files added with writepy() must end with ".py"') + fname, arcname = self._get_codename(pathname[0:-3], basename) + if self.debug: + print("Adding file", arcname) + self.write(fname, arcname) + + def _get_codename(self, pathname, basename): + """Return (filename, archivename) for the path. + + Given a module name path, return the correct file path and + archive name, compiling if necessary. For example, given + /python/lib/string, return (/python/lib/string.pyc, string). + """ + def _compile(file, optimize=-1): + import py_compile + if self.debug: + print("Compiling", file) + try: + py_compile.compile(file, doraise=True, optimize=optimize) + except py_compile.PyCompileError as err: + print(err.msg) + return False + return True + + file_py = pathname + ".py" + file_pyc = pathname + ".pyc" + pycache_opt0 = importlib.util.cache_from_source(file_py, optimization='') + pycache_opt1 = importlib.util.cache_from_source(file_py, optimization=1) + pycache_opt2 = importlib.util.cache_from_source(file_py, optimization=2) + if self._optimize == -1: + # legacy mode: use whatever file is present + if (os.path.isfile(file_pyc) and + os.stat(file_pyc).st_mtime >= os.stat(file_py).st_mtime): + # Use .pyc file. + arcname = fname = file_pyc + elif (os.path.isfile(pycache_opt0) and + os.stat(pycache_opt0).st_mtime >= os.stat(file_py).st_mtime): + # Use the __pycache__/*.pyc file, but write it to the legacy pyc + # file name in the archive. + fname = pycache_opt0 + arcname = file_pyc + elif (os.path.isfile(pycache_opt1) and + os.stat(pycache_opt1).st_mtime >= os.stat(file_py).st_mtime): + # Use the __pycache__/*.pyc file, but write it to the legacy pyc + # file name in the archive. + fname = pycache_opt1 + arcname = file_pyc + elif (os.path.isfile(pycache_opt2) and + os.stat(pycache_opt2).st_mtime >= os.stat(file_py).st_mtime): + # Use the __pycache__/*.pyc file, but write it to the legacy pyc + # file name in the archive. + fname = pycache_opt2 + arcname = file_pyc + else: + # Compile py into PEP 3147 pyc file. + if _compile(file_py): + if sys.flags.optimize == 0: + fname = pycache_opt0 + elif sys.flags.optimize == 1: + fname = pycache_opt1 + else: + fname = pycache_opt2 + arcname = file_pyc + else: + fname = arcname = file_py + else: + # new mode: use given optimization level + if self._optimize == 0: + fname = pycache_opt0 + arcname = file_pyc + else: + arcname = file_pyc + if self._optimize == 1: + fname = pycache_opt1 + elif self._optimize == 2: + fname = pycache_opt2 + else: + msg = "invalid value for 'optimize': {!r}".format(self._optimize) + raise ValueError(msg) + if not (os.path.isfile(fname) and + os.stat(fname).st_mtime >= os.stat(file_py).st_mtime): + if not _compile(file_py, optimize=self._optimize): + fname = arcname = file_py + archivename = os.path.split(arcname)[1] + if basename: + archivename = "%s/%s" % (basename, archivename) + return (fname, archivename) + + +def _parents(path): + """ + Given a path with elements separated by + posixpath.sep, generate all parents of that path. + + >>> list(_parents('b/d')) + ['b'] + >>> list(_parents('/b/d/')) + ['/b'] + >>> list(_parents('b/d/f/')) + ['b/d', 'b'] + >>> list(_parents('b')) + [] + >>> list(_parents('')) + [] + """ + return itertools.islice(_ancestry(path), 1, None) + + +def _ancestry(path): + """ + Given a path with elements separated by + posixpath.sep, generate all elements of that path. + + >>> list(_ancestry('b/d')) + ['b/d', 'b'] + >>> list(_ancestry('/b/d/')) + ['/b/d', '/b'] + >>> list(_ancestry('b/d/f/')) + ['b/d/f', 'b/d', 'b'] + >>> list(_ancestry('b')) + ['b'] + >>> list(_ancestry('')) + [] + + Multiple separators are treated like a single. + + >>> list(_ancestry('//b//d///f//')) + ['//b//d///f', '//b//d', '//b'] + """ + path = path.rstrip(posixpath.sep) + while path.rstrip(posixpath.sep): + yield path + path, tail = posixpath.split(path) + + +_dedupe = dict.fromkeys +"""Deduplicate an iterable in original order""" + + +def _difference(minuend, subtrahend): + """ + Return items in minuend not in subtrahend, retaining order + with O(1) lookup. + """ + return itertools.filterfalse(set(subtrahend).__contains__, minuend) + + +class CompleteDirs(ZipFile): + """ + A ZipFile subclass that ensures that implied directories + are always included in the namelist. + """ + + @staticmethod + def _implied_dirs(names): + parents = itertools.chain.from_iterable(map(_parents, names)) + as_dirs = (p + posixpath.sep for p in parents) + return _dedupe(_difference(as_dirs, names)) + + def namelist(self): + names = super(CompleteDirs, self).namelist() + return names + list(self._implied_dirs(names)) + + def _name_set(self): + return set(self.namelist()) + + def resolve_dir(self, name): + """ + If the name represents a directory, return that name + as a directory (with the trailing slash). + """ + names = self._name_set() + dirname = name + '/' + dir_match = name not in names and dirname in names + return dirname if dir_match else name + + def getinfo(self, name): + """ + Supplement getinfo for implied dirs. + """ + try: + return super().getinfo(name) + except KeyError: + if not name.endswith('/') or name not in self._name_set(): + raise + return ZipInfo(filename=name) + + @classmethod + def make(cls, source): + """ + Given a source (filename or zipfile), return an + appropriate CompleteDirs subclass. + """ + if isinstance(source, CompleteDirs): + return source + + if not isinstance(source, ZipFile): + return cls(source) + + # Only allow for FastLookup when supplied zipfile is read-only + if 'r' not in source.mode: + cls = CompleteDirs + + source.__class__ = cls + return source + + +class FastLookup(CompleteDirs): + """ + ZipFile subclass to ensure implicit + dirs exist and are resolved rapidly. + """ + + def namelist(self): + with contextlib.suppress(AttributeError): + return self.__names + self.__names = super(FastLookup, self).namelist() + return self.__names + + def _name_set(self): + with contextlib.suppress(AttributeError): + return self.__lookup + self.__lookup = super(FastLookup, self)._name_set() + return self.__lookup + + +def _extract_text_encoding(encoding=None, *args, **kwargs): + # stacklevel=3 so that the caller of the caller see any warning. + return io.text_encoding(encoding, 3), args, kwargs + + +class Path: + """ + A pathlib-compatible interface for zip files. + + Consider a zip file with this structure:: + + . + ├── a.txt + └── b + ├── c.txt + └── d + └── e.txt + + >>> data = io.BytesIO() + >>> zf = ZipFile(data, 'w') + >>> zf.writestr('a.txt', 'content of a') + >>> zf.writestr('b/c.txt', 'content of c') + >>> zf.writestr('b/d/e.txt', 'content of e') + >>> zf.filename = 'mem/abcde.zip' + + Path accepts the zipfile object itself or a filename + + >>> root = Path(zf) + + From there, several path operations are available. + + Directory iteration (including the zip file itself): + + >>> a, b = root.iterdir() + >>> a + Path('mem/abcde.zip', 'a.txt') + >>> b + Path('mem/abcde.zip', 'b/') + + name property: + + >>> b.name + 'b' + + join with divide operator: + + >>> c = b / 'c.txt' + >>> c + Path('mem/abcde.zip', 'b/c.txt') + >>> c.name + 'c.txt' + + Read text: + + >>> c.read_text() + 'content of c' + + existence: + + >>> c.exists() + True + >>> (b / 'missing.txt').exists() + False + + Coercion to string: + + >>> import os + >>> str(c).replace(os.sep, posixpath.sep) + 'mem/abcde.zip/b/c.txt' + + At the root, ``name``, ``filename``, and ``parent`` + resolve to the zipfile. Note these attributes are not + valid and will raise a ``ValueError`` if the zipfile + has no filename. + + >>> root.name + 'abcde.zip' + >>> str(root.filename).replace(os.sep, posixpath.sep) + 'mem/abcde.zip' + >>> str(root.parent) + 'mem' + """ + + __repr = "{self.__class__.__name__}({self.root.filename!r}, {self.at!r})" + + def __init__(self, root, at=""): + """ + Construct a Path from a ZipFile or filename. + + Note: When the source is an existing ZipFile object, + its type (__class__) will be mutated to a + specialized type. If the caller wishes to retain the + original type, the caller should either create a + separate ZipFile object or pass a filename. + """ + self.root = FastLookup.make(root) + self.at = at + + def open(self, mode='r', *args, pwd=None, **kwargs): + """ + Open this entry as text or binary following the semantics + of ``pathlib.Path.open()`` by passing arguments through + to io.TextIOWrapper(). + """ + if self.is_dir(): + raise IsADirectoryError(self) + zip_mode = mode[0] + if not self.exists() and zip_mode == 'r': + raise FileNotFoundError(self) + stream = self.root.open(self.at, zip_mode, pwd=pwd) + if 'b' in mode: + if args or kwargs: + raise ValueError("encoding args invalid for binary operation") + return stream + # Text mode: + encoding, args, kwargs = _extract_text_encoding(*args, **kwargs) + return io.TextIOWrapper(stream, encoding, *args, **kwargs) + + def _base(self): + return pathlib.PurePosixPath(self.at or self.root.filename) + + @property + def name(self): + return self._base().name + + @property + def suffix(self): + return self._base().suffix + + @property + def suffixes(self): + return self._base().suffixes + + @property + def stem(self): + return self._base().stem + + @property + def filename(self): + return pathlib.Path(self.root.filename).joinpath(self.at) + + def read_text(self, *args, **kwargs): + encoding, args, kwargs = _extract_text_encoding(*args, **kwargs) + with self.open('r', encoding, *args, **kwargs) as strm: + return strm.read() + + def read_bytes(self): + with self.open('rb') as strm: + return strm.read() + + def _is_child(self, path): + return posixpath.dirname(path.at.rstrip("/")) == self.at.rstrip("/") + + def _next(self, at): + return self.__class__(self.root, at) + + def is_dir(self): + return not self.at or self.at.endswith("/") + + def is_file(self): + return self.exists() and not self.is_dir() + + def exists(self): + return self.at in self.root._name_set() + + def iterdir(self): + if not self.is_dir(): + raise ValueError("Can't listdir a file") + subs = map(self._next, self.root.namelist()) + return filter(self._is_child, subs) + + def __str__(self): + return posixpath.join(self.root.filename, self.at) + + def __repr__(self): + return self.__repr.format(self=self) + + def joinpath(self, *other): + next = posixpath.join(self.at, *other) + return self._next(self.root.resolve_dir(next)) + + __truediv__ = joinpath + + @property + def parent(self): + if not self.at: + return self.filename.parent + parent_at = posixpath.dirname(self.at.rstrip('/')) + if parent_at: + parent_at += '/' + return self._next(parent_at) + + +def main(args=None): + import argparse + + description = 'A simple command-line interface for zipfile module.' + parser = argparse.ArgumentParser(description=description) + group = parser.add_mutually_exclusive_group(required=True) + group.add_argument('-l', '--list', metavar='', + help='Show listing of a zipfile') + group.add_argument('-e', '--extract', nargs=2, + metavar=('', ''), + help='Extract zipfile into target dir') + group.add_argument('-c', '--create', nargs='+', + metavar=('', ''), + help='Create zipfile from sources') + group.add_argument('-t', '--test', metavar='', + help='Test if a zipfile is valid') + parser.add_argument('--metadata-encoding', metavar='', + help='Specify encoding of member names for -l, -e and -t') + args = parser.parse_args(args) + + encoding = args.metadata_encoding + + if args.test is not None: + src = args.test + with ZipFile(src, 'r', metadata_encoding=encoding) as zf: + badfile = zf.testzip() + if badfile: + print("The following enclosed file is corrupted: {!r}".format(badfile)) + print("Done testing") + + elif args.list is not None: + src = args.list + with ZipFile(src, 'r', metadata_encoding=encoding) as zf: + zf.printdir() + + elif args.extract is not None: + src, curdir = args.extract + with ZipFile(src, 'r', metadata_encoding=encoding) as zf: + zf.extractall(curdir) + + elif args.create is not None: + if encoding: + print("Non-conforming encodings not supported with -c.", + file=sys.stderr) + sys.exit(1) + + zip_name = args.create.pop(0) + files = args.create + + def addToZip(zf, path, zippath): + if os.path.isfile(path): + zf.write(path, zippath, ZIP_DEFLATED) + elif os.path.isdir(path): + if zippath: + zf.write(path, zippath) + for nm in sorted(os.listdir(path)): + addToZip(zf, + os.path.join(path, nm), os.path.join(zippath, nm)) + # else: ignore + + with ZipFile(zip_name, 'w') as zf: + for path in files: + zippath = os.path.basename(path) + if not zippath: + zippath = os.path.basename(os.path.dirname(path)) + if zippath in ('', os.curdir, os.pardir): + zippath = '' + addToZip(zf, path, zippath) + + +if __name__ == "__main__": + main() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/zipimport.py b/physworld_p1_20261018/envs/p1/lib/python3.11/zipimport.py new file mode 100644 index 0000000000000000000000000000000000000000..e9da8be5fadd42752f8a7f4864eceb72499bd220 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/zipimport.py @@ -0,0 +1,778 @@ +"""zipimport provides support for importing Python modules from Zip archives. + +This module exports three objects: +- zipimporter: a class; its constructor takes a path to a Zip archive. +- ZipImportError: exception raised by zipimporter objects. It's a + subclass of ImportError, so it can be caught as ImportError, too. +- _zip_directory_cache: a dict, mapping archive paths to zip directory + info dicts, as used in zipimporter._files. + +It is usually not needed to use the zipimport module explicitly; it is +used by the builtin import mechanism for sys.path items that are paths +to Zip archives. +""" + +#from importlib import _bootstrap_external +#from importlib import _bootstrap # for _verbose_message +import _frozen_importlib_external as _bootstrap_external +from _frozen_importlib_external import _unpack_uint16, _unpack_uint32 +import _frozen_importlib as _bootstrap # for _verbose_message +import _imp # for check_hash_based_pycs +import _io # for open +import marshal # for loads +import sys # for modules +import time # for mktime +import _warnings # For warn() + +__all__ = ['ZipImportError', 'zipimporter'] + + +path_sep = _bootstrap_external.path_sep +alt_path_sep = _bootstrap_external.path_separators[1:] + + +class ZipImportError(ImportError): + pass + +# _read_directory() cache +_zip_directory_cache = {} + +_module_type = type(sys) + +END_CENTRAL_DIR_SIZE = 22 +STRING_END_ARCHIVE = b'PK\x05\x06' +MAX_COMMENT_LEN = (1 << 16) - 1 + +class zipimporter(_bootstrap_external._LoaderBasics): + """zipimporter(archivepath) -> zipimporter object + + Create a new zipimporter instance. 'archivepath' must be a path to + a zipfile, or to a specific path inside a zipfile. For example, it can be + '/tmp/myimport.zip', or '/tmp/myimport.zip/mydirectory', if mydirectory is a + valid directory inside the archive. + + 'ZipImportError is raised if 'archivepath' doesn't point to a valid Zip + archive. + + The 'archive' attribute of zipimporter objects contains the name of the + zipfile targeted. + """ + + # Split the "subdirectory" from the Zip archive path, lookup a matching + # entry in sys.path_importer_cache, fetch the file directory from there + # if found, or else read it from the archive. + def __init__(self, path): + if not isinstance(path, str): + raise TypeError(f"expected str, not {type(path)!r}") + if not path: + raise ZipImportError('archive path is empty', path=path) + if alt_path_sep: + path = path.replace(alt_path_sep, path_sep) + + prefix = [] + while True: + try: + st = _bootstrap_external._path_stat(path) + except (OSError, ValueError): + # On Windows a ValueError is raised for too long paths. + # Back up one path element. + dirname, basename = _bootstrap_external._path_split(path) + if dirname == path: + raise ZipImportError('not a Zip file', path=path) + path = dirname + prefix.append(basename) + else: + # it exists + if (st.st_mode & 0o170000) != 0o100000: # stat.S_ISREG + # it's a not file + raise ZipImportError('not a Zip file', path=path) + break + + try: + files = _zip_directory_cache[path] + except KeyError: + files = _read_directory(path) + _zip_directory_cache[path] = files + self._files = files + self.archive = path + # a prefix directory following the ZIP file path. + self.prefix = _bootstrap_external._path_join(*prefix[::-1]) + if self.prefix: + self.prefix += path_sep + + + # Check whether we can satisfy the import of the module named by + # 'fullname', or whether it could be a portion of a namespace + # package. Return self if we can load it, a string containing the + # full path if it's a possible namespace portion, None if we + # can't load it. + def find_loader(self, fullname, path=None): + """find_loader(fullname, path=None) -> self, str or None. + + Search for a module specified by 'fullname'. 'fullname' must be the + fully qualified (dotted) module name. It returns the zipimporter + instance itself if the module was found, a string containing the + full path name if it's possibly a portion of a namespace package, + or None otherwise. The optional 'path' argument is ignored -- it's + there for compatibility with the importer protocol. + + Deprecated since Python 3.10. Use find_spec() instead. + """ + _warnings.warn("zipimporter.find_loader() is deprecated and slated for " + "removal in Python 3.12; use find_spec() instead", + DeprecationWarning) + mi = _get_module_info(self, fullname) + if mi is not None: + # This is a module or package. + return self, [] + + # Not a module or regular package. See if this is a directory, and + # therefore possibly a portion of a namespace package. + + # We're only interested in the last path component of fullname + # earlier components are recorded in self.prefix. + modpath = _get_module_path(self, fullname) + if _is_dir(self, modpath): + # This is possibly a portion of a namespace + # package. Return the string representing its path, + # without a trailing separator. + return None, [f'{self.archive}{path_sep}{modpath}'] + + return None, [] + + + # Check whether we can satisfy the import of the module named by + # 'fullname'. Return self if we can, None if we can't. + def find_module(self, fullname, path=None): + """find_module(fullname, path=None) -> self or None. + + Search for a module specified by 'fullname'. 'fullname' must be the + fully qualified (dotted) module name. It returns the zipimporter + instance itself if the module was found, or None if it wasn't. + The optional 'path' argument is ignored -- it's there for compatibility + with the importer protocol. + + Deprecated since Python 3.10. Use find_spec() instead. + """ + _warnings.warn("zipimporter.find_module() is deprecated and slated for " + "removal in Python 3.12; use find_spec() instead", + DeprecationWarning) + return self.find_loader(fullname, path)[0] + + def find_spec(self, fullname, target=None): + """Create a ModuleSpec for the specified module. + + Returns None if the module cannot be found. + """ + module_info = _get_module_info(self, fullname) + if module_info is not None: + return _bootstrap.spec_from_loader(fullname, self, is_package=module_info) + else: + # Not a module or regular package. See if this is a directory, and + # therefore possibly a portion of a namespace package. + + # We're only interested in the last path component of fullname + # earlier components are recorded in self.prefix. + modpath = _get_module_path(self, fullname) + if _is_dir(self, modpath): + # This is possibly a portion of a namespace + # package. Return the string representing its path, + # without a trailing separator. + path = f'{self.archive}{path_sep}{modpath}' + spec = _bootstrap.ModuleSpec(name=fullname, loader=None, + is_package=True) + spec.submodule_search_locations.append(path) + return spec + else: + return None + + def get_code(self, fullname): + """get_code(fullname) -> code object. + + Return the code object for the specified module. Raise ZipImportError + if the module couldn't be imported. + """ + code, ispackage, modpath = _get_module_code(self, fullname) + return code + + + def get_data(self, pathname): + """get_data(pathname) -> string with file data. + + Return the data associated with 'pathname'. Raise OSError if + the file wasn't found. + """ + if alt_path_sep: + pathname = pathname.replace(alt_path_sep, path_sep) + + key = pathname + if pathname.startswith(self.archive + path_sep): + key = pathname[len(self.archive + path_sep):] + + try: + toc_entry = self._files[key] + except KeyError: + raise OSError(0, '', key) + return _get_data(self.archive, toc_entry) + + + # Return a string matching __file__ for the named module + def get_filename(self, fullname): + """get_filename(fullname) -> filename string. + + Return the filename for the specified module or raise ZipImportError + if it couldn't be imported. + """ + # Deciding the filename requires working out where the code + # would come from if the module was actually loaded + code, ispackage, modpath = _get_module_code(self, fullname) + return modpath + + + def get_source(self, fullname): + """get_source(fullname) -> source string. + + Return the source code for the specified module. Raise ZipImportError + if the module couldn't be found, return None if the archive does + contain the module, but has no source for it. + """ + mi = _get_module_info(self, fullname) + if mi is None: + raise ZipImportError(f"can't find module {fullname!r}", name=fullname) + + path = _get_module_path(self, fullname) + if mi: + fullpath = _bootstrap_external._path_join(path, '__init__.py') + else: + fullpath = f'{path}.py' + + try: + toc_entry = self._files[fullpath] + except KeyError: + # we have the module, but no source + return None + return _get_data(self.archive, toc_entry).decode() + + + # Return a bool signifying whether the module is a package or not. + def is_package(self, fullname): + """is_package(fullname) -> bool. + + Return True if the module specified by fullname is a package. + Raise ZipImportError if the module couldn't be found. + """ + mi = _get_module_info(self, fullname) + if mi is None: + raise ZipImportError(f"can't find module {fullname!r}", name=fullname) + return mi + + + # Load and return the module named by 'fullname'. + def load_module(self, fullname): + """load_module(fullname) -> module. + + Load the module specified by 'fullname'. 'fullname' must be the + fully qualified (dotted) module name. It returns the imported + module, or raises ZipImportError if it could not be imported. + + Deprecated since Python 3.10. Use exec_module() instead. + """ + msg = ("zipimport.zipimporter.load_module() is deprecated and slated for " + "removal in Python 3.12; use exec_module() instead") + _warnings.warn(msg, DeprecationWarning) + code, ispackage, modpath = _get_module_code(self, fullname) + mod = sys.modules.get(fullname) + if mod is None or not isinstance(mod, _module_type): + mod = _module_type(fullname) + sys.modules[fullname] = mod + mod.__loader__ = self + + try: + if ispackage: + # add __path__ to the module *before* the code gets + # executed + path = _get_module_path(self, fullname) + fullpath = _bootstrap_external._path_join(self.archive, path) + mod.__path__ = [fullpath] + + if not hasattr(mod, '__builtins__'): + mod.__builtins__ = __builtins__ + _bootstrap_external._fix_up_module(mod.__dict__, fullname, modpath) + exec(code, mod.__dict__) + except: + del sys.modules[fullname] + raise + + try: + mod = sys.modules[fullname] + except KeyError: + raise ImportError(f'Loaded module {fullname!r} not found in sys.modules') + _bootstrap._verbose_message('import {} # loaded from Zip {}', fullname, modpath) + return mod + + + def get_resource_reader(self, fullname): + """Return the ResourceReader for a package in a zip file. + + If 'fullname' is a package within the zip file, return the + 'ResourceReader' object for the package. Otherwise return None. + """ + try: + if not self.is_package(fullname): + return None + except ZipImportError: + return None + from importlib.readers import ZipReader + return ZipReader(self, fullname) + + + def invalidate_caches(self): + """Reload the file data of the archive path.""" + try: + self._files = _read_directory(self.archive) + _zip_directory_cache[self.archive] = self._files + except ZipImportError: + _zip_directory_cache.pop(self.archive, None) + self._files = {} + + + def __repr__(self): + return f'' + + +# _zip_searchorder defines how we search for a module in the Zip +# archive: we first search for a package __init__, then for +# non-package .pyc, and .py entries. The .pyc entries +# are swapped by initzipimport() if we run in optimized mode. Also, +# '/' is replaced by path_sep there. +_zip_searchorder = ( + (path_sep + '__init__.pyc', True, True), + (path_sep + '__init__.py', False, True), + ('.pyc', True, False), + ('.py', False, False), +) + +# Given a module name, return the potential file path in the +# archive (without extension). +def _get_module_path(self, fullname): + return self.prefix + fullname.rpartition('.')[2] + +# Does this path represent a directory? +def _is_dir(self, path): + # See if this is a "directory". If so, it's eligible to be part + # of a namespace package. We test by seeing if the name, with an + # appended path separator, exists. + dirpath = path + path_sep + # If dirpath is present in self._files, we have a directory. + return dirpath in self._files + +# Return some information about a module. +def _get_module_info(self, fullname): + path = _get_module_path(self, fullname) + for suffix, isbytecode, ispackage in _zip_searchorder: + fullpath = path + suffix + if fullpath in self._files: + return ispackage + return None + + +# implementation + +# _read_directory(archive) -> files dict (new reference) +# +# Given a path to a Zip archive, build a dict, mapping file names +# (local to the archive, using SEP as a separator) to toc entries. +# +# A toc_entry is a tuple: +# +# (__file__, # value to use for __file__, available for all files, +# # encoded to the filesystem encoding +# compress, # compression kind; 0 for uncompressed +# data_size, # size of compressed data on disk +# file_size, # size of decompressed data +# file_offset, # offset of file header from start of archive +# time, # mod time of file (in dos format) +# date, # mod data of file (in dos format) +# crc, # crc checksum of the data +# ) +# +# Directories can be recognized by the trailing path_sep in the name, +# data_size and file_offset are 0. +def _read_directory(archive): + try: + fp = _io.open_code(archive) + except OSError: + raise ZipImportError(f"can't open Zip file: {archive!r}", path=archive) + + with fp: + # GH-87235: On macOS all file descriptors for /dev/fd/N share the same + # file offset, reset the file offset after scanning the zipfile diretory + # to not cause problems when some runs 'python3 /dev/fd/9 9 header_offset: + raise ZipImportError(f'bad local header offset: {archive!r}', path=archive) + file_offset += arc_offset + + try: + name = fp.read(name_size) + except OSError: + raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive) + if len(name) != name_size: + raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive) + # On Windows, calling fseek to skip over the fields we don't use is + # slower than reading the data because fseek flushes stdio's + # internal buffers. See issue #8745. + try: + if len(fp.read(header_size - name_size)) != header_size - name_size: + raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive) + except OSError: + raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive) + + if flags & 0x800: + # UTF-8 file names extension + name = name.decode() + else: + # Historical ZIP filename encoding + try: + name = name.decode('ascii') + except UnicodeDecodeError: + name = name.decode('latin1').translate(cp437_table) + + name = name.replace('/', path_sep) + path = _bootstrap_external._path_join(archive, name) + t = (path, compress, data_size, file_size, file_offset, time, date, crc) + files[name] = t + count += 1 + finally: + fp.seek(start_offset) + _bootstrap._verbose_message('zipimport: found {} names in {!r}', count, archive) + return files + +# During bootstrap, we may need to load the encodings +# package from a ZIP file. But the cp437 encoding is implemented +# in Python in the encodings package. +# +# Break out of this dependency by using the translation table for +# the cp437 encoding. +cp437_table = ( + # ASCII part, 8 rows x 16 chars + '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f' + '\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f' + ' !"#$%&\'()*+,-./' + '0123456789:;<=>?' + '@ABCDEFGHIJKLMNO' + 'PQRSTUVWXYZ[\\]^_' + '`abcdefghijklmno' + 'pqrstuvwxyz{|}~\x7f' + # non-ASCII part, 16 rows x 8 chars + '\xc7\xfc\xe9\xe2\xe4\xe0\xe5\xe7' + '\xea\xeb\xe8\xef\xee\xec\xc4\xc5' + '\xc9\xe6\xc6\xf4\xf6\xf2\xfb\xf9' + '\xff\xd6\xdc\xa2\xa3\xa5\u20a7\u0192' + '\xe1\xed\xf3\xfa\xf1\xd1\xaa\xba' + '\xbf\u2310\xac\xbd\xbc\xa1\xab\xbb' + '\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556' + '\u2555\u2563\u2551\u2557\u255d\u255c\u255b\u2510' + '\u2514\u2534\u252c\u251c\u2500\u253c\u255e\u255f' + '\u255a\u2554\u2569\u2566\u2560\u2550\u256c\u2567' + '\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256b' + '\u256a\u2518\u250c\u2588\u2584\u258c\u2590\u2580' + '\u03b1\xdf\u0393\u03c0\u03a3\u03c3\xb5\u03c4' + '\u03a6\u0398\u03a9\u03b4\u221e\u03c6\u03b5\u2229' + '\u2261\xb1\u2265\u2264\u2320\u2321\xf7\u2248' + '\xb0\u2219\xb7\u221a\u207f\xb2\u25a0\xa0' +) + +_importing_zlib = False + +# Return the zlib.decompress function object, or NULL if zlib couldn't +# be imported. The function is cached when found, so subsequent calls +# don't import zlib again. +def _get_decompress_func(): + global _importing_zlib + if _importing_zlib: + # Someone has a zlib.py[co] in their Zip file + # let's avoid a stack overflow. + _bootstrap._verbose_message('zipimport: zlib UNAVAILABLE') + raise ZipImportError("can't decompress data; zlib not available") + + _importing_zlib = True + try: + from zlib import decompress + except Exception: + _bootstrap._verbose_message('zipimport: zlib UNAVAILABLE') + raise ZipImportError("can't decompress data; zlib not available") + finally: + _importing_zlib = False + + _bootstrap._verbose_message('zipimport: zlib available') + return decompress + +# Given a path to a Zip file and a toc_entry, return the (uncompressed) data. +def _get_data(archive, toc_entry): + datapath, compress, data_size, file_size, file_offset, time, date, crc = toc_entry + if data_size < 0: + raise ZipImportError('negative data size') + + with _io.open_code(archive) as fp: + # Check to make sure the local file header is correct + try: + fp.seek(file_offset) + except OSError: + raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive) + buffer = fp.read(30) + if len(buffer) != 30: + raise EOFError('EOF read where not expected') + + if buffer[:4] != b'PK\x03\x04': + # Bad: Local File Header + raise ZipImportError(f'bad local file header: {archive!r}', path=archive) + + name_size = _unpack_uint16(buffer[26:28]) + extra_size = _unpack_uint16(buffer[28:30]) + header_size = 30 + name_size + extra_size + file_offset += header_size # Start of file data + try: + fp.seek(file_offset) + except OSError: + raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive) + raw_data = fp.read(data_size) + if len(raw_data) != data_size: + raise OSError("zipimport: can't read data") + + if compress == 0: + # data is not compressed + return raw_data + + # Decompress with zlib + try: + decompress = _get_decompress_func() + except Exception: + raise ZipImportError("can't decompress data; zlib not available") + return decompress(raw_data, -15) + + +# Lenient date/time comparison function. The precision of the mtime +# in the archive is lower than the mtime stored in a .pyc: we +# must allow a difference of at most one second. +def _eq_mtime(t1, t2): + # dostime only stores even seconds, so be lenient + return abs(t1 - t2) <= 1 + + +# Given the contents of a .py[co] file, unmarshal the data +# and return the code object. Raises ImportError it the magic word doesn't +# match, or if the recorded .py[co] metadata does not match the source. +def _unmarshal_code(self, pathname, fullpath, fullname, data): + exc_details = { + 'name': fullname, + 'path': fullpath, + } + + flags = _bootstrap_external._classify_pyc(data, fullname, exc_details) + + hash_based = flags & 0b1 != 0 + if hash_based: + check_source = flags & 0b10 != 0 + if (_imp.check_hash_based_pycs != 'never' and + (check_source or _imp.check_hash_based_pycs == 'always')): + source_bytes = _get_pyc_source(self, fullpath) + if source_bytes is not None: + source_hash = _imp.source_hash( + _bootstrap_external._RAW_MAGIC_NUMBER, + source_bytes, + ) + + _bootstrap_external._validate_hash_pyc( + data, source_hash, fullname, exc_details) + else: + source_mtime, source_size = \ + _get_mtime_and_size_of_source(self, fullpath) + + if source_mtime: + # We don't use _bootstrap_external._validate_timestamp_pyc + # to allow for a more lenient timestamp check. + if (not _eq_mtime(_unpack_uint32(data[8:12]), source_mtime) or + _unpack_uint32(data[12:16]) != source_size): + _bootstrap._verbose_message( + f'bytecode is stale for {fullname!r}') + return None + + code = marshal.loads(data[16:]) + if not isinstance(code, _code_type): + raise TypeError(f'compiled module {pathname!r} is not a code object') + return code + +_code_type = type(_unmarshal_code.__code__) + + +# Replace any occurrences of '\r\n?' in the input string with '\n'. +# This converts DOS and Mac line endings to Unix line endings. +def _normalize_line_endings(source): + source = source.replace(b'\r\n', b'\n') + source = source.replace(b'\r', b'\n') + return source + +# Given a string buffer containing Python source code, compile it +# and return a code object. +def _compile_source(pathname, source): + source = _normalize_line_endings(source) + return compile(source, pathname, 'exec', dont_inherit=True) + +# Convert the date/time values found in the Zip archive to a value +# that's compatible with the time stamp stored in .pyc files. +def _parse_dostime(d, t): + return time.mktime(( + (d >> 9) + 1980, # bits 9..15: year + (d >> 5) & 0xF, # bits 5..8: month + d & 0x1F, # bits 0..4: day + t >> 11, # bits 11..15: hours + (t >> 5) & 0x3F, # bits 8..10: minutes + (t & 0x1F) * 2, # bits 0..7: seconds / 2 + -1, -1, -1)) + +# Given a path to a .pyc file in the archive, return the +# modification time of the matching .py file and its size, +# or (0, 0) if no source is available. +def _get_mtime_and_size_of_source(self, path): + try: + # strip 'c' or 'o' from *.py[co] + assert path[-1:] in ('c', 'o') + path = path[:-1] + toc_entry = self._files[path] + # fetch the time stamp of the .py file for comparison + # with an embedded pyc time stamp + time = toc_entry[5] + date = toc_entry[6] + uncompressed_size = toc_entry[3] + return _parse_dostime(date, time), uncompressed_size + except (KeyError, IndexError, TypeError): + return 0, 0 + + +# Given a path to a .pyc file in the archive, return the +# contents of the matching .py file, or None if no source +# is available. +def _get_pyc_source(self, path): + # strip 'c' or 'o' from *.py[co] + assert path[-1:] in ('c', 'o') + path = path[:-1] + + try: + toc_entry = self._files[path] + except KeyError: + return None + else: + return _get_data(self.archive, toc_entry) + + +# Get the code object associated with the module specified by +# 'fullname'. +def _get_module_code(self, fullname): + path = _get_module_path(self, fullname) + import_error = None + for suffix, isbytecode, ispackage in _zip_searchorder: + fullpath = path + suffix + _bootstrap._verbose_message('trying {}{}{}', self.archive, path_sep, fullpath, verbosity=2) + try: + toc_entry = self._files[fullpath] + except KeyError: + pass + else: + modpath = toc_entry[0] + data = _get_data(self.archive, toc_entry) + code = None + if isbytecode: + try: + code = _unmarshal_code(self, modpath, fullpath, fullname, data) + except ImportError as exc: + import_error = exc + else: + code = _compile_source(modpath, data) + if code is None: + # bad magic number or non-matching mtime + # in byte code, try next + continue + modpath = toc_entry[0] + return code, ispackage, modpath + else: + if import_error: + msg = f"module load failed: {import_error}" + raise ZipImportError(msg, name=fullname) from import_error + else: + raise ZipImportError(f"can't find module {fullname!r}", name=fullname) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f5510ee049751345ef4788401ca427549be3aab5 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/__init__.py @@ -0,0 +1,31 @@ +__all__ = [ + "ZoneInfo", + "reset_tzpath", + "available_timezones", + "TZPATH", + "ZoneInfoNotFoundError", + "InvalidTZPathWarning", +] + +from . import _tzpath +from ._common import ZoneInfoNotFoundError + +try: + from _zoneinfo import ZoneInfo +except ImportError: # pragma: nocover + from ._zoneinfo import ZoneInfo + +reset_tzpath = _tzpath.reset_tzpath +available_timezones = _tzpath.available_timezones +InvalidTZPathWarning = _tzpath.InvalidTZPathWarning + + +def __getattr__(name): + if name == "TZPATH": + return _tzpath.TZPATH + else: + raise AttributeError(f"module {__name__!r} has no attribute {name!r}") + + +def __dir__(): + return sorted(list(globals()) + ["TZPATH"]) diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..80498e148c160d79770756e95f55025f0a8ca2ce Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/__pycache__/__init__.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/__pycache__/_common.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/__pycache__/_common.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9a0babcdd9707cae79235ed925184e4341fb606e Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/__pycache__/_common.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/__pycache__/_tzpath.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/__pycache__/_tzpath.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3cae1560392866849234bb59f461d32644a29d76 Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/__pycache__/_tzpath.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/__pycache__/_zoneinfo.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/__pycache__/_zoneinfo.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9677987619106864b5a118bb4cd1280107ae101b Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/__pycache__/_zoneinfo.cpython-311.pyc differ diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/_common.py b/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/_common.py new file mode 100644 index 0000000000000000000000000000000000000000..98cdfe37ca6caef972d20bf15fce8f664adbad6a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/_common.py @@ -0,0 +1,164 @@ +import struct + + +def load_tzdata(key): + from importlib import resources + + components = key.split("/") + package_name = ".".join(["tzdata.zoneinfo"] + components[:-1]) + resource_name = components[-1] + + try: + return resources.files(package_name).joinpath(resource_name).open("rb") + except (ImportError, FileNotFoundError, UnicodeEncodeError): + # There are three types of exception that can be raised that all amount + # to "we cannot find this key": + # + # ImportError: If package_name doesn't exist (e.g. if tzdata is not + # installed, or if there's an error in the folder name like + # Amrica/New_York) + # FileNotFoundError: If resource_name doesn't exist in the package + # (e.g. Europe/Krasnoy) + # UnicodeEncodeError: If package_name or resource_name are not UTF-8, + # such as keys containing a surrogate character. + raise ZoneInfoNotFoundError(f"No time zone found with key {key}") + + +def load_data(fobj): + header = _TZifHeader.from_file(fobj) + + if header.version == 1: + time_size = 4 + time_type = "l" + else: + # Version 2+ has 64-bit integer transition times + time_size = 8 + time_type = "q" + + # Version 2+ also starts with a Version 1 header and data, which + # we need to skip now + skip_bytes = ( + header.timecnt * 5 # Transition times and types + + header.typecnt * 6 # Local time type records + + header.charcnt # Time zone designations + + header.leapcnt * 8 # Leap second records + + header.isstdcnt # Standard/wall indicators + + header.isutcnt # UT/local indicators + ) + + fobj.seek(skip_bytes, 1) + + # Now we need to read the second header, which is not the same + # as the first + header = _TZifHeader.from_file(fobj) + + typecnt = header.typecnt + timecnt = header.timecnt + charcnt = header.charcnt + + # The data portion starts with timecnt transitions and indices + if timecnt: + trans_list_utc = struct.unpack( + f">{timecnt}{time_type}", fobj.read(timecnt * time_size) + ) + trans_idx = struct.unpack(f">{timecnt}B", fobj.read(timecnt)) + else: + trans_list_utc = () + trans_idx = () + + # Read the ttinfo struct, (utoff, isdst, abbrind) + if typecnt: + utcoff, isdst, abbrind = zip( + *(struct.unpack(">lbb", fobj.read(6)) for i in range(typecnt)) + ) + else: + utcoff = () + isdst = () + abbrind = () + + # Now read the abbreviations. They are null-terminated strings, indexed + # not by position in the array but by position in the unsplit + # abbreviation string. I suppose this makes more sense in C, which uses + # null to terminate the strings, but it's inconvenient here... + abbr_vals = {} + abbr_chars = fobj.read(charcnt) + + def get_abbr(idx): + # Gets a string starting at idx and running until the next \x00 + # + # We cannot pre-populate abbr_vals by splitting on \x00 because there + # are some zones that use subsets of longer abbreviations, like so: + # + # LMT\x00AHST\x00HDT\x00 + # + # Where the idx to abbr mapping should be: + # + # {0: "LMT", 4: "AHST", 5: "HST", 9: "HDT"} + if idx not in abbr_vals: + span_end = abbr_chars.find(b"\x00", idx) + abbr_vals[idx] = abbr_chars[idx:span_end].decode() + + return abbr_vals[idx] + + abbr = tuple(get_abbr(idx) for idx in abbrind) + + # The remainder of the file consists of leap seconds (currently unused) and + # the standard/wall and ut/local indicators, which are metadata we don't need. + # In version 2 files, we need to skip the unnecessary data to get at the TZ string: + if header.version >= 2: + # Each leap second record has size (time_size + 4) + skip_bytes = header.isutcnt + header.isstdcnt + header.leapcnt * 12 + fobj.seek(skip_bytes, 1) + + c = fobj.read(1) # Should be \n + assert c == b"\n", c + + tz_bytes = b"" + while (c := fobj.read(1)) != b"\n": + tz_bytes += c + + tz_str = tz_bytes + else: + tz_str = None + + return trans_idx, trans_list_utc, utcoff, isdst, abbr, tz_str + + +class _TZifHeader: + __slots__ = [ + "version", + "isutcnt", + "isstdcnt", + "leapcnt", + "timecnt", + "typecnt", + "charcnt", + ] + + def __init__(self, *args): + for attr, val in zip(self.__slots__, args, strict=True): + setattr(self, attr, val) + + @classmethod + def from_file(cls, stream): + # The header starts with a 4-byte "magic" value + if stream.read(4) != b"TZif": + raise ValueError("Invalid TZif file: magic not found") + + _version = stream.read(1) + if _version == b"\x00": + version = 1 + else: + version = int(_version) + stream.read(15) + + args = (version,) + + # Slots are defined in the order that the bytes are arranged + args = args + struct.unpack(">6l", stream.read(24)) + + return cls(*args) + + +class ZoneInfoNotFoundError(KeyError): + """Exception raised when a ZoneInfo key is not found.""" diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/_tzpath.py b/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/_tzpath.py new file mode 100644 index 0000000000000000000000000000000000000000..4985dce2dc36d0e6b3c9c9dddc1fb69fd7667768 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/_tzpath.py @@ -0,0 +1,175 @@ +import os +import sysconfig + + +def reset_tzpath(to=None): + global TZPATH + + tzpaths = to + if tzpaths is not None: + if isinstance(tzpaths, (str, bytes)): + raise TypeError( + f"tzpaths must be a list or tuple, " + + f"not {type(tzpaths)}: {tzpaths!r}" + ) + + if not all(map(os.path.isabs, tzpaths)): + raise ValueError(_get_invalid_paths_message(tzpaths)) + base_tzpath = tzpaths + else: + env_var = os.environ.get("PYTHONTZPATH", None) + if env_var is not None: + base_tzpath = _parse_python_tzpath(env_var) + else: + base_tzpath = _parse_python_tzpath( + sysconfig.get_config_var("TZPATH") + ) + + TZPATH = tuple(base_tzpath) + + +def _parse_python_tzpath(env_var): + if not env_var: + return () + + raw_tzpath = env_var.split(os.pathsep) + new_tzpath = tuple(filter(os.path.isabs, raw_tzpath)) + + # If anything has been filtered out, we will warn about it + if len(new_tzpath) != len(raw_tzpath): + import warnings + + msg = _get_invalid_paths_message(raw_tzpath) + + warnings.warn( + "Invalid paths specified in PYTHONTZPATH environment variable. " + + msg, + InvalidTZPathWarning, + ) + + return new_tzpath + + +def _get_invalid_paths_message(tzpaths): + invalid_paths = (path for path in tzpaths if not os.path.isabs(path)) + + prefix = "\n " + indented_str = prefix + prefix.join(invalid_paths) + + return ( + "Paths should be absolute but found the following relative paths:" + + indented_str + ) + + +def find_tzfile(key): + """Retrieve the path to a TZif file from a key.""" + _validate_tzfile_path(key) + for search_path in TZPATH: + filepath = os.path.join(search_path, key) + if os.path.isfile(filepath): + return filepath + + return None + + +_TEST_PATH = os.path.normpath(os.path.join("_", "_"))[:-1] + + +def _validate_tzfile_path(path, _base=_TEST_PATH): + if os.path.isabs(path): + raise ValueError( + f"ZoneInfo keys may not be absolute paths, got: {path}" + ) + + # We only care about the kinds of path normalizations that would change the + # length of the key - e.g. a/../b -> a/b, or a/b/ -> a/b. On Windows, + # normpath will also change from a/b to a\b, but that would still preserve + # the length. + new_path = os.path.normpath(path) + if len(new_path) != len(path): + raise ValueError( + f"ZoneInfo keys must be normalized relative paths, got: {path}" + ) + + resolved = os.path.normpath(os.path.join(_base, new_path)) + if not resolved.startswith(_base): + raise ValueError( + f"ZoneInfo keys must refer to subdirectories of TZPATH, got: {path}" + ) + + +del _TEST_PATH + + +def available_timezones(): + """Returns a set containing all available time zones. + + .. caution:: + + This may attempt to open a large number of files, since the best way to + determine if a given file on the time zone search path is to open it + and check for the "magic string" at the beginning. + """ + from importlib import resources + + valid_zones = set() + + # Start with loading from the tzdata package if it exists: this has a + # pre-assembled list of zones that only requires opening one file. + try: + with resources.files("tzdata").joinpath("zones").open("r") as f: + for zone in f: + zone = zone.strip() + if zone: + valid_zones.add(zone) + except (ImportError, FileNotFoundError): + pass + + def valid_key(fpath): + try: + with open(fpath, "rb") as f: + return f.read(4) == b"TZif" + except Exception: # pragma: nocover + return False + + for tz_root in TZPATH: + if not os.path.exists(tz_root): + continue + + for root, dirnames, files in os.walk(tz_root): + if root == tz_root: + # right/ and posix/ are special directories and shouldn't be + # included in the output of available zones + if "right" in dirnames: + dirnames.remove("right") + if "posix" in dirnames: + dirnames.remove("posix") + + for file in files: + fpath = os.path.join(root, file) + + key = os.path.relpath(fpath, start=tz_root) + if os.sep != "/": # pragma: nocover + key = key.replace(os.sep, "/") + + if not key or key in valid_zones: + continue + + if valid_key(fpath): + valid_zones.add(key) + + if "posixrules" in valid_zones: + # posixrules is a special symlink-only time zone where it exists, it + # should not be included in the output + valid_zones.remove("posixrules") + + return valid_zones + + +class InvalidTZPathWarning(RuntimeWarning): + """Warning raised if an invalid path is specified in PYTHONTZPATH.""" + + +TZPATH = () +reset_tzpath() diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/_zoneinfo.py b/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/_zoneinfo.py new file mode 100644 index 0000000000000000000000000000000000000000..b77dc0ed391bb36adc50f20b489b30caa7dcc9ed --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/python3.11/zoneinfo/_zoneinfo.py @@ -0,0 +1,772 @@ +import bisect +import calendar +import collections +import functools +import re +import weakref +from datetime import datetime, timedelta, tzinfo + +from . import _common, _tzpath + +EPOCH = datetime(1970, 1, 1) +EPOCHORDINAL = datetime(1970, 1, 1).toordinal() + +# It is relatively expensive to construct new timedelta objects, and in most +# cases we're looking at the same deltas, like integer numbers of hours, etc. +# To improve speed and memory use, we'll keep a dictionary with references +# to the ones we've already used so far. +# +# Loading every time zone in the 2020a version of the time zone database +# requires 447 timedeltas, which requires approximately the amount of space +# that ZoneInfo("America/New_York") with 236 transitions takes up, so we will +# set the cache size to 512 so that in the common case we always get cache +# hits, but specifically crafted ZoneInfo objects don't leak arbitrary amounts +# of memory. +@functools.lru_cache(maxsize=512) +def _load_timedelta(seconds): + return timedelta(seconds=seconds) + + +class ZoneInfo(tzinfo): + _strong_cache_size = 8 + _strong_cache = collections.OrderedDict() + _weak_cache = weakref.WeakValueDictionary() + __module__ = "zoneinfo" + + def __init_subclass__(cls): + cls._strong_cache = collections.OrderedDict() + cls._weak_cache = weakref.WeakValueDictionary() + + def __new__(cls, key): + instance = cls._weak_cache.get(key, None) + if instance is None: + instance = cls._weak_cache.setdefault(key, cls._new_instance(key)) + instance._from_cache = True + + # Update the "strong" cache + cls._strong_cache[key] = cls._strong_cache.pop(key, instance) + + if len(cls._strong_cache) > cls._strong_cache_size: + cls._strong_cache.popitem(last=False) + + return instance + + @classmethod + def no_cache(cls, key): + obj = cls._new_instance(key) + obj._from_cache = False + + return obj + + @classmethod + def _new_instance(cls, key): + obj = super().__new__(cls) + obj._key = key + obj._file_path = obj._find_tzfile(key) + + if obj._file_path is not None: + file_obj = open(obj._file_path, "rb") + else: + file_obj = _common.load_tzdata(key) + + with file_obj as f: + obj._load_file(f) + + return obj + + @classmethod + def from_file(cls, fobj, /, key=None): + obj = super().__new__(cls) + obj._key = key + obj._file_path = None + obj._load_file(fobj) + obj._file_repr = repr(fobj) + + # Disable pickling for objects created from files + obj.__reduce__ = obj._file_reduce + + return obj + + @classmethod + def clear_cache(cls, *, only_keys=None): + if only_keys is not None: + for key in only_keys: + cls._weak_cache.pop(key, None) + cls._strong_cache.pop(key, None) + + else: + cls._weak_cache.clear() + cls._strong_cache.clear() + + @property + def key(self): + return self._key + + def utcoffset(self, dt): + return self._find_trans(dt).utcoff + + def dst(self, dt): + return self._find_trans(dt).dstoff + + def tzname(self, dt): + return self._find_trans(dt).tzname + + def fromutc(self, dt): + """Convert from datetime in UTC to datetime in local time""" + + if not isinstance(dt, datetime): + raise TypeError("fromutc() requires a datetime argument") + if dt.tzinfo is not self: + raise ValueError("dt.tzinfo is not self") + + timestamp = self._get_local_timestamp(dt) + num_trans = len(self._trans_utc) + + if num_trans >= 1 and timestamp < self._trans_utc[0]: + tti = self._tti_before + fold = 0 + elif ( + num_trans == 0 or timestamp > self._trans_utc[-1] + ) and not isinstance(self._tz_after, _ttinfo): + tti, fold = self._tz_after.get_trans_info_fromutc( + timestamp, dt.year + ) + elif num_trans == 0: + tti = self._tz_after + fold = 0 + else: + idx = bisect.bisect_right(self._trans_utc, timestamp) + + if num_trans > 1 and timestamp >= self._trans_utc[1]: + tti_prev, tti = self._ttinfos[idx - 2 : idx] + elif timestamp > self._trans_utc[-1]: + tti_prev = self._ttinfos[-1] + tti = self._tz_after + else: + tti_prev = self._tti_before + tti = self._ttinfos[0] + + # Detect fold + shift = tti_prev.utcoff - tti.utcoff + fold = shift.total_seconds() > timestamp - self._trans_utc[idx - 1] + dt += tti.utcoff + if fold: + return dt.replace(fold=1) + else: + return dt + + def _find_trans(self, dt): + if dt is None: + if self._fixed_offset: + return self._tz_after + else: + return _NO_TTINFO + + ts = self._get_local_timestamp(dt) + + lt = self._trans_local[dt.fold] + + num_trans = len(lt) + + if num_trans and ts < lt[0]: + return self._tti_before + elif not num_trans or ts > lt[-1]: + if isinstance(self._tz_after, _TZStr): + return self._tz_after.get_trans_info(ts, dt.year, dt.fold) + else: + return self._tz_after + else: + # idx is the transition that occurs after this timestamp, so we + # subtract off 1 to get the current ttinfo + idx = bisect.bisect_right(lt, ts) - 1 + assert idx >= 0 + return self._ttinfos[idx] + + def _get_local_timestamp(self, dt): + return ( + (dt.toordinal() - EPOCHORDINAL) * 86400 + + dt.hour * 3600 + + dt.minute * 60 + + dt.second + ) + + def __str__(self): + if self._key is not None: + return f"{self._key}" + else: + return repr(self) + + def __repr__(self): + if self._key is not None: + return f"{self.__class__.__name__}(key={self._key!r})" + else: + return f"{self.__class__.__name__}.from_file({self._file_repr})" + + def __reduce__(self): + return (self.__class__._unpickle, (self._key, self._from_cache)) + + def _file_reduce(self): + import pickle + + raise pickle.PicklingError( + "Cannot pickle a ZoneInfo file created from a file stream." + ) + + @classmethod + def _unpickle(cls, key, from_cache, /): + if from_cache: + return cls(key) + else: + return cls.no_cache(key) + + def _find_tzfile(self, key): + return _tzpath.find_tzfile(key) + + def _load_file(self, fobj): + # Retrieve all the data as it exists in the zoneinfo file + trans_idx, trans_utc, utcoff, isdst, abbr, tz_str = _common.load_data( + fobj + ) + + # Infer the DST offsets (needed for .dst()) from the data + dstoff = self._utcoff_to_dstoff(trans_idx, utcoff, isdst) + + # Convert all the transition times (UTC) into "seconds since 1970-01-01 local time" + trans_local = self._ts_to_local(trans_idx, trans_utc, utcoff) + + # Construct `_ttinfo` objects for each transition in the file + _ttinfo_list = [ + _ttinfo( + _load_timedelta(utcoffset), _load_timedelta(dstoffset), tzname + ) + for utcoffset, dstoffset, tzname in zip(utcoff, dstoff, abbr) + ] + + self._trans_utc = trans_utc + self._trans_local = trans_local + self._ttinfos = [_ttinfo_list[idx] for idx in trans_idx] + + # Find the first non-DST transition + for i in range(len(isdst)): + if not isdst[i]: + self._tti_before = _ttinfo_list[i] + break + else: + if self._ttinfos: + self._tti_before = self._ttinfos[0] + else: + self._tti_before = None + + # Set the "fallback" time zone + if tz_str is not None and tz_str != b"": + self._tz_after = _parse_tz_str(tz_str.decode()) + else: + if not self._ttinfos and not _ttinfo_list: + raise ValueError("No time zone information found.") + + if self._ttinfos: + self._tz_after = self._ttinfos[-1] + else: + self._tz_after = _ttinfo_list[-1] + + # Determine if this is a "fixed offset" zone, meaning that the output + # of the utcoffset, dst and tzname functions does not depend on the + # specific datetime passed. + # + # We make three simplifying assumptions here: + # + # 1. If _tz_after is not a _ttinfo, it has transitions that might + # actually occur (it is possible to construct TZ strings that + # specify STD and DST but no transitions ever occur, such as + # AAA0BBB,0/0,J365/25). + # 2. If _ttinfo_list contains more than one _ttinfo object, the objects + # represent different offsets. + # 3. _ttinfo_list contains no unused _ttinfos (in which case an + # otherwise fixed-offset zone with extra _ttinfos defined may + # appear to *not* be a fixed offset zone). + # + # Violations to these assumptions would be fairly exotic, and exotic + # zones should almost certainly not be used with datetime.time (the + # only thing that would be affected by this). + if len(_ttinfo_list) > 1 or not isinstance(self._tz_after, _ttinfo): + self._fixed_offset = False + elif not _ttinfo_list: + self._fixed_offset = True + else: + self._fixed_offset = _ttinfo_list[0] == self._tz_after + + @staticmethod + def _utcoff_to_dstoff(trans_idx, utcoffsets, isdsts): + # Now we must transform our ttis and abbrs into `_ttinfo` objects, + # but there is an issue: .dst() must return a timedelta with the + # difference between utcoffset() and the "standard" offset, but + # the "base offset" and "DST offset" are not encoded in the file; + # we can infer what they are from the isdst flag, but it is not + # sufficient to just look at the last standard offset, because + # occasionally countries will shift both DST offset and base offset. + + typecnt = len(isdsts) + dstoffs = [0] * typecnt # Provisionally assign all to 0. + dst_cnt = sum(isdsts) + dst_found = 0 + + for i in range(1, len(trans_idx)): + if dst_cnt == dst_found: + break + + idx = trans_idx[i] + + dst = isdsts[idx] + + # We're only going to look at daylight saving time + if not dst: + continue + + # Skip any offsets that have already been assigned + if dstoffs[idx] != 0: + continue + + dstoff = 0 + utcoff = utcoffsets[idx] + + comp_idx = trans_idx[i - 1] + + if not isdsts[comp_idx]: + dstoff = utcoff - utcoffsets[comp_idx] + + if not dstoff and idx < (typecnt - 1): + comp_idx = trans_idx[i + 1] + + # If the following transition is also DST and we couldn't + # find the DST offset by this point, we're going to have to + # skip it and hope this transition gets assigned later + if isdsts[comp_idx]: + continue + + dstoff = utcoff - utcoffsets[comp_idx] + + if dstoff: + dst_found += 1 + dstoffs[idx] = dstoff + else: + # If we didn't find a valid value for a given index, we'll end up + # with dstoff = 0 for something where `isdst=1`. This is obviously + # wrong - one hour will be a much better guess than 0 + for idx in range(typecnt): + if not dstoffs[idx] and isdsts[idx]: + dstoffs[idx] = 3600 + + return dstoffs + + @staticmethod + def _ts_to_local(trans_idx, trans_list_utc, utcoffsets): + """Generate number of seconds since 1970 *in the local time*. + + This is necessary to easily find the transition times in local time""" + if not trans_list_utc: + return [[], []] + + # Start with the timestamps and modify in-place + trans_list_wall = [list(trans_list_utc), list(trans_list_utc)] + + if len(utcoffsets) > 1: + offset_0 = utcoffsets[0] + offset_1 = utcoffsets[trans_idx[0]] + if offset_1 > offset_0: + offset_1, offset_0 = offset_0, offset_1 + else: + offset_0 = offset_1 = utcoffsets[0] + + trans_list_wall[0][0] += offset_0 + trans_list_wall[1][0] += offset_1 + + for i in range(1, len(trans_idx)): + offset_0 = utcoffsets[trans_idx[i - 1]] + offset_1 = utcoffsets[trans_idx[i]] + + if offset_1 > offset_0: + offset_1, offset_0 = offset_0, offset_1 + + trans_list_wall[0][i] += offset_0 + trans_list_wall[1][i] += offset_1 + + return trans_list_wall + + +class _ttinfo: + __slots__ = ["utcoff", "dstoff", "tzname"] + + def __init__(self, utcoff, dstoff, tzname): + self.utcoff = utcoff + self.dstoff = dstoff + self.tzname = tzname + + def __eq__(self, other): + return ( + self.utcoff == other.utcoff + and self.dstoff == other.dstoff + and self.tzname == other.tzname + ) + + def __repr__(self): # pragma: nocover + return ( + f"{self.__class__.__name__}" + + f"({self.utcoff}, {self.dstoff}, {self.tzname})" + ) + + +_NO_TTINFO = _ttinfo(None, None, None) + + +class _TZStr: + __slots__ = ( + "std", + "dst", + "start", + "end", + "get_trans_info", + "get_trans_info_fromutc", + "dst_diff", + ) + + def __init__( + self, std_abbr, std_offset, dst_abbr, dst_offset, start=None, end=None + ): + self.dst_diff = dst_offset - std_offset + std_offset = _load_timedelta(std_offset) + self.std = _ttinfo( + utcoff=std_offset, dstoff=_load_timedelta(0), tzname=std_abbr + ) + + self.start = start + self.end = end + + dst_offset = _load_timedelta(dst_offset) + delta = _load_timedelta(self.dst_diff) + self.dst = _ttinfo(utcoff=dst_offset, dstoff=delta, tzname=dst_abbr) + + # These are assertions because the constructor should only be called + # by functions that would fail before passing start or end + assert start is not None, "No transition start specified" + assert end is not None, "No transition end specified" + + self.get_trans_info = self._get_trans_info + self.get_trans_info_fromutc = self._get_trans_info_fromutc + + def transitions(self, year): + start = self.start.year_to_epoch(year) + end = self.end.year_to_epoch(year) + return start, end + + def _get_trans_info(self, ts, year, fold): + """Get the information about the current transition - tti""" + start, end = self.transitions(year) + + # With fold = 0, the period (denominated in local time) with the + # smaller offset starts at the end of the gap and ends at the end of + # the fold; with fold = 1, it runs from the start of the gap to the + # beginning of the fold. + # + # So in order to determine the DST boundaries we need to know both + # the fold and whether DST is positive or negative (rare), and it + # turns out that this boils down to fold XOR is_positive. + if fold == (self.dst_diff >= 0): + end -= self.dst_diff + else: + start += self.dst_diff + + if start < end: + isdst = start <= ts < end + else: + isdst = not (end <= ts < start) + + return self.dst if isdst else self.std + + def _get_trans_info_fromutc(self, ts, year): + start, end = self.transitions(year) + start -= self.std.utcoff.total_seconds() + end -= self.dst.utcoff.total_seconds() + + if start < end: + isdst = start <= ts < end + else: + isdst = not (end <= ts < start) + + # For positive DST, the ambiguous period is one dst_diff after the end + # of DST; for negative DST, the ambiguous period is one dst_diff before + # the start of DST. + if self.dst_diff > 0: + ambig_start = end + ambig_end = end + self.dst_diff + else: + ambig_start = start + ambig_end = start - self.dst_diff + + fold = ambig_start <= ts < ambig_end + + return (self.dst if isdst else self.std, fold) + + +def _post_epoch_days_before_year(year): + """Get the number of days between 1970-01-01 and YEAR-01-01""" + y = year - 1 + return y * 365 + y // 4 - y // 100 + y // 400 - EPOCHORDINAL + + +class _DayOffset: + __slots__ = ["d", "julian", "hour", "minute", "second"] + + def __init__(self, d, julian, hour=2, minute=0, second=0): + min_day = 0 + julian # convert bool to int + if not min_day <= d <= 365: + raise ValueError(f"d must be in [{min_day}, 365], not: {d}") + + self.d = d + self.julian = julian + self.hour = hour + self.minute = minute + self.second = second + + def year_to_epoch(self, year): + days_before_year = _post_epoch_days_before_year(year) + + d = self.d + if self.julian and d >= 59 and calendar.isleap(year): + d += 1 + + epoch = (days_before_year + d) * 86400 + epoch += self.hour * 3600 + self.minute * 60 + self.second + + return epoch + + +class _CalendarOffset: + __slots__ = ["m", "w", "d", "hour", "minute", "second"] + + _DAYS_BEFORE_MONTH = ( + -1, + 0, + 31, + 59, + 90, + 120, + 151, + 181, + 212, + 243, + 273, + 304, + 334, + ) + + def __init__(self, m, w, d, hour=2, minute=0, second=0): + if not 1 <= m <= 12: + raise ValueError("m must be in [1, 12]") + + if not 1 <= w <= 5: + raise ValueError("w must be in [1, 5]") + + if not 0 <= d <= 6: + raise ValueError("d must be in [0, 6]") + + self.m = m + self.w = w + self.d = d + self.hour = hour + self.minute = minute + self.second = second + + @classmethod + def _ymd2ord(cls, year, month, day): + return ( + _post_epoch_days_before_year(year) + + cls._DAYS_BEFORE_MONTH[month] + + (month > 2 and calendar.isleap(year)) + + day + ) + + # TODO: These are not actually epoch dates as they are expressed in local time + def year_to_epoch(self, year): + """Calculates the datetime of the occurrence from the year""" + # We know year and month, we need to convert w, d into day of month + # + # Week 1 is the first week in which day `d` (where 0 = Sunday) appears. + # Week 5 represents the last occurrence of day `d`, so we need to know + # the range of the month. + first_day, days_in_month = calendar.monthrange(year, self.m) + + # This equation seems magical, so I'll break it down: + # 1. calendar says 0 = Monday, POSIX says 0 = Sunday + # so we need first_day + 1 to get 1 = Monday -> 7 = Sunday, + # which is still equivalent because this math is mod 7 + # 2. Get first day - desired day mod 7: -1 % 7 = 6, so we don't need + # to do anything to adjust negative numbers. + # 3. Add 1 because month days are a 1-based index. + month_day = (self.d - (first_day + 1)) % 7 + 1 + + # Now use a 0-based index version of `w` to calculate the w-th + # occurrence of `d` + month_day += (self.w - 1) * 7 + + # month_day will only be > days_in_month if w was 5, and `w` means + # "last occurrence of `d`", so now we just check if we over-shot the + # end of the month and if so knock off 1 week. + if month_day > days_in_month: + month_day -= 7 + + ordinal = self._ymd2ord(year, self.m, month_day) + epoch = ordinal * 86400 + epoch += self.hour * 3600 + self.minute * 60 + self.second + return epoch + + +def _parse_tz_str(tz_str): + # The tz string has the format: + # + # std[offset[dst[offset],start[/time],end[/time]]] + # + # std and dst must be 3 or more characters long and must not contain + # a leading colon, embedded digits, commas, nor a plus or minus signs; + # The spaces between "std" and "offset" are only for display and are + # not actually present in the string. + # + # The format of the offset is ``[+|-]hh[:mm[:ss]]`` + + offset_str, *start_end_str = tz_str.split(",", 1) + + parser_re = re.compile( + r""" + (?P[^<0-9:.+-]+|<[a-zA-Z0-9+-]+>) + (?: + (?P[+-]?\d{1,3}(?::\d{2}(?::\d{2})?)?) + (?: + (?P[^0-9:.+-]+|<[a-zA-Z0-9+-]+>) + (?P[+-]?\d{1,3}(?::\d{2}(?::\d{2})?)?)? + )? # dst + )? # stdoff + """, + re.ASCII|re.VERBOSE + ) + + m = parser_re.fullmatch(offset_str) + + if m is None: + raise ValueError(f"{tz_str} is not a valid TZ string") + + std_abbr = m.group("std") + dst_abbr = m.group("dst") + dst_offset = None + + std_abbr = std_abbr.strip("<>") + + if dst_abbr: + dst_abbr = dst_abbr.strip("<>") + + if std_offset := m.group("stdoff"): + try: + std_offset = _parse_tz_delta(std_offset) + except ValueError as e: + raise ValueError(f"Invalid STD offset in {tz_str}") from e + else: + std_offset = 0 + + if dst_abbr is not None: + if dst_offset := m.group("dstoff"): + try: + dst_offset = _parse_tz_delta(dst_offset) + except ValueError as e: + raise ValueError(f"Invalid DST offset in {tz_str}") from e + else: + dst_offset = std_offset + 3600 + + if not start_end_str: + raise ValueError(f"Missing transition rules: {tz_str}") + + start_end_strs = start_end_str[0].split(",", 1) + try: + start, end = (_parse_dst_start_end(x) for x in start_end_strs) + except ValueError as e: + raise ValueError(f"Invalid TZ string: {tz_str}") from e + + return _TZStr(std_abbr, std_offset, dst_abbr, dst_offset, start, end) + elif start_end_str: + raise ValueError(f"Transition rule present without DST: {tz_str}") + else: + # This is a static ttinfo, don't return _TZStr + return _ttinfo( + _load_timedelta(std_offset), _load_timedelta(0), std_abbr + ) + + +def _parse_dst_start_end(dststr): + date, *time = dststr.split("/", 1) + type = date[:1] + if type == "M": + n_is_julian = False + m = re.fullmatch(r"M(\d{1,2})\.(\d).(\d)", date, re.ASCII) + if m is None: + raise ValueError(f"Invalid dst start/end date: {dststr}") + date_offset = tuple(map(int, m.groups())) + offset = _CalendarOffset(*date_offset) + else: + if type == "J": + n_is_julian = True + date = date[1:] + else: + n_is_julian = False + + doy = int(date) + offset = _DayOffset(doy, n_is_julian) + + if time: + offset.hour, offset.minute, offset.second = _parse_transition_time(time[0]) + + return offset + + +def _parse_transition_time(time_str): + match = re.fullmatch( + r"(?P[+-])?(?P\d{1,3})(:(?P\d{2})(:(?P\d{2}))?)?", + time_str, + re.ASCII + ) + if match is None: + raise ValueError(f"Invalid time: {time_str}") + + h, m, s = (int(v or 0) for v in match.group("h", "m", "s")) + + if h > 167: + raise ValueError( + f"Hour must be in [0, 167]: {time_str}" + ) + + if match.group("sign") == "-": + h, m, s = -h, -m, -s + + return h, m, s + + +def _parse_tz_delta(tz_delta): + match = re.fullmatch( + r"(?P[+-])?(?P\d{1,3})(:(?P\d{2})(:(?P\d{2}))?)?", + tz_delta, + re.ASCII + ) + # Anything passed to this function should already have hit an equivalent + # regular expression to find the section to parse. + assert match is not None, tz_delta + + h, m, s = (int(v or 0) for v in match.group("h", "m", "s")) + + total = h * 3600 + m * 60 + s + + if h > 24: + raise ValueError( + f"Offset hours must be in [0, 24]: {tz_delta}" + ) + + # Yes, +5 maps to an offset of -5h + if match.group("sign") != "-": + total = -total + + return total diff --git a/physworld_p1_20261018/envs/p1/lib/sqlite3.40.0/libsqlite3.40.0.so b/physworld_p1_20261018/envs/p1/lib/sqlite3.40.0/libsqlite3.40.0.so new file mode 100644 index 0000000000000000000000000000000000000000..ba4e80f641b785a3ce1a0ee7b18e8ffa9d297b87 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/sqlite3.40.0/libsqlite3.40.0.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7432dd221132c301970e9f526a9654b10cbd53bb92b1f0cb3d6d899877ff8c53 +size 1581720 diff --git a/physworld_p1_20261018/envs/p1/lib/sqlite3.40.0/pkgIndex.tcl b/physworld_p1_20261018/envs/p1/lib/sqlite3.40.0/pkgIndex.tcl new file mode 100644 index 0000000000000000000000000000000000000000..5483b0912db757c4e359b891045a45d573d1a762 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/sqlite3.40.0/pkgIndex.tcl @@ -0,0 +1,12 @@ +# -*- tcl -*- +# Tcl package index file, version 1.1 +# +# Note sqlite*3* init specifically +# +if {[package vsatisfies [package provide Tcl] 9.0-]} { + package ifneeded sqlite3 3.40.0 \ + [list load [file join $dir libtcl9sqlite3.40.0.so] Sqlite3] +} else { + package ifneeded sqlite3 3.40.0 \ + [list load [file join $dir libsqlite3.40.0.so] Sqlite3] +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/auto.tcl b/physworld_p1_20261018/envs/p1/lib/tcl8.6/auto.tcl new file mode 100644 index 0000000000000000000000000000000000000000..7d23b6ed4925ecc90b214fe93d5a59bf3b3421c7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/auto.tcl @@ -0,0 +1,648 @@ +# auto.tcl -- +# +# utility procs formerly in init.tcl dealing with auto execution of commands +# and can be auto loaded themselves. +# +# Copyright (c) 1991-1993 The Regents of the University of California. +# Copyright (c) 1994-1998 Sun Microsystems, Inc. +# +# See the file "license.terms" for information on usage and redistribution of +# this file, and for a DISCLAIMER OF ALL WARRANTIES. +# + +# auto_reset -- +# +# Destroy all cached information for auto-loading and auto-execution, so that +# the information gets recomputed the next time it's needed. Also delete any +# commands that are listed in the auto-load index. +# +# Arguments: +# None. + +proc auto_reset {} { + global auto_execs auto_index auto_path + if {[array exists auto_index]} { + foreach cmdName [array names auto_index] { + set fqcn [namespace which $cmdName] + if {$fqcn eq ""} { + continue + } + rename $fqcn {} + } + } + unset -nocomplain auto_execs auto_index ::tcl::auto_oldpath + if {[catch {llength $auto_path}]} { + set auto_path [list [info library]] + } elseif {[info library] ni $auto_path} { + lappend auto_path [info library] + } +} + +# tcl_findLibrary -- +# +# This is a utility for extensions that searches for a library directory +# using a canonical searching algorithm. A side effect is to source the +# initialization script and set a global library variable. +# +# Arguments: +# basename Prefix of the directory name, (e.g., "tk") +# version Version number of the package, (e.g., "8.0") +# patch Patchlevel of the package, (e.g., "8.0.3") +# initScript Initialization script to source (e.g., tk.tcl) +# enVarName environment variable to honor (e.g., TK_LIBRARY) +# varName Global variable to set when done (e.g., tk_library) + +proc tcl_findLibrary {basename version patch initScript enVarName varName} { + upvar #0 $varName the_library + global auto_path env tcl_platform + + set dirs {} + set errors {} + + # The C application may have hardwired a path, which we honor + + if {[info exists the_library] && $the_library ne ""} { + lappend dirs $the_library + } else { + # Do the canonical search + + # 1. From an environment variable, if it exists. Placing this first + # gives the end-user ultimate control to work-around any bugs, or + # to customize. + + if {[info exists env($enVarName)]} { + lappend dirs $env($enVarName) + } + + # 2. In the package script directory registered within the + # configuration of the package itself. + + catch { + lappend dirs [::${basename}::pkgconfig get scriptdir,runtime] + } + + # 3. Relative to auto_path directories. This checks relative to the + # Tcl library as well as allowing loading of libraries added to the + # auto_path that is not relative to the core library or binary paths. + foreach d $auto_path { + lappend dirs [file join $d $basename$version] + if {$tcl_platform(platform) eq "unix" + && $tcl_platform(os) eq "Darwin"} { + # 4. On MacOSX, check the Resources/Scripts subdir too + lappend dirs [file join $d $basename$version Resources Scripts] + } + } + + # 3. Various locations relative to the executable + # ../lib/foo1.0 (From bin directory in install hierarchy) + # ../../lib/foo1.0 (From bin/arch directory in install hierarchy) + # ../library (From unix directory in build hierarchy) + # + # Remaining locations are out of date (when relevant, they ought to be + # covered by the $::auto_path seach above) and disabled. + # + # ../../library (From unix/arch directory in build hierarchy) + # ../../foo1.0.1/library + # (From unix directory in parallel build hierarchy) + # ../../../foo1.0.1/library + # (From unix/arch directory in parallel build hierarchy) + + set parentDir [file dirname [file dirname [info nameofexecutable]]] + set grandParentDir [file dirname $parentDir] + lappend dirs [file join $parentDir lib $basename$version] + lappend dirs [file join $grandParentDir lib $basename$version] + lappend dirs [file join $parentDir library] + if {0} { + lappend dirs [file join $grandParentDir library] + lappend dirs [file join $grandParentDir $basename$patch library] + lappend dirs [file join [file dirname $grandParentDir] \ + $basename$patch library] + } + } + # uniquify $dirs in order + array set seen {} + foreach i $dirs { + # Make sure $i is unique under normalization. Avoid repeated [source]. + if {[interp issafe]} { + # Safe interps have no [file normalize]. + set norm $i + } else { + set norm [file normalize $i] + } + if {[info exists seen($norm)]} { + continue + } + set seen($norm) {} + + set the_library $i + set file [file join $i $initScript] + + # source everything when in a safe interpreter because we have a + # source command, but no file exists command + + if {[interp issafe] || [file exists $file]} { + if {![catch {uplevel #0 [list source $file]} msg opts]} { + return + } + append errors "$file: $msg\n" + append errors [dict get $opts -errorinfo]\n + } + } + unset -nocomplain the_library + set msg "Can't find a usable $initScript in the following directories: \n" + append msg " $dirs\n\n" + append msg "$errors\n\n" + append msg "This probably means that $basename wasn't installed properly.\n" + error $msg +} + + +# ---------------------------------------------------------------------- +# auto_mkindex +# ---------------------------------------------------------------------- +# The following procedures are used to generate the tclIndex file from Tcl +# source files. They use a special safe interpreter to parse Tcl source +# files, writing out index entries as "proc" commands are encountered. This +# implementation won't work in a safe interpreter, since a safe interpreter +# can't create the special parser and mess with its commands. + +if {[interp issafe]} { + return ;# Stop sourcing the file here +} + +# auto_mkindex -- +# Regenerate a tclIndex file from Tcl source files. Takes as argument the +# name of the directory in which the tclIndex file is to be placed, followed +# by any number of glob patterns to use in that directory to locate all of the +# relevant files. +# +# Arguments: +# dir - Name of the directory in which to create an index. + +# args - Any number of additional arguments giving the names of files +# within dir. If no additional are given auto_mkindex will look +# for *.tcl. + +proc auto_mkindex {dir args} { + if {[interp issafe]} { + error "can't generate index within safe interpreter" + } + + set oldDir [pwd] + cd $dir + + append index "# Tcl autoload index file, version 2.0\n" + append index "# This file is generated by the \"auto_mkindex\" command\n" + append index "# and sourced to set up indexing information for one or\n" + append index "# more commands. Typically each line is a command that\n" + append index "# sets an element in the auto_index array, where the\n" + append index "# element name is the name of a command and the value is\n" + append index "# a script that loads the command.\n\n" + if {![llength $args]} { + set args *.tcl + } + + auto_mkindex_parser::init + foreach file [lsort [glob -- {*}$args]] { + try { + append index [auto_mkindex_parser::mkindex $file] + } on error {msg opts} { + cd $oldDir + return -options $opts $msg + } + } + auto_mkindex_parser::cleanup + + set fid [open "tclIndex" w] + puts -nonewline $fid $index + close $fid + cd $oldDir +} + +# Original version of auto_mkindex that just searches the source code for +# "proc" at the beginning of the line. + +proc auto_mkindex_old {dir args} { + set oldDir [pwd] + cd $dir + set dir [pwd] + append index "# Tcl autoload index file, version 2.0\n" + append index "# This file is generated by the \"auto_mkindex\" command\n" + append index "# and sourced to set up indexing information for one or\n" + append index "# more commands. Typically each line is a command that\n" + append index "# sets an element in the auto_index array, where the\n" + append index "# element name is the name of a command and the value is\n" + append index "# a script that loads the command.\n\n" + if {![llength $args]} { + set args *.tcl + } + foreach file [lsort [glob -- {*}$args]] { + set f "" + set error [catch { + set f [open $file] + fconfigure $f -eofchar "\032 {}" + while {[gets $f line] >= 0} { + if {[regexp {^proc[ ]+([^ ]*)} $line match procName]} { + set procName [lindex [auto_qualify $procName "::"] 0] + append index "set [list auto_index($procName)]" + append index " \[list source \[file join \$dir [list $file]\]\]\n" + } + } + close $f + } msg opts] + if {$error} { + catch {close $f} + cd $oldDir + return -options $opts $msg + } + } + set f "" + set error [catch { + set f [open tclIndex w] + puts -nonewline $f $index + close $f + cd $oldDir + } msg opts] + if {$error} { + catch {close $f} + cd $oldDir + error $msg $info $code + return -options $opts $msg + } +} + +# Create a safe interpreter that can be used to parse Tcl source files +# generate a tclIndex file for autoloading. This interp contains commands for +# things that need index entries. Each time a command is executed, it writes +# an entry out to the index file. + +namespace eval auto_mkindex_parser { + variable parser "" ;# parser used to build index + variable index "" ;# maintains index as it is built + variable scriptFile "" ;# name of file being processed + variable contextStack "" ;# stack of namespace scopes + variable imports "" ;# keeps track of all imported cmds + variable initCommands ;# list of commands that create aliases + if {![info exists initCommands]} { + set initCommands [list] + } + + proc init {} { + variable parser + variable initCommands + + if {![interp issafe]} { + set parser [interp create -safe] + $parser hide info + $parser hide rename + $parser hide proc + $parser hide namespace + $parser hide eval + $parser hide puts + foreach ns [$parser invokehidden namespace children ::] { + # MUST NOT DELETE "::tcl" OR BAD THINGS HAPPEN! + if {$ns eq "::tcl"} continue + $parser invokehidden namespace delete $ns + } + foreach cmd [$parser invokehidden info commands ::*] { + $parser invokehidden rename $cmd {} + } + $parser invokehidden proc unknown {args} {} + + # We'll need access to the "namespace" command within the + # interp. Put it back, but move it out of the way. + + $parser expose namespace + $parser invokehidden rename namespace _%@namespace + $parser expose eval + $parser invokehidden rename eval _%@eval + + # Install all the registered psuedo-command implementations + + foreach cmd $initCommands { + eval $cmd + } + } + } + proc cleanup {} { + variable parser + interp delete $parser + unset parser + } +} + +# auto_mkindex_parser::mkindex -- +# +# Used by the "auto_mkindex" command to create a "tclIndex" file for the given +# Tcl source file. Executes the commands in the file, and handles things like +# the "proc" command by adding an entry for the index file. Returns a string +# that represents the index file. +# +# Arguments: +# file Name of Tcl source file to be indexed. + +proc auto_mkindex_parser::mkindex {file} { + variable parser + variable index + variable scriptFile + variable contextStack + variable imports + + set scriptFile $file + + set fid [open $file] + fconfigure $fid -eofchar "\032 {}" + set contents [read $fid] + close $fid + + # There is one problem with sourcing files into the safe interpreter: + # references like "$x" will fail since code is not really being executed + # and variables do not really exist. To avoid this, we replace all $ with + # \0 (literally, the null char) later, when getting proc names we will + # have to reverse this replacement, in case there were any $ in the proc + # name. This will cause a problem if somebody actually tries to have a \0 + # in their proc name. Too bad for them. + set contents [string map [list \$ \0] $contents] + + set index "" + set contextStack "" + set imports "" + + $parser eval $contents + + foreach name $imports { + catch {$parser eval [list _%@namespace forget $name]} + } + return $index +} + +# auto_mkindex_parser::hook command +# +# Registers a Tcl command to evaluate when initializing the child interpreter +# used by the mkindex parser. The command is evaluated in the parent +# interpreter, and can use the variable auto_mkindex_parser::parser to get to +# the child + +proc auto_mkindex_parser::hook {cmd} { + variable initCommands + + lappend initCommands $cmd +} + +# auto_mkindex_parser::slavehook command +# +# Registers a Tcl command to evaluate when initializing the child interpreter +# used by the mkindex parser. The command is evaluated in the child +# interpreter. + +proc auto_mkindex_parser::slavehook {cmd} { + variable initCommands + + # The $parser variable is defined to be the name of the child interpreter + # when this command is used later. + + lappend initCommands "\$parser eval [list $cmd]" +} + +# auto_mkindex_parser::command -- +# +# Registers a new command with the "auto_mkindex_parser" interpreter that +# parses Tcl files. These commands are fake versions of things like the +# "proc" command. When you execute them, they simply write out an entry to a +# "tclIndex" file for auto-loading. +# +# This procedure allows extensions to register their own commands with the +# auto_mkindex facility. For example, a package like [incr Tcl] might +# register a "class" command so that class definitions could be added to a +# "tclIndex" file for auto-loading. +# +# Arguments: +# name Name of command recognized in Tcl files. +# arglist Argument list for command. +# body Implementation of command to handle indexing. + +proc auto_mkindex_parser::command {name arglist body} { + hook [list auto_mkindex_parser::commandInit $name $arglist $body] +} + +# auto_mkindex_parser::commandInit -- +# +# This does the actual work set up by auto_mkindex_parser::command. This is +# called when the interpreter used by the parser is created. +# +# Arguments: +# name Name of command recognized in Tcl files. +# arglist Argument list for command. +# body Implementation of command to handle indexing. + +proc auto_mkindex_parser::commandInit {name arglist body} { + variable parser + + set ns [namespace qualifiers $name] + set tail [namespace tail $name] + if {$ns eq ""} { + set fakeName [namespace current]::_%@fake_$tail + } else { + set fakeName [namespace current]::[string map {:: _} _%@fake_$name] + } + proc $fakeName $arglist $body + + # YUK! Tcl won't let us alias fully qualified command names, so we can't + # handle names like "::itcl::class". Instead, we have to build procs with + # the fully qualified names, and have the procs point to the aliases. + + if {[string match *::* $name]} { + set exportCmd [list _%@namespace export [namespace tail $name]] + $parser eval [list _%@namespace eval $ns $exportCmd] + + # The following proc definition does not work if you want to tolerate + # space or something else diabolical in the procedure name, (i.e., + # space in $alias). The following does not work: + # "_%@eval {$alias} \$args" + # because $alias gets concat'ed to $args. The following does not work + # because $cmd is somehow undefined + # "set cmd {$alias} \; _%@eval {\$cmd} \$args" + # A gold star to someone that can make test autoMkindex-3.3 work + # properly + + set alias [namespace tail $fakeName] + $parser invokehidden proc $name {args} "_%@eval {$alias} \$args" + $parser alias $alias $fakeName + } else { + $parser alias $name $fakeName + } + return +} + +# auto_mkindex_parser::fullname -- +# +# Used by commands like "proc" within the auto_mkindex parser. Returns the +# qualified namespace name for the "name" argument. If the "name" does not +# start with "::", elements are added from the current namespace stack to +# produce a qualified name. Then, the name is examined to see whether or not +# it should really be qualified. If the name has more than the leading "::", +# it is returned as a fully qualified name. Otherwise, it is returned as a +# simple name. That way, the Tcl autoloader will recognize it properly. +# +# Arguments: +# name - Name that is being added to index. + +proc auto_mkindex_parser::fullname {name} { + variable contextStack + + if {![string match ::* $name]} { + foreach ns $contextStack { + set name "${ns}::$name" + if {[string match ::* $name]} { + break + } + } + } + + if {[namespace qualifiers $name] eq ""} { + set name [namespace tail $name] + } elseif {![string match ::* $name]} { + set name "::$name" + } + + # Earlier, mkindex replaced all $'s with \0. Now, we have to reverse that + # replacement. + return [string map [list \0 \$] $name] +} + +# auto_mkindex_parser::indexEntry -- +# +# Used by commands like "proc" within the auto_mkindex parser to add a +# correctly-quoted entry to the index. This is shared code so it is done +# *right*, in one place. +# +# Arguments: +# name - Name that is being added to index. + +proc auto_mkindex_parser::indexEntry {name} { + variable index + variable scriptFile + + # We convert all metacharacters to their backslashed form, and pre-split + # the file name that we know about (which will be a proper list, and so + # correctly quoted). + + set name [string range [list \}[fullname $name]] 2 end] + set filenameParts [file split $scriptFile] + + append index [format \ + {set auto_index(%s) [list source [file join $dir %s]]%s} \ + $name $filenameParts \n] + return +} + +if {[llength $::auto_mkindex_parser::initCommands]} { + return +} + +# Register all of the procedures for the auto_mkindex parser that will build +# the "tclIndex" file. + +# AUTO MKINDEX: proc name arglist body +# Adds an entry to the auto index list for the given procedure name. + +auto_mkindex_parser::command proc {name args} { + indexEntry $name +} + +# Conditionally add support for Tcl byte code files. There are some tricky +# details here. First, we need to get the tbcload library initialized in the +# current interpreter. We cannot load tbcload into the child until we have +# done so because it needs access to the tcl_patchLevel variable. Second, +# because the package index file may defer loading the library until we invoke +# a command, we need to explicitly invoke auto_load to force it to be loaded. +# This should be a noop if the package has already been loaded + +auto_mkindex_parser::hook { + try { + package require tbcload + } on error {} { + # OK, don't have it so do nothing + } on ok {} { + if {[namespace which -command tbcload::bcproc] eq ""} { + auto_load tbcload::bcproc + } + load {} tbcload $auto_mkindex_parser::parser + + # AUTO MKINDEX: tbcload::bcproc name arglist body + # Adds an entry to the auto index list for the given pre-compiled + # procedure name. + + auto_mkindex_parser::commandInit tbcload::bcproc {name args} { + indexEntry $name + } + } +} + +# AUTO MKINDEX: namespace eval name command ?arg arg...? +# Adds the namespace name onto the context stack and evaluates the associated +# body of commands. +# +# AUTO MKINDEX: namespace import ?-force? pattern ?pattern...? +# Performs the "import" action in the parser interpreter. This is important +# for any commands contained in a namespace that affect the index. For +# example, a script may say "itcl::class ...", or it may import "itcl::*" and +# then say "class ...". This procedure does the import operation, but keeps +# track of imported patterns so we can remove the imports later. + +auto_mkindex_parser::command namespace {op args} { + switch -- $op { + eval { + variable parser + variable contextStack + + set name [lindex $args 0] + set args [lrange $args 1 end] + + set contextStack [linsert $contextStack 0 $name] + $parser eval [list _%@namespace eval $name] $args + set contextStack [lrange $contextStack 1 end] + } + import { + variable parser + variable imports + foreach pattern $args { + if {$pattern ne "-force"} { + lappend imports $pattern + } + } + catch {$parser eval "_%@namespace import $args"} + } + ensemble { + variable parser + variable contextStack + if {[lindex $args 0] eq "create"} { + set name ::[join [lreverse $contextStack] ::] + catch { + set name [dict get [lrange $args 1 end] -command] + if {![string match ::* $name]} { + set name ::[join [lreverse $contextStack] ::]$name + } + regsub -all ::+ $name :: name + } + # create artifical proc to force an entry in the tclIndex + $parser eval [list ::proc $name {} {}] + } + } + } +} + +# AUTO MKINDEX: oo::class create name ?definition? +# Adds an entry to the auto index list for the given class name. +auto_mkindex_parser::command oo::class {op name {body ""}} { + if {$op eq "create"} { + indexEntry $name + } +} +auto_mkindex_parser::command class {op name {body ""}} { + if {$op eq "create"} { + indexEntry $name + } +} + +return diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/clock.tcl b/physworld_p1_20261018/envs/p1/lib/tcl8.6/clock.tcl new file mode 100644 index 0000000000000000000000000000000000000000..aa5d228b6dbda12d63137ae800975c17907f3e69 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/clock.tcl @@ -0,0 +1,4546 @@ +#---------------------------------------------------------------------- +# +# clock.tcl -- +# +# This file implements the portions of the [clock] ensemble that are +# coded in Tcl. Refer to the users' manual to see the description of +# the [clock] command and its subcommands. +# +# +#---------------------------------------------------------------------- +# +# Copyright (c) 2004-2007 Kevin B. Kenny +# See the file "license.terms" for information on usage and redistribution +# of this file, and for a DISCLAIMER OF ALL WARRANTIES. +# +#---------------------------------------------------------------------- + +# We must have message catalogs that support the root locale, and we need +# access to the Registry on Windows systems. + +uplevel \#0 { + package require msgcat 1.6 + if { $::tcl_platform(platform) eq {windows} } { + if { [catch { package require registry 1.1 }] } { + namespace eval ::tcl::clock [list variable NoRegistry {}] + } + } +} + +# Put the library directory into the namespace for the ensemble so that the +# library code can find message catalogs and time zone definition files. + +namespace eval ::tcl::clock \ + [list variable LibDir [file dirname [info script]]] + +#---------------------------------------------------------------------- +# +# clock -- +# +# Manipulate times. +# +# The 'clock' command manipulates time. Refer to the user documentation for +# the available subcommands and what they do. +# +#---------------------------------------------------------------------- + +namespace eval ::tcl::clock { + + # Export the subcommands + + namespace export format + namespace export clicks + namespace export microseconds + namespace export milliseconds + namespace export scan + namespace export seconds + namespace export add + + # Import the message catalog commands that we use. + + namespace import ::msgcat::mcload + namespace import ::msgcat::mclocale + namespace import ::msgcat::mc + namespace import ::msgcat::mcpackagelocale + +} + +#---------------------------------------------------------------------- +# +# ::tcl::clock::Initialize -- +# +# Finish initializing the 'clock' subsystem +# +# Results: +# None. +# +# Side effects: +# Namespace variable in the 'clock' subsystem are initialized. +# +# The '::tcl::clock::Initialize' procedure initializes the namespace variables +# and root locale message catalog for the 'clock' subsystem. It is broken +# into a procedure rather than simply evaluated as a script so that it will be +# able to use local variables, avoiding the dangers of 'creative writing' as +# in Bug 1185933. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::Initialize {} { + + rename ::tcl::clock::Initialize {} + + variable LibDir + + # Define the Greenwich time zone + + proc InitTZData {} { + variable TZData + array unset TZData + set TZData(:Etc/GMT) { + {-9223372036854775808 0 0 GMT} + } + set TZData(:GMT) $TZData(:Etc/GMT) + set TZData(:Etc/UTC) { + {-9223372036854775808 0 0 UTC} + } + set TZData(:UTC) $TZData(:Etc/UTC) + set TZData(:localtime) {} + } + InitTZData + + mcpackagelocale set {} + ::msgcat::mcpackageconfig set mcfolder [file join $LibDir msgs] + ::msgcat::mcpackageconfig set unknowncmd "" + ::msgcat::mcpackageconfig set changecmd ChangeCurrentLocale + + # Define the message catalog for the root locale. + + ::msgcat::mcmset {} { + AM {am} + BCE {B.C.E.} + CE {C.E.} + DATE_FORMAT {%m/%d/%Y} + DATE_TIME_FORMAT {%a %b %e %H:%M:%S %Y} + DAYS_OF_WEEK_ABBREV { + Sun Mon Tue Wed Thu Fri Sat + } + DAYS_OF_WEEK_FULL { + Sunday Monday Tuesday Wednesday Thursday Friday Saturday + } + GREGORIAN_CHANGE_DATE 2299161 + LOCALE_DATE_FORMAT {%m/%d/%Y} + LOCALE_DATE_TIME_FORMAT {%a %b %e %H:%M:%S %Y} + LOCALE_ERAS {} + LOCALE_NUMERALS { + 00 01 02 03 04 05 06 07 08 09 + 10 11 12 13 14 15 16 17 18 19 + 20 21 22 23 24 25 26 27 28 29 + 30 31 32 33 34 35 36 37 38 39 + 40 41 42 43 44 45 46 47 48 49 + 50 51 52 53 54 55 56 57 58 59 + 60 61 62 63 64 65 66 67 68 69 + 70 71 72 73 74 75 76 77 78 79 + 80 81 82 83 84 85 86 87 88 89 + 90 91 92 93 94 95 96 97 98 99 + } + LOCALE_TIME_FORMAT {%H:%M:%S} + LOCALE_YEAR_FORMAT {%EC%Ey} + MONTHS_ABBREV { + Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec + } + MONTHS_FULL { + January February March + April May June + July August September + October November December + } + PM {pm} + TIME_FORMAT {%H:%M:%S} + TIME_FORMAT_12 {%I:%M:%S %P} + TIME_FORMAT_24 {%H:%M} + TIME_FORMAT_24_SECS {%H:%M:%S} + } + + # Define a few Gregorian change dates for other locales. In most cases + # the change date follows a language, because a nation's colonies changed + # at the same time as the nation itself. In many cases, different + # national boundaries existed; the dominating rule is to follow the + # nation's capital. + + # Italy, Spain, Portugal, Poland + + ::msgcat::mcset it GREGORIAN_CHANGE_DATE 2299161 + ::msgcat::mcset es GREGORIAN_CHANGE_DATE 2299161 + ::msgcat::mcset pt GREGORIAN_CHANGE_DATE 2299161 + ::msgcat::mcset pl GREGORIAN_CHANGE_DATE 2299161 + + # France, Austria + + ::msgcat::mcset fr GREGORIAN_CHANGE_DATE 2299227 + + # For Belgium, we follow Southern Netherlands; Liege Diocese changed + # several weeks later. + + ::msgcat::mcset fr_BE GREGORIAN_CHANGE_DATE 2299238 + ::msgcat::mcset nl_BE GREGORIAN_CHANGE_DATE 2299238 + + # Austria + + ::msgcat::mcset de_AT GREGORIAN_CHANGE_DATE 2299527 + + # Hungary + + ::msgcat::mcset hu GREGORIAN_CHANGE_DATE 2301004 + + # Germany, Norway, Denmark (Catholic Germany changed earlier) + + ::msgcat::mcset de_DE GREGORIAN_CHANGE_DATE 2342032 + ::msgcat::mcset nb GREGORIAN_CHANGE_DATE 2342032 + ::msgcat::mcset nn GREGORIAN_CHANGE_DATE 2342032 + ::msgcat::mcset no GREGORIAN_CHANGE_DATE 2342032 + ::msgcat::mcset da GREGORIAN_CHANGE_DATE 2342032 + + # Holland (Brabant, Gelderland, Flanders, Friesland, etc. changed at + # various times) + + ::msgcat::mcset nl GREGORIAN_CHANGE_DATE 2342165 + + # Protestant Switzerland (Catholic cantons changed earlier) + + ::msgcat::mcset fr_CH GREGORIAN_CHANGE_DATE 2361342 + ::msgcat::mcset it_CH GREGORIAN_CHANGE_DATE 2361342 + ::msgcat::mcset de_CH GREGORIAN_CHANGE_DATE 2361342 + + # English speaking countries + + ::msgcat::mcset en GREGORIAN_CHANGE_DATE 2361222 + + # Sweden (had several changes onto and off of the Gregorian calendar) + + ::msgcat::mcset sv GREGORIAN_CHANGE_DATE 2361390 + + # Russia + + ::msgcat::mcset ru GREGORIAN_CHANGE_DATE 2421639 + + # Romania (Transylvania changed earler - perhaps de_RO should show the + # earlier date?) + + ::msgcat::mcset ro GREGORIAN_CHANGE_DATE 2422063 + + # Greece + + ::msgcat::mcset el GREGORIAN_CHANGE_DATE 2423480 + + #------------------------------------------------------------------ + # + # CONSTANTS + # + #------------------------------------------------------------------ + + # Paths at which binary time zone data for the Olson libraries are known + # to reside on various operating systems + + variable ZoneinfoPaths {} + foreach path { + /usr/share/zoneinfo + /usr/share/lib/zoneinfo + /usr/lib/zoneinfo + /usr/local/etc/zoneinfo + } { + if { [file isdirectory $path] } { + lappend ZoneinfoPaths $path + } + } + + # Define the directories for time zone data and message catalogs. + + variable DataDir [file join $LibDir tzdata] + + # Number of days in the months, in common years and leap years. + + variable DaysInRomanMonthInCommonYear \ + { 31 28 31 30 31 30 31 31 30 31 30 31 } + variable DaysInRomanMonthInLeapYear \ + { 31 29 31 30 31 30 31 31 30 31 30 31 } + variable DaysInPriorMonthsInCommonYear [list 0] + variable DaysInPriorMonthsInLeapYear [list 0] + set i 0 + foreach j $DaysInRomanMonthInCommonYear { + lappend DaysInPriorMonthsInCommonYear [incr i $j] + } + set i 0 + foreach j $DaysInRomanMonthInLeapYear { + lappend DaysInPriorMonthsInLeapYear [incr i $j] + } + + # Another epoch (Hi, Jeff!) + + variable Roddenberry 1946 + + # Integer ranges + + variable MINWIDE -9223372036854775808 + variable MAXWIDE 9223372036854775807 + + # Day before Leap Day + + variable FEB_28 58 + + # Translation table to map Windows TZI onto cities, so that the Olson + # rules can apply. In some cases the mapping is ambiguous, so it's wise + # to specify $::env(TCL_TZ) rather than simply depending on the system + # time zone. + + # The keys are long lists of values obtained from the time zone + # information in the Registry. In order, the list elements are: + # Bias StandardBias DaylightBias + # StandardDate.wYear StandardDate.wMonth StandardDate.wDayOfWeek + # StandardDate.wDay StandardDate.wHour StandardDate.wMinute + # StandardDate.wSecond StandardDate.wMilliseconds + # DaylightDate.wYear DaylightDate.wMonth DaylightDate.wDayOfWeek + # DaylightDate.wDay DaylightDate.wHour DaylightDate.wMinute + # DaylightDate.wSecond DaylightDate.wMilliseconds + # The values are the names of time zones where those rules apply. There + # is considerable ambiguity in certain zones; an attempt has been made to + # make a reasonable guess, but this table needs to be taken with a grain + # of salt. + + variable WinZoneInfo [dict create {*}{ + {-43200 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Pacific/Kwajalein + {-39600 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Pacific/Midway + {-36000 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Pacific/Honolulu + {-32400 0 3600 0 11 0 1 2 0 0 0 0 3 0 2 2 0 0 0} :America/Anchorage + {-28800 0 3600 0 11 0 1 2 0 0 0 0 3 0 2 2 0 0 0} :America/Los_Angeles + {-28800 0 3600 0 10 0 5 2 0 0 0 0 4 0 1 2 0 0 0} :America/Tijuana + {-25200 0 3600 0 11 0 1 2 0 0 0 0 3 0 2 2 0 0 0} :America/Denver + {-25200 0 3600 0 10 0 5 2 0 0 0 0 4 0 1 2 0 0 0} :America/Chihuahua + {-25200 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :America/Phoenix + {-21600 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :America/Regina + {-21600 0 3600 0 11 0 1 2 0 0 0 0 3 0 2 2 0 0 0} :America/Chicago + {-21600 0 3600 0 10 0 5 2 0 0 0 0 4 0 1 2 0 0 0} :America/Mexico_City + {-18000 0 3600 0 11 0 1 2 0 0 0 0 3 0 2 2 0 0 0} :America/New_York + {-18000 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :America/Indianapolis + {-14400 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :America/Caracas + {-14400 0 3600 0 3 6 2 23 59 59 999 0 10 6 2 23 59 59 999} + :America/Santiago + {-14400 0 3600 0 2 0 5 2 0 0 0 0 11 0 1 2 0 0 0} :America/Manaus + {-14400 0 3600 0 11 0 1 2 0 0 0 0 3 0 2 2 0 0 0} :America/Halifax + {-12600 0 3600 0 10 0 5 2 0 0 0 0 4 0 1 2 0 0 0} :America/St_Johns + {-10800 0 3600 0 2 0 2 2 0 0 0 0 10 0 3 2 0 0 0} :America/Sao_Paulo + {-10800 0 3600 0 10 0 5 2 0 0 0 0 4 0 1 2 0 0 0} :America/Godthab + {-10800 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :America/Buenos_Aires + {-10800 0 3600 0 2 0 5 2 0 0 0 0 11 0 1 2 0 0 0} :America/Bahia + {-10800 0 3600 0 3 0 2 2 0 0 0 0 10 0 1 2 0 0 0} :America/Montevideo + {-7200 0 3600 0 9 0 5 2 0 0 0 0 3 0 5 2 0 0 0} :America/Noronha + {-3600 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Atlantic/Azores + {-3600 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Atlantic/Cape_Verde + {0 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :UTC + {0 0 3600 0 10 0 5 2 0 0 0 0 3 0 5 1 0 0 0} :Europe/London + {3600 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Africa/Kinshasa + {3600 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :CET + {7200 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Africa/Harare + {7200 0 3600 0 9 4 5 23 59 59 0 0 4 4 5 23 59 59 0} + :Africa/Cairo + {7200 0 3600 0 10 0 5 4 0 0 0 0 3 0 5 3 0 0 0} :Europe/Helsinki + {7200 0 3600 0 9 0 3 2 0 0 0 0 3 5 5 2 0 0 0} :Asia/Jerusalem + {7200 0 3600 0 9 0 5 1 0 0 0 0 3 0 5 0 0 0 0} :Europe/Bucharest + {7200 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Europe/Athens + {7200 0 3600 0 9 5 5 1 0 0 0 0 3 4 5 0 0 0 0} :Asia/Amman + {7200 0 3600 0 10 6 5 23 59 59 999 0 3 0 5 0 0 0 0} + :Asia/Beirut + {7200 0 -3600 0 4 0 1 2 0 0 0 0 9 0 1 2 0 0 0} :Africa/Windhoek + {10800 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Riyadh + {10800 0 3600 0 10 0 1 4 0 0 0 0 4 0 1 3 0 0 0} :Asia/Baghdad + {10800 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Europe/Moscow + {12600 0 3600 0 9 2 4 2 0 0 0 0 3 0 1 2 0 0 0} :Asia/Tehran + {14400 0 3600 0 10 0 5 5 0 0 0 0 3 0 5 4 0 0 0} :Asia/Baku + {14400 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Muscat + {14400 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Asia/Tbilisi + {16200 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Kabul + {18000 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Karachi + {18000 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Asia/Yekaterinburg + {19800 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Calcutta + {20700 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Katmandu + {21600 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Dhaka + {21600 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Asia/Novosibirsk + {23400 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Rangoon + {25200 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Bangkok + {25200 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Asia/Krasnoyarsk + {28800 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Chongqing + {28800 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Asia/Irkutsk + {32400 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Asia/Tokyo + {32400 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Asia/Yakutsk + {34200 0 3600 0 3 0 5 3 0 0 0 0 10 0 5 2 0 0 0} :Australia/Adelaide + {34200 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Australia/Darwin + {36000 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Australia/Brisbane + {36000 0 3600 0 10 0 5 3 0 0 0 0 3 0 5 2 0 0 0} :Asia/Vladivostok + {36000 0 3600 0 3 0 5 3 0 0 0 0 10 0 1 2 0 0 0} :Australia/Hobart + {36000 0 3600 0 3 0 5 3 0 0 0 0 10 0 5 2 0 0 0} :Australia/Sydney + {39600 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Pacific/Noumea + {43200 0 3600 0 3 0 3 3 0 0 0 0 10 0 1 2 0 0 0} :Pacific/Auckland + {43200 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Pacific/Fiji + {46800 0 3600 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0} :Pacific/Tongatapu + }] + + # Groups of fields that specify the date, priorities, and code bursts that + # determine Julian Day Number given those groups. The code in [clock + # scan] will choose the highest priority (lowest numbered) set of fields + # that determines the date. + + variable DateParseActions { + + { seconds } 0 {} + + { julianDay } 1 {} + + { era century yearOfCentury month dayOfMonth } 2 { + dict set date year [expr { 100 * [dict get $date century] + + [dict get $date yearOfCentury] }] + set date [GetJulianDayFromEraYearMonthDay $date[set date {}] \ + $changeover] + } + { era century yearOfCentury dayOfYear } 2 { + dict set date year [expr { 100 * [dict get $date century] + + [dict get $date yearOfCentury] }] + set date [GetJulianDayFromEraYearDay $date[set date {}] \ + $changeover] + } + + { century yearOfCentury month dayOfMonth } 3 { + dict set date era CE + dict set date year [expr { 100 * [dict get $date century] + + [dict get $date yearOfCentury] }] + set date [GetJulianDayFromEraYearMonthDay $date[set date {}] \ + $changeover] + } + { century yearOfCentury dayOfYear } 3 { + dict set date era CE + dict set date year [expr { 100 * [dict get $date century] + + [dict get $date yearOfCentury] }] + set date [GetJulianDayFromEraYearDay $date[set date {}] \ + $changeover] + } + { iso8601Century iso8601YearOfCentury iso8601Week dayOfWeek } 3 { + dict set date era CE + dict set date iso8601Year \ + [expr { 100 * [dict get $date iso8601Century] + + [dict get $date iso8601YearOfCentury] }] + set date [GetJulianDayFromEraYearWeekDay $date[set date {}] \ + $changeover] + } + + { yearOfCentury month dayOfMonth } 4 { + set date [InterpretTwoDigitYear $date[set date {}] $baseTime] + dict set date era CE + set date [GetJulianDayFromEraYearMonthDay $date[set date {}] \ + $changeover] + } + { yearOfCentury dayOfYear } 4 { + set date [InterpretTwoDigitYear $date[set date {}] $baseTime] + dict set date era CE + set date [GetJulianDayFromEraYearDay $date[set date {}] \ + $changeover] + } + { iso8601YearOfCentury iso8601Week dayOfWeek } 4 { + set date [InterpretTwoDigitYear \ + $date[set date {}] $baseTime \ + iso8601YearOfCentury iso8601Year] + dict set date era CE + set date [GetJulianDayFromEraYearWeekDay $date[set date {}] \ + $changeover] + } + + { month dayOfMonth } 5 { + set date [AssignBaseYear $date[set date {}] \ + $baseTime $timeZone $changeover] + set date [GetJulianDayFromEraYearMonthDay $date[set date {}] \ + $changeover] + } + { dayOfYear } 5 { + set date [AssignBaseYear $date[set date {}] \ + $baseTime $timeZone $changeover] + set date [GetJulianDayFromEraYearDay $date[set date {}] \ + $changeover] + } + { iso8601Week dayOfWeek } 5 { + set date [AssignBaseIso8601Year $date[set date {}] \ + $baseTime $timeZone $changeover] + set date [GetJulianDayFromEraYearWeekDay $date[set date {}] \ + $changeover] + } + + { dayOfMonth } 6 { + set date [AssignBaseMonth $date[set date {}] \ + $baseTime $timeZone $changeover] + set date [GetJulianDayFromEraYearMonthDay $date[set date {}] \ + $changeover] + } + + { dayOfWeek } 7 { + set date [AssignBaseWeek $date[set date {}] \ + $baseTime $timeZone $changeover] + set date [GetJulianDayFromEraYearWeekDay $date[set date {}] \ + $changeover] + } + + {} 8 { + set date [AssignBaseJulianDay $date[set date {}] \ + $baseTime $timeZone $changeover] + } + } + + # Groups of fields that specify time of day, priorities, and code that + # processes them + + variable TimeParseActions { + + seconds 1 {} + + { hourAMPM minute second amPmIndicator } 2 { + dict set date secondOfDay [InterpretHMSP $date] + } + { hour minute second } 2 { + dict set date secondOfDay [InterpretHMS $date] + } + + { hourAMPM minute amPmIndicator } 3 { + dict set date second 0 + dict set date secondOfDay [InterpretHMSP $date] + } + { hour minute } 3 { + dict set date second 0 + dict set date secondOfDay [InterpretHMS $date] + } + + { hourAMPM amPmIndicator } 4 { + dict set date minute 0 + dict set date second 0 + dict set date secondOfDay [InterpretHMSP $date] + } + { hour } 4 { + dict set date minute 0 + dict set date second 0 + dict set date secondOfDay [InterpretHMS $date] + } + + { } 5 { + dict set date secondOfDay 0 + } + } + + # Legacy time zones, used primarily for parsing RFC822 dates. + + variable LegacyTimeZone [dict create \ + gmt +0000 \ + ut +0000 \ + utc +0000 \ + bst +0100 \ + wet +0000 \ + wat -0100 \ + at -0200 \ + nft -0330 \ + nst -0330 \ + ndt -0230 \ + ast -0400 \ + adt -0300 \ + est -0500 \ + edt -0400 \ + cst -0600 \ + cdt -0500 \ + mst -0700 \ + mdt -0600 \ + pst -0800 \ + pdt -0700 \ + yst -0900 \ + ydt -0800 \ + hst -1000 \ + hdt -0900 \ + cat -1000 \ + ahst -1000 \ + nt -1100 \ + idlw -1200 \ + cet +0100 \ + cest +0200 \ + met +0100 \ + mewt +0100 \ + mest +0200 \ + swt +0100 \ + sst +0200 \ + fwt +0100 \ + fst +0200 \ + eet +0200 \ + eest +0300 \ + bt +0300 \ + it +0330 \ + zp4 +0400 \ + zp5 +0500 \ + ist +0530 \ + zp6 +0600 \ + wast +0700 \ + wadt +0800 \ + jt +0730 \ + cct +0800 \ + jst +0900 \ + kst +0900 \ + cast +0930 \ + jdt +1000 \ + kdt +1000 \ + cadt +1030 \ + east +1000 \ + eadt +1030 \ + gst +1000 \ + nzt +1200 \ + nzst +1200 \ + nzdt +1300 \ + idle +1200 \ + a +0100 \ + b +0200 \ + c +0300 \ + d +0400 \ + e +0500 \ + f +0600 \ + g +0700 \ + h +0800 \ + i +0900 \ + k +1000 \ + l +1100 \ + m +1200 \ + n -0100 \ + o -0200 \ + p -0300 \ + q -0400 \ + r -0500 \ + s -0600 \ + t -0700 \ + u -0800 \ + v -0900 \ + w -1000 \ + x -1100 \ + y -1200 \ + z +0000 \ + ] + + # Caches + + variable LocaleNumeralCache {}; # Dictionary whose keys are locale + # names and whose values are pairs + # comprising regexes matching numerals + # in the given locales and dictionaries + # mapping the numerals to their numeric + # values. + # variable CachedSystemTimeZone; # If 'CachedSystemTimeZone' exists, + # it contains the value of the + # system time zone, as determined from + # the environment. + variable TimeZoneBad {}; # Dictionary whose keys are time zone + # names and whose values are 1 if + # the time zone is unknown and 0 + # if it is known. + variable TZData; # Array whose keys are time zone names + # and whose values are lists of quads + # comprising start time, UTC offset, + # Daylight Saving Time indicator, and + # time zone abbreviation. + variable FormatProc; # Array mapping format group + # and locale to the name of a procedure + # that renders the given format +} +::tcl::clock::Initialize + +#---------------------------------------------------------------------- +# +# clock format -- +# +# Formats a count of seconds since the Posix Epoch as a time of day. +# +# The 'clock format' command formats times of day for output. Refer to the +# user documentation to see what it does. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::format { args } { + + variable FormatProc + variable TZData + + lassign [ParseFormatArgs {*}$args] format locale timezone + set locale [string tolower $locale] + set clockval [lindex $args 0] + + # Get the data for time changes in the given zone + + if {$timezone eq ""} { + set timezone [GetSystemTimeZone] + } + if {![info exists TZData($timezone)]} { + if {[catch {SetupTimeZone $timezone} retval opts]} { + dict unset opts -errorinfo + return -options $opts $retval + } + } + + # Build a procedure to format the result. Cache the built procedure's name + # in the 'FormatProc' array to avoid losing its internal representation, + # which contains the name resolution. + + set procName formatproc'$format'$locale + set procName [namespace current]::[string map {: {\:} \\ {\\}} $procName] + if {[info exists FormatProc($procName)]} { + set procName $FormatProc($procName) + } else { + set FormatProc($procName) \ + [ParseClockFormatFormat $procName $format $locale] + } + + return [$procName $clockval $timezone] + +} + +#---------------------------------------------------------------------- +# +# ParseClockFormatFormat -- +# +# Builds and caches a procedure that formats a time value. +# +# Parameters: +# format -- Format string to use +# locale -- Locale in which the format string is to be interpreted +# +# Results: +# Returns the name of the newly-built procedure. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::ParseClockFormatFormat {procName format locale} { + + if {[namespace which $procName] ne {}} { + return $procName + } + + # Map away the locale-dependent composite format groups + + EnterLocale $locale + + # Change locale if a fresh locale has been given on the command line. + + try { + return [ParseClockFormatFormat2 $format $locale $procName] + } trap CLOCK {result opts} { + dict unset opts -errorinfo + return -options $opts $result + } +} + +proc ::tcl::clock::ParseClockFormatFormat2 {format locale procName} { + set didLocaleEra 0 + set didLocaleNumerals 0 + set preFormatCode \ + [string map [list @GREGORIAN_CHANGE_DATE@ \ + [mc GREGORIAN_CHANGE_DATE]] \ + { + variable TZData + set date [GetDateFields $clockval \ + $TZData($timezone) \ + @GREGORIAN_CHANGE_DATE@] + }] + set formatString {} + set substituents {} + set state {} + + set format [LocalizeFormat $locale $format] + + foreach char [split $format {}] { + switch -exact -- $state { + {} { + if { [string equal % $char] } { + set state percent + } else { + append formatString $char + } + } + percent { # Character following a '%' character + set state {} + switch -exact -- $char { + % { # A literal character, '%' + append formatString %% + } + a { # Day of week, abbreviated + append formatString %s + append substituents \ + [string map \ + [list @DAYS_OF_WEEK_ABBREV@ \ + [list [mc DAYS_OF_WEEK_ABBREV]]] \ + { [lindex @DAYS_OF_WEEK_ABBREV@ \ + [expr {[dict get $date dayOfWeek] \ + % 7}]]}] + } + A { # Day of week, spelt out. + append formatString %s + append substituents \ + [string map \ + [list @DAYS_OF_WEEK_FULL@ \ + [list [mc DAYS_OF_WEEK_FULL]]] \ + { [lindex @DAYS_OF_WEEK_FULL@ \ + [expr {[dict get $date dayOfWeek] \ + % 7}]]}] + } + b - h { # Name of month, abbreviated. + append formatString %s + append substituents \ + [string map \ + [list @MONTHS_ABBREV@ \ + [list [mc MONTHS_ABBREV]]] \ + { [lindex @MONTHS_ABBREV@ \ + [expr {[dict get $date month]-1}]]}] + } + B { # Name of month, spelt out + append formatString %s + append substituents \ + [string map \ + [list @MONTHS_FULL@ \ + [list [mc MONTHS_FULL]]] \ + { [lindex @MONTHS_FULL@ \ + [expr {[dict get $date month]-1}]]}] + } + C { # Century number + append formatString %02d + append substituents \ + { [expr {[dict get $date year] / 100}]} + } + d { # Day of month, with leading zero + append formatString %02d + append substituents { [dict get $date dayOfMonth]} + } + e { # Day of month, without leading zero + append formatString %2d + append substituents { [dict get $date dayOfMonth]} + } + E { # Format group in a locale-dependent + # alternative era + set state percentE + if {!$didLocaleEra} { + append preFormatCode \ + [string map \ + [list @LOCALE_ERAS@ \ + [list [mc LOCALE_ERAS]]] \ + { + set date [GetLocaleEra \ + $date[set date {}] \ + @LOCALE_ERAS@]}] \n + set didLocaleEra 1 + } + if {!$didLocaleNumerals} { + append preFormatCode \ + [list set localeNumerals \ + [mc LOCALE_NUMERALS]] \n + set didLocaleNumerals 1 + } + } + g { # Two-digit year relative to ISO8601 + # week number + append formatString %02d + append substituents \ + { [expr { [dict get $date iso8601Year] % 100 }]} + } + G { # Four-digit year relative to ISO8601 + # week number + append formatString %02d + append substituents { [dict get $date iso8601Year]} + } + H { # Hour in the 24-hour day, leading zero + append formatString %02d + append substituents \ + { [expr { [dict get $date localSeconds] \ + / 3600 % 24}]} + } + I { # Hour AM/PM, with leading zero + append formatString %02d + append substituents \ + { [expr { ( ( ( [dict get $date localSeconds] \ + % 86400 ) \ + + 86400 \ + - 3600 ) \ + / 3600 ) \ + % 12 + 1 }] } + } + j { # Day of year (001-366) + append formatString %03d + append substituents { [dict get $date dayOfYear]} + } + J { # Julian Day Number + append formatString %07ld + append substituents { [dict get $date julianDay]} + } + k { # Hour (0-23), no leading zero + append formatString %2d + append substituents \ + { [expr { [dict get $date localSeconds] + / 3600 + % 24 }]} + } + l { # Hour (12-11), no leading zero + append formatString %2d + append substituents \ + { [expr { ( ( ( [dict get $date localSeconds] + % 86400 ) + + 86400 + - 3600 ) + / 3600 ) + % 12 + 1 }]} + } + m { # Month number, leading zero + append formatString %02d + append substituents { [dict get $date month]} + } + M { # Minute of the hour, leading zero + append formatString %02d + append substituents \ + { [expr { [dict get $date localSeconds] + / 60 + % 60 }]} + } + n { # A literal newline + append formatString \n + } + N { # Month number, no leading zero + append formatString %2d + append substituents { [dict get $date month]} + } + O { # A format group in the locale's + # alternative numerals + set state percentO + if {!$didLocaleNumerals} { + append preFormatCode \ + [list set localeNumerals \ + [mc LOCALE_NUMERALS]] \n + set didLocaleNumerals 1 + } + } + p { # Localized 'AM' or 'PM' indicator + # converted to uppercase + append formatString %s + append preFormatCode \ + [list set AM [string toupper [mc AM]]] \n \ + [list set PM [string toupper [mc PM]]] \n + append substituents \ + { [expr {(([dict get $date localSeconds] + % 86400) < 43200) ? + $AM : $PM}]} + } + P { # Localized 'AM' or 'PM' indicator + append formatString %s + append preFormatCode \ + [list set am [mc AM]] \n \ + [list set pm [mc PM]] \n + append substituents \ + { [expr {(([dict get $date localSeconds] + % 86400) < 43200) ? + $am : $pm}]} + + } + Q { # Hi, Jeff! + append formatString %s + append substituents { [FormatStarDate $date]} + } + s { # Seconds from the Posix Epoch + append formatString %s + append substituents { [dict get $date seconds]} + } + S { # Second of the minute, with + # leading zero + append formatString %02d + append substituents \ + { [expr { [dict get $date localSeconds] + % 60 }]} + } + t { # A literal tab character + append formatString \t + } + u { # Day of the week (1-Monday, 7-Sunday) + append formatString %1d + append substituents { [dict get $date dayOfWeek]} + } + U { # Week of the year (00-53). The + # first Sunday of the year is the + # first day of week 01 + append formatString %02d + append preFormatCode { + set dow [dict get $date dayOfWeek] + if { $dow == 7 } { + set dow 0 + } + incr dow + set UweekNumber \ + [expr { ( [dict get $date dayOfYear] + - $dow + 7 ) + / 7 }] + } + append substituents { $UweekNumber} + } + V { # The ISO8601 week number + append formatString %02d + append substituents { [dict get $date iso8601Week]} + } + w { # Day of the week (0-Sunday, + # 6-Saturday) + append formatString %1d + append substituents \ + { [expr { [dict get $date dayOfWeek] % 7 }]} + } + W { # Week of the year (00-53). The first + # Monday of the year is the first day + # of week 01. + append preFormatCode { + set WweekNumber \ + [expr { ( [dict get $date dayOfYear] + - [dict get $date dayOfWeek] + + 7 ) + / 7 }] + } + append formatString %02d + append substituents { $WweekNumber} + } + y { # The two-digit year of the century + append formatString %02d + append substituents \ + { [expr { [dict get $date year] % 100 }]} + } + Y { # The four-digit year + append formatString %04d + append substituents { [dict get $date year]} + } + z { # The time zone as hours and minutes + # east (+) or west (-) of Greenwich + append formatString %s + append substituents { [FormatNumericTimeZone \ + [dict get $date tzOffset]]} + } + Z { # The name of the time zone + append formatString %s + append substituents { [dict get $date tzName]} + } + % { # A literal percent character + append formatString %% + } + default { # An unknown escape sequence + append formatString %% $char + } + } + } + percentE { # Character following %E + set state {} + switch -exact -- $char { + E { + append formatString %s + append substituents { } \ + [string map \ + [list @BCE@ [list [mc BCE]] \ + @CE@ [list [mc CE]]] \ + {[dict get {BCE @BCE@ CE @CE@} \ + [dict get $date era]]}] + } + C { # Locale-dependent era + append formatString %s + append substituents { [dict get $date localeEra]} + } + y { # Locale-dependent year of the era + append preFormatCode { + set y [dict get $date localeYear] + if { $y >= 0 && $y < 100 } { + set Eyear [lindex $localeNumerals $y] + } else { + set Eyear $y + } + } + append formatString %s + append substituents { $Eyear} + } + default { # Unknown %E format group + append formatString %%E $char + } + } + } + percentO { # Character following %O + set state {} + switch -exact -- $char { + d - e { # Day of the month in alternative + # numerals + append formatString %s + append substituents \ + { [lindex $localeNumerals \ + [dict get $date dayOfMonth]]} + } + H - k { # Hour of the day in alternative + # numerals + append formatString %s + append substituents \ + { [lindex $localeNumerals \ + [expr { [dict get $date localSeconds] + / 3600 + % 24 }]]} + } + I - l { # Hour (12-11) AM/PM in alternative + # numerals + append formatString %s + append substituents \ + { [lindex $localeNumerals \ + [expr { ( ( ( [dict get $date localSeconds] + % 86400 ) + + 86400 + - 3600 ) + / 3600 ) + % 12 + 1 }]]} + } + m { # Month number in alternative numerals + append formatString %s + append substituents \ + { [lindex $localeNumerals [dict get $date month]]} + } + M { # Minute of the hour in alternative + # numerals + append formatString %s + append substituents \ + { [lindex $localeNumerals \ + [expr { [dict get $date localSeconds] + / 60 + % 60 }]]} + } + S { # Second of the minute in alternative + # numerals + append formatString %s + append substituents \ + { [lindex $localeNumerals \ + [expr { [dict get $date localSeconds] + % 60 }]]} + } + u { # Day of the week (Monday=1,Sunday=7) + # in alternative numerals + append formatString %s + append substituents \ + { [lindex $localeNumerals \ + [dict get $date dayOfWeek]]} + } + w { # Day of the week (Sunday=0,Saturday=6) + # in alternative numerals + append formatString %s + append substituents \ + { [lindex $localeNumerals \ + [expr { [dict get $date dayOfWeek] % 7 }]]} + } + y { # Year of the century in alternative + # numerals + append formatString %s + append substituents \ + { [lindex $localeNumerals \ + [expr { [dict get $date year] % 100 }]]} + } + default { # Unknown format group + append formatString %%O $char + } + } + } + } + } + + # Clean up any improperly terminated groups + + switch -exact -- $state { + percent { + append formatString %% + } + percentE { + append retval %%E + } + percentO { + append retval %%O + } + } + + proc $procName {clockval timezone} " + $preFormatCode + return \[::format [list $formatString] $substituents\] + " + + # puts [list $procName [info args $procName] [info body $procName]] + + return $procName +} + +#---------------------------------------------------------------------- +# +# clock scan -- +# +# Inputs a count of seconds since the Posix Epoch as a time of day. +# +# The 'clock format' command scans times of day on input. Refer to the user +# documentation to see what it does. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::scan { args } { + + set format {} + + # Check the count of args + + if { [llength $args] < 1 || [llength $args] % 2 != 1 } { + set cmdName "clock scan" + return -code error \ + -errorcode [list CLOCK wrongNumArgs] \ + "wrong \# args: should be\ + \"$cmdName string\ + ?-base seconds?\ + ?-format string? ?-gmt boolean?\ + ?-locale LOCALE? ?-timezone ZONE?\"" + } + + # Set defaults + + set base [clock seconds] + set string [lindex $args 0] + set format {} + set gmt 0 + set locale c + set timezone [GetSystemTimeZone] + + # Pick up command line options. + + foreach { flag value } [lreplace $args 0 0] { + set saw($flag) {} + switch -exact -- $flag { + -b - -ba - -bas - -base { + set base $value + } + -f - -fo - -for - -form - -forma - -format { + set format $value + } + -g - -gm - -gmt { + set gmt $value + } + -l - -lo - -loc - -loca - -local - -locale { + set locale [string tolower $value] + } + -t - -ti - -tim - -time - -timez - -timezo - -timezon - -timezone { + set timezone $value + } + default { + return -code error \ + -errorcode [list CLOCK badOption $flag] \ + "bad option \"$flag\",\ + must be -base, -format, -gmt, -locale or -timezone" + } + } + } + + # Check options for validity + + if { [info exists saw(-gmt)] && [info exists saw(-timezone)] } { + return -code error \ + -errorcode [list CLOCK gmtWithTimezone] \ + "cannot use -gmt and -timezone in same call" + } + if { [catch { expr { wide($base) } } result] } { + return -code error "expected integer but got \"$base\"" + } + if { ![string is boolean -strict $gmt] } { + return -code error "expected boolean value but got \"$gmt\"" + } elseif { $gmt } { + set timezone :GMT + } + + if { ![info exists saw(-format)] } { + # Perhaps someday we'll localize the legacy code. Right now, it's not + # localized. + if { [info exists saw(-locale)] } { + return -code error \ + -errorcode [list CLOCK flagWithLegacyFormat] \ + "legacy \[clock scan\] does not support -locale" + + } + return [FreeScan $string $base $timezone $locale] + } + + # Change locale if a fresh locale has been given on the command line. + + EnterLocale $locale + + try { + # Map away the locale-dependent composite format groups + + set scanner [ParseClockScanFormat $format $locale] + return [$scanner $string $base $timezone] + } trap CLOCK {result opts} { + # Conceal location of generation of expected errors + dict unset opts -errorinfo + return -options $opts $result + } +} + +#---------------------------------------------------------------------- +# +# FreeScan -- +# +# Scans a time in free format +# +# Parameters: +# string - String containing the time to scan +# base - Base time, expressed in seconds from the Epoch +# timezone - Default time zone in which the time will be expressed +# locale - (Unused) Name of the locale where the time will be scanned. +# +# Results: +# Returns the date and time extracted from the string in seconds from +# the epoch +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::FreeScan { string base timezone locale } { + + variable TZData + + # Get the data for time changes in the given zone + + try { + SetupTimeZone $timezone + } on error {retval opts} { + dict unset opts -errorinfo + return -options $opts $retval + } + + # Extract year, month and day from the base time for the parser to use as + # defaults + + set date [GetDateFields $base $TZData($timezone) 2361222] + dict set date secondOfDay [expr { + [dict get $date localSeconds] % 86400 + }] + + # Parse the date. The parser will return a list comprising date, time, + # time zone, relative month/day/seconds, relative weekday, ordinal month. + + try { + set scanned [Oldscan $string \ + [dict get $date year] \ + [dict get $date month] \ + [dict get $date dayOfMonth]] + lassign $scanned \ + parseDate parseTime parseZone parseRel \ + parseWeekday parseOrdinalMonth + } on error message { + return -code error \ + "unable to convert date-time string \"$string\": $message" + } + + # If the caller supplied a date in the string, update the 'date' dict with + # the value. If the caller didn't specify a time with the date, default to + # midnight. + + if { [llength $parseDate] > 0 } { + lassign $parseDate y m d + if { $y < 100 } { + if { $y >= 39 } { + incr y 1900 + } else { + incr y 2000 + } + } + dict set date era CE + dict set date year $y + dict set date month $m + dict set date dayOfMonth $d + if { $parseTime eq {} } { + set parseTime 0 + } + } + + # If the caller supplied a time zone in the string, it comes back as a + # two-element list; the first element is the number of minutes east of + # Greenwich, and the second is a Daylight Saving Time indicator (1 == yes, + # 0 == no, -1 == unknown). We make it into a time zone indicator of + # +-hhmm. + + if { [llength $parseZone] > 0 } { + lassign $parseZone minEast dstFlag + set timezone [FormatNumericTimeZone \ + [expr { 60 * $minEast + 3600 * $dstFlag }]] + SetupTimeZone $timezone + } + dict set date tzName $timezone + + # Assemble date, time, zone into seconds-from-epoch + + set date [GetJulianDayFromEraYearMonthDay $date[set date {}] 2361222] + if { $parseTime ne {} } { + dict set date secondOfDay $parseTime + } elseif { [llength $parseWeekday] != 0 + || [llength $parseOrdinalMonth] != 0 + || ( [llength $parseRel] != 0 + && ( [lindex $parseRel 0] != 0 + || [lindex $parseRel 1] != 0 ) ) } { + dict set date secondOfDay 0 + } + + dict set date localSeconds [expr { + -210866803200 + + ( 86400 * wide([dict get $date julianDay]) ) + + [dict get $date secondOfDay] + }] + dict set date tzName $timezone + set date [ConvertLocalToUTC $date[set date {}] $TZData($timezone) 2361222] + set seconds [dict get $date seconds] + + # Do relative times + + if { [llength $parseRel] > 0 } { + lassign $parseRel relMonth relDay relSecond + set seconds [add $seconds \ + $relMonth months $relDay days $relSecond seconds \ + -timezone $timezone -locale $locale] + } + + # Do relative weekday + + if { [llength $parseWeekday] > 0 } { + lassign $parseWeekday dayOrdinal dayOfWeek + set date2 [GetDateFields $seconds $TZData($timezone) 2361222] + dict set date2 era CE + set jdwkday [WeekdayOnOrBefore $dayOfWeek [expr { + [dict get $date2 julianDay] + 6 + }]] + incr jdwkday [expr { 7 * $dayOrdinal }] + if { $dayOrdinal > 0 } { + incr jdwkday -7 + } + dict set date2 secondOfDay \ + [expr { [dict get $date2 localSeconds] % 86400 }] + dict set date2 julianDay $jdwkday + dict set date2 localSeconds [expr { + -210866803200 + + ( 86400 * wide([dict get $date2 julianDay]) ) + + [dict get $date secondOfDay] + }] + dict set date2 tzName $timezone + set date2 [ConvertLocalToUTC $date2[set date2 {}] $TZData($timezone) \ + 2361222] + set seconds [dict get $date2 seconds] + + } + + # Do relative month + + if { [llength $parseOrdinalMonth] > 0 } { + lassign $parseOrdinalMonth monthOrdinal monthNumber + if { $monthOrdinal > 0 } { + set monthDiff [expr { $monthNumber - [dict get $date month] }] + if { $monthDiff <= 0 } { + incr monthDiff 12 + } + incr monthOrdinal -1 + } else { + set monthDiff [expr { [dict get $date month] - $monthNumber }] + if { $monthDiff >= 0 } { + incr monthDiff -12 + } + incr monthOrdinal + } + set seconds [add $seconds $monthOrdinal years $monthDiff months \ + -timezone $timezone -locale $locale] + } + + return $seconds +} + + +#---------------------------------------------------------------------- +# +# ParseClockScanFormat -- +# +# Parses a format string given to [clock scan -format] +# +# Parameters: +# formatString - The format being parsed +# locale - The current locale +# +# Results: +# Constructs and returns a procedure that accepts the string being +# scanned, the base time, and the time zone. The procedure will either +# return the scanned time or else throw an error that should be rethrown +# to the caller of [clock scan] +# +# Side effects: +# The given procedure is defined in the ::tcl::clock namespace. Scan +# procedures are not deleted once installed. +# +# Why do we parse dates by defining a procedure to parse them? The reason is +# that by doing so, we have one convenient place to cache all the information: +# the regular expressions that match the patterns (which will be compiled), +# the code that assembles the date information, everything lands in one place. +# In this way, when a given format is reused at run time, all the information +# of how to apply it is available in a single place. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::ParseClockScanFormat {formatString locale} { + # Check whether the format has been parsed previously, and return the + # existing recognizer if it has. + + set procName scanproc'$formatString'$locale + set procName [namespace current]::[string map {: {\:} \\ {\\}} $procName] + if { [namespace which $procName] != {} } { + return $procName + } + + variable DateParseActions + variable TimeParseActions + + # Localize the %x, %X, etc. groups + + set formatString [LocalizeFormat $locale $formatString] + + # Condense whitespace + + regsub -all {[[:space:]]+} $formatString { } formatString + + # Walk through the groups of the format string. In this loop, we + # accumulate: + # - a regular expression that matches the string, + # - the count of capturing brackets in the regexp + # - a set of code that post-processes the fields captured by the regexp, + # - a dictionary whose keys are the names of fields that are present + # in the format string. + + set re {^[[:space:]]*} + set captureCount 0 + set postcode {} + set fieldSet [dict create] + set fieldCount 0 + set postSep {} + set state {} + + foreach c [split $formatString {}] { + switch -exact -- $state { + {} { + if { $c eq "%" } { + set state % + } elseif { $c eq " " } { + append re {[[:space:]]+} + } else { + if { ! [string is alnum $c] } { + append re "\\" + } + append re $c + } + } + % { + set state {} + switch -exact -- $c { + % { + append re % + } + { } { + append re "\[\[:space:\]\]*" + } + a - A { # Day of week, in words + set l {} + foreach \ + i {7 1 2 3 4 5 6} \ + abr [mc DAYS_OF_WEEK_ABBREV] \ + full [mc DAYS_OF_WEEK_FULL] { + dict set l [string tolower $abr] $i + dict set l [string tolower $full] $i + incr i + } + lassign [UniquePrefixRegexp $l] regex lookup + append re ( $regex ) + dict set fieldSet dayOfWeek [incr fieldCount] + append postcode "dict set date dayOfWeek \[" \ + "dict get " [list $lookup] " " \ + \[ {string tolower $field} [incr captureCount] \] \ + "\]\n" + } + b - B - h { # Name of month + set i 0 + set l {} + foreach \ + abr [mc MONTHS_ABBREV] \ + full [mc MONTHS_FULL] { + incr i + dict set l [string tolower $abr] $i + dict set l [string tolower $full] $i + } + lassign [UniquePrefixRegexp $l] regex lookup + append re ( $regex ) + dict set fieldSet month [incr fieldCount] + append postcode "dict set date month \[" \ + "dict get " [list $lookup] \ + " " \[ {string tolower $field} \ + [incr captureCount] \] \ + "\]\n" + } + C { # Gregorian century + append re \\s*(\\d\\d?) + dict set fieldSet century [incr fieldCount] + append postcode "dict set date century \[" \ + "::scan \$field" [incr captureCount] " %d" \ + "\]\n" + } + d - e { # Day of month + append re \\s*(\\d\\d?) + dict set fieldSet dayOfMonth [incr fieldCount] + append postcode "dict set date dayOfMonth \[" \ + "::scan \$field" [incr captureCount] " %d" \ + "\]\n" + } + E { # Prefix for locale-specific codes + set state %E + } + g { # ISO8601 2-digit year + append re \\s*(\\d\\d) + dict set fieldSet iso8601YearOfCentury \ + [incr fieldCount] + append postcode \ + "dict set date iso8601YearOfCentury \[" \ + "::scan \$field" [incr captureCount] " %d" \ + "\]\n" + } + G { # ISO8601 4-digit year + append re \\s*(\\d\\d)(\\d\\d) + dict set fieldSet iso8601Century [incr fieldCount] + dict set fieldSet iso8601YearOfCentury \ + [incr fieldCount] + append postcode \ + "dict set date iso8601Century \[" \ + "::scan \$field" [incr captureCount] " %d" \ + "\]\n" \ + "dict set date iso8601YearOfCentury \[" \ + "::scan \$field" [incr captureCount] " %d" \ + "\]\n" + } + H - k { # Hour of day + append re \\s*(\\d\\d?) + dict set fieldSet hour [incr fieldCount] + append postcode "dict set date hour \[" \ + "::scan \$field" [incr captureCount] " %d" \ + "\]\n" + } + I - l { # Hour, AM/PM + append re \\s*(\\d\\d?) + dict set fieldSet hourAMPM [incr fieldCount] + append postcode "dict set date hourAMPM \[" \ + "::scan \$field" [incr captureCount] " %d" \ + "\]\n" + } + j { # Day of year + append re \\s*(\\d\\d?\\d?) + dict set fieldSet dayOfYear [incr fieldCount] + append postcode "dict set date dayOfYear \[" \ + "::scan \$field" [incr captureCount] " %d" \ + "\]\n" + } + J { # Julian Day Number + append re \\s*(\\d+) + dict set fieldSet julianDay [incr fieldCount] + append postcode "dict set date julianDay \[" \ + "::scan \$field" [incr captureCount] " %ld" \ + "\]\n" + } + m - N { # Month number + append re \\s*(\\d\\d?) + dict set fieldSet month [incr fieldCount] + append postcode "dict set date month \[" \ + "::scan \$field" [incr captureCount] " %d" \ + "\]\n" + } + M { # Minute + append re \\s*(\\d\\d?) + dict set fieldSet minute [incr fieldCount] + append postcode "dict set date minute \[" \ + "::scan \$field" [incr captureCount] " %d" \ + "\]\n" + } + n { # Literal newline + append re \\n + } + O { # Prefix for locale numerics + set state %O + } + p - P { # AM/PM indicator + set l [list [string tolower [mc AM]] 0 \ + [string tolower [mc PM]] 1] + lassign [UniquePrefixRegexp $l] regex lookup + append re ( $regex ) + dict set fieldSet amPmIndicator [incr fieldCount] + append postcode "dict set date amPmIndicator \[" \ + "dict get " [list $lookup] " \[string tolower " \ + "\$field" \ + [incr captureCount] \ + "\]\]\n" + } + Q { # Hi, Jeff! + append re {Stardate\s+([-+]?\d+)(\d\d\d)[.](\d)} + incr captureCount + dict set fieldSet seconds [incr fieldCount] + append postcode {dict set date seconds } \[ \ + {ParseStarDate $field} [incr captureCount] \ + { $field} [incr captureCount] \ + { $field} [incr captureCount] \ + \] \n + } + s { # Seconds from Posix Epoch + # This next case is insanely difficult, because it's + # problematic to determine whether the field is + # actually within the range of a wide integer. + append re {\s*([-+]?\d+)} + dict set fieldSet seconds [incr fieldCount] + append postcode {dict set date seconds } \[ \ + {ScanWide $field} [incr captureCount] \] \n + } + S { # Second + append re \\s*(\\d\\d?) + dict set fieldSet second [incr fieldCount] + append postcode "dict set date second \[" \ + "::scan \$field" [incr captureCount] " %d" \ + "\]\n" + } + t { # Literal tab character + append re \\t + } + u - w { # Day number within week, 0 or 7 == Sun + # 1=Mon, 6=Sat + append re \\s*(\\d) + dict set fieldSet dayOfWeek [incr fieldCount] + append postcode {::scan $field} [incr captureCount] \ + { %d dow} \n \ + { + if { $dow == 0 } { + set dow 7 + } elseif { $dow > 7 } { + return -code error \ + -errorcode [list CLOCK badDayOfWeek] \ + "day of week is greater than 7" + } + dict set date dayOfWeek $dow + } + } + U { # Week of year. The first Sunday of + # the year is the first day of week + # 01. No scan rule uses this group. + append re \\s*\\d\\d? + } + V { # Week of ISO8601 year + + append re \\s*(\\d\\d?) + dict set fieldSet iso8601Week [incr fieldCount] + append postcode "dict set date iso8601Week \[" \ + "::scan \$field" [incr captureCount] " %d" \ + "\]\n" + } + W { # Week of the year (00-53). The first + # Monday of the year is the first day + # of week 01. No scan rule uses this + # group. + append re \\s*\\d\\d? + } + y { # Two-digit Gregorian year + append re \\s*(\\d\\d?) + dict set fieldSet yearOfCentury [incr fieldCount] + append postcode "dict set date yearOfCentury \[" \ + "::scan \$field" [incr captureCount] " %d" \ + "\]\n" + } + Y { # 4-digit Gregorian year + append re \\s*(\\d\\d)(\\d\\d) + dict set fieldSet century [incr fieldCount] + dict set fieldSet yearOfCentury [incr fieldCount] + append postcode \ + "dict set date century \[" \ + "::scan \$field" [incr captureCount] " %d" \ + "\]\n" \ + "dict set date yearOfCentury \[" \ + "::scan \$field" [incr captureCount] " %d" \ + "\]\n" + } + z - Z { # Time zone name + append re {(?:([-+]\d\d(?::?\d\d(?::?\d\d)?)?)|([[:alnum:]]{1,4}))} + dict set fieldSet tzName [incr fieldCount] + append postcode \ + {if } \{ { $field} [incr captureCount] \ + { ne "" } \} { } \{ \n \ + {dict set date tzName $field} \ + $captureCount \n \ + \} { else } \{ \n \ + {dict set date tzName } \[ \ + {ConvertLegacyTimeZone $field} \ + [incr captureCount] \] \n \ + \} \n \ + } + % { # Literal percent character + append re % + } + default { + append re % + if { ! [string is alnum $c] } { + append re \\ + } + append re $c + } + } + } + %E { + switch -exact -- $c { + C { # Locale-dependent era + set d {} + foreach triple [mc LOCALE_ERAS] { + lassign $triple t symbol year + dict set d [string tolower $symbol] $year + } + lassign [UniquePrefixRegexp $d] regex lookup + append re (?: $regex ) + } + E { + set l {} + dict set l [string tolower [mc BCE]] BCE + dict set l [string tolower [mc CE]] CE + dict set l b.c.e. BCE + dict set l c.e. CE + dict set l b.c. BCE + dict set l a.d. CE + lassign [UniquePrefixRegexp $l] regex lookup + append re ( $regex ) + dict set fieldSet era [incr fieldCount] + append postcode "dict set date era \["\ + "dict get " [list $lookup] \ + { } \[ {string tolower $field} \ + [incr captureCount] \] \ + "\]\n" + } + y { # Locale-dependent year of the era + lassign [LocaleNumeralMatcher $locale] regex lookup + append re $regex + incr captureCount + } + default { + append re %E + if { ! [string is alnum $c] } { + append re \\ + } + append re $c + } + } + set state {} + } + %O { + switch -exact -- $c { + d - e { + lassign [LocaleNumeralMatcher $locale] regex lookup + append re $regex + dict set fieldSet dayOfMonth [incr fieldCount] + append postcode "dict set date dayOfMonth \[" \ + "dict get " [list $lookup] " \$field" \ + [incr captureCount] \ + "\]\n" + } + H - k { + lassign [LocaleNumeralMatcher $locale] regex lookup + append re $regex + dict set fieldSet hour [incr fieldCount] + append postcode "dict set date hour \[" \ + "dict get " [list $lookup] " \$field" \ + [incr captureCount] \ + "\]\n" + } + I - l { + lassign [LocaleNumeralMatcher $locale] regex lookup + append re $regex + dict set fieldSet hourAMPM [incr fieldCount] + append postcode "dict set date hourAMPM \[" \ + "dict get " [list $lookup] " \$field" \ + [incr captureCount] \ + "\]\n" + } + m { + lassign [LocaleNumeralMatcher $locale] regex lookup + append re $regex + dict set fieldSet month [incr fieldCount] + append postcode "dict set date month \[" \ + "dict get " [list $lookup] " \$field" \ + [incr captureCount] \ + "\]\n" + } + M { + lassign [LocaleNumeralMatcher $locale] regex lookup + append re $regex + dict set fieldSet minute [incr fieldCount] + append postcode "dict set date minute \[" \ + "dict get " [list $lookup] " \$field" \ + [incr captureCount] \ + "\]\n" + } + S { + lassign [LocaleNumeralMatcher $locale] regex lookup + append re $regex + dict set fieldSet second [incr fieldCount] + append postcode "dict set date second \[" \ + "dict get " [list $lookup] " \$field" \ + [incr captureCount] \ + "\]\n" + } + u - w { + lassign [LocaleNumeralMatcher $locale] regex lookup + append re $regex + dict set fieldSet dayOfWeek [incr fieldCount] + append postcode "set dow \[dict get " [list $lookup] \ + { $field} [incr captureCount] \] \n \ + { + if { $dow == 0 } { + set dow 7 + } elseif { $dow > 7 } { + return -code error \ + -errorcode [list CLOCK badDayOfWeek] \ + "day of week is greater than 7" + } + dict set date dayOfWeek $dow + } + } + y { + lassign [LocaleNumeralMatcher $locale] regex lookup + append re $regex + dict set fieldSet yearOfCentury [incr fieldCount] + append postcode {dict set date yearOfCentury } \[ \ + {dict get } [list $lookup] { $field} \ + [incr captureCount] \] \n + } + default { + append re %O + if { ! [string is alnum $c] } { + append re \\ + } + append re $c + } + } + set state {} + } + } + } + + # Clean up any unfinished format groups + + append re $state \\s*\$ + + # Build the procedure + + set procBody {} + append procBody "variable ::tcl::clock::TZData" \n + append procBody "if \{ !\[ regexp -nocase [list $re] \$string ->" + for { set i 1 } { $i <= $captureCount } { incr i } { + append procBody " " field $i + } + append procBody "\] \} \{" \n + append procBody { + return -code error -errorcode [list CLOCK badInputString] \ + {input string does not match supplied format} + } + append procBody \}\n + append procBody "set date \[dict create\]" \n + append procBody {dict set date tzName $timeZone} \n + append procBody $postcode + append procBody [list set changeover [mc GREGORIAN_CHANGE_DATE]] \n + + # Set up the time zone before doing anything with a default base date + # that might need a timezone to interpret it. + + if { ![dict exists $fieldSet seconds] + && ![dict exists $fieldSet starDate] } { + if { [dict exists $fieldSet tzName] } { + append procBody { + set timeZone [dict get $date tzName] + } + } + append procBody { + ::tcl::clock::SetupTimeZone $timeZone + } + } + + # Add code that gets Julian Day Number from the fields. + + append procBody [MakeParseCodeFromFields $fieldSet $DateParseActions] + + # Get time of day + + append procBody [MakeParseCodeFromFields $fieldSet $TimeParseActions] + + # Assemble seconds from the Julian day and second of the day. + # Convert to local time unless epoch seconds or stardate are + # being processed - they're always absolute + + if { ![dict exists $fieldSet seconds] + && ![dict exists $fieldSet starDate] } { + append procBody { + if { [dict get $date julianDay] > 5373484 } { + return -code error -errorcode [list CLOCK dateTooLarge] \ + "requested date too large to represent" + } + dict set date localSeconds [expr { + -210866803200 + + ( 86400 * wide([dict get $date julianDay]) ) + + [dict get $date secondOfDay] + }] + } + + # Finally, convert the date to local time + + append procBody { + set date [::tcl::clock::ConvertLocalToUTC $date[set date {}] \ + $TZData($timeZone) $changeover] + } + } + + # Return result + + append procBody {return [dict get $date seconds]} \n + + proc $procName { string baseTime timeZone } $procBody + + # puts [list proc $procName [list string baseTime timeZone] $procBody] + + return $procName +} + +#---------------------------------------------------------------------- +# +# LocaleNumeralMatcher -- +# +# Composes a regexp that captures the numerals in the given locale, and +# a dictionary to map them to conventional numerals. +# +# Parameters: +# locale - Name of the current locale +# +# Results: +# Returns a two-element list comprising the regexp and the dictionary. +# +# Side effects: +# Caches the result. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::LocaleNumeralMatcher {l} { + variable LocaleNumeralCache + + if { ![dict exists $LocaleNumeralCache $l] } { + set d {} + set i 0 + set sep \( + foreach n [mc LOCALE_NUMERALS] { + dict set d $n $i + regsub -all {[^[:alnum:]]} $n \\\\& subex + append re $sep $subex + set sep | + incr i + } + append re \) + dict set LocaleNumeralCache $l [list $re $d] + } + return [dict get $LocaleNumeralCache $l] +} + + + +#---------------------------------------------------------------------- +# +# UniquePrefixRegexp -- +# +# Composes a regexp that performs unique-prefix matching. The RE +# matches one of a supplied set of strings, or any unique prefix +# thereof. +# +# Parameters: +# data - List of alternating match-strings and values. +# Match-strings with distinct values are considered +# distinct. +# +# Results: +# Returns a two-element list. The first is a regexp that matches any +# unique prefix of any of the strings. The second is a dictionary whose +# keys are match values from the regexp and whose values are the +# corresponding values from 'data'. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::UniquePrefixRegexp { data } { + # The 'successors' dictionary will contain, for each string that is a + # prefix of any key, all characters that may follow that prefix. The + # 'prefixMapping' dictionary will have keys that are prefixes of keys and + # values that correspond to the keys. + + set prefixMapping [dict create] + set successors [dict create {} {}] + + # Walk the key-value pairs + + foreach { key value } $data { + # Construct all prefixes of the key; + + set prefix {} + foreach char [split $key {}] { + set oldPrefix $prefix + dict set successors $oldPrefix $char {} + append prefix $char + + # Put the prefixes in the 'prefixMapping' and 'successors' + # dictionaries + + dict lappend prefixMapping $prefix $value + if { ![dict exists $successors $prefix] } { + dict set successors $prefix {} + } + } + } + + # Identify those prefixes that designate unique values, and those that are + # the full keys + + set uniquePrefixMapping {} + dict for { key valueList } $prefixMapping { + if { [llength $valueList] == 1 } { + dict set uniquePrefixMapping $key [lindex $valueList 0] + } + } + foreach { key value } $data { + dict set uniquePrefixMapping $key $value + } + + # Construct the re. + + return [list \ + [MakeUniquePrefixRegexp $successors $uniquePrefixMapping {}] \ + $uniquePrefixMapping] +} + +#---------------------------------------------------------------------- +# +# MakeUniquePrefixRegexp -- +# +# Service procedure for 'UniquePrefixRegexp' that constructs a regular +# expresison that matches the unique prefixes. +# +# Parameters: +# successors - Dictionary whose keys are all prefixes +# of keys passed to 'UniquePrefixRegexp' and whose +# values are dictionaries whose keys are the characters +# that may follow those prefixes. +# uniquePrefixMapping - Dictionary whose keys are the unique +# prefixes and whose values are not examined. +# prefixString - Current prefix being processed. +# +# Results: +# Returns a constructed regular expression that matches the set of +# unique prefixes beginning with the 'prefixString'. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::MakeUniquePrefixRegexp { successors + uniquePrefixMapping + prefixString } { + + # Get the characters that may follow the current prefix string + + set schars [lsort -ascii [dict keys [dict get $successors $prefixString]]] + if { [llength $schars] == 0 } { + return {} + } + + # If there is more than one successor character, or if the current prefix + # is a unique prefix, surround the generated re with non-capturing + # parentheses. + + set re {} + if { + [dict exists $uniquePrefixMapping $prefixString] + || [llength $schars] > 1 + } then { + append re "(?:" + } + + # Generate a regexp that matches the successors. + + set sep "" + foreach { c } $schars { + set nextPrefix $prefixString$c + regsub -all {[^[:alnum:]]} $c \\\\& rechar + append re $sep $rechar \ + [MakeUniquePrefixRegexp \ + $successors $uniquePrefixMapping $nextPrefix] + set sep | + } + + # If the current prefix is a unique prefix, make all following text + # optional. Otherwise, if there is more than one successor character, + # close the non-capturing parentheses. + + if { [dict exists $uniquePrefixMapping $prefixString] } { + append re ")?" + } elseif { [llength $schars] > 1 } { + append re ")" + } + + return $re +} + +#---------------------------------------------------------------------- +# +# MakeParseCodeFromFields -- +# +# Composes Tcl code to extract the Julian Day Number from a dictionary +# containing date fields. +# +# Parameters: +# dateFields -- Dictionary whose keys are fields of the date, +# and whose values are the rightmost positions +# at which those fields appear. +# parseActions -- List of triples: field set, priority, and +# code to emit. Smaller priorities are better, and +# the list must be in ascending order by priority +# +# Results: +# Returns a burst of code that extracts the day number from the given +# date. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::MakeParseCodeFromFields { dateFields parseActions } { + + set currPrio 999 + set currFieldPos [list] + set currCodeBurst { + error "in ::tcl::clock::MakeParseCodeFromFields: can't happen" + } + + foreach { fieldSet prio parseAction } $parseActions { + # If we've found an answer that's better than any that follow, quit + # now. + + if { $prio > $currPrio } { + break + } + + # Accumulate the field positions that are used in the current field + # grouping. + + set fieldPos [list] + set ok true + foreach field $fieldSet { + if { ! [dict exists $dateFields $field] } { + set ok 0 + break + } + lappend fieldPos [dict get $dateFields $field] + } + + # Quit if we don't have a complete set of fields + if { !$ok } { + continue + } + + # Determine whether the current answer is better than the last. + + set fPos [lsort -integer -decreasing $fieldPos] + + if { $prio == $currPrio } { + foreach currPos $currFieldPos newPos $fPos { + if { + ![string is integer $newPos] + || ![string is integer $currPos] + || $newPos > $currPos + } then { + break + } + if { $newPos < $currPos } { + set ok 0 + break + } + } + } + if { !$ok } { + continue + } + + # Remember the best possibility for extracting date information + + set currPrio $prio + set currFieldPos $fPos + set currCodeBurst $parseAction + } + + return $currCodeBurst +} + +#---------------------------------------------------------------------- +# +# EnterLocale -- +# +# Switch [mclocale] to a given locale if necessary +# +# Parameters: +# locale -- Desired locale +# +# Results: +# Returns the locale that was previously current. +# +# Side effects: +# Does [mclocale]. If necessary, loades the designated locale's files. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::EnterLocale { locale } { + if { $locale eq {system} } { + if { $::tcl_platform(platform) ne {windows} } { + # On a non-windows platform, the 'system' locale is the same as + # the 'current' locale + + set locale current + } else { + # On a windows platform, the 'system' locale is adapted from the + # 'current' locale by applying the date and time formats from the + # Control Panel. First, load the 'current' locale if it's not yet + # loaded + + mcpackagelocale set [mclocale] + + # Make a new locale string for the system locale, and get the + # Control Panel information + + set locale [mclocale]_windows + if { ! [mcpackagelocale present $locale] } { + LoadWindowsDateTimeFormats $locale + } + } + } + if { $locale eq {current}} { + set locale [mclocale] + } + # Eventually load the locale + mcpackagelocale set $locale +} + +#---------------------------------------------------------------------- +# +# LoadWindowsDateTimeFormats -- +# +# Load the date/time formats from the Control Panel in Windows and +# convert them so that they're usable by Tcl. +# +# Parameters: +# locale - Name of the locale in whose message catalog +# the converted formats are to be stored. +# +# Results: +# None. +# +# Side effects: +# Updates the given message catalog with the locale strings. +# +# Presumes that on entry, [mclocale] is set to the current locale, so that +# default strings can be obtained if the Registry query fails. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::LoadWindowsDateTimeFormats { locale } { + # Bail out if we can't find the Registry + + variable NoRegistry + if { [info exists NoRegistry] } return + + if { ![catch { + registry get "HKEY_CURRENT_USER\\Control Panel\\International" \ + sShortDate + } string] } { + set quote {} + set datefmt {} + foreach { unquoted quoted } [split $string '] { + append datefmt $quote [string map { + dddd %A + ddd %a + dd %d + d %e + MMMM %B + MMM %b + MM %m + M %N + yyyy %Y + yy %y + y %y + gg {} + } $unquoted] + if { $quoted eq {} } { + set quote ' + } else { + set quote $quoted + } + } + ::msgcat::mcset $locale DATE_FORMAT $datefmt + } + + if { ![catch { + registry get "HKEY_CURRENT_USER\\Control Panel\\International" \ + sLongDate + } string] } { + set quote {} + set ldatefmt {} + foreach { unquoted quoted } [split $string '] { + append ldatefmt $quote [string map { + dddd %A + ddd %a + dd %d + d %e + MMMM %B + MMM %b + MM %m + M %N + yyyy %Y + yy %y + y %y + gg {} + } $unquoted] + if { $quoted eq {} } { + set quote ' + } else { + set quote $quoted + } + } + ::msgcat::mcset $locale LOCALE_DATE_FORMAT $ldatefmt + } + + if { ![catch { + registry get "HKEY_CURRENT_USER\\Control Panel\\International" \ + sTimeFormat + } string] } { + set quote {} + set timefmt {} + foreach { unquoted quoted } [split $string '] { + append timefmt $quote [string map { + HH %H + H %k + hh %I + h %l + mm %M + m %M + ss %S + s %S + tt %p + t %p + } $unquoted] + if { $quoted eq {} } { + set quote ' + } else { + set quote $quoted + } + } + ::msgcat::mcset $locale TIME_FORMAT $timefmt + } + + catch { + ::msgcat::mcset $locale DATE_TIME_FORMAT "$datefmt $timefmt" + } + catch { + ::msgcat::mcset $locale LOCALE_DATE_TIME_FORMAT "$ldatefmt $timefmt" + } + + return + +} + +#---------------------------------------------------------------------- +# +# LocalizeFormat -- +# +# Map away locale-dependent format groups in a clock format. +# +# Parameters: +# locale -- Current [mclocale] locale, supplied to avoid +# an extra call +# format -- Format supplied to [clock scan] or [clock format] +# +# Results: +# Returns the string with locale-dependent composite format groups +# substituted out. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::LocalizeFormat { locale format } { + + # message catalog key to cache this format + set key FORMAT_$format + + if { [::msgcat::mcexists -exactlocale -exactnamespace $key] } { + return [mc $key] + } + # Handle locale-dependent format groups by mapping them out of the format + # string. Note that the order of the [string map] operations is + # significant because later formats can refer to later ones; for example + # %c can refer to %X, which in turn can refer to %T. + + set list { + %% %% + %D %m/%d/%Y + %+ {%a %b %e %H:%M:%S %Z %Y} + } + lappend list %EY [string map $list [mc LOCALE_YEAR_FORMAT]] + lappend list %T [string map $list [mc TIME_FORMAT_24_SECS]] + lappend list %R [string map $list [mc TIME_FORMAT_24]] + lappend list %r [string map $list [mc TIME_FORMAT_12]] + lappend list %X [string map $list [mc TIME_FORMAT]] + lappend list %EX [string map $list [mc LOCALE_TIME_FORMAT]] + lappend list %x [string map $list [mc DATE_FORMAT]] + lappend list %Ex [string map $list [mc LOCALE_DATE_FORMAT]] + lappend list %c [string map $list [mc DATE_TIME_FORMAT]] + lappend list %Ec [string map $list [mc LOCALE_DATE_TIME_FORMAT]] + set format [string map $list $format] + + ::msgcat::mcset $locale $key $format + return $format +} + +#---------------------------------------------------------------------- +# +# FormatNumericTimeZone -- +# +# Formats a time zone as +hhmmss +# +# Parameters: +# z - Time zone in seconds east of Greenwich +# +# Results: +# Returns the time zone formatted in a numeric form +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::FormatNumericTimeZone { z } { + if { $z < 0 } { + set z [expr { - $z }] + set retval - + } else { + set retval + + } + append retval [::format %02d [expr { $z / 3600 }]] + set z [expr { $z % 3600 }] + append retval [::format %02d [expr { $z / 60 }]] + set z [expr { $z % 60 }] + if { $z != 0 } { + append retval [::format %02d $z] + } + return $retval +} + +#---------------------------------------------------------------------- +# +# FormatStarDate -- +# +# Formats a date as a StarDate. +# +# Parameters: +# date - Dictionary containing 'year', 'dayOfYear', and +# 'localSeconds' fields. +# +# Results: +# Returns the given date formatted as a StarDate. +# +# Side effects: +# None. +# +# Jeff Hobbs put this in to support an atrocious pun about Tcl being +# "Enterprise ready." Now we're stuck with it. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::FormatStarDate { date } { + variable Roddenberry + + # Get day of year, zero based + + set doy [expr { [dict get $date dayOfYear] - 1 }] + + # Determine whether the year is a leap year + + set lp [IsGregorianLeapYear $date] + + # Convert day of year to a fractional year + + if { $lp } { + set fractYear [expr { 1000 * $doy / 366 }] + } else { + set fractYear [expr { 1000 * $doy / 365 }] + } + + # Put together the StarDate + + return [::format "Stardate %02d%03d.%1d" \ + [expr { [dict get $date year] - $Roddenberry }] \ + $fractYear \ + [expr { [dict get $date localSeconds] % 86400 + / ( 86400 / 10 ) }]] +} + +#---------------------------------------------------------------------- +# +# ParseStarDate -- +# +# Parses a StarDate +# +# Parameters: +# year - Year from the Roddenberry epoch +# fractYear - Fraction of a year specifiying the day of year. +# fractDay - Fraction of a day +# +# Results: +# Returns a count of seconds from the Posix epoch. +# +# Side effects: +# None. +# +# Jeff Hobbs put this in to support an atrocious pun about Tcl being +# "Enterprise ready." Now we're stuck with it. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::ParseStarDate { year fractYear fractDay } { + variable Roddenberry + + # Build a tentative date from year and fraction. + + set date [dict create \ + gregorian 1 \ + era CE \ + year [expr { $year + $Roddenberry }] \ + dayOfYear [expr { $fractYear * 365 / 1000 + 1 }]] + set date [GetJulianDayFromGregorianEraYearDay $date[set date {}]] + + # Determine whether the given year is a leap year + + set lp [IsGregorianLeapYear $date] + + # Reconvert the fractional year according to whether the given year is a + # leap year + + if { $lp } { + dict set date dayOfYear \ + [expr { $fractYear * 366 / 1000 + 1 }] + } else { + dict set date dayOfYear \ + [expr { $fractYear * 365 / 1000 + 1 }] + } + dict unset date julianDay + dict unset date gregorian + set date [GetJulianDayFromGregorianEraYearDay $date[set date {}]] + + return [expr { + 86400 * [dict get $date julianDay] + - 210866803200 + + ( 86400 / 10 ) * $fractDay + }] +} + +#---------------------------------------------------------------------- +# +# ScanWide -- +# +# Scans a wide integer from an input +# +# Parameters: +# str - String containing a decimal wide integer +# +# Results: +# Returns the string as a pure wide integer. Throws an error if the +# string is misformatted or out of range. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::ScanWide { str } { + set count [::scan $str {%ld %c} result junk] + if { $count != 1 } { + return -code error -errorcode [list CLOCK notAnInteger $str] \ + "\"$str\" is not an integer" + } + if { [incr result 0] != $str } { + return -code error -errorcode [list CLOCK integervalueTooLarge] \ + "integer value too large to represent" + } + return $result +} + +#---------------------------------------------------------------------- +# +# InterpretTwoDigitYear -- +# +# Given a date that contains only the year of the century, determines +# the target value of a two-digit year. +# +# Parameters: +# date - Dictionary containing fields of the date. +# baseTime - Base time relative to which the date is expressed. +# twoDigitField - Name of the field that stores the two-digit year. +# Default is 'yearOfCentury' +# fourDigitField - Name of the field that will receive the four-digit +# year. Default is 'year' +# +# Results: +# Returns the dictionary augmented with the four-digit year, stored in +# the given key. +# +# Side effects: +# None. +# +# The current rule for interpreting a two-digit year is that the year shall be +# between 1937 and 2037, thus staying within the range of a 32-bit signed +# value for time. This rule may change to a sliding window in future +# versions, so the 'baseTime' parameter (which is currently ignored) is +# provided in the procedure signature. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::InterpretTwoDigitYear { date baseTime + { twoDigitField yearOfCentury } + { fourDigitField year } } { + set yr [dict get $date $twoDigitField] + if { $yr <= 37 } { + dict set date $fourDigitField [expr { $yr + 2000 }] + } else { + dict set date $fourDigitField [expr { $yr + 1900 }] + } + return $date +} + +#---------------------------------------------------------------------- +# +# AssignBaseYear -- +# +# Places the number of the current year into a dictionary. +# +# Parameters: +# date - Dictionary value to update +# baseTime - Base time from which to extract the year, expressed +# in seconds from the Posix epoch +# timezone - the time zone in which the date is being scanned +# changeover - the Julian Day on which the Gregorian calendar +# was adopted in the target locale. +# +# Results: +# Returns the dictionary with the current year assigned. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::AssignBaseYear { date baseTime timezone changeover } { + variable TZData + + # Find the Julian Day Number corresponding to the base time, and + # find the Gregorian year corresponding to that Julian Day. + + set date2 [GetDateFields $baseTime $TZData($timezone) $changeover] + + # Store the converted year + + dict set date era [dict get $date2 era] + dict set date year [dict get $date2 year] + + return $date +} + +#---------------------------------------------------------------------- +# +# AssignBaseIso8601Year -- +# +# Determines the base year in the ISO8601 fiscal calendar. +# +# Parameters: +# date - Dictionary containing the fields of the date that +# is to be augmented with the base year. +# baseTime - Base time expressed in seconds from the Posix epoch. +# timeZone - Target time zone +# changeover - Julian Day of adoption of the Gregorian calendar in +# the target locale. +# +# Results: +# Returns the given date with "iso8601Year" set to the +# base year. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::AssignBaseIso8601Year {date baseTime timeZone changeover} { + variable TZData + + # Find the Julian Day Number corresponding to the base time + + set date2 [GetDateFields $baseTime $TZData($timeZone) $changeover] + + # Calculate the ISO8601 date and transfer the year + + dict set date era CE + dict set date iso8601Year [dict get $date2 iso8601Year] + return $date +} + +#---------------------------------------------------------------------- +# +# AssignBaseMonth -- +# +# Places the number of the current year and month into a +# dictionary. +# +# Parameters: +# date - Dictionary value to update +# baseTime - Time from which the year and month are to be +# obtained, expressed in seconds from the Posix epoch. +# timezone - Name of the desired time zone +# changeover - Julian Day on which the Gregorian calendar was adopted. +# +# Results: +# Returns the dictionary with the base year and month assigned. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::AssignBaseMonth {date baseTime timezone changeover} { + variable TZData + + # Find the year and month corresponding to the base time + + set date2 [GetDateFields $baseTime $TZData($timezone) $changeover] + dict set date era [dict get $date2 era] + dict set date year [dict get $date2 year] + dict set date month [dict get $date2 month] + return $date +} + +#---------------------------------------------------------------------- +# +# AssignBaseWeek -- +# +# Determines the base year and week in the ISO8601 fiscal calendar. +# +# Parameters: +# date - Dictionary containing the fields of the date that +# is to be augmented with the base year and week. +# baseTime - Base time expressed in seconds from the Posix epoch. +# changeover - Julian Day on which the Gregorian calendar was adopted +# in the target locale. +# +# Results: +# Returns the given date with "iso8601Year" set to the +# base year and "iso8601Week" to the week number. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::AssignBaseWeek {date baseTime timeZone changeover} { + variable TZData + + # Find the Julian Day Number corresponding to the base time + + set date2 [GetDateFields $baseTime $TZData($timeZone) $changeover] + + # Calculate the ISO8601 date and transfer the year + + dict set date era CE + dict set date iso8601Year [dict get $date2 iso8601Year] + dict set date iso8601Week [dict get $date2 iso8601Week] + return $date +} + +#---------------------------------------------------------------------- +# +# AssignBaseJulianDay -- +# +# Determines the base day for a time-of-day conversion. +# +# Parameters: +# date - Dictionary that is to get the base day +# baseTime - Base time expressed in seconds from the Posix epoch +# changeover - Julian day on which the Gregorian calendar was +# adpoted in the target locale. +# +# Results: +# Returns the given dictionary augmented with a 'julianDay' field +# that contains the base day. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::AssignBaseJulianDay { date baseTime timeZone changeover } { + variable TZData + + # Find the Julian Day Number corresponding to the base time + + set date2 [GetDateFields $baseTime $TZData($timeZone) $changeover] + dict set date julianDay [dict get $date2 julianDay] + + return $date +} + +#---------------------------------------------------------------------- +# +# InterpretHMSP -- +# +# Interprets a time in the form "hh:mm:ss am". +# +# Parameters: +# date -- Dictionary containing "hourAMPM", "minute", "second" +# and "amPmIndicator" fields. +# +# Results: +# Returns the number of seconds from local midnight. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::InterpretHMSP { date } { + set hr [dict get $date hourAMPM] + if { $hr == 12 } { + set hr 0 + } + if { [dict get $date amPmIndicator] } { + incr hr 12 + } + dict set date hour $hr + return [InterpretHMS $date[set date {}]] +} + +#---------------------------------------------------------------------- +# +# InterpretHMS -- +# +# Interprets a 24-hour time "hh:mm:ss" +# +# Parameters: +# date -- Dictionary containing the "hour", "minute" and "second" +# fields. +# +# Results: +# Returns the given dictionary augmented with a "secondOfDay" +# field containing the number of seconds from local midnight. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::InterpretHMS { date } { + return [expr { + ( [dict get $date hour] * 60 + + [dict get $date minute] ) * 60 + + [dict get $date second] + }] +} + +#---------------------------------------------------------------------- +# +# GetSystemTimeZone -- +# +# Determines the system time zone, which is the default for the +# 'clock' command if no other zone is supplied. +# +# Parameters: +# None. +# +# Results: +# Returns the system time zone. +# +# Side effects: +# Stores the sustem time zone in the 'CachedSystemTimeZone' +# variable, since determining it may be an expensive process. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::GetSystemTimeZone {} { + variable CachedSystemTimeZone + variable TimeZoneBad + + if {[set result [getenv TCL_TZ]] ne {}} { + set timezone $result + } elseif {[set result [getenv TZ]] ne {}} { + set timezone $result + } else { + # Cache the time zone only if it was detected by one of the + # expensive methods. + if { [info exists CachedSystemTimeZone] } { + set timezone $CachedSystemTimeZone + } elseif { $::tcl_platform(platform) eq {windows} } { + set timezone [GuessWindowsTimeZone] + } elseif { [file exists /etc/localtime] + && ![catch {ReadZoneinfoFile \ + Tcl/Localtime /etc/localtime}] } { + set timezone :Tcl/Localtime + } else { + set timezone :localtime + } + set CachedSystemTimeZone $timezone + } + if { ![dict exists $TimeZoneBad $timezone] } { + dict set TimeZoneBad $timezone [catch {SetupTimeZone $timezone}] + } + if { [dict get $TimeZoneBad $timezone] } { + return :localtime + } else { + return $timezone + } +} + +#---------------------------------------------------------------------- +# +# ConvertLegacyTimeZone -- +# +# Given an alphanumeric time zone identifier and the system time zone, +# convert the alphanumeric identifier to an unambiguous time zone. +# +# Parameters: +# tzname - Name of the time zone to convert +# +# Results: +# Returns a time zone name corresponding to tzname, but in an +# unambiguous form, generally +hhmm. +# +# This procedure is implemented primarily to allow the parsing of RFC822 +# date/time strings. Processing a time zone name on input is not recommended +# practice, because there is considerable room for ambiguity; for instance, is +# BST Brazilian Standard Time, or British Summer Time? +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::ConvertLegacyTimeZone { tzname } { + variable LegacyTimeZone + + set tzname [string tolower $tzname] + if { ![dict exists $LegacyTimeZone $tzname] } { + return -code error -errorcode [list CLOCK badTZName $tzname] \ + "time zone \"$tzname\" not found" + } + return [dict get $LegacyTimeZone $tzname] +} + +#---------------------------------------------------------------------- +# +# SetupTimeZone -- +# +# Given the name or specification of a time zone, sets up its in-memory +# data. +# +# Parameters: +# tzname - Name of a time zone +# +# Results: +# Unless the time zone is ':localtime', sets the TZData array to contain +# the lookup table for local<->UTC conversion. Returns an error if the +# time zone cannot be parsed. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::SetupTimeZone { timezone } { + variable TZData + + if {! [info exists TZData($timezone)] } { + variable MINWIDE + if { $timezone eq {:localtime} } { + # Nothing to do, we'll convert using the localtime function + + } elseif { + [regexp {^([-+])(\d\d)(?::?(\d\d)(?::?(\d\d))?)?} $timezone \ + -> s hh mm ss] + } then { + # Make a fixed offset + + ::scan $hh %d hh + if { $mm eq {} } { + set mm 0 + } else { + ::scan $mm %d mm + } + if { $ss eq {} } { + set ss 0 + } else { + ::scan $ss %d ss + } + set offset [expr { ( $hh * 60 + $mm ) * 60 + $ss }] + if { $s eq {-} } { + set offset [expr { - $offset }] + } + set TZData($timezone) [list [list $MINWIDE $offset -1 $timezone]] + + } elseif { [string index $timezone 0] eq {:} } { + # Convert using a time zone file + + if { + [catch { + LoadTimeZoneFile [string range $timezone 1 end] + }] && [catch { + LoadZoneinfoFile [string range $timezone 1 end] + }] + } then { + return -code error \ + -errorcode [list CLOCK badTimeZone $timezone] \ + "time zone \"$timezone\" not found" + } + } elseif { ![catch {ParsePosixTimeZone $timezone} tzfields] } { + # This looks like a POSIX time zone - try to process it + + if { [catch {ProcessPosixTimeZone $tzfields} data opts] } { + if { [lindex [dict get $opts -errorcode] 0] eq {CLOCK} } { + dict unset opts -errorinfo + } + return -options $opts $data + } else { + set TZData($timezone) $data + } + + } else { + # We couldn't parse this as a POSIX time zone. Try again with a + # time zone file - this time without a colon + + if { [catch { LoadTimeZoneFile $timezone }] + && [catch { LoadZoneinfoFile $timezone } - opts] } { + dict unset opts -errorinfo + return -options $opts "time zone $timezone not found" + } + set TZData($timezone) $TZData(:$timezone) + } + } + + return +} + +#---------------------------------------------------------------------- +# +# GuessWindowsTimeZone -- +# +# Determines the system time zone on windows. +# +# Parameters: +# None. +# +# Results: +# Returns a time zone specifier that corresponds to the system time zone +# information found in the Registry. +# +# Bugs: +# Fixed dates for DST change are unimplemented at present, because no +# time zone information supplied with Windows actually uses them! +# +# On a Windows system where neither $env(TCL_TZ) nor $env(TZ) is specified, +# GuessWindowsTimeZone looks in the Registry for the system time zone +# information. It then attempts to find an entry in WinZoneInfo for a time +# zone that uses the same rules. If it finds one, it returns it; otherwise, +# it constructs a Posix-style time zone string and returns that. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::GuessWindowsTimeZone {} { + variable WinZoneInfo + variable NoRegistry + variable TimeZoneBad + + if { [info exists NoRegistry] } { + return :localtime + } + + # Dredge time zone information out of the registry + + if { [catch { + set rpath HKEY_LOCAL_MACHINE\\System\\CurrentControlSet\\Control\\TimeZoneInformation + set data [list \ + [expr { -60 + * [registry get $rpath Bias] }] \ + [expr { -60 + * [registry get $rpath StandardBias] }] \ + [expr { -60 \ + * [registry get $rpath DaylightBias] }]] + set stdtzi [registry get $rpath StandardStart] + foreach ind {0 2 14 4 6 8 10 12} { + binary scan $stdtzi @${ind}s val + lappend data $val + } + set daytzi [registry get $rpath DaylightStart] + foreach ind {0 2 14 4 6 8 10 12} { + binary scan $daytzi @${ind}s val + lappend data $val + } + }] } { + # Missing values in the Registry - bail out + + return :localtime + } + + # Make up a Posix time zone specifier if we can't find one. Check here + # that the tzdata file exists, in case we're running in an environment + # (e.g. starpack) where tzdata is incomplete. (Bug 1237907) + + if { [dict exists $WinZoneInfo $data] } { + set tzname [dict get $WinZoneInfo $data] + if { ! [dict exists $TimeZoneBad $tzname] } { + dict set TimeZoneBad $tzname [catch {SetupTimeZone $tzname}] + } + } else { + set tzname {} + } + if { $tzname eq {} || [dict get $TimeZoneBad $tzname] } { + lassign $data \ + bias stdBias dstBias \ + stdYear stdMonth stdDayOfWeek stdDayOfMonth \ + stdHour stdMinute stdSecond stdMillisec \ + dstYear dstMonth dstDayOfWeek dstDayOfMonth \ + dstHour dstMinute dstSecond dstMillisec + set stdDelta [expr { $bias + $stdBias }] + set dstDelta [expr { $bias + $dstBias }] + if { $stdDelta <= 0 } { + set stdSignum + + set stdDelta [expr { - $stdDelta }] + set dispStdSignum - + } else { + set stdSignum - + set dispStdSignum + + } + set hh [::format %02d [expr { $stdDelta / 3600 }]] + set mm [::format %02d [expr { ($stdDelta / 60 ) % 60 }]] + set ss [::format %02d [expr { $stdDelta % 60 }]] + set tzname {} + append tzname < $dispStdSignum $hh $mm > $stdSignum $hh : $mm : $ss + if { $stdMonth >= 0 } { + if { $dstDelta <= 0 } { + set dstSignum + + set dstDelta [expr { - $dstDelta }] + set dispDstSignum - + } else { + set dstSignum - + set dispDstSignum + + } + set hh [::format %02d [expr { $dstDelta / 3600 }]] + set mm [::format %02d [expr { ($dstDelta / 60 ) % 60 }]] + set ss [::format %02d [expr { $dstDelta % 60 }]] + append tzname < $dispDstSignum $hh $mm > $dstSignum $hh : $mm : $ss + if { $dstYear == 0 } { + append tzname ,M $dstMonth . $dstDayOfMonth . $dstDayOfWeek + } else { + # I have not been able to find any locale on which Windows + # converts time zone on a fixed day of the year, hence don't + # know how to interpret the fields. If someone can inform me, + # I'd be glad to code it up. For right now, we bail out in + # such a case. + return :localtime + } + append tzname / [::format %02d $dstHour] \ + : [::format %02d $dstMinute] \ + : [::format %02d $dstSecond] + if { $stdYear == 0 } { + append tzname ,M $stdMonth . $stdDayOfMonth . $stdDayOfWeek + } else { + # I have not been able to find any locale on which Windows + # converts time zone on a fixed day of the year, hence don't + # know how to interpret the fields. If someone can inform me, + # I'd be glad to code it up. For right now, we bail out in + # such a case. + return :localtime + } + append tzname / [::format %02d $stdHour] \ + : [::format %02d $stdMinute] \ + : [::format %02d $stdSecond] + } + dict set WinZoneInfo $data $tzname + } + + return [dict get $WinZoneInfo $data] +} + +#---------------------------------------------------------------------- +# +# LoadTimeZoneFile -- +# +# Load the data file that specifies the conversion between a +# given time zone and Greenwich. +# +# Parameters: +# fileName -- Name of the file to load +# +# Results: +# None. +# +# Side effects: +# TZData(:fileName) contains the time zone data +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::LoadTimeZoneFile { fileName } { + variable DataDir + variable TZData + + if { [info exists TZData($fileName)] } { + return + } + + # Since an unsafe interp uses the [clock] command in the parent, this code + # is security sensitive. Make sure that the path name cannot escape the + # given directory. + + if { ![regexp {^[[.-.][:alpha:]_]+(?:/[[.-.][:alpha:]_]+)*$} $fileName] } { + return -code error \ + -errorcode [list CLOCK badTimeZone $:fileName] \ + "time zone \":$fileName\" not valid" + } + try { + source -encoding utf-8 [file join $DataDir $fileName] + } on error {} { + return -code error \ + -errorcode [list CLOCK badTimeZone :$fileName] \ + "time zone \":$fileName\" not found" + } + return +} + +#---------------------------------------------------------------------- +# +# LoadZoneinfoFile -- +# +# Loads a binary time zone information file in Olson format. +# +# Parameters: +# fileName - Relative path name of the file to load. +# +# Results: +# Returns an empty result normally; returns an error if no Olson file +# was found or the file was malformed in some way. +# +# Side effects: +# TZData(:fileName) contains the time zone data +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::LoadZoneinfoFile { fileName } { + variable ZoneinfoPaths + + # Since an unsafe interp uses the [clock] command in the parent, this code + # is security sensitive. Make sure that the path name cannot escape the + # given directory. + + if { ![regexp {^[[.-.][:alpha:]_]+(?:/[[.-.][:alpha:]_]+)*$} $fileName] } { + return -code error \ + -errorcode [list CLOCK badTimeZone $:fileName] \ + "time zone \":$fileName\" not valid" + } + foreach d $ZoneinfoPaths { + set fname [file join $d $fileName] + if { [file readable $fname] && [file isfile $fname] } { + break + } + unset fname + } + ReadZoneinfoFile $fileName $fname +} + +#---------------------------------------------------------------------- +# +# ReadZoneinfoFile -- +# +# Loads a binary time zone information file in Olson format. +# +# Parameters: +# fileName - Name of the time zone (relative path name of the +# file). +# fname - Absolute path name of the file. +# +# Results: +# Returns an empty result normally; returns an error if no Olson file +# was found or the file was malformed in some way. +# +# Side effects: +# TZData(:fileName) contains the time zone data +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::ReadZoneinfoFile {fileName fname} { + variable MINWIDE + variable TZData + if { ![file exists $fname] } { + return -code error "$fileName not found" + } + + if { [file size $fname] > 262144 } { + return -code error "$fileName too big" + } + + # Suck in all the data from the file + + set f [open $fname r] + fconfigure $f -translation binary + set d [read $f] + close $f + + # The file begins with a magic number, sixteen reserved bytes, and then + # six 4-byte integers giving counts of fileds in the file. + + binary scan $d a4a1x15IIIIII \ + magic version nIsGMT nIsStd nLeap nTime nType nChar + set seek 44 + set ilen 4 + set iformat I + if { $magic != {TZif} } { + return -code error "$fileName not a time zone information file" + } + if { $nType > 255 } { + return -code error "$fileName contains too many time types" + } + # Accept only Posix-style zoneinfo. Sorry, 'leaps' bigots. + if { $nLeap != 0 } { + return -code error "$fileName contains leap seconds" + } + + # In a version 2 file, we use the second part of the file, which contains + # 64-bit transition times. + + if {$version eq "2"} { + set seek [expr { + 44 + + 5 * $nTime + + 6 * $nType + + 4 * $nLeap + + $nIsStd + + $nIsGMT + + $nChar + }] + binary scan $d @${seek}a4a1x15IIIIII \ + magic version nIsGMT nIsStd nLeap nTime nType nChar + if {$magic ne {TZif}} { + return -code error "seek address $seek miscomputed, magic = $magic" + } + set iformat W + set ilen 8 + incr seek 44 + } + + # Next come ${nTime} transition times, followed by ${nTime} time type + # codes. The type codes are unsigned 1-byte quantities. We insert an + # arbitrary start time in front of the transitions. + + binary scan $d @${seek}${iformat}${nTime}c${nTime} times tempCodes + incr seek [expr { ($ilen + 1) * $nTime }] + set times [linsert $times 0 $MINWIDE] + set codes {} + foreach c $tempCodes { + lappend codes [expr { $c & 0xFF }] + } + set codes [linsert $codes 0 0] + + # Next come ${nType} time type descriptions, each of which has an offset + # (seconds east of GMT), a DST indicator, and an index into the + # abbreviation text. + + for { set i 0 } { $i < $nType } { incr i } { + binary scan $d @${seek}Icc gmtOff isDst abbrInd + lappend types [list $gmtOff $isDst $abbrInd] + incr seek 6 + } + + # Next come $nChar characters of time zone name abbreviations, which are + # null-terminated. + # We build them up into a dictionary indexed by character index, because + # that's what's in the indices above. + + binary scan $d @${seek}a${nChar} abbrs + incr seek ${nChar} + set abbrList [split $abbrs \0] + set i 0 + set abbrevs {} + foreach a $abbrList { + for {set j 0} {$j <= [string length $a]} {incr j} { + dict set abbrevs $i [string range $a $j end] + incr i + } + } + + # Package up a list of tuples, each of which contains transition time, + # seconds east of Greenwich, DST flag and time zone abbreviation. + + set r {} + set lastTime $MINWIDE + foreach t $times c $codes { + if { $t < $lastTime } { + return -code error "$fileName has times out of order" + } + set lastTime $t + lassign [lindex $types $c] gmtoff isDst abbrInd + set abbrev [dict get $abbrevs $abbrInd] + lappend r [list $t $gmtoff $isDst $abbrev] + } + + # In a version 2 file, there is also a POSIX-style time zone description + # at the very end of the file. To get to it, skip over nLeap leap second + # values (8 bytes each), + # nIsStd standard/DST indicators and nIsGMT UTC/local indicators. + + if {$version eq {2}} { + set seek [expr {$seek + 8 * $nLeap + $nIsStd + $nIsGMT + 1}] + set last [string first \n $d $seek] + set posix [string range $d $seek [expr {$last-1}]] + if {[llength $posix] > 0} { + set posixFields [ParsePosixTimeZone $posix] + foreach tuple [ProcessPosixTimeZone $posixFields] { + lassign $tuple t gmtoff isDst abbrev + if {$t > $lastTime} { + lappend r $tuple + } + } + } + } + + set TZData(:$fileName) $r + + return +} + +#---------------------------------------------------------------------- +# +# ParsePosixTimeZone -- +# +# Parses the TZ environment variable in Posix form +# +# Parameters: +# tz Time zone specifier to be interpreted +# +# Results: +# Returns a dictionary whose values contain the various pieces of the +# time zone specification. +# +# Side effects: +# None. +# +# Errors: +# Throws an error if the syntax of the time zone is incorrect. +# +# The following keys are present in the dictionary: +# stdName - Name of the time zone when Daylight Saving Time +# is not in effect. +# stdSignum - Sign (+, -, or empty) of the offset from Greenwich +# to the given (non-DST) time zone. + and the empty +# string denote zones west of Greenwich, - denotes east +# of Greenwich; this is contrary to the ISO convention +# but follows Posix. +# stdHours - Hours part of the offset from Greenwich to the given +# (non-DST) time zone. +# stdMinutes - Minutes part of the offset from Greenwich to the +# given (non-DST) time zone. Empty denotes zero. +# stdSeconds - Seconds part of the offset from Greenwich to the +# given (non-DST) time zone. Empty denotes zero. +# dstName - Name of the time zone when DST is in effect, or the +# empty string if the time zone does not observe Daylight +# Saving Time. +# dstSignum, dstHours, dstMinutes, dstSeconds - +# Fields corresponding to stdSignum, stdHours, stdMinutes, +# stdSeconds for the Daylight Saving Time version of the +# time zone. If dstHours is empty, it is presumed to be 1. +# startDayOfYear - The ordinal number of the day of the year on which +# Daylight Saving Time begins. If this field is +# empty, then DST begins on a given month-week-day, +# as below. +# startJ - The letter J, or an empty string. If a J is present in +# this field, then startDayOfYear does not count February 29 +# even in leap years. +# startMonth - The number of the month in which Daylight Saving Time +# begins, supplied if startDayOfYear is empty. If both +# startDayOfYear and startMonth are empty, then US rules +# are presumed. +# startWeekOfMonth - The number of the week in the month in which +# Daylight Saving Time begins, in the range 1-5. +# 5 denotes the last week of the month even in a +# 4-week month. +# startDayOfWeek - The number of the day of the week (Sunday=0, +# Saturday=6) on which Daylight Saving Time begins. +# startHours - The hours part of the time of day at which Daylight +# Saving Time begins. An empty string is presumed to be 2. +# startMinutes - The minutes part of the time of day at which DST begins. +# An empty string is presumed zero. +# startSeconds - The seconds part of the time of day at which DST begins. +# An empty string is presumed zero. +# endDayOfYear, endJ, endMonth, endWeekOfMonth, endDayOfWeek, +# endHours, endMinutes, endSeconds - +# Specify the end of DST in the same way that the start* fields +# specify the beginning of DST. +# +# This procedure serves only to break the time specifier into fields. No +# attempt is made to canonicalize the fields or supply default values. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::ParsePosixTimeZone { tz } { + if {[regexp -expanded -nocase -- { + ^ + # 1 - Standard time zone name + ([[:alpha:]]+ | <[-+[:alnum:]]+>) + # 2 - Standard time zone offset, signum + ([-+]?) + # 3 - Standard time zone offset, hours + ([[:digit:]]{1,2}) + (?: + # 4 - Standard time zone offset, minutes + : ([[:digit:]]{1,2}) + (?: + # 5 - Standard time zone offset, seconds + : ([[:digit:]]{1,2} ) + )? + )? + (?: + # 6 - DST time zone name + ([[:alpha:]]+ | <[-+[:alnum:]]+>) + (?: + (?: + # 7 - DST time zone offset, signum + ([-+]?) + # 8 - DST time zone offset, hours + ([[:digit:]]{1,2}) + (?: + # 9 - DST time zone offset, minutes + : ([[:digit:]]{1,2}) + (?: + # 10 - DST time zone offset, seconds + : ([[:digit:]]{1,2}) + )? + )? + )? + (?: + , + (?: + # 11 - Optional J in n and Jn form 12 - Day of year + ( J ? ) ( [[:digit:]]+ ) + | M + # 13 - Month number 14 - Week of month 15 - Day of week + ( [[:digit:]] + ) + [.] ( [[:digit:]] + ) + [.] ( [[:digit:]] + ) + ) + (?: + # 16 - Start time of DST - hours + / ( [[:digit:]]{1,2} ) + (?: + # 17 - Start time of DST - minutes + : ( [[:digit:]]{1,2} ) + (?: + # 18 - Start time of DST - seconds + : ( [[:digit:]]{1,2} ) + )? + )? + )? + , + (?: + # 19 - Optional J in n and Jn form 20 - Day of year + ( J ? ) ( [[:digit:]]+ ) + | M + # 21 - Month number 22 - Week of month 23 - Day of week + ( [[:digit:]] + ) + [.] ( [[:digit:]] + ) + [.] ( [[:digit:]] + ) + ) + (?: + # 24 - End time of DST - hours + / ( [[:digit:]]{1,2} ) + (?: + # 25 - End time of DST - minutes + : ( [[:digit:]]{1,2} ) + (?: + # 26 - End time of DST - seconds + : ( [[:digit:]]{1,2} ) + )? + )? + )? + )? + )? + )? + $ + } $tz -> x(stdName) x(stdSignum) x(stdHours) x(stdMinutes) x(stdSeconds) \ + x(dstName) x(dstSignum) x(dstHours) x(dstMinutes) x(dstSeconds) \ + x(startJ) x(startDayOfYear) \ + x(startMonth) x(startWeekOfMonth) x(startDayOfWeek) \ + x(startHours) x(startMinutes) x(startSeconds) \ + x(endJ) x(endDayOfYear) \ + x(endMonth) x(endWeekOfMonth) x(endDayOfWeek) \ + x(endHours) x(endMinutes) x(endSeconds)] } { + # it's a good timezone + + return [array get x] + } + + return -code error\ + -errorcode [list CLOCK badTimeZone $tz] \ + "unable to parse time zone specification \"$tz\"" +} + +#---------------------------------------------------------------------- +# +# ProcessPosixTimeZone -- +# +# Handle a Posix time zone after it's been broken out into fields. +# +# Parameters: +# z - Dictionary returned from 'ParsePosixTimeZone' +# +# Results: +# Returns time zone information for the 'TZData' array. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::ProcessPosixTimeZone { z } { + variable MINWIDE + variable TZData + + # Determine the standard time zone name and seconds east of Greenwich + + set stdName [dict get $z stdName] + if { [string index $stdName 0] eq {<} } { + set stdName [string range $stdName 1 end-1] + } + if { [dict get $z stdSignum] eq {-} } { + set stdSignum +1 + } else { + set stdSignum -1 + } + set stdHours [lindex [::scan [dict get $z stdHours] %d] 0] + if { [dict get $z stdMinutes] ne {} } { + set stdMinutes [lindex [::scan [dict get $z stdMinutes] %d] 0] + } else { + set stdMinutes 0 + } + if { [dict get $z stdSeconds] ne {} } { + set stdSeconds [lindex [::scan [dict get $z stdSeconds] %d] 0] + } else { + set stdSeconds 0 + } + set stdOffset [expr { + (($stdHours * 60 + $stdMinutes) * 60 + $stdSeconds) * $stdSignum + }] + set data [list [list $MINWIDE $stdOffset 0 $stdName]] + + # If there's no daylight zone, we're done + + set dstName [dict get $z dstName] + if { $dstName eq {} } { + return $data + } + if { [string index $dstName 0] eq {<} } { + set dstName [string range $dstName 1 end-1] + } + + # Determine the daylight name + + if { [dict get $z dstSignum] eq {-} } { + set dstSignum +1 + } else { + set dstSignum -1 + } + if { [dict get $z dstHours] eq {} } { + set dstOffset [expr { 3600 + $stdOffset }] + } else { + set dstHours [lindex [::scan [dict get $z dstHours] %d] 0] + if { [dict get $z dstMinutes] ne {} } { + set dstMinutes [lindex [::scan [dict get $z dstMinutes] %d] 0] + } else { + set dstMinutes 0 + } + if { [dict get $z dstSeconds] ne {} } { + set dstSeconds [lindex [::scan [dict get $z dstSeconds] %d] 0] + } else { + set dstSeconds 0 + } + set dstOffset [expr { + (($dstHours*60 + $dstMinutes) * 60 + $dstSeconds) * $dstSignum + }] + } + + # Fill in defaults for European or US DST rules + # US start time is the second Sunday in March + # EU start time is the last Sunday in March + # US end time is the first Sunday in November. + # EU end time is the last Sunday in October + + if { + [dict get $z startDayOfYear] eq {} + && [dict get $z startMonth] eq {} + } then { + if {($stdSignum * $stdHours>=0) && ($stdSignum * $stdHours<=12)} { + # EU + dict set z startWeekOfMonth 5 + if {$stdHours>2} { + dict set z startHours 2 + } else { + dict set z startHours [expr {$stdHours+1}] + } + } else { + # US + dict set z startWeekOfMonth 2 + dict set z startHours 2 + } + dict set z startMonth 3 + dict set z startDayOfWeek 0 + dict set z startMinutes 0 + dict set z startSeconds 0 + } + if { + [dict get $z endDayOfYear] eq {} + && [dict get $z endMonth] eq {} + } then { + if {($stdSignum * $stdHours>=0) && ($stdSignum * $stdHours<=12)} { + # EU + dict set z endMonth 10 + dict set z endWeekOfMonth 5 + if {$stdHours>2} { + dict set z endHours 3 + } else { + dict set z endHours [expr {$stdHours+2}] + } + } else { + # US + dict set z endMonth 11 + dict set z endWeekOfMonth 1 + dict set z endHours 2 + } + dict set z endDayOfWeek 0 + dict set z endMinutes 0 + dict set z endSeconds 0 + } + + # Put DST in effect in all years from 1916 to 2099. + + for { set y 1916 } { $y < 2100 } { incr y } { + set startTime [DeterminePosixDSTTime $z start $y] + incr startTime [expr { - wide($stdOffset) }] + set endTime [DeterminePosixDSTTime $z end $y] + incr endTime [expr { - wide($dstOffset) }] + if { $startTime < $endTime } { + lappend data \ + [list $startTime $dstOffset 1 $dstName] \ + [list $endTime $stdOffset 0 $stdName] + } else { + lappend data \ + [list $endTime $stdOffset 0 $stdName] \ + [list $startTime $dstOffset 1 $dstName] + } + } + + return $data +} + +#---------------------------------------------------------------------- +# +# DeterminePosixDSTTime -- +# +# Determines the time that Daylight Saving Time starts or ends from a +# Posix time zone specification. +# +# Parameters: +# z - Time zone data returned from ParsePosixTimeZone. +# Missing fields are expected to be filled in with +# default values. +# bound - The word 'start' or 'end' +# y - The year for which the transition time is to be determined. +# +# Results: +# Returns the transition time as a count of seconds from the epoch. The +# time is relative to the wall clock, not UTC. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::DeterminePosixDSTTime { z bound y } { + + variable FEB_28 + + # Determine the start or end day of DST + + set date [dict create era CE year $y] + set doy [dict get $z ${bound}DayOfYear] + if { $doy ne {} } { + + # Time was specified as a day of the year + + if { [dict get $z ${bound}J] ne {} + && [IsGregorianLeapYear $y] + && ( $doy > $FEB_28 ) } { + incr doy + } + dict set date dayOfYear $doy + set date [GetJulianDayFromEraYearDay $date[set date {}] 2361222] + } else { + # Time was specified as a day of the week within a month + + dict set date month [dict get $z ${bound}Month] + dict set date dayOfWeek [dict get $z ${bound}DayOfWeek] + set dowim [dict get $z ${bound}WeekOfMonth] + if { $dowim >= 5 } { + set dowim -1 + } + dict set date dayOfWeekInMonth $dowim + set date [GetJulianDayFromEraYearMonthWeekDay $date[set date {}] 2361222] + + } + + set jd [dict get $date julianDay] + set seconds [expr { + wide($jd) * wide(86400) - wide(210866803200) + }] + + set h [dict get $z ${bound}Hours] + if { $h eq {} } { + set h 2 + } else { + set h [lindex [::scan $h %d] 0] + } + set m [dict get $z ${bound}Minutes] + if { $m eq {} } { + set m 0 + } else { + set m [lindex [::scan $m %d] 0] + } + set s [dict get $z ${bound}Seconds] + if { $s eq {} } { + set s 0 + } else { + set s [lindex [::scan $s %d] 0] + } + set tod [expr { ( $h * 60 + $m ) * 60 + $s }] + return [expr { $seconds + $tod }] +} + +#---------------------------------------------------------------------- +# +# GetLocaleEra -- +# +# Given local time expressed in seconds from the Posix epoch, +# determine localized era and year within the era. +# +# Parameters: +# date - Dictionary that must contain the keys, 'localSeconds', +# whose value is expressed as the appropriate local time; +# and 'year', whose value is the Gregorian year. +# etable - Value of the LOCALE_ERAS key in the message catalogue +# for the target locale. +# +# Results: +# Returns the dictionary, augmented with the keys, 'localeEra' and +# 'localeYear'. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::GetLocaleEra { date etable } { + set index [BSearch $etable [dict get $date localSeconds]] + if { $index < 0} { + dict set date localeEra \ + [::format %02d [expr { [dict get $date year] / 100 }]] + dict set date localeYear [expr { + [dict get $date year] % 100 + }] + } else { + dict set date localeEra [lindex $etable $index 1] + dict set date localeYear [expr { + [dict get $date year] - [lindex $etable $index 2] + }] + } + return $date +} + +#---------------------------------------------------------------------- +# +# GetJulianDayFromEraYearDay -- +# +# Given a year, month and day on the Gregorian calendar, determines +# the Julian Day Number beginning at noon on that date. +# +# Parameters: +# date -- A dictionary in which the 'era', 'year', and +# 'dayOfYear' slots are populated. The calendar in use +# is determined by the date itself relative to: +# changeover -- Julian day on which the Gregorian calendar was +# adopted in the current locale. +# +# Results: +# Returns the given dictionary augmented with a 'julianDay' key whose +# value is the desired Julian Day Number, and a 'gregorian' key that +# specifies whether the calendar is Gregorian (1) or Julian (0). +# +# Side effects: +# None. +# +# Bugs: +# This code needs to be moved to the C layer. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::GetJulianDayFromEraYearDay {date changeover} { + # Get absolute year number from the civil year + + switch -exact -- [dict get $date era] { + BCE { + set year [expr { 1 - [dict get $date year] }] + } + CE { + set year [dict get $date year] + } + } + set ym1 [expr { $year - 1 }] + + # Try the Gregorian calendar first. + + dict set date gregorian 1 + set jd [expr { + 1721425 + + [dict get $date dayOfYear] + + ( 365 * $ym1 ) + + ( $ym1 / 4 ) + - ( $ym1 / 100 ) + + ( $ym1 / 400 ) + }] + + # If the date is before the Gregorian change, use the Julian calendar. + + if { $jd < $changeover } { + dict set date gregorian 0 + set jd [expr { + 1721423 + + [dict get $date dayOfYear] + + ( 365 * $ym1 ) + + ( $ym1 / 4 ) + }] + } + + dict set date julianDay $jd + return $date +} + +#---------------------------------------------------------------------- +# +# GetJulianDayFromEraYearMonthWeekDay -- +# +# Determines the Julian Day number corresponding to the nth given +# day-of-the-week in a given month. +# +# Parameters: +# date - Dictionary containing the keys, 'era', 'year', 'month' +# 'weekOfMonth', 'dayOfWeek', and 'dayOfWeekInMonth'. +# changeover - Julian Day of adoption of the Gregorian calendar +# +# Results: +# Returns the given dictionary, augmented with a 'julianDay' key. +# +# Side effects: +# None. +# +# Bugs: +# This code needs to be moved to the C layer. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::GetJulianDayFromEraYearMonthWeekDay {date changeover} { + # Come up with a reference day; either the zeroeth day of the given month + # (dayOfWeekInMonth >= 0) or the seventh day of the following month + # (dayOfWeekInMonth < 0) + + set date2 $date + set week [dict get $date dayOfWeekInMonth] + if { $week >= 0 } { + dict set date2 dayOfMonth 0 + } else { + dict incr date2 month + dict set date2 dayOfMonth 7 + } + set date2 [GetJulianDayFromEraYearMonthDay $date2[set date2 {}] \ + $changeover] + set wd0 [WeekdayOnOrBefore [dict get $date dayOfWeek] \ + [dict get $date2 julianDay]] + dict set date julianDay [expr { $wd0 + 7 * $week }] + return $date +} + +#---------------------------------------------------------------------- +# +# IsGregorianLeapYear -- +# +# Determines whether a given date represents a leap year in the +# Gregorian calendar. +# +# Parameters: +# date -- The date to test. The fields, 'era', 'year' and 'gregorian' +# must be set. +# +# Results: +# Returns 1 if the year is a leap year, 0 otherwise. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::IsGregorianLeapYear { date } { + switch -exact -- [dict get $date era] { + BCE { + set year [expr { 1 - [dict get $date year]}] + } + CE { + set year [dict get $date year] + } + } + if { $year % 4 != 0 } { + return 0 + } elseif { ![dict get $date gregorian] } { + return 1 + } elseif { $year % 400 == 0 } { + return 1 + } elseif { $year % 100 == 0 } { + return 0 + } else { + return 1 + } +} + +#---------------------------------------------------------------------- +# +# WeekdayOnOrBefore -- +# +# Determine the nearest day of week (given by the 'weekday' parameter, +# Sunday==0) on or before a given Julian Day. +# +# Parameters: +# weekday -- Day of the week +# j -- Julian Day number +# +# Results: +# Returns the Julian Day Number of the desired date. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::WeekdayOnOrBefore { weekday j } { + set k [expr { ( $weekday + 6 ) % 7 }] + return [expr { $j - ( $j - $k ) % 7 }] +} + +#---------------------------------------------------------------------- +# +# BSearch -- +# +# Service procedure that does binary search in several places inside the +# 'clock' command. +# +# Parameters: +# list - List of lists, sorted in ascending order by the +# first elements +# key - Value to search for +# +# Results: +# Returns the index of the greatest element in $list that is less than +# or equal to $key. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::BSearch { list key } { + if {[llength $list] == 0} { + return -1 + } + if { $key < [lindex $list 0 0] } { + return -1 + } + + set l 0 + set u [expr { [llength $list] - 1 }] + + while { $l < $u } { + # At this point, we know that + # $k >= [lindex $list $l 0] + # Either $u == [llength $list] or else $k < [lindex $list $u+1 0] + # We find the midpoint of the interval {l,u} rounded UP, compare + # against it, and set l or u to maintain the invariant. Note that the + # interval shrinks at each step, guaranteeing convergence. + + set m [expr { ( $l + $u + 1 ) / 2 }] + if { $key >= [lindex $list $m 0] } { + set l $m + } else { + set u [expr { $m - 1 }] + } + } + + return $l +} + +#---------------------------------------------------------------------- +# +# clock add -- +# +# Adds an offset to a given time. +# +# Syntax: +# clock add clockval ?count unit?... ?-option value? +# +# Parameters: +# clockval -- Starting time value +# count -- Amount of a unit of time to add +# unit -- Unit of time to add, must be one of: +# years year months month weeks week +# days day hours hour minutes minute +# seconds second +# +# Options: +# -gmt BOOLEAN +# (Deprecated) Flag synonymous with '-timezone :GMT' +# -timezone ZONE +# Name of the time zone in which calculations are to be done. +# -locale NAME +# Name of the locale in which calculations are to be done. +# Used to determine the Gregorian change date. +# +# Results: +# Returns the given time adjusted by the given offset(s) in +# order. +# +# Notes: +# It is possible that adding a number of months or years will adjust the +# day of the month as well. For instance, the time at one month after +# 31 January is either 28 or 29 February, because February has fewer +# than 31 days. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::add { clockval args } { + if { [llength $args] % 2 != 0 } { + set cmdName "clock add" + return -code error \ + -errorcode [list CLOCK wrongNumArgs] \ + "wrong \# args: should be\ + \"$cmdName clockval ?number units?...\ + ?-gmt boolean? ?-locale LOCALE? ?-timezone ZONE?\"" + } + if { [catch { expr {wide($clockval)} } result] } { + return -code error $result + } + + set offsets {} + set gmt 0 + set locale c + set timezone [GetSystemTimeZone] + + foreach { a b } $args { + if { [string is integer -strict $a] } { + lappend offsets $a $b + } else { + switch -exact -- $a { + -g - -gm - -gmt { + set gmt $b + } + -l - -lo - -loc - -loca - -local - -locale { + set locale [string tolower $b] + } + -t - -ti - -tim - -time - -timez - -timezo - -timezon - + -timezone { + set timezone $b + } + default { + throw [list CLOCK badOption $a] \ + "bad option \"$a\",\ + must be -gmt, -locale or -timezone" + } + } + } + } + + # Check options for validity + + if { [info exists saw(-gmt)] && [info exists saw(-timezone)] } { + return -code error \ + -errorcode [list CLOCK gmtWithTimezone] \ + "cannot use -gmt and -timezone in same call" + } + if { [catch { expr { wide($clockval) } } result] } { + return -code error "expected integer but got \"$clockval\"" + } + if { ![string is boolean -strict $gmt] } { + return -code error "expected boolean value but got \"$gmt\"" + } elseif { $gmt } { + set timezone :GMT + } + + EnterLocale $locale + + set changeover [mc GREGORIAN_CHANGE_DATE] + + if {[catch {SetupTimeZone $timezone} retval opts]} { + dict unset opts -errorinfo + return -options $opts $retval + } + + try { + foreach { quantity unit } $offsets { + switch -exact -- $unit { + years - year { + set clockval [AddMonths [expr { 12 * $quantity }] \ + $clockval $timezone $changeover] + } + months - month { + set clockval [AddMonths $quantity $clockval $timezone \ + $changeover] + } + + weeks - week { + set clockval [AddDays [expr { 7 * $quantity }] \ + $clockval $timezone $changeover] + } + days - day { + set clockval [AddDays $quantity $clockval $timezone \ + $changeover] + } + + hours - hour { + set clockval [expr { 3600 * $quantity + $clockval }] + } + minutes - minute { + set clockval [expr { 60 * $quantity + $clockval }] + } + seconds - second { + set clockval [expr { $quantity + $clockval }] + } + + default { + throw [list CLOCK badUnit $unit] \ + "unknown unit \"$unit\", must be \ + years, months, weeks, days, hours, minutes or seconds" + } + } + } + return $clockval + } trap CLOCK {result opts} { + # Conceal the innards of [clock] when it's an expected error + dict unset opts -errorinfo + return -options $opts $result + } +} + +#---------------------------------------------------------------------- +# +# AddMonths -- +# +# Add a given number of months to a given clock value in a given +# time zone. +# +# Parameters: +# months - Number of months to add (may be negative) +# clockval - Seconds since the epoch before the operation +# timezone - Time zone in which the operation is to be performed +# +# Results: +# Returns the new clock value as a number of seconds since +# the epoch. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::AddMonths { months clockval timezone changeover } { + variable DaysInRomanMonthInCommonYear + variable DaysInRomanMonthInLeapYear + variable TZData + + # Convert the time to year, month, day, and fraction of day. + + set date [GetDateFields $clockval $TZData($timezone) $changeover] + dict set date secondOfDay [expr { + [dict get $date localSeconds] % 86400 + }] + dict set date tzName $timezone + + # Add the requisite number of months + + set m [dict get $date month] + incr m $months + incr m -1 + set delta [expr { $m / 12 }] + set mm [expr { $m % 12 }] + dict set date month [expr { $mm + 1 }] + dict incr date year $delta + + # If the date doesn't exist in the current month, repair it + + if { [IsGregorianLeapYear $date] } { + set hath [lindex $DaysInRomanMonthInLeapYear $mm] + } else { + set hath [lindex $DaysInRomanMonthInCommonYear $mm] + } + if { [dict get $date dayOfMonth] > $hath } { + dict set date dayOfMonth $hath + } + + # Reconvert to a number of seconds + + set date [GetJulianDayFromEraYearMonthDay \ + $date[set date {}]\ + $changeover] + dict set date localSeconds [expr { + -210866803200 + + ( 86400 * wide([dict get $date julianDay]) ) + + [dict get $date secondOfDay] + }] + set date [ConvertLocalToUTC $date[set date {}] $TZData($timezone) \ + $changeover] + + return [dict get $date seconds] + +} + +#---------------------------------------------------------------------- +# +# AddDays -- +# +# Add a given number of days to a given clock value in a given time +# zone. +# +# Parameters: +# days - Number of days to add (may be negative) +# clockval - Seconds since the epoch before the operation +# timezone - Time zone in which the operation is to be performed +# changeover - Julian Day on which the Gregorian calendar was adopted +# in the target locale. +# +# Results: +# Returns the new clock value as a number of seconds since the epoch. +# +# Side effects: +# None. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::AddDays { days clockval timezone changeover } { + variable TZData + + # Convert the time to Julian Day + + set date [GetDateFields $clockval $TZData($timezone) $changeover] + dict set date secondOfDay [expr { + [dict get $date localSeconds] % 86400 + }] + dict set date tzName $timezone + + # Add the requisite number of days + + dict incr date julianDay $days + + # Reconvert to a number of seconds + + dict set date localSeconds [expr { + -210866803200 + + ( 86400 * wide([dict get $date julianDay]) ) + + [dict get $date secondOfDay] + }] + set date [ConvertLocalToUTC $date[set date {}] $TZData($timezone) \ + $changeover] + + return [dict get $date seconds] + +} + +#---------------------------------------------------------------------- +# +# ChangeCurrentLocale -- +# +# The global locale was changed within msgcat. +# Clears the buffered parse functions of the current locale. +# +# Parameters: +# loclist (ignored) +# +# Results: +# None. +# +# Side effects: +# Buffered parse functions are cleared. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::ChangeCurrentLocale {args} { + variable FormatProc + variable LocaleNumeralCache + variable CachedSystemTimeZone + variable TimeZoneBad + + foreach p [info procs [namespace current]::scanproc'*'current] { + rename $p {} + } + foreach p [info procs [namespace current]::formatproc'*'current] { + rename $p {} + } + + catch {array unset FormatProc *'current} + set LocaleNumeralCache {} +} + +#---------------------------------------------------------------------- +# +# ClearCaches -- +# +# Clears all caches to reclaim the memory used in [clock] +# +# Parameters: +# None. +# +# Results: +# None. +# +# Side effects: +# Caches are cleared. +# +#---------------------------------------------------------------------- + +proc ::tcl::clock::ClearCaches {} { + variable FormatProc + variable LocaleNumeralCache + variable CachedSystemTimeZone + variable TimeZoneBad + + foreach p [info procs [namespace current]::scanproc'*] { + rename $p {} + } + foreach p [info procs [namespace current]::formatproc'*] { + rename $p {} + } + + catch {unset FormatProc} + set LocaleNumeralCache {} + catch {unset CachedSystemTimeZone} + set TimeZoneBad {} + InitTZData +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/ascii.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/ascii.enc new file mode 100644 index 0000000000000000000000000000000000000000..e0320b8c58918fe264791ca900108fde55bf5b17 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/ascii.enc @@ -0,0 +1,20 @@ +# Encoding file: ascii, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/big5.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/big5.enc new file mode 100644 index 0000000000000000000000000000000000000000..26179f43d3404fda0817a481358883c5b4c6aa03 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/big5.enc @@ -0,0 +1,1516 @@ +# Encoding file: big5, multi-byte +M +003F 0 89 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +A1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +3000FF0C30013002FF0E2022FF1BFF1AFF1FFF01FE3020262025FE50FF64FE52 +00B7FE54FE55FE56FE57FF5C2013FE312014FE33FFFDFE34FE4FFF08FF09FE35 +FE36FF5BFF5DFE37FE3830143015FE39FE3A30103011FE3BFE3C300A300BFE3D +FE3E30083009FE3FFE40300C300DFE41FE42300E300FFE43FE44FE59FE5A0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000FE5BFE5CFE5DFE5E20182019201C201D301D301E20352032FF03FF06FF0A +203B00A7300325CB25CF25B325B225CE2606260525C725C625A125A025BD25BC +32A32105203EFFFDFF3FFFFDFE49FE4AFE4DFE4EFE4BFE4CFE5FFE60FE61FF0B +FF0D00D700F700B1221AFF1CFF1EFF1D226622672260221E22522261FE62FE63 +FE64FE65FE66223C2229222A22A52220221F22BF33D233D1222B222E22352234 +26402642264126092191219321902192219621972199219822252223FFFD0000 +A2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +FFFDFF0FFF3CFF0400A5301200A200A3FF05FF2021032109FE69FE6AFE6B33D5 +339C339D339E33CE33A1338E338F33C400B05159515B515E515D5161516355E7 +74E97CCE25812582258325842585258625872588258F258E258D258C258B258A +2589253C2534252C2524251C2594250025022595250C251025142518256D0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000256E2570256F2550255E256A256125E225E325E525E4257125722573FF10 +FF11FF12FF13FF14FF15FF16FF17FF18FF192160216121622163216421652166 +216721682169302130223023302430253026302730283029FFFD5344FFFDFF21 +FF22FF23FF24FF25FF26FF27FF28FF29FF2AFF2BFF2CFF2DFF2EFF2FFF30FF31 +FF32FF33FF34FF35FF36FF37FF38FF39FF3AFF41FF42FF43FF44FF45FF46FF47 +FF48FF49FF4AFF4BFF4CFF4DFF4EFF4FFF50FF51FF52FF53FF54FF55FF560000 +A3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +FF57FF58FF59FF5A039103920393039403950396039703980399039A039B039C +039D039E039F03A003A103A303A403A503A603A703A803A903B103B203B303B4 +03B503B603B703B803B903BA03BB03BC03BD03BE03BF03C003C103C303C403C5 +03C603C703C803C931053106310731083109310A310B310C310D310E310F0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00003110311131123113311431153116311731183119311A311B311C311D311E +311F312031213122312331243125312631273128312902D902C902CA02C702CB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +A4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +4E004E594E014E034E434E5D4E864E8C4EBA513F5165516B51E052005201529B +53155341535C53C84E094E0B4E084E0A4E2B4E3851E14E454E484E5F4E5E4E8E +4EA15140520352FA534353C953E3571F58EB5915592759735B505B515B535BF8 +5C0F5C225C385C715DDD5DE55DF15DF25DF35DFE5E725EFE5F0B5F13624D0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00004E114E104E0D4E2D4E304E394E4B5C394E884E914E954E924E944EA24EC1 +4EC04EC34EC64EC74ECD4ECA4ECB4EC4514351415167516D516E516C519751F6 +52065207520852FB52FE52FF53165339534853475345535E538453CB53CA53CD +58EC5929592B592A592D5B545C115C245C3A5C6F5DF45E7B5EFF5F145F155FC3 +62086236624B624E652F6587659765A465B965E566F0670867286B206B626B79 +6BCB6BD46BDB6C0F6C34706B722A7236723B72477259725B72AC738B4E190000 +A5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +4E164E154E144E184E3B4E4D4E4F4E4E4EE54ED84ED44ED54ED64ED74EE34EE4 +4ED94EDE514551445189518A51AC51F951FA51F8520A52A0529F530553065317 +531D4EDF534A534953615360536F536E53BB53EF53E453F353EC53EE53E953E8 +53FC53F853F553EB53E653EA53F253F153F053E553ED53FB56DB56DA59160000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000592E5931597459765B555B835C3C5DE85DE75DE65E025E035E735E7C5F01 +5F185F175FC5620A625362546252625165A565E6672E672C672A672B672D6B63 +6BCD6C116C106C386C416C406C3E72AF7384738974DC74E67518751F75287529 +7530753175327533758B767D76AE76BF76EE77DB77E277F3793A79BE7A747ACB +4E1E4E1F4E524E534E694E994EA44EA64EA54EFF4F094F194F0A4F154F0D4F10 +4F114F0F4EF24EF64EFB4EF04EF34EFD4F014F0B514951475146514851680000 +A6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5171518D51B0521752115212520E521652A3530853215320537053715409540F +540C540A54105401540B54045411540D54085403540E5406541256E056DE56DD +573357305728572D572C572F57295919591A59375938598459785983597D5979 +598259815B575B585B875B885B855B895BFA5C165C795DDE5E065E765E740000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005F0F5F1B5FD95FD6620E620C620D62106263625B6258653665E965E865EC +65ED66F266F36709673D6734673167356B216B646B7B6C166C5D6C576C596C5F +6C606C506C556C616C5B6C4D6C4E7070725F725D767E7AF97C737CF87F367F8A +7FBD80018003800C80128033807F8089808B808C81E381EA81F381FC820C821B +821F826E8272827E866B8840884C8863897F96214E324EA84F4D4F4F4F474F57 +4F5E4F344F5B4F554F304F504F514F3D4F3A4F384F434F544F3C4F464F630000 +A7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +4F5C4F604F2F4F4E4F364F594F5D4F484F5A514C514B514D517551B651B75225 +52245229522A522852AB52A952AA52AC532353735375541D542D541E543E5426 +544E542754465443543354485442541B5429544A5439543B5438542E54355436 +5420543C54405431542B541F542C56EA56F056E456EB574A57515740574D0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005747574E573E5750574F573B58EF593E599D599259A8599E59A359995996 +598D59A45993598A59A55B5D5B5C5B5A5B5B5B8C5B8B5B8F5C2C5C405C415C3F +5C3E5C905C915C945C8C5DEB5E0C5E8F5E875E8A5EF75F045F1F5F645F625F77 +5F795FD85FCC5FD75FCD5FF15FEB5FF85FEA6212621162846297629662806276 +6289626D628A627C627E627962736292626F6298626E62956293629162866539 +653B653865F166F4675F674E674F67506751675C6756675E6749674667600000 +A8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +675367576B656BCF6C426C5E6C996C816C886C896C856C9B6C6A6C7A6C906C70 +6C8C6C686C966C926C7D6C836C726C7E6C746C866C766C8D6C946C986C827076 +707C707D707872627261726072C472C27396752C752B75377538768276EF77E3 +79C179C079BF7A767CFB7F5580968093809D8098809B809A80B2826F82920000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000828B828D898B89D28A008C378C468C558C9D8D648D708DB38EAB8ECA8F9B +8FB08FC28FC68FC58FC45DE1909190A290AA90A690A3914991C691CC9632962E +9631962A962C4E264E564E734E8B4E9B4E9E4EAB4EAC4F6F4F9D4F8D4F734F7F +4F6C4F9B4F8B4F864F834F704F754F884F694F7B4F964F7E4F8F4F914F7A5154 +51525155516951775176517851BD51FD523B52385237523A5230522E52365241 +52BE52BB5352535453535351536653775378537953D653D453D7547354750000 +A9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5496547854955480547B5477548454925486547C549054715476548C549A5462 +5468548B547D548E56FA57835777576A5769576157665764577C591C59495947 +59485944595459BE59BB59D459B959AE59D159C659D059CD59CB59D359CA59AF +59B359D259C55B5F5B645B635B975B9A5B985B9C5B995B9B5C1A5C485C450000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005C465CB75CA15CB85CA95CAB5CB15CB35E185E1A5E165E155E1B5E115E78 +5E9A5E975E9C5E955E965EF65F265F275F295F805F815F7F5F7C5FDD5FE05FFD +5FF55FFF600F6014602F60356016602A6015602160276029602B601B62166215 +623F623E6240627F62C962CC62C462BF62C262B962D262DB62AB62D362D462CB +62C862A862BD62BC62D062D962C762CD62B562DA62B162D862D662D762C662AC +62CE653E65A765BC65FA66146613660C66066602660E6600660F6615660A0000 +AA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6607670D670B676D678B67956771679C677367776787679D6797676F6770677F +6789677E67906775679A6793677C676A67726B236B666B676B7F6C136C1B6CE3 +6CE86CF36CB16CCC6CE56CB36CBD6CBE6CBC6CE26CAB6CD56CD36CB86CC46CB9 +6CC16CAE6CD76CC56CF16CBF6CBB6CE16CDB6CCA6CAC6CEF6CDC6CD66CE00000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007095708E7092708A7099722C722D723872487267726972C072CE72D972D7 +72D073A973A8739F73AB73A5753D759D7599759A768476C276F276F477E577FD +793E7940794179C979C87A7A7A797AFA7CFE7F547F8C7F8B800580BA80A580A2 +80B180A180AB80A980B480AA80AF81E581FE820D82B3829D829982AD82BD829F +82B982B182AC82A582AF82B882A382B082BE82B7864E8671521D88688ECB8FCE +8FD48FD190B590B890B190B691C791D195779580961C9640963F963B96440000 +AB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +964296B996E89752975E4E9F4EAD4EAE4FE14FB54FAF4FBF4FE04FD14FCF4FDD +4FC34FB64FD84FDF4FCA4FD74FAE4FD04FC44FC24FDA4FCE4FDE4FB751575192 +519151A0524E5243524A524D524C524B524752C752C952C352C1530D5357537B +539A53DB54AC54C054A854CE54C954B854A654B354C754C254BD54AA54C10000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000054C454C854AF54AB54B154BB54A954A754BF56FF5782578B57A057A357A2 +57CE57AE579359555951594F594E595059DC59D859FF59E359E85A0359E559EA +59DA59E65A0159FB5B695BA35BA65BA45BA25BA55C015C4E5C4F5C4D5C4B5CD9 +5CD25DF75E1D5E255E1F5E7D5EA05EA65EFA5F085F2D5F655F885F855F8A5F8B +5F875F8C5F896012601D60206025600E6028604D60706068606260466043606C +606B606A6064624162DC6316630962FC62ED630162EE62FD630762F162F70000 +AC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +62EF62EC62FE62F463116302653F654565AB65BD65E26625662D66206627662F +661F66286631662466F767FF67D367F167D467D067EC67B667AF67F567E967EF +67C467D167B467DA67E567B867CF67DE67F367B067D967E267DD67D26B6A6B83 +6B866BB56BD26BD76C1F6CC96D0B6D326D2A6D416D256D0C6D316D1E6D170000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006D3B6D3D6D3E6D366D1B6CF56D396D276D386D296D2E6D356D0E6D2B70AB +70BA70B370AC70AF70AD70B870AE70A472307272726F727472E972E072E173B7 +73CA73BB73B273CD73C073B3751A752D754F754C754E754B75AB75A475A575A2 +75A3767876867687768876C876C676C376C5770176F976F87709770B76FE76FC +770777DC78027814780C780D794679497948794779B979BA79D179D279CB7A7F +7A817AFF7AFD7C7D7D027D057D007D097D077D047D067F387F8E7FBF80040000 +AD +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8010800D8011803680D680E580DA80C380C480CC80E180DB80CE80DE80E480DD +81F4822282E78303830582E382DB82E6830482E58302830982D282D782F18301 +82DC82D482D182DE82D382DF82EF830686508679867B867A884D886B898189D4 +8A088A028A038C9E8CA08D748D738DB48ECD8ECC8FF08FE68FE28FEA8FE50000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008FED8FEB8FE48FE890CA90CE90C190C3914B914A91CD95829650964B964C +964D9762976997CB97ED97F3980198A898DB98DF999699994E584EB3500C500D +50234FEF502650254FF8502950165006503C501F501A501250114FFA50005014 +50284FF15021500B501950184FF34FEE502D502A4FFE502B5009517C51A451A5 +51A251CD51CC51C651CB5256525C5254525B525D532A537F539F539D53DF54E8 +55105501553754FC54E554F2550654FA551454E954ED54E1550954EE54EA0000 +AE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +54E65527550754FD550F5703570457C257D457CB57C35809590F59575958595A +5A115A185A1C5A1F5A1B5A1359EC5A205A235A295A255A0C5A095B6B5C585BB0 +5BB35BB65BB45BAE5BB55BB95BB85C045C515C555C505CED5CFD5CFB5CEA5CE8 +5CF05CF65D015CF45DEE5E2D5E2B5EAB5EAD5EA75F315F925F915F9060590000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006063606560506055606D6069606F6084609F609A608D6094608C60856096 +624762F3630862FF634E633E632F635563426346634F6349633A6350633D632A +632B6328634D634C65486549659965C165C566426649664F66436652664C6645 +664166F867146715671768216838684868466853683968426854682968B36817 +684C6851683D67F468506840683C6843682A68456813681868416B8A6B896BB7 +6C236C276C286C266C246CF06D6A6D956D886D876D666D786D776D596D930000 +AF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6D6C6D896D6E6D5A6D746D696D8C6D8A6D796D856D656D9470CA70D870E470D9 +70C870CF7239727972FC72F972FD72F872F7738673ED740973EE73E073EA73DE +7554755D755C755A755975BE75C575C775B275B375BD75BC75B975C275B8768B +76B076CA76CD76CE7729771F7720772877E9783078277838781D783478370000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007825782D7820781F7832795579507960795F7956795E795D7957795A79E4 +79E379E779DF79E679E979D87A847A887AD97B067B117C897D217D177D0B7D0A +7D207D227D147D107D157D1A7D1C7D0D7D197D1B7F3A7F5F7F947FC57FC18006 +8018801580198017803D803F80F1810280F0810580ED80F4810680F880F38108 +80FD810A80FC80EF81ED81EC82008210822A822B8228822C82BB832B83528354 +834A83388350834983358334834F833283398336831783408331832883430000 +B0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8654868A86AA869386A486A9868C86A3869C8870887788818882887D88798A18 +8A108A0E8A0C8A158A0A8A178A138A168A0F8A118C488C7A8C798CA18CA28D77 +8EAC8ED28ED48ECF8FB1900190068FF790008FFA8FF490038FFD90058FF89095 +90E190DD90E29152914D914C91D891DD91D791DC91D995839662966396610000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000965B965D96649658965E96BB98E299AC9AA89AD89B259B329B3C4E7E507A +507D505C50475043504C505A504950655076504E5055507550745077504F500F +506F506D515C519551F0526A526F52D252D952D852D55310530F5319533F5340 +533E53C366FC5546556A55665544555E55615543554A55315556554F5555552F +55645538552E555C552C55635533554155575708570B570957DF5805580A5806 +57E057E457FA5802583557F757F9592059625A365A415A495A665A6A5A400000 +B1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5A3C5A625A5A5A465A4A5B705BC75BC55BC45BC25BBF5BC65C095C085C075C60 +5C5C5C5D5D075D065D0E5D1B5D165D225D115D295D145D195D245D275D175DE2 +5E385E365E335E375EB75EB85EB65EB55EBE5F355F375F575F6C5F695F6B5F97 +5F995F9E5F985FA15FA05F9C607F60A3608960A060A860CB60B460E660BD0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000060C560BB60B560DC60BC60D860D560C660DF60B860DA60C7621A621B6248 +63A063A76372639663A263A563776367639863AA637163A963896383639B636B +63A863846388639963A163AC6392638F6380637B63696368637A655D65566551 +65596557555F654F655865556554659C659B65AC65CF65CB65CC65CE665D665A +666466686666665E66F952D7671B688168AF68A2689368B5687F687668B168A7 +689768B0688368C468AD688668856894689D68A8689F68A168826B326BBA0000 +B2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6BEB6BEC6C2B6D8E6DBC6DF36DD96DB26DE16DCC6DE46DFB6DFA6E056DC76DCB +6DAF6DD16DAE6DDE6DF96DB86DF76DF56DC56DD26E1A6DB56DDA6DEB6DD86DEA +6DF16DEE6DE86DC66DC46DAA6DEC6DBF6DE670F97109710A70FD70EF723D727D +7281731C731B73167313731973877405740A7403740673FE740D74E074F60000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000074F7751C75227565756675627570758F75D475D575B575CA75CD768E76D4 +76D276DB7737773E773C77367738773A786B7843784E79657968796D79FB7A92 +7A957B207B287B1B7B2C7B267B197B1E7B2E7C927C977C957D467D437D717D2E +7D397D3C7D407D307D337D447D2F7D427D327D317F3D7F9E7F9A7FCC7FCE7FD2 +801C804A8046812F81168123812B81298130812482028235823782368239838E +839E8398837883A2839683BD83AB8392838A8393838983A08377837B837C0000 +B3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +838683A786555F6A86C786C086B686C486B586C686CB86B186AF86C98853889E +888888AB88928896888D888B8993898F8A2A8A1D8A238A258A318A2D8A1F8A1B +8A228C498C5A8CA98CAC8CAB8CA88CAA8CA78D678D668DBE8DBA8EDB8EDF9019 +900D901A90179023901F901D90109015901E9020900F90229016901B90140000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000090E890ED90FD915791CE91F591E691E391E791ED91E99589966A96759673 +96789670967496769677966C96C096EA96E97AE07ADF980298039B5A9CE59E75 +9E7F9EA59EBB50A2508D508550995091508050965098509A670051F152725274 +5275526952DE52DD52DB535A53A5557B558055A7557C558A559D55985582559C +55AA55945587558B558355B355AE559F553E55B2559A55BB55AC55B1557E5589 +55AB5599570D582F582A58345824583058315821581D582058F958FA59600000 +B4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5A775A9A5A7F5A925A9B5AA75B735B715BD25BCC5BD35BD05C0A5C0B5C315D4C +5D505D345D475DFD5E455E3D5E405E435E7E5ECA5EC15EC25EC45F3C5F6D5FA9 +5FAA5FA860D160E160B260B660E0611C612360FA611560F060FB60F4616860F1 +610E60F6610961006112621F624963A3638C63CF63C063E963C963C663CD0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000063D263E363D063E163D663ED63EE637663F463EA63DB645263DA63F9655E +6566656265636591659065AF666E667066746676666F6691667A667E667766FE +66FF671F671D68FA68D568E068D868D7690568DF68F568EE68E768F968D268F2 +68E368CB68CD690D6912690E68C968DA696E68FB6B3E6B3A6B3D6B986B966BBC +6BEF6C2E6C2F6C2C6E2F6E386E546E216E326E676E4A6E206E256E236E1B6E5B +6E586E246E566E6E6E2D6E266E6F6E346E4D6E3A6E2C6E436E1D6E3E6ECB0000 +B5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6E896E196E4E6E636E446E726E696E5F7119711A7126713071217136716E711C +724C728472807336732573347329743A742A743374227425743574367434742F +741B7426742875257526756B756A75E275DB75E375D975D875DE75E0767B767C +7696769376B476DC774F77ED785D786C786F7A0D7A087A0B7A057A007A980000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007A977A967AE57AE37B497B567B467B507B527B547B4D7B4B7B4F7B517C9F +7CA57D5E7D507D687D557D2B7D6E7D727D617D667D627D707D7355847FD47FD5 +800B8052808581558154814B8151814E81398146813E814C815381748212821C +83E9840383F8840D83E083C5840B83C183EF83F183F48457840A83F0840C83CC +83FD83F283CA8438840E840483DC840783D483DF865B86DF86D986ED86D486DB +86E486D086DE885788C188C288B1898389968A3B8A608A558A5E8A3C8A410000 +B6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8A548A5B8A508A468A348A3A8A368A568C618C828CAF8CBC8CB38CBD8CC18CBB +8CC08CB48CB78CB68CBF8CB88D8A8D858D818DCE8DDD8DCB8DDA8DD18DCC8DDB +8DC68EFB8EF88EFC8F9C902E90359031903890329036910290F5910990FE9163 +916591CF9214921592239209921E920D9210920792119594958F958B95910000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000095939592958E968A968E968B967D96859686968D9672968496C196C596C4 +96C696C796EF96F297CC98059806980898E798EA98EF98E998F298ED99AE99AD +9EC39ECD9ED14E8250AD50B550B250B350C550BE50AC50B750BB50AF50C7527F +5277527D52DF52E652E452E252E3532F55DF55E855D355E655CE55DC55C755D1 +55E355E455EF55DA55E155C555C655E555C957125713585E585158585857585A +5854586B584C586D584A58625852584B59675AC15AC95ACC5ABE5ABD5ABC0000 +B7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5AB35AC25AB25D695D6F5E4C5E795EC95EC85F125F595FAC5FAE611A610F6148 +611F60F3611B60F961016108614E614C6144614D613E61346127610D61066137 +622162226413643E641E642A642D643D642C640F641C6414640D643664166417 +6406656C659F65B06697668966876688669666846698668D67036994696D0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000695A697769606954697569306982694A6968696B695E695369796986695D +6963695B6B476B726BC06BBF6BD36BFD6EA26EAF6ED36EB66EC26E906E9D6EC7 +6EC56EA56E986EBC6EBA6EAB6ED16E966E9C6EC46ED46EAA6EA76EB4714E7159 +7169716471497167715C716C7166714C7165715E714671687156723A72527337 +7345733F733E746F745A7455745F745E7441743F7459745B745C757675787600 +75F0760175F275F175FA75FF75F475F376DE76DF775B776B7766775E77630000 +B8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +7779776A776C775C77657768776277EE788E78B078977898788C7889787C7891 +7893787F797A797F7981842C79BD7A1C7A1A7A207A147A1F7A1E7A9F7AA07B77 +7BC07B607B6E7B677CB17CB37CB57D937D797D917D817D8F7D5B7F6E7F697F6A +7F727FA97FA87FA480568058808680848171817081788165816E8173816B0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008179817A81668205824784828477843D843184758466846B8449846C845B +843C8435846184638469846D8446865E865C865F86F9871387088707870086FE +86FB870287038706870A885988DF88D488D988DC88D888DD88E188CA88D588D2 +899C89E38A6B8A728A738A668A698A708A878A7C8A638AA08A718A858A6D8A62 +8A6E8A6C8A798A7B8A3E8A688C628C8A8C898CCA8CC78CC88CC48CB28CC38CC2 +8CC58DE18DDF8DE88DEF8DF38DFA8DEA8DE48DE68EB28F038F098EFE8F0A0000 +B9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8F9F8FB2904B904A905390429054903C905590509047904F904E904D9051903E +904191129117916C916A916991C9923792579238923D9240923E925B924B9264 +925192349249924D92459239923F925A959896989694969596CD96CB96C996CA +96F796FB96F996F6975697749776981098119813980A9812980C98FC98F40000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000098FD98FE99B399B199B49AE19CE99E829F0E9F139F2050E750EE50E550D6 +50ED50DA50D550CF50D150F150CE50E9516251F352835282533153AD55FE5600 +561B561755FD561456065609560D560E55F75616561F5608561055F657185716 +5875587E58835893588A58795885587D58FD592559225924596A59695AE15AE6 +5AE95AD75AD65AD85AE35B755BDE5BE75BE15BE55BE65BE85BE25BE45BDF5C0D +5C625D845D875E5B5E635E555E575E545ED35ED65F0A5F465F705FB961470000 +BA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +613F614B617761626163615F615A61586175622A64876458645464A46478645F +647A645164676434646D647B657265A165D765D666A266A8669D699C69A86995 +69C169AE69D369CB699B69B769BB69AB69B469D069CD69AD69CC69A669C369A3 +6B496B4C6C336F336F146EFE6F136EF46F296F3E6F206F2C6F0F6F026F220000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006EFF6EEF6F066F316F386F326F236F156F2B6F2F6F886F2A6EEC6F016EF2 +6ECC6EF771947199717D718A71847192723E729272967344735074647463746A +7470746D750475917627760D760B7609761376E176E37784777D777F776178C1 +789F78A778B378A978A3798E798F798D7A2E7A317AAA7AA97AED7AEF7BA17B95 +7B8B7B757B977B9D7B947B8F7BB87B877B847CB97CBD7CBE7DBB7DB07D9C7DBD +7DBE7DA07DCA7DB47DB27DB17DBA7DA27DBF7DB57DB87DAD7DD27DC77DAC0000 +BB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +7F707FE07FE17FDF805E805A808781508180818F8188818A817F818281E781FA +82078214821E824B84C984BF84C684C48499849E84B2849C84CB84B884C084D3 +849084BC84D184CA873F871C873B872287258734871887558737872988F38902 +88F488F988F888FD88E8891A88EF8AA68A8C8A9E8AA38A8D8AA18A938AA40000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008AAA8AA58AA88A988A918A9A8AA78C6A8C8D8C8C8CD38CD18CD28D6B8D99 +8D958DFC8F148F128F158F138FA390609058905C90639059905E9062905D905B +91199118911E917591789177917492789280928592989296927B9293929C92A8 +927C929195A195A895A995A395A595A49699969C969B96CC96D29700977C9785 +97F69817981898AF98B199039905990C990999C19AAF9AB09AE69B419B429CF4 +9CF69CF39EBC9F3B9F4A5104510050FB50F550F9510251085109510551DC0000 +BC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +528752885289528D528A52F053B2562E563B56395632563F563456295653564E +565756745636562F56305880589F589E58B3589C58AE58A958A6596D5B095AFB +5B0B5AF55B0C5B085BEE5BEC5BE95BEB5C645C655D9D5D945E625E5F5E615EE2 +5EDA5EDF5EDD5EE35EE05F485F715FB75FB561766167616E615D615561820000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000617C6170616B617E61A7619061AB618E61AC619A61A4619461AE622E6469 +646F6479649E64B26488649064B064A56493649564A9649264AE64AD64AB649A +64AC649964A264B365756577657866AE66AB66B466B16A236A1F69E86A016A1E +6A1969FD6A216A136A0A69F36A026A0569ED6A116B506B4E6BA46BC56BC66F3F +6F7C6F846F516F666F546F866F6D6F5B6F786F6E6F8E6F7A6F706F646F976F58 +6ED56F6F6F606F5F719F71AC71B171A87256729B734E73577469748B74830000 +BD +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +747E7480757F76207629761F7624762676217622769A76BA76E4778E7787778C +7791778B78CB78C578BA78CA78BE78D578BC78D07A3F7A3C7A407A3D7A377A3B +7AAF7AAE7BAD7BB17BC47BB47BC67BC77BC17BA07BCC7CCA7DE07DF47DEF7DFB +7DD87DEC7DDD7DE87DE37DDA7DDE7DE97D9E7DD97DF27DF97F757F777FAF0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007FE98026819B819C819D81A0819A81988517853D851A84EE852C852D8513 +851185238521851484EC852584FF850687828774877687608766877887688759 +8757874C8753885B885D89108907891289138915890A8ABC8AD28AC78AC48A95 +8ACB8AF88AB28AC98AC28ABF8AB08AD68ACD8AB68AB98ADB8C4C8C4E8C6C8CE0 +8CDE8CE68CE48CEC8CED8CE28CE38CDC8CEA8CE18D6D8D9F8DA38E2B8E108E1D +8E228E0F8E298E1F8E218E1E8EBA8F1D8F1B8F1F8F298F268F2A8F1C8F1E0000 +BE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8F259069906E9068906D90779130912D9127913191879189918B918392C592BB +92B792EA92AC92E492C192B392BC92D292C792F092B295AD95B1970497069707 +97099760978D978B978F9821982B981C98B3990A99139912991899DD99D099DF +99DB99D199D599D299D99AB79AEE9AEF9B279B459B449B779B6F9D069D090000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009D039EA99EBE9ECE58A89F5251125118511451105115518051AA51DD5291 +529352F35659566B5679566956645678566A566856655671566F566C56625676 +58C158BE58C758C5596E5B1D5B345B785BF05C0E5F4A61B2619161A9618A61CD +61B661BE61CA61C8623064C564C164CB64BB64BC64DA64C464C764C264CD64BF +64D264D464BE657466C666C966B966C466C766B86A3D6A386A3A6A596A6B6A58 +6A396A446A626A616A4B6A476A356A5F6A486B596B776C056FC26FB16FA10000 +BF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6FC36FA46FC16FA76FB36FC06FB96FB66FA66FA06FB471BE71C971D071D271C8 +71D571B971CE71D971DC71C371C47368749C74A37498749F749E74E2750C750D +76347638763A76E776E577A0779E779F77A578E878DA78EC78E779A67A4D7A4E +7A467A4C7A4B7ABA7BD97C117BC97BE47BDB7BE17BE97BE67CD57CD67E0A0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007E117E087E1B7E237E1E7E1D7E097E107F797FB27FF07FF17FEE802881B3 +81A981A881FB820882588259854A855985488568856985438549856D856A855E +8783879F879E87A2878D8861892A89328925892B892189AA89A68AE68AFA8AEB +8AF18B008ADC8AE78AEE8AFE8B018B028AF78AED8AF38AF68AFC8C6B8C6D8C93 +8CF48E448E318E348E428E398E358F3B8F2F8F388F338FA88FA6907590749078 +9072907C907A913491929320933692F89333932F932292FC932B9304931A0000 +C0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +9310932693219315932E931995BB96A796A896AA96D5970E97119716970D9713 +970F975B975C9766979898309838983B9837982D9839982499109928991E991B +9921991A99ED99E299F19AB89ABC9AFB9AED9B289B919D159D239D269D289D12 +9D1B9ED89ED49F8D9F9C512A511F5121513252F5568E56805690568556870000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000568F58D558D358D158CE5B305B2A5B245B7A5C375C685DBC5DBA5DBD5DB8 +5E6B5F4C5FBD61C961C261C761E661CB6232623464CE64CA64D864E064F064E6 +64EC64F164E264ED6582658366D966D66A806A946A846AA26A9C6ADB6AA36A7E +6A976A906AA06B5C6BAE6BDA6C086FD86FF16FDF6FE06FDB6FE46FEB6FEF6F80 +6FEC6FE16FE96FD56FEE6FF071E771DF71EE71E671E571ED71EC71F471E07235 +72467370737274A974B074A674A876467642764C76EA77B377AA77B077AC0000 +C1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +77A777AD77EF78F778FA78F478EF790179A779AA7A577ABF7C077C0D7BFE7BF7 +7C0C7BE07CE07CDC7CDE7CE27CDF7CD97CDD7E2E7E3E7E467E377E327E437E2B +7E3D7E317E457E417E347E397E487E357E3F7E2F7F447FF37FFC807180728070 +806F807381C681C381BA81C281C081BF81BD81C981BE81E88209827185AA0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008584857E859C8591859485AF859B858785A8858A866787C087D187B387D2 +87C687AB87BB87BA87C887CB893B893689448938893D89AC8B0E8B178B198B1B +8B0A8B208B1D8B048B108C418C3F8C738CFA8CFD8CFC8CF88CFB8DA88E498E4B +8E488E4A8F448F3E8F428F458F3F907F907D9084908190829080913991A3919E +919C934D938293289375934A9365934B9318937E936C935B9370935A935495CA +95CB95CC95C895C696B196B896D6971C971E97A097D3984698B699359A010000 +C2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +99FF9BAE9BAB9BAA9BAD9D3B9D3F9E8B9ECF9EDE9EDC9EDD9EDB9F3E9F4B53E2 +569556AE58D958D85B385F5D61E3623364F464F264FE650664FA64FB64F765B7 +66DC67266AB36AAC6AC36ABB6AB86AC26AAE6AAF6B5F6B786BAF7009700B6FFE +70066FFA7011700F71FB71FC71FE71F87377737574A774BF7515765676580000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000765277BD77BF77BB77BC790E79AE7A617A627A607AC47AC57C2B7C277C2A +7C1E7C237C217CE77E547E557E5E7E5A7E617E527E597F487FF97FFB80778076 +81CD81CF820A85CF85A985CD85D085C985B085BA85B985A687EF87EC87F287E0 +898689B289F48B288B398B2C8B2B8C508D058E598E638E668E648E5F8E558EC0 +8F498F4D90879083908891AB91AC91D09394938A939693A293B393AE93AC93B0 +9398939A939795D495D695D095D596E296DC96D996DB96DE972497A397A60000 +C3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +97AD97F9984D984F984C984E985398BA993E993F993D992E99A59A0E9AC19B03 +9B069B4F9B4E9B4D9BCA9BC99BFD9BC89BC09D519D5D9D609EE09F159F2C5133 +56A558DE58DF58E25BF59F905EEC61F261F761F661F56500650F66E066DD6AE5 +6ADD6ADA6AD3701B701F7028701A701D701570187206720D725872A273780000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000737A74BD74CA74E375877586765F766177C7791979B17A6B7A697C3E7C3F +7C387C3D7C377C407E6B7E6D7E797E697E6A7F857E737FB67FB97FB881D885E9 +85DD85EA85D585E485E585F787FB8805880D87F987FE8960895F8956895E8B41 +8B5C8B588B498B5A8B4E8B4F8B468B598D088D0A8E7C8E728E878E768E6C8E7A +8E748F548F4E8FAD908A908B91B191AE93E193D193DF93C393C893DC93DD93D6 +93E293CD93D893E493D793E895DC96B496E3972A9727976197DC97FB985E0000 +C4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +9858985B98BC994599499A169A199B0D9BE89BE79BD69BDB9D899D619D729D6A +9D6C9E929E979E939EB452F856A856B756B656B456BC58E45B405B435B7D5BF6 +5DC961F861FA65186514651966E667276AEC703E703070327210737B74CF7662 +76657926792A792C792B7AC77AF67C4C7C437C4D7CEF7CF08FAE7E7D7E7C0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007E827F4C800081DA826685FB85F9861185FA8606860B8607860A88148815 +896489BA89F88B708B6C8B668B6F8B5F8B6B8D0F8D0D8E898E818E858E8291B4 +91CB9418940393FD95E1973098C49952995199A89A2B9A309A379A359C139C0D +9E799EB59EE89F2F9F5F9F639F615137513856C156C056C259145C6C5DCD61FC +61FE651D651C659566E96AFB6B046AFA6BB2704C721B72A774D674D4766977D3 +7C507E8F7E8C7FBC8617862D861A882388228821881F896A896C89BD8B740000 +C5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8B778B7D8D138E8A8E8D8E8B8F5F8FAF91BA942E94339435943A94389432942B +95E297389739973297FF9867986599579A459A439A409A3E9ACF9B549B519C2D +9C259DAF9DB49DC29DB89E9D9EEF9F199F5C9F669F67513C513B56C856CA56C9 +5B7F5DD45DD25F4E61FF65246B0A6B6170517058738074E4758A766E766C0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000079B37C607C5F807E807D81DF8972896F89FC8B808D168D178E918E938F61 +9148944494519452973D973E97C397C1986B99559A559A4D9AD29B1A9C499C31 +9C3E9C3B9DD39DD79F349F6C9F6A9F9456CC5DD662006523652B652A66EC6B10 +74DA7ACA7C647C637C657E937E967E9481E28638863F88318B8A9090908F9463 +946094649768986F995C9A5A9A5B9A579AD39AD49AD19C549C579C569DE59E9F +9EF456D158E9652C705E7671767277D77F507F888836883988628B938B920000 +C6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8B9682778D1B91C0946A97429748974497C698709A5F9B229B589C5F9DF99DFA +9E7C9E7D9F079F779F725EF36B1670637C6C7C6E883B89C08EA191C194729470 +9871995E9AD69B239ECC706477DA8B9A947797C99A629A657E9C8B9C8EAA91C5 +947D947E947C9C779C789EF78C54947F9E1A72289A6A9B319E1B9E1E7C720000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000030FE309D309E3005304130423043304430453046304730483049304A304B +304C304D304E304F3050305130523053305430553056305730583059305A305B +305C305D305E305F3060306130623063306430653066306730683069306A306B +306C306D306E306F3070307130723073307430753076307730783079307A307B +307C307D307E307F3080308130823083308430853086308730883089308A308B +308C308D308E308F309030913092309330A130A230A330A430A530A630A70000 +C7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +30A830A930AA30AB30AC30AD30AE30AF30B030B130B230B330B430B530B630B7 +30B830B930BA30BB30BC30BD30BE30BF30C030C130C230C330C430C530C630C7 +30C830C930CA30CB30CC30CD30CE30CF30D030D130D230D330D430D530D630D7 +30D830D930DA30DB30DC30DD30DE30DF30E030E130E230E330E430E530E60000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000030E730E830E930EA30EB30EC30ED30EE30EF30F030F130F230F330F430F5 +30F60414041504010416041704180419041A041B041C04230424042504260427 +04280429042A042B042C042D042E042F04300431043204330434043504510436 +043704380439043A043B043C043D043E043F0440044104420443044404450446 +044704480449044A044B044C044D044E044F2460246124622463246424652466 +246724682469247424752476247724782479247A247B247C247D000000000000 +C9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +4E424E5C51F5531A53824E074E0C4E474E8D56D7FA0C5C6E5F734E0F51874E0E +4E2E4E934EC24EC94EC8519852FC536C53B957205903592C5C105DFF65E16BB3 +6BCC6C14723F4E314E3C4EE84EDC4EE94EE14EDD4EDA520C531C534C57225723 +5917592F5B815B845C125C3B5C745C735E045E805E825FC9620962506C150000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006C366C436C3F6C3B72AE72B0738A79B8808A961E4F0E4F184F2C4EF54F14 +4EF14F004EF74F084F1D4F024F054F224F134F044EF44F1251B1521352095210 +52A65322531F534D538A540756E156DF572E572A5734593C5980597C5985597B +597E5977597F5B565C155C255C7C5C7A5C7B5C7E5DDF5E755E845F025F1A5F74 +5FD55FD45FCF625C625E626462616266626262596260625A626565EF65EE673E +67396738673B673A673F673C67336C186C466C526C5C6C4F6C4A6C546C4B0000 +CA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6C4C7071725E72B472B5738E752A767F7A757F518278827C8280827D827F864D +897E909990979098909B909496229624962096234F564F3B4F624F494F534F64 +4F3E4F674F524F5F4F414F584F2D4F334F3F4F61518F51B9521C521E522152AD +52AE530953635372538E538F54305437542A545454455419541C542554180000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000543D544F544154285424544756EE56E756E557415745574C5749574B5752 +5906594059A6599859A05997598E59A25990598F59A759A15B8E5B925C285C2A +5C8D5C8F5C885C8B5C895C925C8A5C865C935C955DE05E0A5E0E5E8B5E895E8C +5E885E8D5F055F1D5F785F765FD25FD15FD05FED5FE85FEE5FF35FE15FE45FE3 +5FFA5FEF5FF75FFB60005FF4623A6283628C628E628F629462876271627B627A +6270628162886277627D62726274653765F065F465F365F265F5674567470000 +CB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +67596755674C6748675D674D675A674B6BD06C196C1A6C786C676C6B6C846C8B +6C8F6C716C6F6C696C9A6C6D6C876C956C9C6C666C736C656C7B6C8E7074707A +726372BF72BD72C372C672C172BA72C573957397739373947392753A75397594 +75957681793D80348095809980908092809C8290828F8285828E829182930000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000828A828382848C788FC98FBF909F90A190A5909E90A790A096309628962F +962D4E334F984F7C4F854F7D4F804F874F764F744F894F844F774F4C4F974F6A +4F9A4F794F814F784F904F9C4F944F9E4F924F824F954F6B4F6E519E51BC51BE +5235523252335246523152BC530A530B533C539253945487547F548154915482 +5488546B547A547E5465546C54745466548D546F546154605498546354675464 +56F756F9576F5772576D576B57715770577657805775577B5773577457620000 +CC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5768577D590C594559B559BA59CF59CE59B259CC59C159B659BC59C359D659B1 +59BD59C059C859B459C75B625B655B935B955C445C475CAE5CA45CA05CB55CAF +5CA85CAC5C9F5CA35CAD5CA25CAA5CA75C9D5CA55CB65CB05CA65E175E145E19 +5F285F225F235F245F545F825F7E5F7D5FDE5FE5602D602660196032600B0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006034600A60176033601A601E602C6022600D6010602E60136011600C6009 +601C6214623D62AD62B462D162BE62AA62B662CA62AE62B362AF62BB62A962B0 +62B8653D65A865BB660965FC66046612660865FB6603660B660D660565FD6611 +661066F6670A6785676C678E67926776677B6798678667846774678D678C677A +679F679167996783677D67816778677967946B256B806B7E6BDE6C1D6C936CEC +6CEB6CEE6CD96CB66CD46CAD6CE76CB76CD06CC26CBA6CC36CC66CED6CF20000 +CD +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6CD26CDD6CB46C8A6C9D6C806CDE6CC06D306CCD6CC76CB06CF96CCF6CE96CD1 +709470987085709370867084709170967082709A7083726A72D672CB72D872C9 +72DC72D272D472DA72CC72D173A473A173AD73A673A273A073AC739D74DD74E8 +753F7540753E758C759876AF76F376F176F076F577F877FC77F977FB77FA0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000077F77942793F79C57A787A7B7AFB7C757CFD8035808F80AE80A380B880B5 +80AD822082A082C082AB829A8298829B82B582A782AE82BC829E82BA82B482A8 +82A182A982C282A482C382B682A28670866F866D866E8C568FD28FCB8FD38FCD +8FD68FD58FD790B290B490AF90B390B09639963D963C963A96434FCD4FC54FD3 +4FB24FC94FCB4FC14FD44FDC4FD94FBB4FB34FDB4FC74FD64FBA4FC04FB94FEC +5244524952C052C2533D537C539753965399539854BA54A154AD54A554CF0000 +CE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +54C3830D54B754AE54D654B654C554C654A0547054BC54A254BE547254DE54B0 +57B5579E579F57A4578C5797579D579B57945798578F579957A5579A579558F4 +590D595359E159DE59EE5A0059F159DD59FA59FD59FC59F659E459F259F759DB +59E959F359F559E059FE59F459ED5BA85C4C5CD05CD85CCC5CD75CCB5CDB0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005CDE5CDA5CC95CC75CCA5CD65CD35CD45CCF5CC85CC65CCE5CDF5CF85DF9 +5E215E225E235E205E245EB05EA45EA25E9B5EA35EA55F075F2E5F565F866037 +603960546072605E6045605360476049605B604C60406042605F602460446058 +6066606E6242624362CF630D630B62F5630E630362EB62F9630F630C62F862F6 +63006313631462FA631562FB62F06541654365AA65BF6636662166326635661C +662666226633662B663A661D66346639662E670F671067C167F267C867BA0000 +CF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +67DC67BB67F867D867C067B767C567EB67E467DF67B567CD67B367F767F667EE +67E367C267B967CE67E767F067B267FC67C667ED67CC67AE67E667DB67FA67C9 +67CA67C367EA67CB6B286B826B846BB66BD66BD86BE06C206C216D286D346D2D +6D1F6D3C6D3F6D126D0A6CDA6D336D046D196D3A6D1A6D116D006D1D6D420000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006D016D186D376D036D0F6D406D076D206D2C6D086D226D096D1070B7709F +70BE70B170B070A170B470B570A972417249724A726C72707273726E72CA72E4 +72E872EB72DF72EA72E672E3738573CC73C273C873C573B973B673B573B473EB +73BF73C773BE73C373C673B873CB74EC74EE752E7547754875A775AA767976C4 +7708770377047705770A76F776FB76FA77E777E878067811781278057810780F +780E780978037813794A794C794B7945794479D579CD79CF79D679CE7A800000 +D0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +7A7E7AD17B007B017C7A7C787C797C7F7C807C817D037D087D017F587F917F8D +7FBE8007800E800F8014803780D880C780E080D180C880C280D080C580E380D9 +80DC80CA80D580C980CF80D780E680CD81FF8221829482D982FE82F9830782E8 +830082D5833A82EB82D682F482EC82E182F282F5830C82FB82F682F082EA0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000082E482E082FA82F382ED86778674867C86738841884E8867886A886989D3 +8A048A078D728FE38FE18FEE8FE090F190BD90BF90D590C590BE90C790CB90C8 +91D491D39654964F96519653964A964E501E50055007501350225030501B4FF5 +4FF450335037502C4FF64FF75017501C502050275035502F5031500E515A5194 +519351CA51C451C551C851CE5261525A5252525E525F5255526252CD530E539E +552654E25517551254E754F354E4551A54FF5504550854EB5511550554F10000 +D1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +550A54FB54F754F854E0550E5503550B5701570257CC583257D557D257BA57C6 +57BD57BC57B857B657BF57C757D057B957C1590E594A5A195A165A2D5A2E5A15 +5A0F5A175A0A5A1E5A335B6C5BA75BAD5BAC5C035C565C545CEC5CFF5CEE5CF1 +5CF75D005CF95E295E285EA85EAE5EAA5EAC5F335F305F67605D605A60670000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000604160A26088608060926081609D60836095609B60976087609C608E6219 +624662F263106356632C634463456336634363E46339634B634A633C63296341 +6334635863546359632D63476333635A63516338635763406348654A654665C6 +65C365C465C2664A665F6647665167126713681F681A684968326833683B684B +684F68166831681C6835682B682D682F684E68446834681D6812681468266828 +682E684D683A682568206B2C6B2F6B2D6B316B346B6D80826B886BE66BE40000 +D2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6BE86BE36BE26BE76C256D7A6D636D646D766D0D6D616D926D586D626D6D6D6F +6D916D8D6DEF6D7F6D866D5E6D676D606D976D706D7C6D5F6D826D986D2F6D68 +6D8B6D7E6D806D846D166D836D7B6D7D6D756D9070DC70D370D170DD70CB7F39 +70E270D770D270DE70E070D470CD70C570C670C770DA70CE70E1724272780000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000072777276730072FA72F472FE72F672F372FB730173D373D973E573D673BC +73E773E373E973DC73D273DB73D473DD73DA73D773D873E874DE74DF74F474F5 +7521755B755F75B075C175BB75C475C075BF75B675BA768A76C9771D771B7710 +771377127723771177157719771A772277277823782C78227835782F7828782E +782B782178297833782A78317954795B794F795C79537952795179EB79EC79E0 +79EE79ED79EA79DC79DE79DD7A867A897A857A8B7A8C7A8A7A877AD87B100000 +D3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +7B047B137B057B0F7B087B0A7B0E7B097B127C847C917C8A7C8C7C887C8D7C85 +7D1E7D1D7D117D0E7D187D167D137D1F7D127D0F7D0C7F5C7F617F5E7F607F5D +7F5B7F967F927FC37FC27FC08016803E803980FA80F280F980F5810180FB8100 +8201822F82258333832D83448319835183258356833F83418326831C83220000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008342834E831B832A8308833C834D8316832483208337832F832983478345 +834C8353831E832C834B832783488653865286A286A88696868D8691869E8687 +86978686868B869A868586A5869986A186A786958698868E869D869086948843 +8844886D88758876887288808871887F886F8883887E8874887C8A128C478C57 +8C7B8CA48CA38D768D788DB58DB78DB68ED18ED38FFE8FF590028FFF8FFB9004 +8FFC8FF690D690E090D990DA90E390DF90E590D890DB90D790DC90E491500000 +D4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +914E914F91D591E291DA965C965F96BC98E39ADF9B2F4E7F5070506A5061505E +50605053504B505D50725048504D5041505B504A506250155045505F5069506B +5063506450465040506E50735057505151D0526B526D526C526E52D652D3532D +539C55755576553C554D55505534552A55515562553655355530555255450000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000550C55325565554E55395548552D553B5540554B570A570757FB581457E2 +57F657DC57F4580057ED57FD580857F8580B57F357CF580757EE57E357F257E5 +57EC57E1580E57FC581057E75801580C57F157E957F0580D5804595C5A605A58 +5A555A675A5E5A385A355A6D5A505A5F5A655A6C5A535A645A575A435A5D5A52 +5A445A5B5A485A8E5A3E5A4D5A395A4C5A705A695A475A515A565A425A5C5B72 +5B6E5BC15BC05C595D1E5D0B5D1D5D1A5D205D0C5D285D0D5D265D255D0F0000 +D5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5D305D125D235D1F5D2E5E3E5E345EB15EB45EB95EB25EB35F365F385F9B5F96 +5F9F608A6090608660BE60B060BA60D360D460CF60E460D960DD60C860B160DB +60B760CA60BF60C360CD60C063326365638A6382637D63BD639E63AD639D6397 +63AB638E636F63876390636E63AF6375639C636D63AE637C63A4633B639F0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006378638563816391638D6370655365CD66656661665B6659665C66626718 +687968876890689C686D686E68AE68AB6956686F68A368AC68A96875687468B2 +688F68776892687C686B687268AA68806871687E689B6896688B68A0688968A4 +6878687B6891688C688A687D6B366B336B376B386B916B8F6B8D6B8E6B8C6C2A +6DC06DAB6DB46DB36E746DAC6DE96DE26DB76DF66DD46E006DC86DE06DDF6DD6 +6DBE6DE56DDC6DDD6DDB6DF46DCA6DBD6DED6DF06DBA6DD56DC26DCF6DC90000 +D6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6DD06DF26DD36DFD6DD76DCD6DE36DBB70FA710D70F7711770F4710C70F07104 +70F3711070FC70FF71067113710070F870F6710B7102710E727E727B727C727F +731D7317730773117318730A730872FF730F731E738873F673F873F574047401 +73FD7407740073FA73FC73FF740C740B73F474087564756375CE75D275CF0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000075CB75CC75D175D0768F768976D37739772F772D7731773277347733773D +7725773B7735784878527849784D784A784C782678457850796479677969796A +7963796B796179BB79FA79F879F679F77A8F7A947A907B357B477B347B257B30 +7B227B247B337B187B2A7B1D7B317B2B7B2D7B2F7B327B387B1A7B237C947C98 +7C967CA37D357D3D7D387D367D3A7D457D2C7D297D417D477D3E7D3F7D4A7D3B +7D287F637F957F9C7F9D7F9B7FCA7FCB7FCD7FD07FD17FC77FCF7FC9801F0000 +D7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +801E801B804780438048811881258119811B812D811F812C811E812181158127 +811D8122821182388233823A823482328274839083A383A8838D837A837383A4 +8374838F8381839583998375839483A9837D8383838C839D839B83AA838B837E +83A583AF8388839783B0837F83A6838783AE8376839A8659865686BF86B70000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000086C286C186C586BA86B086C886B986B386B886CC86B486BB86BC86C386BD +86BE88528889889588A888A288AA889A889188A1889F889888A78899889B8897 +88A488AC888C8893888E898289D689D989D58A308A278A2C8A1E8C398C3B8C5C +8C5D8C7D8CA58D7D8D7B8D798DBC8DC28DB98DBF8DC18ED88EDE8EDD8EDC8ED7 +8EE08EE19024900B9011901C900C902190EF90EA90F090F490F290F390D490EB +90EC90E991569158915A9153915591EC91F491F191F391F891E491F991EA0000 +D8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +91EB91F791E891EE957A95869588967C966D966B9671966F96BF976A980498E5 +9997509B50955094509E508B50A35083508C508E509D5068509C509250825087 +515F51D45312531153A453A7559155A855A555AD5577564555A255935588558F +55B5558155A3559255A4557D558C55A6557F559555A1558E570C582958370000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005819581E58275823582857F558485825581C581B5833583F5836582E5839 +5838582D582C583B59615AAF5A945A9F5A7A5AA25A9E5A785AA65A7C5AA55AAC +5A955AAE5A375A845A8A5A975A835A8B5AA95A7B5A7D5A8C5A9C5A8F5A935A9D +5BEA5BCD5BCB5BD45BD15BCA5BCE5C0C5C305D375D435D6B5D415D4B5D3F5D35 +5D515D4E5D555D335D3A5D525D3D5D315D595D425D395D495D385D3C5D325D36 +5D405D455E445E415F585FA65FA55FAB60C960B960CC60E260CE60C461140000 +D9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +60F2610A6116610560F5611360F860FC60FE60C161036118611D611060FF6104 +610B624A639463B163B063CE63E563E863EF63C3649D63F363CA63E063F663D5 +63F263F5646163DF63BE63DD63DC63C463D863D363C263C763CC63CB63C863F0 +63D763D965326567656A6564655C65686565658C659D659E65AE65D065D20000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000667C666C667B668066716679666A66726701690C68D3690468DC692A68EC +68EA68F1690F68D668F768EB68E468F66913691068F368E1690768CC69086970 +68B4691168EF68C6691468F868D068FD68FC68E8690B690A691768CE68C868DD +68DE68E668F468D1690668D468E96915692568C76B396B3B6B3F6B3C6B946B97 +6B996B956BBD6BF06BF26BF36C306DFC6E466E476E1F6E496E886E3C6E3D6E45 +6E626E2B6E3F6E416E5D6E736E1C6E336E4B6E406E516E3B6E036E2E6E5E0000 +DA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6E686E5C6E616E316E286E606E716E6B6E396E226E306E536E656E276E786E64 +6E776E556E796E526E666E356E366E5A7120711E712F70FB712E713171237125 +71227132711F7128713A711B724B725A7288728972867285728B7312730B7330 +73227331733373277332732D732673237335730C742E742C7430742B74160000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000741A7421742D743174247423741D74297420743274FB752F756F756C75E7 +75DA75E175E675DD75DF75E475D77695769276DA774677477744774D7745774A +774E774B774C77DE77EC786078647865785C786D7871786A786E787078697868 +785E786279747973797279707A027A0A7A037A0C7A047A997AE67AE47B4A7B3B +7B447B487B4C7B4E7B407B587B457CA27C9E7CA87CA17D587D6F7D637D537D56 +7D677D6A7D4F7D6D7D5C7D6B7D527D547D697D517D5F7D4E7F3E7F3F7F650000 +DB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +7F667FA27FA07FA17FD78051804F805080FE80D48143814A8152814F8147813D +814D813A81E681EE81F781F881F98204823C823D823F8275833B83CF83F98423 +83C083E8841283E783E483FC83F6841083C683C883EB83E383BF840183DD83E5 +83D883FF83E183CB83CE83D683F583C98409840F83DE8411840683C283F30000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000083D583FA83C783D183EA841383C383EC83EE83C483FB83D783E2841B83DB +83FE86D886E286E686D386E386DA86EA86DD86EB86DC86EC86E986D786E886D1 +88488856885588BA88D788B988B888C088BE88B688BC88B788BD88B2890188C9 +89958998899789DD89DA89DB8A4E8A4D8A398A598A408A578A588A448A458A52 +8A488A518A4A8A4C8A4F8C5F8C818C808CBA8CBE8CB08CB98CB58D848D808D89 +8DD88DD38DCD8DC78DD68DDC8DCF8DD58DD98DC88DD78DC58EEF8EF78EFA0000 +DC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8EF98EE68EEE8EE58EF58EE78EE88EF68EEB8EF18EEC8EF48EE9902D9034902F +9106912C910490FF90FC910890F990FB9101910091079105910391619164915F +916291609201920A92259203921A9226920F920C9200921291FF91FD92069204 +92279202921C92249219921792059216957B958D958C95909687967E96880000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000096899683968096C296C896C396F196F0976C9770976E980798A998EB9CE6 +9EF94E834E844EB650BD50BF50C650AE50C450CA50B450C850C250B050C150BA +50B150CB50C950B650B851D7527A5278527B527C55C355DB55CC55D055CB55CA +55DD55C055D455C455E955BF55D2558D55CF55D555E255D655C855F255CD55D9 +55C25714585358685864584F584D5849586F5855584E585D58595865585B583D +5863587158FC5AC75AC45ACB5ABA5AB85AB15AB55AB05ABF5AC85ABB5AC60000 +DD +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5AB75AC05ACA5AB45AB65ACD5AB95A905BD65BD85BD95C1F5C335D715D635D4A +5D655D725D6C5D5E5D685D675D625DF05E4F5E4E5E4A5E4D5E4B5EC55ECC5EC6 +5ECB5EC75F405FAF5FAD60F76149614A612B614561366132612E6146612F614F +612961406220916862236225622463C563F163EB641064126409642064240000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000064336443641F641564186439643764226423640C64266430642864416435 +642F640A641A644064256427640B63E7641B642E6421640E656F659265D36686 +668C66956690668B668A66996694667867206966695F6938694E69626971693F +6945696A6939694269576959697A694869496935696C6933693D696568F06978 +693469696940696F69446976695869416974694C693B694B6937695C694F6951 +69326952692F697B693C6B466B456B436B426B486B416B9BFA0D6BFB6BFC0000 +DE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6BF96BF76BF86E9B6ED66EC86E8F6EC06E9F6E936E946EA06EB16EB96EC66ED2 +6EBD6EC16E9E6EC96EB76EB06ECD6EA66ECF6EB26EBE6EC36EDC6ED86E996E92 +6E8E6E8D6EA46EA16EBF6EB36ED06ECA6E976EAE6EA371477154715271637160 +7141715D716271727178716A7161714271587143714B7170715F715071530000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007144714D715A724F728D728C72917290728E733C7342733B733A7340734A +73497444744A744B7452745174577440744F7450744E74427446744D745474E1 +74FF74FE74FD751D75797577698375EF760F760375F775FE75FC75F975F87610 +75FB75F675ED75F575FD769976B576DD7755775F776077527756775A77697767 +77547759776D77E07887789A7894788F788478957885788678A1788378797899 +78807896787B797C7982797D79797A117A187A197A127A177A157A227A130000 +DF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +7A1B7A107AA37AA27A9E7AEB7B667B647B6D7B747B697B727B657B737B717B70 +7B617B787B767B637CB27CB47CAF7D887D867D807D8D7D7F7D857D7A7D8E7D7B +7D837D7C7D8C7D947D847D7D7D927F6D7F6B7F677F687F6C7FA67FA57FA77FDB +7FDC8021816481608177815C8169815B816281726721815E81768167816F0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000081448161821D8249824482408242824584F1843F845684768479848F848D +846584518440848684678430844D847D845A845984748473845D8507845E8437 +843A8434847A8443847884328445842983D9844B842F8442842D845F84708439 +844E844C8452846F84C5848E843B8447843684338468847E8444842B84608454 +846E8450870B870486F7870C86FA86D686F5874D86F8870E8709870186F6870D +870588D688CB88CD88CE88DE88DB88DA88CC88D08985899B89DF89E589E40000 +E0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +89E189E089E289DC89E68A768A868A7F8A618A3F8A778A828A848A758A838A81 +8A748A7A8C3C8C4B8C4A8C658C648C668C868C848C858CCC8D688D698D918D8C +8D8E8D8F8D8D8D938D948D908D928DF08DE08DEC8DF18DEE8DD08DE98DE38DE2 +8DE78DF28DEB8DF48F068EFF8F018F008F058F078F088F028F0B9052903F0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000090449049903D9110910D910F911191169114910B910E916E916F92489252 +9230923A926692339265925E9283922E924A9246926D926C924F92609267926F +92369261927092319254926392509272924E9253924C92569232959F959C959E +959B969296939691969796CE96FA96FD96F896F59773977797789772980F980D +980E98AC98F698F999AF99B299B099B59AAD9AAB9B5B9CEA9CED9CE79E809EFD +50E650D450D750E850F350DB50EA50DD50E450D350EC50F050EF50E350E00000 +E1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +51D85280528152E952EB533053AC56275615560C561255FC560F561C56015613 +560255FA561D560455FF55F95889587C5890589858865881587F5874588B587A +58875891588E587658825888587B5894588F58FE596B5ADC5AEE5AE55AD55AEA +5ADA5AED5AEB5AF35AE25AE05ADB5AEC5ADE5ADD5AD95AE85ADF5B775BE00000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005BE35C635D825D805D7D5D865D7A5D815D775D8A5D895D885D7E5D7C5D8D +5D795D7F5E585E595E535ED85ED15ED75ECE5EDC5ED55ED95ED25ED45F445F43 +5F6F5FB6612C61286141615E61716173615261536172616C618061746154617A +615B6165613B616A6161615662296227622B642B644D645B645D647464766472 +6473647D6475646664A6644E6482645E645C644B645364606450647F643F646C +646B645964656477657365A066A166A0669F67056704672269B169B669C90000 +E2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +69A069CE699669B069AC69BC69916999698E69A7698D69A969BE69AF69BF69C4 +69BD69A469D469B969CA699A69CF69B3699369AA69A1699E69D96997699069C2 +69B569A569C66B4A6B4D6B4B6B9E6B9F6BA06BC36BC46BFE6ECE6EF56EF16F03 +6F256EF86F376EFB6F2E6F096F4E6F196F1A6F276F186F3B6F126EED6F0A0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006F366F736EF96EEE6F2D6F406F306F3C6F356EEB6F076F0E6F436F056EFD +6EF66F396F1C6EFC6F3A6F1F6F0D6F1E6F086F21718771907189718071857182 +718F717B718671817197724472537297729572937343734D7351734C74627473 +7471747574727467746E750075027503757D759076167608760C76157611760A +761476B87781777C77857782776E7780776F777E778378B278AA78B478AD78A8 +787E78AB789E78A578A078AC78A278A47998798A798B79967995799479930000 +E3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +79977988799279907A2B7A4A7A307A2F7A287A267AA87AAB7AAC7AEE7B887B9C +7B8A7B917B907B967B8D7B8C7B9B7B8E7B857B9852847B997BA47B827CBB7CBF +7CBC7CBA7DA77DB77DC27DA37DAA7DC17DC07DC57D9D7DCE7DC47DC67DCB7DCC +7DAF7DB97D967DBC7D9F7DA67DAE7DA97DA17DC97F737FE27FE37FE57FDE0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008024805D805C8189818681838187818D818C818B8215849784A484A1849F +84BA84CE84C284AC84AE84AB84B984B484C184CD84AA849A84B184D0849D84A7 +84BB84A2849484C784CC849B84A984AF84A884D6849884B684CF84A084D784D4 +84D284DB84B084918661873387238728876B8740872E871E87218719871B8743 +872C8741873E874687208732872A872D873C8712873A87318735874287268727 +87388724871A8730871188F788E788F188F288FA88FE88EE88FC88F688FB0000 +E4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +88F088EC88EB899D89A1899F899E89E989EB89E88AAB8A998A8B8A928A8F8A96 +8C3D8C688C698CD58CCF8CD78D968E098E028DFF8E0D8DFD8E0A8E038E078E06 +8E058DFE8E008E048F108F118F0E8F0D9123911C91209122911F911D911A9124 +9121911B917A91729179917392A592A49276929B927A92A0929492AA928D0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000092A6929A92AB92799297927F92A392EE928E9282929592A2927D928892A1 +928A9286928C929992A7927E928792A9929D928B922D969E96A196FF9758977D +977A977E978397809782977B97849781977F97CE97CD981698AD98AE99029900 +9907999D999C99C399B999BB99BA99C299BD99C79AB19AE39AE79B3E9B3F9B60 +9B619B5F9CF19CF29CF59EA750FF5103513050F85106510750F650FE510B510C +50FD510A528B528C52F152EF56485642564C56355641564A5649564656580000 +E5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +565A56405633563D562C563E5638562A563A571A58AB589D58B158A058A358AF +58AC58A558A158FF5AFF5AF45AFD5AF75AF65B035AF85B025AF95B015B075B05 +5B0F5C675D995D975D9F5D925DA25D935D955DA05D9C5DA15D9A5D9E5E695E5D +5E605E5C7DF35EDB5EDE5EE15F495FB2618B6183617961B161B061A261890000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000619B619361AF61AD619F619261AA61A1618D616661B3622D646E64706496 +64A064856497649C648F648B648A648C64A3649F646864B164986576657A6579 +657B65B265B366B566B066A966B266B766AA66AF6A006A066A1769E569F86A15 +69F169E46A2069FF69EC69E26A1B6A1D69FE6A2769F269EE6A1469F769E76A40 +6A0869E669FB6A0D69FC69EB6A096A046A186A256A0F69F66A266A0769F46A16 +6B516BA56BA36BA26BA66C016C006BFF6C026F416F266F7E6F876FC66F920000 +E6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6F8D6F896F8C6F626F4F6F856F5A6F966F766F6C6F826F556F726F526F506F57 +6F946F936F5D6F006F616F6B6F7D6F676F906F536F8B6F696F7F6F956F636F77 +6F6A6F7B71B271AF719B71B071A0719A71A971B5719D71A5719E71A471A171AA +719C71A771B37298729A73587352735E735F7360735D735B7361735A73590000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000736274877489748A74867481747D74857488747C747975087507757E7625 +761E7619761D761C7623761A7628761B769C769D769E769B778D778F77897788 +78CD78BB78CF78CC78D178CE78D478C878C378C478C9799A79A179A0799C79A2 +799B6B767A397AB27AB47AB37BB77BCB7BBE7BAC7BCE7BAF7BB97BCA7BB57CC5 +7CC87CCC7CCB7DF77DDB7DEA7DE77DD77DE17E037DFA7DE67DF67DF17DF07DEE +7DDF7F767FAC7FB07FAD7FED7FEB7FEA7FEC7FE67FE88064806781A3819F0000 +E7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +819E819581A2819981978216824F825382528250824E82518524853B850F8500 +8529850E8509850D851F850A8527851C84FB852B84FA8508850C84F4852A84F2 +851584F784EB84F384FC851284EA84E9851684FE8528851D852E850284FD851E +84F68531852684E784E884F084EF84F9851885208530850B8519852F86620000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000875687638764877787E1877387588754875B87528761875A8751875E876D +876A8750874E875F875D876F876C877A876E875C8765874F877B877587628767 +8769885A8905890C8914890B891789188919890689168911890E890989A289A4 +89A389ED89F089EC8ACF8AC68AB88AD38AD18AD48AD58ABB8AD78ABE8AC08AC5 +8AD88AC38ABA8ABD8AD98C3E8C4D8C8F8CE58CDF8CD98CE88CDA8CDD8CE78DA0 +8D9C8DA18D9B8E208E238E258E248E2E8E158E1B8E168E118E198E268E270000 +E8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8E148E128E188E138E1C8E178E1A8F2C8F248F188F1A8F208F238F168F179073 +9070906F9067906B912F912B9129912A91329126912E91859186918A91819182 +9184918092D092C392C492C092D992B692CF92F192DF92D892E992D792DD92CC +92EF92C292E892CA92C892CE92E692CD92D592C992E092DE92E792D192D30000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000092B592E192C692B4957C95AC95AB95AE95B096A496A296D3970597089702 +975A978A978E978897D097CF981E981D9826982998289820981B982798B29908 +98FA9911991499169917991599DC99CD99CF99D399D499CE99C999D699D899CB +99D799CC9AB39AEC9AEB9AF39AF29AF19B469B439B679B749B719B669B769B75 +9B709B689B649B6C9CFC9CFA9CFD9CFF9CF79D079D009CF99CFB9D089D059D04 +9E839ED39F0F9F10511C51135117511A511151DE533453E156705660566E0000 +E9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +567356665663566D5672565E5677571C571B58C858BD58C958BF58BA58C258BC +58C65B175B195B1B5B215B145B135B105B165B285B1A5B205B1E5BEF5DAC5DB1 +5DA95DA75DB55DB05DAE5DAA5DA85DB25DAD5DAF5DB45E675E685E665E6F5EE9 +5EE75EE65EE85EE55F4B5FBC619D61A8619661C561B461C661C161CC61BA0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000061BF61B8618C64D764D664D064CF64C964BD648964C364DB64F364D96533 +657F657C65A266C866BE66C066CA66CB66CF66BD66BB66BA66CC67236A346A66 +6A496A676A326A686A3E6A5D6A6D6A766A5B6A516A286A5A6A3B6A3F6A416A6A +6A646A506A4F6A546A6F6A696A606A3C6A5E6A566A556A4D6A4E6A466B556B54 +6B566BA76BAA6BAB6BC86BC76C046C036C066FAD6FCB6FA36FC76FBC6FCE6FC8 +6F5E6FC46FBD6F9E6FCA6FA870046FA56FAE6FBA6FAC6FAA6FCF6FBF6FB80000 +EA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6FA26FC96FAB6FCD6FAF6FB26FB071C571C271BF71B871D671C071C171CB71D4 +71CA71C771CF71BD71D871BC71C671DA71DB729D729E736973667367736C7365 +736B736A747F749A74A074947492749574A1750B7580762F762D7631763D7633 +763C76357632763076BB76E6779A779D77A1779C779B77A277A3779577990000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000779778DD78E978E578EA78DE78E378DB78E178E278ED78DF78E079A47A44 +7A487A477AB67AB87AB57AB17AB77BDE7BE37BE77BDD7BD57BE57BDA7BE87BF9 +7BD47BEA7BE27BDC7BEB7BD87BDF7CD27CD47CD77CD07CD17E127E217E177E0C +7E1F7E207E137E0E7E1C7E157E1A7E227E0B7E0F7E167E0D7E147E257E247F43 +7F7B7F7C7F7A7FB17FEF802A8029806C81B181A681AE81B981B581AB81B081AC +81B481B281B781A781F282558256825785568545856B854D8553856185580000 +EB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +854085468564854185628544855185478563853E855B8571854E856E85758555 +85678560858C8566855D85548565856C866386658664879B878F879787938792 +87888781879687988779878787A3878587908791879D87848794879C879A8789 +891E89268930892D892E89278931892289298923892F892C891F89F18AE00000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008AE28AF28AF48AF58ADD8B148AE48ADF8AF08AC88ADE8AE18AE88AFF8AEF +8AFB8C918C928C908CF58CEE8CF18CF08CF38D6C8D6E8DA58DA78E338E3E8E38 +8E408E458E368E3C8E3D8E418E308E3F8EBD8F368F2E8F358F328F398F378F34 +90769079907B908690FA913391359136919391909191918D918F9327931E9308 +931F9306930F937A9338933C931B9323931293019346932D930E930D92CB931D +92FA9325931392F992F793349302932492FF932993399335932A9314930C0000 +EC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +930B92FE9309930092FB931695BC95CD95BE95B995BA95B695BF95B595BD96A9 +96D4970B9712971097999797979497F097F89835982F98329924991F99279929 +999E99EE99EC99E599E499F099E399EA99E999E79AB99ABF9AB49ABB9AF69AFA +9AF99AF79B339B809B859B879B7C9B7E9B7B9B829B939B929B909B7A9B950000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009B7D9B889D259D179D209D1E9D149D299D1D9D189D229D109D199D1F9E88 +9E869E879EAE9EAD9ED59ED69EFA9F129F3D51265125512251245120512952F4 +5693568C568D568656845683567E5682567F568158D658D458CF58D25B2D5B25 +5B325B235B2C5B275B265B2F5B2E5B7B5BF15BF25DB75E6C5E6A5FBE5FBB61C3 +61B561BC61E761E061E561E461E861DE64EF64E964E364EB64E464E865816580 +65B665DA66D26A8D6A966A816AA56A896A9F6A9B6AA16A9E6A876A936A8E0000 +ED +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6A956A836AA86AA46A916A7F6AA66A9A6A856A8C6A926B5B6BAD6C096FCC6FA9 +6FF46FD46FE36FDC6FED6FE76FE66FDE6FF26FDD6FE26FE871E171F171E871F2 +71E471F071E27373736E736F749774B274AB749074AA74AD74B174A574AF7510 +75117512750F7584764376487649764776A476E977B577AB77B277B777B60000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000077B477B177A877F078F378FD790278FB78FC78F2790578F978FE790479AB +79A87A5C7A5B7A567A587A547A5A7ABE7AC07AC17C057C0F7BF27C007BFF7BFB +7C0E7BF47C0B7BF37C027C097C037C017BF87BFD7C067BF07BF17C107C0A7CE8 +7E2D7E3C7E427E3398487E387E2A7E497E407E477E297E4C7E307E3B7E367E44 +7E3A7F457F7F7F7E7F7D7FF47FF2802C81BB81C481CC81CA81C581C781BC81E9 +825B825A825C85838580858F85A7859585A0858B85A3857B85A4859A859E0000 +EE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8577857C858985A1857A85788557858E85968586858D8599859D858185A28582 +858885858579857685988590859F866887BE87AA87AD87C587B087AC87B987B5 +87BC87AE87C987C387C287CC87B787AF87C487CA87B487B687BF87B887BD87DE +87B289358933893C893E894189528937894289AD89AF89AE89F289F38B1E0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008B188B168B118B058B0B8B228B0F8B128B158B078B0D8B088B068B1C8B13 +8B1A8C4F8C708C728C718C6F8C958C948CF98D6F8E4E8E4D8E538E508E4C8E47 +8F438F409085907E9138919A91A2919B9199919F91A1919D91A093A1938393AF +936493569347937C9358935C93769349935093519360936D938F934C936A9379 +935793559352934F93719377937B9361935E936393679380934E935995C795C0 +95C995C395C595B796AE96B096AC9720971F9718971D9719979A97A1979C0000 +EF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +979E979D97D597D497F198419844984A9849984598439925992B992C992A9933 +9932992F992D99319930999899A399A19A0299FA99F499F799F999F899F699FB +99FD99FE99FC9A039ABE9AFE9AFD9B019AFC9B489B9A9BA89B9E9B9B9BA69BA1 +9BA59BA49B869BA29BA09BAF9D339D419D679D369D2E9D2F9D319D389D300000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009D459D429D439D3E9D379D409D3D7FF59D2D9E8A9E899E8D9EB09EC89EDA +9EFB9EFF9F249F239F229F549FA05131512D512E5698569C5697569A569D5699 +59705B3C5C695C6A5DC05E6D5E6E61D861DF61ED61EE61F161EA61F061EB61D6 +61E964FF650464FD64F86501650364FC659465DB66DA66DB66D86AC56AB96ABD +6AE16AC66ABA6AB66AB76AC76AB46AAD6B5E6BC96C0B7007700C700D70017005 +7014700E6FFF70006FFB70266FFC6FF7700A720171FF71F9720371FD73760000 +F0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +74B874C074B574C174BE74B674BB74C275147513765C76647659765076537657 +765A76A676BD76EC77C277BA78FF790C79137914790979107912791179AD79AC +7A5F7C1C7C297C197C207C1F7C2D7C1D7C267C287C227C257C307E5C7E507E56 +7E637E587E627E5F7E517E607E577E537FB57FB37FF77FF8807581D181D20000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000081D0825F825E85B485C685C085C385C285B385B585BD85C785C485BF85CB +85CE85C885C585B185B685D2862485B885B785BE866987E787E687E287DB87EB +87EA87E587DF87F387E487D487DC87D387ED87D887E387A487D787D9880187F4 +87E887DD8953894B894F894C89468950895189498B2A8B278B238B338B308B35 +8B478B2F8B3C8B3E8B318B258B378B268B368B2E8B248B3B8B3D8B3A8C428C75 +8C998C988C978CFE8D048D028D008E5C8E628E608E578E568E5E8E658E670000 +F1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8E5B8E5A8E618E5D8E698E548F468F478F488F4B9128913A913B913E91A891A5 +91A791AF91AA93B5938C939293B7939B939D938993A7938E93AA939E93A69395 +93889399939F938D93B1939193B293A493A893B493A393A595D295D395D196B3 +96D796DA5DC296DF96D896DD97239722972597AC97AE97A897AB97A497AA0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000097A297A597D797D997D697D897FA98509851985298B89941993C993A9A0F +9A0B9A099A0D9A049A119A0A9A059A079A069AC09ADC9B089B049B059B299B35 +9B4A9B4C9B4B9BC79BC69BC39BBF9BC19BB59BB89BD39BB69BC49BB99BBD9D5C +9D539D4F9D4A9D5B9D4B9D599D569D4C9D579D529D549D5F9D589D5A9E8E9E8C +9EDF9F019F009F169F259F2B9F2A9F299F289F4C9F5551345135529652F753B4 +56AB56AD56A656A756AA56AC58DA58DD58DB59125B3D5B3E5B3F5DC35E700000 +F2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5FBF61FB65076510650D6509650C650E658465DE65DD66DE6AE76AE06ACC6AD1 +6AD96ACB6ADF6ADC6AD06AEB6ACF6ACD6ADE6B606BB06C0C7019702770207016 +702B702170227023702970177024701C702A720C720A72077202720572A572A6 +72A472A372A174CB74C574B774C37516766077C977CA77C477F1791D791B0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007921791C7917791E79B07A677A687C337C3C7C397C2C7C3B7CEC7CEA7E76 +7E757E787E707E777E6F7E7A7E727E747E687F4B7F4A7F837F867FB77FFD7FFE +807881D781D582648261826385EB85F185ED85D985E185E885DA85D785EC85F2 +85F885D885DF85E385DC85D185F085E685EF85DE85E2880087FA880387F687F7 +8809880C880B880687FC880887FF880A88028962895A895B89578961895C8958 +895D8959898889B789B689F68B508B488B4A8B408B538B568B548B4B8B550000 +F3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8B518B428B528B578C438C778C768C9A8D068D078D098DAC8DAA8DAD8DAB8E6D +8E788E738E6A8E6F8E7B8EC28F528F518F4F8F508F538FB49140913F91B091AD +93DE93C793CF93C293DA93D093F993EC93CC93D993A993E693CA93D493EE93E3 +93D593C493CE93C093D293E7957D95DA95DB96E19729972B972C972897260000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000097B397B797B697DD97DE97DF985C9859985D985798BF98BD98BB98BE9948 +9947994399A699A79A1A9A159A259A1D9A249A1B9A229A209A279A239A1E9A1C +9A149AC29B0B9B0A9B0E9B0C9B379BEA9BEB9BE09BDE9BE49BE69BE29BF09BD4 +9BD79BEC9BDC9BD99BE59BD59BE19BDA9D779D819D8A9D849D889D719D809D78 +9D869D8B9D8C9D7D9D6B9D749D759D709D699D859D739D7B9D829D6F9D799D7F +9D879D689E949E919EC09EFC9F2D9F409F419F4D9F569F579F58533756B20000 +F4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +56B556B358E35B455DC65DC75EEE5EEF5FC05FC161F9651765166515651365DF +66E866E366E46AF36AF06AEA6AE86AF96AF16AEE6AEF703C7035702F70377034 +703170427038703F703A70397040703B703370417213721472A8737D737C74BA +76AB76AA76BE76ED77CC77CE77CF77CD77F27925792379277928792479290000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000079B27A6E7A6C7A6D7AF77C497C487C4A7C477C457CEE7E7B7E7E7E817E80 +7FBA7FFF807981DB81D9820B82688269862285FF860185FE861B860085F68604 +86098605860C85FD8819881088118817881388168963896689B989F78B608B6A +8B5D8B688B638B658B678B6D8DAE8E868E888E848F598F568F578F558F588F5A +908D9143914191B791B591B291B3940B941393FB9420940F941493FE94159410 +94289419940D93F5940093F79407940E9416941293FA940993F8940A93FF0000 +F5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +93FC940C93F69411940695DE95E095DF972E972F97B997BB97FD97FE98609862 +9863985F98C198C29950994E9959994C994B99539A329A349A319A2C9A2A9A36 +9A299A2E9A389A2D9AC79ACA9AC69B109B129B119C0B9C089BF79C059C129BF8 +9C409C079C0E9C069C179C149C099D9F9D999DA49D9D9D929D989D909D9B0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009DA09D949D9C9DAA9D979DA19D9A9DA29DA89D9E9DA39DBF9DA99D969DA6 +9DA79E999E9B9E9A9EE59EE49EE79EE69F309F2E9F5B9F609F5E9F5D9F599F91 +513A51395298529756C356BD56BE5B485B475DCB5DCF5EF161FD651B6B026AFC +6B036AF86B0070437044704A7048704970457046721D721A7219737E7517766A +77D0792D7931792F7C547C537CF27E8A7E877E887E8B7E867E8D7F4D7FBB8030 +81DD8618862A8626861F8623861C86198627862E862186208629861E86250000 +F6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8829881D881B88208824881C882B884A896D8969896E896B89FA8B798B788B45 +8B7A8B7B8D108D148DAF8E8E8E8C8F5E8F5B8F5D91469144914591B9943F943B +94369429943D943C94309439942A9437942C9440943195E595E495E39735973A +97BF97E1986498C998C698C0995899569A399A3D9A469A449A429A419A3A0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009A3F9ACD9B159B179B189B169B3A9B529C2B9C1D9C1C9C2C9C239C289C29 +9C249C219DB79DB69DBC9DC19DC79DCA9DCF9DBE9DC59DC39DBB9DB59DCE9DB9 +9DBA9DAC9DC89DB19DAD9DCC9DB39DCD9DB29E7A9E9C9EEB9EEE9EED9F1B9F18 +9F1A9F319F4E9F659F649F924EB956C656C556CB59715B4B5B4C5DD55DD15EF2 +65216520652665226B0B6B086B096C0D7055705670577052721E721F72A9737F +74D874D574D974D7766D76AD793579B47A707A717C577C5C7C597C5B7C5A0000 +F7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +7CF47CF17E917F4F7F8781DE826B863486358633862C86328636882C88288826 +882A8825897189BF89BE89FB8B7E8B848B828B868B858B7F8D158E958E948E9A +8E928E908E968E978F608F629147944C9450944A944B944F9447944594489449 +9446973F97E3986A986998CB9954995B9A4E9A539A549A4C9A4F9A489A4A0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009A499A529A509AD09B199B2B9B3B9B569B559C469C489C3F9C449C399C33 +9C419C3C9C379C349C329C3D9C369DDB9DD29DDE9DDA9DCB9DD09DDC9DD19DDF +9DE99DD99DD89DD69DF59DD59DDD9EB69EF09F359F339F329F429F6B9F959FA2 +513D529958E858E759725B4D5DD8882F5F4F62016203620465296525659666EB +6B116B126B0F6BCA705B705A7222738273817383767077D47C677C667E95826C +863A86408639863C8631863B863E88308832882E883389768974897389FE0000 +F8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8B8C8B8E8B8B8B888C458D198E988F648F6391BC94629455945D9457945E97C4 +97C598009A569A599B1E9B1F9B209C529C589C509C4A9C4D9C4B9C559C599C4C +9C4E9DFB9DF79DEF9DE39DEB9DF89DE49DF69DE19DEE9DE69DF29DF09DE29DEC +9DF49DF39DE89DED9EC29ED09EF29EF39F069F1C9F389F379F369F439F4F0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009F719F709F6E9F6F56D356CD5B4E5C6D652D66ED66EE6B13705F7061705D +7060722374DB74E577D5793879B779B67C6A7E977F89826D8643883888378835 +884B8B948B958E9E8E9F8EA08E9D91BE91BD91C2946B9468946996E597469743 +974797C797E59A5E9AD59B599C639C679C669C629C5E9C609E029DFE9E079E03 +9E069E059E009E019E099DFF9DFD9E049EA09F1E9F469F749F759F7656D4652E +65B86B186B196B176B1A7062722672AA77D877D979397C697C6B7CF67E9A0000 +F9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +7E987E9B7E9981E081E18646864786488979897A897C897B89FF8B988B998EA5 +8EA48EA3946E946D946F9471947397499872995F9C689C6E9C6D9E0B9E0D9E10 +9E0F9E129E119EA19EF59F099F479F789F7B9F7A9F79571E70667C6F883C8DB2 +8EA691C394749478947694759A609C749C739C719C759E149E139EF69F0A0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009FA4706870657CF7866A883E883D883F8B9E8C9C8EA98EC9974B98739874 +98CC996199AB9A649A669A679B249E159E179F4862076B1E7227864C8EA89482 +948094819A699A689B2E9E197229864B8B9F94839C799EB776759A6B9C7A9E1D +7069706A9EA49F7E9F499F980000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cns11643.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cns11643.enc new file mode 100644 index 0000000000000000000000000000000000000000..44dd9b7a09f5f421a387247770250de20791b922 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cns11643.enc @@ -0,0 +1,1584 @@ +# Encoding file: cns11643, double-byte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diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1250.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1250.enc new file mode 100644 index 0000000000000000000000000000000000000000..070ad901bd6aee7640caa7152a79bcc77444693c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1250.enc @@ -0,0 +1,20 @@ +# Encoding file: cp1250, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +20AC0081201A0083201E2026202020210088203001602039015A0164017D0179 +009020182019201C201D202220132014009821220161203A015B0165017E017A +00A002C702D8014100A4010400A600A700A800A9015E00AB00AC00AD00AE017B +00B000B102DB014200B400B500B600B700B80105015F00BB013D02DD013E017C +015400C100C2010200C40139010600C7010C00C9011800CB011A00CD00CE010E +01100143014700D300D4015000D600D70158016E00DA017000DC00DD016200DF +015500E100E2010300E4013A010700E7010D00E9011900EB011B00ED00EE010F +01110144014800F300F4015100F600F70159016F00FA017100FC00FD016302D9 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1251.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1251.enc new file mode 100644 index 0000000000000000000000000000000000000000..376b1b40d89a829d9d5708d8d1fd02de10d044f2 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1251.enc @@ -0,0 +1,20 @@ +# Encoding file: cp1251, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +04020403201A0453201E20262020202120AC203004092039040A040C040B040F +045220182019201C201D202220132014009821220459203A045A045C045B045F +00A0040E045E040800A4049000A600A7040100A9040400AB00AC00AD00AE0407 +00B000B104060456049100B500B600B704512116045400BB0458040504550457 +0410041104120413041404150416041704180419041A041B041C041D041E041F +0420042104220423042404250426042704280429042A042B042C042D042E042F +0430043104320433043404350436043704380439043A043B043C043D043E043F +0440044104420443044404450446044704480449044A044B044C044D044E044F diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1252.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1252.enc new file mode 100644 index 0000000000000000000000000000000000000000..dd525ea4c58e6abd0f75552907e051b51bd49145 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1252.enc @@ -0,0 +1,20 @@ +# Encoding file: cp1252, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +20AC0081201A0192201E20262020202102C62030016020390152008D017D008F +009020182019201C201D20222013201402DC21220161203A0153009D017E0178 +00A000A100A200A300A400A500A600A700A800A900AA00AB00AC00AD00AE00AF +00B000B100B200B300B400B500B600B700B800B900BA00BB00BC00BD00BE00BF +00C000C100C200C300C400C500C600C700C800C900CA00CB00CC00CD00CE00CF +00D000D100D200D300D400D500D600D700D800D900DA00DB00DC00DD00DE00DF +00E000E100E200E300E400E500E600E700E800E900EA00EB00EC00ED00EE00EF +00F000F100F200F300F400F500F600F700F800F900FA00FB00FC00FD00FE00FF diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1253.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1253.enc new file mode 100644 index 0000000000000000000000000000000000000000..a8754c37a2efa35494b9e2209eb2731eccbdb6ef --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1253.enc @@ -0,0 +1,20 @@ +# Encoding file: cp1253, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +20AC0081201A0192201E20262020202100882030008A2039008C008D008E008F +009020182019201C201D20222013201400982122009A203A009C009D009E009F +00A00385038600A300A400A500A600A700A800A9000000AB00AC00AD00AE2015 +00B000B100B200B3038400B500B600B703880389038A00BB038C00BD038E038F +0390039103920393039403950396039703980399039A039B039C039D039E039F +03A003A1000003A303A403A503A603A703A803A903AA03AB03AC03AD03AE03AF +03B003B103B203B303B403B503B603B703B803B903BA03BB03BC03BD03BE03BF +03C003C103C203C303C403C503C603C703C803C903CA03CB03CC03CD03CE0000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1254.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1254.enc new file mode 100644 index 0000000000000000000000000000000000000000..b9e3b3c518d160faaec10b98249bd13f4bb87c69 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1254.enc @@ -0,0 +1,20 @@ +# Encoding file: cp1254, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +20AC0081201A0192201E20262020202102C62030016020390152008D008E008F +009020182019201C201D20222013201402DC21220161203A0153009D009E0178 +00A000A100A200A300A400A500A600A700A800A900AA00AB00AC00AD00AE00AF +00B000B100B200B300B400B500B600B700B800B900BA00BB00BC00BD00BE00BF +00C000C100C200C300C400C500C600C700C800C900CA00CB00CC00CD00CE00CF +011E00D100D200D300D400D500D600D700D800D900DA00DB00DC0130015E00DF +00E000E100E200E300E400E500E600E700E800E900EA00EB00EC00ED00EE00EF +011F00F100F200F300F400F500F600F700F800F900FA00FB00FC0131015F00FF diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1255.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1255.enc new file mode 100644 index 0000000000000000000000000000000000000000..6e78b954b7eeb839a4e584e193710f79b2f238e0 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1255.enc @@ -0,0 +1,20 @@ +# Encoding file: cp1255, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +20AC0081201A0192201E20262020202102C62030008A2039008C008D008E008F +009020182019201C201D20222013201402DC2122009A203A009C009D009E009F +00A000A100A200A320AA00A500A600A700A800A900D700AB00AC00AD00AE00AF +00B000B100B200B300B400B500B600B700B800B900F700BB00BC00BD00BE00BF +05B005B105B205B305B405B505B605B705B805B9000005BB05BC05BD05BE05BF +05C005C105C205C305F005F105F205F305F40000000000000000000000000000 +05D005D105D205D305D405D505D605D705D805D905DA05DB05DC05DD05DE05DF +05E005E105E205E305E405E505E605E705E805E905EA00000000200E200F0000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1256.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1256.enc new file mode 100644 index 0000000000000000000000000000000000000000..a98762a0868e19dec1f15094694f66b4620cd53a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1256.enc @@ -0,0 +1,20 @@ +# Encoding file: cp1256, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +20AC067E201A0192201E20262020202102C62030067920390152068606980688 +06AF20182019201C201D20222013201406A921220691203A0153200C200D06BA +00A0060C00A200A300A400A500A600A700A800A906BE00AB00AC00AD00AE00AF +00B000B100B200B300B400B500B600B700B800B9061B00BB00BC00BD00BE061F +06C1062106220623062406250626062706280629062A062B062C062D062E062F +063006310632063306340635063600D7063706380639063A0640064106420643 +00E0064400E2064506460647064800E700E800E900EA00EB0649064A00EE00EF +064B064C064D064E00F4064F065000F7065100F9065200FB00FC200E200F06D2 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1257.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1257.enc new file mode 100644 index 0000000000000000000000000000000000000000..4aa135dfc0c749f645c397dc4f39ff56811ce9c4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1257.enc @@ -0,0 +1,20 @@ +# Encoding file: cp1257, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +20AC0081201A0083201E20262020202100882030008A2039008C00A802C700B8 +009020182019201C201D20222013201400982122009A203A009C00AF02DB009F +00A0000000A200A300A4000000A600A700D800A9015600AB00AC00AD00AE00C6 +00B000B100B200B300B400B500B600B700F800B9015700BB00BC00BD00BE00E6 +0104012E0100010600C400C501180112010C00C90179011601220136012A013B +01600143014500D3014C00D500D600D701720141015A016A00DC017B017D00DF +0105012F0101010700E400E501190113010D00E9017A011701230137012B013C +01610144014600F3014D00F500F600F701730142015B016B00FC017C017E02D9 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1258.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1258.enc new file mode 100644 index 0000000000000000000000000000000000000000..95fdef882959ac09db866fab45506ef2188e0faf --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp1258.enc @@ -0,0 +1,20 @@ +# Encoding file: cp1258, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +20AC0081201A0192201E20262020202102C62030008A20390152008D008E008F +009020182019201C201D20222013201402DC2122009A203A0153009D009E0178 +00A000A100A200A300A400A500A600A700A800A900AA00AB00AC00AD00AE00AF +00B000B100B200B300B400B500B600B700B800B900BA00BB00BC00BD00BE00BF +00C000C100C2010200C400C500C600C700C800C900CA00CB030000CD00CE00CF +011000D1030900D300D401A000D600D700D800D900DA00DB00DC01AF030300DF +00E000E100E2010300E400E500E600E700E800E900EA00EB030100ED00EE00EF +011100F1032300F300F401A100F600F700F800F900FA00FB00FC01B020AB00FF diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp437.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp437.enc new file mode 100644 index 0000000000000000000000000000000000000000..ecae4e65403ef7c1f352fbb789322a040f832d68 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp437.enc @@ -0,0 +1,20 @@ +# Encoding file: cp437, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00C700FC00E900E200E400E000E500E700EA00EB00E800EF00EE00EC00C400C5 +00C900E600C600F400F600F200FB00F900FF00D600DC00A200A300A520A70192 +00E100ED00F300FA00F100D100AA00BA00BF231000AC00BD00BC00A100AB00BB +259125922593250225242561256225562555256325512557255D255C255B2510 +25142534252C251C2500253C255E255F255A25542569256625602550256C2567 +2568256425652559255825522553256B256A2518250C25882584258C25902580 +03B100DF039303C003A303C300B503C403A6039803A903B4221E03C603B52229 +226100B1226522642320232100F7224800B0221900B7221A207F00B225A000A0 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp737.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp737.enc new file mode 100644 index 0000000000000000000000000000000000000000..5b59661ea42d673be0c0ed4b8288406dcdd45826 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp737.enc @@ -0,0 +1,20 @@ +# Encoding file: cp737, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +039103920393039403950396039703980399039A039B039C039D039E039F03A0 +03A103A303A403A503A603A703A803A903B103B203B303B403B503B603B703B8 +03B903BA03BB03BC03BD03BE03BF03C003C103C303C203C403C503C603C703C8 +259125922593250225242561256225562555256325512557255D255C255B2510 +25142534252C251C2500253C255E255F255A25542569256625602550256C2567 +2568256425652559255825522553256B256A2518250C25882584258C25902580 +03C903AC03AD03AE03CA03AF03CC03CD03CB03CE038603880389038A038C038E +038F00B12265226403AA03AB00F7224800B0221900B7221A207F00B225A000A0 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp775.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp775.enc new file mode 100644 index 0000000000000000000000000000000000000000..71b65c322198cf084252d31eadcf3411b56b5f6c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp775.enc @@ -0,0 +1,20 @@ +# Encoding file: cp775, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +010600FC00E9010100E4012300E501070142011301560157012B017900C400C5 +00C900E600C6014D00F6012200A2015A015B00D600DC00F800A300D800D700A4 +0100012A00F3017B017C017A201D00A600A900AE00AC00BD00BC014100AB00BB +259125922593250225240104010C01180116256325512557255D012E01602510 +25142534252C251C2500253C0172016A255A25542569256625602550256C017D +0105010D01190117012F01610173016B017E2518250C25882584258C25902580 +00D300DF014C014300F500D500B5014401360137013B013C0146011201452019 +00AD00B1201C00BE00B600A700F7201E00B0221900B700B900B300B225A000A0 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp850.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp850.enc new file mode 100644 index 0000000000000000000000000000000000000000..4e7a90d725f404359d4750cb6809068614f35bdd --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp850.enc @@ -0,0 +1,20 @@ +# Encoding file: cp850, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00C700FC00E900E200E400E000E500E700EA00EB00E800EF00EE00EC00C400C5 +00C900E600C600F400F600F200FB00F900FF00D600DC00F800A300D800D70192 +00E100ED00F300FA00F100D100AA00BA00BF00AE00AC00BD00BC00A100AB00BB +2591259225932502252400C100C200C000A9256325512557255D00A200A52510 +25142534252C251C2500253C00E300C3255A25542569256625602550256C00A4 +00F000D000CA00CB00C8013100CD00CE00CF2518250C2588258400A600CC2580 +00D300DF00D400D200F500D500B500FE00DE00DA00DB00D900FD00DD00AF00B4 +00AD00B1201700BE00B600A700F700B800B000A800B700B900B300B225A000A0 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp852.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp852.enc new file mode 100644 index 0000000000000000000000000000000000000000..f34899eec544ce064f9b831d7931c94d4b5ccec6 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp852.enc @@ -0,0 +1,20 @@ +# Encoding file: cp852, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00C700FC00E900E200E4016F010700E7014200EB0150015100EE017900C40106 +00C90139013A00F400F6013D013E015A015B00D600DC01640165014100D7010D +00E100ED00F300FA01040105017D017E0118011900AC017A010C015F00AB00BB +2591259225932502252400C100C2011A015E256325512557255D017B017C2510 +25142534252C251C2500253C01020103255A25542569256625602550256C00A4 +01110110010E00CB010F014700CD00CE011B2518250C258825840162016E2580 +00D300DF00D401430144014801600161015400DA0155017000FD00DD016300B4 +00AD02DD02DB02C702D800A700F700B800B000A802D901710158015925A000A0 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp855.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp855.enc new file mode 100644 index 0000000000000000000000000000000000000000..4d58b86cc2fd06b11347622a0f9bbd9e3cfa2a63 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp855.enc @@ -0,0 +1,20 @@ +# Encoding file: cp855, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0452040204530403045104010454040404550405045604060457040704580408 +04590409045A040A045B040B045C040C045E040E045F040F044E042E044A042A +0430041004310411044604260434041404350415044404240433041300AB00BB +259125922593250225240445042504380418256325512557255D043904192510 +25142534252C251C2500253C043A041A255A25542569256625602550256C00A4 +043B041B043C041C043D041D043E041E043F2518250C25882584041F044F2580 +042F044004200441042104420422044304230436041604320412044C042C2116 +00AD044B042B0437041704480428044D042D044904290447042700A725A000A0 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp857.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp857.enc new file mode 100644 index 0000000000000000000000000000000000000000..b42ed55713a46d19b8f460febd1aba7ff469249a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp857.enc @@ -0,0 +1,20 @@ +# Encoding file: cp857, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00C700FC00E900E200E400E000E500E700EA00EB00E800EF00EE013100C400C5 +00C900E600C600F400F600F200FB00F9013000D600DC00F800A300D8015E015F +00E100ED00F300FA00F100D1011E011F00BF00AE00AC00BD00BC00A100AB00BB +2591259225932502252400C100C200C000A9256325512557255D00A200A52510 +25142534252C251C2500253C00E300C3255A25542569256625602550256C00A4 +00BA00AA00CA00CB00C8000000CD00CE00CF2518250C2588258400A600CC2580 +00D300DF00D400D200F500D500B5000000D700DA00DB00D900EC00FF00AF00B4 +00AD00B1000000BE00B600A700F700B800B000A800B700B900B300B225A000A0 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp860.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp860.enc new file mode 100644 index 0000000000000000000000000000000000000000..871943b3718441d70bb405ff6f20afa94539997f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp860.enc @@ -0,0 +1,20 @@ +# Encoding file: cp860, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00C700FC00E900E200E300E000C100E700EA00CA00E800CD00D400EC00C300C2 +00C900C000C800F400F500F200DA00F900CC00D500DC00A200A300D920A700D3 +00E100ED00F300FA00F100D100AA00BA00BF00D200AC00BD00BC00A100AB00BB +259125922593250225242561256225562555256325512557255D255C255B2510 +25142534252C251C2500253C255E255F255A25542569256625602550256C2567 +2568256425652559255825522553256B256A2518250C25882584258C25902580 +03B100DF039303C003A303C300B503C403A6039803A903B4221E03C603B52229 +226100B1226522642320232100F7224800B0221900B7221A207F00B225A000A0 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp861.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp861.enc new file mode 100644 index 0000000000000000000000000000000000000000..3f8f605e510abbb6e45ce207abad1dd7b7cc8b51 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp861.enc @@ -0,0 +1,20 @@ +# Encoding file: cp861, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00C700FC00E900E200E400E000E500E700EA00EB00E800D000F000DE00C400C5 +00C900E600C600F400F600FE00FB00DD00FD00D600DC00F800A300D820A70192 +00E100ED00F300FA00C100CD00D300DA00BF231000AC00BD00BC00A100AB00BB +259125922593250225242561256225562555256325512557255D255C255B2510 +25142534252C251C2500253C255E255F255A25542569256625602550256C2567 +2568256425652559255825522553256B256A2518250C25882584258C25902580 +03B100DF039303C003A303C300B503C403A6039803A903B4221E03C603B52229 +226100B1226522642320232100F7224800B0221900B7221A207F00B225A000A0 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp862.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp862.enc new file mode 100644 index 0000000000000000000000000000000000000000..5f9d16cc298b455bc39c8e84fcd622747be63f6b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp862.enc @@ -0,0 +1,20 @@ +# Encoding file: cp862, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +05D005D105D205D305D405D505D605D705D805D905DA05DB05DC05DD05DE05DF +05E005E105E205E305E405E505E605E705E805E905EA00A200A300A520A70192 +00E100ED00F300FA00F100D100AA00BA00BF231000AC00BD00BC00A100AB00BB +259125922593250225242561256225562555256325512557255D255C255B2510 +25142534252C251C2500253C255E255F255A25542569256625602550256C2567 +2568256425652559255825522553256B256A2518250C25882584258C25902580 +03B100DF039303C003A303C300B503C403A6039803A903B4221E03C603B52229 +226100B1226522642320232100F7224800B0221900B7221A207F00B225A000A0 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp863.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp863.enc new file mode 100644 index 0000000000000000000000000000000000000000..c8b8686f814128630f9d575180d2d6bfdf6a2185 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp863.enc @@ -0,0 +1,20 @@ +# Encoding file: cp863, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00C700FC00E900E200C200E000B600E700EA00EB00E800EF00EE201700C000A7 +00C900C800CA00F400CB00CF00FB00F900A400D400DC00A200A300D900DB0192 +00A600B400F300FA00A800B800B300AF00CE231000AC00BD00BC00BE00AB00BB +259125922593250225242561256225562555256325512557255D255C255B2510 +25142534252C251C2500253C255E255F255A25542569256625602550256C2567 +2568256425652559255825522553256B256A2518250C25882584258C25902580 +03B100DF039303C003A303C300B503C403A6039803A903B4221E03C603B52229 +226100B1226522642320232100F7224800B0221900B7221A207F00B225A000A0 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp864.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp864.enc new file mode 100644 index 0000000000000000000000000000000000000000..71f9e62b1f9b423936cec3dc4382955b6f925398 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp864.enc @@ -0,0 +1,20 @@ +# Encoding file: cp864, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +00200021002200230024066A0026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00B000B72219221A259225002502253C2524252C251C25342510250C25142518 +03B2221E03C600B100BD00BC224800AB00BBFEF7FEF8009B009CFEFBFEFC009F +00A000ADFE8200A300A4FE8400000000FE8EFE8FFE95FE99060CFE9DFEA1FEA5 +0660066106620663066406650666066706680669FED1061BFEB1FEB5FEB9061F +00A2FE80FE81FE83FE85FECAFE8BFE8DFE91FE93FE97FE9BFE9FFEA3FEA7FEA9 +FEABFEADFEAFFEB3FEB7FEBBFEBFFEC1FEC5FECBFECF00A600AC00F700D7FEC9 +0640FED3FED7FEDBFEDFFEE3FEE7FEEBFEEDFEEFFEF3FEBDFECCFECEFECDFEE1 +FE7D0651FEE5FEE9FEECFEF0FEF2FED0FED5FEF5FEF6FEDDFED9FEF125A00000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp865.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp865.enc new file mode 100644 index 0000000000000000000000000000000000000000..543da9c5f381a51b616b8d327a100d53f4e00cf0 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp865.enc @@ -0,0 +1,20 @@ +# Encoding file: cp865, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00C700FC00E900E200E400E000E500E700EA00EB00E800EF00EE00EC00C400C5 +00C900E600C600F400F600F200FB00F900FF00D600DC00F800A300D820A70192 +00E100ED00F300FA00F100D100AA00BA00BF231000AC00BD00BC00A100AB00A4 +259125922593250225242561256225562555256325512557255D255C255B2510 +25142534252C251C2500253C255E255F255A25542569256625602550256C2567 +2568256425652559255825522553256B256A2518250C25882584258C25902580 +03B100DF039303C003A303C300B503C403A6039803A903B4221E03C603B52229 +226100B1226522642320232100F7224800B0221900B7221A207F00B225A000A0 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp866.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp866.enc new file mode 100644 index 0000000000000000000000000000000000000000..b851cf5b8c68ac7a0c218e6a5844fdfadd9f648f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp866.enc @@ -0,0 +1,20 @@ +# Encoding file: cp866, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0410041104120413041404150416041704180419041A041B041C041D041E041F +0420042104220423042404250426042704280429042A042B042C042D042E042F +0430043104320433043404350436043704380439043A043B043C043D043E043F +259125922593250225242561256225562555256325512557255D255C255B2510 +25142534252C251C2500253C255E255F255A25542569256625602550256C2567 +2568256425652559255825522553256B256A2518250C25882584258C25902580 +0440044104420443044404450446044704480449044A044B044C044D044E044F +040104510404045404070457040E045E00B0221900B7221A211600A425A000A0 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp869.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp869.enc new file mode 100644 index 0000000000000000000000000000000000000000..9fd2929079ccc8b36c76f6bebf507e8e9463cac6 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp869.enc @@ -0,0 +1,20 @@ +# Encoding file: cp869, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850386008700B700AC00A620182019038820150389 +038A03AA038C00930094038E03AB00A9038F00B200B303AC00A303AD03AE03AF +03CA039003CC03CD039103920393039403950396039700BD0398039900AB00BB +25912592259325022524039A039B039C039D256325512557255D039E039F2510 +25142534252C251C2500253C03A003A1255A25542569256625602550256C03A3 +03A403A503A603A703A803A903B103B203B32518250C2588258403B403B52580 +03B603B703B803B903BA03BB03BC03BD03BE03BF03C003C103C303C203C40384 +00AD00B103C503C603C700A703C8038500B000A803C903CB03B003CE25A000A0 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp874.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp874.enc new file mode 100644 index 0000000000000000000000000000000000000000..0487b97d98aade7304f45c178370a6bce15e384b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp874.enc @@ -0,0 +1,20 @@ +# Encoding file: cp874, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +20AC008100820083008420260086008700880089008A008B008C008D008E008F +009020182019201C201D20222013201400980099009A009B009C009D009E009F +00A00E010E020E030E040E050E060E070E080E090E0A0E0B0E0C0E0D0E0E0E0F +0E100E110E120E130E140E150E160E170E180E190E1A0E1B0E1C0E1D0E1E0E1F +0E200E210E220E230E240E250E260E270E280E290E2A0E2B0E2C0E2D0E2E0E2F +0E300E310E320E330E340E350E360E370E380E390E3A00000000000000000E3F +0E400E410E420E430E440E450E460E470E480E490E4A0E4B0E4C0E4D0E4E0E4F +0E500E510E520E530E540E550E560E570E580E590E5A0E5B0000000000000000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp932.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp932.enc new file mode 100644 index 0000000000000000000000000000000000000000..8da8cd69c30e9102fba9fc9895693f0069a4674f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp932.enc @@ -0,0 +1,801 @@ +# Encoding file: cp932, multi-byte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a +81BF 2229 +81DA 2220 +81DB 22a5 +81DF 2261 +81E0 2252 +81E3 221a +81E6 2235 +81E7 222b diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp936.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp936.enc new file mode 100644 index 0000000000000000000000000000000000000000..37bcc80db0f5b601500a3ecb8083ae5f318e4109 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp936.enc @@ -0,0 +1,2162 @@ +# Encoding file: cp936, multi-byte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diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp949.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp949.enc new file mode 100644 index 0000000000000000000000000000000000000000..2f3ec39f949cc2e02698cd88c42a6d09420786ea --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp949.enc @@ -0,0 +1,2128 @@ +# Encoding file: cp949, multi-byte +M +003F 0 125 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +81 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000AC02AC03AC05AC06AC0BAC0CAC0DAC0EAC0FAC18AC1EAC1FAC21AC22AC23 +AC25AC26AC27AC28AC29AC2AAC2BAC2EAC32AC33AC3400000000000000000000 +0000AC35AC36AC37AC3AAC3BAC3DAC3EAC3FAC41AC42AC43AC44AC45AC46AC47 +AC48AC49AC4AAC4CAC4EAC4FAC50AC51AC52AC53AC5500000000000000000000 +0000AC56AC57AC59AC5AAC5BAC5DAC5EAC5FAC60AC61AC62AC63AC64AC65AC66 +AC67AC68AC69AC6AAC6BAC6CAC6DAC6EAC6FAC72AC73AC75AC76AC79AC7BAC7C +AC7DAC7EAC7FAC82AC87AC88AC8DAC8EAC8FAC91AC92AC93AC95AC96AC97AC98 +AC99AC9AAC9BAC9EACA2ACA3ACA4ACA5ACA6ACA7ACABACADACAEACB1ACB2ACB3 +ACB4ACB5ACB6ACB7ACBAACBEACBFACC0ACC2ACC3ACC5ACC6ACC7ACC9ACCAACCB +ACCDACCEACCFACD0ACD1ACD2ACD3ACD4ACD6ACD8ACD9ACDAACDBACDCACDDACDE +ACDFACE2ACE3ACE5ACE6ACE9ACEBACEDACEEACF2ACF4ACF7ACF8ACF9ACFAACFB +ACFEACFFAD01AD02AD03AD05AD07AD08AD09AD0AAD0BAD0EAD10AD12AD130000 +82 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000AD14AD15AD16AD17AD19AD1AAD1BAD1DAD1EAD1FAD21AD22AD23AD24AD25 +AD26AD27AD28AD2AAD2BAD2EAD2FAD30AD31AD32AD3300000000000000000000 +0000AD36AD37AD39AD3AAD3BAD3DAD3EAD3FAD40AD41AD42AD43AD46AD48AD4A +AD4BAD4CAD4DAD4EAD4FAD51AD52AD53AD55AD56AD5700000000000000000000 +0000AD59AD5AAD5BAD5CAD5DAD5EAD5FAD60AD62AD64AD65AD66AD67AD68AD69 +AD6AAD6BAD6EAD6FAD71AD72AD77AD78AD79AD7AAD7EAD80AD83AD84AD85AD86 +AD87AD8AAD8BAD8DAD8EAD8FAD91AD92AD93AD94AD95AD96AD97AD98AD99AD9A +AD9BAD9EAD9FADA0ADA1ADA2ADA3ADA5ADA6ADA7ADA8ADA9ADAAADABADACADAD +ADAEADAFADB0ADB1ADB2ADB3ADB4ADB5ADB6ADB8ADB9ADBAADBBADBCADBDADBE +ADBFADC2ADC3ADC5ADC6ADC7ADC9ADCAADCBADCCADCDADCEADCFADD2ADD4ADD5 +ADD6ADD7ADD8ADD9ADDAADDBADDDADDEADDFADE1ADE2ADE3ADE5ADE6ADE7ADE8 +ADE9ADEAADEBADECADEDADEEADEFADF0ADF1ADF2ADF3ADF4ADF5ADF6ADF70000 +83 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000ADFAADFBADFDADFEAE02AE03AE04AE05AE06AE07AE0AAE0CAE0EAE0FAE10 +AE11AE12AE13AE15AE16AE17AE18AE19AE1AAE1BAE1C00000000000000000000 +0000AE1DAE1EAE1FAE20AE21AE22AE23AE24AE25AE26AE27AE28AE29AE2AAE2B +AE2CAE2DAE2EAE2FAE32AE33AE35AE36AE39AE3BAE3C00000000000000000000 +0000AE3DAE3EAE3FAE42AE44AE47AE48AE49AE4BAE4FAE51AE52AE53AE55AE57 +AE58AE59AE5AAE5BAE5EAE62AE63AE64AE66AE67AE6AAE6BAE6DAE6EAE6FAE71 +AE72AE73AE74AE75AE76AE77AE7AAE7EAE7FAE80AE81AE82AE83AE86AE87AE88 +AE89AE8AAE8BAE8DAE8EAE8FAE90AE91AE92AE93AE94AE95AE96AE97AE98AE99 +AE9AAE9BAE9CAE9DAE9EAE9FAEA0AEA1AEA2AEA3AEA4AEA5AEA6AEA7AEA8AEA9 +AEAAAEABAEACAEADAEAEAEAFAEB0AEB1AEB2AEB3AEB4AEB5AEB6AEB7AEB8AEB9 +AEBAAEBBAEBFAEC1AEC2AEC3AEC5AEC6AEC7AEC8AEC9AECAAECBAECEAED2AED3 +AED4AED5AED6AED7AEDAAEDBAEDDAEDEAEDFAEE0AEE1AEE2AEE3AEE4AEE50000 +84 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000AEE6AEE7AEE9AEEAAEECAEEEAEEFAEF0AEF1AEF2AEF3AEF5AEF6AEF7AEF9 +AEFAAEFBAEFDAEFEAEFFAF00AF01AF02AF03AF04AF0500000000000000000000 +0000AF06AF09AF0AAF0BAF0CAF0EAF0FAF11AF12AF13AF14AF15AF16AF17AF18 +AF19AF1AAF1BAF1CAF1DAF1EAF1FAF20AF21AF22AF2300000000000000000000 +0000AF24AF25AF26AF27AF28AF29AF2AAF2BAF2EAF2FAF31AF33AF35AF36AF37 +AF38AF39AF3AAF3BAF3EAF40AF44AF45AF46AF47AF4AAF4BAF4CAF4DAF4EAF4F +AF51AF52AF53AF54AF55AF56AF57AF58AF59AF5AAF5BAF5EAF5FAF60AF61AF62 +AF63AF66AF67AF68AF69AF6AAF6BAF6CAF6DAF6EAF6FAF70AF71AF72AF73AF74 +AF75AF76AF77AF78AF7AAF7BAF7CAF7DAF7EAF7FAF81AF82AF83AF85AF86AF87 +AF89AF8AAF8BAF8CAF8DAF8EAF8FAF92AF93AF94AF96AF97AF98AF99AF9AAF9B +AF9DAF9EAF9FAFA0AFA1AFA2AFA3AFA4AFA5AFA6AFA7AFA8AFA9AFAAAFABAFAC +AFADAFAEAFAFAFB0AFB1AFB2AFB3AFB4AFB5AFB6AFB7AFBAAFBBAFBDAFBE0000 +85 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000AFBFAFC1AFC2AFC3AFC4AFC5AFC6AFCAAFCCAFCFAFD0AFD1AFD2AFD3AFD5 +AFD6AFD7AFD8AFD9AFDAAFDBAFDDAFDEAFDFAFE0AFE100000000000000000000 +0000AFE2AFE3AFE4AFE5AFE6AFE7AFEAAFEBAFECAFEDAFEEAFEFAFF2AFF3AFF5 +AFF6AFF7AFF9AFFAAFFBAFFCAFFDAFFEAFFFB002B00300000000000000000000 +0000B005B006B007B008B009B00AB00BB00DB00EB00FB011B012B013B015B016 +B017B018B019B01AB01BB01EB01FB020B021B022B023B024B025B026B027B029 +B02AB02BB02CB02DB02EB02FB030B031B032B033B034B035B036B037B038B039 +B03AB03BB03CB03DB03EB03FB040B041B042B043B046B047B049B04BB04DB04F +B050B051B052B056B058B05AB05BB05CB05EB05FB060B061B062B063B064B065 +B066B067B068B069B06AB06BB06CB06DB06EB06FB070B071B072B073B074B075 +B076B077B078B079B07AB07BB07EB07FB081B082B083B085B086B087B088B089 +B08AB08BB08EB090B092B093B094B095B096B097B09BB09DB09EB0A3B0A40000 +86 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000B0A5B0A6B0A7B0AAB0B0B0B2B0B6B0B7B0B9B0BAB0BBB0BDB0BEB0BFB0C0 +B0C1B0C2B0C3B0C6B0CAB0CBB0CCB0CDB0CEB0CFB0D200000000000000000000 +0000B0D3B0D5B0D6B0D7B0D9B0DAB0DBB0DCB0DDB0DEB0DFB0E1B0E2B0E3B0E4 +B0E6B0E7B0E8B0E9B0EAB0EBB0ECB0EDB0EEB0EFB0F000000000000000000000 +0000B0F1B0F2B0F3B0F4B0F5B0F6B0F7B0F8B0F9B0FAB0FBB0FCB0FDB0FEB0FF +B100B101B102B103B104B105B106B107B10AB10DB10EB10FB111B114B115B116 +B117B11AB11EB11FB120B121B122B126B127B129B12AB12BB12DB12EB12FB130 +B131B132B133B136B13AB13BB13CB13DB13EB13FB142B143B145B146B147B149 +B14AB14BB14CB14DB14EB14FB152B153B156B157B159B15AB15BB15DB15EB15F +B161B162B163B164B165B166B167B168B169B16AB16BB16CB16DB16EB16FB170 +B171B172B173B174B175B176B177B17AB17BB17DB17EB17FB181B183B184B185 +B186B187B18AB18CB18EB18FB190B191B195B196B197B199B19AB19BB19D0000 +87 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000B19EB19FB1A0B1A1B1A2B1A3B1A4B1A5B1A6B1A7B1A9B1AAB1ABB1ACB1AD +B1AEB1AFB1B0B1B1B1B2B1B3B1B4B1B5B1B6B1B7B1B800000000000000000000 +0000B1B9B1BAB1BBB1BCB1BDB1BEB1BFB1C0B1C1B1C2B1C3B1C4B1C5B1C6B1C7 +B1C8B1C9B1CAB1CBB1CDB1CEB1CFB1D1B1D2B1D3B1D500000000000000000000 +0000B1D6B1D7B1D8B1D9B1DAB1DBB1DEB1E0B1E1B1E2B1E3B1E4B1E5B1E6B1E7 +B1EAB1EBB1EDB1EEB1EFB1F1B1F2B1F3B1F4B1F5B1F6B1F7B1F8B1FAB1FCB1FE +B1FFB200B201B202B203B206B207B209B20AB20DB20EB20FB210B211B212B213 +B216B218B21AB21BB21CB21DB21EB21FB221B222B223B224B225B226B227B228 +B229B22AB22BB22CB22DB22EB22FB230B231B232B233B235B236B237B238B239 +B23AB23BB23DB23EB23FB240B241B242B243B244B245B246B247B248B249B24A +B24BB24CB24DB24EB24FB250B251B252B253B254B255B256B257B259B25AB25B +B25DB25EB25FB261B262B263B264B265B266B267B26AB26BB26CB26DB26E0000 +88 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000B26FB270B271B272B273B276B277B278B279B27AB27BB27DB27EB27FB280 +B281B282B283B286B287B288B28AB28BB28CB28DB28E00000000000000000000 +0000B28FB292B293B295B296B297B29BB29CB29DB29EB29FB2A2B2A4B2A7B2A8 +B2A9B2ABB2ADB2AEB2AFB2B1B2B2B2B3B2B5B2B6B2B700000000000000000000 +0000B2B8B2B9B2BAB2BBB2BCB2BDB2BEB2BFB2C0B2C1B2C2B2C3B2C4B2C5B2C6 +B2C7B2CAB2CBB2CDB2CEB2CFB2D1B2D3B2D4B2D5B2D6B2D7B2DAB2DCB2DEB2DF +B2E0B2E1B2E3B2E7B2E9B2EAB2F0B2F1B2F2B2F6B2FCB2FDB2FEB302B303B305 +B306B307B309B30AB30BB30CB30DB30EB30FB312B316B317B318B319B31AB31B +B31DB31EB31FB320B321B322B323B324B325B326B327B328B329B32AB32BB32C +B32DB32EB32FB330B331B332B333B334B335B336B337B338B339B33AB33BB33C +B33DB33EB33FB340B341B342B343B344B345B346B347B348B349B34AB34BB34C +B34DB34EB34FB350B351B352B353B357B359B35AB35DB360B361B362B3630000 +89 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000B366B368B36AB36CB36DB36FB372B373B375B376B377B379B37AB37BB37C +B37DB37EB37FB382B386B387B388B389B38AB38BB38D00000000000000000000 +0000B38EB38FB391B392B393B395B396B397B398B399B39AB39BB39CB39DB39E +B39FB3A2B3A3B3A4B3A5B3A6B3A7B3A9B3AAB3ABB3AD00000000000000000000 +0000B3AEB3AFB3B0B3B1B3B2B3B3B3B4B3B5B3B6B3B7B3B8B3B9B3BAB3BBB3BC +B3BDB3BEB3BFB3C0B3C1B3C2B3C3B3C6B3C7B3C9B3CAB3CDB3CFB3D1B3D2B3D3 +B3D6B3D8B3DAB3DCB3DEB3DFB3E1B3E2B3E3B3E5B3E6B3E7B3E9B3EAB3EBB3EC +B3EDB3EEB3EFB3F0B3F1B3F2B3F3B3F4B3F5B3F6B3F7B3F8B3F9B3FAB3FBB3FD +B3FEB3FFB400B401B402B403B404B405B406B407B408B409B40AB40BB40CB40D +B40EB40FB411B412B413B414B415B416B417B419B41AB41BB41DB41EB41FB421 +B422B423B424B425B426B427B42AB42CB42DB42EB42FB430B431B432B433B435 +B436B437B438B439B43AB43BB43CB43DB43EB43FB440B441B442B443B4440000 +8A +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000B445B446B447B448B449B44AB44BB44CB44DB44EB44FB452B453B455B456 +B457B459B45AB45BB45CB45DB45EB45FB462B464B46600000000000000000000 +0000B467B468B469B46AB46BB46DB46EB46FB470B471B472B473B474B475B476 +B477B478B479B47AB47BB47CB47DB47EB47FB481B48200000000000000000000 +0000B483B484B485B486B487B489B48AB48BB48CB48DB48EB48FB490B491B492 +B493B494B495B496B497B498B499B49AB49BB49CB49EB49FB4A0B4A1B4A2B4A3 +B4A5B4A6B4A7B4A9B4AAB4ABB4ADB4AEB4AFB4B0B4B1B4B2B4B3B4B4B4B6B4B8 +B4BAB4BBB4BCB4BDB4BEB4BFB4C1B4C2B4C3B4C5B4C6B4C7B4C9B4CAB4CBB4CC +B4CDB4CEB4CFB4D1B4D2B4D3B4D4B4D6B4D7B4D8B4D9B4DAB4DBB4DEB4DFB4E1 +B4E2B4E5B4E7B4E8B4E9B4EAB4EBB4EEB4F0B4F2B4F3B4F4B4F5B4F6B4F7B4F9 +B4FAB4FBB4FCB4FDB4FEB4FFB500B501B502B503B504B505B506B507B508B509 +B50AB50BB50CB50DB50EB50FB510B511B512B513B516B517B519B51AB51D0000 +8B +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000B51EB51FB520B521B522B523B526B52BB52CB52DB52EB52FB532B533B535 +B536B537B539B53AB53BB53CB53DB53EB53FB542B54600000000000000000000 +0000B547B548B549B54AB54EB54FB551B552B553B555B556B557B558B559B55A +B55BB55EB562B563B564B565B566B567B568B569B56A00000000000000000000 +0000B56BB56CB56DB56EB56FB570B571B572B573B574B575B576B577B578B579 +B57AB57BB57CB57DB57EB57FB580B581B582B583B584B585B586B587B588B589 +B58AB58BB58CB58DB58EB58FB590B591B592B593B594B595B596B597B598B599 +B59AB59BB59CB59DB59EB59FB5A2B5A3B5A5B5A6B5A7B5A9B5ACB5ADB5AEB5AF +B5B2B5B6B5B7B5B8B5B9B5BAB5BEB5BFB5C1B5C2B5C3B5C5B5C6B5C7B5C8B5C9 +B5CAB5CBB5CEB5D2B5D3B5D4B5D5B5D6B5D7B5D9B5DAB5DBB5DCB5DDB5DEB5DF +B5E0B5E1B5E2B5E3B5E4B5E5B5E6B5E7B5E8B5E9B5EAB5EBB5EDB5EEB5EFB5F0 +B5F1B5F2B5F3B5F4B5F5B5F6B5F7B5F8B5F9B5FAB5FBB5FCB5FDB5FEB5FF0000 +8C +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000B600B601B602B603B604B605B606B607B608B609B60AB60BB60CB60DB60E +B60FB612B613B615B616B617B619B61AB61BB61CB61D00000000000000000000 +0000B61EB61FB620B621B622B623B624B626B627B628B629B62AB62BB62DB62E +B62FB630B631B632B633B635B636B637B638B639B63A00000000000000000000 +0000B63BB63CB63DB63EB63FB640B641B642B643B644B645B646B647B649B64A +B64BB64CB64DB64EB64FB650B651B652B653B654B655B656B657B658B659B65A +B65BB65CB65DB65EB65FB660B661B662B663B665B666B667B669B66AB66BB66C +B66DB66EB66FB670B671B672B673B674B675B676B677B678B679B67AB67BB67C +B67DB67EB67FB680B681B682B683B684B685B686B687B688B689B68AB68BB68C +B68DB68EB68FB690B691B692B693B694B695B696B697B698B699B69AB69BB69E +B69FB6A1B6A2B6A3B6A5B6A6B6A7B6A8B6A9B6AAB6ADB6AEB6AFB6B0B6B2B6B3 +B6B4B6B5B6B6B6B7B6B8B6B9B6BAB6BBB6BCB6BDB6BEB6BFB6C0B6C1B6C20000 +8D +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000B6C3B6C4B6C5B6C6B6C7B6C8B6C9B6CAB6CBB6CCB6CDB6CEB6CFB6D0B6D1 +B6D2B6D3B6D5B6D6B6D7B6D8B6D9B6DAB6DBB6DCB6DD00000000000000000000 +0000B6DEB6DFB6E0B6E1B6E2B6E3B6E4B6E5B6E6B6E7B6E8B6E9B6EAB6EBB6EC +B6EDB6EEB6EFB6F1B6F2B6F3B6F5B6F6B6F7B6F9B6FA00000000000000000000 +0000B6FBB6FCB6FDB6FEB6FFB702B703B704B706B707B708B709B70AB70BB70C +B70DB70EB70FB710B711B712B713B714B715B716B717B718B719B71AB71BB71C +B71DB71EB71FB720B721B722B723B724B725B726B727B72AB72BB72DB72EB731 +B732B733B734B735B736B737B73AB73CB73DB73EB73FB740B741B742B743B745 +B746B747B749B74AB74BB74DB74EB74FB750B751B752B753B756B757B758B759 +B75AB75BB75CB75DB75EB75FB761B762B763B765B766B767B769B76AB76BB76C +B76DB76EB76FB772B774B776B777B778B779B77AB77BB77EB77FB781B782B783 +B785B786B787B788B789B78AB78BB78EB793B794B795B79AB79BB79DB79E0000 +8E +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000B79FB7A1B7A2B7A3B7A4B7A5B7A6B7A7B7AAB7AEB7AFB7B0B7B1B7B2B7B3 +B7B6B7B7B7B9B7BAB7BBB7BCB7BDB7BEB7BFB7C0B7C100000000000000000000 +0000B7C2B7C3B7C4B7C5B7C6B7C8B7CAB7CBB7CCB7CDB7CEB7CFB7D0B7D1B7D2 +B7D3B7D4B7D5B7D6B7D7B7D8B7D9B7DAB7DBB7DCB7DD00000000000000000000 +0000B7DEB7DFB7E0B7E1B7E2B7E3B7E4B7E5B7E6B7E7B7E8B7E9B7EAB7EBB7EE +B7EFB7F1B7F2B7F3B7F5B7F6B7F7B7F8B7F9B7FAB7FBB7FEB802B803B804B805 +B806B80AB80BB80DB80EB80FB811B812B813B814B815B816B817B81AB81CB81E +B81FB820B821B822B823B826B827B829B82AB82BB82DB82EB82FB830B831B832 +B833B836B83AB83BB83CB83DB83EB83FB841B842B843B845B846B847B848B849 +B84AB84BB84CB84DB84EB84FB850B852B854B855B856B857B858B859B85AB85B +B85EB85FB861B862B863B865B866B867B868B869B86AB86BB86EB870B872B873 +B874B875B876B877B879B87AB87BB87DB87EB87FB880B881B882B883B8840000 +8F +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000B885B886B887B888B889B88AB88BB88CB88EB88FB890B891B892B893B894 +B895B896B897B898B899B89AB89BB89CB89DB89EB89F00000000000000000000 +0000B8A0B8A1B8A2B8A3B8A4B8A5B8A6B8A7B8A9B8AAB8ABB8ACB8ADB8AEB8AF +B8B1B8B2B8B3B8B5B8B6B8B7B8B9B8BAB8BBB8BCB8BD00000000000000000000 +0000B8BEB8BFB8C2B8C4B8C6B8C7B8C8B8C9B8CAB8CBB8CDB8CEB8CFB8D1B8D2 +B8D3B8D5B8D6B8D7B8D8B8D9B8DAB8DBB8DCB8DEB8E0B8E2B8E3B8E4B8E5B8E6 +B8E7B8EAB8EBB8EDB8EEB8EFB8F1B8F2B8F3B8F4B8F5B8F6B8F7B8FAB8FCB8FE +B8FFB900B901B902B903B905B906B907B908B909B90AB90BB90CB90DB90EB90F +B910B911B912B913B914B915B916B917B919B91AB91BB91CB91DB91EB91FB921 +B922B923B924B925B926B927B928B929B92AB92BB92CB92DB92EB92FB930B931 +B932B933B934B935B936B937B938B939B93AB93BB93EB93FB941B942B943B945 +B946B947B948B949B94AB94BB94DB94EB950B952B953B954B955B956B9570000 +90 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000B95AB95BB95DB95EB95FB961B962B963B964B965B966B967B96AB96CB96E +B96FB970B971B972B973B976B977B979B97AB97BB97D00000000000000000000 +0000B97EB97FB980B981B982B983B986B988B98BB98CB98FB990B991B992B993 +B994B995B996B997B998B999B99AB99BB99CB99DB99E00000000000000000000 +0000B99FB9A0B9A1B9A2B9A3B9A4B9A5B9A6B9A7B9A8B9A9B9AAB9ABB9AEB9AF +B9B1B9B2B9B3B9B5B9B6B9B7B9B8B9B9B9BAB9BBB9BEB9C0B9C2B9C3B9C4B9C5 +B9C6B9C7B9CAB9CBB9CDB9D3B9D4B9D5B9D6B9D7B9DAB9DCB9DFB9E0B9E2B9E6 +B9E7B9E9B9EAB9EBB9EDB9EEB9EFB9F0B9F1B9F2B9F3B9F6B9FBB9FCB9FDB9FE +B9FFBA02BA03BA04BA05BA06BA07BA09BA0ABA0BBA0CBA0DBA0EBA0FBA10BA11 +BA12BA13BA14BA16BA17BA18BA19BA1ABA1BBA1CBA1DBA1EBA1FBA20BA21BA22 +BA23BA24BA25BA26BA27BA28BA29BA2ABA2BBA2CBA2DBA2EBA2FBA30BA31BA32 +BA33BA34BA35BA36BA37BA3ABA3BBA3DBA3EBA3FBA41BA43BA44BA45BA460000 +91 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000BA47BA4ABA4CBA4FBA50BA51BA52BA56BA57BA59BA5ABA5BBA5DBA5EBA5F +BA60BA61BA62BA63BA66BA6ABA6BBA6CBA6DBA6EBA6F00000000000000000000 +0000BA72BA73BA75BA76BA77BA79BA7ABA7BBA7CBA7DBA7EBA7FBA80BA81BA82 +BA86BA88BA89BA8ABA8BBA8DBA8EBA8FBA90BA91BA9200000000000000000000 +0000BA93BA94BA95BA96BA97BA98BA99BA9ABA9BBA9CBA9DBA9EBA9FBAA0BAA1 +BAA2BAA3BAA4BAA5BAA6BAA7BAAABAADBAAEBAAFBAB1BAB3BAB4BAB5BAB6BAB7 +BABABABCBABEBABFBAC0BAC1BAC2BAC3BAC5BAC6BAC7BAC9BACABACBBACCBACD +BACEBACFBAD0BAD1BAD2BAD3BAD4BAD5BAD6BAD7BADABADBBADCBADDBADEBADF +BAE0BAE1BAE2BAE3BAE4BAE5BAE6BAE7BAE8BAE9BAEABAEBBAECBAEDBAEEBAEF +BAF0BAF1BAF2BAF3BAF4BAF5BAF6BAF7BAF8BAF9BAFABAFBBAFDBAFEBAFFBB01 +BB02BB03BB05BB06BB07BB08BB09BB0ABB0BBB0CBB0EBB10BB12BB13BB14BB15 +BB16BB17BB19BB1ABB1BBB1DBB1EBB1FBB21BB22BB23BB24BB25BB26BB270000 +92 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000BB28BB2ABB2CBB2DBB2EBB2FBB30BB31BB32BB33BB37BB39BB3ABB3FBB40 +BB41BB42BB43BB46BB48BB4ABB4BBB4CBB4EBB51BB5200000000000000000000 +0000BB53BB55BB56BB57BB59BB5ABB5BBB5CBB5DBB5EBB5FBB60BB62BB64BB65 +BB66BB67BB68BB69BB6ABB6BBB6DBB6EBB6FBB70BB7100000000000000000000 +0000BB72BB73BB74BB75BB76BB77BB78BB79BB7ABB7BBB7CBB7DBB7EBB7FBB80 +BB81BB82BB83BB84BB85BB86BB87BB89BB8ABB8BBB8DBB8EBB8FBB91BB92BB93 +BB94BB95BB96BB97BB98BB99BB9ABB9BBB9CBB9DBB9EBB9FBBA0BBA1BBA2BBA3 +BBA5BBA6BBA7BBA9BBAABBABBBADBBAEBBAFBBB0BBB1BBB2BBB3BBB5BBB6BBB8 +BBB9BBBABBBBBBBCBBBDBBBEBBBFBBC1BBC2BBC3BBC5BBC6BBC7BBC9BBCABBCB +BBCCBBCDBBCEBBCFBBD1BBD2BBD4BBD5BBD6BBD7BBD8BBD9BBDABBDBBBDCBBDD +BBDEBBDFBBE0BBE1BBE2BBE3BBE4BBE5BBE6BBE7BBE8BBE9BBEABBEBBBECBBED +BBEEBBEFBBF0BBF1BBF2BBF3BBF4BBF5BBF6BBF7BBFABBFBBBFDBBFEBC010000 +93 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000BC03BC04BC05BC06BC07BC0ABC0EBC10BC12BC13BC19BC1ABC20BC21BC22 +BC23BC26BC28BC2ABC2BBC2CBC2EBC2FBC32BC33BC3500000000000000000000 +0000BC36BC37BC39BC3ABC3BBC3CBC3DBC3EBC3FBC42BC46BC47BC48BC4ABC4B +BC4EBC4FBC51BC52BC53BC54BC55BC56BC57BC58BC5900000000000000000000 +0000BC5ABC5BBC5CBC5EBC5FBC60BC61BC62BC63BC64BC65BC66BC67BC68BC69 +BC6ABC6BBC6CBC6DBC6EBC6FBC70BC71BC72BC73BC74BC75BC76BC77BC78BC79 +BC7ABC7BBC7CBC7DBC7EBC7FBC80BC81BC82BC83BC86BC87BC89BC8ABC8DBC8F +BC90BC91BC92BC93BC96BC98BC9BBC9CBC9DBC9EBC9FBCA2BCA3BCA5BCA6BCA9 +BCAABCABBCACBCADBCAEBCAFBCB2BCB6BCB7BCB8BCB9BCBABCBBBCBEBCBFBCC1 +BCC2BCC3BCC5BCC6BCC7BCC8BCC9BCCABCCBBCCCBCCEBCD2BCD3BCD4BCD6BCD7 +BCD9BCDABCDBBCDDBCDEBCDFBCE0BCE1BCE2BCE3BCE4BCE5BCE6BCE7BCE8BCE9 +BCEABCEBBCECBCEDBCEEBCEFBCF0BCF1BCF2BCF3BCF7BCF9BCFABCFBBCFD0000 +94 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000BCFEBCFFBD00BD01BD02BD03BD06BD08BD0ABD0BBD0CBD0DBD0EBD0FBD11 +BD12BD13BD15BD16BD17BD18BD19BD1ABD1BBD1CBD1D00000000000000000000 +0000BD1EBD1FBD20BD21BD22BD23BD25BD26BD27BD28BD29BD2ABD2BBD2DBD2E +BD2FBD30BD31BD32BD33BD34BD35BD36BD37BD38BD3900000000000000000000 +0000BD3ABD3BBD3CBD3DBD3EBD3FBD41BD42BD43BD44BD45BD46BD47BD4ABD4B +BD4DBD4EBD4FBD51BD52BD53BD54BD55BD56BD57BD5ABD5BBD5CBD5DBD5EBD5F +BD60BD61BD62BD63BD65BD66BD67BD69BD6ABD6BBD6CBD6DBD6EBD6FBD70BD71 +BD72BD73BD74BD75BD76BD77BD78BD79BD7ABD7BBD7CBD7DBD7EBD7FBD82BD83 +BD85BD86BD8BBD8CBD8DBD8EBD8FBD92BD94BD96BD97BD98BD9BBD9DBD9EBD9F +BDA0BDA1BDA2BDA3BDA5BDA6BDA7BDA8BDA9BDAABDABBDACBDADBDAEBDAFBDB1 +BDB2BDB3BDB4BDB5BDB6BDB7BDB9BDBABDBBBDBCBDBDBDBEBDBFBDC0BDC1BDC2 +BDC3BDC4BDC5BDC6BDC7BDC8BDC9BDCABDCBBDCCBDCDBDCEBDCFBDD0BDD10000 +95 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000BDD2BDD3BDD6BDD7BDD9BDDABDDBBDDDBDDEBDDFBDE0BDE1BDE2BDE3BDE4 +BDE5BDE6BDE7BDE8BDEABDEBBDECBDEDBDEEBDEFBDF100000000000000000000 +0000BDF2BDF3BDF5BDF6BDF7BDF9BDFABDFBBDFCBDFDBDFEBDFFBE01BE02BE04 +BE06BE07BE08BE09BE0ABE0BBE0EBE0FBE11BE12BE1300000000000000000000 +0000BE15BE16BE17BE18BE19BE1ABE1BBE1EBE20BE21BE22BE23BE24BE25BE26 +BE27BE28BE29BE2ABE2BBE2CBE2DBE2EBE2FBE30BE31BE32BE33BE34BE35BE36 +BE37BE38BE39BE3ABE3BBE3CBE3DBE3EBE3FBE40BE41BE42BE43BE46BE47BE49 +BE4ABE4BBE4DBE4FBE50BE51BE52BE53BE56BE58BE5CBE5DBE5EBE5FBE62BE63 +BE65BE66BE67BE69BE6BBE6CBE6DBE6EBE6FBE72BE76BE77BE78BE79BE7ABE7E +BE7FBE81BE82BE83BE85BE86BE87BE88BE89BE8ABE8BBE8EBE92BE93BE94BE95 +BE96BE97BE9ABE9BBE9CBE9DBE9EBE9FBEA0BEA1BEA2BEA3BEA4BEA5BEA6BEA7 +BEA9BEAABEABBEACBEADBEAEBEAFBEB0BEB1BEB2BEB3BEB4BEB5BEB6BEB70000 +96 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000BEB8BEB9BEBABEBBBEBCBEBDBEBEBEBFBEC0BEC1BEC2BEC3BEC4BEC5BEC6 +BEC7BEC8BEC9BECABECBBECCBECDBECEBECFBED2BED300000000000000000000 +0000BED5BED6BED9BEDABEDBBEDCBEDDBEDEBEDFBEE1BEE2BEE6BEE7BEE8BEE9 +BEEABEEBBEEDBEEEBEEFBEF0BEF1BEF2BEF3BEF4BEF500000000000000000000 +0000BEF6BEF7BEF8BEF9BEFABEFBBEFCBEFDBEFEBEFFBF00BF02BF03BF04BF05 +BF06BF07BF0ABF0BBF0CBF0DBF0EBF0FBF10BF11BF12BF13BF14BF15BF16BF17 +BF1ABF1EBF1FBF20BF21BF22BF23BF24BF25BF26BF27BF28BF29BF2ABF2BBF2C +BF2DBF2EBF2FBF30BF31BF32BF33BF34BF35BF36BF37BF38BF39BF3ABF3BBF3C +BF3DBF3EBF3FBF42BF43BF45BF46BF47BF49BF4ABF4BBF4CBF4DBF4EBF4FBF52 +BF53BF54BF56BF57BF58BF59BF5ABF5BBF5CBF5DBF5EBF5FBF60BF61BF62BF63 +BF64BF65BF66BF67BF68BF69BF6ABF6BBF6CBF6DBF6EBF6FBF70BF71BF72BF73 +BF74BF75BF76BF77BF78BF79BF7ABF7BBF7CBF7DBF7EBF7FBF80BF81BF820000 +97 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000BF83BF84BF85BF86BF87BF88BF89BF8ABF8BBF8CBF8DBF8EBF8FBF90BF91 +BF92BF93BF95BF96BF97BF98BF99BF9ABF9BBF9CBF9D00000000000000000000 +0000BF9EBF9FBFA0BFA1BFA2BFA3BFA4BFA5BFA6BFA7BFA8BFA9BFAABFABBFAC +BFADBFAEBFAFBFB1BFB2BFB3BFB4BFB5BFB6BFB7BFB800000000000000000000 +0000BFB9BFBABFBBBFBCBFBDBFBEBFBFBFC0BFC1BFC2BFC3BFC4BFC6BFC7BFC8 +BFC9BFCABFCBBFCEBFCFBFD1BFD2BFD3BFD5BFD6BFD7BFD8BFD9BFDABFDBBFDD +BFDEBFE0BFE2BFE3BFE4BFE5BFE6BFE7BFE8BFE9BFEABFEBBFECBFEDBFEEBFEF +BFF0BFF1BFF2BFF3BFF4BFF5BFF6BFF7BFF8BFF9BFFABFFBBFFCBFFDBFFEBFFF +C000C001C002C003C004C005C006C007C008C009C00AC00BC00CC00DC00EC00F +C010C011C012C013C014C015C016C017C018C019C01AC01BC01CC01DC01EC01F +C020C021C022C023C024C025C026C027C028C029C02AC02BC02CC02DC02EC02F +C030C031C032C033C034C035C036C037C038C039C03AC03BC03DC03EC03F0000 +98 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000C040C041C042C043C044C045C046C047C048C049C04AC04BC04CC04DC04E +C04FC050C052C053C054C055C056C057C059C05AC05B00000000000000000000 +0000C05DC05EC05FC061C062C063C064C065C066C067C06AC06BC06CC06DC06E +C06FC070C071C072C073C074C075C076C077C078C07900000000000000000000 +0000C07AC07BC07CC07DC07EC07FC080C081C082C083C084C085C086C087C088 +C089C08AC08BC08CC08DC08EC08FC092C093C095C096C097C099C09AC09BC09C +C09DC09EC09FC0A2C0A4C0A6C0A7C0A8C0A9C0AAC0ABC0AEC0B1C0B2C0B7C0B8 +C0B9C0BAC0BBC0BEC0C2C0C3C0C4C0C6C0C7C0CAC0CBC0CDC0CEC0CFC0D1C0D2 +C0D3C0D4C0D5C0D6C0D7C0DAC0DEC0DFC0E0C0E1C0E2C0E3C0E6C0E7C0E9C0EA +C0EBC0EDC0EEC0EFC0F0C0F1C0F2C0F3C0F6C0F8C0FAC0FBC0FCC0FDC0FEC0FF +C101C102C103C105C106C107C109C10AC10BC10CC10DC10EC10FC111C112C113 +C114C116C117C118C119C11AC11BC121C122C125C128C129C12AC12BC12E0000 +99 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000C132C133C134C135C137C13AC13BC13DC13EC13FC141C142C143C144C145 +C146C147C14AC14EC14FC150C151C152C153C156C15700000000000000000000 +0000C159C15AC15BC15DC15EC15FC160C161C162C163C166C16AC16BC16CC16D +C16EC16FC171C172C173C175C176C177C179C17AC17B00000000000000000000 +0000C17CC17DC17EC17FC180C181C182C183C184C186C187C188C189C18AC18B +C18FC191C192C193C195C197C198C199C19AC19BC19EC1A0C1A2C1A3C1A4C1A6 +C1A7C1AAC1ABC1ADC1AEC1AFC1B1C1B2C1B3C1B4C1B5C1B6C1B7C1B8C1B9C1BA +C1BBC1BCC1BEC1BFC1C0C1C1C1C2C1C3C1C5C1C6C1C7C1C9C1CAC1CBC1CDC1CE +C1CFC1D0C1D1C1D2C1D3C1D5C1D6C1D9C1DAC1DBC1DCC1DDC1DEC1DFC1E1C1E2 +C1E3C1E5C1E6C1E7C1E9C1EAC1EBC1ECC1EDC1EEC1EFC1F2C1F4C1F5C1F6C1F7 +C1F8C1F9C1FAC1FBC1FEC1FFC201C202C203C205C206C207C208C209C20AC20B +C20EC210C212C213C214C215C216C217C21AC21BC21DC21EC221C222C2230000 +9A +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000C224C225C226C227C22AC22CC22EC230C233C235C236C237C238C239C23A +C23BC23CC23DC23EC23FC240C241C242C243C244C24500000000000000000000 +0000C246C247C249C24AC24BC24CC24DC24EC24FC252C253C255C256C257C259 +C25AC25BC25CC25DC25EC25FC261C262C263C264C26600000000000000000000 +0000C267C268C269C26AC26BC26EC26FC271C272C273C275C276C277C278C279 +C27AC27BC27EC280C282C283C284C285C286C287C28AC28BC28CC28DC28EC28F +C291C292C293C294C295C296C297C299C29AC29CC29EC29FC2A0C2A1C2A2C2A3 +C2A6C2A7C2A9C2AAC2ABC2AEC2AFC2B0C2B1C2B2C2B3C2B6C2B8C2BAC2BBC2BC +C2BDC2BEC2BFC2C0C2C1C2C2C2C3C2C4C2C5C2C6C2C7C2C8C2C9C2CAC2CBC2CC +C2CDC2CEC2CFC2D0C2D1C2D2C2D3C2D4C2D5C2D6C2D7C2D8C2D9C2DAC2DBC2DE +C2DFC2E1C2E2C2E5C2E6C2E7C2E8C2E9C2EAC2EEC2F0C2F2C2F3C2F4C2F5C2F7 +C2FAC2FDC2FEC2FFC301C302C303C304C305C306C307C30AC30BC30EC30F0000 +9B +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000C310C311C312C316C317C319C31AC31BC31DC31EC31FC320C321C322C323 +C326C327C32AC32BC32CC32DC32EC32FC330C331C33200000000000000000000 +0000C333C334C335C336C337C338C339C33AC33BC33CC33DC33EC33FC340C341 +C342C343C344C346C347C348C349C34AC34BC34CC34D00000000000000000000 +0000C34EC34FC350C351C352C353C354C355C356C357C358C359C35AC35BC35C +C35DC35EC35FC360C361C362C363C364C365C366C367C36AC36BC36DC36EC36F +C371C373C374C375C376C377C37AC37BC37EC37FC380C381C382C383C385C386 +C387C389C38AC38BC38DC38EC38FC390C391C392C393C394C395C396C397C398 +C399C39AC39BC39CC39DC39EC39FC3A0C3A1C3A2C3A3C3A4C3A5C3A6C3A7C3A8 +C3A9C3AAC3ABC3ACC3ADC3AEC3AFC3B0C3B1C3B2C3B3C3B4C3B5C3B6C3B7C3B8 +C3B9C3BAC3BBC3BCC3BDC3BEC3BFC3C1C3C2C3C3C3C4C3C5C3C6C3C7C3C8C3C9 +C3CAC3CBC3CCC3CDC3CEC3CFC3D0C3D1C3D2C3D3C3D4C3D5C3D6C3D7C3DA0000 +9C +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000C3DBC3DDC3DEC3E1C3E3C3E4C3E5C3E6C3E7C3EAC3EBC3ECC3EEC3EFC3F0 +C3F1C3F2C3F3C3F6C3F7C3F9C3FAC3FBC3FCC3FDC3FE00000000000000000000 +0000C3FFC400C401C402C403C404C405C406C407C409C40AC40BC40CC40DC40E +C40FC411C412C413C414C415C416C417C418C419C41A00000000000000000000 +0000C41BC41CC41DC41EC41FC420C421C422C423C425C426C427C428C429C42A +C42BC42DC42EC42FC431C432C433C435C436C437C438C439C43AC43BC43EC43F +C440C441C442C443C444C445C446C447C449C44AC44BC44CC44DC44EC44FC450 +C451C452C453C454C455C456C457C458C459C45AC45BC45CC45DC45EC45FC460 +C461C462C463C466C467C469C46AC46BC46DC46EC46FC470C471C472C473C476 +C477C478C47AC47BC47CC47DC47EC47FC481C482C483C484C485C486C487C488 +C489C48AC48BC48CC48DC48EC48FC490C491C492C493C495C496C497C498C499 +C49AC49BC49DC49EC49FC4A0C4A1C4A2C4A3C4A4C4A5C4A6C4A7C4A8C4A90000 +9D +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000C4AAC4ABC4ACC4ADC4AEC4AFC4B0C4B1C4B2C4B3C4B4C4B5C4B6C4B7C4B9 +C4BAC4BBC4BDC4BEC4BFC4C0C4C1C4C2C4C3C4C4C4C500000000000000000000 +0000C4C6C4C7C4C8C4C9C4CAC4CBC4CCC4CDC4CEC4CFC4D0C4D1C4D2C4D3C4D4 +C4D5C4D6C4D7C4D8C4D9C4DAC4DBC4DCC4DDC4DEC4DF00000000000000000000 +0000C4E0C4E1C4E2C4E3C4E4C4E5C4E6C4E7C4E8C4EAC4EBC4ECC4EDC4EEC4EF +C4F2C4F3C4F5C4F6C4F7C4F9C4FBC4FCC4FDC4FEC502C503C504C505C506C507 +C508C509C50AC50BC50DC50EC50FC511C512C513C515C516C517C518C519C51A +C51BC51DC51EC51FC520C521C522C523C524C525C526C527C52AC52BC52DC52E +C52FC531C532C533C534C535C536C537C53AC53CC53EC53FC540C541C542C543 +C546C547C54BC54FC550C551C552C556C55AC55BC55CC55FC562C563C565C566 +C567C569C56AC56BC56CC56DC56EC56FC572C576C577C578C579C57AC57BC57E +C57FC581C582C583C585C586C588C589C58AC58BC58EC590C592C593C5940000 +9E +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000C596C599C59AC59BC59DC59EC59FC5A1C5A2C5A3C5A4C5A5C5A6C5A7C5A8 +C5AAC5ABC5ACC5ADC5AEC5AFC5B0C5B1C5B2C5B3C5B600000000000000000000 +0000C5B7C5BAC5BFC5C0C5C1C5C2C5C3C5CBC5CDC5CFC5D2C5D3C5D5C5D6C5D7 +C5D9C5DAC5DBC5DCC5DDC5DEC5DFC5E2C5E4C5E6C5E700000000000000000000 +0000C5E8C5E9C5EAC5EBC5EFC5F1C5F2C5F3C5F5C5F8C5F9C5FAC5FBC602C603 +C604C609C60AC60BC60DC60EC60FC611C612C613C614C615C616C617C61AC61D +C61EC61FC620C621C622C623C626C627C629C62AC62BC62FC631C632C636C638 +C63AC63CC63DC63EC63FC642C643C645C646C647C649C64AC64BC64CC64DC64E +C64FC652C656C657C658C659C65AC65BC65EC65FC661C662C663C664C665C666 +C667C668C669C66AC66BC66DC66EC670C672C673C674C675C676C677C67AC67B +C67DC67EC67FC681C682C683C684C685C686C687C68AC68CC68EC68FC690C691 +C692C693C696C697C699C69AC69BC69DC69EC69FC6A0C6A1C6A2C6A3C6A60000 +9F +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000C6A8C6AAC6ABC6ACC6ADC6AEC6AFC6B2C6B3C6B5C6B6C6B7C6BBC6BCC6BD +C6BEC6BFC6C2C6C4C6C6C6C7C6C8C6C9C6CAC6CBC6CE00000000000000000000 +0000C6CFC6D1C6D2C6D3C6D5C6D6C6D7C6D8C6D9C6DAC6DBC6DEC6DFC6E2C6E3 +C6E4C6E5C6E6C6E7C6EAC6EBC6EDC6EEC6EFC6F1C6F200000000000000000000 +0000C6F3C6F4C6F5C6F6C6F7C6FAC6FBC6FCC6FEC6FFC700C701C702C703C706 +C707C709C70AC70BC70DC70EC70FC710C711C712C713C716C718C71AC71BC71C +C71DC71EC71FC722C723C725C726C727C729C72AC72BC72CC72DC72EC72FC732 +C734C736C738C739C73AC73BC73EC73FC741C742C743C745C746C747C748C749 +C74BC74EC750C759C75AC75BC75DC75EC75FC761C762C763C764C765C766C767 +C769C76AC76CC76DC76EC76FC770C771C772C773C776C777C779C77AC77BC77F +C780C781C782C786C78BC78CC78DC78FC792C793C795C799C79BC79CC79DC79E +C79FC7A2C7A7C7A8C7A9C7AAC7ABC7AEC7AFC7B1C7B2C7B3C7B5C7B6C7B70000 +A0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000C7B8C7B9C7BAC7BBC7BEC7C2C7C3C7C4C7C5C7C6C7C7C7CAC7CBC7CDC7CF +C7D1C7D2C7D3C7D4C7D5C7D6C7D7C7D9C7DAC7DBC7DC00000000000000000000 +0000C7DEC7DFC7E0C7E1C7E2C7E3C7E5C7E6C7E7C7E9C7EAC7EBC7EDC7EEC7EF +C7F0C7F1C7F2C7F3C7F4C7F5C7F6C7F7C7F8C7F9C7FA00000000000000000000 +0000C7FBC7FCC7FDC7FEC7FFC802C803C805C806C807C809C80BC80CC80DC80E +C80FC812C814C817C818C819C81AC81BC81EC81FC821C822C823C825C826C827 +C828C829C82AC82BC82EC830C832C833C834C835C836C837C839C83AC83BC83D +C83EC83FC841C842C843C844C845C846C847C84AC84BC84EC84FC850C851C852 +C853C855C856C857C858C859C85AC85BC85CC85DC85EC85FC860C861C862C863 +C864C865C866C867C868C869C86AC86BC86CC86DC86EC86FC872C873C875C876 +C877C879C87BC87CC87DC87EC87FC882C884C888C889C88AC88EC88FC890C891 +C892C893C895C896C897C898C899C89AC89BC89CC89EC8A0C8A2C8A3C8A40000 +A1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000C8A5C8A6C8A7C8A9C8AAC8ABC8ACC8ADC8AEC8AFC8B0C8B1C8B2C8B3C8B4 +C8B5C8B6C8B7C8B8C8B9C8BAC8BBC8BEC8BFC8C0C8C100000000000000000000 +0000C8C2C8C3C8C5C8C6C8C7C8C9C8CAC8CBC8CDC8CEC8CFC8D0C8D1C8D2C8D3 +C8D6C8D8C8DAC8DBC8DCC8DDC8DEC8DFC8E2C8E3C8E500000000000000000000 +0000C8E6C8E7C8E8C8E9C8EAC8EBC8ECC8EDC8EEC8EFC8F0C8F1C8F2C8F3C8F4 +C8F6C8F7C8F8C8F9C8FAC8FBC8FEC8FFC901C902C903C907C908C909C90AC90B +C90E30003001300200B72025202600A8300300AD20152225FF3C223C20182019 +201C201D3014301530083009300A300B300C300D300E300F3010301100B100D7 +00F7226022642265221E223400B0203220332103212BFFE0FFE1FFE526422640 +222022A52312220222072261225200A7203B2606260525CB25CF25CE25C725C6 +25A125A025B325B225BD25BC219221902191219321943013226A226B221A223D +221D2235222B222C2208220B2286228722822283222A222922272228FFE20000 +A2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000C910C912C913C914C915C916C917C919C91AC91BC91CC91DC91EC91FC920 +C921C922C923C924C925C926C927C928C929C92AC92B00000000000000000000 +0000C92DC92EC92FC930C931C932C933C935C936C937C938C939C93AC93BC93C +C93DC93EC93FC940C941C942C943C944C945C946C94700000000000000000000 +0000C948C949C94AC94BC94CC94DC94EC94FC952C953C955C956C957C959C95A +C95BC95CC95DC95EC95FC962C964C965C966C967C968C969C96AC96BC96DC96E +C96F21D221D42200220300B4FF5E02C702D802DD02DA02D900B802DB00A100BF +02D0222E2211220F00A42109203025C125C025B725B626642660266126652667 +2663229925C825A325D025D1259225A425A525A825A725A625A92668260F260E +261C261E00B62020202121952197219921962198266D2669266A266C327F321C +211633C7212233C233D8212120AC00AE00000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +A3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000C971C972C973C975C976C977C978C979C97AC97BC97DC97EC97FC980C981 +C982C983C984C985C986C987C98AC98BC98DC98EC98F00000000000000000000 +0000C991C992C993C994C995C996C997C99AC99CC99EC99FC9A0C9A1C9A2C9A3 +C9A4C9A5C9A6C9A7C9A8C9A9C9AAC9ABC9ACC9ADC9AE00000000000000000000 +0000C9AFC9B0C9B1C9B2C9B3C9B4C9B5C9B6C9B7C9B8C9B9C9BAC9BBC9BCC9BD +C9BEC9BFC9C2C9C3C9C5C9C6C9C9C9CBC9CCC9CDC9CEC9CFC9D2C9D4C9D7C9D8 +C9DBFF01FF02FF03FF04FF05FF06FF07FF08FF09FF0AFF0BFF0CFF0DFF0EFF0F +FF10FF11FF12FF13FF14FF15FF16FF17FF18FF19FF1AFF1BFF1CFF1DFF1EFF1F +FF20FF21FF22FF23FF24FF25FF26FF27FF28FF29FF2AFF2BFF2CFF2DFF2EFF2F +FF30FF31FF32FF33FF34FF35FF36FF37FF38FF39FF3AFF3BFFE6FF3DFF3EFF3F +FF40FF41FF42FF43FF44FF45FF46FF47FF48FF49FF4AFF4BFF4CFF4DFF4EFF4F +FF50FF51FF52FF53FF54FF55FF56FF57FF58FF59FF5AFF5BFF5CFF5DFFE30000 +A4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000C9DEC9DFC9E1C9E3C9E5C9E6C9E8C9E9C9EAC9EBC9EEC9F2C9F3C9F4C9F5 +C9F6C9F7C9FAC9FBC9FDC9FEC9FFCA01CA02CA03CA0400000000000000000000 +0000CA05CA06CA07CA0ACA0ECA0FCA10CA11CA12CA13CA15CA16CA17CA19CA1A +CA1BCA1CCA1DCA1ECA1FCA20CA21CA22CA23CA24CA2500000000000000000000 +0000CA26CA27CA28CA2ACA2BCA2CCA2DCA2ECA2FCA30CA31CA32CA33CA34CA35 +CA36CA37CA38CA39CA3ACA3BCA3CCA3DCA3ECA3FCA40CA41CA42CA43CA44CA45 +CA46313131323133313431353136313731383139313A313B313C313D313E313F +3140314131423143314431453146314731483149314A314B314C314D314E314F +3150315131523153315431553156315731583159315A315B315C315D315E315F +3160316131623163316431653166316731683169316A316B316C316D316E316F +3170317131723173317431753176317731783179317A317B317C317D317E317F +3180318131823183318431853186318731883189318A318B318C318D318E0000 +A5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000CA47CA48CA49CA4ACA4BCA4ECA4FCA51CA52CA53CA55CA56CA57CA58CA59 +CA5ACA5BCA5ECA62CA63CA64CA65CA66CA67CA69CA6A00000000000000000000 +0000CA6BCA6CCA6DCA6ECA6FCA70CA71CA72CA73CA74CA75CA76CA77CA78CA79 +CA7ACA7BCA7CCA7ECA7FCA80CA81CA82CA83CA85CA8600000000000000000000 +0000CA87CA88CA89CA8ACA8BCA8CCA8DCA8ECA8FCA90CA91CA92CA93CA94CA95 +CA96CA97CA99CA9ACA9BCA9CCA9DCA9ECA9FCAA0CAA1CAA2CAA3CAA4CAA5CAA6 +CAA7217021712172217321742175217621772178217900000000000000000000 +2160216121622163216421652166216721682169000000000000000000000000 +0000039103920393039403950396039703980399039A039B039C039D039E039F +03A003A103A303A403A503A603A703A803A90000000000000000000000000000 +000003B103B203B303B403B503B603B703B803B903BA03BB03BC03BD03BE03BF +03C003C103C303C403C503C603C703C803C90000000000000000000000000000 +A6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000CAA8CAA9CAAACAABCAACCAADCAAECAAFCAB0CAB1CAB2CAB3CAB4CAB5CAB6 +CAB7CAB8CAB9CABACABBCABECABFCAC1CAC2CAC3CAC500000000000000000000 +0000CAC6CAC7CAC8CAC9CACACACBCACECAD0CAD2CAD4CAD5CAD6CAD7CADACADB +CADCCADDCADECADFCAE1CAE2CAE3CAE4CAE5CAE6CAE700000000000000000000 +0000CAE8CAE9CAEACAEBCAEDCAEECAEFCAF0CAF1CAF2CAF3CAF5CAF6CAF7CAF8 +CAF9CAFACAFBCAFCCAFDCAFECAFFCB00CB01CB02CB03CB04CB05CB06CB07CB09 +CB0A25002502250C251025182514251C252C25242534253C25012503250F2513 +251B251725232533252B253B254B2520252F25282537253F251D253025252538 +254225122511251A251925162515250E250D251E251F25212522252625272529 +252A252D252E25312532253525362539253A253D253E25402541254325442545 +2546254725482549254A00000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +A7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000CB0BCB0CCB0DCB0ECB0FCB11CB12CB13CB15CB16CB17CB19CB1ACB1BCB1C +CB1DCB1ECB1FCB22CB23CB24CB25CB26CB27CB28CB2900000000000000000000 +0000CB2ACB2BCB2CCB2DCB2ECB2FCB30CB31CB32CB33CB34CB35CB36CB37CB38 +CB39CB3ACB3BCB3CCB3DCB3ECB3FCB40CB42CB43CB4400000000000000000000 +0000CB45CB46CB47CB4ACB4BCB4DCB4ECB4FCB51CB52CB53CB54CB55CB56CB57 +CB5ACB5BCB5CCB5ECB5FCB60CB61CB62CB63CB65CB66CB67CB68CB69CB6ACB6B +CB6C3395339633972113339833C433A333A433A533A63399339A339B339C339D +339E339F33A033A133A233CA338D338E338F33CF3388338933C833A733A833B0 +33B133B233B333B433B533B633B733B833B93380338133823383338433BA33BB +33BC33BD33BE33BF33903391339233933394212633C033C1338A338B338C33D6 +33C533AD33AE33AF33DB33A933AA33AB33AC33DD33D033D333C333C933DC33C6 +0000000000000000000000000000000000000000000000000000000000000000 +A8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000CB6DCB6ECB6FCB70CB71CB72CB73CB74CB75CB76CB77CB7ACB7BCB7CCB7D +CB7ECB7FCB80CB81CB82CB83CB84CB85CB86CB87CB8800000000000000000000 +0000CB89CB8ACB8BCB8CCB8DCB8ECB8FCB90CB91CB92CB93CB94CB95CB96CB97 +CB98CB99CB9ACB9BCB9DCB9ECB9FCBA0CBA1CBA2CBA300000000000000000000 +0000CBA4CBA5CBA6CBA7CBA8CBA9CBAACBABCBACCBADCBAECBAFCBB0CBB1CBB2 +CBB3CBB4CBB5CBB6CBB7CBB9CBBACBBBCBBCCBBDCBBECBBFCBC0CBC1CBC2CBC3 +CBC400C600D000AA0126000001320000013F014100D8015200BA00DE0166014A +00003260326132623263326432653266326732683269326A326B326C326D326E +326F3270327132723273327432753276327732783279327A327B24D024D124D2 +24D324D424D524D624D724D824D924DA24DB24DC24DD24DE24DF24E024E124E2 +24E324E424E524E624E724E824E9246024612462246324642465246624672468 +2469246A246B246C246D246E00BD2153215400BC00BE215B215C215D215E0000 +A9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000CBC5CBC6CBC7CBC8CBC9CBCACBCBCBCCCBCDCBCECBCFCBD0CBD1CBD2CBD3 +CBD5CBD6CBD7CBD8CBD9CBDACBDBCBDCCBDDCBDECBDF00000000000000000000 +0000CBE0CBE1CBE2CBE3CBE5CBE6CBE8CBEACBEBCBECCBEDCBEECBEFCBF0CBF1 +CBF2CBF3CBF4CBF5CBF6CBF7CBF8CBF9CBFACBFBCBFC00000000000000000000 +0000CBFDCBFECBFFCC00CC01CC02CC03CC04CC05CC06CC07CC08CC09CC0ACC0B +CC0ECC0FCC11CC12CC13CC15CC16CC17CC18CC19CC1ACC1BCC1ECC1FCC20CC23 +CC2400E6011100F001270131013301380140014200F8015300DF00FE0167014B +01493200320132023203320432053206320732083209320A320B320C320D320E +320F3210321132123213321432153216321732183219321A321B249C249D249E +249F24A024A124A224A324A424A524A624A724A824A924AA24AB24AC24AD24AE +24AF24B024B124B224B324B424B5247424752476247724782479247A247B247C +247D247E247F24802481248200B900B200B32074207F20812082208320840000 +AA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000CC25CC26CC2ACC2BCC2DCC2FCC31CC32CC33CC34CC35CC36CC37CC3ACC3F +CC40CC41CC42CC43CC46CC47CC49CC4ACC4BCC4DCC4E00000000000000000000 +0000CC4FCC50CC51CC52CC53CC56CC5ACC5BCC5CCC5DCC5ECC5FCC61CC62CC63 +CC65CC67CC69CC6ACC6BCC6CCC6DCC6ECC6FCC71CC7200000000000000000000 +0000CC73CC74CC76CC77CC78CC79CC7ACC7BCC7CCC7DCC7ECC7FCC80CC81CC82 +CC83CC84CC85CC86CC87CC88CC89CC8ACC8BCC8CCC8DCC8ECC8FCC90CC91CC92 +CC93304130423043304430453046304730483049304A304B304C304D304E304F +3050305130523053305430553056305730583059305A305B305C305D305E305F +3060306130623063306430653066306730683069306A306B306C306D306E306F +3070307130723073307430753076307730783079307A307B307C307D307E307F +3080308130823083308430853086308730883089308A308B308C308D308E308F +3090309130923093000000000000000000000000000000000000000000000000 +AB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000CC94CC95CC96CC97CC9ACC9BCC9DCC9ECC9FCCA1CCA2CCA3CCA4CCA5CCA6 +CCA7CCAACCAECCAFCCB0CCB1CCB2CCB3CCB6CCB7CCB900000000000000000000 +0000CCBACCBBCCBDCCBECCBFCCC0CCC1CCC2CCC3CCC6CCC8CCCACCCBCCCCCCCD +CCCECCCFCCD1CCD2CCD3CCD5CCD6CCD7CCD8CCD9CCDA00000000000000000000 +0000CCDBCCDCCCDDCCDECCDFCCE0CCE1CCE2CCE3CCE5CCE6CCE7CCE8CCE9CCEA +CCEBCCEDCCEECCEFCCF1CCF2CCF3CCF4CCF5CCF6CCF7CCF8CCF9CCFACCFBCCFC +CCFD30A130A230A330A430A530A630A730A830A930AA30AB30AC30AD30AE30AF +30B030B130B230B330B430B530B630B730B830B930BA30BB30BC30BD30BE30BF +30C030C130C230C330C430C530C630C730C830C930CA30CB30CC30CD30CE30CF +30D030D130D230D330D430D530D630D730D830D930DA30DB30DC30DD30DE30DF +30E030E130E230E330E430E530E630E730E830E930EA30EB30EC30ED30EE30EF +30F030F130F230F330F430F530F6000000000000000000000000000000000000 +AC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000CCFECCFFCD00CD02CD03CD04CD05CD06CD07CD0ACD0BCD0DCD0ECD0FCD11 +CD12CD13CD14CD15CD16CD17CD1ACD1CCD1ECD1FCD2000000000000000000000 +0000CD21CD22CD23CD25CD26CD27CD29CD2ACD2BCD2DCD2ECD2FCD30CD31CD32 +CD33CD34CD35CD36CD37CD38CD3ACD3BCD3CCD3DCD3E00000000000000000000 +0000CD3FCD40CD41CD42CD43CD44CD45CD46CD47CD48CD49CD4ACD4BCD4CCD4D +CD4ECD4FCD50CD51CD52CD53CD54CD55CD56CD57CD58CD59CD5ACD5BCD5DCD5E +CD5F04100411041204130414041504010416041704180419041A041B041C041D +041E041F0420042104220423042404250426042704280429042A042B042C042D +042E042F00000000000000000000000000000000000000000000000000000000 +000004300431043204330434043504510436043704380439043A043B043C043D +043E043F0440044104420443044404450446044704480449044A044B044C044D +044E044F00000000000000000000000000000000000000000000000000000000 +AD +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000CD61CD62CD63CD65CD66CD67CD68CD69CD6ACD6BCD6ECD70CD72CD73CD74 +CD75CD76CD77CD79CD7ACD7BCD7CCD7DCD7ECD7FCD8000000000000000000000 +0000CD81CD82CD83CD84CD85CD86CD87CD89CD8ACD8BCD8CCD8DCD8ECD8FCD90 +CD91CD92CD93CD96CD97CD99CD9ACD9BCD9DCD9ECD9F00000000000000000000 +0000CDA0CDA1CDA2CDA3CDA6CDA8CDAACDABCDACCDADCDAECDAFCDB1CDB2CDB3 +CDB4CDB5CDB6CDB7CDB8CDB9CDBACDBBCDBCCDBDCDBECDBFCDC0CDC1CDC2CDC3 +CDC5000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +AE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000CDC6CDC7CDC8CDC9CDCACDCBCDCDCDCECDCFCDD1CDD2CDD3CDD4CDD5CDD6 +CDD7CDD8CDD9CDDACDDBCDDCCDDDCDDECDDFCDE0CDE100000000000000000000 +0000CDE2CDE3CDE4CDE5CDE6CDE7CDE9CDEACDEBCDEDCDEECDEFCDF1CDF2CDF3 +CDF4CDF5CDF6CDF7CDFACDFCCDFECDFFCE00CE01CE0200000000000000000000 +0000CE03CE05CE06CE07CE09CE0ACE0BCE0DCE0ECE0FCE10CE11CE12CE13CE15 +CE16CE17CE18CE1ACE1BCE1CCE1DCE1ECE1FCE22CE23CE25CE26CE27CE29CE2A +CE2B000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +AF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000CE2CCE2DCE2ECE2FCE32CE34CE36CE37CE38CE39CE3ACE3BCE3CCE3DCE3E +CE3FCE40CE41CE42CE43CE44CE45CE46CE47CE48CE4900000000000000000000 +0000CE4ACE4BCE4CCE4DCE4ECE4FCE50CE51CE52CE53CE54CE55CE56CE57CE5A +CE5BCE5DCE5ECE62CE63CE64CE65CE66CE67CE6ACE6C00000000000000000000 +0000CE6ECE6FCE70CE71CE72CE73CE76CE77CE79CE7ACE7BCE7DCE7ECE7FCE80 +CE81CE82CE83CE86CE88CE8ACE8BCE8CCE8DCE8ECE8FCE92CE93CE95CE96CE97 +CE99000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +B0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000CE9ACE9BCE9CCE9DCE9ECE9FCEA2CEA6CEA7CEA8CEA9CEAACEABCEAECEAF +CEB0CEB1CEB2CEB3CEB4CEB5CEB6CEB7CEB8CEB9CEBA00000000000000000000 +0000CEBBCEBCCEBDCEBECEBFCEC0CEC2CEC3CEC4CEC5CEC6CEC7CEC8CEC9CECA +CECBCECCCECDCECECECFCED0CED1CED2CED3CED4CED500000000000000000000 +0000CED6CED7CED8CED9CEDACEDBCEDCCEDDCEDECEDFCEE0CEE1CEE2CEE3CEE6 +CEE7CEE9CEEACEEDCEEECEEFCEF0CEF1CEF2CEF3CEF6CEFACEFBCEFCCEFDCEFE +CEFFAC00AC01AC04AC07AC08AC09AC0AAC10AC11AC12AC13AC14AC15AC16AC17 +AC19AC1AAC1BAC1CAC1DAC20AC24AC2CAC2DAC2FAC30AC31AC38AC39AC3CAC40 +AC4BAC4DAC54AC58AC5CAC70AC71AC74AC77AC78AC7AAC80AC81AC83AC84AC85 +AC86AC89AC8AAC8BAC8CAC90AC94AC9CAC9DAC9FACA0ACA1ACA8ACA9ACAAACAC +ACAFACB0ACB8ACB9ACBBACBCACBDACC1ACC4ACC8ACCCACD5ACD7ACE0ACE1ACE4 +ACE7ACE8ACEAACECACEFACF0ACF1ACF3ACF5ACF6ACFCACFDAD00AD04AD060000 +B1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000CF02CF03CF05CF06CF07CF09CF0ACF0BCF0CCF0DCF0ECF0FCF12CF14CF16 +CF17CF18CF19CF1ACF1BCF1DCF1ECF1FCF21CF22CF2300000000000000000000 +0000CF25CF26CF27CF28CF29CF2ACF2BCF2ECF32CF33CF34CF35CF36CF37CF39 +CF3ACF3BCF3CCF3DCF3ECF3FCF40CF41CF42CF43CF4400000000000000000000 +0000CF45CF46CF47CF48CF49CF4ACF4BCF4CCF4DCF4ECF4FCF50CF51CF52CF53 +CF56CF57CF59CF5ACF5BCF5DCF5ECF5FCF60CF61CF62CF63CF66CF68CF6ACF6B +CF6CAD0CAD0DAD0FAD11AD18AD1CAD20AD29AD2CAD2DAD34AD35AD38AD3CAD44 +AD45AD47AD49AD50AD54AD58AD61AD63AD6CAD6DAD70AD73AD74AD75AD76AD7B +AD7CAD7DAD7FAD81AD82AD88AD89AD8CAD90AD9CAD9DADA4ADB7ADC0ADC1ADC4 +ADC8ADD0ADD1ADD3ADDCADE0ADE4ADF8ADF9ADFCADFFAE00AE01AE08AE09AE0B +AE0DAE14AE30AE31AE34AE37AE38AE3AAE40AE41AE43AE45AE46AE4AAE4CAE4D +AE4EAE50AE54AE56AE5CAE5DAE5FAE60AE61AE65AE68AE69AE6CAE70AE780000 +B2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000CF6DCF6ECF6FCF72CF73CF75CF76CF77CF79CF7ACF7BCF7CCF7DCF7ECF7F +CF81CF82CF83CF84CF86CF87CF88CF89CF8ACF8BCF8D00000000000000000000 +0000CF8ECF8FCF90CF91CF92CF93CF94CF95CF96CF97CF98CF99CF9ACF9BCF9C +CF9DCF9ECF9FCFA0CFA2CFA3CFA4CFA5CFA6CFA7CFA900000000000000000000 +0000CFAACFABCFACCFADCFAECFAFCFB1CFB2CFB3CFB4CFB5CFB6CFB7CFB8CFB9 +CFBACFBBCFBCCFBDCFBECFBFCFC0CFC1CFC2CFC3CFC5CFC6CFC7CFC8CFC9CFCA +CFCBAE79AE7BAE7CAE7DAE84AE85AE8CAEBCAEBDAEBEAEC0AEC4AECCAECDAECF +AED0AED1AED8AED9AEDCAEE8AEEBAEEDAEF4AEF8AEFCAF07AF08AF0DAF10AF2C +AF2DAF30AF32AF34AF3CAF3DAF3FAF41AF42AF43AF48AF49AF50AF5CAF5DAF64 +AF65AF79AF80AF84AF88AF90AF91AF95AF9CAFB8AFB9AFBCAFC0AFC7AFC8AFC9 +AFCBAFCDAFCEAFD4AFDCAFE8AFE9AFF0AFF1AFF4AFF8B000B001B004B00CB010 +B014B01CB01DB028B044B045B048B04AB04CB04EB053B054B055B057B0590000 +B3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000CFCCCFCDCFCECFCFCFD0CFD1CFD2CFD3CFD4CFD5CFD6CFD7CFD8CFD9CFDA +CFDBCFDCCFDDCFDECFDFCFE2CFE3CFE5CFE6CFE7CFE900000000000000000000 +0000CFEACFEBCFECCFEDCFEECFEFCFF2CFF4CFF6CFF7CFF8CFF9CFFACFFBCFFD +CFFECFFFD001D002D003D005D006D007D008D009D00A00000000000000000000 +0000D00BD00CD00DD00ED00FD010D012D013D014D015D016D017D019D01AD01B +D01CD01DD01ED01FD020D021D022D023D024D025D026D027D028D029D02AD02B +D02CB05DB07CB07DB080B084B08CB08DB08FB091B098B099B09AB09CB09FB0A0 +B0A1B0A2B0A8B0A9B0ABB0ACB0ADB0AEB0AFB0B1B0B3B0B4B0B5B0B8B0BCB0C4 +B0C5B0C7B0C8B0C9B0D0B0D1B0D4B0D8B0E0B0E5B108B109B10BB10CB110B112 +B113B118B119B11BB11CB11DB123B124B125B128B12CB134B135B137B138B139 +B140B141B144B148B150B151B154B155B158B15CB160B178B179B17CB180B182 +B188B189B18BB18DB192B193B194B198B19CB1A8B1CCB1D0B1D4B1DCB1DD0000 +B4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D02ED02FD030D031D032D033D036D037D039D03AD03BD03DD03ED03FD040 +D041D042D043D046D048D04AD04BD04CD04DD04ED04F00000000000000000000 +0000D051D052D053D055D056D057D059D05AD05BD05CD05DD05ED05FD061D062 +D063D064D065D066D067D068D069D06AD06BD06ED06F00000000000000000000 +0000D071D072D073D075D076D077D078D079D07AD07BD07ED07FD080D082D083 +D084D085D086D087D088D089D08AD08BD08CD08DD08ED08FD090D091D092D093 +D094B1DFB1E8B1E9B1ECB1F0B1F9B1FBB1FDB204B205B208B20BB20CB214B215 +B217B219B220B234B23CB258B25CB260B268B269B274B275B27CB284B285B289 +B290B291B294B298B299B29AB2A0B2A1B2A3B2A5B2A6B2AAB2ACB2B0B2B4B2C8 +B2C9B2CCB2D0B2D2B2D8B2D9B2DBB2DDB2E2B2E4B2E5B2E6B2E8B2EBB2ECB2ED +B2EEB2EFB2F3B2F4B2F5B2F7B2F8B2F9B2FAB2FBB2FFB300B301B304B308B310 +B311B313B314B315B31CB354B355B356B358B35BB35CB35EB35FB364B3650000 +B5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D095D096D097D098D099D09AD09BD09CD09DD09ED09FD0A0D0A1D0A2D0A3 +D0A6D0A7D0A9D0AAD0ABD0ADD0AED0AFD0B0D0B1D0B200000000000000000000 +0000D0B3D0B6D0B8D0BAD0BBD0BCD0BDD0BED0BFD0C2D0C3D0C5D0C6D0C7D0CA +D0CBD0CCD0CDD0CED0CFD0D2D0D6D0D7D0D8D0D9D0DA00000000000000000000 +0000D0DBD0DED0DFD0E1D0E2D0E3D0E5D0E6D0E7D0E8D0E9D0EAD0EBD0EED0F2 +D0F3D0F4D0F5D0F6D0F7D0F9D0FAD0FBD0FCD0FDD0FED0FFD100D101D102D103 +D104B367B369B36BB36EB370B371B374B378B380B381B383B384B385B38CB390 +B394B3A0B3A1B3A8B3ACB3C4B3C5B3C8B3CBB3CCB3CEB3D0B3D4B3D5B3D7B3D9 +B3DBB3DDB3E0B3E4B3E8B3FCB410B418B41CB420B428B429B42BB434B450B451 +B454B458B460B461B463B465B46CB480B488B49DB4A4B4A8B4ACB4B5B4B7B4B9 +B4C0B4C4B4C8B4D0B4D5B4DCB4DDB4E0B4E3B4E4B4E6B4ECB4EDB4EFB4F1B4F8 +B514B515B518B51BB51CB524B525B527B528B529B52AB530B531B534B5380000 +B6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D105D106D107D108D109D10AD10BD10CD10ED10FD110D111D112D113D114 +D115D116D117D118D119D11AD11BD11CD11DD11ED11F00000000000000000000 +0000D120D121D122D123D124D125D126D127D128D129D12AD12BD12CD12DD12E +D12FD132D133D135D136D137D139D13BD13CD13DD13E00000000000000000000 +0000D13FD142D146D147D148D149D14AD14BD14ED14FD151D152D153D155D156 +D157D158D159D15AD15BD15ED160D162D163D164D165D166D167D169D16AD16B +D16DB540B541B543B544B545B54BB54CB54DB550B554B55CB55DB55FB560B561 +B5A0B5A1B5A4B5A8B5AAB5ABB5B0B5B1B5B3B5B4B5B5B5BBB5BCB5BDB5C0B5C4 +B5CCB5CDB5CFB5D0B5D1B5D8B5ECB610B611B614B618B625B62CB634B648B664 +B668B69CB69DB6A0B6A4B6ABB6ACB6B1B6D4B6F0B6F4B6F8B700B701B705B728 +B729B72CB72FB730B738B739B73BB744B748B74CB754B755B760B764B768B770 +B771B773B775B77CB77DB780B784B78CB78DB78FB790B791B792B796B7970000 +B7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D16ED16FD170D171D172D173D174D175D176D177D178D179D17AD17BD17D +D17ED17FD180D181D182D183D185D186D187D189D18A00000000000000000000 +0000D18BD18CD18DD18ED18FD190D191D192D193D194D195D196D197D198D199 +D19AD19BD19CD19DD19ED19FD1A2D1A3D1A5D1A6D1A700000000000000000000 +0000D1A9D1AAD1ABD1ACD1ADD1AED1AFD1B2D1B4D1B6D1B7D1B8D1B9D1BBD1BD +D1BED1BFD1C1D1C2D1C3D1C4D1C5D1C6D1C7D1C8D1C9D1CAD1CBD1CCD1CDD1CE +D1CFB798B799B79CB7A0B7A8B7A9B7ABB7ACB7ADB7B4B7B5B7B8B7C7B7C9B7EC +B7EDB7F0B7F4B7FCB7FDB7FFB800B801B807B808B809B80CB810B818B819B81B +B81DB824B825B828B82CB834B835B837B838B839B840B844B851B853B85CB85D +B860B864B86CB86DB86FB871B878B87CB88DB8A8B8B0B8B4B8B8B8C0B8C1B8C3 +B8C5B8CCB8D0B8D4B8DDB8DFB8E1B8E8B8E9B8ECB8F0B8F8B8F9B8FBB8FDB904 +B918B920B93CB93DB940B944B94CB94FB951B958B959B95CB960B968B9690000 +B8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D1D0D1D1D1D2D1D3D1D4D1D5D1D6D1D7D1D9D1DAD1DBD1DCD1DDD1DED1DF +D1E0D1E1D1E2D1E3D1E4D1E5D1E6D1E7D1E8D1E9D1EA00000000000000000000 +0000D1EBD1ECD1EDD1EED1EFD1F0D1F1D1F2D1F3D1F5D1F6D1F7D1F9D1FAD1FB +D1FCD1FDD1FED1FFD200D201D202D203D204D205D20600000000000000000000 +0000D208D20AD20BD20CD20DD20ED20FD211D212D213D214D215D216D217D218 +D219D21AD21BD21CD21DD21ED21FD220D221D222D223D224D225D226D227D228 +D229B96BB96DB974B975B978B97CB984B985B987B989B98AB98DB98EB9ACB9AD +B9B0B9B4B9BCB9BDB9BFB9C1B9C8B9C9B9CCB9CEB9CFB9D0B9D1B9D2B9D8B9D9 +B9DBB9DDB9DEB9E1B9E3B9E4B9E5B9E8B9ECB9F4B9F5B9F7B9F8B9F9B9FABA00 +BA01BA08BA15BA38BA39BA3CBA40BA42BA48BA49BA4BBA4DBA4EBA53BA54BA55 +BA58BA5CBA64BA65BA67BA68BA69BA70BA71BA74BA78BA83BA84BA85BA87BA8C +BAA8BAA9BAABBAACBAB0BAB2BAB8BAB9BABBBABDBAC4BAC8BAD8BAD9BAFC0000 +B9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D22AD22BD22ED22FD231D232D233D235D236D237D238D239D23AD23BD23E +D240D242D243D244D245D246D247D249D24AD24BD24C00000000000000000000 +0000D24DD24ED24FD250D251D252D253D254D255D256D257D258D259D25AD25B +D25DD25ED25FD260D261D262D263D265D266D267D26800000000000000000000 +0000D269D26AD26BD26CD26DD26ED26FD270D271D272D273D274D275D276D277 +D278D279D27AD27BD27CD27DD27ED27FD282D283D285D286D287D289D28AD28B +D28CBB00BB04BB0DBB0FBB11BB18BB1CBB20BB29BB2BBB34BB35BB36BB38BB3B +BB3CBB3DBB3EBB44BB45BB47BB49BB4DBB4FBB50BB54BB58BB61BB63BB6CBB88 +BB8CBB90BBA4BBA8BBACBBB4BBB7BBC0BBC4BBC8BBD0BBD3BBF8BBF9BBFCBBFF +BC00BC02BC08BC09BC0BBC0CBC0DBC0FBC11BC14BC15BC16BC17BC18BC1BBC1C +BC1DBC1EBC1FBC24BC25BC27BC29BC2DBC30BC31BC34BC38BC40BC41BC43BC44 +BC45BC49BC4CBC4DBC50BC5DBC84BC85BC88BC8BBC8CBC8EBC94BC95BC970000 +BA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D28DD28ED28FD292D293D294D296D297D298D299D29AD29BD29DD29ED29F +D2A1D2A2D2A3D2A5D2A6D2A7D2A8D2A9D2AAD2ABD2AD00000000000000000000 +0000D2AED2AFD2B0D2B2D2B3D2B4D2B5D2B6D2B7D2BAD2BBD2BDD2BED2C1D2C3 +D2C4D2C5D2C6D2C7D2CAD2CCD2CDD2CED2CFD2D0D2D100000000000000000000 +0000D2D2D2D3D2D5D2D6D2D7D2D9D2DAD2DBD2DDD2DED2DFD2E0D2E1D2E2D2E3 +D2E6D2E7D2E8D2E9D2EAD2EBD2ECD2EDD2EED2EFD2F2D2F3D2F5D2F6D2F7D2F9 +D2FABC99BC9ABCA0BCA1BCA4BCA7BCA8BCB0BCB1BCB3BCB4BCB5BCBCBCBDBCC0 +BCC4BCCDBCCFBCD0BCD1BCD5BCD8BCDCBCF4BCF5BCF6BCF8BCFCBD04BD05BD07 +BD09BD10BD14BD24BD2CBD40BD48BD49BD4CBD50BD58BD59BD64BD68BD80BD81 +BD84BD87BD88BD89BD8ABD90BD91BD93BD95BD99BD9ABD9CBDA4BDB0BDB8BDD4 +BDD5BDD8BDDCBDE9BDF0BDF4BDF8BE00BE03BE05BE0CBE0DBE10BE14BE1CBE1D +BE1FBE44BE45BE48BE4CBE4EBE54BE55BE57BE59BE5ABE5BBE60BE61BE640000 +BB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D2FBD2FCD2FDD2FED2FFD302D304D306D307D308D309D30AD30BD30FD311 +D312D313D315D317D318D319D31AD31BD31ED322D32300000000000000000000 +0000D324D326D327D32AD32BD32DD32ED32FD331D332D333D334D335D336D337 +D33AD33ED33FD340D341D342D343D346D347D348D34900000000000000000000 +0000D34AD34BD34CD34DD34ED34FD350D351D352D353D354D355D356D357D358 +D359D35AD35BD35CD35DD35ED35FD360D361D362D363D364D365D366D367D368 +D369BE68BE6ABE70BE71BE73BE74BE75BE7BBE7CBE7DBE80BE84BE8CBE8DBE8F +BE90BE91BE98BE99BEA8BED0BED1BED4BED7BED8BEE0BEE3BEE4BEE5BEECBF01 +BF08BF09BF18BF19BF1BBF1CBF1DBF40BF41BF44BF48BF50BF51BF55BF94BFB0 +BFC5BFCCBFCDBFD0BFD4BFDCBFDFBFE1C03CC051C058C05CC060C068C069C090 +C091C094C098C0A0C0A1C0A3C0A5C0ACC0ADC0AFC0B0C0B3C0B4C0B5C0B6C0BC +C0BDC0BFC0C0C0C1C0C5C0C8C0C9C0CCC0D0C0D8C0D9C0DBC0DCC0DDC0E40000 +BC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D36AD36BD36CD36DD36ED36FD370D371D372D373D374D375D376D377D378 +D379D37AD37BD37ED37FD381D382D383D385D386D38700000000000000000000 +0000D388D389D38AD38BD38ED392D393D394D395D396D397D39AD39BD39DD39E +D39FD3A1D3A2D3A3D3A4D3A5D3A6D3A7D3AAD3ACD3AE00000000000000000000 +0000D3AFD3B0D3B1D3B2D3B3D3B5D3B6D3B7D3B9D3BAD3BBD3BDD3BED3BFD3C0 +D3C1D3C2D3C3D3C6D3C7D3CAD3CBD3CCD3CDD3CED3CFD3D1D3D2D3D3D3D4D3D5 +D3D6C0E5C0E8C0ECC0F4C0F5C0F7C0F9C100C104C108C110C115C11CC11DC11E +C11FC120C123C124C126C127C12CC12DC12FC130C131C136C138C139C13CC140 +C148C149C14BC14CC14DC154C155C158C15CC164C165C167C168C169C170C174 +C178C185C18CC18DC18EC190C194C196C19CC19DC19FC1A1C1A5C1A8C1A9C1AC +C1B0C1BDC1C4C1C8C1CCC1D4C1D7C1D8C1E0C1E4C1E8C1F0C1F1C1F3C1FCC1FD +C200C204C20CC20DC20FC211C218C219C21CC21FC220C228C229C22BC22D0000 +BD +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D3D7D3D9D3DAD3DBD3DCD3DDD3DED3DFD3E0D3E2D3E4D3E5D3E6D3E7D3E8 +D3E9D3EAD3EBD3EED3EFD3F1D3F2D3F3D3F5D3F6D3F700000000000000000000 +0000D3F8D3F9D3FAD3FBD3FED400D402D403D404D405D406D407D409D40AD40B +D40CD40DD40ED40FD410D411D412D413D414D415D41600000000000000000000 +0000D417D418D419D41AD41BD41CD41ED41FD420D421D422D423D424D425D426 +D427D428D429D42AD42BD42CD42DD42ED42FD430D431D432D433D434D435D436 +D437C22FC231C232C234C248C250C251C254C258C260C265C26CC26DC270C274 +C27CC27DC27FC281C288C289C290C298C29BC29DC2A4C2A5C2A8C2ACC2ADC2B4 +C2B5C2B7C2B9C2DCC2DDC2E0C2E3C2E4C2EBC2ECC2EDC2EFC2F1C2F6C2F8C2F9 +C2FBC2FCC300C308C309C30CC30DC313C314C315C318C31CC324C325C328C329 +C345C368C369C36CC370C372C378C379C37CC37DC384C388C38CC3C0C3D8C3D9 +C3DCC3DFC3E0C3E2C3E8C3E9C3EDC3F4C3F5C3F8C408C410C424C42CC4300000 +BE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D438D439D43AD43BD43CD43DD43ED43FD441D442D443D445D446D447D448 +D449D44AD44BD44CD44DD44ED44FD450D451D452D45300000000000000000000 +0000D454D455D456D457D458D459D45AD45BD45DD45ED45FD461D462D463D465 +D466D467D468D469D46AD46BD46CD46ED470D471D47200000000000000000000 +0000D473D474D475D476D477D47AD47BD47DD47ED481D483D484D485D486D487 +D48AD48CD48ED48FD490D491D492D493D495D496D497D498D499D49AD49BD49C +D49DC434C43CC43DC448C464C465C468C46CC474C475C479C480C494C49CC4B8 +C4BCC4E9C4F0C4F1C4F4C4F8C4FAC4FFC500C501C50CC510C514C51CC528C529 +C52CC530C538C539C53BC53DC544C545C548C549C54AC54CC54DC54EC553C554 +C555C557C558C559C55DC55EC560C561C564C568C570C571C573C574C575C57C +C57DC580C584C587C58CC58DC58FC591C595C597C598C59CC5A0C5A9C5B4C5B5 +C5B8C5B9C5BBC5BCC5BDC5BEC5C4C5C5C5C6C5C7C5C8C5C9C5CAC5CCC5CE0000 +BF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D49ED49FD4A0D4A1D4A2D4A3D4A4D4A5D4A6D4A7D4A8D4AAD4ABD4ACD4AD +D4AED4AFD4B0D4B1D4B2D4B3D4B4D4B5D4B6D4B7D4B800000000000000000000 +0000D4B9D4BAD4BBD4BCD4BDD4BED4BFD4C0D4C1D4C2D4C3D4C4D4C5D4C6D4C7 +D4C8D4C9D4CAD4CBD4CDD4CED4CFD4D1D4D2D4D3D4D500000000000000000000 +0000D4D6D4D7D4D8D4D9D4DAD4DBD4DDD4DED4E0D4E1D4E2D4E3D4E4D4E5D4E6 +D4E7D4E9D4EAD4EBD4EDD4EED4EFD4F1D4F2D4F3D4F4D4F5D4F6D4F7D4F9D4FA +D4FCC5D0C5D1C5D4C5D8C5E0C5E1C5E3C5E5C5ECC5EDC5EEC5F0C5F4C5F6C5F7 +C5FCC5FDC5FEC5FFC600C601C605C606C607C608C60CC610C618C619C61BC61C +C624C625C628C62CC62DC62EC630C633C634C635C637C639C63BC640C641C644 +C648C650C651C653C654C655C65CC65DC660C66CC66FC671C678C679C67CC680 +C688C689C68BC68DC694C695C698C69CC6A4C6A5C6A7C6A9C6B0C6B1C6B4C6B8 +C6B9C6BAC6C0C6C1C6C3C6C5C6CCC6CDC6D0C6D4C6DCC6DDC6E0C6E1C6E80000 +C0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D4FED4FFD500D501D502D503D505D506D507D509D50AD50BD50DD50ED50F +D510D511D512D513D516D518D519D51AD51BD51CD51D00000000000000000000 +0000D51ED51FD520D521D522D523D524D525D526D527D528D529D52AD52BD52C +D52DD52ED52FD530D531D532D533D534D535D536D53700000000000000000000 +0000D538D539D53AD53BD53ED53FD541D542D543D545D546D547D548D549D54A +D54BD54ED550D552D553D554D555D556D557D55AD55BD55DD55ED55FD561D562 +D563C6E9C6ECC6F0C6F8C6F9C6FDC704C705C708C70CC714C715C717C719C720 +C721C724C728C730C731C733C735C737C73CC73DC740C744C74AC74CC74DC74F +C751C752C753C754C755C756C757C758C75CC760C768C76BC774C775C778C77C +C77DC77EC783C784C785C787C788C789C78AC78EC790C791C794C796C797C798 +C79AC7A0C7A1C7A3C7A4C7A5C7A6C7ACC7ADC7B0C7B4C7BCC7BDC7BFC7C0C7C1 +C7C8C7C9C7CCC7CEC7D0C7D8C7DDC7E4C7E8C7ECC800C801C804C808C80A0000 +C1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D564D566D567D56AD56CD56ED56FD570D571D572D573D576D577D579D57A +D57BD57DD57ED57FD580D581D582D583D586D58AD58B00000000000000000000 +0000D58CD58DD58ED58FD591D592D593D594D595D596D597D598D599D59AD59B +D59CD59DD59ED59FD5A0D5A1D5A2D5A3D5A4D5A6D5A700000000000000000000 +0000D5A8D5A9D5AAD5ABD5ACD5ADD5AED5AFD5B0D5B1D5B2D5B3D5B4D5B5D5B6 +D5B7D5B8D5B9D5BAD5BBD5BCD5BDD5BED5BFD5C0D5C1D5C2D5C3D5C4D5C5D5C6 +D5C7C810C811C813C815C816C81CC81DC820C824C82CC82DC82FC831C838C83C +C840C848C849C84CC84DC854C870C871C874C878C87AC880C881C883C885C886 +C887C88BC88CC88DC894C89DC89FC8A1C8A8C8BCC8BDC8C4C8C8C8CCC8D4C8D5 +C8D7C8D9C8E0C8E1C8E4C8F5C8FCC8FDC900C904C905C906C90CC90DC90FC911 +C918C92CC934C950C951C954C958C960C961C963C96CC970C974C97CC988C989 +C98CC990C998C999C99BC99DC9C0C9C1C9C4C9C7C9C8C9CAC9D0C9D1C9D30000 +C2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D5CAD5CBD5CDD5CED5CFD5D1D5D3D5D4D5D5D5D6D5D7D5DAD5DCD5DED5DF +D5E0D5E1D5E2D5E3D5E6D5E7D5E9D5EAD5EBD5EDD5EE00000000000000000000 +0000D5EFD5F0D5F1D5F2D5F3D5F6D5F8D5FAD5FBD5FCD5FDD5FED5FFD602D603 +D605D606D607D609D60AD60BD60CD60DD60ED60FD61200000000000000000000 +0000D616D617D618D619D61AD61BD61DD61ED61FD621D622D623D625D626D627 +D628D629D62AD62BD62CD62ED62FD630D631D632D633D634D635D636D637D63A +D63BC9D5C9D6C9D9C9DAC9DCC9DDC9E0C9E2C9E4C9E7C9ECC9EDC9EFC9F0C9F1 +C9F8C9F9C9FCCA00CA08CA09CA0BCA0CCA0DCA14CA18CA29CA4CCA4DCA50CA54 +CA5CCA5DCA5FCA60CA61CA68CA7DCA84CA98CABCCABDCAC0CAC4CACCCACDCACF +CAD1CAD3CAD8CAD9CAE0CAECCAF4CB08CB10CB14CB18CB20CB21CB41CB48CB49 +CB4CCB50CB58CB59CB5DCB64CB78CB79CB9CCBB8CBD4CBE4CBE7CBE9CC0CCC0D +CC10CC14CC1CCC1DCC21CC22CC27CC28CC29CC2CCC2ECC30CC38CC39CC3B0000 +C3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D63DD63ED63FD641D642D643D644D646D647D64AD64CD64ED64FD650D652 +D653D656D657D659D65AD65BD65DD65ED65FD660D66100000000000000000000 +0000D662D663D664D665D666D668D66AD66BD66CD66DD66ED66FD672D673D675 +D676D677D678D679D67AD67BD67CD67DD67ED67FD68000000000000000000000 +0000D681D682D684D686D687D688D689D68AD68BD68ED68FD691D692D693D695 +D696D697D698D699D69AD69BD69CD69ED6A0D6A2D6A3D6A4D6A5D6A6D6A7D6A9 +D6AACC3CCC3DCC3ECC44CC45CC48CC4CCC54CC55CC57CC58CC59CC60CC64CC66 +CC68CC70CC75CC98CC99CC9CCCA0CCA8CCA9CCABCCACCCADCCB4CCB5CCB8CCBC +CCC4CCC5CCC7CCC9CCD0CCD4CCE4CCECCCF0CD01CD08CD09CD0CCD10CD18CD19 +CD1BCD1DCD24CD28CD2CCD39CD5CCD60CD64CD6CCD6DCD6FCD71CD78CD88CD94 +CD95CD98CD9CCDA4CDA5CDA7CDA9CDB0CDC4CDCCCDD0CDE8CDECCDF0CDF8CDF9 +CDFBCDFDCE04CE08CE0CCE14CE19CE20CE21CE24CE28CE30CE31CE33CE350000 +C4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D6ABD6ADD6AED6AFD6B1D6B2D6B3D6B4D6B5D6B6D6B7D6B8D6BAD6BCD6BD +D6BED6BFD6C0D6C1D6C2D6C3D6C6D6C7D6C9D6CAD6CB00000000000000000000 +0000D6CDD6CED6CFD6D0D6D2D6D3D6D5D6D6D6D8D6DAD6DBD6DCD6DDD6DED6DF +D6E1D6E2D6E3D6E5D6E6D6E7D6E9D6EAD6EBD6ECD6ED00000000000000000000 +0000D6EED6EFD6F1D6F2D6F3D6F4D6F6D6F7D6F8D6F9D6FAD6FBD6FED6FFD701 +D702D703D705D706D707D708D709D70AD70BD70CD70DD70ED70FD710D712D713 +D714CE58CE59CE5CCE5FCE60CE61CE68CE69CE6BCE6DCE74CE75CE78CE7CCE84 +CE85CE87CE89CE90CE91CE94CE98CEA0CEA1CEA3CEA4CEA5CEACCEADCEC1CEE4 +CEE5CEE8CEEBCEECCEF4CEF5CEF7CEF8CEF9CF00CF01CF04CF08CF10CF11CF13 +CF15CF1CCF20CF24CF2CCF2DCF2FCF30CF31CF38CF54CF55CF58CF5CCF64CF65 +CF67CF69CF70CF71CF74CF78CF80CF85CF8CCFA1CFA8CFB0CFC4CFE0CFE1CFE4 +CFE8CFF0CFF1CFF3CFF5CFFCD000D004D011D018D02DD034D035D038D03C0000 +C5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D715D716D717D71AD71BD71DD71ED71FD721D722D723D724D725D726D727 +D72AD72CD72ED72FD730D731D732D733D736D737D73900000000000000000000 +0000D73AD73BD73DD73ED73FD740D741D742D743D745D746D748D74AD74BD74C +D74DD74ED74FD752D753D755D75AD75BD75CD75DD75E00000000000000000000 +0000D75FD762D764D766D767D768D76AD76BD76DD76ED76FD771D772D773D775 +D776D777D778D779D77AD77BD77ED77FD780D782D783D784D785D786D787D78A +D78BD044D045D047D049D050D054D058D060D06CD06DD070D074D07CD07DD081 +D0A4D0A5D0A8D0ACD0B4D0B5D0B7D0B9D0C0D0C1D0C4D0C8D0C9D0D0D0D1D0D3 +D0D4D0D5D0DCD0DDD0E0D0E4D0ECD0EDD0EFD0F0D0F1D0F8D10DD130D131D134 +D138D13AD140D141D143D144D145D14CD14DD150D154D15CD15DD15FD161D168 +D16CD17CD184D188D1A0D1A1D1A4D1A8D1B0D1B1D1B3D1B5D1BAD1BCD1C0D1D8 +D1F4D1F8D207D209D210D22CD22DD230D234D23CD23DD23FD241D248D25C0000 +C6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D78DD78ED78FD791D792D793D794D795D796D797D79AD79CD79ED79FD7A0 +D7A1D7A2D7A30000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D264D280D281D284D288D290D291D295D29CD2A0D2A4D2ACD2B1D2B8D2B9 +D2BCD2BFD2C0D2C2D2C8D2C9D2CBD2D4D2D8D2DCD2E4D2E5D2F0D2F1D2F4D2F8 +D300D301D303D305D30CD30DD30ED310D314D316D31CD31DD31FD320D321D325 +D328D329D32CD330D338D339D33BD33CD33DD344D345D37CD37DD380D384D38C +D38DD38FD390D391D398D399D39CD3A0D3A8D3A9D3ABD3ADD3B4D3B8D3BCD3C4 +D3C5D3C8D3C9D3D0D3D8D3E1D3E3D3ECD3EDD3F0D3F4D3FCD3FDD3FFD4010000 +C7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D408D41DD440D444D45CD460D464D46DD46FD478D479D47CD47FD480D482 +D488D489D48BD48DD494D4A9D4CCD4D0D4D4D4DCD4DFD4E8D4ECD4F0D4F8D4FB +D4FDD504D508D50CD514D515D517D53CD53DD540D544D54CD54DD54FD551D558 +D559D55CD560D565D568D569D56BD56DD574D575D578D57CD584D585D587D588 +D589D590D5A5D5C8D5C9D5CCD5D0D5D2D5D8D5D9D5DBD5DDD5E4D5E5D5E8D5EC +D5F4D5F5D5F7D5F9D600D601D604D608D610D611D613D614D615D61CD6200000 +C8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000D624D62DD638D639D63CD640D645D648D649D64BD64DD651D654D655D658 +D65CD667D669D670D671D674D683D685D68CD68DD690D694D69DD69FD6A1D6A8 +D6ACD6B0D6B9D6BBD6C4D6C5D6C8D6CCD6D1D6D4D6D7D6D9D6E0D6E4D6E8D6F0 +D6F5D6FCD6FDD700D704D711D718D719D71CD720D728D729D72BD72DD734D735 +D738D73CD744D747D749D750D751D754D756D757D758D759D760D761D763D765 +D769D76CD770D774D77CD77DD781D788D789D78CD790D798D799D79BD79D0000 +CA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00004F3D4F73504750F952A053EF547554E556095AC15BB6668767B667B767EF +6B4C73C275C27A3C82DB8304885788888A368CC88DCF8EFB8FE699D5523B5374 +5404606A61646BBC73CF811A89BA89D295A34F83520A58BE597859E65E725E79 +61C763C0674667EC687F6F97764E770B78F57A087AFF7C21809D826E82718AEB +95934E6B559D66F76E3478A37AED845B8910874E97A852D8574E582A5D4C611F +61BE6221656267D16A446E1B751875B376E377B07D3A90AF945194529F950000 +CB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000053235CAC753280DB92409598525B580859DC5CA15D175EB75F3A5F4A6177 +6C5F757A75867CE07D737DB17F8C81548221859189418B1B92FC964D9C474ECB +4EF7500B51F1584F6137613E6168653969EA6F1175A5768676D67B8782A584CB +F90093A7958B55805BA25751F9017CB37FB991B5502853BB5C455DE862D2636E +64DA64E76E2070AC795B8DDD8E1EF902907D924592F84E7E4EF650655DFE5EFA +61066957817186548E4793759A2B4E5E5091677068405109528D52926AA20000 +CC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000077BC92109ED452AB602F8FF2504861A963ED64CA683C6A846FC0818889A1 +96945805727D72AC75047D797E6D80A9898B8B7490639D5162896C7A6F547D50 +7F3A8A23517C614A7B9D8B199257938C4EAC4FD3501E50BE510652C152CD537F +577058835E9A5F91617661AC64CE656C666F66BB66F468976D87708570F1749F +74A574CA75D9786C78EC7ADF7AF67D457D938015803F811B83968B668F159015 +93E1980398389A5A9BE84FC25553583A59515B635C4660B86212684268B00000 +CD +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000068E86EAA754C767878CE7A3D7CFB7E6B7E7C8A088AA18C3F968E9DC453E4 +53E9544A547156FA59D15B645C3B5EAB62F765376545657266A067AF69C16CBD +75FC7690777E7A3F7F94800380A1818F82E682FD83F085C1883188B48AA5F903 +8F9C932E96C798679AD89F1354ED659B66F2688F7A408C379D6056F057645D11 +660668B168CD6EFE7428889E9BE46C68F9049AA84F9B516C5171529F5B545DE5 +6050606D62F163A7653B73D97A7A86A38CA2978F4E325BE16208679C74DC0000 +CE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000079D183D38A878AB28DE8904E934B98465ED369E885FF90EDF90551A05B98 +5BEC616368FA6B3E704C742F74D87BA17F5083C589C08CAB95DC9928522E605D +62EC90024F8A5149532158D95EE366E06D38709A72C273D67B5080F1945B5366 +639B7F6B4E565080584A58DE602A612762D069D09B415B8F7D1880B18F5F4EA4 +50D154AC55AC5B0C5DA05DE7652A654E68216A4B72E1768E77EF7D5E7FF981A0 +854E86DF8F038F4E90CA99039A559BAB4E184E454E5D4EC74FF1517752FE0000 +CF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000534053E353E5548E5614577557A25BC75D875ED061FC62D8655167B867E9 +69CB6B506BC66BEC6C426E9D707872D77396740377BF77E97A767D7F800981FC +8205820A82DF88628B338CFC8EC0901190B1926492B699D29A459CE99DD79F9C +570B5C4083CA97A097AB9EB4541B7A987FA488D98ECD90E158005C4863987A9F +5BAE5F137A797AAE828E8EAC5026523852F85377570862F363726B0A6DC37737 +53A5735785688E7695D5673A6AC36F708A6D8ECC994BF90666776B788CB40000 +D0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009B3CF90753EB572D594E63C669FB73EA78457ABA7AC57CFE8475898F8D73 +903595A852FB574775477B6083CC921EF9086A58514B524B5287621F68D86975 +969950C552A452E461C365A4683969FF747E7B4B82B983EB89B28B398FD19949 +F9094ECA599764D266116A8E7434798179BD82A9887E887F895FF90A93264F0B +53CA602562716C727D1A7D664E98516277DC80AF4F014F0E5176518055DC5668 +573B57FA57FC5914594759935BC45C905D0E5DF15E7E5FCC628065D765E30000 +D1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000671E671F675E68CB68C46A5F6B3A6C236C7D6C826DC773987426742A7482 +74A37578757F788178EF794179477948797A7B957D007DBA7F888006802D808C +8A188B4F8C488D779321932498E299519A0E9A0F9A659E927DCA4F76540962EE +685491D155AB513AF90BF90C5A1C61E6F90D62CF62FFF90EF90FF910F911F912 +F91390A3F914F915F916F917F9188AFEF919F91AF91BF91C6696F91D7156F91E +F91F96E3F920634F637A5357F921678F69606E73F9227537F923F924F9250000 +D2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007D0DF926F927887256CA5A18F928F929F92AF92BF92C4E43F92D51675948 +67F08010F92E59735E74649A79CA5FF5606C62C8637B5BE75BD752AAF92F5974 +5F296012F930F931F9327459F933F934F935F936F937F93899D1F939F93AF93B +F93CF93DF93EF93FF940F941F942F9436FC3F944F94581BF8FB260F1F946F947 +8166F948F9495C3FF94AF94BF94CF94DF94EF94FF950F9515AE98A25677B7D10 +F952F953F954F955F956F95780FDF958F9595C3C6CE5533F6EBA591A83360000 +D3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00004E394EB64F4655AE571858C75F5665B765E66A806BB56E4D77ED7AEF7C1E +7DDE86CB88929132935B64BB6FBE737A75B890545556574D61BA64D466C76DE1 +6E5B6F6D6FB975F0804381BD854189838AC78B5A931F6C9375537B548E0F905D +5510580258585E626207649E68E075767CD687B39EE84EE35788576E59275C0D +5CB15E365F85623464E173B381FA888B8CB8968A9EDB5B855FB760B350125200 +52305716583558575C0E5C605CF65D8B5EA65F9260BC63116389641768430000 +D4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000068F96AC26DD86E216ED46FE471FE76DC777979B17A3B840489A98CED8DF3 +8E4890039014905390FD934D967697DC6BD27006725872A27368776379BF7BE4 +7E9B8B8058A960C7656665FD66BE6C8C711E71C98C5A98134E6D7A814EDD51AC +51CD52D5540C61A76771685068DF6D1E6F7C75BC77B37AE580F484639285515C +6597675C679375D87AC78373F95A8C469017982D5C6F81C0829A9041906F920D +5F975D9D6A5971C8767B7B4985E48B0491279A30558761F6F95B76697F850000 +D5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000863F87BA88F8908FF95C6D1B70D973DE7D61843DF95D916A99F1F95E4E82 +53756B046B12703E721B862D9E1E524C8FA35D5064E5652C6B166FEB7C437E9C +85CD896489BD62C981D8881F5ECA67176D6A72FC7405746F878290DE4F865D0D +5FA0840A51B763A075654EAE5006516951C968816A117CAE7CB17CE7826F8AD2 +8F1B91CF4FB6513752F554425EEC616E623E65C56ADA6FFE792A85DC882395AD +9A629A6A9E979ECE529B66C66B77701D792B8F6297426190620065236F230000 +D6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000714974897DF4806F84EE8F269023934A51BD521752A36D0C70C888C25EC9 +65826BAE6FC27C3E73754EE44F3656F9F95F5CBA5DBA601C73B27B2D7F9A7FCE +8046901E923496F6974898189F614F8B6FA779AE91B496B752DEF960648864C4 +6AD36F5E7018721076E780018606865C8DEF8F0597329B6F9DFA9E75788C797F +7DA083C993049E7F9E938AD658DF5F046727702774CF7C60807E512170287262 +78CA8CC28CDA8CF496F74E8650DA5BEE5ED6659971CE764277AD804A84FC0000 +D7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000907C9B279F8D58D85A415C626A136DDA6F0F763B7D2F7E37851E893893E4 +964B528965D267F369B46D416E9C700F7409746075597624786B8B2C985E516D +622E96784F96502B5D196DEA7DB88F2A5F8B61446817F961968652D2808B51DC +51CC695E7A1C7DBE83F196754FDA52295398540F550E5C6560A7674E68A86D6C +728172F874067483F96275E27C6C7F797FB8838988CF88E191CC91D096E29BC9 +541D6F7E71D0749885FA8EAA96A39C579E9F67976DCB743381E89716782C0000 +D8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007ACB7B207C926469746A75F278BC78E899AC9B549EBB5BDE5E556F20819C +83AB90884E07534D5A295DD25F4E6162633D666966FC6EFF6F2B7063779E842C +8513883B8F1399459C3B551C62B9672B6CAB8309896A977A4EA159845FD85FD9 +671B7DB27F548292832B83BD8F1E909957CB59B95A925BD06627679A68856BCF +71647F758CB78CE390819B4581088C8A964C9A409EA55B5F6C13731B76F276DF +840C51AA8993514D519552C968C96C94770477207DBF7DEC97629EB56EC50000 +D9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000851151A5540D547D660E669D69276E9F76BF7791831784C2879F91699298 +9CF488824FAE519252DF59C65E3D61556478647966AE67D06A216BCD6BDB725F +72617441773877DB801782BC83058B008B288C8C67286C90726776EE77667A46 +9DA96B7F6C92592267268499536F589359995EDF63CF663467736E3A732B7AD7 +82D7932852D95DEB61AE61CB620A62C764AB65E069596B666BCB712173F7755D +7E46821E8302856A8AA38CBF97279D6158A89ED85011520E543B554F65870000 +DA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006C767D0A7D0B805E868A958096EF52FF6C95726954735A9A5C3E5D4B5F4C +5FAE672A68B669636E3C6E4477097C737F8E85878B0E8FF797619EF45CB760B6 +610D61AB654F65FB65FC6C116CEF739F73C97DE195945BC6871C8B10525D535A +62CD640F64B267346A386CCA73C0749E7B947C957E1B818A823685848FEB96F9 +99C14F34534A53CD53DB62CC642C6500659169C36CEE6F5873ED7554762276E4 +76FC78D078FB792C7D46822C87E08FD4981298EF52C362D464A56E246F510000 +DB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000767C8DCB91B192629AEE9B435023508D574A59A85C285E475F77623F653E +65B965C16609678B699C6EC278C57D2180AA8180822B82B384A1868C8A2A8B17 +90A696329F90500D4FF3F96357F95F9862DC6392676F6E43711976C380CC80DA +88F488F589198CE08F29914D966A4F2F4F705E1B67CF6822767D767E9B445E61 +6A0A716971D4756AF9647E41854385E998DC4F107B4F7F7095A551E15E0668B5 +6C3E6C4E6CDB72AF7BC483036CD5743A50FB528858C164D86A9774A776560000 +DC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000078A7861795E29739F965535E5F018B8A8FA88FAF908A522577A59C499F08 +4E19500251755C5B5E77661E663A67C468C570B3750175C579C97ADD8F279920 +9A084FDD582158315BF6666E6B656D116E7A6F7D73E4752B83E988DC89138B5C +8F144F0F50D55310535C5B935FA9670D798F8179832F8514890789868F398F3B +99A59C12672C4E764FF859495C015CEF5CF0636768D270FD71A2742B7E2B84EC +8702902292D29CF34E0D4ED84FEF50855256526F5426549057E0592B5A660000 +DD +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005B5A5B755BCC5E9CF9666276657765A76D6E6EA572367B267C3F7F368150 +8151819A8240829983A98A038CA08CE68CFB8D748DBA90E891DC961C964499D9 +9CE7531752065429567458B35954596E5FFF61A4626E66106C7E711A76C67C89 +7CDE7D1B82AC8CC196F0F9674F5B5F175F7F62C25D29670B68DA787C7E439D6C +4E1550995315532A535159835A625E8760B2618A624962796590678769A76BD4 +6BD66BD76BD86CB8F968743575FA7812789179D579D87C837DCB7FE180A50000 +DE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000813E81C283F2871A88E88AB98B6C8CBB9119975E98DB9F3B56AC5B2A5F6C +658C6AB36BAF6D5C6FF17015725D73AD8CA78CD3983B61916C3780589A014E4D +4E8B4E9B4ED54F3A4F3C4F7F4FDF50FF53F253F8550655E356DB58EB59625A11 +5BEB5BFA5C045DF35E2B5F99601D6368659C65AF67F667FB68AD6B7B6C996CD7 +6E23700973457802793E7940796079C17BE97D177D728086820D838E84D186C7 +88DF8A508A5E8B1D8CDC8D668FAD90AA98FC99DF9E9D524AF9696714F96A0000 +DF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005098522A5C7165636C5573CA7523759D7B97849C917897304E7764926BBA +715E85A94E09F96B674968EE6E17829F8518886B63F76F81921298AF4E0A50B7 +50CF511F554655AA56175B405C195CE05E385E8A5EA05EC260F368516A616E58 +723D724072C076F879657BB17FD488F389F48A738C618CDE971C585E74BD8CFD +55C7F96C7A617D2282727272751F7525F96D7B19588558FB5DBC5E8F5EB65F90 +60556292637F654D669166D966F8681668F27280745E7B6E7D6E7DD67F720000 +E0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000080E5821285AF897F8A93901D92E49ECD9F205915596D5E2D60DC66146673 +67906C506DC56F5F77F378A984C691CB932B4ED950CA514855845B0B5BA36247 +657E65CB6E32717D74017444748774BF766C79AA7DDA7E557FA8817A81B38239 +861A87EC8A758DE3907892919425994D9BAE53685C5169546CC46D296E2B820C +859B893B8A2D8AAA96EA9F67526166B96BB27E9687FE8D0D9583965D651D6D89 +71EEF96E57CE59D35BAC602760FA6210661F665F732973F976DB77017B6C0000 +E1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008056807281658AA091924E1652E26B726D177A057B397D30F96F8CB053EC +562F58515BB55C0F5C115DE2624063836414662D68B36CBC6D886EAF701F70A4 +71D27526758F758E76197B117BE07C2B7D207D39852C856D86078A34900D9061 +90B592B797F69A374FD75C6C675F6D917C9F7E8C8B168D16901F5B6B5DFD640D +84C0905C98E173875B8B609A677E6DDE8A1F8AA69001980C5237F9707051788E +9396887091D74FEE53D755FD56DA578258FD5AC25B885CAB5CC05E2561010000 +E2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000620D624B6388641C653665786A396B8A6C346D196F3171E772E973787407 +74B27626776179C07A577AEA7CB97D8F7DAC7E617F9E81298331849084DA85EA +88968AB08B908F3890429083916C929692B9968B96A796A896D6970098089996 +9AD39B1A53D4587E59195B705BBF6DD16F5A719F742174B9808583FD5DE15F87 +5FAA604265EC6812696F6A536B896D356DF373E376FE77AC7B4D7D148123821C +834084F485638A628AC49187931E980699B4620C88538FF092655D075D270000 +E3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005D69745F819D87686FD562FE7FD2893689724E1E4E5850E752DD5347627F +66077E698805965E4F8D5319563659CB5AA45C385C4E5C4D5E025F11604365BD +662F664267BE67F4731C77E2793A7FC5849484CD89968A668A698AE18C558C7A +57F45BD45F0F606F62ED690D6B966E5C71847BD287558B588EFE98DF98FE4F38 +4F814FE1547B5A205BB8613C65B0666871FC7533795E7D33814E81E3839885AA +85CE87038A0A8EAB8F9BF9718FC559315BA45BE660895BE95C0B5FC36C810000 +E4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000F9726DF1700B751A82AF8AF64EC05341F97396D96C0F4E9E4FC45152555E +5A255CE86211725982BD83AA86FE88598A1D963F96C599139D099D5D580A5CB3 +5DBD5E4460E1611563E16A026E2591029354984E9C109F775B895CB86309664F +6848773C96C1978D98549B9F65A18B018ECB95BC55355CA95DD65EB56697764C +83F495C758D362BC72CE9D284EF0592E600F663B6B8379E79D26539354C057C3 +5D16611B66D66DAF788D827E969897445384627C63966DB27E0A814B984D0000 +E5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006AFB7F4C9DAF9E1A4E5F503B51B6591C60F963F66930723A8036F97491CE +5F31F975F9767D0482E5846F84BB85E58E8DF9774F6FF978F97958E45B436059 +63DA6518656D6698F97A694A6A236D0B7001716C75D2760D79B37A70F97B7F8A +F97C8944F97D8B9391C0967DF97E990A57045FA165BC6F01760079A68A9E99AD +9B5A9F6C510461B662916A8D81C6504358305F6671098A008AFA5B7C86164FFA +513C56B4594463A96DF95DAA696D51864E884F59F97FF980F9815982F9820000 +E6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000F9836B5F6C5DF98474B57916F9858207824583398F3F8F5DF9869918F987 +F988F9894EA6F98A57DF5F796613F98BF98C75AB7E798B6FF98D90069A5B56A5 +582759F85A1F5BB4F98E5EF6F98FF9906350633BF991693D6C876CBF6D8E6D93 +6DF56F14F99270DF71367159F99371C371D5F994784F786FF9957B757DE3F996 +7E2FF997884D8EDFF998F999F99A925BF99B9CF6F99CF99DF99E60856D85F99F +71B1F9A0F9A195B153ADF9A2F9A3F9A467D3F9A5708E71307430827682D20000 +E7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000F9A695BB9AE59E7D66C4F9A771C18449F9A8F9A9584BF9AAF9AB5DB85F71 +F9AC6620668E697969AE6C386CF36E366F416FDA701B702F715071DF7370F9AD +745BF9AE74D476C87A4E7E93F9AFF9B082F18A608FCEF9B19348F9B29719F9B3 +F9B44E42502AF9B5520853E166F36C6D6FCA730A777F7A6282AE85DD8602F9B6 +88D48A638B7D8C6BF9B792B3F9B8971398104E944F0D4FC950B25348543E5433 +55DA586258BA59675A1B5BE4609FF9B961CA655665FF666468A76C5A6FB30000 +E8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000070CF71AC73527B7D87088AA49C329F075C4B6C8373447389923A6EAB7465 +761F7A697E15860A514058C564C174EE751576707FC1909596CD99546E2674E6 +7AA97AAA81E586D987788A1B5A495B8C5B9B68A169006D6373A97413742C7897 +7DE97FEB81188155839E8C4C962E981166F05F8065FA67896C6A738B502D5A03 +6B6A77EE59165D6C5DCD7325754FF9BAF9BB50E551F9582F592D599659DA5BE5 +F9BCF9BD5DA262D76416649364FEF9BE66DCF9BF6A48F9C071FF7464F9C10000 +E9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007A887AAF7E477E5E80008170F9C287EF89818B209059F9C390809952617E +6B326D747E1F89258FB14FD150AD519752C757C758895BB95EB8614269956D8C +6E676EB6719474627528752C8073833884C98E0A939493DEF9C44E8E4F515076 +512A53C853CB53F35B875BD35C24611A618265F4725B7397744076C279507991 +79B97D067FBD828B85D5865E8FC2904790F591EA968596E896E952D65F6765ED +6631682F715C7A3690C1980A4E91F9C56A526B9E6F907189801882B885530000 +EA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000904B969596F297FB851A9B314E90718A96C45143539F54E15713571257A3 +5A9B5AC45BC36028613F63F46C856D396E726E907230733F745782D188818F45 +9060F9C6966298589D1B67088D8A925E4F4D504950DE5371570D59D45A015C09 +617066906E2D7232744B7DEF80C3840E8466853F875F885B89188B02905597CB +9B4F4E734F915112516AF9C7552F55A95B7A5BA55E7C5E7D5EBE60A060DF6108 +610963C465386709F9C867D467DAF9C9696169626CB96D27F9CA6E38F9CB0000 +EB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006FE173367337F9CC745C7531F9CD7652F9CEF9CF7DAD81FE843888D58A98 +8ADB8AED8E308E42904A903E907A914991C9936EF9D0F9D15809F9D26BD38089 +80B2F9D3F9D45141596B5C39F9D5F9D66F6473A780E48D07F9D79217958FF9D8 +F9D9F9DAF9DB807F620E701C7D68878DF9DC57A0606961476BB78ABE928096B1 +4E59541F6DEB852D967097F398EE63D66CE3909151DD61C981BA9DF94F9D501A +51005B9C610F61FF64EC69056BC5759177E37FA98264858F87FB88638ABC0000 +EC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008B7091AB4E8C4EE54F0AF9DDF9DE593759E8F9DF5DF25F1B5F5B6021F9E0 +F9E1F9E2F9E3723E73E5F9E4757075CDF9E579FBF9E6800C8033808482E18351 +F9E7F9E88CBD8CB39087F9E9F9EA98F4990CF9EBF9EC703776CA7FCA7FCC7FFC +8B1A4EBA4EC152035370F9ED54BD56E059FB5BC55F155FCD6E6EF9EEF9EF7D6A +8335F9F086938A8DF9F1976D9777F9F2F9F34E004F5A4F7E58F965E56EA29038 +93B099B94EFB58EC598A59D96041F9F4F9F57A14F9F6834F8CC3516553440000 +ED +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000F9F7F9F8F9F94ECD52695B5582BF4ED4523A54A859C959FF5B505B575B5C +606361486ECB7099716E738674F775B578C17D2B800581EA8328851785C98AEE +8CC796CC4F5C52FA56BC65AB6628707C70B872357DBD828D914C96C09D725B71 +68E76B986F7A76DE5C9166AB6F5B7BB47C2A883696DC4E084ED75320583458BB +58EF596C5C075E335E845F35638C66B267566A1F6AA36B0C6F3F7246F9FA7350 +748B7AE07CA7817881DF81E7838A846C8523859485CF88DD8D1391AC95770000 +EE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000969C518D54C957285BB0624D6750683D68936E3D6ED3707D7E2188C18CA1 +8F099F4B9F4E722D7B8F8ACD931A4F474F4E5132548059D05E9562B56775696E +6A176CAE6E1A72D9732A75BD7BB87D3582E783F9845785F78A5B8CAF8E879019 +90B896CE9F5F52E3540A5AE15BC2645865756EF472C4F9FB76847A4D7B1B7C4D +7E3E7FDF837B8B2B8CCA8D648DE18E5F8FEA8FF9906993D14F434F7A50B35168 +5178524D526A5861587C59605C085C555EDB609B623068136BBF6C086FB10000 +EF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000714E742075307538755176727B4C7B8B7BAD7BC67E8F8A6E8F3E8F49923F +92939322942B96FB985A986B991E5207622A62986D5976647ACA7BC07D765360 +5CBE5E976F3870B97C9897119B8E9EDE63A5647A87764E014E954EAD505C5075 +544859C35B9A5E405EAD5EF75F8160C5633A653F657465CC6676667867FE6968 +6A896B636C406DC06DE86E1F6E5E701E70A1738E73FD753A775B7887798E7A0B +7A7D7CBE7D8E82478A028AEA8C9E912D914A91D8926692CC9320970697560000 +F0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000975C98029F0E52365291557C58245E1D5F1F608C63D068AF6FDF796D7B2C +81CD85BA88FD8AF88E44918D9664969B973D984C9F4A4FCE514651CB52A95632 +5F145F6B63AA64CD65E9664166FA66F9671D689D68D769FD6F156F6E716771E5 +722A74AA773A7956795A79DF7A207A957C977CDF7D447E70808785FB86A48A54 +8ABF8D998E819020906D91E3963B96D59CE565CF7C078DB393C35B585C0A5352 +62D9731D50275B975F9E60B0616B68D56DD9742E7A2E7D427D9C7E31816B0000 +F1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008E2A8E35937E94184F5057505DE65EA7632B7F6A4E3B4F4F4F8F505A59DD +80C4546A546855FE594F5B995DDE5EDA665D673167F1682A6CE86D326E4A6F8D +70B773E075877C4C7D027D2C7DA2821F86DB8A3B8A858D708E8A8F339031914E +9152944499D07AF97CA54FCA510151C657C85BEF5CFB66596A3D6D5A6E966FEC +710C756F7AE388229021907596CB99FF83014E2D4EF2884691CD537D6ADB696B +6C41847A589E618E66FE62EF70DD751175C77E5284B88B498D084E4B53EA0000 +F2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000054AB573057405FD763016307646F652F65E8667A679D67B36B626C606C9A +6F2C77E57825794979577D1980A2810281F3829D82B787188A8CF9FC8D048DBE +907276F47A197A377E548077550755D45875632F64226649664B686D699B6B84 +6D256EB173CD746874A1755B75B976E1771E778B79E67E097E1D81FB852F8897 +8A3A8CD18EEB8FB0903293AD9663967397074F8453F159EA5AC95E19684E74C6 +75BE79E97A9281A386ED8CEA8DCC8FED659F6715F9FD57F76F577DDD8F2F0000 +F3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000093F696C65FB561F26F844E144F98501F53C955DF5D6F5DEE6B216B6478CB +7B9AF9FE8E498ECA906E6349643E77407A84932F947F9F6A64B06FAF71E674A8 +74DA7AC47C127E827CB27E988B9A8D0A947D9910994C52395BDF64E6672D7D2E +50ED53C358796158615961FA65AC7AD98B928B9650095021527555315A3C5EE0 +5F706134655E660C663666A269CD6EC46F32731676217A938139825983D684BC +50B557F05BC05BE85F6963A178267DB583DC852191C791F5518A67F57B560000 +F4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008CAC51C459BB60BD8655501CF9FF52545C3A617D621A62D364F265A56ECC +7620810A8E60965F96BB4EDF5343559859295DDD64C56CC96DFA73947A7F821B +85A68CE48E10907791E795E1962197C651F854F255865FB964A46F887DB48F1F +8F4D943550C95C166CBE6DFB751B77BB7C3D7C648A798AC2581E59BE5E166377 +7252758A776B8ADC8CBC8F125EF366746DF8807D83C18ACB97519BD6FA005243 +66FF6D956EEF7DE08AE6902E905E9AD4521D527F54E86194628462DB68A20000 +F5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006912695A6A3570927126785D7901790E79D27A0D8096827882D583498549 +8C828D859162918B91AE4FC356D171ED77D7870089F85BF85FD6675190A853E2 +585A5BF560A4618164607E3D80708525928364AE50AC5D146700589C62BD63A8 +690E69786A1E6E6B76BA79CB82BB84298ACF8DA88FFD9112914B919C93109318 +939A96DB9A369C0D4E11755C795D7AFA7B517BC97E2E84C48E598E748EF89010 +6625693F744351FA672E9EDC51455FE06C9687F2885D887760B481B584030000 +F6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008D0553D6543956345A365C31708A7FE0805A810681ED8DA391899A5F9DF2 +50744EC453A060FB6E2C5C644F88502455E45CD95E5F606568946CBB6DC471BE +75D475F476617A1A7A497DC77DFB7F6E81F486A98F1C96C999B39F52524752C5 +98ED89AA4E0367D26F064FB55BE267956C886D78741B782791DD937C87C479E4 +7A315FEB4ED654A4553E58AE59A560F0625362D6673669558235964099B199DD +502C53535544577CFA016258FA0264E2666B67DD6FC16FEF742274388A170000 +F7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000094385451560657665F48619A6B4E705870AD7DBB8A95596A812B63A27708 +803D8CAA5854642D69BB5B955E116E6FFA038569514C53F0592A6020614B6B86 +6C706CF07B1E80CE82D48DC690B098B1FA0464C76FA464916504514E5410571F +8A0E615F6876FA0575DB7B527D71901A580669CC817F892A9000983950785957 +59AC6295900F9B2A615D727995D657615A465DF4628A64AD64FA67776CE26D3E +722C743678347F7782AD8DDB981752245742677F724874E38CA98FA692110000 +F8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000962A516B53ED634C4F695504609665576C9B6D7F724C72FD7A1789878C9D +5F6D6F8E70F981A8610E4FBF504F624172477BC77DE87FE9904D97AD9A198CB6 +576A5E7367B0840D8A5554205B165E635EE25F0A658380BA853D9589965B4F48 +5305530D530F548654FA57035E036016629B62B16355FA066CE16D6675B17832 +80DE812F82DE846184B2888D8912900B92EA98FD9B915E4566B466DD70117206 +FA074FF5527D5F6A615367536A196F0274E2796888688C7998C798C49A430000 +F9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000054C17A1F69538AF78C4A98A899AE5F7C62AB75B276AE88AB907F96425339 +5F3C5FC56CCC73CC7562758B7B4682FE999D4E4F903C4E0B4F5553A6590F5EC8 +66306CB37455837787668CC09050971E9C1558D15B7886508B149DB45BD26068 +608D65F16C576F226FA3701A7F557FF095919592965097D352728F4451FD542B +54B85563558A6ABB6DB57DD88266929C96779E79540854C876D286E495A495D4 +965C4EA24F0959EE5AE65DF760526297676D68416C866E2F7F38809B822A0000 +FA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000FA08FA0998054EA5505554B35793595A5B695BB361C869776D77702387F9 +89E38A728AE7908299ED9AB852BE683850165E78674F8347884C4EAB541156AE +73E6911597FF9909995799995653589F865B8A3161B26AF6737B8ED26B4796AA +9A57595572008D6B97694FD45CF45F2661F8665B6CEB70AB738473B973FE7729 +774D7D437D627E2382378852FA0A8CE29249986F5B517A74884098015ACC4FE0 +5354593E5CFD633E6D7972F98105810783A292CF98304EA851445211578B0000 +FB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005F626CC26ECE7005705070AF719273E97469834A87A28861900890A293A3 +99A8516E5F5760E0616766B385598E4A91AF978B4E4E4E92547C58D558FA597D +5CB55F2762366248660A66676BEB6D696DCF6E566EF86F946FE06FE9705D72D0 +7425745A74E07693795C7CCA7E1E80E182A6846B84BF864E865F87748B778C6A +93AC9800986560D1621691775A5A660F6DF76E3E743F9B425FFD60DA7B0F54C4 +5F186C5E6CD36D2A70D87D0586798A0C9D3B5316548C5B056A3A706B75750000 +FC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000798D79BE82B183EF8A718B418CA89774FA0B64F4652B78BA78BB7A6B4E38 +559A59505BA65E7B60A363DB6B61666568536E19716574B07D0890849A699C25 +6D3B6ED1733E8C4195CA51F05E4C5FA8604D60F66130614C6643664469A56CC1 +6E5F6EC96F62714C749C76877BC17C27835287579051968D9EC3532F56DE5EFB +5F8A6062609461F7666667036A9C6DEE6FAE7070736A7E6A81BE833486D48AA8 +8CC4528373725B966A6B940454EE56865B5D6548658566C9689F6D8D6DC60000 +FD +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000723B80B491759A4D4FAF5019539A540E543C558955C55E3F5F8C673D7166 +73DD900552DB52F3586458CE7104718F71FB85B08A13668885A855A76684714A +8431534955996BC15F595FBD63EE668971478AF18F1D9EBE4F11643A70CB7566 +866760648B4E9DF8514751F653086D3680F89ED166156B23709875D554035C79 +7D078A166B206B3D6B46543860706D3D7FD5820850D651DE559C566B56CD59EC +5B095E0C619961986231665E66E6719971B971BA72A779A77A007FB28A700000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp950.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp950.enc new file mode 100644 index 0000000000000000000000000000000000000000..f33d7854a6a2686910837bb487b4555ceb1240a2 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/cp950.enc @@ -0,0 +1,1499 @@ +# Encoding file: cp950, multi-byte +M +003F 0 88 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +A1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +3000FF0C30013002FF0E2027FF1BFF1AFF1FFF01FE3020262025FE50FE51FE52 +00B7FE54FE55FE56FE57FF5C2013FE312014FE332574FE34FE4FFF08FF09FE35 +FE36FF5BFF5DFE37FE3830143015FE39FE3A30103011FE3BFE3C300A300BFE3D +FE3E30083009FE3FFE40300C300DFE41FE42300E300FFE43FE44FE59FE5A0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000FE5BFE5CFE5DFE5E20182019201C201D301D301E20352032FF03FF06FF0A +203B00A7300325CB25CF25B325B225CE2606260525C725C625A125A025BD25BC +32A3210500AFFFE3FF3F02CDFE49FE4AFE4DFE4EFE4BFE4CFE5FFE60FE61FF0B +FF0D00D700F700B1221AFF1CFF1EFF1D226622672260221E22522261FE62FE63 +FE64FE65FE66FF5E2229222A22A52220221F22BF33D233D1222B222E22352234 +26402642229522992191219321902192219621972199219822252223FF0F0000 +A2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +FF3C2215FE68FF04FFE53012FFE0FFE1FF05FF2021032109FE69FE6AFE6B33D5 +339C339D339E33CE33A1338E338F33C400B05159515B515E515D5161516355E7 +74E97CCE25812582258325842585258625872588258F258E258D258C258B258A +2589253C2534252C2524251C2594250025022595250C251025142518256D0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000256E2570256F2550255E256A256125E225E325E525E4257125722573FF10 +FF11FF12FF13FF14FF15FF16FF17FF18FF192160216121622163216421652166 +216721682169302130223023302430253026302730283029534153445345FF21 +FF22FF23FF24FF25FF26FF27FF28FF29FF2AFF2BFF2CFF2DFF2EFF2FFF30FF31 +FF32FF33FF34FF35FF36FF37FF38FF39FF3AFF41FF42FF43FF44FF45FF46FF47 +FF48FF49FF4AFF4BFF4CFF4DFF4EFF4FFF50FF51FF52FF53FF54FF55FF560000 +A3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +FF57FF58FF59FF5A039103920393039403950396039703980399039A039B039C +039D039E039F03A003A103A303A403A503A603A703A803A903B103B203B303B4 +03B503B603B703B803B903BA03BB03BC03BD03BE03BF03C003C103C303C403C5 +03C603C703C803C931053106310731083109310A310B310C310D310E310F0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00003110311131123113311431153116311731183119311A311B311C311D311E +311F312031213122312331243125312631273128312902D902C902CA02C702CB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000020AC00000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +A4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +4E004E594E014E034E434E5D4E864E8C4EBA513F5165516B51E052005201529B +53155341535C53C84E094E0B4E084E0A4E2B4E3851E14E454E484E5F4E5E4E8E +4EA15140520352FA534353C953E3571F58EB5915592759735B505B515B535BF8 +5C0F5C225C385C715DDD5DE55DF15DF25DF35DFE5E725EFE5F0B5F13624D0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00004E114E104E0D4E2D4E304E394E4B5C394E884E914E954E924E944EA24EC1 +4EC04EC34EC64EC74ECD4ECA4ECB4EC4514351415167516D516E516C519751F6 +52065207520852FB52FE52FF53165339534853475345535E538453CB53CA53CD +58EC5929592B592A592D5B545C115C245C3A5C6F5DF45E7B5EFF5F145F155FC3 +62086236624B624E652F6587659765A465B965E566F0670867286B206B626B79 +6BCB6BD46BDB6C0F6C34706B722A7236723B72477259725B72AC738B4E190000 +A5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +4E164E154E144E184E3B4E4D4E4F4E4E4EE54ED84ED44ED54ED64ED74EE34EE4 +4ED94EDE514551445189518A51AC51F951FA51F8520A52A0529F530553065317 +531D4EDF534A534953615360536F536E53BB53EF53E453F353EC53EE53E953E8 +53FC53F853F553EB53E653EA53F253F153F053E553ED53FB56DB56DA59160000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000592E5931597459765B555B835C3C5DE85DE75DE65E025E035E735E7C5F01 +5F185F175FC5620A625362546252625165A565E6672E672C672A672B672D6B63 +6BCD6C116C106C386C416C406C3E72AF7384738974DC74E67518751F75287529 +7530753175327533758B767D76AE76BF76EE77DB77E277F3793A79BE7A747ACB +4E1E4E1F4E524E534E694E994EA44EA64EA54EFF4F094F194F0A4F154F0D4F10 +4F114F0F4EF24EF64EFB4EF04EF34EFD4F014F0B514951475146514851680000 +A6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5171518D51B0521752115212520E521652A3530853215320537053715409540F +540C540A54105401540B54045411540D54085403540E5406541256E056DE56DD +573357305728572D572C572F57295919591A59375938598459785983597D5979 +598259815B575B585B875B885B855B895BFA5C165C795DDE5E065E765E740000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005F0F5F1B5FD95FD6620E620C620D62106263625B6258653665E965E865EC +65ED66F266F36709673D6734673167356B216B646B7B6C166C5D6C576C596C5F +6C606C506C556C616C5B6C4D6C4E7070725F725D767E7AF97C737CF87F367F8A +7FBD80018003800C80128033807F8089808B808C81E381EA81F381FC820C821B +821F826E8272827E866B8840884C8863897F96214E324EA84F4D4F4F4F474F57 +4F5E4F344F5B4F554F304F504F514F3D4F3A4F384F434F544F3C4F464F630000 +A7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +4F5C4F604F2F4F4E4F364F594F5D4F484F5A514C514B514D517551B651B75225 +52245229522A522852AB52A952AA52AC532353735375541D542D541E543E5426 +544E542754465443543354485442541B5429544A5439543B5438542E54355436 +5420543C54405431542B541F542C56EA56F056E456EB574A57515740574D0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005747574E573E5750574F573B58EF593E599D599259A8599E59A359995996 +598D59A45993598A59A55B5D5B5C5B5A5B5B5B8C5B8B5B8F5C2C5C405C415C3F +5C3E5C905C915C945C8C5DEB5E0C5E8F5E875E8A5EF75F045F1F5F645F625F77 +5F795FD85FCC5FD75FCD5FF15FEB5FF85FEA6212621162846297629662806276 +6289626D628A627C627E627962736292626F6298626E62956293629162866539 +653B653865F166F4675F674E674F67506751675C6756675E6749674667600000 +A8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +675367576B656BCF6C426C5E6C996C816C886C896C856C9B6C6A6C7A6C906C70 +6C8C6C686C966C926C7D6C836C726C7E6C746C866C766C8D6C946C986C827076 +707C707D707872627261726072C472C27396752C752B75377538768276EF77E3 +79C179C079BF7A767CFB7F5580968093809D8098809B809A80B2826F82920000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000828B828D898B89D28A008C378C468C558C9D8D648D708DB38EAB8ECA8F9B +8FB08FC28FC68FC58FC45DE1909190A290AA90A690A3914991C691CC9632962E +9631962A962C4E264E564E734E8B4E9B4E9E4EAB4EAC4F6F4F9D4F8D4F734F7F +4F6C4F9B4F8B4F864F834F704F754F884F694F7B4F964F7E4F8F4F914F7A5154 +51525155516951775176517851BD51FD523B52385237523A5230522E52365241 +52BE52BB5352535453535351536653775378537953D653D453D7547354750000 +A9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5496547854955480547B5477548454925486547C549054715476548C549A5462 +5468548B547D548E56FA57835777576A5769576157665764577C591C59495947 +59485944595459BE59BB59D459B959AE59D159C659D059CD59CB59D359CA59AF +59B359D259C55B5F5B645B635B975B9A5B985B9C5B995B9B5C1A5C485C450000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005C465CB75CA15CB85CA95CAB5CB15CB35E185E1A5E165E155E1B5E115E78 +5E9A5E975E9C5E955E965EF65F265F275F295F805F815F7F5F7C5FDD5FE05FFD +5FF55FFF600F6014602F60356016602A6015602160276029602B601B62166215 +623F623E6240627F62C962CC62C462BF62C262B962D262DB62AB62D362D462CB +62C862A862BD62BC62D062D962C762CD62B562DA62B162D862D662D762C662AC +62CE653E65A765BC65FA66146613660C66066602660E6600660F6615660A0000 +AA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6607670D670B676D678B67956771679C677367776787679D6797676F6770677F +6789677E67906775679A6793677C676A67726B236B666B676B7F6C136C1B6CE3 +6CE86CF36CB16CCC6CE56CB36CBD6CBE6CBC6CE26CAB6CD56CD36CB86CC46CB9 +6CC16CAE6CD76CC56CF16CBF6CBB6CE16CDB6CCA6CAC6CEF6CDC6CD66CE00000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007095708E7092708A7099722C722D723872487267726972C072CE72D972D7 +72D073A973A8739F73AB73A5753D759D7599759A768476C276F276F477E577FD +793E7940794179C979C87A7A7A797AFA7CFE7F547F8C7F8B800580BA80A580A2 +80B180A180AB80A980B480AA80AF81E581FE820D82B3829D829982AD82BD829F +82B982B182AC82A582AF82B882A382B082BE82B7864E8671521D88688ECB8FCE +8FD48FD190B590B890B190B691C791D195779580961C9640963F963B96440000 +AB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +964296B996E89752975E4E9F4EAD4EAE4FE14FB54FAF4FBF4FE04FD14FCF4FDD +4FC34FB64FD84FDF4FCA4FD74FAE4FD04FC44FC24FDA4FCE4FDE4FB751575192 +519151A0524E5243524A524D524C524B524752C752C952C352C1530D5357537B +539A53DB54AC54C054A854CE54C954B854A654B354C754C254BD54AA54C10000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000054C454C854AF54AB54B154BB54A954A754BF56FF5782578B57A057A357A2 +57CE57AE579359555951594F594E595059DC59D859FF59E359E85A0359E559EA +59DA59E65A0159FB5B695BA35BA65BA45BA25BA55C015C4E5C4F5C4D5C4B5CD9 +5CD25DF75E1D5E255E1F5E7D5EA05EA65EFA5F085F2D5F655F885F855F8A5F8B +5F875F8C5F896012601D60206025600E6028604D60706068606260466043606C +606B606A6064624162DC6316630962FC62ED630162EE62FD630762F162F70000 +AC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +62EF62EC62FE62F463116302653F654565AB65BD65E26625662D66206627662F +661F66286631662466F767FF67D367F167D467D067EC67B667AF67F567E967EF +67C467D167B467DA67E567B867CF67DE67F367B067D967E267DD67D26B6A6B83 +6B866BB56BD26BD76C1F6CC96D0B6D326D2A6D416D256D0C6D316D1E6D170000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006D3B6D3D6D3E6D366D1B6CF56D396D276D386D296D2E6D356D0E6D2B70AB +70BA70B370AC70AF70AD70B870AE70A472307272726F727472E972E072E173B7 +73CA73BB73B273CD73C073B3751A752D754F754C754E754B75AB75A475A575A2 +75A3767876867687768876C876C676C376C5770176F976F87709770B76FE76FC +770777DC78027814780C780D794679497948794779B979BA79D179D279CB7A7F +7A817AFF7AFD7C7D7D027D057D007D097D077D047D067F387F8E7FBF80040000 +AD +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8010800D8011803680D680E580DA80C380C480CC80E180DB80CE80DE80E480DD +81F4822282E78303830582E382DB82E6830482E58302830982D282D782F18301 +82DC82D482D182DE82D382DF82EF830686508679867B867A884D886B898189D4 +8A088A028A038C9E8CA08D748D738DB48ECD8ECC8FF08FE68FE28FEA8FE50000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008FED8FEB8FE48FE890CA90CE90C190C3914B914A91CD95829650964B964C +964D9762976997CB97ED97F3980198A898DB98DF999699994E584EB3500C500D +50234FEF502650254FF8502950165006503C501F501A501250114FFA50005014 +50284FF15021500B501950184FF34FEE502D502A4FFE502B5009517C51A451A5 +51A251CD51CC51C651CB5256525C5254525B525D532A537F539F539D53DF54E8 +55105501553754FC54E554F2550654FA551454E954ED54E1550954EE54EA0000 +AE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +54E65527550754FD550F5703570457C257D457CB57C35809590F59575958595A +5A115A185A1C5A1F5A1B5A1359EC5A205A235A295A255A0C5A095B6B5C585BB0 +5BB35BB65BB45BAE5BB55BB95BB85C045C515C555C505CED5CFD5CFB5CEA5CE8 +5CF05CF65D015CF45DEE5E2D5E2B5EAB5EAD5EA75F315F925F915F9060590000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006063606560506055606D6069606F6084609F609A608D6094608C60856096 +624762F3630862FF634E633E632F635563426346634F6349633A6350633D632A +632B6328634D634C65486549659965C165C566426649664F66436652664C6645 +664166F867146715671768216838684868466853683968426854682968B36817 +684C6851683D67F468506840683C6843682A68456813681868416B8A6B896BB7 +6C236C276C286C266C246CF06D6A6D956D886D876D666D786D776D596D930000 +AF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6D6C6D896D6E6D5A6D746D696D8C6D8A6D796D856D656D9470CA70D870E470D9 +70C870CF7239727972FC72F972FD72F872F7738673ED740973EE73E073EA73DE +7554755D755C755A755975BE75C575C775B275B375BD75BC75B975C275B8768B +76B076CA76CD76CE7729771F7720772877E9783078277838781D783478370000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007825782D7820781F7832795579507960795F7956795E795D7957795A79E4 +79E379E779DF79E679E979D87A847A887AD97B067B117C897D217D177D0B7D0A +7D207D227D147D107D157D1A7D1C7D0D7D197D1B7F3A7F5F7F947FC57FC18006 +8018801580198017803D803F80F1810280F0810580ED80F4810680F880F38108 +80FD810A80FC80EF81ED81EC82008210822A822B8228822C82BB832B83528354 +834A83388350834983358334834F833283398336831783408331832883430000 +B0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8654868A86AA869386A486A9868C86A3869C8870887788818882887D88798A18 +8A108A0E8A0C8A158A0A8A178A138A168A0F8A118C488C7A8C798CA18CA28D77 +8EAC8ED28ED48ECF8FB1900190068FF790008FFA8FF490038FFD90058FF89095 +90E190DD90E29152914D914C91D891DD91D791DC91D995839662966396610000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000965B965D96649658965E96BB98E299AC9AA89AD89B259B329B3C4E7E507A +507D505C50475043504C505A504950655076504E5055507550745077504F500F +506F506D515C519551F0526A526F52D252D952D852D55310530F5319533F5340 +533E53C366FC5546556A55665544555E55615543554A55315556554F5555552F +55645538552E555C552C55635533554155575708570B570957DF5805580A5806 +57E057E457FA5802583557F757F9592059625A365A415A495A665A6A5A400000 +B1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5A3C5A625A5A5A465A4A5B705BC75BC55BC45BC25BBF5BC65C095C085C075C60 +5C5C5C5D5D075D065D0E5D1B5D165D225D115D295D145D195D245D275D175DE2 +5E385E365E335E375EB75EB85EB65EB55EBE5F355F375F575F6C5F695F6B5F97 +5F995F9E5F985FA15FA05F9C607F60A3608960A060A860CB60B460E660BD0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000060C560BB60B560DC60BC60D860D560C660DF60B860DA60C7621A621B6248 +63A063A76372639663A263A563776367639863AA637163A963896383639B636B +63A863846388639963A163AC6392638F6380637B63696368637A655D65566551 +65596557555F654F655865556554659C659B65AC65CF65CB65CC65CE665D665A +666466686666665E66F952D7671B688168AF68A2689368B5687F687668B168A7 +689768B0688368C468AD688668856894689D68A8689F68A168826B326BBA0000 +B2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6BEB6BEC6C2B6D8E6DBC6DF36DD96DB26DE16DCC6DE46DFB6DFA6E056DC76DCB +6DAF6DD16DAE6DDE6DF96DB86DF76DF56DC56DD26E1A6DB56DDA6DEB6DD86DEA +6DF16DEE6DE86DC66DC46DAA6DEC6DBF6DE670F97109710A70FD70EF723D727D +7281731C731B73167313731973877405740A7403740673FE740D74E074F60000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000074F7751C75227565756675627570758F75D475D575B575CA75CD768E76D4 +76D276DB7737773E773C77367738773A786B7843784E79657968796D79FB7A92 +7A957B207B287B1B7B2C7B267B197B1E7B2E7C927C977C957D467D437D717D2E +7D397D3C7D407D307D337D447D2F7D427D327D317F3D7F9E7F9A7FCC7FCE7FD2 +801C804A8046812F81168123812B81298130812482028235823782368239838E +839E8398837883A2839683BD83AB8392838A8393838983A08377837B837C0000 +B3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +838683A786555F6A86C786C086B686C486B586C686CB86B186AF86C98853889E +888888AB88928896888D888B8993898F8A2A8A1D8A238A258A318A2D8A1F8A1B +8A228C498C5A8CA98CAC8CAB8CA88CAA8CA78D678D668DBE8DBA8EDB8EDF9019 +900D901A90179023901F901D90109015901E9020900F90229016901B90140000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000090E890ED90FD915791CE91F591E691E391E791ED91E99589966A96759673 +96789670967496769677966C96C096EA96E97AE07ADF980298039B5A9CE59E75 +9E7F9EA59EBB50A2508D508550995091508050965098509A670051F152725274 +5275526952DE52DD52DB535A53A5557B558055A7557C558A559D55985582559C +55AA55945587558B558355B355AE559F553E55B2559A55BB55AC55B1557E5589 +55AB5599570D582F582A58345824583058315821581D582058F958FA59600000 +B4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5A775A9A5A7F5A925A9B5AA75B735B715BD25BCC5BD35BD05C0A5C0B5C315D4C +5D505D345D475DFD5E455E3D5E405E435E7E5ECA5EC15EC25EC45F3C5F6D5FA9 +5FAA5FA860D160E160B260B660E0611C612360FA611560F060FB60F4616860F1 +610E60F6610961006112621F624963A3638C63CF63C063E963C963C663CD0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000063D263E363D063E163D663ED63EE637663F463EA63DB645263DA63F9655E +6566656265636591659065AF666E667066746676666F6691667A667E667766FE +66FF671F671D68FA68D568E068D868D7690568DF68F568EE68E768F968D268F2 +68E368CB68CD690D6912690E68C968DA696E68FB6B3E6B3A6B3D6B986B966BBC +6BEF6C2E6C2F6C2C6E2F6E386E546E216E326E676E4A6E206E256E236E1B6E5B +6E586E246E566E6E6E2D6E266E6F6E346E4D6E3A6E2C6E436E1D6E3E6ECB0000 +B5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6E896E196E4E6E636E446E726E696E5F7119711A7126713071217136716E711C +724C728472807336732573347329743A742A743374227425743574367434742F +741B7426742875257526756B756A75E275DB75E375D975D875DE75E0767B767C +7696769376B476DC774F77ED785D786C786F7A0D7A087A0B7A057A007A980000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007A977A967AE57AE37B497B567B467B507B527B547B4D7B4B7B4F7B517C9F +7CA57D5E7D507D687D557D2B7D6E7D727D617D667D627D707D7355847FD47FD5 +800B8052808581558154814B8151814E81398146813E814C815381748212821C +83E9840383F8840D83E083C5840B83C183EF83F183F48457840A83F0840C83CC +83FD83F283CA8438840E840483DC840783D483DF865B86DF86D986ED86D486DB +86E486D086DE885788C188C288B1898389968A3B8A608A558A5E8A3C8A410000 +B6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8A548A5B8A508A468A348A3A8A368A568C618C828CAF8CBC8CB38CBD8CC18CBB +8CC08CB48CB78CB68CBF8CB88D8A8D858D818DCE8DDD8DCB8DDA8DD18DCC8DDB +8DC68EFB8EF88EFC8F9C902E90359031903890329036910290F5910990FE9163 +916591CF9214921592239209921E920D9210920792119594958F958B95910000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000095939592958E968A968E968B967D96859686968D9672968496C196C596C4 +96C696C796EF96F297CC98059806980898E798EA98EF98E998F298ED99AE99AD +9EC39ECD9ED14E8250AD50B550B250B350C550BE50AC50B750BB50AF50C7527F +5277527D52DF52E652E452E252E3532F55DF55E855D355E655CE55DC55C755D1 +55E355E455EF55DA55E155C555C655E555C957125713585E585158585857585A +5854586B584C586D584A58625852584B59675AC15AC95ACC5ABE5ABD5ABC0000 +B7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5AB35AC25AB25D695D6F5E4C5E795EC95EC85F125F595FAC5FAE611A610F6148 +611F60F3611B60F961016108614E614C6144614D613E61346127610D61066137 +622162226413643E641E642A642D643D642C640F641C6414640D643664166417 +6406656C659F65B06697668966876688669666846698668D67036994696D0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000695A697769606954697569306982694A6968696B695E695369796986695D +6963695B6B476B726BC06BBF6BD36BFD6EA26EAF6ED36EB66EC26E906E9D6EC7 +6EC56EA56E986EBC6EBA6EAB6ED16E966E9C6EC46ED46EAA6EA76EB4714E7159 +7169716471497167715C716C7166714C7165715E714671687156723A72527337 +7345733F733E746F745A7455745F745E7441743F7459745B745C757675787600 +75F0760175F275F175FA75FF75F475F376DE76DF775B776B7766775E77630000 +B8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +7779776A776C775C77657768776277EE788E78B078977898788C7889787C7891 +7893787F797A797F7981842C79BD7A1C7A1A7A207A147A1F7A1E7A9F7AA07B77 +7BC07B607B6E7B677CB17CB37CB57D937D797D917D817D8F7D5B7F6E7F697F6A +7F727FA97FA87FA480568058808680848171817081788165816E8173816B0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008179817A81668205824784828477843D843184758466846B8449846C845B +843C8435846184638469846D8446865E865C865F86F9871387088707870086FE +86FB870287038706870A885988DF88D488D988DC88D888DD88E188CA88D588D2 +899C89E38A6B8A728A738A668A698A708A878A7C8A638AA08A718A858A6D8A62 +8A6E8A6C8A798A7B8A3E8A688C628C8A8C898CCA8CC78CC88CC48CB28CC38CC2 +8CC58DE18DDF8DE88DEF8DF38DFA8DEA8DE48DE68EB28F038F098EFE8F0A0000 +B9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8F9F8FB2904B904A905390429054903C905590509047904F904E904D9051903E +904191129117916C916A916991C9923792579238923D9240923E925B924B9264 +925192349249924D92459239923F925A959896989694969596CD96CB96C996CA +96F796FB96F996F6975697749776981098119813980A9812980C98FC98F40000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000098FD98FE99B399B199B49AE19CE99E829F0E9F139F2050E750EE50E550D6 +50ED50DA50D550CF50D150F150CE50E9516251F352835282533153AD55FE5600 +561B561755FD561456065609560D560E55F75616561F5608561055F657185716 +5875587E58835893588A58795885587D58FD592559225924596A59695AE15AE6 +5AE95AD75AD65AD85AE35B755BDE5BE75BE15BE55BE65BE85BE25BE45BDF5C0D +5C625D845D875E5B5E635E555E575E545ED35ED65F0A5F465F705FB961470000 +BA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +613F614B617761626163615F615A61586175622A64876458645464A46478645F +647A645164676434646D647B657265A165D765D666A266A8669D699C69A86995 +69C169AE69D369CB699B69B769BB69AB69B469D069CD69AD69CC69A669C369A3 +6B496B4C6C336F336F146EFE6F136EF46F296F3E6F206F2C6F0F6F026F220000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006EFF6EEF6F066F316F386F326F236F156F2B6F2F6F886F2A6EEC6F016EF2 +6ECC6EF771947199717D718A71847192723E729272967344735074647463746A +7470746D750475917627760D760B7609761376E176E37784777D777F776178C1 +789F78A778B378A978A3798E798F798D7A2E7A317AAA7AA97AED7AEF7BA17B95 +7B8B7B757B977B9D7B947B8F7BB87B877B847CB97CBD7CBE7DBB7DB07D9C7DBD +7DBE7DA07DCA7DB47DB27DB17DBA7DA27DBF7DB57DB87DAD7DD27DC77DAC0000 +BB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +7F707FE07FE17FDF805E805A808781508180818F8188818A817F818281E781FA +82078214821E824B84C984BF84C684C48499849E84B2849C84CB84B884C084D3 +849084BC84D184CA873F871C873B872287258734871887558737872988F38902 +88F488F988F888FD88E8891A88EF8AA68A8C8A9E8AA38A8D8AA18A938AA40000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008AAA8AA58AA88A988A918A9A8AA78C6A8C8D8C8C8CD38CD18CD28D6B8D99 +8D958DFC8F148F128F158F138FA390609058905C90639059905E9062905D905B +91199118911E917591789177917492789280928592989296927B9293929C92A8 +927C929195A195A895A995A395A595A49699969C969B96CC96D29700977C9785 +97F69817981898AF98B199039905990C990999C19AAF9AB09AE69B419B429CF4 +9CF69CF39EBC9F3B9F4A5104510050FB50F550F9510251085109510551DC0000 +BC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +528752885289528D528A52F053B2562E563B56395632563F563456295653564E +565756745636562F56305880589F589E58B3589C58AE58A958A6596D5B095AFB +5B0B5AF55B0C5B085BEE5BEC5BE95BEB5C645C655D9D5D945E625E5F5E615EE2 +5EDA5EDF5EDD5EE35EE05F485F715FB75FB561766167616E615D615561820000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000617C6170616B617E61A7619061AB618E61AC619A61A4619461AE622E6469 +646F6479649E64B26488649064B064A56493649564A9649264AE64AD64AB649A +64AC649964A264B365756577657866AE66AB66B466B16A236A1F69E86A016A1E +6A1969FD6A216A136A0A69F36A026A0569ED6A116B506B4E6BA46BC56BC66F3F +6F7C6F846F516F666F546F866F6D6F5B6F786F6E6F8E6F7A6F706F646F976F58 +6ED56F6F6F606F5F719F71AC71B171A87256729B734E73577469748B74830000 +BD +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +747E7480757F76207629761F7624762676217622769A76BA76E4778E7787778C +7791778B78CB78C578BA78CA78BE78D578BC78D07A3F7A3C7A407A3D7A377A3B +7AAF7AAE7BAD7BB17BC47BB47BC67BC77BC17BA07BCC7CCA7DE07DF47DEF7DFB +7DD87DEC7DDD7DE87DE37DDA7DDE7DE97D9E7DD97DF27DF97F757F777FAF0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007FE98026819B819C819D81A0819A81988517853D851A84EE852C852D8513 +851185238521851484EC852584FF850687828774877687608766877887688759 +8757874C8753885B885D89108907891289138915890A8ABC8AD28AC78AC48A95 +8ACB8AF88AB28AC98AC28ABF8AB08AD68ACD8AB68AB98ADB8C4C8C4E8C6C8CE0 +8CDE8CE68CE48CEC8CED8CE28CE38CDC8CEA8CE18D6D8D9F8DA38E2B8E108E1D +8E228E0F8E298E1F8E218E1E8EBA8F1D8F1B8F1F8F298F268F2A8F1C8F1E0000 +BE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8F259069906E9068906D90779130912D9127913191879189918B918392C592BB +92B792EA92AC92E492C192B392BC92D292C792F092B295AD95B1970497069707 +97099760978D978B978F9821982B981C98B3990A99139912991899DD99D099DF +99DB99D199D599D299D99AB79AEE9AEF9B279B459B449B779B6F9D069D090000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009D039EA99EBE9ECE58A89F5251125118511451105115518051AA51DD5291 +529352F35659566B5679566956645678566A566856655671566F566C56625676 +58C158BE58C758C5596E5B1D5B345B785BF05C0E5F4A61B2619161A9618A61CD +61B661BE61CA61C8623064C564C164CB64BB64BC64DA64C464C764C264CD64BF +64D264D464BE657466C666C966B966C466C766B86A3D6A386A3A6A596A6B6A58 +6A396A446A626A616A4B6A476A356A5F6A486B596B776C056FC26FB16FA10000 +BF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6FC36FA46FC16FA76FB36FC06FB96FB66FA66FA06FB471BE71C971D071D271C8 +71D571B971CE71D971DC71C371C47368749C74A37498749F749E74E2750C750D +76347638763A76E776E577A0779E779F77A578E878DA78EC78E779A67A4D7A4E +7A467A4C7A4B7ABA7BD97C117BC97BE47BDB7BE17BE97BE67CD57CD67E0A0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007E117E087E1B7E237E1E7E1D7E097E107F797FB27FF07FF17FEE802881B3 +81A981A881FB820882588259854A855985488568856985438549856D856A855E +8783879F879E87A2878D8861892A89328925892B892189AA89A68AE68AFA8AEB +8AF18B008ADC8AE78AEE8AFE8B018B028AF78AED8AF38AF68AFC8C6B8C6D8C93 +8CF48E448E318E348E428E398E358F3B8F2F8F388F338FA88FA6907590749078 +9072907C907A913491929320933692F89333932F932292FC932B9304931A0000 +C0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +9310932693219315932E931995BB96A796A896AA96D5970E97119716970D9713 +970F975B975C9766979898309838983B9837982D9839982499109928991E991B +9921991A99ED99E299F19AB89ABC9AFB9AED9B289B919D159D239D269D289D12 +9D1B9ED89ED49F8D9F9C512A511F5121513252F5568E56805690568556870000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000568F58D558D358D158CE5B305B2A5B245B7A5C375C685DBC5DBA5DBD5DB8 +5E6B5F4C5FBD61C961C261C761E661CB6232623464CE64CA64D864E064F064E6 +64EC64F164E264ED6582658366D966D66A806A946A846AA26A9C6ADB6AA36A7E +6A976A906AA06B5C6BAE6BDA6C086FD86FF16FDF6FE06FDB6FE46FEB6FEF6F80 +6FEC6FE16FE96FD56FEE6FF071E771DF71EE71E671E571ED71EC71F471E07235 +72467370737274A974B074A674A876467642764C76EA77B377AA77B077AC0000 +C1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +77A777AD77EF78F778FA78F478EF790179A779AA7A577ABF7C077C0D7BFE7BF7 +7C0C7BE07CE07CDC7CDE7CE27CDF7CD97CDD7E2E7E3E7E467E377E327E437E2B +7E3D7E317E457E417E347E397E487E357E3F7E2F7F447FF37FFC807180728070 +806F807381C681C381BA81C281C081BF81BD81C981BE81E88209827185AA0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008584857E859C8591859485AF859B858785A8858A866787C087D187B387D2 +87C687AB87BB87BA87C887CB893B893689448938893D89AC8B0E8B178B198B1B +8B0A8B208B1D8B048B108C418C3F8C738CFA8CFD8CFC8CF88CFB8DA88E498E4B +8E488E4A8F448F3E8F428F458F3F907F907D9084908190829080913991A3919E +919C934D938293289375934A9365934B9318937E936C935B9370935A935495CA +95CB95CC95C895C696B196B896D6971C971E97A097D3984698B699359A010000 +C2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +99FF9BAE9BAB9BAA9BAD9D3B9D3F9E8B9ECF9EDE9EDC9EDD9EDB9F3E9F4B53E2 +569556AE58D958D85B385F5D61E3623364F464F264FE650664FA64FB64F765B7 +66DC67266AB36AAC6AC36ABB6AB86AC26AAE6AAF6B5F6B786BAF7009700B6FFE +70066FFA7011700F71FB71FC71FE71F87377737574A774BF7515765676580000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000765277BD77BF77BB77BC790E79AE7A617A627A607AC47AC57C2B7C277C2A +7C1E7C237C217CE77E547E557E5E7E5A7E617E527E597F487FF97FFB80778076 +81CD81CF820A85CF85A985CD85D085C985B085BA85B985A687EF87EC87F287E0 +898689B289F48B288B398B2C8B2B8C508D058E598E638E668E648E5F8E558EC0 +8F498F4D90879083908891AB91AC91D09394938A939693A293B393AE93AC93B0 +9398939A939795D495D695D095D596E296DC96D996DB96DE972497A397A60000 +C3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +97AD97F9984D984F984C984E985398BA993E993F993D992E99A59A0E9AC19B03 +9B069B4F9B4E9B4D9BCA9BC99BFD9BC89BC09D519D5D9D609EE09F159F2C5133 +56A558DE58DF58E25BF59F905EEC61F261F761F661F56500650F66E066DD6AE5 +6ADD6ADA6AD3701B701F7028701A701D701570187206720D725872A273780000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000737A74BD74CA74E375877586765F766177C7791979B17A6B7A697C3E7C3F +7C387C3D7C377C407E6B7E6D7E797E697E6A7F857E737FB67FB97FB881D885E9 +85DD85EA85D585E485E585F787FB8805880D87F987FE8960895F8956895E8B41 +8B5C8B588B498B5A8B4E8B4F8B468B598D088D0A8E7C8E728E878E768E6C8E7A +8E748F548F4E8FAD908A908B91B191AE93E193D193DF93C393C893DC93DD93D6 +93E293CD93D893E493D793E895DC96B496E3972A9727976197DC97FB985E0000 +C4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +9858985B98BC994599499A169A199B0D9BE89BE79BD69BDB9D899D619D729D6A +9D6C9E929E979E939EB452F856A856B756B656B456BC58E45B405B435B7D5BF6 +5DC961F861FA65186514651966E667276AEC703E703070327210737B74CF7662 +76657926792A792C792B7AC77AF67C4C7C437C4D7CEF7CF08FAE7E7D7E7C0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007E827F4C800081DA826685FB85F9861185FA8606860B8607860A88148815 +896489BA89F88B708B6C8B668B6F8B5F8B6B8D0F8D0D8E898E818E858E8291B4 +91CB9418940393FD95E1973098C49952995199A89A2B9A309A379A359C139C0D +9E799EB59EE89F2F9F5F9F639F615137513856C156C056C259145C6C5DCD61FC +61FE651D651C659566E96AFB6B046AFA6BB2704C721B72A774D674D4766977D3 +7C507E8F7E8C7FBC8617862D861A882388228821881F896A896C89BD8B740000 +C5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8B778B7D8D138E8A8E8D8E8B8F5F8FAF91BA942E94339435943A94389432942B +95E297389739973297FF9867986599579A459A439A409A3E9ACF9B549B519C2D +9C259DAF9DB49DC29DB89E9D9EEF9F199F5C9F669F67513C513B56C856CA56C9 +5B7F5DD45DD25F4E61FF65246B0A6B6170517058738074E4758A766E766C0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000079B37C607C5F807E807D81DF8972896F89FC8B808D168D178E918E938F61 +9148944494519452973D973E97C397C1986B99559A559A4D9AD29B1A9C499C31 +9C3E9C3B9DD39DD79F349F6C9F6A9F9456CC5DD662006523652B652A66EC6B10 +74DA7ACA7C647C637C657E937E967E9481E28638863F88318B8A9090908F9463 +946094649768986F995C9A5A9A5B9A579AD39AD49AD19C549C579C569DE59E9F +9EF456D158E9652C705E7671767277D77F507F888836883988628B938B920000 +C6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8B9682778D1B91C0946A97429748974497C698709A5F9B229B589C5F9DF99DFA +9E7C9E7D9F079F779F725EF36B1670637C6C7C6E883B89C08EA191C194729470 +9871995E9AD69B239ECC706477DA8B9A947797C99A629A657E9C8B9C8EAA91C5 +947D947E947C9C779C789EF78C54947F9E1A72289A6A9B319E1B9E1E7C720000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +C9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +4E424E5C51F5531A53824E074E0C4E474E8D56D7FA0C5C6E5F734E0F51874E0E +4E2E4E934EC24EC94EC8519852FC536C53B957205903592C5C105DFF65E16BB3 +6BCC6C14723F4E314E3C4EE84EDC4EE94EE14EDD4EDA520C531C534C57225723 +5917592F5B815B845C125C3B5C745C735E045E805E825FC9620962506C150000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006C366C436C3F6C3B72AE72B0738A79B8808A961E4F0E4F184F2C4EF54F14 +4EF14F004EF74F084F1D4F024F054F224F134F044EF44F1251B1521352095210 +52A65322531F534D538A540756E156DF572E572A5734593C5980597C5985597B +597E5977597F5B565C155C255C7C5C7A5C7B5C7E5DDF5E755E845F025F1A5F74 +5FD55FD45FCF625C625E626462616266626262596260625A626565EF65EE673E +67396738673B673A673F673C67336C186C466C526C5C6C4F6C4A6C546C4B0000 +CA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6C4C7071725E72B472B5738E752A767F7A757F518278827C8280827D827F864D +897E909990979098909B909496229624962096234F564F3B4F624F494F534F64 +4F3E4F674F524F5F4F414F584F2D4F334F3F4F61518F51B9521C521E522152AD +52AE530953635372538E538F54305437542A545454455419541C542554180000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000543D544F544154285424544756EE56E756E557415745574C5749574B5752 +5906594059A6599859A05997598E59A25990598F59A759A15B8E5B925C285C2A +5C8D5C8F5C885C8B5C895C925C8A5C865C935C955DE05E0A5E0E5E8B5E895E8C +5E885E8D5F055F1D5F785F765FD25FD15FD05FED5FE85FEE5FF35FE15FE45FE3 +5FFA5FEF5FF75FFB60005FF4623A6283628C628E628F629462876271627B627A +6270628162886277627D62726274653765F065F465F365F265F5674567470000 +CB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +67596755674C6748675D674D675A674B6BD06C196C1A6C786C676C6B6C846C8B +6C8F6C716C6F6C696C9A6C6D6C876C956C9C6C666C736C656C7B6C8E7074707A +726372BF72BD72C372C672C172BA72C573957397739373947392753A75397594 +75957681793D80348095809980908092809C8290828F8285828E829182930000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000828A828382848C788FC98FBF909F90A190A5909E90A790A096309628962F +962D4E334F984F7C4F854F7D4F804F874F764F744F894F844F774F4C4F974F6A +4F9A4F794F814F784F904F9C4F944F9E4F924F824F954F6B4F6E519E51BC51BE +5235523252335246523152BC530A530B533C539253945487547F548154915482 +5488546B547A547E5465546C54745466548D546F546154605498546354675464 +56F756F9576F5772576D576B57715770577657805775577B5773577457620000 +CC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5768577D590C594559B559BA59CF59CE59B259CC59C159B659BC59C359D659B1 +59BD59C059C859B459C75B625B655B935B955C445C475CAE5CA45CA05CB55CAF +5CA85CAC5C9F5CA35CAD5CA25CAA5CA75C9D5CA55CB65CB05CA65E175E145E19 +5F285F225F235F245F545F825F7E5F7D5FDE5FE5602D602660196032600B0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006034600A60176033601A601E602C6022600D6010602E60136011600C6009 +601C6214623D62AD62B462D162BE62AA62B662CA62AE62B362AF62BB62A962B0 +62B8653D65A865BB660965FC66046612660865FB6603660B660D660565FD6611 +661066F6670A6785676C678E67926776677B6798678667846774678D678C677A +679F679167996783677D67816778677967946B256B806B7E6BDE6C1D6C936CEC +6CEB6CEE6CD96CB66CD46CAD6CE76CB76CD06CC26CBA6CC36CC66CED6CF20000 +CD +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6CD26CDD6CB46C8A6C9D6C806CDE6CC06D306CCD6CC76CB06CF96CCF6CE96CD1 +709470987085709370867084709170967082709A7083726A72D672CB72D872C9 +72DC72D272D472DA72CC72D173A473A173AD73A673A273A073AC739D74DD74E8 +753F7540753E758C759876AF76F376F176F076F577F877FC77F977FB77FA0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000077F77942793F79C57A787A7B7AFB7C757CFD8035808F80AE80A380B880B5 +80AD822082A082C082AB829A8298829B82B582A782AE82BC829E82BA82B482A8 +82A182A982C282A482C382B682A28670866F866D866E8C568FD28FCB8FD38FCD +8FD68FD58FD790B290B490AF90B390B09639963D963C963A96434FCD4FC54FD3 +4FB24FC94FCB4FC14FD44FDC4FD94FBB4FB34FDB4FC74FD64FBA4FC04FB94FEC +5244524952C052C2533D537C539753965399539854BA54A154AD54A554CF0000 +CE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +54C3830D54B754AE54D654B654C554C654A0547054BC54A254BE547254DE54B0 +57B5579E579F57A4578C5797579D579B57945798578F579957A5579A579558F4 +590D595359E159DE59EE5A0059F159DD59FA59FD59FC59F659E459F259F759DB +59E959F359F559E059FE59F459ED5BA85C4C5CD05CD85CCC5CD75CCB5CDB0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005CDE5CDA5CC95CC75CCA5CD65CD35CD45CCF5CC85CC65CCE5CDF5CF85DF9 +5E215E225E235E205E245EB05EA45EA25E9B5EA35EA55F075F2E5F565F866037 +603960546072605E6045605360476049605B604C60406042605F602460446058 +6066606E6242624362CF630D630B62F5630E630362EB62F9630F630C62F862F6 +63006313631462FA631562FB62F06541654365AA65BF6636662166326635661C +662666226633662B663A661D66346639662E670F671067C167F267C867BA0000 +CF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +67DC67BB67F867D867C067B767C567EB67E467DF67B567CD67B367F767F667EE +67E367C267B967CE67E767F067B267FC67C667ED67CC67AE67E667DB67FA67C9 +67CA67C367EA67CB6B286B826B846BB66BD66BD86BE06C206C216D286D346D2D +6D1F6D3C6D3F6D126D0A6CDA6D336D046D196D3A6D1A6D116D006D1D6D420000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006D016D186D376D036D0F6D406D076D206D2C6D086D226D096D1070B7709F +70BE70B170B070A170B470B570A972417249724A726C72707273726E72CA72E4 +72E872EB72DF72EA72E672E3738573CC73C273C873C573B973B673B573B473EB +73BF73C773BE73C373C673B873CB74EC74EE752E7547754875A775AA767976C4 +7708770377047705770A76F776FB76FA77E777E878067811781278057810780F +780E780978037813794A794C794B7945794479D579CD79CF79D679CE7A800000 +D0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +7A7E7AD17B007B017C7A7C787C797C7F7C807C817D037D087D017F587F917F8D +7FBE8007800E800F8014803780D880C780E080D180C880C280D080C580E380D9 +80DC80CA80D580C980CF80D780E680CD81FF8221829482D982FE82F9830782E8 +830082D5833A82EB82D682F482EC82E182F282F5830C82FB82F682F082EA0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000082E482E082FA82F382ED86778674867C86738841884E8867886A886989D3 +8A048A078D728FE38FE18FEE8FE090F190BD90BF90D590C590BE90C790CB90C8 +91D491D39654964F96519653964A964E501E50055007501350225030501B4FF5 +4FF450335037502C4FF64FF75017501C502050275035502F5031500E515A5194 +519351CA51C451C551C851CE5261525A5252525E525F5255526252CD530E539E +552654E25517551254E754F354E4551A54FF5504550854EB5511550554F10000 +D1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +550A54FB54F754F854E0550E5503550B5701570257CC583257D557D257BA57C6 +57BD57BC57B857B657BF57C757D057B957C1590E594A5A195A165A2D5A2E5A15 +5A0F5A175A0A5A1E5A335B6C5BA75BAD5BAC5C035C565C545CEC5CFF5CEE5CF1 +5CF75D005CF95E295E285EA85EAE5EAA5EAC5F335F305F67605D605A60670000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000604160A26088608060926081609D60836095609B60976087609C608E6219 +624662F263106356632C634463456336634363E46339634B634A633C63296341 +6334635863546359632D63476333635A63516338635763406348654A654665C6 +65C365C465C2664A665F6647665167126713681F681A684968326833683B684B +684F68166831681C6835682B682D682F684E68446834681D6812681468266828 +682E684D683A682568206B2C6B2F6B2D6B316B346B6D80826B886BE66BE40000 +D2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6BE86BE36BE26BE76C256D7A6D636D646D766D0D6D616D926D586D626D6D6D6F +6D916D8D6DEF6D7F6D866D5E6D676D606D976D706D7C6D5F6D826D986D2F6D68 +6D8B6D7E6D806D846D166D836D7B6D7D6D756D9070DC70D370D170DD70CB7F39 +70E270D770D270DE70E070D470CD70C570C670C770DA70CE70E1724272780000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000072777276730072FA72F472FE72F672F372FB730173D373D973E573D673BC +73E773E373E973DC73D273DB73D473DD73DA73D773D873E874DE74DF74F474F5 +7521755B755F75B075C175BB75C475C075BF75B675BA768A76C9771D771B7710 +771377127723771177157719771A772277277823782C78227835782F7828782E +782B782178297833782A78317954795B794F795C79537952795179EB79EC79E0 +79EE79ED79EA79DC79DE79DD7A867A897A857A8B7A8C7A8A7A877AD87B100000 +D3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +7B047B137B057B0F7B087B0A7B0E7B097B127C847C917C8A7C8C7C887C8D7C85 +7D1E7D1D7D117D0E7D187D167D137D1F7D127D0F7D0C7F5C7F617F5E7F607F5D +7F5B7F967F927FC37FC27FC08016803E803980FA80F280F980F5810180FB8100 +8201822F82258333832D83448319835183258356833F83418326831C83220000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008342834E831B832A8308833C834D8316832483208337832F832983478345 +834C8353831E832C834B832783488653865286A286A88696868D8691869E8687 +86978686868B869A868586A5869986A186A786958698868E869D869086948843 +8844886D88758876887288808871887F886F8883887E8874887C8A128C478C57 +8C7B8CA48CA38D768D788DB58DB78DB68ED18ED38FFE8FF590028FFF8FFB9004 +8FFC8FF690D690E090D990DA90E390DF90E590D890DB90D790DC90E491500000 +D4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +914E914F91D591E291DA965C965F96BC98E39ADF9B2F4E7F5070506A5061505E +50605053504B505D50725048504D5041505B504A506250155045505F5069506B +5063506450465040506E50735057505151D0526B526D526C526E52D652D3532D +539C55755576553C554D55505534552A55515562553655355530555255450000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000550C55325565554E55395548552D553B5540554B570A570757FB581457E2 +57F657DC57F4580057ED57FD580857F8580B57F357CF580757EE57E357F257E5 +57EC57E1580E57FC581057E75801580C57F157E957F0580D5804595C5A605A58 +5A555A675A5E5A385A355A6D5A505A5F5A655A6C5A535A645A575A435A5D5A52 +5A445A5B5A485A8E5A3E5A4D5A395A4C5A705A695A475A515A565A425A5C5B72 +5B6E5BC15BC05C595D1E5D0B5D1D5D1A5D205D0C5D285D0D5D265D255D0F0000 +D5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5D305D125D235D1F5D2E5E3E5E345EB15EB45EB95EB25EB35F365F385F9B5F96 +5F9F608A6090608660BE60B060BA60D360D460CF60E460D960DD60C860B160DB +60B760CA60BF60C360CD60C063326365638A6382637D63BD639E63AD639D6397 +63AB638E636F63876390636E63AF6375639C636D63AE637C63A4633B639F0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006378638563816391638D6370655365CD66656661665B6659665C66626718 +687968876890689C686D686E68AE68AB6956686F68A368AC68A96875687468B2 +688F68776892687C686B687268AA68806871687E689B6896688B68A0688968A4 +6878687B6891688C688A687D6B366B336B376B386B916B8F6B8D6B8E6B8C6C2A +6DC06DAB6DB46DB36E746DAC6DE96DE26DB76DF66DD46E006DC86DE06DDF6DD6 +6DBE6DE56DDC6DDD6DDB6DF46DCA6DBD6DED6DF06DBA6DD56DC26DCF6DC90000 +D6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6DD06DF26DD36DFD6DD76DCD6DE36DBB70FA710D70F7711770F4710C70F07104 +70F3711070FC70FF71067113710070F870F6710B7102710E727E727B727C727F +731D7317730773117318730A730872FF730F731E738873F673F873F574047401 +73FD7407740073FA73FC73FF740C740B73F474087564756375CE75D275CF0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000075CB75CC75D175D0768F768976D37739772F772D7731773277347733773D +7725773B7735784878527849784D784A784C782678457850796479677969796A +7963796B796179BB79FA79F879F679F77A8F7A947A907B357B477B347B257B30 +7B227B247B337B187B2A7B1D7B317B2B7B2D7B2F7B327B387B1A7B237C947C98 +7C967CA37D357D3D7D387D367D3A7D457D2C7D297D417D477D3E7D3F7D4A7D3B +7D287F637F957F9C7F9D7F9B7FCA7FCB7FCD7FD07FD17FC77FCF7FC9801F0000 +D7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +801E801B804780438048811881258119811B812D811F812C811E812181158127 +811D8122821182388233823A823482328274839083A383A8838D837A837383A4 +8374838F8381839583998375839483A9837D8383838C839D839B83AA838B837E +83A583AF8388839783B0837F83A6838783AE8376839A8659865686BF86B70000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000086C286C186C586BA86B086C886B986B386B886CC86B486BB86BC86C386BD +86BE88528889889588A888A288AA889A889188A1889F889888A78899889B8897 +88A488AC888C8893888E898289D689D989D58A308A278A2C8A1E8C398C3B8C5C +8C5D8C7D8CA58D7D8D7B8D798DBC8DC28DB98DBF8DC18ED88EDE8EDD8EDC8ED7 +8EE08EE19024900B9011901C900C902190EF90EA90F090F490F290F390D490EB +90EC90E991569158915A9153915591EC91F491F191F391F891E491F991EA0000 +D8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +91EB91F791E891EE957A95869588967C966D966B9671966F96BF976A980498E5 +9997509B50955094509E508B50A35083508C508E509D5068509C509250825087 +515F51D45312531153A453A7559155A855A555AD5577564555A255935588558F +55B5558155A3559255A4557D558C55A6557F559555A1558E570C582958370000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005819581E58275823582857F558485825581C581B5833583F5836582E5839 +5838582D582C583B59615AAF5A945A9F5A7A5AA25A9E5A785AA65A7C5AA55AAC +5A955AAE5A375A845A8A5A975A835A8B5AA95A7B5A7D5A8C5A9C5A8F5A935A9D +5BEA5BCD5BCB5BD45BD15BCA5BCE5C0C5C305D375D435D6B5D415D4B5D3F5D35 +5D515D4E5D555D335D3A5D525D3D5D315D595D425D395D495D385D3C5D325D36 +5D405D455E445E415F585FA65FA55FAB60C960B960CC60E260CE60C461140000 +D9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +60F2610A6116610560F5611360F860FC60FE60C161036118611D611060FF6104 +610B624A639463B163B063CE63E563E863EF63C3649D63F363CA63E063F663D5 +63F263F5646163DF63BE63DD63DC63C463D863D363C263C763CC63CB63C863F0 +63D763D965326567656A6564655C65686565658C659D659E65AE65D065D20000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000667C666C667B668066716679666A66726701690C68D3690468DC692A68EC +68EA68F1690F68D668F768EB68E468F66913691068F368E1690768CC69086970 +68B4691168EF68C6691468F868D068FD68FC68E8690B690A691768CE68C868DD +68DE68E668F468D1690668D468E96915692568C76B396B3B6B3F6B3C6B946B97 +6B996B956BBD6BF06BF26BF36C306DFC6E466E476E1F6E496E886E3C6E3D6E45 +6E626E2B6E3F6E416E5D6E736E1C6E336E4B6E406E516E3B6E036E2E6E5E0000 +DA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6E686E5C6E616E316E286E606E716E6B6E396E226E306E536E656E276E786E64 +6E776E556E796E526E666E356E366E5A7120711E712F70FB712E713171237125 +71227132711F7128713A711B724B725A7288728972867285728B7312730B7330 +73227331733373277332732D732673237335730C742E742C7430742B74160000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000741A7421742D743174247423741D74297420743274FB752F756F756C75E7 +75DA75E175E675DD75DF75E475D77695769276DA774677477744774D7745774A +774E774B774C77DE77EC786078647865785C786D7871786A786E787078697868 +785E786279747973797279707A027A0A7A037A0C7A047A997AE67AE47B4A7B3B +7B447B487B4C7B4E7B407B587B457CA27C9E7CA87CA17D587D6F7D637D537D56 +7D677D6A7D4F7D6D7D5C7D6B7D527D547D697D517D5F7D4E7F3E7F3F7F650000 +DB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +7F667FA27FA07FA17FD78051804F805080FE80D48143814A8152814F8147813D +814D813A81E681EE81F781F881F98204823C823D823F8275833B83CF83F98423 +83C083E8841283E783E483FC83F6841083C683C883EB83E383BF840183DD83E5 +83D883FF83E183CB83CE83D683F583C98409840F83DE8411840683C283F30000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000083D583FA83C783D183EA841383C383EC83EE83C483FB83D783E2841B83DB +83FE86D886E286E686D386E386DA86EA86DD86EB86DC86EC86E986D786E886D1 +88488856885588BA88D788B988B888C088BE88B688BC88B788BD88B2890188C9 +89958998899789DD89DA89DB8A4E8A4D8A398A598A408A578A588A448A458A52 +8A488A518A4A8A4C8A4F8C5F8C818C808CBA8CBE8CB08CB98CB58D848D808D89 +8DD88DD38DCD8DC78DD68DDC8DCF8DD58DD98DC88DD78DC58EEF8EF78EFA0000 +DC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8EF98EE68EEE8EE58EF58EE78EE88EF68EEB8EF18EEC8EF48EE9902D9034902F +9106912C910490FF90FC910890F990FB9101910091079105910391619164915F +916291609201920A92259203921A9226920F920C9200921291FF91FD92069204 +92279202921C92249219921792059216957B958D958C95909687967E96880000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000096899683968096C296C896C396F196F0976C9770976E980798A998EB9CE6 +9EF94E834E844EB650BD50BF50C650AE50C450CA50B450C850C250B050C150BA +50B150CB50C950B650B851D7527A5278527B527C55C355DB55CC55D055CB55CA +55DD55C055D455C455E955BF55D2558D55CF55D555E255D655C855F255CD55D9 +55C25714585358685864584F584D5849586F5855584E585D58595865585B583D +5863587158FC5AC75AC45ACB5ABA5AB85AB15AB55AB05ABF5AC85ABB5AC60000 +DD +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5AB75AC05ACA5AB45AB65ACD5AB95A905BD65BD85BD95C1F5C335D715D635D4A +5D655D725D6C5D5E5D685D675D625DF05E4F5E4E5E4A5E4D5E4B5EC55ECC5EC6 +5ECB5EC75F405FAF5FAD60F76149614A612B614561366132612E6146612F614F +612961406220916862236225622463C563F163EB641064126409642064240000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000064336443641F641564186439643764226423640C64266430642864416435 +642F640A641A644064256427640B63E7641B642E6421640E656F659265D36686 +668C66956690668B668A66996694667867206966695F6938694E69626971693F +6945696A6939694269576959697A694869496935696C6933693D696568F06978 +693469696940696F69446976695869416974694C693B694B6937695C694F6951 +69326952692F697B693C6B466B456B436B426B486B416B9BFA0D6BFB6BFC0000 +DE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6BF96BF76BF86E9B6ED66EC86E8F6EC06E9F6E936E946EA06EB16EB96EC66ED2 +6EBD6EC16E9E6EC96EB76EB06ECD6EA66ECF6EB26EBE6EC36EDC6ED86E996E92 +6E8E6E8D6EA46EA16EBF6EB36ED06ECA6E976EAE6EA371477154715271637160 +7141715D716271727178716A7161714271587143714B7170715F715071530000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007144714D715A724F728D728C72917290728E733C7342733B733A7340734A +73497444744A744B7452745174577440744F7450744E74427446744D745474E1 +74FF74FE74FD751D75797577698375EF760F760375F775FE75FC75F975F87610 +75FB75F675ED75F575FD769976B576DD7755775F776077527756775A77697767 +77547759776D77E07887789A7894788F788478957885788678A1788378797899 +78807896787B797C7982797D79797A117A187A197A127A177A157A227A130000 +DF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +7A1B7A107AA37AA27A9E7AEB7B667B647B6D7B747B697B727B657B737B717B70 +7B617B787B767B637CB27CB47CAF7D887D867D807D8D7D7F7D857D7A7D8E7D7B +7D837D7C7D8C7D947D847D7D7D927F6D7F6B7F677F687F6C7FA67FA57FA77FDB +7FDC8021816481608177815C8169815B816281726721815E81768167816F0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000081448161821D8249824482408242824584F1843F845684768479848F848D +846584518440848684678430844D847D845A845984748473845D8507845E8437 +843A8434847A8443847884328445842983D9844B842F8442842D845F84708439 +844E844C8452846F84C5848E843B8447843684338468847E8444842B84608454 +846E8450870B870486F7870C86FA86D686F5874D86F8870E8709870186F6870D +870588D688CB88CD88CE88DE88DB88DA88CC88D08985899B89DF89E589E40000 +E0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +89E189E089E289DC89E68A768A868A7F8A618A3F8A778A828A848A758A838A81 +8A748A7A8C3C8C4B8C4A8C658C648C668C868C848C858CCC8D688D698D918D8C +8D8E8D8F8D8D8D938D948D908D928DF08DE08DEC8DF18DEE8DD08DE98DE38DE2 +8DE78DF28DEB8DF48F068EFF8F018F008F058F078F088F028F0B9052903F0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000090449049903D9110910D910F911191169114910B910E916E916F92489252 +9230923A926692339265925E9283922E924A9246926D926C924F92609267926F +92369261927092319254926392509272924E9253924C92569232959F959C959E +959B969296939691969796CE96FA96FD96F896F59773977797789772980F980D +980E98AC98F698F999AF99B299B099B59AAD9AAB9B5B9CEA9CED9CE79E809EFD +50E650D450D750E850F350DB50EA50DD50E450D350EC50F050EF50E350E00000 +E1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +51D85280528152E952EB533053AC56275615560C561255FC560F561C56015613 +560255FA561D560455FF55F95889587C5890589858865881587F5874588B587A +58875891588E587658825888587B5894588F58FE596B5ADC5AEE5AE55AD55AEA +5ADA5AED5AEB5AF35AE25AE05ADB5AEC5ADE5ADD5AD95AE85ADF5B775BE00000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005BE35C635D825D805D7D5D865D7A5D815D775D8A5D895D885D7E5D7C5D8D +5D795D7F5E585E595E535ED85ED15ED75ECE5EDC5ED55ED95ED25ED45F445F43 +5F6F5FB6612C61286141615E61716173615261536172616C618061746154617A +615B6165613B616A6161615662296227622B642B644D645B645D647464766472 +6473647D6475646664A6644E6482645E645C644B645364606450647F643F646C +646B645964656477657365A066A166A0669F67056704672269B169B669C90000 +E2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +69A069CE699669B069AC69BC69916999698E69A7698D69A969BE69AF69BF69C4 +69BD69A469D469B969CA699A69CF69B3699369AA69A1699E69D96997699069C2 +69B569A569C66B4A6B4D6B4B6B9E6B9F6BA06BC36BC46BFE6ECE6EF56EF16F03 +6F256EF86F376EFB6F2E6F096F4E6F196F1A6F276F186F3B6F126EED6F0A0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006F366F736EF96EEE6F2D6F406F306F3C6F356EEB6F076F0E6F436F056EFD +6EF66F396F1C6EFC6F3A6F1F6F0D6F1E6F086F21718771907189718071857182 +718F717B718671817197724472537297729572937343734D7351734C74627473 +7471747574727467746E750075027503757D759076167608760C76157611760A +761476B87781777C77857782776E7780776F777E778378B278AA78B478AD78A8 +787E78AB789E78A578A078AC78A278A47998798A798B79967995799479930000 +E3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +79977988799279907A2B7A4A7A307A2F7A287A267AA87AAB7AAC7AEE7B887B9C +7B8A7B917B907B967B8D7B8C7B9B7B8E7B857B9852847B997BA47B827CBB7CBF +7CBC7CBA7DA77DB77DC27DA37DAA7DC17DC07DC57D9D7DCE7DC47DC67DCB7DCC +7DAF7DB97D967DBC7D9F7DA67DAE7DA97DA17DC97F737FE27FE37FE57FDE0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008024805D805C8189818681838187818D818C818B8215849784A484A1849F +84BA84CE84C284AC84AE84AB84B984B484C184CD84AA849A84B184D0849D84A7 +84BB84A2849484C784CC849B84A984AF84A884D6849884B684CF84A084D784D4 +84D284DB84B084918661873387238728876B8740872E871E87218719871B8743 +872C8741873E874687208732872A872D873C8712873A87318735874287268727 +87388724871A8730871188F788E788F188F288FA88FE88EE88FC88F688FB0000 +E4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +88F088EC88EB899D89A1899F899E89E989EB89E88AAB8A998A8B8A928A8F8A96 +8C3D8C688C698CD58CCF8CD78D968E098E028DFF8E0D8DFD8E0A8E038E078E06 +8E058DFE8E008E048F108F118F0E8F0D9123911C91209122911F911D911A9124 +9121911B917A91729179917392A592A49276929B927A92A0929492AA928D0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000092A6929A92AB92799297927F92A392EE928E9282929592A2927D928892A1 +928A9286928C929992A7927E928792A9929D928B922D969E96A196FF9758977D +977A977E978397809782977B97849781977F97CE97CD981698AD98AE99029900 +9907999D999C99C399B999BB99BA99C299BD99C79AB19AE39AE79B3E9B3F9B60 +9B619B5F9CF19CF29CF59EA750FF5103513050F85106510750F650FE510B510C +50FD510A528B528C52F152EF56485642564C56355641564A5649564656580000 +E5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +565A56405633563D562C563E5638562A563A571A58AB589D58B158A058A358AF +58AC58A558A158FF5AFF5AF45AFD5AF75AF65B035AF85B025AF95B015B075B05 +5B0F5C675D995D975D9F5D925DA25D935D955DA05D9C5DA15D9A5D9E5E695E5D +5E605E5C7DF35EDB5EDE5EE15F495FB2618B6183617961B161B061A261890000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000619B619361AF61AD619F619261AA61A1618D616661B3622D646E64706496 +64A064856497649C648F648B648A648C64A3649F646864B164986576657A6579 +657B65B265B366B566B066A966B266B766AA66AF6A006A066A1769E569F86A15 +69F169E46A2069FF69EC69E26A1B6A1D69FE6A2769F269EE6A1469F769E76A40 +6A0869E669FB6A0D69FC69EB6A096A046A186A256A0F69F66A266A0769F46A16 +6B516BA56BA36BA26BA66C016C006BFF6C026F416F266F7E6F876FC66F920000 +E6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6F8D6F896F8C6F626F4F6F856F5A6F966F766F6C6F826F556F726F526F506F57 +6F946F936F5D6F006F616F6B6F7D6F676F906F536F8B6F696F7F6F956F636F77 +6F6A6F7B71B271AF719B71B071A0719A71A971B5719D71A5719E71A471A171AA +719C71A771B37298729A73587352735E735F7360735D735B7361735A73590000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000736274877489748A74867481747D74857488747C747975087507757E7625 +761E7619761D761C7623761A7628761B769C769D769E769B778D778F77897788 +78CD78BB78CF78CC78D178CE78D478C878C378C478C9799A79A179A0799C79A2 +799B6B767A397AB27AB47AB37BB77BCB7BBE7BAC7BCE7BAF7BB97BCA7BB57CC5 +7CC87CCC7CCB7DF77DDB7DEA7DE77DD77DE17E037DFA7DE67DF67DF17DF07DEE +7DDF7F767FAC7FB07FAD7FED7FEB7FEA7FEC7FE67FE88064806781A3819F0000 +E7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +819E819581A2819981978216824F825382528250824E82518524853B850F8500 +8529850E8509850D851F850A8527851C84FB852B84FA8508850C84F4852A84F2 +851584F784EB84F384FC851284EA84E9851684FE8528851D852E850284FD851E +84F68531852684E784E884F084EF84F9851885208530850B8519852F86620000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000875687638764877787E1877387588754875B87528761875A8751875E876D +876A8750874E875F875D876F876C877A876E875C8765874F877B877587628767 +8769885A8905890C8914890B891789188919890689168911890E890989A289A4 +89A389ED89F089EC8ACF8AC68AB88AD38AD18AD48AD58ABB8AD78ABE8AC08AC5 +8AD88AC38ABA8ABD8AD98C3E8C4D8C8F8CE58CDF8CD98CE88CDA8CDD8CE78DA0 +8D9C8DA18D9B8E208E238E258E248E2E8E158E1B8E168E118E198E268E270000 +E8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8E148E128E188E138E1C8E178E1A8F2C8F248F188F1A8F208F238F168F179073 +9070906F9067906B912F912B9129912A91329126912E91859186918A91819182 +9184918092D092C392C492C092D992B692CF92F192DF92D892E992D792DD92CC +92EF92C292E892CA92C892CE92E692CD92D592C992E092DE92E792D192D30000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000092B592E192C692B4957C95AC95AB95AE95B096A496A296D3970597089702 +975A978A978E978897D097CF981E981D9826982998289820981B982798B29908 +98FA9911991499169917991599DC99CD99CF99D399D499CE99C999D699D899CB +99D799CC9AB39AEC9AEB9AF39AF29AF19B469B439B679B749B719B669B769B75 +9B709B689B649B6C9CFC9CFA9CFD9CFF9CF79D079D009CF99CFB9D089D059D04 +9E839ED39F0F9F10511C51135117511A511151DE533453E156705660566E0000 +E9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +567356665663566D5672565E5677571C571B58C858BD58C958BF58BA58C258BC +58C65B175B195B1B5B215B145B135B105B165B285B1A5B205B1E5BEF5DAC5DB1 +5DA95DA75DB55DB05DAE5DAA5DA85DB25DAD5DAF5DB45E675E685E665E6F5EE9 +5EE75EE65EE85EE55F4B5FBC619D61A8619661C561B461C661C161CC61BA0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000061BF61B8618C64D764D664D064CF64C964BD648964C364DB64F364D96533 +657F657C65A266C866BE66C066CA66CB66CF66BD66BB66BA66CC67236A346A66 +6A496A676A326A686A3E6A5D6A6D6A766A5B6A516A286A5A6A3B6A3F6A416A6A +6A646A506A4F6A546A6F6A696A606A3C6A5E6A566A556A4D6A4E6A466B556B54 +6B566BA76BAA6BAB6BC86BC76C046C036C066FAD6FCB6FA36FC76FBC6FCE6FC8 +6F5E6FC46FBD6F9E6FCA6FA870046FA56FAE6FBA6FAC6FAA6FCF6FBF6FB80000 +EA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6FA26FC96FAB6FCD6FAF6FB26FB071C571C271BF71B871D671C071C171CB71D4 +71CA71C771CF71BD71D871BC71C671DA71DB729D729E736973667367736C7365 +736B736A747F749A74A074947492749574A1750B7580762F762D7631763D7633 +763C76357632763076BB76E6779A779D77A1779C779B77A277A3779577990000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000779778DD78E978E578EA78DE78E378DB78E178E278ED78DF78E079A47A44 +7A487A477AB67AB87AB57AB17AB77BDE7BE37BE77BDD7BD57BE57BDA7BE87BF9 +7BD47BEA7BE27BDC7BEB7BD87BDF7CD27CD47CD77CD07CD17E127E217E177E0C +7E1F7E207E137E0E7E1C7E157E1A7E227E0B7E0F7E167E0D7E147E257E247F43 +7F7B7F7C7F7A7FB17FEF802A8029806C81B181A681AE81B981B581AB81B081AC +81B481B281B781A781F282558256825785568545856B854D8553856185580000 +EB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +854085468564854185628544855185478563853E855B8571854E856E85758555 +85678560858C8566855D85548565856C866386658664879B878F879787938792 +87888781879687988779878787A3878587908791879D87848794879C879A8789 +891E89268930892D892E89278931892289298923892F892C891F89F18AE00000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008AE28AF28AF48AF58ADD8B148AE48ADF8AF08AC88ADE8AE18AE88AFF8AEF +8AFB8C918C928C908CF58CEE8CF18CF08CF38D6C8D6E8DA58DA78E338E3E8E38 +8E408E458E368E3C8E3D8E418E308E3F8EBD8F368F2E8F358F328F398F378F34 +90769079907B908690FA913391359136919391909191918D918F9327931E9308 +931F9306930F937A9338933C931B9323931293019346932D930E930D92CB931D +92FA9325931392F992F793349302932492FF932993399335932A9314930C0000 +EC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +930B92FE9309930092FB931695BC95CD95BE95B995BA95B695BF95B595BD96A9 +96D4970B9712971097999797979497F097F89835982F98329924991F99279929 +999E99EE99EC99E599E499F099E399EA99E999E79AB99ABF9AB49ABB9AF69AFA +9AF99AF79B339B809B859B879B7C9B7E9B7B9B829B939B929B909B7A9B950000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009B7D9B889D259D179D209D1E9D149D299D1D9D189D229D109D199D1F9E88 +9E869E879EAE9EAD9ED59ED69EFA9F129F3D51265125512251245120512952F4 +5693568C568D568656845683567E5682567F568158D658D458CF58D25B2D5B25 +5B325B235B2C5B275B265B2F5B2E5B7B5BF15BF25DB75E6C5E6A5FBE5FBB61C3 +61B561BC61E761E061E561E461E861DE64EF64E964E364EB64E464E865816580 +65B665DA66D26A8D6A966A816AA56A896A9F6A9B6AA16A9E6A876A936A8E0000 +ED +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +6A956A836AA86AA46A916A7F6AA66A9A6A856A8C6A926B5B6BAD6C096FCC6FA9 +6FF46FD46FE36FDC6FED6FE76FE66FDE6FF26FDD6FE26FE871E171F171E871F2 +71E471F071E27373736E736F749774B274AB749074AA74AD74B174A574AF7510 +75117512750F7584764376487649764776A476E977B577AB77B277B777B60000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000077B477B177A877F078F378FD790278FB78FC78F2790578F978FE790479AB +79A87A5C7A5B7A567A587A547A5A7ABE7AC07AC17C057C0F7BF27C007BFF7BFB +7C0E7BF47C0B7BF37C027C097C037C017BF87BFD7C067BF07BF17C107C0A7CE8 +7E2D7E3C7E427E3398487E387E2A7E497E407E477E297E4C7E307E3B7E367E44 +7E3A7F457F7F7F7E7F7D7FF47FF2802C81BB81C481CC81CA81C581C781BC81E9 +825B825A825C85838580858F85A7859585A0858B85A3857B85A4859A859E0000 +EE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8577857C858985A1857A85788557858E85968586858D8599859D858185A28582 +858885858579857685988590859F866887BE87AA87AD87C587B087AC87B987B5 +87BC87AE87C987C387C287CC87B787AF87C487CA87B487B687BF87B887BD87DE +87B289358933893C893E894189528937894289AD89AF89AE89F289F38B1E0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008B188B168B118B058B0B8B228B0F8B128B158B078B0D8B088B068B1C8B13 +8B1A8C4F8C708C728C718C6F8C958C948CF98D6F8E4E8E4D8E538E508E4C8E47 +8F438F409085907E9138919A91A2919B9199919F91A1919D91A093A1938393AF +936493569347937C9358935C93769349935093519360936D938F934C936A9379 +935793559352934F93719377937B9361935E936393679380934E935995C795C0 +95C995C395C595B796AE96B096AC9720971F9718971D9719979A97A1979C0000 +EF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +979E979D97D597D497F198419844984A9849984598439925992B992C992A9933 +9932992F992D99319930999899A399A19A0299FA99F499F799F999F899F699FB +99FD99FE99FC9A039ABE9AFE9AFD9B019AFC9B489B9A9BA89B9E9B9B9BA69BA1 +9BA59BA49B869BA29BA09BAF9D339D419D679D369D2E9D2F9D319D389D300000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009D459D429D439D3E9D379D409D3D7FF59D2D9E8A9E899E8D9EB09EC89EDA +9EFB9EFF9F249F239F229F549FA05131512D512E5698569C5697569A569D5699 +59705B3C5C695C6A5DC05E6D5E6E61D861DF61ED61EE61F161EA61F061EB61D6 +61E964FF650464FD64F86501650364FC659465DB66DA66DB66D86AC56AB96ABD +6AE16AC66ABA6AB66AB76AC76AB46AAD6B5E6BC96C0B7007700C700D70017005 +7014700E6FFF70006FFB70266FFC6FF7700A720171FF71F9720371FD73760000 +F0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +74B874C074B574C174BE74B674BB74C275147513765C76647659765076537657 +765A76A676BD76EC77C277BA78FF790C79137914790979107912791179AD79AC +7A5F7C1C7C297C197C207C1F7C2D7C1D7C267C287C227C257C307E5C7E507E56 +7E637E587E627E5F7E517E607E577E537FB57FB37FF77FF8807581D181D20000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000081D0825F825E85B485C685C085C385C285B385B585BD85C785C485BF85CB +85CE85C885C585B185B685D2862485B885B785BE866987E787E687E287DB87EB +87EA87E587DF87F387E487D487DC87D387ED87D887E387A487D787D9880187F4 +87E887DD8953894B894F894C89468950895189498B2A8B278B238B338B308B35 +8B478B2F8B3C8B3E8B318B258B378B268B368B2E8B248B3B8B3D8B3A8C428C75 +8C998C988C978CFE8D048D028D008E5C8E628E608E578E568E5E8E658E670000 +F1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8E5B8E5A8E618E5D8E698E548F468F478F488F4B9128913A913B913E91A891A5 +91A791AF91AA93B5938C939293B7939B939D938993A7938E93AA939E93A69395 +93889399939F938D93B1939193B293A493A893B493A393A595D295D395D196B3 +96D796DA5DC296DF96D896DD97239722972597AC97AE97A897AB97A497AA0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000097A297A597D797D997D697D897FA98509851985298B89941993C993A9A0F +9A0B9A099A0D9A049A119A0A9A059A079A069AC09ADC9B089B049B059B299B35 +9B4A9B4C9B4B9BC79BC69BC39BBF9BC19BB59BB89BD39BB69BC49BB99BBD9D5C +9D539D4F9D4A9D5B9D4B9D599D569D4C9D579D529D549D5F9D589D5A9E8E9E8C +9EDF9F019F009F169F259F2B9F2A9F299F289F4C9F5551345135529652F753B4 +56AB56AD56A656A756AA56AC58DA58DD58DB59125B3D5B3E5B3F5DC35E700000 +F2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +5FBF61FB65076510650D6509650C650E658465DE65DD66DE6AE76AE06ACC6AD1 +6AD96ACB6ADF6ADC6AD06AEB6ACF6ACD6ADE6B606BB06C0C7019702770207016 +702B702170227023702970177024701C702A720C720A72077202720572A572A6 +72A472A372A174CB74C574B774C37516766077C977CA77C477F1791D791B0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007921791C7917791E79B07A677A687C337C3C7C397C2C7C3B7CEC7CEA7E76 +7E757E787E707E777E6F7E7A7E727E747E687F4B7F4A7F837F867FB77FFD7FFE +807881D781D582648261826385EB85F185ED85D985E185E885DA85D785EC85F2 +85F885D885DF85E385DC85D185F085E685EF85DE85E2880087FA880387F687F7 +8809880C880B880687FC880887FF880A88028962895A895B89578961895C8958 +895D8959898889B789B689F68B508B488B4A8B408B538B568B548B4B8B550000 +F3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8B518B428B528B578C438C778C768C9A8D068D078D098DAC8DAA8DAD8DAB8E6D +8E788E738E6A8E6F8E7B8EC28F528F518F4F8F508F538FB49140913F91B091AD +93DE93C793CF93C293DA93D093F993EC93CC93D993A993E693CA93D493EE93E3 +93D593C493CE93C093D293E7957D95DA95DB96E19729972B972C972897260000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000097B397B797B697DD97DE97DF985C9859985D985798BF98BD98BB98BE9948 +9947994399A699A79A1A9A159A259A1D9A249A1B9A229A209A279A239A1E9A1C +9A149AC29B0B9B0A9B0E9B0C9B379BEA9BEB9BE09BDE9BE49BE69BE29BF09BD4 +9BD79BEC9BDC9BD99BE59BD59BE19BDA9D779D819D8A9D849D889D719D809D78 +9D869D8B9D8C9D7D9D6B9D749D759D709D699D859D739D7B9D829D6F9D799D7F +9D879D689E949E919EC09EFC9F2D9F409F419F4D9F569F579F58533756B20000 +F4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +56B556B358E35B455DC65DC75EEE5EEF5FC05FC161F9651765166515651365DF +66E866E366E46AF36AF06AEA6AE86AF96AF16AEE6AEF703C7035702F70377034 +703170427038703F703A70397040703B703370417213721472A8737D737C74BA +76AB76AA76BE76ED77CC77CE77CF77CD77F27925792379277928792479290000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000079B27A6E7A6C7A6D7AF77C497C487C4A7C477C457CEE7E7B7E7E7E817E80 +7FBA7FFF807981DB81D9820B82688269862285FF860185FE861B860085F68604 +86098605860C85FD8819881088118817881388168963896689B989F78B608B6A +8B5D8B688B638B658B678B6D8DAE8E868E888E848F598F568F578F558F588F5A +908D9143914191B791B591B291B3940B941393FB9420940F941493FE94159410 +94289419940D93F5940093F79407940E9416941293FA940993F8940A93FF0000 +F5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +93FC940C93F69411940695DE95E095DF972E972F97B997BB97FD97FE98609862 +9863985F98C198C29950994E9959994C994B99539A329A349A319A2C9A2A9A36 +9A299A2E9A389A2D9AC79ACA9AC69B109B129B119C0B9C089BF79C059C129BF8 +9C409C079C0E9C069C179C149C099D9F9D999DA49D9D9D929D989D909D9B0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009DA09D949D9C9DAA9D979DA19D9A9DA29DA89D9E9DA39DBF9DA99D969DA6 +9DA79E999E9B9E9A9EE59EE49EE79EE69F309F2E9F5B9F609F5E9F5D9F599F91 +513A51395298529756C356BD56BE5B485B475DCB5DCF5EF161FD651B6B026AFC +6B036AF86B0070437044704A7048704970457046721D721A7219737E7517766A +77D0792D7931792F7C547C537CF27E8A7E877E887E8B7E867E8D7F4D7FBB8030 +81DD8618862A8626861F8623861C86198627862E862186208629861E86250000 +F6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8829881D881B88208824881C882B884A896D8969896E896B89FA8B798B788B45 +8B7A8B7B8D108D148DAF8E8E8E8C8F5E8F5B8F5D91469144914591B9943F943B +94369429943D943C94309439942A9437942C9440943195E595E495E39735973A +97BF97E1986498C998C698C0995899569A399A3D9A469A449A429A419A3A0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009A3F9ACD9B159B179B189B169B3A9B529C2B9C1D9C1C9C2C9C239C289C29 +9C249C219DB79DB69DBC9DC19DC79DCA9DCF9DBE9DC59DC39DBB9DB59DCE9DB9 +9DBA9DAC9DC89DB19DAD9DCC9DB39DCD9DB29E7A9E9C9EEB9EEE9EED9F1B9F18 +9F1A9F319F4E9F659F649F924EB956C656C556CB59715B4B5B4C5DD55DD15EF2 +65216520652665226B0B6B086B096C0D7055705670577052721E721F72A9737F +74D874D574D974D7766D76AD793579B47A707A717C577C5C7C597C5B7C5A0000 +F7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +7CF47CF17E917F4F7F8781DE826B863486358633862C86328636882C88288826 +882A8825897189BF89BE89FB8B7E8B848B828B868B858B7F8D158E958E948E9A +8E928E908E968E978F608F629147944C9450944A944B944F9447944594489449 +9446973F97E3986A986998CB9954995B9A4E9A539A549A4C9A4F9A489A4A0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009A499A529A509AD09B199B2B9B3B9B569B559C469C489C3F9C449C399C33 +9C419C3C9C379C349C329C3D9C369DDB9DD29DDE9DDA9DCB9DD09DDC9DD19DDF +9DE99DD99DD89DD69DF59DD59DDD9EB69EF09F359F339F329F429F6B9F959FA2 +513D529958E858E759725B4D5DD8882F5F4F62016203620465296525659666EB +6B116B126B0F6BCA705B705A7222738273817383767077D47C677C667E95826C +863A86408639863C8631863B863E88308832882E883389768974897389FE0000 +F8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +8B8C8B8E8B8B8B888C458D198E988F648F6391BC94629455945D9457945E97C4 +97C598009A569A599B1E9B1F9B209C529C589C509C4A9C4D9C4B9C559C599C4C +9C4E9DFB9DF79DEF9DE39DEB9DF89DE49DF69DE19DEE9DE69DF29DF09DE29DEC +9DF49DF39DE89DED9EC29ED09EF29EF39F069F1C9F389F379F369F439F4F0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009F719F709F6E9F6F56D356CD5B4E5C6D652D66ED66EE6B13705F7061705D +7060722374DB74E577D5793879B779B67C6A7E977F89826D8643883888378835 +884B8B948B958E9E8E9F8EA08E9D91BE91BD91C2946B9468946996E597469743 +974797C797E59A5E9AD59B599C639C679C669C629C5E9C609E029DFE9E079E03 +9E069E059E009E019E099DFF9DFD9E049EA09F1E9F469F749F759F7656D4652E +65B86B186B196B176B1A7062722672AA77D877D979397C697C6B7CF67E9A0000 +F9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +7E987E9B7E9981E081E18646864786488979897A897C897B89FF8B988B998EA5 +8EA48EA3946E946D946F9471947397499872995F9C689C6E9C6D9E0B9E0D9E10 +9E0F9E129E119EA19EF59F099F479F789F7B9F7A9F79571E70667C6F883C8DB2 +8EA691C394749478947694759A609C749C739C719C759E149E139EF69F0A0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009FA4706870657CF7866A883E883D883F8B9E8C9C8EA98EC9974B98739874 +98CC996199AB9A649A669A679B249E159E179F4862076B1E7227864C8EA89482 +948094819A699A689B2E9E197229864B8B9F94839C799EB776759A6B9C7A9E1D +7069706A9EA49F7E9F499F98788192B988CF58BB60527CA75AFA255425662557 +2560256C2563255A2569255D255225642555255E256A256125582567255B2553 +25652556255F256B256225592568255C25512550256D256E2570256F25930000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/dingbats.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/dingbats.enc new file mode 100644 index 0000000000000000000000000000000000000000..972948767d0055d123c9ef3096a95b4eef8b0996 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/dingbats.enc @@ -0,0 +1,20 @@ +# Encoding file: dingbats, single-byte +S +003F 1 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +00202701270227032704260E2706270727082709261B261E270C270D270E270F +2710271127122713271427152716271727182719271A271B271C271D271E271F +2720272127222723272427252726272726052729272A272B272C272D272E272F +2730273127322733273427352736273727382739273A273B273C273D273E273F +2740274127422743274427452746274727482749274A274B25CF274D25A0274F +27502751275225B225BC25C6275625D727582759275A275B275C275D275E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +0000276127622763276427652766276726632666266526602460246124622463 +2464246524662467246824692776277727782779277A277B277C277D277E277F +2780278127822783278427852786278727882789278A278B278C278D278E278F +2790279127922793279421922194219527982799279A279B279C279D279E279F +27A027A127A227A327A427A527A627A727A827A927AA27AB27AC27AD27AE27AF +000027B127B227B327B427B527B627B727B827B927BA27BB27BC27BD27BE0000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/ebcdic.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/ebcdic.enc new file mode 100644 index 0000000000000000000000000000000000000000..f451de59a59c122e23292085412b8bf112cfb151 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/ebcdic.enc @@ -0,0 +1,19 @@ +S +006F 0 1 +00 +0000000100020003008500090086007F0087008D008E000B000C000D000E000F +0010001100120013008F000A0008009700180019009C009D001C001D001E001F +0080008100820083008400920017001B00880089008A008B008C000500060007 +0090009100160093009400950096000400980099009A009B00140015009E001A +002000A000E200E400E000E100E300E500E700F10060002E003C0028002B007C +002600E900EA00EB00E800ED00EE00EF00EC00DF00210024002A0029003B009F +002D002F00C200C400C000C100C300C500C700D1005E002C0025005F003E003F +00F800C900CA00CB00C800CD00CE00CF00CC00A8003A002300400027003D0022 +00D800610062006300640065006600670068006900AB00BB00F000FD00FE00B1 +00B0006A006B006C006D006E006F00700071007200AA00BA00E600B800C600A4 +00B500AF0073007400750076007700780079007A00A100BF00D000DD00DE00AE +00A200A300A500B700A900A700B600BC00BD00BE00AC005B005C005D00B400D7 +00F900410042004300440045004600470048004900AD00F400F600F200F300F5 +00A6004A004B004C004D004E004F00500051005200B900FB00FC00DB00FA00FF +00D900F70053005400550056005700580059005A00B200D400D600D200D300D5 +003000310032003300340035003600370038003900B3007B00DC007D00DA007E diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/euc-cn.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/euc-cn.enc new file mode 100644 index 0000000000000000000000000000000000000000..4b2f8c73ad798c18c3dbf139e9bdb206e60e0ce2 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/euc-cn.enc @@ -0,0 +1,1397 @@ +# Encoding file: euc-cn, multi-byte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diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/euc-jp.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/euc-jp.enc new file mode 100644 index 0000000000000000000000000000000000000000..db56c888231c15f4b289344979eb92117e9de400 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/euc-jp.enc @@ -0,0 +1,1353 @@ +# Encoding file: euc-jp, multi-byte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diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/euc-kr.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/euc-kr.enc new file mode 100644 index 0000000000000000000000000000000000000000..5e9bb93bbb0ae96e1d995570e4a336a1bcb00e42 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/euc-kr.enc @@ -0,0 +1,1533 @@ +# Encoding file: euc-kr, multi-byte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diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/gb12345.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/gb12345.enc new file mode 100644 index 0000000000000000000000000000000000000000..3f3f4d254586a07e90d26155dda61b886029fbc4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/gb12345.enc @@ -0,0 +1,1414 @@ +# Encoding file: gb12345, double-byte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diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/gb1988.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/gb1988.enc new file mode 100644 index 0000000000000000000000000000000000000000..298732ccc2300e57a32b3139ee674c7f5019835e --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/gb1988.enc @@ -0,0 +1,20 @@ +# Encoding file: gb1988, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +002000210022002300A500250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D203E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +0000FF61FF62FF63FF64FF65FF66FF67FF68FF69FF6AFF6BFF6CFF6DFF6EFF6F +FF70FF71FF72FF73FF74FF75FF76FF77FF78FF79FF7AFF7BFF7CFF7DFF7EFF7F +FF80FF81FF82FF83FF84FF85FF86FF87FF88FF89FF8AFF8BFF8CFF8DFF8EFF8F +FF90FF91FF92FF93FF94FF95FF96FF97FF98FF99FF9AFF9BFF9CFF9DFF9EFF9F +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/gb2312-raw.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/gb2312-raw.enc new file mode 100644 index 0000000000000000000000000000000000000000..813d7a6f3707068b67946aa377a3e409ee1967b1 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/gb2312-raw.enc @@ -0,0 +1,1380 @@ +# Encoding file: gb2312, double-byte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diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/gb2312.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/gb2312.enc new file mode 100644 index 0000000000000000000000000000000000000000..4b2f8c73ad798c18c3dbf139e9bdb206e60e0ce2 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/gb2312.enc @@ -0,0 +1,1397 @@ +# Encoding file: euc-cn, multi-byte +M +003F 0 82 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +A1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000030003001300230FB02C902C700A8300330052015FF5E2225202620182019 +201C201D3014301530083009300A300B300C300D300E300F3016301730103011 +00B100D700F72236222722282211220F222A222922082237221A22A522252220 +23122299222B222E2261224C2248223D221D2260226E226F22642265221E2235 +22342642264000B0203220332103FF0400A4FFE0FFE1203000A7211626062605 +25CB25CF25CE25C725C625A125A025B325B2203B219221902191219330130000 +A2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000024882489248A248B248C248D248E248F2490249124922493249424952496 +249724982499249A249B247424752476247724782479247A247B247C247D247E +247F248024812482248324842485248624872460246124622463246424652466 +2467246824690000000032203221322232233224322532263227322832290000 +00002160216121622163216421652166216721682169216A216B000000000000 +A3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000FF01FF02FF03FFE5FF05FF06FF07FF08FF09FF0AFF0BFF0CFF0DFF0EFF0F +FF10FF11FF12FF13FF14FF15FF16FF17FF18FF19FF1AFF1BFF1CFF1DFF1EFF1F +FF20FF21FF22FF23FF24FF25FF26FF27FF28FF29FF2AFF2BFF2CFF2DFF2EFF2F +FF30FF31FF32FF33FF34FF35FF36FF37FF38FF39FF3AFF3BFF3CFF3DFF3EFF3F +FF40FF41FF42FF43FF44FF45FF46FF47FF48FF49FF4AFF4BFF4CFF4DFF4EFF4F +FF50FF51FF52FF53FF54FF55FF56FF57FF58FF59FF5AFF5BFF5CFF5DFFE30000 +A4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000304130423043304430453046304730483049304A304B304C304D304E304F +3050305130523053305430553056305730583059305A305B305C305D305E305F +3060306130623063306430653066306730683069306A306B306C306D306E306F +3070307130723073307430753076307730783079307A307B307C307D307E307F +3080308130823083308430853086308730883089308A308B308C308D308E308F +3090309130923093000000000000000000000000000000000000000000000000 +A5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000030A130A230A330A430A530A630A730A830A930AA30AB30AC30AD30AE30AF +30B030B130B230B330B430B530B630B730B830B930BA30BB30BC30BD30BE30BF +30C030C130C230C330C430C530C630C730C830C930CA30CB30CC30CD30CE30CF +30D030D130D230D330D430D530D630D730D830D930DA30DB30DC30DD30DE30DF +30E030E130E230E330E430E530E630E730E830E930EA30EB30EC30ED30EE30EF +30F030F130F230F330F430F530F6000000000000000000000000000000000000 +A6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000039103920393039403950396039703980399039A039B039C039D039E039F +03A003A103A303A403A503A603A703A803A90000000000000000000000000000 +000003B103B203B303B403B503B603B703B803B903BA03BB03BC03BD03BE03BF +03C003C103C303C403C503C603C703C803C90000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +A7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000004100411041204130414041504010416041704180419041A041B041C041D +041E041F0420042104220423042404250426042704280429042A042B042C042D +042E042F00000000000000000000000000000000000000000000000000000000 +000004300431043204330434043504510436043704380439043A043B043C043D +043E043F0440044104420443044404450446044704480449044A044B044C044D +044E044F00000000000000000000000000000000000000000000000000000000 +A8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000010100E101CE00E0011300E9011B00E8012B00ED01D000EC014D00F301D2 +00F2016B00FA01D400F901D601D801DA01DC00FC00EA00000000000000000000 +0000000000000000000031053106310731083109310A310B310C310D310E310F +3110311131123113311431153116311731183119311A311B311C311D311E311F +3120312131223123312431253126312731283129000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +A9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00000000000000002500250125022503250425052506250725082509250A250B +250C250D250E250F2510251125122513251425152516251725182519251A251B +251C251D251E251F2520252125222523252425252526252725282529252A252B +252C252D252E252F2530253125322533253425352536253725382539253A253B +253C253D253E253F2540254125422543254425452546254725482549254A254B +0000000000000000000000000000000000000000000000000000000000000000 +B0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000554A963F57C3632854CE550954C07691764C853C77EE827E788D72319698 +978D6C285B894FFA630966975CB880FA684880AE660276CE51F9655671AC7FF1 +888450B2596561CA6FB382AD634C625253ED54277B06516B75A45DF462D48DCB +9776628A8019575D97387F627238767D67CF767E64464F708D2562DC7A176591 +73ED642C6273822C9881677F7248626E62CC4F3474E3534A529E7ECA90A65E2E +6886699C81807ED168D278C5868C9551508D8C2482DE80DE5305891252650000 +B1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000858496F94FDD582199715B9D62B162A566B48C799C8D7206676F789160B2 +535153178F8880CC8D1D94A1500D72C8590760EB711988AB595482EF672C7B28 +5D297EF7752D6CF58E668FF8903C9F3B6BD491197B145F7C78A784D6853D6BD5 +6BD96BD65E015E8775F995ED655D5F0A5FC58F9F58C181C2907F965B97AD8FB9 +7F168D2C62414FBF53D8535E8FA88FA98FAB904D68075F6A819888689CD6618B +522B762A5F6C658C6FD26EE85BBE6448517551B067C44E1979C9997C70B30000 +B2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000075C55E7673BB83E064AD62E894B56CE2535A52C3640F94C27B944F2F5E1B +82368116818A6E246CCA9A736355535C54FA886557E04E0D5E036B657C3F90E8 +601664E6731C88C16750624D8D22776C8E2991C75F6983DC8521991053C28695 +6B8B60ED60E8707F82CD82314ED36CA785CF64CD7CD969FD66F9834953957B56 +4FA7518C6D4B5C428E6D63D253C9832C833667E578B4643D5BDF5C945DEE8BE7 +62C667F48C7A640063BA8749998B8C177F2094F24EA7961098A4660C73160000 +B3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000573A5C1D5E38957F507F80A05382655E7545553150218D856284949E671D +56326F6E5DE2543570928F66626F64A463A35F7B6F8890F481E38FB05C186668 +5FF16C8996488D81886C649179F057CE6A59621054484E587A0B60E96F848BDA +627F901E9A8B79E4540375F4630153196C608FDF5F1B9A70803B9F7F4F885C3A +8D647FC565A570BD514551B2866B5D075BA062BD916C75748E0C7A2061017B79 +4EC77EF877854E1181ED521D51FA6A7153A88E87950496CF6EC19664695A0000 +B4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000784050A877D7641089E6590463E35DDD7A7F693D4F20823955984E3275AE +7A975E625E8A95EF521B5439708A6376952457826625693F918755076DF37EAF +882262337EF075B5832878C196CC8F9E614874F78BCD6B64523A8D506B21806A +847156F153064ECE4E1B51D17C97918B7C074FC38E7F7BE17A9C64675D1450AC +810676017CB96DEC7FE067515B585BF878CB64AE641363AA632B9519642D8FBE +7B5476296253592754466B7950A362345E266B864EE38D37888B5F85902E0000 +B5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006020803D62C54E39535590F863B880C665E66C2E4F4660EE6DE18BDE5F39 +86CB5F536321515A83616863520063638E4850125C9B79775BFC52307A3B60BC +905376D75FB75F9776848E6C706F767B7B4977AA51F3909358244F4E6EF48FEA +654C7B1B72C46DA47FDF5AE162B55E95573084827B2C5E1D5F1F90127F1498A0 +63826EC7789870B95178975B57AB75354F4375385E9760E659606DC06BBF7889 +53FC96D551CB52016389540A94938C038DCC7239789F87768FED8C0D53E00000 +B6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00004E0176EF53EE948998769F0E952D5B9A8BA24E224E1C51AC846361C252A8 +680B4F97606B51BB6D1E515C6296659796618C46901775D890FD77636BD2728A +72EC8BFB583577798D4C675C9540809A5EA66E2159927AEF77ED953B6BB565AD +7F0E58065151961F5BF958A954288E726566987F56E4949D76FE9041638754C6 +591A593A579B8EB267358DFA8235524160F0581586FE5CE89E454FC4989D8BB9 +5A2560765384627C904F9102997F6069800C513F80335C1499756D314E8C0000 +B7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008D3053D17F5A7B4F4F104E4F96006CD573D085E95E06756A7FFB6A0A77FE +94927E4151E170E653CD8FD483038D2972AF996D6CDB574A82B365B980AA623F +963259A84EFF8BBF7EBA653E83F2975E556198DE80A5532A8BFD542080BA5E9F +6CB88D3982AC915A54296C1B52067EB7575F711A6C7E7C89594B4EFD5FFF6124 +7CAA4E305C0167AB87025CF0950B98CE75AF70FD902251AF7F1D8BBD594951E4 +4F5B5426592B657780A45B75627662C28F905E456C1F7B264F0F4FD8670D0000 +B8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006D6E6DAA798F88B15F17752B629A8F854FEF91DC65A7812F81515E9C8150 +8D74526F89868D4B590D50854ED8961C723681798D1F5BCC8BA3964459877F1A +54905676560E8BE565396982949976D66E895E727518674667D17AFF809D8D76 +611F79C665628D635188521A94A27F38809B7EB25C976E2F67607BD9768B9AD8 +818F7F947CD5641E95507A3F544A54E56B4C640162089E3D80F3759952729769 +845B683C86E49601969494EC4E2A54047ED968398DDF801566F45E9A7FB90000 +B9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000057C2803F68975DE5653B529F606D9F9A4F9B8EAC516C5BAB5F135DE96C5E +62F18D21517194A952FE6C9F82DF72D757A267848D2D591F8F9C83C754957B8D +4F306CBD5B6459D19F1353E486CA9AA88C3780A16545987E56FA96C7522E74DC +52505BE1630289024E5662D0602A68FA51735B9851A089C27BA199867F5060EF +704C8D2F51495E7F901B747089C4572D78455F529F9F95FA8F689B3C8BE17678 +684267DC8DEA8D35523D8F8A6EDA68CD950590ED56FD679C88F98FC754C80000 +BA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009AB85B696D776C264EA55BB39A87916361A890AF97E9542B6DB55BD251FD +558A7F557FF064BC634D65F161BE608D710A6C576C49592F676D822A58D5568E +8C6A6BEB90DD597D801753F76D695475559D837783CF683879BE548C4F555408 +76D28C8996026CB36DB88D6B89109E648D3A563F9ED175D55F8872E0606854FC +4EA86A2A886160528F7054C470D886799E3F6D2A5B8F5F187EA255894FAF7334 +543C539A5019540E547C4E4E5FFD745A58F6846B80E1877472D07CCA6E560000 +BB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005F27864E552C62A44E926CAA623782B154D7534E733E6ED1753B52125316 +8BDD69D05F8A60006DEE574F6B2273AF68538FD87F13636260A3552475EA8C62 +71156DA35BA65E7B8352614C9EC478FA87577C27768751F060F6714C66435E4C +604D8C0E707063258F895FBD606286D456DE6BC160946167534960E066668D3F +79FD4F1A70E96C478BB38BF27ED88364660F5A5A9B426D516DF78C416D3B4F19 +706B83B7621660D1970D8D27797851FB573E57FA673A75787A3D79EF7B950000 +BC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000808C99658FF96FC08BA59E2159EC7EE97F095409678168D88F917C4D96C6 +53CA602575BE6C7253735AC97EA7632451E0810A5DF184DF628051805B634F0E +796D524260B86D4E5BC45BC28BA18BB065E25FCC964559937EE77EAA560967B7 +59394F735BB652A0835A988A8D3E753294BE50477A3C4EF767B69A7E5AC16B7C +76D1575A5C167B3A95F4714E517C80A9827059787F04832768C067EC78B17877 +62E363617B804FED526A51CF835069DB92748DF58D3189C1952E7BAD4EF60000 +BD +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000506582305251996F6E106E856DA75EFA50F559DC5C066D466C5F7586848B +686859568BB253209171964D854969127901712680F64EA490CA6D479A845A07 +56BC640594F077EB4FA5811A72E189D2997A7F347EDE527F655991758F7F8F83 +53EB7A9663ED63A5768679F888579636622A52AB8282685467706377776B7AED +6D017ED389E359D0621285C982A5754C501F4ECB75A58BEB5C4A5DFE7B4B65A4 +91D14ECA6D25895F7D2795264EC58C288FDB9773664B79818FD170EC6D780000 +BE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005C3D52B283465162830E775B66769CB84EAC60CA7CBE7CB37ECF4E958B66 +666F988897595883656C955C5F8475C997567ADF7ADE51C070AF7A9863EA7A76 +7EA0739697ED4E4570784E5D915253A9655165E781FC8205548E5C31759A97A0 +62D872D975BD5C459A7983CA5C40548077E94E3E6CAE805A62D2636E5DE85177 +8DDD8E1E952F4FF153E560E770AC526763509E435A1F5026773753777EE26485 +652B628963985014723589C951B38BC07EDD574783CC94A7519B541B5CFB0000 +BF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00004FCA7AE36D5A90E19A8F55805496536154AF5F0063E9697751EF6168520A +582A52D8574E780D770B5EB761777CE0625B62974EA27095800362F770E49760 +577782DB67EF68F578D5989779D158F354B353EF6E34514B523B5BA28BFE80AF +554357A660735751542D7A7A60505B5463A762A053E362635BC767AF54ED7A9F +82E691775E9388E4593857AE630E8DE880EF57577B774FA95FEB5BBD6B3E5321 +7B5072C2684677FF773665F751B54E8F76D45CBF7AA58475594E9B4150800000 +C0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000998861276E8357646606634656F062EC62695ED39614578362C955878721 +814A8FA3556683B167658D5684DD5A6A680F62E67BEE961151706F9C8C3063FD +89C861D27F0670C26EE57405699472FC5ECA90CE67176D6A635E52B372628001 +4F6C59E5916A70D96D9D52D24E5096F7956D857E78CA7D2F5121579264C2808B +7C7B6CEA68F1695E51B7539868A872819ECE7BF172F879BB6F137406674E91CC +9CA4793C83898354540F68174E3D538952B1783E5386522950884F8B4FD00000 +C1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000075E27ACB7C926CA596B6529B748354E94FE9805483B28FDE95705EC9601C +6D9F5E18655B813894FE604B70BC7EC37CAE51C968817CB1826F4E248F8691CF +667E4EAE8C0564A9804A50DA759771CE5BE58FBD6F664E86648295635ED66599 +521788C270C852A3730E7433679778F797164E3490BB9CDE6DCB51DB8D41541D +62CE73B283F196F69F8494C34F367F9A51CC707596755CAD988653E64EE46E9C +740969B4786B998F7559521876246D4167F3516D9F99804B54997B3C7ABF0000 +C2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009686578462E29647697C5A0464027BD36F0F964B82A6536298855E907089 +63B35364864F9C819E93788C97328DEF8D429E7F6F5E79845F559646622E9A74 +541594DD4FA365C55C655C617F1586516C2F5F8B73876EE47EFF5CE6631B5B6A +6EE653754E7163A0756562A18F6E4F264ED16CA67EB68BBA841D87BA7F57903B +95237BA99AA188F8843D6D1B9A867EDC59889EBB739B780186829A6C9A82561B +541757CB4E709EA653568FC881097792999286EE6EE1851366FC61626F2B0000 +C3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008C298292832B76F26C135FD983BD732B8305951A6BDB77DB94C6536F8302 +51925E3D8C8C8D384E4873AB679A68859176970971646CA177095A9295416BCF +7F8E66275BD059B95A9A95E895F74EEC840C84996AAC76DF9530731B68A65B5F +772F919A97617CDC8FF78C1C5F257C7379D889C56CCC871C5BC65E4268C97720 +7EF55195514D52C95A297F05976282D763CF778485D079D26E3A5E9959998511 +706D6C1162BF76BF654F60AF95FD660E879F9E2394ED540D547D8C2C64780000 +C4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000647986116A21819C78E864699B5462B9672B83AB58A89ED86CAB6F205BDE +964C8C0B725F67D062C772614EA959C66BCD589366AE5E5552DF6155672876EE +776672677A4662FF54EA545094A090A35A1C7EB36C164E435976801059485357 +753796BE56CA63208111607C95F96DD65462998151855AE980FD59AE9713502A +6CE55C3C62DF4F60533F817B90066EBA852B62C85E7478BE64B5637B5FF55A18 +917F9E1F5C3F634F80425B7D556E954A954D6D8560A867E072DE51DD5B810000 +C5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000062E76CDE725B626D94AE7EBD81136D53519C5F04597452AA601259736696 +8650759F632A61E67CEF8BFA54E66B279E256BB485D5545550766CA4556A8DB4 +722C5E156015743662CD6392724C5F986E436D3E65006F5876D878D076FC7554 +522453DB4E535E9E65C1802A80D6629B5486522870AE888D8DD16CE1547880DA +57F988F48D54966A914D4F696C9B55B776C6783062A870F96F8E5F6D84EC68DA +787C7BF781A8670B9E4F636778B0576F78129739627962AB528874356BD70000 +C6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005564813E75B276AE533975DE50FB5C418B6C7BC7504F72479A9798D86F02 +74E27968648777A562FC98918D2B54C180584E52576A82F9840D5E7351ED74F6 +8BC45C4F57616CFC98875A4678349B448FEB7C955256625194FA4EC683868461 +83E984B257D467345703666E6D668C3166DD7011671F6B3A6816621A59BB4E03 +51C46F0667D26C8F517668CB59476B6775665D0E81109F5065D7794879419A91 +8D775C824E5E4F01542F5951780C56686C148FC45F036C7D6CE38BAB63900000 +C7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000060706D3D72756266948E94C553438FC17B7E4EDF8C264E7E9ED494B194B3 +524D6F5C90636D458C3458115D4C6B206B4967AA545B81547F8C589985375F3A +62A26A47953965726084686577A74E544FA85DE7979864AC7FD85CED4FCF7A8D +520783044E14602F7A8394A64FB54EB279E6743452E482B964D279BD5BDD6C81 +97528F7B6C22503E537F6E0564CE66746C3060C598778BF75E86743C7A7779CB +4E1890B174036C4256DA914B6CC58D8B533A86C666F28EAF5C489A716E200000 +C8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000053D65A369F8B8DA353BB570898A76743919B6CC9516875CA62F372AC5238 +529D7F3A7094763853749E4A69B7786E96C088D97FA4713671C3518967D374E4 +58E4651856B78BA9997662707ED560F970ED58EC4EC14EBA5FCD97E74EFB8BA4 +5203598A7EAB62544ECD65E5620E833884C98363878D71946EB65BB97ED25197 +63C967D480898339881551125B7A59828FB14E736C5D516589258F6F962E854A +745E951095F06DA682E55F3164926D128428816E9CC3585E8D5B4E0953C10000 +C9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00004F1E6563685155D34E2764149A9A626B5AC2745F82726DA968EE50E7838E +7802674052396C997EB150BB5565715E7B5B665273CA82EB67495C715220717D +886B95EA965564C58D6181B355846C5562477F2E58924F2455468D4F664C4E0A +5C1A88F368A2634E7A0D70E7828D52FA97F65C1154E890B57ECD59628D4A86C7 +820C820D8D6664445C0461516D89793E8BBE78377533547B4F388EAB6DF15A20 +7EC5795E6C885BA15A76751A80BE614E6E1758F0751F7525727253477EF30000 +CA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000770176DB526980DC57235E08593172EE65BD6E7F8BD75C388671534177F3 +62FE65F64EC098DF86805B9E8BC653F277E24F7F5C4E9A7659CB5F0F793A58EB +4E1667FF4E8B62ED8A93901D52BF662F55DC566C90024ED54F8D91CA99706C0F +5E0260435BA489C68BD56536624B99965B885BFF6388552E53D77626517D852C +67A268B36B8A62928F9353D482126DD1758F4E668D4E5B70719F85AF669166D9 +7F7287009ECD9F205C5E672F8FF06811675F620D7AD658855EB665706F310000 +CB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000060555237800D6454887075295E05681362F4971C53CC723D8C016C347761 +7A0E542E77AC987A821C8BF47855671470C165AF64955636601D79C153F84E1D +6B7B80865BFA55E356DB4F3A4F3C99725DF3677E80386002988290015B8B8BBC +8BF5641C825864DE55FD82CF91654FD77D20901F7C9F50F358516EAF5BBF8BC9 +80839178849C7B97867D968B968F7EE59AD3788E5C817A57904296A7795F5B59 +635F7B0B84D168AD55067F2974107D2295016240584C4ED65B83597958540000 +CC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000736D631E8E4B8E0F80CE82D462AC53F06CF0915E592A60016C70574D644A +8D2A762B6EE9575B6A8075F06F6D8C2D8C0857666BEF889278B363A253F970AD +6C645858642A580268E0819B55107CD650188EBA6DCC8D9F70EB638F6D9B6ED4 +7EE68404684390036DD896768BA85957727985E4817E75BC8A8A68AF52548E22 +951163D098988E44557C4F5366FF568F60D56D9552435C4959296DFB586B7530 +751C606C82148146631167618FE2773A8DF38D3494C15E165385542C70C30000 +CD +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006C405EF7505C4EAD5EAD633A8247901A6850916E77B3540C94DC5F647AE5 +687663457B527EDF75DB507762955934900F51F879C37A8156FE5F9290146D82 +5C60571F541051546E4D56E263A89893817F8715892A9000541E5C6F81C062D6 +625881319E3596409A6E9A7C692D59A562D3553E631654C786D96D3C5A0374E6 +889C6B6A59168C4C5F2F6E7E73A9987D4E3870F75B8C7897633D665A769660CB +5B9B5A494E0781556C6A738B4EA167897F515F8065FA671B5FD859845A010000 +CE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005DCD5FAE537197E68FDD684556F4552F60DF4E3A6F4D7EF482C7840E59D4 +4F1F4F2A5C3E7EAC672A851A5473754F80C355829B4F4F4D6E2D8C135C096170 +536B761F6E29868A658795FB7EB9543B7A337D0A95EE55E17FC174EE631D8717 +6DA17A9D621165A1536763E16C835DEB545C94A84E4C6C618BEC5C4B65E0829C +68A7543E54346BCB6B664E9463425348821E4F0D4FAE575E620A96FE66647269 +52FF52A1609F8BEF661471996790897F785277FD6670563B54389521727A0000 +CF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007A00606F5E0C6089819D591560DC718470EF6EAA6C5072806A8488AD5E2D +4E605AB3559C94E36D177CFB9699620F7EC6778E867E5323971E8F9666875CE1 +4FA072ED4E0B53A6590F54136380952851484ED99C9C7EA454B88D2488548237 +95F26D8E5F265ACC663E966973B0732E53BF817A99857FA15BAA967796507EBF +76F853A2957699997BB189446E584E617FD479658BE660F354CD4EAB98795DF7 +6A6150CF54118C618427785D9704524A54EE56A395006D885BB56DC666530000 +D0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005C0F5B5D6821809655787B11654869544E9B6B47874E978B534F631F643A +90AA659C80C18C10519968B0537887F961C86CC46CFB8C225C5185AA82AF950C +6B238F9B65B05FFB5FC34FE18845661F8165732960FA51745211578B5F6290A2 +884C91925E78674F602759D3514451F680F853086C7996C4718A4F114FEE7F9E +673D55C5950879C088967EE3589F620C9700865A5618987B5F908BB884C49157 +53D965ED5E8F755C60647D6E5A7F7EEA7EED8F6955A75BA360AC65CB73840000 +D1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009009766377297EDA9774859B5B667A7496EA884052CB718F5FAA65EC8BE2 +5BFB9A6F5DE16B896C5B8BAD8BAF900A8FC5538B62BC9E269E2D54404E2B82BD +7259869C5D1688596DAF96C554D14E9A8BB6710954BD960970DF6DF976D04E25 +781487125CA95EF68A00989C960E708E6CBF594463A9773C884D6F1482735830 +71D5538C781A96C155015F6671305BB48C1A9A8C6B83592E9E2F79E76768626C +4F6F75A17F8A6D0B96336C274EF075D2517B68376F3E90808170599674760000 +D2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000064475C2790657A918C2359DA54AC8200836F898180006930564E80367237 +91CE51B64E5F987563964E1A53F666F3814B591C6DB24E0058F9533B63D694F1 +4F9D4F0A886398905937905779FB4EEA80F075916C825B9C59E85F5D69058681 +501A5DF24E5977E34EE5827A6291661390915C794EBF5F7981C69038808475AB +4EA688D4610F6BC55FC64E4976CA6EA28BE38BAE8C0A8BD15F027FFC7FCC7ECE +8335836B56E06BB797F3963459FB541F94F66DEB5BC5996E5C395F1596900000 +D3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000537082F16A315A749E705E947F2883B984248425836787478FCE8D6276C8 +5F719896786C662054DF62E54F6381C375C85EB896CD8E0A86F9548F6CF36D8C +6C38607F52C775285E7D4F1860A05FE75C24753190AE94C072B96CB96E389149 +670953CB53F34F5191C98BF153C85E7C8FC26DE44E8E76C26986865E611A8206 +4F594FDE903E9C7C61096E1D6E1496854E885A3196E84E0E5C7F79B95B878BED +7FBD738957DF828B90C15401904755BB5CEA5FA161086B3272F180B28A890000 +D4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006D745BD388D598848C6B9A6D9E336E0A51A4514357A38881539F63F48F95 +56ED54585706733F6E907F188FDC82D1613F6028966266F07EA68D8A8DC394A5 +5CB37CA4670860A6960580184E9190E75300966851418FD08574915D665597F5 +5B55531D78386742683D54C9707E5BB08F7D518D572854B1651266828D5E8D43 +810F846C906D7CDF51FF85FB67A365E96FA186A48E81566A90207682707671E5 +8D2362E952196CFD8D3C600E589E618E66FE8D60624E55B36E23672D8F670000 +D5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000094E195F87728680569A8548B4E4D70B88BC86458658B5B857A84503A5BE8 +77BB6BE18A797C986CBE76CF65A98F975D2D5C5586386808536062187AD96E5B +7EFD6A1F7AE05F706F335F20638C6DA867564E085E108D264ED780C07634969C +62DB662D627E6CBC8D7571677F695146808753EC906E629854F286F08F998005 +951785178FD96D5973CD659F771F7504782781FB8D1E94884FA6679575B98BCA +9707632F9547963584B8632377415F8172F04E896014657462EF6B63653F0000 +D6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005E2775C790D18BC1829D679D652F5431871877E580A281026C414E4B7EC7 +804C76F4690D6B966267503C4F84574063076B628DBE53EA65E87EB85FD7631A +63B781F381F47F6E5E1C5CD95236667A79E97A1A8D28709975D46EDE6CBB7A92 +4E2D76C55FE0949F88777EC879CD80BF91CD4EF24F17821F54685DDE6D328BCC +7CA58F7480985E1A549276B15B99663C9AA473E0682A86DB6731732A8BF88BDB +90107AF970DB716E62C477A956314E3B845767F152A986C08D2E94F87B510000 +D7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00004F4F6CE8795D9A7B6293722A62FD4E1378168F6C64B08D5A7BC668695E84 +88C55986649E58EE72B6690E95258FFD8D5857607F008C0651C6634962D95353 +684C74228301914C55447740707C6D4A517954A88D4459FF6ECB6DC45B5C7D2B +4ED47C7D6ED35B5081EA6E0D5B579B0368D58E2A5B977EFC603B7EB590B98D70 +594F63CD79DF8DB3535265CF79568BC5963B7EC494BB7E825634918967007F6A +5C0A907566285DE64F5067DE505A4F5C57505EA7000000000000000000000000 +D8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00004E8D4E0C51404E105EFF53454E154E984E1E9B325B6C56694E2879BA4E3F +53154E47592D723B536E6C1056DF80E499976BD3777E9F174E364E9F9F104E5C +4E694E9382885B5B556C560F4EC4538D539D53A353A553AE97658D5D531A53F5 +5326532E533E8D5C5366536352025208520E522D5233523F5240524C525E5261 +525C84AF527D528252815290529351827F544EBB4EC34EC94EC24EE84EE14EEB +4EDE4F1B4EF34F224F644EF54F254F274F094F2B4F5E4F6765384F5A4F5D0000 +D9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00004F5F4F574F324F3D4F764F744F914F894F834F8F4F7E4F7B4FAA4F7C4FAC +4F944FE64FE84FEA4FC54FDA4FE34FDC4FD14FDF4FF85029504C4FF3502C500F +502E502D4FFE501C500C50255028507E504350555048504E506C507B50A550A7 +50A950BA50D6510650ED50EC50E650EE5107510B4EDD6C3D4F584F654FCE9FA0 +6C467C74516E5DFD9EC999985181591452F9530D8A07531051EB591951554EA0 +51564EB3886E88A44EB5811488D279805B3488037FB851AB51B151BD51BC0000 +DA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000051C7519651A251A58BA08BA68BA78BAA8BB48BB58BB78BC28BC38BCB8BCF +8BCE8BD28BD38BD48BD68BD88BD98BDC8BDF8BE08BE48BE88BE98BEE8BF08BF3 +8BF68BF98BFC8BFF8C008C028C048C078C0C8C0F8C118C128C148C158C168C19 +8C1B8C188C1D8C1F8C208C218C258C278C2A8C2B8C2E8C2F8C328C338C358C36 +5369537A961D962296219631962A963D963C964296499654965F9667966C9672 +96749688968D969796B09097909B909D909990AC90A190B490B390B690BA0000 +DB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000090B890B090CF90C590BE90D090C490C790D390E690E290DC90D790DB90EB +90EF90FE91049122911E91239131912F913991439146520D594252A252AC52AD +52BE54FF52D052D652F053DF71EE77CD5EF451F551FC9B2F53B65F01755A5DEF +574C57A957A1587E58BC58C558D15729572C572A57335739572E572F575C573B +574257695785576B5786577C577B5768576D5776577357AD57A4578C57B257CF +57A757B4579357A057D557D857DA57D957D257B857F457EF57F857E457DD0000 +DC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000580B580D57FD57ED5800581E5819584458205865586C58815889589A5880 +99A89F1961FF8279827D827F828F828A82A88284828E82918297829982AB82B8 +82BE82B082C882CA82E3829882B782AE82CB82CC82C182A982B482A182AA829F +82C482CE82A482E1830982F782E4830F830782DC82F482D282D8830C82FB82D3 +8311831A83068314831582E082D5831C8351835B835C83088392833C83348331 +839B835E832F834F83478343835F834083178360832D833A8333836683650000 +DD +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008368831B8369836C836A836D836E83B0837883B383B483A083AA8393839C +8385837C83B683A9837D83B8837B8398839E83A883BA83BC83C1840183E583D8 +58078418840B83DD83FD83D6841C84388411840683D483DF840F840383F883F9 +83EA83C583C0842683F083E1845C8451845A8459847384878488847A84898478 +843C844684698476848C848E8431846D84C184CD84D084E684BD84D384CA84BF +84BA84E084A184B984B4849784E584E3850C750D853884F08539851F853A0000 +DE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008556853B84FF84FC8559854885688564855E857A77A285438572857B85A4 +85A88587858F857985AE859C858585B985B785B085D385C185DC85FF86278605 +86298616863C5EFE5F08593C594180375955595A5958530F5C225C255C2C5C34 +624C626A629F62BB62CA62DA62D762EE632262F66339634B634363AD63F66371 +637A638E63B4636D63AC638A636963AE63BC63F263F863E063FF63C463DE63CE +645263C663BE64456441640B641B6420640C64266421645E6484646D64960000 +DF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000647A64B764B8649964BA64C064D064D764E464E265096525652E5F0B5FD2 +75195F11535F53F153FD53E953E853FB541254165406544B5452545354545456 +54435421545754595423543254825494547754715464549A549B548454765466 +549D54D054AD54C254B454D254A754A654D354D4547254A354D554BB54BF54CC +54D954DA54DC54A954AA54A454DD54CF54DE551B54E7552054FD551454F35522 +5523550F55115527552A5567558F55B55549556D55415555553F5550553C0000 +E0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005537555655755576557755335530555C558B55D2558355B155B955885581 +559F557E55D65591557B55DF55BD55BE5594559955EA55F755C9561F55D155EB +55EC55D455E655DD55C455EF55E555F255F355CC55CD55E855F555E48F94561E +5608560C56015624562355FE56005627562D565856395657562C564D56625659 +565C564C5654568656645671566B567B567C5685569356AF56D456D756DD56E1 +56F556EB56F956FF5704570A5709571C5E0F5E195E145E115E315E3B5E3C0000 +E1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00005E375E445E545E5B5E5E5E615C8C5C7A5C8D5C905C965C885C985C995C91 +5C9A5C9C5CB55CA25CBD5CAC5CAB5CB15CA35CC15CB75CC45CD25CE45CCB5CE5 +5D025D035D275D265D2E5D245D1E5D065D1B5D585D3E5D345D3D5D6C5D5B5D6F +5D5D5D6B5D4B5D4A5D695D745D825D995D9D8C735DB75DC55F735F775F825F87 +5F895F8C5F955F995F9C5FA85FAD5FB55FBC88625F6172AD72B072B472B772B8 +72C372C172CE72CD72D272E872EF72E972F272F472F7730172F3730372FA0000 +E2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000072FB731773137321730A731E731D7315732273397325732C733873317350 +734D73577360736C736F737E821B592598E7592459029963996799689969996A +996B996C99749977997D998099849987998A998D999099919993999499955E80 +5E915E8B5E965EA55EA05EB95EB55EBE5EB38D535ED25ED15EDB5EE85EEA81BA +5FC45FC95FD65FCF60035FEE60045FE15FE45FFE600560065FEA5FED5FF86019 +60356026601B600F600D6029602B600A603F602160786079607B607A60420000 +E3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000606A607D6096609A60AD609D60836092608C609B60EC60BB60B160DD60D8 +60C660DA60B4612061266115612360F46100610E612B614A617561AC619461A7 +61B761D461F55FDD96B395E995EB95F195F395F595F695FC95FE960396049606 +9608960A960B960C960D960F96129615961696179619961A4E2C723F62156C35 +6C546C5C6C4A6CA36C856C906C946C8C6C686C696C746C766C866CA96CD06CD4 +6CAD6CF76CF86CF16CD76CB26CE06CD66CFA6CEB6CEE6CB16CD36CEF6CFE0000 +E4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006D396D276D0C6D436D486D076D046D196D0E6D2B6D4D6D2E6D356D1A6D4F +6D526D546D336D916D6F6D9E6DA06D5E6D936D946D5C6D606D7C6D636E1A6DC7 +6DC56DDE6E0E6DBF6DE06E116DE66DDD6DD96E166DAB6E0C6DAE6E2B6E6E6E4E +6E6B6EB26E5F6E866E536E546E326E256E446EDF6EB16E986EE06F2D6EE26EA5 +6EA76EBD6EBB6EB76ED76EB46ECF6E8F6EC26E9F6F626F466F476F246F156EF9 +6F2F6F366F4B6F746F2A6F096F296F896F8D6F8C6F786F726F7C6F7A6FD10000 +E5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00006FC96FA76FB96FB66FC26FE16FEE6FDE6FE06FEF701A7023701B70397035 +704F705E5B805B845B955B935BA55BB8752F9A9E64345BE45BEE89305BF08E47 +8B078FB68FD38FD58FE58FEE8FE48FE98FE68FF38FE890059004900B90269011 +900D9016902190359036902D902F9044905190529050906890589062905B66B9 +9074907D908290889083908B5F505F575F565F585C3B54AB5C505C595B715C63 +5C667FBC5F2A5F295F2D82745F3C9B3B5C6E59815983598D59A959AA59A30000 +E6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000599759CA59AB599E59A459D259B259AF59D759BE5A055A0659DD5A0859E3 +59D859F95A0C5A095A325A345A115A235A135A405A675A4A5A555A3C5A625A75 +80EC5AAA5A9B5A775A7A5ABE5AEB5AB25AD25AD45AB85AE05AE35AF15AD65AE6 +5AD85ADC5B095B175B165B325B375B405C155C1C5B5A5B655B735B515B535B62 +9A759A779A789A7A9A7F9A7D9A809A819A859A889A8A9A909A929A939A969A98 +9A9B9A9C9A9D9A9F9AA09AA29AA39AA59AA77E9F7EA17EA37EA57EA87EA90000 +E7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007EAD7EB07EBE7EC07EC17EC27EC97ECB7ECC7ED07ED47ED77EDB7EE07EE1 +7EE87EEB7EEE7EEF7EF17EF27F0D7EF67EFA7EFB7EFE7F017F027F037F077F08 +7F0B7F0C7F0F7F117F127F177F197F1C7F1B7F1F7F217F227F237F247F257F26 +7F277F2A7F2B7F2C7F2D7F2F7F307F317F327F337F355E7A757F5DDB753E9095 +738E739173AE73A2739F73CF73C273D173B773B373C073C973C873E573D9987C +740A73E973E773DE73BA73F2740F742A745B7426742574287430742E742C0000 +E8 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000741B741A7441745C7457745574597477746D747E749C748E748074817487 +748B749E74A874A9749074A774D274BA97EA97EB97EC674C6753675E67486769 +67A56787676A6773679867A7677567A8679E67AD678B6777677C67F0680967D8 +680A67E967B0680C67D967B567DA67B367DD680067C367B867E2680E67C167FD +6832683368606861684E6862684468646883681D68556866684168676840683E +684A6849682968B5688F687468776893686B68C2696E68FC691F692068F90000 +E9 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000692468F0690B6901695768E369106971693969606942695D6984696B6980 +69986978693469CC6987698869CE6989696669636979699B69A769BB69AB69AD +69D469B169C169CA69DF699569E0698D69FF6A2F69ED6A176A186A6569F26A44 +6A3E6AA06A506A5B6A356A8E6A796A3D6A286A586A7C6A916A906AA96A976AAB +733773526B816B826B876B846B926B936B8D6B9A6B9B6BA16BAA8F6B8F6D8F71 +8F728F738F758F768F788F778F798F7A8F7C8F7E8F818F828F848F878F8B0000 +EA +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00008F8D8F8E8F8F8F988F9A8ECE620B6217621B621F6222622162256224622C +81E774EF74F474FF750F75117513653465EE65EF65F0660A6619677266036615 +6600708566F7661D66346631663666358006665F66546641664F665666616657 +66776684668C66A7669D66BE66DB66DC66E666E98D328D338D368D3B8D3D8D40 +8D458D468D488D498D478D4D8D558D5989C789CA89CB89CC89CE89CF89D089D1 +726E729F725D7266726F727E727F7284728B728D728F72926308633263B00000 +EB +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000643F64D880046BEA6BF36BFD6BF56BF96C056C076C066C0D6C156C186C19 +6C1A6C216C296C246C2A6C3265356555656B724D72527256723086625216809F +809C809380BC670A80BD80B180AB80AD80B480B780E780E880E980EA80DB80C2 +80C480D980CD80D7671080DD80EB80F180F480ED810D810E80F280FC67158112 +8C5A8136811E812C811881328148814C815381748159815A817181608169817C +817D816D8167584D5AB58188818281916ED581A381AA81CC672681CA81BB0000 +EC +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000081C181A66B246B376B396B436B466B5998D198D298D398D598D998DA6BB3 +5F406BC289F365909F51659365BC65C665C465C365CC65CE65D265D67080709C +7096709D70BB70C070B770AB70B170E870CA711071137116712F71317173715C +716871457172714A7178717A719871B371B571A871A071E071D471E771F9721D +7228706C7118716671B9623E623D624362486249793B794079467949795B795C +7953795A796279577960796F7967797A7985798A799A79A779B35FD15FD00000 +ED +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000603C605D605A606760416059606360AB6106610D615D61A9619D61CB61D1 +62068080807F6C936CF66DFC77F677F87800780978177818781165AB782D781C +781D7839783A783B781F783C7825782C78237829784E786D7856785778267850 +7847784C786A789B7893789A7887789C78A178A378B278B978A578D478D978C9 +78EC78F2790578F479137924791E79349F9B9EF99EFB9EFC76F17704770D76F9 +77077708771A77227719772D7726773577387750775177477743775A77680000 +EE +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000077627765777F778D777D7780778C7791779F77A077B077B577BD753A7540 +754E754B7548755B7572757975837F587F617F5F8A487F687F747F717F797F81 +7F7E76CD76E58832948594869487948B948A948C948D948F9490949494979495 +949A949B949C94A394A494AB94AA94AD94AC94AF94B094B294B494B694B794B8 +94B994BA94BC94BD94BF94C494C894C994CA94CB94CC94CD94CE94D094D194D2 +94D594D694D794D994D894DB94DE94DF94E094E294E494E594E794E894EA0000 +EF +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000094E994EB94EE94EF94F394F494F594F794F994FC94FD94FF950395029506 +95079509950A950D950E950F951295139514951595169518951B951D951E951F +9522952A952B9529952C953195329534953695379538953C953E953F95429535 +9544954595469549954C954E954F9552955395549556955795589559955B955E +955F955D95619562956495659566956795689569956A956B956C956F95719572 +9573953A77E777EC96C979D579ED79E379EB7A065D477A037A027A1E7A140000 +F0 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007A397A377A519ECF99A57A707688768E7693769976A474DE74E0752C9E20 +9E229E289E299E2A9E2B9E2C9E329E319E369E389E379E399E3A9E3E9E419E42 +9E449E469E479E489E499E4B9E4C9E4E9E519E559E579E5A9E5B9E5C9E5E9E63 +9E669E679E689E699E6A9E6B9E6C9E719E6D9E7375927594759675A0759D75AC +75A375B375B475B875C475B175B075C375C275D675CD75E375E875E675E475EB +75E7760375F175FC75FF761076007605760C7617760A76257618761576190000 +F1 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000761B763C762276207640762D7630763F76357643763E7633764D765E7654 +765C7656766B766F7FCA7AE67A787A797A807A867A887A957AA67AA07AAC7AA8 +7AAD7AB3886488698872887D887F888288A288C688B788BC88C988E288CE88E3 +88E588F1891A88FC88E888FE88F0892189198913891B890A8934892B89368941 +8966897B758B80E576B276B477DC801280148016801C80208022802580268027 +802980288031800B803580438046804D80528069807189839878988098830000 +F2 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009889988C988D988F9894989A989B989E989F98A198A298A598A6864D8654 +866C866E867F867A867C867B86A8868D868B86AC869D86A786A386AA869386A9 +86B686C486B586CE86B086BA86B186AF86C986CF86B486E986F186F286ED86F3 +86D0871386DE86F486DF86D886D18703870786F88708870A870D87098723873B +871E8725872E871A873E87488734873187298737873F87828722877D877E877B +87608770874C876E878B87538763877C876487598765879387AF87A887D20000 +F3 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000087C68788878587AD8797878387AB87E587AC87B587B387CB87D387BD87D1 +87C087CA87DB87EA87E087EE8816881387FE880A881B88218839883C7F367F42 +7F447F4582107AFA7AFD7B087B037B047B157B0A7B2B7B0F7B477B387B2A7B19 +7B2E7B317B207B257B247B337B3E7B1E7B587B5A7B457B757B4C7B5D7B607B6E +7B7B7B627B727B717B907BA67BA77BB87BAC7B9D7BA87B857BAA7B9C7BA27BAB +7BB47BD17BC17BCC7BDD7BDA7BE57BE67BEA7C0C7BFE7BFC7C0F7C167C0B0000 +F4 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00007C1F7C2A7C267C387C417C4081FE82018202820481EC8844822182228223 +822D822F8228822B8238823B82338234823E82448249824B824F825A825F8268 +887E8885888888D888DF895E7F9D7F9F7FA77FAF7FB07FB27C7C65497C917C9D +7C9C7C9E7CA27CB27CBC7CBD7CC17CC77CCC7CCD7CC87CC57CD77CE8826E66A8 +7FBF7FCE7FD57FE57FE17FE67FE97FEE7FF37CF87D777DA67DAE7E477E9B9EB8 +9EB48D738D848D948D918DB18D678D6D8C478C49914A9150914E914F91640000 +F5 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009162916191709169916F917D917E917291749179918C91859190918D9191 +91A291A391AA91AD91AE91AF91B591B491BA8C559E7E8DB88DEB8E058E598E69 +8DB58DBF8DBC8DBA8DC48DD68DD78DDA8DDE8DCE8DCF8DDB8DC68DEC8DF78DF8 +8DE38DF98DFB8DE48E098DFD8E148E1D8E1F8E2C8E2E8E238E2F8E3A8E408E39 +8E358E3D8E318E498E418E428E518E528E4A8E708E768E7C8E6F8E748E858E8F +8E948E908E9C8E9E8C788C828C8A8C858C988C94659B89D689DE89DA89DC0000 +F6 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +000089E589EB89EF8A3E8B26975396E996F396EF970697019708970F970E972A +972D9730973E9F809F839F859F869F879F889F899F8A9F8C9EFE9F0B9F0D96B9 +96BC96BD96CE96D277BF96E0928E92AE92C8933E936A93CA938F943E946B9C7F +9C829C859C869C879C887A239C8B9C8E9C909C919C929C949C959C9A9C9B9C9E +9C9F9CA09CA19CA29CA39CA59CA69CA79CA89CA99CAB9CAD9CAE9CB09CB19CB2 +9CB39CB49CB59CB69CB79CBA9CBB9CBC9CBD9CC49CC59CC69CC79CCA9CCB0000 +F7 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00009CCC9CCD9CCE9CCF9CD09CD39CD49CD59CD79CD89CD99CDC9CDD9CDF9CE2 +977C978597919792979497AF97AB97A397B297B49AB19AB09AB79E589AB69ABA +9ABC9AC19AC09AC59AC29ACB9ACC9AD19B459B439B479B499B489B4D9B5198E8 +990D992E995599549ADF9AE19AE69AEF9AEB9AFB9AED9AF99B089B0F9B139B1F +9B239EBD9EBE7E3B9E829E879E889E8B9E9293D69E9D9E9F9EDB9EDC9EDD9EE0 +9EDF9EE29EE99EE79EE59EEA9EEF9F229F2C9F2F9F399F379F3D9F3E9F440000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso2022-jp.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso2022-jp.enc new file mode 100644 index 0000000000000000000000000000000000000000..f6dabe56d32a4f526c7617a1ce864c755d942f35 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso2022-jp.enc @@ -0,0 +1,12 @@ +# Encoding file: iso2022-jp, escape-driven +E +name iso2022-jp +init {} +final {} +ascii \x1b(B +jis0201 \x1b(J +jis0208 \x1b$B +jis0208 \x1b$@ +jis0212 \x1b$(D +gb2312 \x1b$A +ksc5601 \x1b$(C diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso2022-kr.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso2022-kr.enc new file mode 100644 index 0000000000000000000000000000000000000000..d20ce2bc126cf66550286309c5a167acda2e29dc --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso2022-kr.enc @@ -0,0 +1,7 @@ +# Encoding file: iso2022-kr, escape-driven +E +name iso2022-kr +init \x1b$)C +final {} +iso8859-1 \x0f +ksc5601 \x0e diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso2022.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso2022.enc new file mode 100644 index 0000000000000000000000000000000000000000..a58f8e3e297ea002161efa8d6146fe64b1daf321 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso2022.enc @@ -0,0 +1,14 @@ +# Encoding file: iso2022, escape-driven +E +name iso2022 +init {} +final {} +iso8859-1 \x1b(B +jis0201 \x1b(J +gb1988 \x1b(T +jis0208 \x1b$B +jis0208 \x1b$@ +jis0212 \x1b$(D +gb2312 \x1b$A +ksc5601 \x1b$(C +jis0208 \x1b&@\x1b$B diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-1.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-1.enc new file mode 100644 index 0000000000000000000000000000000000000000..045d8fa28b448ef90dd4b5ad2642c1e4942ca324 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-1.enc @@ -0,0 +1,20 @@ +# Encoding file: iso8859-1, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +00A000A100A200A300A400A500A600A700A800A900AA00AB00AC00AD00AE00AF +00B000B100B200B300B400B500B600B700B800B900BA00BB00BC00BD00BE00BF +00C000C100C200C300C400C500C600C700C800C900CA00CB00CC00CD00CE00CF +00D000D100D200D300D400D500D600D700D800D900DA00DB00DC00DD00DE00DF +00E000E100E200E300E400E500E600E700E800E900EA00EB00EC00ED00EE00EF +00F000F100F200F300F400F500F600F700F800F900FA00FB00FC00FD00FE00FF diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-10.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-10.enc new file mode 100644 index 0000000000000000000000000000000000000000..934b3b920ba5ad3a777cc582c2456f90774b02fb --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-10.enc @@ -0,0 +1,20 @@ +# Encoding file: iso8859-10, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +00A0010401120122012A0128013600A7013B011001600166017D00AD016A014A +00B0010501130123012B0129013700B7013C011101610167017E2015016B014B +010000C100C200C300C400C500C6012E010C00C9011800CB011600CD00CE00CF +00D00145014C00D300D400D500D6016800D8017200DA00DB00DC00DD00DE00DF +010100E100E200E300E400E500E6012F010D00E9011900EB011700ED00EE00EF +00F00146014D00F300F400F500F6016900F8017300FA00FB00FC00FD00FE0138 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-11.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-11.enc new file mode 100644 index 0000000000000000000000000000000000000000..d68345358cec5914c8ea532fe6b07cf7c4260bb8 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-11.enc @@ -0,0 +1,20 @@ +# Encoding file: iso8859-11, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +00A00E010E020E030E040E050E060E070E080E090E0A0E0B0E0C0E0D0E0E0E0F +0E100E110E120E130E140E150E160E170E180E190E1A0E1B0E1C0E1D0E1E0E1F +0E200E210E220E230E240E250E260E270E280E290E2A0E2B0E2C0E2D0E2E0E2F +0E300E310E320E330E340E350E360E370E380E390E3A00000000000000000E3F +0E400E410E420E430E440E450E460E470E480E490E4A0E4B0E4C0E4D0E4E0E4F +0E500E510E520E530E540E550E560E570E580E590E5A0E5B0000000000000000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-13.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-13.enc new file mode 100644 index 0000000000000000000000000000000000000000..b7edcaf38f42902061c0cf53d14afdaa712aabc0 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-13.enc @@ -0,0 +1,20 @@ +# Encoding file: iso8859-13, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +00A0201D00A200A300A4201E00A600A700D800A9015600AB00AC00AD00AE00C6 +00B000B100B200B3201C00B500B600B700F800B9015700BB00BC00BD00BE00E6 +0104012E0100010600C400C501180112010C00C90179011601220136012A013B +01600143014500D3014C00D500D600D701720141015A016A00DC017B017D00DF +0105012F0101010700E400E501190113010D00E9017A011701230137012B013C +01610144014600F3014D00F500F600F701730142015B016B00FC017C017E2019 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-14.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-14.enc new file mode 100644 index 0000000000000000000000000000000000000000..a65ba05b9afc1240c9dd2f265349b76b3130903c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-14.enc @@ -0,0 +1,20 @@ +# Encoding file: iso8859-14, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +00A01E021E0300A3010A010B1E0A00A71E8000A91E821E0B1EF200AD00AE0178 +1E1E1E1F012001211E401E4100B61E561E811E571E831E601EF31E841E851E61 +00C000C100C200C300C400C500C600C700C800C900CA00CB00CC00CD00CE00CF +017400D100D200D300D400D500D61E6A00D800D900DA00DB00DC00DD017600DF +00E000E100E200E300E400E500E600E700E800E900EA00EB00EC00ED00EE00EF +017500F100F200F300F400F500F61E6B00F800F900FA00FB00FC00FD017700FF diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-15.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-15.enc new file mode 100644 index 0000000000000000000000000000000000000000..823af466e5b935e856e7c9a1d0bcb5eceb3b70be --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-15.enc @@ -0,0 +1,20 @@ +# Encoding file: iso8859-15, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +00A000A100A200A320AC00A5016000A7016100A900AA00AB00AC00AD00AE00AF +00B000B100B200B3017D00B500B600B7017E00B900BA00BB01520153017800BF +00C000C100C200C300C400C500C600C700C800C900CA00CB00CC00CD00CE00CF +00D000D100D200D300D400D500D600D700D800D900DA00DB00DC00DD00DE00DF +00E000E100E200E300E400E500E600E700E800E900EA00EB00EC00ED00EE00EF +00F000F100F200F300F400F500F600F700F800F900FA00FB00FC00FD00FE00FF diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-16.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-16.enc new file mode 100644 index 0000000000000000000000000000000000000000..da3370932f41ea4e3173907129b183c386a88fdb --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-16.enc @@ -0,0 +1,20 @@ +# Encoding file: iso8859-16, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +00A001040105014120AC201E016000A7016100A9021800AB017900AD017A017B +00B000B1010C0142017D201D00B600B7017E010D021900BB015201530178017C +00C000C100C2010200C4010600C600C700C800C900CA00CB00CC00CD00CE00CF +0110014300D200D300D4015000D6015A017000D900DA00DB00DC0118021A00DF +00E000E100E2010300E4010700E600E700E800E900EA00EB00EC00ED00EE00EF +0111014400F200F300F4015100F6015B017100F900FA00FB00FC0119021B00FF diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-2.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-2.enc new file mode 100644 index 0000000000000000000000000000000000000000..16faab66ed793f66bf64572c8238ab73e431f657 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-2.enc @@ -0,0 +1,20 @@ +# Encoding file: iso8859-2, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +00A0010402D8014100A4013D015A00A700A80160015E0164017900AD017D017B +00B0010502DB014200B4013E015B02C700B80161015F0165017A02DD017E017C +015400C100C2010200C40139010600C7010C00C9011800CB011A00CD00CE010E +01100143014700D300D4015000D600D70158016E00DA017000DC00DD016200DF +015500E100E2010300E4013A010700E7010D00E9011900EB011B00ED00EE010F +01110144014800F300F4015100F600F70159016F00FA017100FC00FD016302D9 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-3.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-3.enc new file mode 100644 index 0000000000000000000000000000000000000000..c914bce7af30184725481de6daf9ec14644fd53f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-3.enc @@ -0,0 +1,20 @@ +# Encoding file: iso8859-3, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +00A0012602D800A300A40000012400A700A80130015E011E013400AD0000017B +00B0012700B200B300B400B5012500B700B80131015F011F013500BD0000017C +00C000C100C2000000C4010A010800C700C800C900CA00CB00CC00CD00CE00CF +000000D100D200D300D4012000D600D7011C00D900DA00DB00DC016C015C00DF +00E000E100E2000000E4010B010900E700E800E900EA00EB00EC00ED00EE00EF +000000F100F200F300F4012100F600F7011D00F900FA00FB00FC016D015D02D9 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-4.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-4.enc new file mode 100644 index 0000000000000000000000000000000000000000..ef5c5a99825b58b9e1c1fc7624dd24946a5093fc --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-4.enc @@ -0,0 +1,20 @@ +# Encoding file: iso8859-4, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +00A001040138015600A40128013B00A700A8016001120122016600AD017D00AF +00B0010502DB015700B40129013C02C700B80161011301230167014A017E014B +010000C100C200C300C400C500C6012E010C00C9011800CB011600CD00CE012A +01100145014C013600D400D500D600D700D8017200DA00DB00DC0168016A00DF +010100E100E200E300E400E500E6012F010D00E9011900EB011700ED00EE012B +01110146014D013700F400F500F600F700F8017300FA00FB00FC0169016B02D9 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-5.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-5.enc new file mode 100644 index 0000000000000000000000000000000000000000..bf4ee82b66283e8c9b4b898210bb0c43db7b63da --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-5.enc @@ -0,0 +1,20 @@ +# Encoding file: iso8859-5, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +00A0040104020403040404050406040704080409040A040B040C00AD040E040F +0410041104120413041404150416041704180419041A041B041C041D041E041F +0420042104220423042404250426042704280429042A042B042C042D042E042F +0430043104320433043404350436043704380439043A043B043C043D043E043F +0440044104420443044404450446044704480449044A044B044C044D044E044F +2116045104520453045404550456045704580459045A045B045C00A7045E045F diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-6.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-6.enc new file mode 100644 index 0000000000000000000000000000000000000000..19ddefbc7bf13db439ff3390970666b41f5a9df1 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-6.enc @@ -0,0 +1,20 @@ +# Encoding file: iso8859-6, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +00A000000000000000A40000000000000000000000000000060C00AD00000000 +00000000000000000000000000000000000000000000061B000000000000061F +0000062106220623062406250626062706280629062A062B062C062D062E062F +0630063106320633063406350636063706380639063A00000000000000000000 +0640064106420643064406450646064706480649064A064B064C064D064E064F +0650065106520000000000000000000000000000000000000000000000000000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-7.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-7.enc new file mode 100644 index 0000000000000000000000000000000000000000..a46112f145825b7aea946481ed9a039e81ed6e1b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-7.enc @@ -0,0 +1,20 @@ +# Encoding file: iso8859-7, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +00A02018201900A320AC20AF00A600A700A800A9037A00AB00AC00AD00002015 +00B000B100B200B303840385038600B703880389038A00BB038C00BD038E038F +0390039103920393039403950396039703980399039A039B039C039D039E039F +03A003A1000003A303A403A503A603A703A803A903AA03AB03AC03AD03AE03AF +03B003B103B203B303B403B503B603B703B803B903BA03BB03BC03BD03BE03BF +03C003C103C203C303C403C503C603C703C803C903CA03CB03CC03CD03CE0000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-8.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-8.enc new file mode 100644 index 0000000000000000000000000000000000000000..579fa5b47ea10dc492b7735664488567139c4254 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-8.enc @@ -0,0 +1,20 @@ +# Encoding file: iso8859-8, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +00A0000000A200A300A400A500A600A700A800A900D700AB00AC00AD00AE00AF +00B000B100B200B300B400B500B600B700B800B900F700BB00BC00BD00BE0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000002017 +05D005D105D205D305D405D505D605D705D805D905DA05DB05DC05DD05DE05DF +05E005E105E205E305E405E505E605E705E805E905EA00000000200E200F0000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-9.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-9.enc new file mode 100644 index 0000000000000000000000000000000000000000..6eed3f1a8717d96aa95d9c7b1654b13dacce4f22 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/iso8859-9.enc @@ -0,0 +1,20 @@ +# Encoding file: iso8859-9, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +00A000A100A200A300A400A500A600A700A800A900AA00AB00AC00AD00AE00AF +00B000B100B200B300B400B500B600B700B800B900BA00BB00BC00BD00BE00BF +00C000C100C200C300C400C500C600C700C800C900CA00CB00CC00CD00CE00CF +011E00D100D200D300D400D500D600D700D800D900DA00DB00DC0130015E00DF +00E000E100E200E300E400E500E600E700E800E900EA00EB00EC00ED00EE00EF +011F00F100F200F300F400F500F600F700F800F900FA00FB00FC0131015F00FF diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/jis0201.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/jis0201.enc new file mode 100644 index 0000000000000000000000000000000000000000..64f423f16201391f064c7298d278186c1c5a6408 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/jis0201.enc @@ -0,0 +1,20 @@ +# Encoding file: jis0201, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D203E007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +0000FF61FF62FF63FF64FF65FF66FF67FF68FF69FF6AFF6BFF6CFF6DFF6EFF6F +FF70FF71FF72FF73FF74FF75FF76FF77FF78FF79FF7AFF7BFF7CFF7DFF7EFF7F +FF80FF81FF82FF83FF84FF85FF86FF87FF88FF89FF8AFF8BFF8CFF8DFF8EFF8F +FF90FF91FF92FF93FF94FF95FF96FF97FF98FF99FF9AFF9BFF9CFF9DFF9EFF9F +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/jis0208.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/jis0208.enc new file mode 100644 index 0000000000000000000000000000000000000000..11c49a4a2ba626ff06d7ac0c8dcafe037ef19d46 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/jis0208.enc @@ -0,0 +1,1319 @@ +# Encoding file: jis0208, double-byte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diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/jis0212.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/jis0212.enc new file mode 100644 index 0000000000000000000000000000000000000000..cddbbba9d209b3547ebc1b9b520ad82c8796aef1 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/jis0212.enc @@ -0,0 +1,1159 @@ +# Encoding file: jis0212, double-byte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diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/koi8-r.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/koi8-r.enc new file mode 100644 index 0000000000000000000000000000000000000000..49bf2ea65cf85811e8f32d219b5ebbfe3792bd71 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/koi8-r.enc @@ -0,0 +1,20 @@ +# Encoding file: koi8-r, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +25002502250C251025142518251C2524252C2534253C258025842588258C2590 +259125922593232025A02219221A22482264226500A0232100B000B200B700F7 +25502551255204512553255425552556255725582559255A255B255C255D255E +255F25602561040125622563256425652566256725682569256A256B256C00A9 +044E0430043104460434043504440433044504380439043A043B043C043D043E +043F044F044004410442044304360432044C044B04370448044D04490447044A +042E0410041104260414041504240413042504180419041A041B041C041D041E +041F042F042004210422042304160412042C042B04170428042D04290427042A diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/koi8-u.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/koi8-u.enc new file mode 100644 index 0000000000000000000000000000000000000000..e4eeb84510773dd12d021d6f10f0494127ff3b16 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/koi8-u.enc @@ -0,0 +1,20 @@ +# Encoding file: koi8-u, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +25002502250C251025142518251C2524252C2534253C258025842588258C2590 +259125922593232025A02219221A22482264226500A0232100B000B200B700F7 +25502551255204510454255404560457255725582559255A255B0491255D255E +255F25602561040104032563040604072566256725682569256A0490256C00A9 +044E0430043104460434043504440433044504380439043A043B043C043D043E +043F044F044004410442044304360432044C044B04370448044D04490447044A +042E0410041104260414041504240413042504180419041A041B041C041D041E +041F042F042004210422042304160412042C042B04170428042D04290427042A diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/ksc5601.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/ksc5601.enc new file mode 100644 index 0000000000000000000000000000000000000000..bec61d0ff846c818f887f458bf528b2e15d9cf67 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/ksc5601.enc @@ -0,0 +1,1516 @@ +# Encoding file: ksc5601, double-byte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diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macCentEuro.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macCentEuro.enc new file mode 100644 index 0000000000000000000000000000000000000000..dde616a4cb72619ac7f2043ff90a4f4b52cd5241 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macCentEuro.enc @@ -0,0 +1,20 @@ +# Encoding file: macCentEuro, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00C40100010100C9010400D600DC00E10105010C00E4010D0106010700E90179 +017A010E00ED010F01120113011600F3011700F400F600F500FA011A011B00FC +202000B0011800A300A7202200B600DF00AE00A92122011900A822600123012E +012F012A22642265012B0136220222110142013B013C013D013E0139013A0145 +0146014300AC221A01440147220600AB00BB202600A00148015000D50151014C +20132014201C201D2018201900F725CA014D0154015501582039203A01590156 +01570160201A201E0161015A015B00C10164016500CD017D017E016A00D300D4 +016B016E00DA016F017001710172017300DD00FD0137017B0141017C012202C7 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macCroatian.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macCroatian.enc new file mode 100644 index 0000000000000000000000000000000000000000..c23d0f0b77230435ea4dce64004ee77f3983c47b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macCroatian.enc @@ -0,0 +1,20 @@ +# Encoding file: macCroatian, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00C400C500C700C900D100D600DC00E100E000E200E400E300E500E700E900E8 +00EA00EB00ED00EC00EE00EF00F100F300F200F400F600F500FA00F900FB00FC +202000B000A200A300A7202200B600DF00AE0160212200B400A82260017D00D8 +221E00B122642265220600B522022211220F0161222B00AA00BA03A9017E00F8 +00BF00A100AC221A01922248010600AB010C202600A000C000C300D501520153 +01102014201C201D2018201900F725CAF8FF00A9204420AC2039203A00C600BB +201300B7201A201E203000C2010700C1010D00C800CD00CE00CF00CC00D300D4 +011100D200DA00DB00D9013102C602DC00AF03C000CB02DA00B800CA00E602C7 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macCyrillic.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macCyrillic.enc new file mode 100644 index 0000000000000000000000000000000000000000..e657739bdaf9f582aa21ad439803bd949bd575cd --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macCyrillic.enc @@ -0,0 +1,20 @@ +# Encoding file: macCyrillic, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0410041104120413041404150416041704180419041A041B041C041D041E041F +0420042104220423042404250426042704280429042A042B042C042D042E042F +202000B0049000A300A7202200B6040600AE00A9212204020452226004030453 +221E00B122642265045600B504910408040404540407045704090459040A045A +0458040500AC221A01922248220600AB00BB202600A0040B045B040C045C0455 +20132014201C201D2018201900F7201E040E045E040F045F211604010451044F +0430043104320433043404350436043704380439043A043B043C043D043E043F +0440044104420443044404450446044704480449044A044B044C044D044E20AC diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macDingbats.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macDingbats.enc new file mode 100644 index 0000000000000000000000000000000000000000..28449cdd651be288dc6d4d28f59eb6f4d3dc5ef9 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macDingbats.enc @@ -0,0 +1,20 @@ +# Encoding file: macDingbats, single-byte +S +003F 1 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +00202701270227032704260E2706270727082709261B261E270C270D270E270F +2710271127122713271427152716271727182719271A271B271C271D271E271F +2720272127222723272427252726272726052729272A272B272C272D272E272F +2730273127322733273427352736273727382739273A273B273C273D273E273F +2740274127422743274427452746274727482749274A274B25CF274D25A0274F +27502751275225B225BC25C6275625D727582759275A275B275C275D275E007F +F8D7F8D8F8D9F8DAF8DBF8DCF8DDF8DEF8DFF8E0F8E1F8E2F8E3F8E4008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +0000276127622763276427652766276726632666266526602460246124622463 +2464246524662467246824692776277727782779277A277B277C277D277E277F +2780278127822783278427852786278727882789278A278B278C278D278E278F +2790279127922793279421922194219527982799279A279B279C279D279E279F +27A027A127A227A327A427A527A627A727A827A927AA27AB27AC27AD27AE27AF +000027B127B227B327B427B527B627B727B827B927BA27BB27BC27BD27BE0000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macGreek.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macGreek.enc new file mode 100644 index 0000000000000000000000000000000000000000..67b9953dd25284b36346ab6d56429784aa1af35f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macGreek.enc @@ -0,0 +1,20 @@ +# Encoding file: macGreek, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00C400B900B200C900B300D600DC038500E000E200E4038400A800E700E900E8 +00EA00EB00A3212200EE00EF202200BD203000F400F600A600AD00F900FB00FC +2020039303940398039B039E03A000DF00AE00A903A303AA00A7226000B000B7 +039100B12264226500A503920395039603970399039A039C03A603AB03A803A9 +03AC039D00AC039F03A1224803A400AB00BB202600A003A503A7038603880153 +20132015201C201D2018201900F70389038A038C038E03AD03AE03AF03CC038F +03CD03B103B203C803B403B503C603B303B703B903BE03BA03BB03BC03BD03BF +03C003CE03C103C303C403B803C903C203C703C503B603CA03CB039003B0F8A0 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macIceland.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macIceland.enc new file mode 100644 index 0000000000000000000000000000000000000000..c6360698ae55fa06128d42b4bbca0c4e84646623 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macIceland.enc @@ -0,0 +1,20 @@ +# Encoding file: macIceland, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00C400C500C700C900D100D600DC00E100E000E200E400E300E500E700E900E8 +00EA00EB00ED00EC00EE00EF00F100F300F200F400F600F500FA00F900FB00FC +00DD00B000A200A300A7202200B600DF00AE00A9212200B400A8226000C600D8 +221E00B12264226500A500B522022211220F03C0222B00AA00BA03A900E600F8 +00BF00A100AC221A01922248220600AB00BB202600A000C000C300D501520153 +20132014201C201D2018201900F725CA00FF0178204420AC00D000F000DE00FE +00FD00B7201A201E203000C200CA00C100CB00C800CD00CE00CF00CC00D300D4 +F8FF00D200DA00DB00D9013102C602DC00AF02D802D902DA00B802DD02DB02C7 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macJapan.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macJapan.enc new file mode 100644 index 0000000000000000000000000000000000000000..dba24bd8e3f3284609d79362f24b49f386cf0550 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macJapan.enc @@ -0,0 +1,785 @@ +# Encoding file: macJapan, multi-byte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diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macRoman.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macRoman.enc new file mode 100644 index 0000000000000000000000000000000000000000..15de26623f32d554209ee8856c892e54161bcbe8 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macRoman.enc @@ -0,0 +1,20 @@ +# Encoding file: macRoman, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00C400C500C700C900D100D600DC00E100E000E200E400E300E500E700E900E8 +00EA00EB00ED00EC00EE00EF00F100F300F200F400F600F500FA00F900FB00FC +202000B000A200A300A7202200B600DF00AE00A9212200B400A8226000C600D8 +221E00B12264226500A500B522022211220F03C0222B00AA00BA03A900E600F8 +00BF00A100AC221A01922248220600AB00BB202600A000C000C300D501520153 +20132014201C201D2018201900F725CA00FF0178204420AC2039203AFB01FB02 +202100B7201A201E203000C200CA00C100CB00C800CD00CE00CF00CC00D300D4 +F8FF00D200DA00DB00D9013102C602DC00AF02D802D902DA00B802DD02DB02C7 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macRomania.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macRomania.enc new file mode 100644 index 0000000000000000000000000000000000000000..ce41cf427f257dfaa63c6d577c17d28f6563758f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macRomania.enc @@ -0,0 +1,20 @@ +# Encoding file: macRomania, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00C400C500C700C900D100D600DC00E100E000E200E400E300E500E700E900E8 +00EA00EB00ED00EC00EE00EF00F100F300F200F400F600F500FA00F900FB00FC +202000B000A200A300A7202200B600DF00AE00A9212200B400A822600102015E +221E00B12264226500A500B522022211220F03C0222B00AA00BA21260103015F +00BF00A100AC221A01922248220600AB00BB202600A000C000C300D501520153 +20132014201C201D2018201900F725CA00FF0178204400A42039203A01620163 +202100B7201A201E203000C200CA00C100CB00C800CD00CE00CF00CC00D300D4 +F8FF00D200DA00DB00D9013102C602DC00AF02D802D902DA00B802DD02DB02C7 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macThai.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macThai.enc new file mode 100644 index 0000000000000000000000000000000000000000..7d9c8ad4a2b3afec156a5696dc0245d330d745b1 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macThai.enc @@ -0,0 +1,20 @@ +# Encoding file: macThai, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00AB00BB2026F88CF88FF892F895F898F88BF88EF891F894F897201C201DF899 +FFFD2022F884F889F885F886F887F888F88AF88DF890F893F89620182019FFFD +00A00E010E020E030E040E050E060E070E080E090E0A0E0B0E0C0E0D0E0E0E0F +0E100E110E120E130E140E150E160E170E180E190E1A0E1B0E1C0E1D0E1E0E1F +0E200E210E220E230E240E250E260E270E280E290E2A0E2B0E2C0E2D0E2E0E2F +0E300E310E320E330E340E350E360E370E380E390E3AFEFF200B201320140E3F +0E400E410E420E430E440E450E460E470E480E490E4A0E4B0E4C0E4D21220E4F +0E500E510E520E530E540E550E560E570E580E5900AE00A9FFFDFFFDFFFDFFFD diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macTurkish.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macTurkish.enc new file mode 100644 index 0000000000000000000000000000000000000000..f9542ae5c8583e95286acc1fac0fc4323a7378ac --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macTurkish.enc @@ -0,0 +1,20 @@ +# Encoding file: macTurkish, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +00C400C500C700C900D100D600DC00E100E000E200E400E300E500E700E900E8 +00EA00EB00ED00EC00EE00EF00F100F300F200F400F600F500FA00F900FB00FC +202000B000A200A300A7202200B600DF00AE00A9212200B400A8226000C600D8 +221E00B12264226500A500B522022211220F03C0222B00AA00BA03A900E600F8 +00BF00A100AC221A01922248220600AB00BB202600A000C000C300D501520153 +20132014201C201D2018201900F725CA00FF0178011E011F01300131015E015F +202100B7201A201E203000C200CA00C100CB00C800CD00CE00CF00CC00D300D4 +F8FF00D200DA00DB00D9F8A002C602DC00AF02D802D902DA00B802DD02DB02C7 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macUkraine.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macUkraine.enc new file mode 100644 index 0000000000000000000000000000000000000000..643cc45e9efb143293c7e054acdf959508d19a7b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/macUkraine.enc @@ -0,0 +1,20 @@ +# Encoding file: macUkraine, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E007F +0410041104120413041404150416041704180419041A041B041C041D041E041F +0420042104220423042404250426042704280429042A042B042C042D042E042F +202000B0049000A300A7202200B6040600AE00A9212204020452226004030453 +221E00B122642265045600B504910408040404540407045704090459040A045A +0458040500AC221A01922248220600AB00BB202600A0040B045B040C045C0455 +20132014201C201D2018201900F7201E040E045E040F045F211604010451044F +0430043104320433043404350436043704380439043A043B043C043D043E043F +0440044104420443044404450446044704480449044A044B044C044D044E00A4 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/shiftjis.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/shiftjis.enc new file mode 100644 index 0000000000000000000000000000000000000000..140aec4c15169a946ae9f4d8d133c930e417e804 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/shiftjis.enc @@ -0,0 +1,690 @@ +# Encoding file: shiftjis, multi-byte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diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/symbol.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/symbol.enc new file mode 100644 index 0000000000000000000000000000000000000000..ffda9e3ee606693f3cbf84b10e418ad4fef2cd05 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/symbol.enc @@ -0,0 +1,20 @@ +# Encoding file: symbol, single-byte +S +003F 1 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002122000023220300250026220D002800292217002B002C2212002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +22450391039203A70394039503A603930397039903D1039A039B039C039D039F +03A0039803A103A303A403A503C203A9039E03A80396005B2234005D22A5005F +F8E503B103B203C703B403B503C603B303B703B903D503BA03BB03BC03BD03BF +03C003B803C103C303C403C503D603C903BE03C803B6007B007C007D223C007F +0080008100820083008400850086008700880089008A008B008C008D008E008F +0090009100920093009400950096009700980099009A009B009C009D009E009F +000003D2203222642044221E0192266326662665266021942190219121922193 +00B000B12033226500D7221D2202202200F72260226122482026F8E6F8E721B5 +21352111211C21182297229522052229222A2283228722842282228622082209 +2220220700AE00A92122220F221A22C500AC2227222821D421D021D121D221D3 +22C42329F8E8F8E9F8EA2211F8EBF8ECF8EDF8EEF8EFF8F0F8F1F8F2F8F3F8F4 +F8FF232A222B2320F8F52321F8F6F8F7F8F8F8F9F8FAF8FBF8FCF8FDF8FE0000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/tis-620.enc b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/tis-620.enc new file mode 100644 index 0000000000000000000000000000000000000000..2e9142a4b237a075154f8042eb9f45163007f19c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/encoding/tis-620.enc @@ -0,0 +1,20 @@ +# Encoding file: tis-620, single-byte +S +003F 0 1 +00 +0000000100020003000400050006000700080009000A000B000C000D000E000F +0010001100120013001400150016001700180019001A001B001C001D001E001F +0020002100220023002400250026002700280029002A002B002C002D002E002F +0030003100320033003400350036003700380039003A003B003C003D003E003F +0040004100420043004400450046004700480049004A004B004C004D004E004F +0050005100520053005400550056005700580059005A005B005C005D005E005F +0060006100620063006400650066006700680069006A006B006C006D006E006F +0070007100720073007400750076007700780079007A007B007C007D007E0000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +00000E010E020E030E040E050E060E070E080E090E0A0E0B0E0C0E0D0E0E0E0F +0E100E110E120E130E140E150E160E170E180E190E1A0E1B0E1C0E1D0E1E0E1F +0E200E210E220E230E240E250E260E270E280E290E2A0E2B0E2C0E2D0E2E0E2F +0E300E310E320E330E340E350E360E370E380E390E3A00000000000000000E3F +0E400E410E420E430E440E450E460E470E480E490E4A0E4B0E4C0E4D0E4E0E4F +0E500E510E520E530E540E550E560E570E580E590E5A0E5B0000000000000000 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/history.tcl b/physworld_p1_20261018/envs/p1/lib/tcl8.6/history.tcl new file mode 100644 index 0000000000000000000000000000000000000000..ef9099be5b68d29604b0af394e371b0301a78bc7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/history.tcl @@ -0,0 +1,335 @@ +# history.tcl -- +# +# Implementation of the history command. +# +# Copyright (c) 1997 Sun Microsystems, Inc. +# +# See the file "license.terms" for information on usage and redistribution of +# this file, and for a DISCLAIMER OF ALL WARRANTIES. +# + +# The tcl::history array holds the history list and some additional +# bookkeeping variables. +# +# nextid the index used for the next history list item. +# keep the max size of the history list +# oldest the index of the oldest item in the history. + +namespace eval ::tcl { + variable history + if {![info exists history]} { + array set history { + nextid 0 + keep 20 + oldest -20 + } + } + + namespace ensemble create -command ::tcl::history -map { + add ::tcl::HistAdd + change ::tcl::HistChange + clear ::tcl::HistClear + event ::tcl::HistEvent + info ::tcl::HistInfo + keep ::tcl::HistKeep + nextid ::tcl::HistNextID + redo ::tcl::HistRedo + } +} + +# history -- +# +# This is the main history command. See the man page for its interface. +# This does some argument checking and calls the helper ensemble in the +# tcl namespace. + +proc ::history {args} { + # If no command given, we're doing 'history info'. Can't be done with an + # ensemble unknown handler, as those don't fire when no subcommand is + # given at all. + + if {![llength $args]} { + set args info + } + + # Tricky stuff needed to make stack and errors come out right! + tailcall apply {arglist {tailcall history {*}$arglist} ::tcl} $args +} + +# (unnamed) -- +# +# Callback when [::history] is destroyed. Destroys the implementation. +# +# Parameters: +# oldName what the command was called. +# newName what the command is now called (an empty string). +# op the operation (= delete). +# +# Results: +# none +# +# Side Effects: +# The implementation of the [::history] command ceases to exist. + +trace add command ::history delete [list apply {{oldName newName op} { + variable history + unset -nocomplain history + foreach c [info procs ::tcl::Hist*] { + rename $c {} + } + rename ::tcl::history {} +} ::tcl}] + +# tcl::HistAdd -- +# +# Add an item to the history, and optionally eval it at the global scope +# +# Parameters: +# event the command to add +# exec (optional) a substring of "exec" causes the command to +# be evaled. +# Results: +# If executing, then the results of the command are returned +# +# Side Effects: +# Adds to the history list + +proc ::tcl::HistAdd {event {exec {}}} { + variable history + + if { + [prefix longest {exec {}} $exec] eq "" + && [llength [info level 0]] == 3 + } then { + return -code error "bad argument \"$exec\": should be \"exec\"" + } + + # Do not add empty commands to the history + if {[string trim $event] eq ""} { + return "" + } + + # Maintain the history + set history([incr history(nextid)]) $event + unset -nocomplain history([incr history(oldest)]) + + # Only execute if 'exec' (or non-empty prefix of it) given + if {$exec eq ""} { + return "" + } + tailcall eval $event +} + +# tcl::HistKeep -- +# +# Set or query the limit on the length of the history list +# +# Parameters: +# limit (optional) the length of the history list +# +# Results: +# If no limit is specified, the current limit is returned +# +# Side Effects: +# Updates history(keep) if a limit is specified + +proc ::tcl::HistKeep {{count {}}} { + variable history + if {[llength [info level 0]] == 1} { + return $history(keep) + } + if {![string is integer -strict $count] || ($count < 0)} { + return -code error "illegal keep count \"$count\"" + } + set oldold $history(oldest) + set history(oldest) [expr {$history(nextid) - $count}] + for {} {$oldold <= $history(oldest)} {incr oldold} { + unset -nocomplain history($oldold) + } + set history(keep) $count +} + +# tcl::HistClear -- +# +# Erase the history list +# +# Parameters: +# none +# +# Results: +# none +# +# Side Effects: +# Resets the history array, except for the keep limit + +proc ::tcl::HistClear {} { + variable history + set keep $history(keep) + unset history + array set history [list \ + nextid 0 \ + keep $keep \ + oldest -$keep \ + ] +} + +# tcl::HistInfo -- +# +# Return a pretty-printed version of the history list +# +# Parameters: +# num (optional) the length of the history list to return +# +# Results: +# A formatted history list + +proc ::tcl::HistInfo {{count {}}} { + variable history + if {[llength [info level 0]] == 1} { + set count [expr {$history(keep) + 1}] + } elseif {![string is integer -strict $count]} { + return -code error "bad integer \"$count\"" + } + set result {} + set newline "" + for {set i [expr {$history(nextid) - $count + 1}]} \ + {$i <= $history(nextid)} {incr i} { + if {![info exists history($i)]} { + continue + } + set cmd [string map [list \n \n\t] [string trimright $history($i) \ \n]] + append result $newline[format "%6d %s" $i $cmd] + set newline \n + } + return $result +} + +# tcl::HistRedo -- +# +# Fetch the previous or specified event, execute it, and then replace +# the current history item with that event. +# +# Parameters: +# event (optional) index of history item to redo. Defaults to -1, +# which means the previous event. +# +# Results: +# Those of the command being redone. +# +# Side Effects: +# Replaces the current history list item with the one being redone. + +proc ::tcl::HistRedo {{event -1}} { + variable history + + set i [HistIndex $event] + if {$i == $history(nextid)} { + return -code error "cannot redo the current event" + } + set cmd $history($i) + HistChange $cmd 0 + tailcall eval $cmd +} + +# tcl::HistIndex -- +# +# Map from an event specifier to an index in the history list. +# +# Parameters: +# event index of history item to redo. +# If this is a positive number, it is used directly. +# If it is a negative number, then it counts back to a previous +# event, where -1 is the most recent event. +# A string can be matched, either by being the prefix of a +# command or by matching a command with string match. +# +# Results: +# The index into history, or an error if the index didn't match. + +proc ::tcl::HistIndex {event} { + variable history + if {![string is integer -strict $event]} { + for {set i [expr {$history(nextid)-1}]} {[info exists history($i)]} \ + {incr i -1} { + if {[string match $event* $history($i)]} { + return $i + } + if {[string match $event $history($i)]} { + return $i + } + } + return -code error "no event matches \"$event\"" + } elseif {$event <= 0} { + set i [expr {$history(nextid) + $event}] + } else { + set i $event + } + if {$i <= $history(oldest)} { + return -code error "event \"$event\" is too far in the past" + } + if {$i > $history(nextid)} { + return -code error "event \"$event\" hasn't occured yet" + } + return $i +} + +# tcl::HistEvent -- +# +# Map from an event specifier to the value in the history list. +# +# Parameters: +# event index of history item to redo. See index for a description of +# possible event patterns. +# +# Results: +# The value from the history list. + +proc ::tcl::HistEvent {{event -1}} { + variable history + set i [HistIndex $event] + if {![info exists history($i)]} { + return "" + } + return [string trimright $history($i) \ \n] +} + +# tcl::HistChange -- +# +# Replace a value in the history list. +# +# Parameters: +# newValue The new value to put into the history list. +# event (optional) index of history item to redo. See index for a +# description of possible event patterns. This defaults to 0, +# which specifies the current event. +# +# Side Effects: +# Changes the history list. + +proc ::tcl::HistChange {newValue {event 0}} { + variable history + set i [HistIndex $event] + set history($i) $newValue +} + +# tcl::HistNextID -- +# +# Returns the number of the next history event. +# +# Parameters: +# None. +# +# Side Effects: +# None. + +proc ::tcl::HistNextID {} { + variable history + return [expr {$history(nextid) + 1}] +} + +return + +# Local Variables: +# mode: tcl +# fill-column: 78 +# End: diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/http1.0/http.tcl b/physworld_p1_20261018/envs/p1/lib/tcl8.6/http1.0/http.tcl new file mode 100644 index 0000000000000000000000000000000000000000..8329de4144d837f24328efcb1391e7b4e7ff5ba1 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/http1.0/http.tcl @@ -0,0 +1,377 @@ +# http.tcl +# Client-side HTTP for GET, POST, and HEAD commands. +# These routines can be used in untrusted code that uses the Safesock +# security policy. +# These procedures use a callback interface to avoid using vwait, +# which is not defined in the safe base. +# +# See the http.n man page for documentation + +package provide http 1.0 + +array set http { + -accept */* + -proxyhost {} + -proxyport {} + -useragent {Tcl http client package 1.0} + -proxyfilter httpProxyRequired +} +proc http_config {args} { + global http + set options [lsort [array names http -*]] + set usage [join $options ", "] + if {[llength $args] == 0} { + set result {} + foreach name $options { + lappend result $name $http($name) + } + return $result + } + regsub -all -- - $options {} options + set pat ^-([join $options |])$ + if {[llength $args] == 1} { + set flag [lindex $args 0] + if {[regexp -- $pat $flag]} { + return $http($flag) + } else { + return -code error "Unknown option $flag, must be: $usage" + } + } else { + foreach {flag value} $args { + if {[regexp -- $pat $flag]} { + set http($flag) $value + } else { + return -code error "Unknown option $flag, must be: $usage" + } + } + } +} + + proc httpFinish { token {errormsg ""} } { + upvar #0 $token state + global errorInfo errorCode + if {[string length $errormsg] != 0} { + set state(error) [list $errormsg $errorInfo $errorCode] + set state(status) error + } + catch {close $state(sock)} + catch {after cancel $state(after)} + if {[info exists state(-command)]} { + if {[catch {eval $state(-command) {$token}} err]} { + if {[string length $errormsg] == 0} { + set state(error) [list $err $errorInfo $errorCode] + set state(status) error + } + } + unset state(-command) + } +} +proc http_reset { token {why reset} } { + upvar #0 $token state + set state(status) $why + catch {fileevent $state(sock) readable {}} + httpFinish $token + if {[info exists state(error)]} { + set errorlist $state(error) + unset state(error) + eval error $errorlist + } +} +proc http_get { url args } { + global http + if {![info exists http(uid)]} { + set http(uid) 0 + } + set token http#[incr http(uid)] + upvar #0 $token state + http_reset $token + array set state { + -blocksize 8192 + -validate 0 + -headers {} + -timeout 0 + state header + meta {} + currentsize 0 + totalsize 0 + type text/html + body {} + status "" + } + set options {-blocksize -channel -command -handler -headers \ + -progress -query -validate -timeout} + set usage [join $options ", "] + regsub -all -- - $options {} options + set pat ^-([join $options |])$ + foreach {flag value} $args { + if {[regexp $pat $flag]} { + # Validate numbers + if {[info exists state($flag)] && \ + [regexp {^[0-9]+$} $state($flag)] && \ + ![regexp {^[0-9]+$} $value]} { + return -code error "Bad value for $flag ($value), must be integer" + } + set state($flag) $value + } else { + return -code error "Unknown option $flag, can be: $usage" + } + } + if {! [regexp -nocase {^(http://)?([^/:]+)(:([0-9]+))?(/.*)?$} $url \ + x proto host y port srvurl]} { + error "Unsupported URL: $url" + } + if {[string length $port] == 0} { + set port 80 + } + if {[string length $srvurl] == 0} { + set srvurl / + } + if {[string length $proto] == 0} { + set url http://$url + } + set state(url) $url + if {![catch {$http(-proxyfilter) $host} proxy]} { + set phost [lindex $proxy 0] + set pport [lindex $proxy 1] + } + if {$state(-timeout) > 0} { + set state(after) [after $state(-timeout) [list http_reset $token timeout]] + } + if {[info exists phost] && [string length $phost]} { + set srvurl $url + set s [socket $phost $pport] + } else { + set s [socket $host $port] + } + set state(sock) $s + + # Send data in cr-lf format, but accept any line terminators + + fconfigure $s -translation {auto crlf} -buffersize $state(-blocksize) + + # The following is disallowed in safe interpreters, but the socket + # is already in non-blocking mode in that case. + + catch {fconfigure $s -blocking off} + set len 0 + set how GET + if {[info exists state(-query)]} { + set len [string length $state(-query)] + if {$len > 0} { + set how POST + } + } elseif {$state(-validate)} { + set how HEAD + } + puts $s "$how $srvurl HTTP/1.0" + puts $s "Accept: $http(-accept)" + puts $s "Host: $host" + puts $s "User-Agent: $http(-useragent)" + foreach {key value} $state(-headers) { + regsub -all \[\n\r\] $value {} value + set key [string trim $key] + if {[string length $key]} { + puts $s "$key: $value" + } + } + if {$len > 0} { + puts $s "Content-Length: $len" + puts $s "Content-Type: application/x-www-form-urlencoded" + puts $s "" + fconfigure $s -translation {auto binary} + puts -nonewline $s $state(-query) + } else { + puts $s "" + } + flush $s + fileevent $s readable [list httpEvent $token] + if {! [info exists state(-command)]} { + http_wait $token + } + return $token +} +proc http_data {token} { + upvar #0 $token state + return $state(body) +} +proc http_status {token} { + upvar #0 $token state + return $state(status) +} +proc http_code {token} { + upvar #0 $token state + return $state(http) +} +proc http_size {token} { + upvar #0 $token state + return $state(currentsize) +} + + proc httpEvent {token} { + upvar #0 $token state + set s $state(sock) + + if {[eof $s]} { + httpEof $token + return + } + if {$state(state) == "header"} { + set n [gets $s line] + if {$n == 0} { + set state(state) body + if {![regexp -nocase ^text $state(type)]} { + # Turn off conversions for non-text data + fconfigure $s -translation binary + if {[info exists state(-channel)]} { + fconfigure $state(-channel) -translation binary + } + } + if {[info exists state(-channel)] && + ![info exists state(-handler)]} { + # Initiate a sequence of background fcopies + fileevent $s readable {} + httpCopyStart $s $token + } + } elseif {$n > 0} { + if {[regexp -nocase {^content-type:(.+)$} $line x type]} { + set state(type) [string trim $type] + } + if {[regexp -nocase {^content-length:(.+)$} $line x length]} { + set state(totalsize) [string trim $length] + } + if {[regexp -nocase {^([^:]+):(.+)$} $line x key value]} { + lappend state(meta) $key $value + } elseif {[regexp ^HTTP $line]} { + set state(http) $line + } + } + } else { + if {[catch { + if {[info exists state(-handler)]} { + set n [eval $state(-handler) {$s $token}] + } else { + set block [read $s $state(-blocksize)] + set n [string length $block] + if {$n >= 0} { + append state(body) $block + } + } + if {$n >= 0} { + incr state(currentsize) $n + } + } err]} { + httpFinish $token $err + } else { + if {[info exists state(-progress)]} { + eval $state(-progress) {$token $state(totalsize) $state(currentsize)} + } + } + } +} + proc httpCopyStart {s token} { + upvar #0 $token state + if {[catch { + fcopy $s $state(-channel) -size $state(-blocksize) -command \ + [list httpCopyDone $token] + } err]} { + httpFinish $token $err + } +} + proc httpCopyDone {token count {error {}}} { + upvar #0 $token state + set s $state(sock) + incr state(currentsize) $count + if {[info exists state(-progress)]} { + eval $state(-progress) {$token $state(totalsize) $state(currentsize)} + } + if {([string length $error] != 0)} { + httpFinish $token $error + } elseif {[eof $s]} { + httpEof $token + } else { + httpCopyStart $s $token + } +} + proc httpEof {token} { + upvar #0 $token state + if {$state(state) == "header"} { + # Premature eof + set state(status) eof + } else { + set state(status) ok + } + set state(state) eof + httpFinish $token +} +proc http_wait {token} { + upvar #0 $token state + if {![info exists state(status)] || [string length $state(status)] == 0} { + vwait $token\(status) + } + if {[info exists state(error)]} { + set errorlist $state(error) + unset state(error) + eval error $errorlist + } + return $state(status) +} + +# Call http_formatQuery with an even number of arguments, where the first is +# a name, the second is a value, the third is another name, and so on. + +proc http_formatQuery {args} { + set result "" + set sep "" + foreach i $args { + append result $sep [httpMapReply $i] + if {$sep != "="} { + set sep = + } else { + set sep & + } + } + return $result +} + +# do x-www-urlencoded character mapping +# The spec says: "non-alphanumeric characters are replaced by '%HH'" +# 1 leave alphanumerics characters alone +# 2 Convert every other character to an array lookup +# 3 Escape constructs that are "special" to the tcl parser +# 4 "subst" the result, doing all the array substitutions + + proc httpMapReply {string} { + global httpFormMap + set alphanumeric a-zA-Z0-9 + if {![info exists httpFormMap]} { + + for {set i 1} {$i <= 256} {incr i} { + set c [format %c $i] + if {![string match \[$alphanumeric\] $c]} { + set httpFormMap($c) %[format %.2x $i] + } + } + # These are handled specially + array set httpFormMap { + " " + \n %0d%0a + } + } + regsub -all \[^$alphanumeric\] $string {$httpFormMap(&)} string + regsub -all \n $string {\\n} string + regsub -all \t $string {\\t} string + regsub -all {[][{})\\]\)} $string {\\&} string + return [subst $string] +} + +# Default proxy filter. + proc httpProxyRequired {host} { + global http + if {[info exists http(-proxyhost)] && [string length $http(-proxyhost)]} { + if {![info exists http(-proxyport)] || ![string length $http(-proxyport)]} { + set http(-proxyport) 8080 + } + return [list $http(-proxyhost) $http(-proxyport)] + } else { + return {} + } +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/http1.0/pkgIndex.tcl b/physworld_p1_20261018/envs/p1/lib/tcl8.6/http1.0/pkgIndex.tcl new file mode 100644 index 0000000000000000000000000000000000000000..ab6170f7f623e269c442ceef76e21b1cc4fb8c6f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/http1.0/pkgIndex.tcl @@ -0,0 +1,11 @@ +# Tcl package index file, version 1.0 +# This file is generated by the "pkg_mkIndex" command +# and sourced either when an application starts up or +# by a "package unknown" script. It invokes the +# "package ifneeded" command to set up package-related +# information so that packages will be loaded automatically +# in response to "package require" commands. When this +# script is sourced, the variable $dir must contain the +# full path name of this file's directory. + +package ifneeded http 1.0 [list tclPkgSetup $dir http 1.0 {{http.tcl source {httpCopyDone httpCopyStart httpEof httpEvent httpFinish httpMapReply httpProxyRequired http_code http_config http_data http_formatQuery http_get http_reset http_size http_status http_wait}}}] diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/init.tcl b/physworld_p1_20261018/envs/p1/lib/tcl8.6/init.tcl new file mode 100644 index 0000000000000000000000000000000000000000..0655dc87b8fa0c1e2d47c6801ac03841866c7e79 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/init.tcl @@ -0,0 +1,827 @@ +# init.tcl -- +# +# Default system startup file for Tcl-based applications. Defines +# "unknown" procedure and auto-load facilities. +# +# Copyright (c) 1991-1993 The Regents of the University of California. +# Copyright (c) 1994-1996 Sun Microsystems, Inc. +# Copyright (c) 1998-1999 Scriptics Corporation. +# Copyright (c) 2004 Kevin B. Kenny. All rights reserved. +# +# See the file "license.terms" for information on usage and redistribution +# of this file, and for a DISCLAIMER OF ALL WARRANTIES. +# + +# This test intentionally written in pre-7.5 Tcl +if {[info commands package] == ""} { + error "version mismatch: library\nscripts expect Tcl version 7.5b1 or later but the loaded version is\nonly [info patchlevel]" +} +package require -exact Tcl 8.6.13 + +# Compute the auto path to use in this interpreter. +# The values on the path come from several locations: +# +# The environment variable TCLLIBPATH +# +# tcl_library, which is the directory containing this init.tcl script. +# [tclInit] (Tcl_Init()) searches around for the directory containing this +# init.tcl and defines tcl_library to that location before sourcing it. +# +# The parent directory of tcl_library. Adding the parent +# means that packages in peer directories will be found automatically. +# +# Also add the directory ../lib relative to the directory where the +# executable is located. This is meant to find binary packages for the +# same architecture as the current executable. +# +# tcl_pkgPath, which is set by the platform-specific initialization routines +# On UNIX it is compiled in +# On Windows, it is not used +# +# (Ticket 41c9857bdd) In a safe interpreter, this file does not set +# ::auto_path (other than to {} if it is undefined). The caller, typically +# a Safe Base command, is responsible for setting ::auto_path. + +if {![info exists auto_path]} { + if {[info exists env(TCLLIBPATH)] && (![interp issafe])} { + set auto_path $env(TCLLIBPATH) + } else { + set auto_path "" + } +} +namespace eval tcl { + if {![interp issafe]} { + variable Dir + foreach Dir [list $::tcl_library [file dirname $::tcl_library]] { + if {$Dir ni $::auto_path} { + lappend ::auto_path $Dir + } + } + set Dir [file join [file dirname [file dirname \ + [info nameofexecutable]]] lib] + if {$Dir ni $::auto_path} { + lappend ::auto_path $Dir + } + if {[info exists ::tcl_pkgPath]} { catch { + foreach Dir $::tcl_pkgPath { + if {$Dir ni $::auto_path} { + lappend ::auto_path $Dir + } + } + }} + + variable Path [encoding dirs] + set Dir [file join $::tcl_library encoding] + if {$Dir ni $Path} { + lappend Path $Dir + encoding dirs $Path + } + unset Dir Path + } + + # TIP #255 min and max functions + namespace eval mathfunc { + proc min {args} { + if {![llength $args]} { + return -code error \ + "not enough arguments to math function \"min\"" + } + set val Inf + foreach arg $args { + # This will handle forcing the numeric value without + # ruining the internal type of a numeric object + if {[catch {expr {double($arg)}} err]} { + return -code error $err + } + if {$arg < $val} {set val $arg} + } + return $val + } + proc max {args} { + if {![llength $args]} { + return -code error \ + "not enough arguments to math function \"max\"" + } + set val -Inf + foreach arg $args { + # This will handle forcing the numeric value without + # ruining the internal type of a numeric object + if {[catch {expr {double($arg)}} err]} { + return -code error $err + } + if {$arg > $val} {set val $arg} + } + return $val + } + namespace export min max + } +} + +# Windows specific end of initialization + +if {(![interp issafe]) && ($tcl_platform(platform) eq "windows")} { + namespace eval tcl { + proc EnvTraceProc {lo n1 n2 op} { + global env + set x $env($n2) + set env($lo) $x + set env([string toupper $lo]) $x + } + proc InitWinEnv {} { + global env tcl_platform + foreach p [array names env] { + set u [string toupper $p] + if {$u ne $p} { + switch -- $u { + COMSPEC - + PATH { + set temp $env($p) + unset env($p) + set env($u) $temp + trace add variable env($p) write \ + [namespace code [list EnvTraceProc $p]] + trace add variable env($u) write \ + [namespace code [list EnvTraceProc $p]] + } + } + } + } + if {![info exists env(COMSPEC)]} { + set env(COMSPEC) cmd.exe + } + } + InitWinEnv + } +} + +# Setup the unknown package handler + + +if {[interp issafe]} { + package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown} +} else { + # Set up search for Tcl Modules (TIP #189). + # and setup platform specific unknown package handlers + if {$tcl_platform(os) eq "Darwin" + && $tcl_platform(platform) eq "unix"} { + package unknown {::tcl::tm::UnknownHandler \ + {::tcl::MacOSXPkgUnknown ::tclPkgUnknown}} + } else { + package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown} + } + + # Set up the 'clock' ensemble + + namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library] + + proc ::tcl::initClock {} { + # Auto-loading stubs for 'clock.tcl' + + foreach cmd {add format scan} { + proc ::tcl::clock::$cmd args { + variable TclLibDir + source -encoding utf-8 [file join $TclLibDir clock.tcl] + return [uplevel 1 [info level 0]] + } + } + + rename ::tcl::initClock {} + } + ::tcl::initClock +} + +# Conditionalize for presence of exec. + +if {[namespace which -command exec] eq ""} { + + # Some machines do not have exec. Also, on all + # platforms, safe interpreters do not have exec. + + set auto_noexec 1 +} + +# Define a log command (which can be overwitten to log errors +# differently, specially when stderr is not available) + +if {[namespace which -command tclLog] eq ""} { + proc tclLog {string} { + catch {puts stderr $string} + } +} + +# unknown -- +# This procedure is called when a Tcl command is invoked that doesn't +# exist in the interpreter. It takes the following steps to make the +# command available: +# +# 1. See if the autoload facility can locate the command in a +# Tcl script file. If so, load it and execute it. +# 2. If the command was invoked interactively at top-level: +# (a) see if the command exists as an executable UNIX program. +# If so, "exec" the command. +# (b) see if the command requests csh-like history substitution +# in one of the common forms !!, !, or ^old^new. If +# so, emulate csh's history substitution. +# (c) see if the command is a unique abbreviation for another +# command. If so, invoke the command. +# +# Arguments: +# args - A list whose elements are the words of the original +# command, including the command name. + +proc unknown args { + variable ::tcl::UnknownPending + global auto_noexec auto_noload env tcl_interactive errorInfo errorCode + + if {[info exists errorInfo]} { + set savedErrorInfo $errorInfo + } + if {[info exists errorCode]} { + set savedErrorCode $errorCode + } + + set name [lindex $args 0] + if {![info exists auto_noload]} { + # + # Make sure we're not trying to load the same proc twice. + # + if {[info exists UnknownPending($name)]} { + return -code error "self-referential recursion\ + in \"unknown\" for command \"$name\"" + } + set UnknownPending($name) pending + set ret [catch { + auto_load $name [uplevel 1 {::namespace current}] + } msg opts] + unset UnknownPending($name) + if {$ret != 0} { + dict append opts -errorinfo "\n (autoloading \"$name\")" + return -options $opts $msg + } + if {![array size UnknownPending]} { + unset UnknownPending + } + if {$msg} { + if {[info exists savedErrorCode]} { + set ::errorCode $savedErrorCode + } else { + unset -nocomplain ::errorCode + } + if {[info exists savedErrorInfo]} { + set errorInfo $savedErrorInfo + } else { + unset -nocomplain errorInfo + } + set code [catch {uplevel 1 $args} msg opts] + if {$code == 1} { + # + # Compute stack trace contribution from the [uplevel]. + # Note the dependence on how Tcl_AddErrorInfo, etc. + # construct the stack trace. + # + set errInfo [dict get $opts -errorinfo] + set errCode [dict get $opts -errorcode] + set cinfo $args + if {[string bytelength $cinfo] > 150} { + set cinfo [string range $cinfo 0 150] + while {[string bytelength $cinfo] > 150} { + set cinfo [string range $cinfo 0 end-1] + } + append cinfo ... + } + set tail "\n (\"uplevel\" body line 1)\n invoked\ + from within\n\"uplevel 1 \$args\"" + set expect "$msg\n while executing\n\"$cinfo\"$tail" + if {$errInfo eq $expect} { + # + # The stack has only the eval from the expanded command + # Do not generate any stack trace here. + # + dict unset opts -errorinfo + dict incr opts -level + return -options $opts $msg + } + # + # Stack trace is nested, trim off just the contribution + # from the extra "eval" of $args due to the "catch" above. + # + set last [string last $tail $errInfo] + if {$last + [string length $tail] != [string length $errInfo]} { + # Very likely cannot happen + return -options $opts $msg + } + set errInfo [string range $errInfo 0 $last-1] + set tail "\"$cinfo\"" + set last [string last $tail $errInfo] + if {$last < 0 || $last + [string length $tail] != [string length $errInfo]} { + return -code error -errorcode $errCode \ + -errorinfo $errInfo $msg + } + set errInfo [string range $errInfo 0 $last-1] + set tail "\n invoked from within\n" + set last [string last $tail $errInfo] + if {$last + [string length $tail] == [string length $errInfo]} { + return -code error -errorcode $errCode \ + -errorinfo [string range $errInfo 0 $last-1] $msg + } + set tail "\n while executing\n" + set last [string last $tail $errInfo] + if {$last + [string length $tail] == [string length $errInfo]} { + return -code error -errorcode $errCode \ + -errorinfo [string range $errInfo 0 $last-1] $msg + } + return -options $opts $msg + } else { + dict incr opts -level + return -options $opts $msg + } + } + } + + if {([info level] == 1) && ([info script] eq "") + && [info exists tcl_interactive] && $tcl_interactive} { + if {![info exists auto_noexec]} { + set new [auto_execok $name] + if {$new ne ""} { + set redir "" + if {[namespace which -command console] eq ""} { + set redir ">&@stdout <@stdin" + } + uplevel 1 [list ::catch \ + [concat exec $redir $new [lrange $args 1 end]] \ + ::tcl::UnknownResult ::tcl::UnknownOptions] + dict incr ::tcl::UnknownOptions -level + return -options $::tcl::UnknownOptions $::tcl::UnknownResult + } + } + if {$name eq "!!"} { + set newcmd [history event] + } elseif {[regexp {^!(.+)$} $name -> event]} { + set newcmd [history event $event] + } elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} { + set newcmd [history event -1] + catch {regsub -all -- $old $newcmd $new newcmd} + } + if {[info exists newcmd]} { + tclLog $newcmd + history change $newcmd 0 + uplevel 1 [list ::catch $newcmd \ + ::tcl::UnknownResult ::tcl::UnknownOptions] + dict incr ::tcl::UnknownOptions -level + return -options $::tcl::UnknownOptions $::tcl::UnknownResult + } + + set ret [catch {set candidates [info commands $name*]} msg] + if {$name eq "::"} { + set name "" + } + if {$ret != 0} { + dict append opts -errorinfo \ + "\n (expanding command prefix \"$name\" in unknown)" + return -options $opts $msg + } + # Filter out bogus matches when $name contained + # a glob-special char [Bug 946952] + if {$name eq ""} { + # Handle empty $name separately due to strangeness + # in [string first] (See RFE 1243354) + set cmds $candidates + } else { + set cmds [list] + foreach x $candidates { + if {[string first $name $x] == 0} { + lappend cmds $x + } + } + } + if {[llength $cmds] == 1} { + uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \ + ::tcl::UnknownResult ::tcl::UnknownOptions] + dict incr ::tcl::UnknownOptions -level + return -options $::tcl::UnknownOptions $::tcl::UnknownResult + } + if {[llength $cmds]} { + return -code error "ambiguous command name \"$name\": [lsort $cmds]" + } + } + return -code error -errorcode [list TCL LOOKUP COMMAND $name] \ + "invalid command name \"$name\"" +} + +# auto_load -- +# Checks a collection of library directories to see if a procedure +# is defined in one of them. If so, it sources the appropriate +# library file to create the procedure. Returns 1 if it successfully +# loaded the procedure, 0 otherwise. +# +# Arguments: +# cmd - Name of the command to find and load. +# namespace (optional) The namespace where the command is being used - must be +# a canonical namespace as returned [namespace current] +# for instance. If not given, namespace current is used. + +proc auto_load {cmd {namespace {}}} { + global auto_index auto_path + + if {$namespace eq ""} { + set namespace [uplevel 1 [list ::namespace current]] + } + set nameList [auto_qualify $cmd $namespace] + # workaround non canonical auto_index entries that might be around + # from older auto_mkindex versions + lappend nameList $cmd + foreach name $nameList { + if {[info exists auto_index($name)]} { + namespace eval :: $auto_index($name) + # There's a couple of ways to look for a command of a given + # name. One is to use + # info commands $name + # Unfortunately, if the name has glob-magic chars in it like * + # or [], it may not match. For our purposes here, a better + # route is to use + # namespace which -command $name + if {[namespace which -command $name] ne ""} { + return 1 + } + } + } + if {![info exists auto_path]} { + return 0 + } + + if {![auto_load_index]} { + return 0 + } + foreach name $nameList { + if {[info exists auto_index($name)]} { + namespace eval :: $auto_index($name) + if {[namespace which -command $name] ne ""} { + return 1 + } + } + } + return 0 +} + +# auto_load_index -- +# Loads the contents of tclIndex files on the auto_path directory +# list. This is usually invoked within auto_load to load the index +# of available commands. Returns 1 if the index is loaded, and 0 if +# the index is already loaded and up to date. +# +# Arguments: +# None. + +proc auto_load_index {} { + variable ::tcl::auto_oldpath + global auto_index auto_path + + if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} { + return 0 + } + set auto_oldpath $auto_path + + # Check if we are a safe interpreter. In that case, we support only + # newer format tclIndex files. + + set issafe [interp issafe] + for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} { + set dir [lindex $auto_path $i] + set f "" + if {$issafe} { + catch {source [file join $dir tclIndex]} + } elseif {[catch {set f [open [file join $dir tclIndex]]}]} { + continue + } else { + set error [catch { + fconfigure $f -eofchar "\032 {}" + set id [gets $f] + if {$id eq "# Tcl autoload index file, version 2.0"} { + eval [read $f] + } elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} { + while {[gets $f line] >= 0} { + if {([string index $line 0] eq "#") \ + || ([llength $line] != 2)} { + continue + } + set name [lindex $line 0] + set auto_index($name) \ + "source [file join $dir [lindex $line 1]]" + } + } else { + error "[file join $dir tclIndex] isn't a proper Tcl index file" + } + } msg opts] + if {$f ne ""} { + close $f + } + if {$error} { + return -options $opts $msg + } + } + } + return 1 +} + +# auto_qualify -- +# +# Compute a fully qualified names list for use in the auto_index array. +# For historical reasons, commands in the global namespace do not have leading +# :: in the index key. The list has two elements when the command name is +# relative (no leading ::) and the namespace is not the global one. Otherwise +# only one name is returned (and searched in the auto_index). +# +# Arguments - +# cmd The command name. Can be any name accepted for command +# invocations (Like "foo::::bar"). +# namespace The namespace where the command is being used - must be +# a canonical namespace as returned by [namespace current] +# for instance. + +proc auto_qualify {cmd namespace} { + + # count separators and clean them up + # (making sure that foo:::::bar will be treated as foo::bar) + set n [regsub -all {::+} $cmd :: cmd] + + # Ignore namespace if the name starts with :: + # Handle special case of only leading :: + + # Before each return case we give an example of which category it is + # with the following form : + # (inputCmd, inputNameSpace) -> output + + if {[string match ::* $cmd]} { + if {$n > 1} { + # (::foo::bar , *) -> ::foo::bar + return [list $cmd] + } else { + # (::global , *) -> global + return [list [string range $cmd 2 end]] + } + } + + # Potentially returning 2 elements to try : + # (if the current namespace is not the global one) + + if {$n == 0} { + if {$namespace eq "::"} { + # (nocolons , ::) -> nocolons + return [list $cmd] + } else { + # (nocolons , ::sub) -> ::sub::nocolons nocolons + return [list ${namespace}::$cmd $cmd] + } + } elseif {$namespace eq "::"} { + # (foo::bar , ::) -> ::foo::bar + return [list ::$cmd] + } else { + # (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar + return [list ${namespace}::$cmd ::$cmd] + } +} + +# auto_import -- +# +# Invoked during "namespace import" to make see if the imported commands +# reside in an autoloaded library. If so, the commands are loaded so +# that they will be available for the import links. If not, then this +# procedure does nothing. +# +# Arguments - +# pattern The pattern of commands being imported (like "foo::*") +# a canonical namespace as returned by [namespace current] + +proc auto_import {pattern} { + global auto_index + + # If no namespace is specified, this will be an error case + + if {![string match *::* $pattern]} { + return + } + + set ns [uplevel 1 [list ::namespace current]] + set patternList [auto_qualify $pattern $ns] + + auto_load_index + + foreach pattern $patternList { + foreach name [array names auto_index $pattern] { + if {([namespace which -command $name] eq "") + && ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} { + namespace eval :: $auto_index($name) + } + } + } +} + +# auto_execok -- +# +# Returns string that indicates name of program to execute if +# name corresponds to a shell builtin or an executable in the +# Windows search path, or "" otherwise. Builds an associative +# array auto_execs that caches information about previous checks, +# for speed. +# +# Arguments: +# name - Name of a command. + +if {$tcl_platform(platform) eq "windows"} { +# Windows version. +# +# Note that file executable doesn't work under Windows, so we have to +# look for files with .exe, .com, or .bat extensions. Also, the path +# may be in the Path or PATH environment variables, and path +# components are separated with semicolons, not colons as under Unix. +# +proc auto_execok name { + global auto_execs env tcl_platform + + if {[info exists auto_execs($name)]} { + return $auto_execs($name) + } + set auto_execs($name) "" + + set shellBuiltins [list assoc cls copy date del dir echo erase exit ftype \ + md mkdir mklink move rd ren rename rmdir start time type ver vol] + if {[info exists env(PATHEXT)]} { + # Add an initial ; to have the {} extension check first. + set execExtensions [split ";$env(PATHEXT)" ";"] + } else { + set execExtensions [list {} .com .exe .bat .cmd] + } + + if {[string tolower $name] in $shellBuiltins} { + # When this is command.com for some reason on Win2K, Tcl won't + # exec it unless the case is right, which this corrects. COMSPEC + # may not point to a real file, so do the check. + set cmd $env(COMSPEC) + if {[file exists $cmd]} { + set cmd [file attributes $cmd -shortname] + } + return [set auto_execs($name) [list $cmd /c $name]] + } + + if {[llength [file split $name]] != 1} { + foreach ext $execExtensions { + set file ${name}${ext} + if {[file exists $file] && ![file isdirectory $file]} { + return [set auto_execs($name) [list $file]] + } + } + return "" + } + + set path "[file dirname [info nameof]];.;" + if {[info exists env(SystemRoot)]} { + set windir $env(SystemRoot) + } elseif {[info exists env(WINDIR)]} { + set windir $env(WINDIR) + } + if {[info exists windir]} { + if {$tcl_platform(os) eq "Windows NT"} { + append path "$windir/system32;" + } + append path "$windir/system;$windir;" + } + + foreach var {PATH Path path} { + if {[info exists env($var)]} { + append path ";$env($var)" + } + } + + foreach ext $execExtensions { + unset -nocomplain checked + foreach dir [split $path {;}] { + # Skip already checked directories + if {[info exists checked($dir)] || ($dir eq "")} { + continue + } + set checked($dir) {} + set file [file join $dir ${name}${ext}] + if {[file exists $file] && ![file isdirectory $file]} { + return [set auto_execs($name) [list $file]] + } + } + } + return "" +} + +} else { +# Unix version. +# +proc auto_execok name { + global auto_execs env + + if {[info exists auto_execs($name)]} { + return $auto_execs($name) + } + set auto_execs($name) "" + if {[llength [file split $name]] != 1} { + if {[file executable $name] && ![file isdirectory $name]} { + set auto_execs($name) [list $name] + } + return $auto_execs($name) + } + foreach dir [split $env(PATH) :] { + if {$dir eq ""} { + set dir . + } + set file [file join $dir $name] + if {[file executable $file] && ![file isdirectory $file]} { + set auto_execs($name) [list $file] + return $auto_execs($name) + } + } + return "" +} + +} + +# ::tcl::CopyDirectory -- +# +# This procedure is called by Tcl's core when attempts to call the +# filesystem's copydirectory function fail. The semantics of the call +# are that 'dest' does not yet exist, i.e. dest should become the exact +# image of src. If dest does exist, we throw an error. +# +# Note that making changes to this procedure can change the results +# of running Tcl's tests. +# +# Arguments: +# action - "renaming" or "copying" +# src - source directory +# dest - destination directory +proc tcl::CopyDirectory {action src dest} { + set nsrc [file normalize $src] + set ndest [file normalize $dest] + + if {$action eq "renaming"} { + # Can't rename volumes. We could give a more precise + # error message here, but that would break the test suite. + if {$nsrc in [file volumes]} { + return -code error "error $action \"$src\" to\ + \"$dest\": trying to rename a volume or move a directory\ + into itself" + } + } + if {[file exists $dest]} { + if {$nsrc eq $ndest} { + return -code error "error $action \"$src\" to\ + \"$dest\": trying to rename a volume or move a directory\ + into itself" + } + if {$action eq "copying"} { + # We used to throw an error here, but, looking more closely + # at the core copy code in tclFCmd.c, if the destination + # exists, then we should only call this function if -force + # is true, which means we just want to over-write. So, + # the following code is now commented out. + # + # return -code error "error $action \"$src\" to\ + # \"$dest\": file already exists" + } else { + # Depending on the platform, and on the current + # working directory, the directories '.', '..' + # can be returned in various combinations. Anyway, + # if any other file is returned, we must signal an error. + set existing [glob -nocomplain -directory $dest * .*] + lappend existing {*}[glob -nocomplain -directory $dest \ + -type hidden * .*] + foreach s $existing { + if {[file tail $s] ni {. ..}} { + return -code error "error $action \"$src\" to\ + \"$dest\": file already exists" + } + } + } + } else { + if {[string first $nsrc $ndest] >= 0} { + set srclen [expr {[llength [file split $nsrc]] - 1}] + set ndest [lindex [file split $ndest] $srclen] + if {$ndest eq [file tail $nsrc]} { + return -code error "error $action \"$src\" to\ + \"$dest\": trying to rename a volume or move a directory\ + into itself" + } + } + file mkdir $dest + } + # Have to be careful to capture both visible and hidden files. + # We will also be more generous to the file system and not + # assume the hidden and non-hidden lists are non-overlapping. + # + # On Unix 'hidden' files begin with '.'. On other platforms + # or filesystems hidden files may have other interpretations. + set filelist [concat [glob -nocomplain -directory $src *] \ + [glob -nocomplain -directory $src -types hidden *]] + + foreach s [lsort -unique $filelist] { + if {[file tail $s] ni {. ..}} { + file copy -force -- $s [file join $dest [file tail $s]] + } + } + return +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/af.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/af.msg new file mode 100644 index 0000000000000000000000000000000000000000..08926157c3743f46d068ff8c614321af0d5e99ee --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/af.msg @@ -0,0 +1,49 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset af DAYS_OF_WEEK_ABBREV [list \ + "So"\ + "Ma"\ + "Di"\ + "Wo"\ + "Do"\ + "Vr"\ + "Sa"] + ::msgcat::mcset af DAYS_OF_WEEK_FULL [list \ + "Sondag"\ + "Maandag"\ + "Dinsdag"\ + "Woensdag"\ + "Donderdag"\ + "Vrydag"\ + "Saterdag"] + ::msgcat::mcset af MONTHS_ABBREV [list \ + "Jan"\ + "Feb"\ + "Mar"\ + "Apr"\ + "Mei"\ + "Jun"\ + "Jul"\ + "Aug"\ + "Sep"\ + "Okt"\ + "Nov"\ + "Des"\ + ""] + ::msgcat::mcset af MONTHS_FULL [list \ + "Januarie"\ + "Februarie"\ + "Maart"\ + "April"\ + "Mei"\ + "Junie"\ + "Julie"\ + "Augustus"\ + "September"\ + "Oktober"\ + "November"\ + "Desember"\ + ""] + ::msgcat::mcset af AM "VM" + ::msgcat::mcset af PM "NM" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/af_za.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/af_za.msg new file mode 100644 index 0000000000000000000000000000000000000000..fef48ad48fe899ab4bbc86f28edcf11edb66c5d8 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/af_za.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset af_ZA DATE_FORMAT "%d %B %Y" + ::msgcat::mcset af_ZA TIME_FORMAT_12 "%l:%M:%S %P" + ::msgcat::mcset af_ZA DATE_TIME_FORMAT "%d %B %Y %l:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ar.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ar.msg new file mode 100644 index 0000000000000000000000000000000000000000..257157fd0e84065c8cf3bb2b58826781579d5e79 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ar.msg @@ -0,0 +1,54 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ar DAYS_OF_WEEK_ABBREV [list \ + "\u062d"\ + "\u0646"\ + "\u062b"\ + "\u0631"\ + "\u062e"\ + "\u062c"\ + "\u0633"] + ::msgcat::mcset ar DAYS_OF_WEEK_FULL [list \ + "\u0627\u0644\u0623\u062d\u062f"\ + "\u0627\u0644\u0627\u062b\u0646\u064a\u0646"\ + "\u0627\u0644\u062b\u0644\u0627\u062b\u0627\u0621"\ + "\u0627\u0644\u0623\u0631\u0628\u0639\u0627\u0621"\ + "\u0627\u0644\u062e\u0645\u064a\u0633"\ + "\u0627\u0644\u062c\u0645\u0639\u0629"\ + "\u0627\u0644\u0633\u0628\u062a"] + ::msgcat::mcset ar MONTHS_ABBREV [list \ + "\u064a\u0646\u0627"\ + "\u0641\u0628\u0631"\ + "\u0645\u0627\u0631"\ + "\u0623\u0628\u0631"\ + "\u0645\u0627\u064a"\ + "\u064a\u0648\u0646"\ + "\u064a\u0648\u0644"\ + "\u0623\u063a\u0633"\ + "\u0633\u0628\u062a"\ + "\u0623\u0643\u062a"\ + "\u0646\u0648\u0641"\ + "\u062f\u064a\u0633"\ + ""] + ::msgcat::mcset ar MONTHS_FULL [list \ + "\u064a\u0646\u0627\u064a\u0631"\ + "\u0641\u0628\u0631\u0627\u064a\u0631"\ + "\u0645\u0627\u0631\u0633"\ + "\u0623\u0628\u0631\u064a\u0644"\ + "\u0645\u0627\u064a\u0648"\ + "\u064a\u0648\u0646\u064a\u0648"\ + "\u064a\u0648\u0644\u064a\u0648"\ + "\u0623\u063a\u0633\u0637\u0633"\ + "\u0633\u0628\u062a\u0645\u0628\u0631"\ + "\u0623\u0643\u062a\u0648\u0628\u0631"\ + "\u0646\u0648\u0641\u0645\u0628\u0631"\ + "\u062f\u064a\u0633\u0645\u0628\u0631"\ + ""] + ::msgcat::mcset ar BCE "\u0642.\u0645" + ::msgcat::mcset ar CE "\u0645" + ::msgcat::mcset ar AM "\u0635" + ::msgcat::mcset ar PM "\u0645" + ::msgcat::mcset ar DATE_FORMAT "%d/%m/%Y" + ::msgcat::mcset ar TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset ar DATE_TIME_FORMAT "%d/%m/%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ar_in.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ar_in.msg new file mode 100644 index 0000000000000000000000000000000000000000..185e49c377ac8c8c0eef18c068a11b28fa6fadcb --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ar_in.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ar_IN DATE_FORMAT "%A %d %B %Y" + ::msgcat::mcset ar_IN TIME_FORMAT_12 "%I:%M:%S %z" + ::msgcat::mcset ar_IN DATE_TIME_FORMAT "%A %d %B %Y %I:%M:%S %z %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ar_jo.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ar_jo.msg new file mode 100644 index 0000000000000000000000000000000000000000..0f5e26975e8eaf3f6e097403ead544f8da63a00e --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ar_jo.msg @@ -0,0 +1,39 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ar_JO DAYS_OF_WEEK_ABBREV [list \ + "\u0627\u0644\u0623\u062d\u062f"\ + "\u0627\u0644\u0627\u062b\u0646\u064a\u0646"\ + "\u0627\u0644\u062b\u0644\u0627\u062b\u0627\u0621"\ + "\u0627\u0644\u0623\u0631\u0628\u0639\u0627\u0621"\ + "\u0627\u0644\u062e\u0645\u064a\u0633"\ + "\u0627\u0644\u062c\u0645\u0639\u0629"\ + "\u0627\u0644\u0633\u0628\u062a"] + ::msgcat::mcset ar_JO MONTHS_ABBREV [list \ + "\u0643\u0627\u0646\u0648\u0646 \u0627\u0644\u062b\u0627\u0646\u064a"\ + "\u0634\u0628\u0627\u0637"\ + "\u0622\u0630\u0627\u0631"\ + "\u0646\u064a\u0633\u0627\u0646"\ + "\u0646\u0648\u0627\u0631"\ + "\u062d\u0632\u064a\u0631\u0627\u0646"\ + "\u062a\u0645\u0648\u0632"\ + "\u0622\u0628"\ + "\u0623\u064a\u0644\u0648\u0644"\ + "\u062a\u0634\u0631\u064a\u0646 \u0627\u0644\u0623\u0648\u0644"\ + "\u062a\u0634\u0631\u064a\u0646 \u0627\u0644\u062b\u0627\u0646\u064a"\ + "\u0643\u0627\u0646\u0648\u0646 \u0627\u0644\u0623\u0648\u0644"\ + ""] + ::msgcat::mcset ar_JO MONTHS_FULL [list \ + "\u0643\u0627\u0646\u0648\u0646 \u0627\u0644\u062b\u0627\u0646\u064a"\ + "\u0634\u0628\u0627\u0637"\ + "\u0622\u0630\u0627\u0631"\ + "\u0646\u064a\u0633\u0627\u0646"\ + "\u0646\u0648\u0627\u0631"\ + "\u062d\u0632\u064a\u0631\u0627\u0646"\ + "\u062a\u0645\u0648\u0632"\ + "\u0622\u0628"\ + "\u0623\u064a\u0644\u0648\u0644"\ + "\u062a\u0634\u0631\u064a\u0646 \u0627\u0644\u0623\u0648\u0644"\ + "\u062a\u0634\u0631\u064a\u0646 \u0627\u0644\u062b\u0627\u0646\u064a"\ + "\u0643\u0627\u0646\u0648\u0646 \u0627\u0644\u0623\u0648\u0644"\ + ""] +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ar_lb.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ar_lb.msg new file mode 100644 index 0000000000000000000000000000000000000000..e62acd35092b7bc3f9ade6c5a34dae2baa12aa30 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ar_lb.msg @@ -0,0 +1,39 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ar_LB DAYS_OF_WEEK_ABBREV [list \ + "\u0627\u0644\u0623\u062d\u062f"\ + "\u0627\u0644\u0627\u062b\u0646\u064a\u0646"\ + "\u0627\u0644\u062b\u0644\u0627\u062b\u0627\u0621"\ + "\u0627\u0644\u0623\u0631\u0628\u0639\u0627\u0621"\ + "\u0627\u0644\u062e\u0645\u064a\u0633"\ + "\u0627\u0644\u062c\u0645\u0639\u0629"\ + "\u0627\u0644\u0633\u0628\u062a"] + ::msgcat::mcset ar_LB MONTHS_ABBREV [list \ + "\u0643\u0627\u0646\u0648\u0646 \u0627\u0644\u062b\u0627\u0646\u064a"\ + "\u0634\u0628\u0627\u0637"\ + "\u0622\u0630\u0627\u0631"\ + "\u0646\u064a\u0633\u0627\u0646"\ + "\u0646\u0648\u0627\u0631"\ + "\u062d\u0632\u064a\u0631\u0627\u0646"\ + "\u062a\u0645\u0648\u0632"\ + "\u0622\u0628"\ + "\u0623\u064a\u0644\u0648\u0644"\ + "\u062a\u0634\u0631\u064a\u0646 \u0627\u0644\u0623\u0648\u0644"\ + "\u062a\u0634\u0631\u064a\u0646 \u0627\u0644\u062b\u0627\u0646\u064a"\ + "\u0643\u0627\u0646\u0648\u0646 \u0627\u0644\u0623\u0648\u0644"\ + ""] + ::msgcat::mcset ar_LB MONTHS_FULL [list \ + "\u0643\u0627\u0646\u0648\u0646 \u0627\u0644\u062b\u0627\u0646\u064a"\ + "\u0634\u0628\u0627\u0637"\ + "\u0622\u0630\u0627\u0631"\ + "\u0646\u064a\u0633\u0627\u0646"\ + "\u0646\u0648\u0627\u0631"\ + "\u062d\u0632\u064a\u0631\u0627\u0646"\ + "\u062a\u0645\u0648\u0632"\ + "\u0622\u0628"\ + "\u0623\u064a\u0644\u0648\u0644"\ + "\u062a\u0634\u0631\u064a\u0646 \u0627\u0644\u0623\u0648\u0644"\ + "\u062a\u0634\u0631\u064a\u0646 \u0627\u0644\u062b\u0627\u0646\u064a"\ + "\u0643\u0627\u0646\u0648\u0646 \u0627\u0644\u0623\u0648\u0644"\ + ""] +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ar_sy.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ar_sy.msg new file mode 100644 index 0000000000000000000000000000000000000000..d5e1c873a1c2b7790d7d539cbb59a3d2e5ae02dd --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ar_sy.msg @@ -0,0 +1,39 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ar_SY DAYS_OF_WEEK_ABBREV [list \ + "\u0627\u0644\u0623\u062d\u062f"\ + "\u0627\u0644\u0627\u062b\u0646\u064a\u0646"\ + "\u0627\u0644\u062b\u0644\u0627\u062b\u0627\u0621"\ + "\u0627\u0644\u0623\u0631\u0628\u0639\u0627\u0621"\ + "\u0627\u0644\u062e\u0645\u064a\u0633"\ + "\u0627\u0644\u062c\u0645\u0639\u0629"\ + "\u0627\u0644\u0633\u0628\u062a"] + ::msgcat::mcset ar_SY MONTHS_ABBREV [list \ + "\u0643\u0627\u0646\u0648\u0646 \u0627\u0644\u062b\u0627\u0646\u064a"\ + "\u0634\u0628\u0627\u0637"\ + "\u0622\u0630\u0627\u0631"\ + "\u0646\u064a\u0633\u0627\u0646"\ + "\u0646\u0648\u0627\u0631"\ + "\u062d\u0632\u064a\u0631\u0627\u0646"\ + "\u062a\u0645\u0648\u0632"\ + "\u0622\u0628"\ + "\u0623\u064a\u0644\u0648\u0644"\ + "\u062a\u0634\u0631\u064a\u0646 \u0627\u0644\u0623\u0648\u0644"\ + "\u062a\u0634\u0631\u064a\u0646 \u0627\u0644\u062b\u0627\u0646\u064a"\ + "\u0643\u0627\u0646\u0648\u0646 \u0627\u0644\u0623\u0648\u0644"\ + ""] + ::msgcat::mcset ar_SY MONTHS_FULL [list \ + "\u0643\u0627\u0646\u0648\u0646 \u0627\u0644\u062b\u0627\u0646\u064a"\ + "\u0634\u0628\u0627\u0637"\ + "\u0622\u0630\u0627\u0631"\ + "\u0646\u064a\u0633\u0627\u0646"\ + "\u0646\u0648\u0627\u0631\u0627\u0646"\ + "\u062d\u0632\u064a\u0631"\ + "\u062a\u0645\u0648\u0632"\ + "\u0622\u0628"\ + "\u0623\u064a\u0644\u0648\u0644"\ + "\u062a\u0634\u0631\u064a\u0646 \u0627\u0644\u0623\u0648\u0644"\ + "\u062a\u0634\u0631\u064a\u0646 \u0627\u0644\u062b\u0627\u0646\u064a"\ + "\u0643\u0627\u0646\u0648\u0646 \u0627\u0644\u0623\u0648\u0644"\ + ""] +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/be.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/be.msg new file mode 100644 index 0000000000000000000000000000000000000000..379a1d7e6cdfdd824a8a14214f89f0a3308b7e81 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/be.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset be DAYS_OF_WEEK_ABBREV [list \ + "\u043d\u0434"\ + "\u043f\u043d"\ + "\u0430\u0442"\ + "\u0441\u0440"\ + "\u0447\u0446"\ + "\u043f\u0442"\ + "\u0441\u0431"] + ::msgcat::mcset be DAYS_OF_WEEK_FULL [list \ + "\u043d\u044f\u0434\u0437\u0435\u043b\u044f"\ + "\u043f\u0430\u043d\u044f\u0434\u0437\u0435\u043b\u0430\u043a"\ + "\u0430\u045e\u0442\u043e\u0440\u0430\u043a"\ + "\u0441\u0435\u0440\u0430\u0434\u0430"\ + "\u0447\u0430\u0446\u0432\u0435\u0440"\ + "\u043f\u044f\u0442\u043d\u0456\u0446\u0430"\ + "\u0441\u0443\u0431\u043e\u0442\u0430"] + ::msgcat::mcset be MONTHS_ABBREV [list \ + "\u0441\u0442\u0434"\ + "\u043b\u044e\u0442"\ + "\u0441\u043a\u0432"\ + "\u043a\u0440\u0441"\ + "\u043c\u0430\u0439"\ + "\u0447\u0440\u0432"\ + "\u043b\u043f\u043d"\ + "\u0436\u043d\u0432"\ + "\u0432\u0440\u0441"\ + "\u043a\u0441\u0442"\ + "\u043b\u0441\u0442"\ + "\u0441\u043d\u0436"\ + ""] + ::msgcat::mcset be MONTHS_FULL [list \ + "\u0441\u0442\u0443\u0434\u0437\u0435\u043d\u044f"\ + "\u043b\u044e\u0442\u0430\u0433\u0430"\ + "\u0441\u0430\u043a\u0430\u0432\u0456\u043a\u0430"\ + "\u043a\u0440\u0430\u0441\u0430\u0432\u0456\u043a\u0430"\ + "\u043c\u0430\u044f"\ + "\u0447\u0440\u0432\u0435\u043d\u044f"\ + "\u043b\u0456\u043f\u0435\u043d\u044f"\ + "\u0436\u043d\u0456\u045e\u043d\u044f"\ + "\u0432\u0435\u0440\u0430\u0441\u043d\u044f"\ + "\u043a\u0430\u0441\u0442\u0440\u044b\u0447\u043d\u0456\u043a\u0430"\ + "\u043b\u0438\u0441\u0442\u0430\u043f\u0430\u0434\u0430"\ + "\u0441\u043d\u0435\u0436\u043d\u044f"\ + ""] + ::msgcat::mcset be BCE "\u0434\u0430 \u043d.\u0435." + ::msgcat::mcset be CE "\u043d.\u0435." + ::msgcat::mcset be DATE_FORMAT "%e.%m.%Y" + ::msgcat::mcset be TIME_FORMAT "%k.%M.%S" + ::msgcat::mcset be DATE_TIME_FORMAT "%e.%m.%Y %k.%M.%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/bg.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/bg.msg new file mode 100644 index 0000000000000000000000000000000000000000..ff177590779190f4567ed65be78b51c3e0b8287b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/bg.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset bg DAYS_OF_WEEK_ABBREV [list \ + "\u041d\u0434"\ + "\u041f\u043d"\ + "\u0412\u0442"\ + "\u0421\u0440"\ + "\u0427\u0442"\ + "\u041f\u0442"\ + "\u0421\u0431"] + ::msgcat::mcset bg DAYS_OF_WEEK_FULL [list \ + "\u041d\u0435\u0434\u0435\u043b\u044f"\ + "\u041f\u043e\u043d\u0435\u0434\u0435\u043b\u043d\u0438\u043a"\ + "\u0412\u0442\u043e\u0440\u043d\u0438\u043a"\ + "\u0421\u0440\u044f\u0434\u0430"\ + "\u0427\u0435\u0442\u0432\u044a\u0440\u0442\u044a\u043a"\ + "\u041f\u0435\u0442\u044a\u043a"\ + "\u0421\u044a\u0431\u043e\u0442\u0430"] + ::msgcat::mcset bg MONTHS_ABBREV [list \ + "I"\ + "II"\ + "III"\ + "IV"\ + "V"\ + "VI"\ + "VII"\ + "VIII"\ + "IX"\ + "X"\ + "XI"\ + "XII"\ + ""] + ::msgcat::mcset bg MONTHS_FULL [list \ + "\u042f\u043d\u0443\u0430\u0440\u0438"\ + "\u0424\u0435\u0432\u0440\u0443\u0430\u0440\u0438"\ + "\u041c\u0430\u0440\u0442"\ + "\u0410\u043f\u0440\u0438\u043b"\ + "\u041c\u0430\u0439"\ + "\u042e\u043d\u0438"\ + "\u042e\u043b\u0438"\ + "\u0410\u0432\u0433\u0443\u0441\u0442"\ + "\u0421\u0435\u043f\u0442\u0435\u043c\u0432\u0440\u0438"\ + "\u041e\u043a\u0442\u043e\u043c\u0432\u0440\u0438"\ + "\u041d\u043e\u0435\u043c\u0432\u0440\u0438"\ + "\u0414\u0435\u043a\u0435\u043c\u0432\u0440\u0438"\ + ""] + ::msgcat::mcset bg BCE "\u043f\u0440.\u043d.\u0435." + ::msgcat::mcset bg CE "\u043d.\u0435." + ::msgcat::mcset bg DATE_FORMAT "%Y-%m-%e" + ::msgcat::mcset bg TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset bg DATE_TIME_FORMAT "%Y-%m-%e %k:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/bn.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/bn.msg new file mode 100644 index 0000000000000000000000000000000000000000..664b9d84c05532ad24be7e3ade9f5e6a53a691ea --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/bn.msg @@ -0,0 +1,49 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset bn DAYS_OF_WEEK_ABBREV [list \ + "\u09b0\u09ac\u09bf"\ + "\u09b8\u09cb\u09ae"\ + "\u09ae\u0999\u0997\u09b2"\ + "\u09ac\u09c1\u09a7"\ + "\u09ac\u09c3\u09b9\u09b8\u09cd\u09aa\u09a4\u09bf"\ + "\u09b6\u09c1\u0995\u09cd\u09b0"\ + "\u09b6\u09a8\u09bf"] + ::msgcat::mcset bn DAYS_OF_WEEK_FULL [list \ + "\u09b0\u09ac\u09bf\u09ac\u09be\u09b0"\ + "\u09b8\u09cb\u09ae\u09ac\u09be\u09b0"\ + "\u09ae\u0999\u0997\u09b2\u09ac\u09be\u09b0"\ + "\u09ac\u09c1\u09a7\u09ac\u09be\u09b0"\ + "\u09ac\u09c3\u09b9\u09b8\u09cd\u09aa\u09a4\u09bf\u09ac\u09be\u09b0"\ + "\u09b6\u09c1\u0995\u09cd\u09b0\u09ac\u09be\u09b0"\ + "\u09b6\u09a8\u09bf\u09ac\u09be\u09b0"] + ::msgcat::mcset bn MONTHS_ABBREV [list \ + "\u099c\u09be\u09a8\u09c1\u09df\u09be\u09b0\u09c0"\ + "\u09ab\u09c7\u09ac\u09cd\u09b0\u09c1\u09df\u09be\u09b0\u09c0"\ + "\u09ae\u09be\u09b0\u09cd\u099a"\ + "\u098f\u09aa\u09cd\u09b0\u09bf\u09b2"\ + "\u09ae\u09c7"\ + "\u099c\u09c1\u09a8"\ + "\u099c\u09c1\u09b2\u09be\u0987"\ + "\u0986\u0997\u09b8\u09cd\u099f"\ + "\u09b8\u09c7\u09aa\u09cd\u099f\u09c7\u09ae\u09cd\u09ac\u09b0"\ + "\u0985\u0995\u09cd\u099f\u09cb\u09ac\u09b0"\ + "\u09a8\u09ad\u09c7\u09ae\u09cd\u09ac\u09b0"\ + "\u09a1\u09bf\u09b8\u09c7\u09ae\u09cd\u09ac\u09b0"\ + ""] + ::msgcat::mcset bn MONTHS_FULL [list \ + "\u099c\u09be\u09a8\u09c1\u09df\u09be\u09b0\u09c0"\ + "\u09ab\u09c7\u09ac\u09cd\u09b0\u09c1\u09df\u09be\u09b0\u09c0"\ + "\u09ae\u09be\u09b0\u09cd\u099a"\ + "\u098f\u09aa\u09cd\u09b0\u09bf\u09b2"\ + "\u09ae\u09c7"\ + "\u099c\u09c1\u09a8"\ + "\u099c\u09c1\u09b2\u09be\u0987"\ + "\u0986\u0997\u09b8\u09cd\u099f"\ + "\u09b8\u09c7\u09aa\u09cd\u099f\u09c7\u09ae\u09cd\u09ac\u09b0"\ + "\u0985\u0995\u09cd\u099f\u09cb\u09ac\u09b0"\ + "\u09a8\u09ad\u09c7\u09ae\u09cd\u09ac\u09b0"\ + "\u09a1\u09bf\u09b8\u09c7\u09ae\u09cd\u09ac\u09b0"\ + ""] + ::msgcat::mcset bn AM "\u09aa\u09c2\u09b0\u09cd\u09ac\u09be\u09b9\u09cd\u09a3" + ::msgcat::mcset bn PM "\u0985\u09aa\u09b0\u09be\u09b9\u09cd\u09a3" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/bn_in.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/bn_in.msg new file mode 100644 index 0000000000000000000000000000000000000000..28c000f23595f3da231fefbb1d3b08030abe1e66 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/bn_in.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset bn_IN DATE_FORMAT "%A %d %b %Y" + ::msgcat::mcset bn_IN TIME_FORMAT_12 "%I:%M:%S %z" + ::msgcat::mcset bn_IN DATE_TIME_FORMAT "%A %d %b %Y %I:%M:%S %z %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ca.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ca.msg new file mode 100644 index 0000000000000000000000000000000000000000..36c977257b7cb2119718216288728067a1749747 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ca.msg @@ -0,0 +1,50 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ca DAYS_OF_WEEK_ABBREV [list \ + "dg."\ + "dl."\ + "dt."\ + "dc."\ + "dj."\ + "dv."\ + "ds."] + ::msgcat::mcset ca DAYS_OF_WEEK_FULL [list \ + "diumenge"\ + "dilluns"\ + "dimarts"\ + "dimecres"\ + "dijous"\ + "divendres"\ + "dissabte"] + ::msgcat::mcset ca MONTHS_ABBREV [list \ + "gen."\ + "feb."\ + "mar\u00e7"\ + "abr."\ + "maig"\ + "juny"\ + "jul."\ + "ag."\ + "set."\ + "oct."\ + "nov."\ + "des."\ + ""] + ::msgcat::mcset ca MONTHS_FULL [list \ + "gener"\ + "febrer"\ + "mar\u00e7"\ + "abril"\ + "maig"\ + "juny"\ + "juliol"\ + "agost"\ + "setembre"\ + "octubre"\ + "novembre"\ + "desembre"\ + ""] + ::msgcat::mcset ca DATE_FORMAT "%d/%m/%Y" + ::msgcat::mcset ca TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset ca DATE_TIME_FORMAT "%d/%m/%Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/cs.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/cs.msg new file mode 100644 index 0000000000000000000000000000000000000000..8db8bdd86f6079a48a5f7f15ac9e6923d2a76532 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/cs.msg @@ -0,0 +1,54 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset cs DAYS_OF_WEEK_ABBREV [list \ + "Ne"\ + "Po"\ + "\u00dat"\ + "St"\ + "\u010ct"\ + "P\u00e1"\ + "So"] + ::msgcat::mcset cs DAYS_OF_WEEK_FULL [list \ + "Ned\u011ble"\ + "Pond\u011bl\u00ed"\ + "\u00dater\u00fd"\ + "St\u0159eda"\ + "\u010ctvrtek"\ + "P\u00e1tek"\ + "Sobota"] + ::msgcat::mcset cs MONTHS_ABBREV [list \ + "I"\ + "II"\ + "III"\ + "IV"\ + "V"\ + "VI"\ + "VII"\ + "VIII"\ + "IX"\ + "X"\ + "XI"\ + "XII"\ + ""] + ::msgcat::mcset cs MONTHS_FULL [list \ + "leden"\ + "\u00fanor"\ + "b\u0159ezen"\ + "duben"\ + "kv\u011bten"\ + "\u010derven"\ + "\u010dervenec"\ + "srpen"\ + "z\u00e1\u0159\u00ed"\ + "\u0159\u00edjen"\ + "listopad"\ + "prosinec"\ + ""] + ::msgcat::mcset cs BCE "p\u0159.Kr." + ::msgcat::mcset cs CE "po Kr." + ::msgcat::mcset cs AM "dop." + ::msgcat::mcset cs PM "odp." + ::msgcat::mcset cs DATE_FORMAT "%e.%m.%Y" + ::msgcat::mcset cs TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset cs DATE_TIME_FORMAT "%e.%m.%Y %k:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/da.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/da.msg new file mode 100644 index 0000000000000000000000000000000000000000..e4fec7f027b11ffd9078e169fb4cd22416a6879f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/da.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset da DAYS_OF_WEEK_ABBREV [list \ + "s\u00f8"\ + "ma"\ + "ti"\ + "on"\ + "to"\ + "fr"\ + "l\u00f8"] + ::msgcat::mcset da DAYS_OF_WEEK_FULL [list \ + "s\u00f8ndag"\ + "mandag"\ + "tirsdag"\ + "onsdag"\ + "torsdag"\ + "fredag"\ + "l\u00f8rdag"] + ::msgcat::mcset da MONTHS_ABBREV [list \ + "jan"\ + "feb"\ + "mar"\ + "apr"\ + "maj"\ + "jun"\ + "jul"\ + "aug"\ + "sep"\ + "okt"\ + "nov"\ + "dec"\ + ""] + ::msgcat::mcset da MONTHS_FULL [list \ + "januar"\ + "februar"\ + "marts"\ + "april"\ + "maj"\ + "juni"\ + "juli"\ + "august"\ + "september"\ + "oktober"\ + "november"\ + "december"\ + ""] + ::msgcat::mcset da BCE "f.Kr." + ::msgcat::mcset da CE "e.Kr." + ::msgcat::mcset da DATE_FORMAT "%d-%m-%Y" + ::msgcat::mcset da TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset da DATE_TIME_FORMAT "%d-%m-%Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/de.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/de.msg new file mode 100644 index 0000000000000000000000000000000000000000..9eb31454b5ce32f90f68e6518378c008a662f5f1 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/de.msg @@ -0,0 +1,54 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset de DAYS_OF_WEEK_ABBREV [list \ + "So"\ + "Mo"\ + "Di"\ + "Mi"\ + "Do"\ + "Fr"\ + "Sa"] + ::msgcat::mcset de DAYS_OF_WEEK_FULL [list \ + "Sonntag"\ + "Montag"\ + "Dienstag"\ + "Mittwoch"\ + "Donnerstag"\ + "Freitag"\ + "Samstag"] + ::msgcat::mcset de MONTHS_ABBREV [list \ + "Jan"\ + "Feb"\ + "Mrz"\ + "Apr"\ + "Mai"\ + "Jun"\ + "Jul"\ + "Aug"\ + "Sep"\ + "Okt"\ + "Nov"\ + "Dez"\ + ""] + ::msgcat::mcset de MONTHS_FULL [list \ + "Januar"\ + "Februar"\ + "M\u00e4rz"\ + "April"\ + "Mai"\ + "Juni"\ + "Juli"\ + "August"\ + "September"\ + "Oktober"\ + "November"\ + "Dezember"\ + ""] + ::msgcat::mcset de BCE "v. Chr." + ::msgcat::mcset de CE "n. Chr." + ::msgcat::mcset de AM "vorm." + ::msgcat::mcset de PM "nachm." + ::msgcat::mcset de DATE_FORMAT "%d.%m.%Y" + ::msgcat::mcset de TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset de DATE_TIME_FORMAT "%d.%m.%Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/de_at.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/de_at.msg new file mode 100644 index 0000000000000000000000000000000000000000..61bc266698ca72e52c9ec6ad118ccd52ddb548c2 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/de_at.msg @@ -0,0 +1,35 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset de_AT MONTHS_ABBREV [list \ + "J\u00e4n"\ + "Feb"\ + "M\u00e4r"\ + "Apr"\ + "Mai"\ + "Jun"\ + "Jul"\ + "Aug"\ + "Sep"\ + "Okt"\ + "Nov"\ + "Dez"\ + ""] + ::msgcat::mcset de_AT MONTHS_FULL [list \ + "J\u00e4nner"\ + "Februar"\ + "M\u00e4rz"\ + "April"\ + "Mai"\ + "Juni"\ + "Juli"\ + "August"\ + "September"\ + "Oktober"\ + "November"\ + "Dezember"\ + ""] + ::msgcat::mcset de_AT DATE_FORMAT "%Y-%m-%d" + ::msgcat::mcset de_AT TIME_FORMAT "%T" + ::msgcat::mcset de_AT TIME_FORMAT_12 "%T" + ::msgcat::mcset de_AT DATE_TIME_FORMAT "%a %d %b %Y %T %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/de_be.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/de_be.msg new file mode 100644 index 0000000000000000000000000000000000000000..3614763a3c35bf0e54c0dc47ed564f8c1b499ca1 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/de_be.msg @@ -0,0 +1,53 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset de_BE DAYS_OF_WEEK_ABBREV [list \ + "Son"\ + "Mon"\ + "Die"\ + "Mit"\ + "Don"\ + "Fre"\ + "Sam"] + ::msgcat::mcset de_BE DAYS_OF_WEEK_FULL [list \ + "Sonntag"\ + "Montag"\ + "Dienstag"\ + "Mittwoch"\ + "Donnerstag"\ + "Freitag"\ + "Samstag"] + ::msgcat::mcset de_BE MONTHS_ABBREV [list \ + "Jan"\ + "Feb"\ + "M\u00e4r"\ + "Apr"\ + "Mai"\ + "Jun"\ + "Jul"\ + "Aug"\ + "Sep"\ + "Okt"\ + "Nov"\ + "Dez"\ + ""] + ::msgcat::mcset de_BE MONTHS_FULL [list \ + "Januar"\ + "Februar"\ + "M\u00e4rz"\ + "April"\ + "Mai"\ + "Juni"\ + "Juli"\ + "August"\ + "September"\ + "Oktober"\ + "November"\ + "Dezember"\ + ""] + ::msgcat::mcset de_BE AM "vorm" + ::msgcat::mcset de_BE PM "nachm" + ::msgcat::mcset de_BE DATE_FORMAT "%Y-%m-%d" + ::msgcat::mcset de_BE TIME_FORMAT "%T" + ::msgcat::mcset de_BE TIME_FORMAT_12 "%T" + ::msgcat::mcset de_BE DATE_TIME_FORMAT "%a %d %b %Y %T %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/el.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/el.msg new file mode 100644 index 0000000000000000000000000000000000000000..ac19f62def15335167aa126a5bd6650c4bedd1ca --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/el.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset el DAYS_OF_WEEK_ABBREV [list \ + "\u039a\u03c5\u03c1"\ + "\u0394\u03b5\u03c5"\ + "\u03a4\u03c1\u03b9"\ + "\u03a4\u03b5\u03c4"\ + "\u03a0\u03b5\u03bc"\ + "\u03a0\u03b1\u03c1"\ + "\u03a3\u03b1\u03b2"] + ::msgcat::mcset el DAYS_OF_WEEK_FULL [list \ + "\u039a\u03c5\u03c1\u03b9\u03b1\u03ba\u03ae"\ + "\u0394\u03b5\u03c5\u03c4\u03ad\u03c1\u03b1"\ + "\u03a4\u03c1\u03af\u03c4\u03b7"\ + "\u03a4\u03b5\u03c4\u03ac\u03c1\u03c4\u03b7"\ + "\u03a0\u03ad\u03bc\u03c0\u03c4\u03b7"\ + "\u03a0\u03b1\u03c1\u03b1\u03c3\u03ba\u03b5\u03c5\u03ae"\ + "\u03a3\u03ac\u03b2\u03b2\u03b1\u03c4\u03bf"] + ::msgcat::mcset el MONTHS_ABBREV [list \ + "\u0399\u03b1\u03bd"\ + "\u03a6\u03b5\u03b2"\ + "\u039c\u03b1\u03c1"\ + "\u0391\u03c0\u03c1"\ + "\u039c\u03b1\u03ca"\ + "\u0399\u03bf\u03c5\u03bd"\ + "\u0399\u03bf\u03c5\u03bb"\ + "\u0391\u03c5\u03b3"\ + "\u03a3\u03b5\u03c0"\ + "\u039f\u03ba\u03c4"\ + "\u039d\u03bf\u03b5"\ + "\u0394\u03b5\u03ba"\ + ""] + ::msgcat::mcset el MONTHS_FULL [list \ + "\u0399\u03b1\u03bd\u03bf\u03c5\u03ac\u03c1\u03b9\u03bf\u03c2"\ + "\u03a6\u03b5\u03b2\u03c1\u03bf\u03c5\u03ac\u03c1\u03b9\u03bf\u03c2"\ + "\u039c\u03ac\u03c1\u03c4\u03b9\u03bf\u03c2"\ + "\u0391\u03c0\u03c1\u03af\u03bb\u03b9\u03bf\u03c2"\ + "\u039c\u03ac\u03ca\u03bf\u03c2"\ + "\u0399\u03bf\u03cd\u03bd\u03b9\u03bf\u03c2"\ + "\u0399\u03bf\u03cd\u03bb\u03b9\u03bf\u03c2"\ + "\u0391\u03cd\u03b3\u03bf\u03c5\u03c3\u03c4\u03bf\u03c2"\ + "\u03a3\u03b5\u03c0\u03c4\u03ad\u03bc\u03b2\u03c1\u03b9\u03bf\u03c2"\ + "\u039f\u03ba\u03c4\u03ce\u03b2\u03c1\u03b9\u03bf\u03c2"\ + "\u039d\u03bf\u03ad\u03bc\u03b2\u03c1\u03b9\u03bf\u03c2"\ + "\u0394\u03b5\u03ba\u03ad\u03bc\u03b2\u03c1\u03b9\u03bf\u03c2"\ + ""] + ::msgcat::mcset el AM "\u03c0\u03bc" + ::msgcat::mcset el PM "\u03bc\u03bc" + ::msgcat::mcset el DATE_FORMAT "%e/%m/%Y" + ::msgcat::mcset el TIME_FORMAT_12 "%l:%M:%S %P" + ::msgcat::mcset el DATE_TIME_FORMAT "%e/%m/%Y %l:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_au.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_au.msg new file mode 100644 index 0000000000000000000000000000000000000000..7f9870c924cf9590a720d790b1e14faceb66a56a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_au.msg @@ -0,0 +1,7 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset en_AU DATE_FORMAT "%e/%m/%Y" + ::msgcat::mcset en_AU TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset en_AU TIME_FORMAT_12 "%I:%M:%S %P %z" + ::msgcat::mcset en_AU DATE_TIME_FORMAT "%e/%m/%Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_be.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_be.msg new file mode 100644 index 0000000000000000000000000000000000000000..5072986dc0f6aef8dd680563f778ef1017252e97 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_be.msg @@ -0,0 +1,7 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset en_BE DATE_FORMAT "%d %b %Y" + ::msgcat::mcset en_BE TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset en_BE TIME_FORMAT_12 "%k h %M min %S s %z" + ::msgcat::mcset en_BE DATE_TIME_FORMAT "%d %b %Y %k:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_bw.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_bw.msg new file mode 100644 index 0000000000000000000000000000000000000000..8fd20c7e3a8dff031501a2ded266f7c20b5d344e --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_bw.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset en_BW DATE_FORMAT "%d %B %Y" + ::msgcat::mcset en_BW TIME_FORMAT_12 "%l:%M:%S %P" + ::msgcat::mcset en_BW DATE_TIME_FORMAT "%d %B %Y %l:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_ca.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_ca.msg new file mode 100644 index 0000000000000000000000000000000000000000..278efe717f6f06836741592396256337a0322fd7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_ca.msg @@ -0,0 +1,7 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset en_CA DATE_FORMAT "%d/%m/%y" + ::msgcat::mcset en_CA TIME_FORMAT "%r" + ::msgcat::mcset en_CA TIME_FORMAT_12 "%I:%M:%S %p" + ::msgcat::mcset en_CA DATE_TIME_FORMAT "%a %d %b %Y %r %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_gb.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_gb.msg new file mode 100644 index 0000000000000000000000000000000000000000..5c61c43c6e180d379e44e3a10d45b64b782e8bfc --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_gb.msg @@ -0,0 +1,7 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset en_GB DATE_FORMAT "%d/%m/%y" + ::msgcat::mcset en_GB TIME_FORMAT "%T" + ::msgcat::mcset en_GB TIME_FORMAT_12 "%T" + ::msgcat::mcset en_GB DATE_TIME_FORMAT "%a %d %b %Y %T %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_hk.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_hk.msg new file mode 100644 index 0000000000000000000000000000000000000000..8b33bc067ad99e738745ba9d9bf29e25d94205bd --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_hk.msg @@ -0,0 +1,8 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset en_HK AM "AM" + ::msgcat::mcset en_HK PM "PM" + ::msgcat::mcset en_HK DATE_FORMAT "%B %e, %Y" + ::msgcat::mcset en_HK TIME_FORMAT_12 "%l:%M:%S %P" + ::msgcat::mcset en_HK DATE_TIME_FORMAT "%B %e, %Y %l:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_ie.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_ie.msg new file mode 100644 index 0000000000000000000000000000000000000000..ba621cf2c819eafd3909e90afc0e7f240f9e4234 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_ie.msg @@ -0,0 +1,7 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset en_IE DATE_FORMAT "%d/%m/%y" + ::msgcat::mcset en_IE TIME_FORMAT "%T" + ::msgcat::mcset en_IE TIME_FORMAT_12 "%T" + ::msgcat::mcset en_IE DATE_TIME_FORMAT "%a %d %b %Y %T %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_in.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_in.msg new file mode 100644 index 0000000000000000000000000000000000000000..a1f155d2c58101bc3f4551e8c14cc7ab6931a62f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_in.msg @@ -0,0 +1,8 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset en_IN AM "AM" + ::msgcat::mcset en_IN PM "PM" + ::msgcat::mcset en_IN DATE_FORMAT "%d %B %Y" + ::msgcat::mcset en_IN TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset en_IN DATE_TIME_FORMAT "%d %B %Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_nz.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_nz.msg new file mode 100644 index 0000000000000000000000000000000000000000..b419017a91d9e3db7435c34a68bd54a224454bf9 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_nz.msg @@ -0,0 +1,7 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset en_NZ DATE_FORMAT "%e/%m/%Y" + ::msgcat::mcset en_NZ TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset en_NZ TIME_FORMAT_12 "%I:%M:%S %P %z" + ::msgcat::mcset en_NZ DATE_TIME_FORMAT "%e/%m/%Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_ph.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_ph.msg new file mode 100644 index 0000000000000000000000000000000000000000..682666d5a6354a89683b50f1b7d8be282b56fc3b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_ph.msg @@ -0,0 +1,8 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset en_PH AM "AM" + ::msgcat::mcset en_PH PM "PM" + ::msgcat::mcset en_PH DATE_FORMAT "%B %e, %Y" + ::msgcat::mcset en_PH TIME_FORMAT_12 "%l:%M:%S %P" + ::msgcat::mcset en_PH DATE_TIME_FORMAT "%B %e, %Y %l:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_sg.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_sg.msg new file mode 100644 index 0000000000000000000000000000000000000000..4dc5b1d379fc8183c2f544f87edecd2fff594011 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_sg.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset en_SG DATE_FORMAT "%d %b %Y" + ::msgcat::mcset en_SG TIME_FORMAT_12 "%P %I:%M:%S" + ::msgcat::mcset en_SG DATE_TIME_FORMAT "%d %b %Y %P %I:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_za.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_za.msg new file mode 100644 index 0000000000000000000000000000000000000000..fe43797fda976a1328445a338fe7deab323d647f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_za.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset en_ZA DATE_FORMAT "%Y/%m/%d" + ::msgcat::mcset en_ZA TIME_FORMAT_12 "%I:%M:%S" + ::msgcat::mcset en_ZA DATE_TIME_FORMAT "%Y/%m/%d %I:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_zw.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_zw.msg new file mode 100644 index 0000000000000000000000000000000000000000..2a5804fa7f13608b94b0725efc619435736552fc --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/en_zw.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset en_ZW DATE_FORMAT "%d %B %Y" + ::msgcat::mcset en_ZW TIME_FORMAT_12 "%l:%M:%S %P" + ::msgcat::mcset en_ZW DATE_TIME_FORMAT "%d %B %Y %l:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/eo.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/eo.msg new file mode 100644 index 0000000000000000000000000000000000000000..1d2a24fece6b010f0020fb9b814ac9ab1ae07445 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/eo.msg @@ -0,0 +1,54 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset eo DAYS_OF_WEEK_ABBREV [list \ + "di"\ + "lu"\ + "ma"\ + "me"\ + "\u0135a"\ + "ve"\ + "sa"] + ::msgcat::mcset eo DAYS_OF_WEEK_FULL [list \ + "diman\u0109o"\ + "lundo"\ + "mardo"\ + "merkredo"\ + "\u0135a\u016ddo"\ + "vendredo"\ + "sabato"] + ::msgcat::mcset eo MONTHS_ABBREV [list \ + "jan"\ + "feb"\ + "mar"\ + "apr"\ + "maj"\ + "jun"\ + "jul"\ + "a\u016dg"\ + "sep"\ + "okt"\ + "nov"\ + "dec"\ + ""] + ::msgcat::mcset eo MONTHS_FULL [list \ + "januaro"\ + "februaro"\ + "marto"\ + "aprilo"\ + "majo"\ + "junio"\ + "julio"\ + "a\u016dgusto"\ + "septembro"\ + "oktobro"\ + "novembro"\ + "decembro"\ + ""] + ::msgcat::mcset eo BCE "aK" + ::msgcat::mcset eo CE "pK" + ::msgcat::mcset eo AM "atm" + ::msgcat::mcset eo PM "ptm" + ::msgcat::mcset eo DATE_FORMAT "%Y-%b-%d" + ::msgcat::mcset eo TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset eo DATE_TIME_FORMAT "%Y-%b-%d %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es.msg new file mode 100644 index 0000000000000000000000000000000000000000..a24f0a1bb2aa78a8f35360b5e0d61192485a8657 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es DAYS_OF_WEEK_ABBREV [list \ + "dom"\ + "lun"\ + "mar"\ + "mi\u00e9"\ + "jue"\ + "vie"\ + "s\u00e1b"] + ::msgcat::mcset es DAYS_OF_WEEK_FULL [list \ + "domingo"\ + "lunes"\ + "martes"\ + "mi\u00e9rcoles"\ + "jueves"\ + "viernes"\ + "s\u00e1bado"] + ::msgcat::mcset es MONTHS_ABBREV [list \ + "ene"\ + "feb"\ + "mar"\ + "abr"\ + "may"\ + "jun"\ + "jul"\ + "ago"\ + "sep"\ + "oct"\ + "nov"\ + "dic"\ + ""] + ::msgcat::mcset es MONTHS_FULL [list \ + "enero"\ + "febrero"\ + "marzo"\ + "abril"\ + "mayo"\ + "junio"\ + "julio"\ + "agosto"\ + "septiembre"\ + "octubre"\ + "noviembre"\ + "diciembre"\ + ""] + ::msgcat::mcset es BCE "a.C." + ::msgcat::mcset es CE "d.C." + ::msgcat::mcset es DATE_FORMAT "%e de %B de %Y" + ::msgcat::mcset es TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset es DATE_TIME_FORMAT "%e de %B de %Y %k:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_ar.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_ar.msg new file mode 100644 index 0000000000000000000000000000000000000000..7d350274ec27838924cf024bd097361386ef4719 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_ar.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_AR DATE_FORMAT "%d/%m/%Y" + ::msgcat::mcset es_AR TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset es_AR DATE_TIME_FORMAT "%d/%m/%Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_bo.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_bo.msg new file mode 100644 index 0000000000000000000000000000000000000000..498ad0d14f2ea7a9d9708803d35559ad937a0dac --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_bo.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_BO DATE_FORMAT "%d-%m-%Y" + ::msgcat::mcset es_BO TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_BO DATE_TIME_FORMAT "%d-%m-%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_cl.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_cl.msg new file mode 100644 index 0000000000000000000000000000000000000000..31d465c99720177b13a1aac133856ac2f8fd1cf4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_cl.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_CL DATE_FORMAT "%d-%m-%Y" + ::msgcat::mcset es_CL TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_CL DATE_TIME_FORMAT "%d-%m-%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_co.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_co.msg new file mode 100644 index 0000000000000000000000000000000000000000..77e57f0be7bee914212540dff7d44ab77cb5f937 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_co.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_CO DATE_FORMAT "%e/%m/%Y" + ::msgcat::mcset es_CO TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_CO DATE_TIME_FORMAT "%e/%m/%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_cr.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_cr.msg new file mode 100644 index 0000000000000000000000000000000000000000..7a652fa41532077db2525999d8ec16d3b858896a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_cr.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_CR DATE_FORMAT "%d/%m/%Y" + ::msgcat::mcset es_CR TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_CR DATE_TIME_FORMAT "%d/%m/%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_do.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_do.msg new file mode 100644 index 0000000000000000000000000000000000000000..0e283da84744a0fac4250b580bf325c42ceba0d8 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_do.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_DO DATE_FORMAT "%m/%d/%Y" + ::msgcat::mcset es_DO TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_DO DATE_TIME_FORMAT "%m/%d/%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_ec.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_ec.msg new file mode 100644 index 0000000000000000000000000000000000000000..9e921e02eef6c3656be7be6f3f0c6b1d130065f3 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_ec.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_EC DATE_FORMAT "%d/%m/%Y" + ::msgcat::mcset es_EC TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_EC DATE_TIME_FORMAT "%d/%m/%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_gt.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_gt.msg new file mode 100644 index 0000000000000000000000000000000000000000..ecd6faf9191c9eb348e8e620a8b264c32e1a25d8 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_gt.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_GT DATE_FORMAT "%e/%m/%Y" + ::msgcat::mcset es_GT TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_GT DATE_TIME_FORMAT "%e/%m/%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_hn.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_hn.msg new file mode 100644 index 0000000000000000000000000000000000000000..a758ca2b6118c92384333f7beb6513939672e81e --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_hn.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_HN DATE_FORMAT "%m-%d-%Y" + ::msgcat::mcset es_HN TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_HN DATE_TIME_FORMAT "%m-%d-%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_mx.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_mx.msg new file mode 100644 index 0000000000000000000000000000000000000000..7cfb545b2510013caf703a7914c827112aed49c5 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_mx.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_MX DATE_FORMAT "%e/%m/%Y" + ::msgcat::mcset es_MX TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_MX DATE_TIME_FORMAT "%e/%m/%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_ni.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_ni.msg new file mode 100644 index 0000000000000000000000000000000000000000..7c394953a3d069ae78355c632ae28a25fbf111d2 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_ni.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_NI DATE_FORMAT "%m-%d-%Y" + ::msgcat::mcset es_NI TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_NI DATE_TIME_FORMAT "%m-%d-%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_pa.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_pa.msg new file mode 100644 index 0000000000000000000000000000000000000000..cecacdce095cd64cb5f7c131da19ee303e9cdb9d --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_pa.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_PA DATE_FORMAT "%m/%d/%Y" + ::msgcat::mcset es_PA TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_PA DATE_TIME_FORMAT "%m/%d/%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_pe.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_pe.msg new file mode 100644 index 0000000000000000000000000000000000000000..9f90595fce588d0b1e55fd7bf44cf4ebc90c2549 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_pe.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_PE DATE_FORMAT "%d/%m/%Y" + ::msgcat::mcset es_PE TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_PE DATE_TIME_FORMAT "%d/%m/%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_pr.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_pr.msg new file mode 100644 index 0000000000000000000000000000000000000000..8511b126ed0be24c044315366f7c75b87aa70f36 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_pr.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_PR DATE_FORMAT "%m-%d-%Y" + ::msgcat::mcset es_PR TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_PR DATE_TIME_FORMAT "%m-%d-%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_py.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_py.msg new file mode 100644 index 0000000000000000000000000000000000000000..aa93d36b013409b4d3f570c82d48bd255ea4a977 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_py.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_PY DATE_FORMAT "%d/%m/%Y" + ::msgcat::mcset es_PY TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_PY DATE_TIME_FORMAT "%d/%m/%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_sv.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_sv.msg new file mode 100644 index 0000000000000000000000000000000000000000..fc7954d6a5df82779ca4d64d4b881666e1f2bfba --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_sv.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_SV DATE_FORMAT "%m-%d-%Y" + ::msgcat::mcset es_SV TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_SV DATE_TIME_FORMAT "%m-%d-%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_uy.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_uy.msg new file mode 100644 index 0000000000000000000000000000000000000000..b33525c0bd768c67ffe986839c45f3cc92a092a9 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_uy.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_UY DATE_FORMAT "%d/%m/%Y" + ::msgcat::mcset es_UY TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_UY DATE_TIME_FORMAT "%d/%m/%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_ve.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_ve.msg new file mode 100644 index 0000000000000000000000000000000000000000..7c2a7b0a55e0cb0207159a2bc6852d76f21ae8eb --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/es_ve.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset es_VE DATE_FORMAT "%d/%m/%Y" + ::msgcat::mcset es_VE TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset es_VE DATE_TIME_FORMAT "%d/%m/%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/et.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/et.msg new file mode 100644 index 0000000000000000000000000000000000000000..8d32e9e5ecfbd24e0b60376433c492c6fef31a1d --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/et.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset et DAYS_OF_WEEK_ABBREV [list \ + "P"\ + "E"\ + "T"\ + "K"\ + "N"\ + "R"\ + "L"] + ::msgcat::mcset et DAYS_OF_WEEK_FULL [list \ + "p\u00fchap\u00e4ev"\ + "esmasp\u00e4ev"\ + "teisip\u00e4ev"\ + "kolmap\u00e4ev"\ + "neljap\u00e4ev"\ + "reede"\ + "laup\u00e4ev"] + ::msgcat::mcset et MONTHS_ABBREV [list \ + "Jaan"\ + "Veebr"\ + "M\u00e4rts"\ + "Apr"\ + "Mai"\ + "Juuni"\ + "Juuli"\ + "Aug"\ + "Sept"\ + "Okt"\ + "Nov"\ + "Dets"\ + ""] + ::msgcat::mcset et MONTHS_FULL [list \ + "Jaanuar"\ + "Veebruar"\ + "M\u00e4rts"\ + "Aprill"\ + "Mai"\ + "Juuni"\ + "Juuli"\ + "August"\ + "September"\ + "Oktoober"\ + "November"\ + "Detsember"\ + ""] + ::msgcat::mcset et BCE "e.m.a." + ::msgcat::mcset et CE "m.a.j." + ::msgcat::mcset et DATE_FORMAT "%e-%m-%Y" + ::msgcat::mcset et TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset et DATE_TIME_FORMAT "%e-%m-%Y %k:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/eu.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/eu.msg new file mode 100644 index 0000000000000000000000000000000000000000..cf708b6b20cf2b6b8d2f716afa5b62f9c62ceeba --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/eu.msg @@ -0,0 +1,47 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset eu DAYS_OF_WEEK_ABBREV [list \ + "igandea"\ + "astelehena"\ + "asteartea"\ + "asteazkena"\ + "osteguna"\ + "ostirala"\ + "larunbata"] + ::msgcat::mcset eu DAYS_OF_WEEK_FULL [list \ + "igandea"\ + "astelehena"\ + "asteartea"\ + "asteazkena"\ + "osteguna"\ + "ostirala"\ + "larunbata"] + ::msgcat::mcset eu MONTHS_ABBREV [list \ + "urt"\ + "ots"\ + "mar"\ + "api"\ + "mai"\ + "eka"\ + "uzt"\ + "abu"\ + "ira"\ + "urr"\ + "aza"\ + "abe"\ + ""] + ::msgcat::mcset eu MONTHS_FULL [list \ + "urtarrila"\ + "otsaila"\ + "martxoa"\ + "apirila"\ + "maiatza"\ + "ekaina"\ + "uztaila"\ + "abuztua"\ + "iraila"\ + "urria"\ + "azaroa"\ + "abendua"\ + ""] +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/eu_es.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/eu_es.msg new file mode 100644 index 0000000000000000000000000000000000000000..2694418d3cb2acc40d6b3b38f70ae98f26d948c2 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/eu_es.msg @@ -0,0 +1,7 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset eu_ES DATE_FORMAT "%a, %Yeko %bren %da" + ::msgcat::mcset eu_ES TIME_FORMAT "%T" + ::msgcat::mcset eu_ES TIME_FORMAT_12 "%T" + ::msgcat::mcset eu_ES DATE_TIME_FORMAT "%y-%m-%d %T %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fa.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fa.msg new file mode 100644 index 0000000000000000000000000000000000000000..89b2f90894a4336f0f5cc15365b08e3a07539a20 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fa.msg @@ -0,0 +1,47 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset fa DAYS_OF_WEEK_ABBREV [list \ + "\u06cc\u2214"\ + "\u062f\u2214"\ + "\u0633\u2214"\ + "\u0686\u2214"\ + "\u067e\u2214"\ + "\u062c\u2214"\ + "\u0634\u2214"] + ::msgcat::mcset fa DAYS_OF_WEEK_FULL [list \ + "\u06cc\u06cc\u200c\u0634\u0646\u0628\u0647"\ + "\u062f\u0648\u0634\u0646\u0628\u0647"\ + "\u0633\u0647\u200c\u0634\u0646\u0628\u0647"\ + "\u0686\u0647\u0627\u0631\u0634\u0646\u0628\u0647"\ + "\u067e\u0646\u062c\u200c\u0634\u0646\u0628\u0647"\ + "\u062c\u0645\u0639\u0647"\ + "\u0634\u0646\u0628\u0647"] + ::msgcat::mcset fa MONTHS_ABBREV [list \ + "\u0698\u0627\u0646"\ + "\u0641\u0648\u0631"\ + "\u0645\u0627\u0631"\ + "\u0622\u0648\u0631"\ + "\u0645\u0640\u0647"\ + "\u0698\u0648\u0646"\ + "\u0698\u0648\u06cc"\ + "\u0627\u0648\u062a"\ + "\u0633\u067e\u062a"\ + "\u0627\u0643\u062a"\ + "\u0646\u0648\u0627"\ + "\u062f\u0633\u0627"\ + ""] + ::msgcat::mcset fa MONTHS_FULL [list \ + "\u0698\u0627\u0646\u0648\u06cc\u0647"\ + "\u0641\u0648\u0631\u0648\u06cc\u0647"\ + "\u0645\u0627\u0631\u0633"\ + "\u0622\u0648\u0631\u06cc\u0644"\ + "\u0645\u0647"\ + "\u0698\u0648\u0626\u0646"\ + "\u0698\u0648\u0626\u06cc\u0647"\ + "\u0627\u0648\u062a"\ + "\u0633\u067e\u062a\u0627\u0645\u0628\u0631"\ + "\u0627\u0643\u062a\u0628\u0631"\ + "\u0646\u0648\u0627\u0645\u0628\u0631"\ + "\u062f\u0633\u0627\u0645\u0628\u0631"\ + ""] +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fa_in.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fa_in.msg new file mode 100644 index 0000000000000000000000000000000000000000..adc9e91d370bb85b0141bedf05e35e98b43f9ad6 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fa_in.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset fa_IN DAYS_OF_WEEK_ABBREV [list \ + "\u06cc\u2214"\ + "\u062f\u2214"\ + "\u0633\u2214"\ + "\u0686\u2214"\ + "\u067e\u2214"\ + "\u062c\u2214"\ + "\u0634\u2214"] + ::msgcat::mcset fa_IN DAYS_OF_WEEK_FULL [list \ + "\u06cc\u06cc\u200c\u0634\u0646\u0628\u0647"\ + "\u062f\u0648\u0634\u0646\u0628\u0647"\ + "\u0633\u0647\u200c\u0634\u0646\u0628\u0647"\ + "\u0686\u0647\u0627\u0631\u0634\u0646\u0628\u0647"\ + "\u067e\u0646\u062c\u200c\u0634\u0646\u0628\u0647"\ + "\u062c\u0645\u0639\u0647"\ + "\u0634\u0646\u0628\u0647"] + ::msgcat::mcset fa_IN MONTHS_ABBREV [list \ + "\u0698\u0627\u0646"\ + "\u0641\u0648\u0631"\ + "\u0645\u0627\u0631"\ + "\u0622\u0648\u0631"\ + "\u0645\u0640\u0647"\ + "\u0698\u0648\u0646"\ + "\u0698\u0648\u06cc"\ + "\u0627\u0648\u062a"\ + "\u0633\u067e\u062a"\ + "\u0627\u0643\u062a"\ + "\u0646\u0648\u0627"\ + "\u062f\u0633\u0627"\ + ""] + ::msgcat::mcset fa_IN MONTHS_FULL [list \ + "\u0698\u0627\u0646\u0648\u06cc\u0647"\ + "\u0641\u0648\u0631\u0648\u06cc\u0647"\ + "\u0645\u0627\u0631\u0633"\ + "\u0622\u0648\u0631\u06cc\u0644"\ + "\u0645\u0647"\ + "\u0698\u0648\u0626\u0646"\ + "\u0698\u0648\u0626\u06cc\u0647"\ + "\u0627\u0648\u062a"\ + "\u0633\u067e\u062a\u0627\u0645\u0628\u0631"\ + "\u0627\u0643\u062a\u0628\u0631"\ + "\u0646\u0648\u0627\u0645\u0628\u0631"\ + "\u062f\u0633\u0627\u0645\u0628\u0631"\ + ""] + ::msgcat::mcset fa_IN AM "\u0635\u0628\u062d" + ::msgcat::mcset fa_IN PM "\u0639\u0635\u0631" + ::msgcat::mcset fa_IN DATE_FORMAT "%A %d %B %Y" + ::msgcat::mcset fa_IN TIME_FORMAT_12 "%I:%M:%S %z" + ::msgcat::mcset fa_IN DATE_TIME_FORMAT "%A %d %B %Y %I:%M:%S %z %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fa_ir.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fa_ir.msg new file mode 100644 index 0000000000000000000000000000000000000000..597ce9d72caa68c7c195ab4ac8709a82f8f8192f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fa_ir.msg @@ -0,0 +1,9 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset fa_IR AM "\u0635\u0628\u062d" + ::msgcat::mcset fa_IR PM "\u0639\u0635\u0631" + ::msgcat::mcset fa_IR DATE_FORMAT "%d\u2044%m\u2044%Y" + ::msgcat::mcset fa_IR TIME_FORMAT "%S:%M:%H" + ::msgcat::mcset fa_IR TIME_FORMAT_12 "%S:%M:%l %P" + ::msgcat::mcset fa_IR DATE_TIME_FORMAT "%d\u2044%m\u2044%Y %S:%M:%H %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fi.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fi.msg new file mode 100644 index 0000000000000000000000000000000000000000..acabba09b433ea886930c37b229b6264a2d81add --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fi.msg @@ -0,0 +1,50 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset fi DAYS_OF_WEEK_ABBREV [list \ + "su"\ + "ma"\ + "ti"\ + "ke"\ + "to"\ + "pe"\ + "la"] + ::msgcat::mcset fi DAYS_OF_WEEK_FULL [list \ + "sunnuntai"\ + "maanantai"\ + "tiistai"\ + "keskiviikko"\ + "torstai"\ + "perjantai"\ + "lauantai"] + ::msgcat::mcset fi MONTHS_ABBREV [list \ + "tammi"\ + "helmi"\ + "maalis"\ + "huhti"\ + "touko"\ + "kes\u00e4"\ + "hein\u00e4"\ + "elo"\ + "syys"\ + "loka"\ + "marras"\ + "joulu"\ + ""] + ::msgcat::mcset fi MONTHS_FULL [list \ + "tammikuu"\ + "helmikuu"\ + "maaliskuu"\ + "huhtikuu"\ + "toukokuu"\ + "kes\u00e4kuu"\ + "hein\u00e4kuu"\ + "elokuu"\ + "syyskuu"\ + "lokakuu"\ + "marraskuu"\ + "joulukuu"\ + ""] + ::msgcat::mcset fi DATE_FORMAT "%e.%m.%Y" + ::msgcat::mcset fi TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset fi DATE_TIME_FORMAT "%e.%m.%Y %k:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fo.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fo.msg new file mode 100644 index 0000000000000000000000000000000000000000..4696e6289ab332d32690d2c5d5d5bafff094ae1a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fo.msg @@ -0,0 +1,47 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset fo DAYS_OF_WEEK_ABBREV [list \ + "sun"\ + "m\u00e1n"\ + "t\u00fds"\ + "mik"\ + "h\u00f3s"\ + "fr\u00ed"\ + "ley"] + ::msgcat::mcset fo DAYS_OF_WEEK_FULL [list \ + "sunnudagur"\ + "m\u00e1nadagur"\ + "t\u00fdsdagur"\ + "mikudagur"\ + "h\u00f3sdagur"\ + "fr\u00edggjadagur"\ + "leygardagur"] + ::msgcat::mcset fo MONTHS_ABBREV [list \ + "jan"\ + "feb"\ + "mar"\ + "apr"\ + "mai"\ + "jun"\ + "jul"\ + "aug"\ + "sep"\ + "okt"\ + "nov"\ + "des"\ + ""] + ::msgcat::mcset fo MONTHS_FULL [list \ + "januar"\ + "februar"\ + "mars"\ + "apr\u00edl"\ + "mai"\ + "juni"\ + "juli"\ + "august"\ + "september"\ + "oktober"\ + "november"\ + "desember"\ + ""] +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fo_fo.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fo_fo.msg new file mode 100644 index 0000000000000000000000000000000000000000..2392b8e6734d6f811cadb5c4ed6aa62147829309 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fo_fo.msg @@ -0,0 +1,7 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset fo_FO DATE_FORMAT "%d/%m-%Y" + ::msgcat::mcset fo_FO TIME_FORMAT "%T" + ::msgcat::mcset fo_FO TIME_FORMAT_12 "%T" + ::msgcat::mcset fo_FO DATE_TIME_FORMAT "%a %d %b %Y %T %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fr.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fr.msg new file mode 100644 index 0000000000000000000000000000000000000000..55b19bf949e4e0b07d28d69f23a5c44aad764062 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fr.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset fr DAYS_OF_WEEK_ABBREV [list \ + "dim."\ + "lun."\ + "mar."\ + "mer."\ + "jeu."\ + "ven."\ + "sam."] + ::msgcat::mcset fr DAYS_OF_WEEK_FULL [list \ + "dimanche"\ + "lundi"\ + "mardi"\ + "mercredi"\ + "jeudi"\ + "vendredi"\ + "samedi"] + ::msgcat::mcset fr MONTHS_ABBREV [list \ + "janv."\ + "f\u00e9vr."\ + "mars"\ + "avr."\ + "mai"\ + "juin"\ + "juil."\ + "ao\u00fbt"\ + "sept."\ + "oct."\ + "nov."\ + "d\u00e9c."\ + ""] + ::msgcat::mcset fr MONTHS_FULL [list \ + "janvier"\ + "f\u00e9vrier"\ + "mars"\ + "avril"\ + "mai"\ + "juin"\ + "juillet"\ + "ao\u00fbt"\ + "septembre"\ + "octobre"\ + "novembre"\ + "d\u00e9cembre"\ + ""] + ::msgcat::mcset fr BCE "av. J.-C." + ::msgcat::mcset fr CE "ap. J.-C." + ::msgcat::mcset fr DATE_FORMAT "%e %B %Y" + ::msgcat::mcset fr TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset fr DATE_TIME_FORMAT "%e %B %Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fr_be.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fr_be.msg new file mode 100644 index 0000000000000000000000000000000000000000..cdb13bd75f307b2498698ebaef0c572877dfe9eb --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fr_be.msg @@ -0,0 +1,7 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset fr_BE DATE_FORMAT "%d/%m/%y" + ::msgcat::mcset fr_BE TIME_FORMAT "%T" + ::msgcat::mcset fr_BE TIME_FORMAT_12 "%T" + ::msgcat::mcset fr_BE DATE_TIME_FORMAT "%a %d %b %Y %T %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fr_ca.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fr_ca.msg new file mode 100644 index 0000000000000000000000000000000000000000..00ccfffcb473d24d682104771f2c9e502285c8d4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fr_ca.msg @@ -0,0 +1,7 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset fr_CA DATE_FORMAT "%Y-%m-%d" + ::msgcat::mcset fr_CA TIME_FORMAT "%T" + ::msgcat::mcset fr_CA TIME_FORMAT_12 "%T" + ::msgcat::mcset fr_CA DATE_TIME_FORMAT "%a %d %b %Y %T %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fr_ch.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fr_ch.msg new file mode 100644 index 0000000000000000000000000000000000000000..7e2bac73d8023f0be9847d123901cbba0fe2ae53 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/fr_ch.msg @@ -0,0 +1,7 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset fr_CH DATE_FORMAT "%d. %m. %y" + ::msgcat::mcset fr_CH TIME_FORMAT "%T" + ::msgcat::mcset fr_CH TIME_FORMAT_12 "%T" + ::msgcat::mcset fr_CH DATE_TIME_FORMAT "%a %d %b %Y %T %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ga.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ga.msg new file mode 100644 index 0000000000000000000000000000000000000000..6edf13aab1c71a7ea1d1f0d4959cdda3ab923653 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ga.msg @@ -0,0 +1,47 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ga DAYS_OF_WEEK_ABBREV [list \ + "Domh"\ + "Luan"\ + "M\u00e1irt"\ + "C\u00e9ad"\ + "D\u00e9ar"\ + "Aoine"\ + "Sath"] + ::msgcat::mcset ga DAYS_OF_WEEK_FULL [list \ + "D\u00e9 Domhnaigh"\ + "D\u00e9 Luain"\ + "D\u00e9 M\u00e1irt"\ + "D\u00e9 C\u00e9adaoin"\ + "D\u00e9ardaoin"\ + "D\u00e9 hAoine"\ + "D\u00e9 Sathairn"] + ::msgcat::mcset ga MONTHS_ABBREV [list \ + "Ean"\ + "Feabh"\ + "M\u00e1rta"\ + "Aib"\ + "Beal"\ + "Meith"\ + "I\u00fail"\ + "L\u00fan"\ + "MF\u00f3mh"\ + "DF\u00f3mh"\ + "Samh"\ + "Noll"\ + ""] + ::msgcat::mcset ga MONTHS_FULL [list \ + "Ean\u00e1ir"\ + "Feabhra"\ + "M\u00e1rta"\ + "Aibre\u00e1n"\ + "M\u00ed na Bealtaine"\ + "Meith"\ + "I\u00fail"\ + "L\u00fanasa"\ + "Me\u00e1n F\u00f3mhair"\ + "Deireadh F\u00f3mhair"\ + "M\u00ed na Samhna"\ + "M\u00ed na Nollag"\ + ""] +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ga_ie.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ga_ie.msg new file mode 100644 index 0000000000000000000000000000000000000000..b6acbbc273ec0b7bb2c9dead694fba4d371fac6d --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ga_ie.msg @@ -0,0 +1,7 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ga_IE DATE_FORMAT "%d.%m.%y" + ::msgcat::mcset ga_IE TIME_FORMAT "%T" + ::msgcat::mcset ga_IE TIME_FORMAT_12 "%T" + ::msgcat::mcset ga_IE DATE_TIME_FORMAT "%a %d %b %Y %T %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/gl.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/gl.msg new file mode 100644 index 0000000000000000000000000000000000000000..4b869e8550665690bf621afdf659cd9d39e9cb2c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/gl.msg @@ -0,0 +1,47 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset gl DAYS_OF_WEEK_ABBREV [list \ + "Dom"\ + "Lun"\ + "Mar"\ + "M\u00e9r"\ + "Xov"\ + "Ven"\ + "S\u00e1b"] + ::msgcat::mcset gl DAYS_OF_WEEK_FULL [list \ + "Domingo"\ + "Luns"\ + "Martes"\ + "M\u00e9rcores"\ + "Xoves"\ + "Venres"\ + "S\u00e1bado"] + ::msgcat::mcset gl MONTHS_ABBREV [list \ + "Xan"\ + "Feb"\ + "Mar"\ + "Abr"\ + "Mai"\ + "Xu\u00f1"\ + "Xul"\ + "Ago"\ + "Set"\ + "Out"\ + "Nov"\ + "Dec"\ + ""] + ::msgcat::mcset gl MONTHS_FULL [list \ + "Xaneiro"\ + "Febreiro"\ + "Marzo"\ + "Abril"\ + "Maio"\ + "Xu\u00f1o"\ + "Xullo"\ + "Agosto"\ + "Setembro"\ + "Outubro"\ + "Novembro"\ + "Decembro"\ + ""] +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/gl_es.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/gl_es.msg new file mode 100644 index 0000000000000000000000000000000000000000..d4ed2704b374b7f7a621482b9ebb8cd2c2d52b2d --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/gl_es.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset gl_ES DATE_FORMAT "%d %B %Y" + ::msgcat::mcset gl_ES TIME_FORMAT_12 "%l:%M:%S %P" + ::msgcat::mcset gl_ES DATE_TIME_FORMAT "%d %B %Y %l:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/gv.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/gv.msg new file mode 100644 index 0000000000000000000000000000000000000000..7d332ad5c40b14dadf4ed342662787c283c7a772 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/gv.msg @@ -0,0 +1,47 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset gv DAYS_OF_WEEK_ABBREV [list \ + "Jed"\ + "Jel"\ + "Jem"\ + "Jerc"\ + "Jerd"\ + "Jeh"\ + "Jes"] + ::msgcat::mcset gv DAYS_OF_WEEK_FULL [list \ + "Jedoonee"\ + "Jelhein"\ + "Jemayrt"\ + "Jercean"\ + "Jerdein"\ + "Jeheiney"\ + "Jesarn"] + ::msgcat::mcset gv MONTHS_ABBREV [list \ + "J-guer"\ + "T-arree"\ + "Mayrnt"\ + "Avrril"\ + "Boaldyn"\ + "M-souree"\ + "J-souree"\ + "Luanistyn"\ + "M-fouyir"\ + "J-fouyir"\ + "M.Houney"\ + "M.Nollick"\ + ""] + ::msgcat::mcset gv MONTHS_FULL [list \ + "Jerrey-geuree"\ + "Toshiaght-arree"\ + "Mayrnt"\ + "Averil"\ + "Boaldyn"\ + "Mean-souree"\ + "Jerrey-souree"\ + "Luanistyn"\ + "Mean-fouyir"\ + "Jerrey-fouyir"\ + "Mee Houney"\ + "Mee ny Nollick"\ + ""] +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/gv_gb.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/gv_gb.msg new file mode 100644 index 0000000000000000000000000000000000000000..5e96e6f3cd699726995bf54773b5c938f2215912 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/gv_gb.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset gv_GB DATE_FORMAT "%d %B %Y" + ::msgcat::mcset gv_GB TIME_FORMAT_12 "%l:%M:%S %P" + ::msgcat::mcset gv_GB DATE_TIME_FORMAT "%d %B %Y %l:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/he.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/he.msg new file mode 100644 index 0000000000000000000000000000000000000000..4fd921d695580d913869978074a8bc5f1e6b5b71 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/he.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset he DAYS_OF_WEEK_ABBREV [list \ + "\u05d0"\ + "\u05d1"\ + "\u05d2"\ + "\u05d3"\ + "\u05d4"\ + "\u05d5"\ + "\u05e9"] + ::msgcat::mcset he DAYS_OF_WEEK_FULL [list \ + "\u05d9\u05d5\u05dd \u05e8\u05d0\u05e9\u05d5\u05df"\ + "\u05d9\u05d5\u05dd \u05e9\u05e0\u05d9"\ + "\u05d9\u05d5\u05dd \u05e9\u05dc\u05d9\u05e9\u05d9"\ + "\u05d9\u05d5\u05dd \u05e8\u05d1\u05d9\u05e2\u05d9"\ + "\u05d9\u05d5\u05dd \u05d7\u05de\u05d9\u05e9\u05d9"\ + "\u05d9\u05d5\u05dd \u05e9\u05d9\u05e9\u05d9"\ + "\u05e9\u05d1\u05ea"] + ::msgcat::mcset he MONTHS_ABBREV [list \ + "\u05d9\u05e0\u05d5"\ + "\u05e4\u05d1\u05e8"\ + "\u05de\u05e8\u05e5"\ + "\u05d0\u05e4\u05e8"\ + "\u05de\u05d0\u05d9"\ + "\u05d9\u05d5\u05e0"\ + "\u05d9\u05d5\u05dc"\ + "\u05d0\u05d5\u05d2"\ + "\u05e1\u05e4\u05d8"\ + "\u05d0\u05d5\u05e7"\ + "\u05e0\u05d5\u05d1"\ + "\u05d3\u05e6\u05de"\ + ""] + ::msgcat::mcset he MONTHS_FULL [list \ + "\u05d9\u05e0\u05d5\u05d0\u05e8"\ + "\u05e4\u05d1\u05e8\u05d5\u05d0\u05e8"\ + "\u05de\u05e8\u05e5"\ + "\u05d0\u05e4\u05e8\u05d9\u05dc"\ + "\u05de\u05d0\u05d9"\ + "\u05d9\u05d5\u05e0\u05d9"\ + "\u05d9\u05d5\u05dc\u05d9"\ + "\u05d0\u05d5\u05d2\u05d5\u05e1\u05d8"\ + "\u05e1\u05e4\u05d8\u05de\u05d1\u05e8"\ + "\u05d0\u05d5\u05e7\u05d8\u05d5\u05d1\u05e8"\ + "\u05e0\u05d5\u05d1\u05de\u05d1\u05e8"\ + "\u05d3\u05e6\u05de\u05d1\u05e8"\ + ""] + ::msgcat::mcset he BCE "\u05dc\u05e1\u05d4\u0022\u05e0" + ::msgcat::mcset he CE "\u05dc\u05e4\u05e1\u05d4\u0022\u05e0" + ::msgcat::mcset he DATE_FORMAT "%d/%m/%Y" + ::msgcat::mcset he TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset he DATE_TIME_FORMAT "%d/%m/%Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/hi.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/hi.msg new file mode 100644 index 0000000000000000000000000000000000000000..50c9fb8093dd47839afcc1321751c56171a060d3 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/hi.msg @@ -0,0 +1,39 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset hi DAYS_OF_WEEK_FULL [list \ + "\u0930\u0935\u093f\u0935\u093e\u0930"\ + "\u0938\u094b\u092e\u0935\u093e\u0930"\ + "\u092e\u0902\u0917\u0932\u0935\u093e\u0930"\ + "\u092c\u0941\u0927\u0935\u093e\u0930"\ + "\u0917\u0941\u0930\u0941\u0935\u093e\u0930"\ + "\u0936\u0941\u0915\u094d\u0930\u0935\u093e\u0930"\ + "\u0936\u0928\u093f\u0935\u093e\u0930"] + ::msgcat::mcset hi MONTHS_ABBREV [list \ + "\u091c\u0928\u0935\u0930\u0940"\ + "\u092b\u093c\u0930\u0935\u0930\u0940"\ + "\u092e\u093e\u0930\u094d\u091a"\ + "\u0905\u092a\u094d\u0930\u0947\u0932"\ + "\u092e\u0908"\ + "\u091c\u0942\u0928"\ + "\u091c\u0941\u0932\u093e\u0908"\ + "\u0905\u0917\u0938\u094d\u0924"\ + "\u0938\u093f\u0924\u092e\u094d\u092c\u0930"\ + "\u0905\u0915\u094d\u091f\u0942\u092c\u0930"\ + "\u0928\u0935\u092e\u094d\u092c\u0930"\ + "\u0926\u093f\u0938\u092e\u094d\u092c\u0930"] + ::msgcat::mcset hi MONTHS_FULL [list \ + "\u091c\u0928\u0935\u0930\u0940"\ + "\u092b\u093c\u0930\u0935\u0930\u0940"\ + "\u092e\u093e\u0930\u094d\u091a"\ + "\u0905\u092a\u094d\u0930\u0947\u0932"\ + "\u092e\u0908"\ + "\u091c\u0942\u0928"\ + "\u091c\u0941\u0932\u093e\u0908"\ + "\u0905\u0917\u0938\u094d\u0924"\ + "\u0938\u093f\u0924\u092e\u094d\u092c\u0930"\ + "\u0905\u0915\u094d\u091f\u0942\u092c\u0930"\ + "\u0928\u0935\u092e\u094d\u092c\u0930"\ + "\u0926\u093f\u0938\u092e\u094d\u092c\u0930"] + ::msgcat::mcset hi AM "\u0908\u0938\u093e\u092a\u0942\u0930\u094d\u0935" + ::msgcat::mcset hi PM "." +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/hi_in.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/hi_in.msg new file mode 100644 index 0000000000000000000000000000000000000000..239793f1ec666a677cbc68741a4c132f6025c95d --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/hi_in.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset hi_IN DATE_FORMAT "%d %M %Y" + ::msgcat::mcset hi_IN TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset hi_IN DATE_TIME_FORMAT "%d %M %Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/hr.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/hr.msg new file mode 100644 index 0000000000000000000000000000000000000000..cec145b083039f22c68ec0120ce1dfc092d920b0 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/hr.msg @@ -0,0 +1,50 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset hr DAYS_OF_WEEK_ABBREV [list \ + "ned"\ + "pon"\ + "uto"\ + "sri"\ + "\u010det"\ + "pet"\ + "sub"] + ::msgcat::mcset hr DAYS_OF_WEEK_FULL [list \ + "nedjelja"\ + "ponedjeljak"\ + "utorak"\ + "srijeda"\ + "\u010detvrtak"\ + "petak"\ + "subota"] + ::msgcat::mcset hr MONTHS_ABBREV [list \ + "sij"\ + "vel"\ + "o\u017eu"\ + "tra"\ + "svi"\ + "lip"\ + "srp"\ + "kol"\ + "ruj"\ + "lis"\ + "stu"\ + "pro"\ + ""] + ::msgcat::mcset hr MONTHS_FULL [list \ + "sije\u010danj"\ + "velja\u010da"\ + "o\u017eujak"\ + "travanj"\ + "svibanj"\ + "lipanj"\ + "srpanj"\ + "kolovoz"\ + "rujan"\ + "listopad"\ + "studeni"\ + "prosinac"\ + ""] + ::msgcat::mcset hr DATE_FORMAT "%Y.%m.%d" + ::msgcat::mcset hr TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset hr DATE_TIME_FORMAT "%Y.%m.%d %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/hu.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/hu.msg new file mode 100644 index 0000000000000000000000000000000000000000..e5e68d925876c5840eab2616674ef5df913078e2 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/hu.msg @@ -0,0 +1,54 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset hu DAYS_OF_WEEK_ABBREV [list \ + "V"\ + "H"\ + "K"\ + "Sze"\ + "Cs"\ + "P"\ + "Szo"] + ::msgcat::mcset hu DAYS_OF_WEEK_FULL [list \ + "vas\u00e1rnap"\ + "h\u00e9tf\u0151"\ + "kedd"\ + "szerda"\ + "cs\u00fct\u00f6rt\u00f6k"\ + "p\u00e9ntek"\ + "szombat"] + ::msgcat::mcset hu MONTHS_ABBREV [list \ + "jan."\ + "febr."\ + "m\u00e1rc."\ + "\u00e1pr."\ + "m\u00e1j."\ + "j\u00fan."\ + "j\u00fal."\ + "aug."\ + "szept."\ + "okt."\ + "nov."\ + "dec."\ + ""] + ::msgcat::mcset hu MONTHS_FULL [list \ + "janu\u00e1r"\ + "febru\u00e1r"\ + "m\u00e1rcius"\ + "\u00e1prilis"\ + "m\u00e1jus"\ + "j\u00fanius"\ + "j\u00falius"\ + "augusztus"\ + "szeptember"\ + "okt\u00f3ber"\ + "november"\ + "december"\ + ""] + ::msgcat::mcset hu BCE "i.e." + ::msgcat::mcset hu CE "i.u." + ::msgcat::mcset hu AM "DE" + ::msgcat::mcset hu PM "DU" + ::msgcat::mcset hu DATE_FORMAT "%Y.%m.%d." + ::msgcat::mcset hu TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset hu DATE_TIME_FORMAT "%Y.%m.%d. %k:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/id.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/id.msg new file mode 100644 index 0000000000000000000000000000000000000000..17c6bb59d47c7e4b2bcf123ce653c54eb558c6a3 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/id.msg @@ -0,0 +1,47 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset id DAYS_OF_WEEK_ABBREV [list \ + "Min"\ + "Sen"\ + "Sel"\ + "Rab"\ + "Kam"\ + "Jum"\ + "Sab"] + ::msgcat::mcset id DAYS_OF_WEEK_FULL [list \ + "Minggu"\ + "Senin"\ + "Selasa"\ + "Rabu"\ + "Kamis"\ + "Jumat"\ + "Sabtu"] + ::msgcat::mcset id MONTHS_ABBREV [list \ + "Jan"\ + "Peb"\ + "Mar"\ + "Apr"\ + "Mei"\ + "Jun"\ + "Jul"\ + "Agu"\ + "Sep"\ + "Okt"\ + "Nov"\ + "Des"\ + ""] + ::msgcat::mcset id MONTHS_FULL [list \ + "Januari"\ + "Pebruari"\ + "Maret"\ + "April"\ + "Mei"\ + "Juni"\ + "Juli"\ + "Agustus"\ + "September"\ + "Oktober"\ + "November"\ + "Desember"\ + ""] +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/id_id.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/id_id.msg new file mode 100644 index 0000000000000000000000000000000000000000..bb672c11eea46eae59bf84a31c2e47a8a7e00b12 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/id_id.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset id_ID DATE_FORMAT "%d %B %Y" + ::msgcat::mcset id_ID TIME_FORMAT_12 "%l:%M:%S %P" + ::msgcat::mcset id_ID DATE_TIME_FORMAT "%d %B %Y %l:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/is.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/is.msg new file mode 100644 index 0000000000000000000000000000000000000000..adc2d2a374ff6838172253f1d57e7f6875f4e905 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/is.msg @@ -0,0 +1,50 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset is DAYS_OF_WEEK_ABBREV [list \ + "sun."\ + "m\u00e1n."\ + "\u00feri."\ + "mi\u00f0."\ + "fim."\ + "f\u00f6s."\ + "lau."] + ::msgcat::mcset is DAYS_OF_WEEK_FULL [list \ + "sunnudagur"\ + "m\u00e1nudagur"\ + "\u00feri\u00f0judagur"\ + "mi\u00f0vikudagur"\ + "fimmtudagur"\ + "f\u00f6studagur"\ + "laugardagur"] + ::msgcat::mcset is MONTHS_ABBREV [list \ + "jan."\ + "feb."\ + "mar."\ + "apr."\ + "ma\u00ed"\ + "j\u00fan."\ + "j\u00fal."\ + "\u00e1g\u00fa."\ + "sep."\ + "okt."\ + "n\u00f3v."\ + "des."\ + ""] + ::msgcat::mcset is MONTHS_FULL [list \ + "jan\u00faar"\ + "febr\u00faar"\ + "mars"\ + "apr\u00edl"\ + "ma\u00ed"\ + "j\u00fan\u00ed"\ + "j\u00fal\u00ed"\ + "\u00e1g\u00fast"\ + "september"\ + "okt\u00f3ber"\ + "n\u00f3vember"\ + "desember"\ + ""] + ::msgcat::mcset is DATE_FORMAT "%e.%m.%Y" + ::msgcat::mcset is TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset is DATE_TIME_FORMAT "%e.%m.%Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/it.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/it.msg new file mode 100644 index 0000000000000000000000000000000000000000..b641cdec7b3a9958e33ab03960cb88a78a3df4c9 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/it.msg @@ -0,0 +1,54 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset it DAYS_OF_WEEK_ABBREV [list \ + "dom"\ + "lun"\ + "mar"\ + "mer"\ + "gio"\ + "ven"\ + "sab"] + ::msgcat::mcset it DAYS_OF_WEEK_FULL [list \ + "domenica"\ + "luned\u00ec"\ + "marted\u00ec"\ + "mercoled\u00ec"\ + "gioved\u00ec"\ + "venerd\u00ec"\ + "sabato"] + ::msgcat::mcset it MONTHS_ABBREV [list \ + "gen"\ + "feb"\ + "mar"\ + "apr"\ + "mag"\ + "giu"\ + "lug"\ + "ago"\ + "set"\ + "ott"\ + "nov"\ + "dic"\ + ""] + ::msgcat::mcset it MONTHS_FULL [list \ + "gennaio"\ + "febbraio"\ + "marzo"\ + "aprile"\ + "maggio"\ + "giugno"\ + "luglio"\ + "agosto"\ + "settembre"\ + "ottobre"\ + "novembre"\ + "dicembre"\ + ""] + ::msgcat::mcset it BCE "aC" + ::msgcat::mcset it CE "dC" + ::msgcat::mcset it AM "m." + ::msgcat::mcset it PM "p." + ::msgcat::mcset it DATE_FORMAT "%d %B %Y" + ::msgcat::mcset it TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset it DATE_TIME_FORMAT "%d %B %Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/it_ch.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/it_ch.msg new file mode 100644 index 0000000000000000000000000000000000000000..b36ed36873ded884391fdad351fbe941521b668b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/it_ch.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset it_CH DATE_FORMAT "%e. %B %Y" + ::msgcat::mcset it_CH TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset it_CH DATE_TIME_FORMAT "%e. %B %Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ja.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ja.msg new file mode 100644 index 0000000000000000000000000000000000000000..cf70c2f326043e83efc1792226331764d271be6f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ja.msg @@ -0,0 +1,44 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ja DAYS_OF_WEEK_ABBREV [list \ + "\u65e5"\ + "\u6708"\ + "\u706b"\ + "\u6c34"\ + "\u6728"\ + "\u91d1"\ + "\u571f"] + ::msgcat::mcset ja DAYS_OF_WEEK_FULL [list \ + "\u65e5\u66dc\u65e5"\ + "\u6708\u66dc\u65e5"\ + "\u706b\u66dc\u65e5"\ + "\u6c34\u66dc\u65e5"\ + "\u6728\u66dc\u65e5"\ + "\u91d1\u66dc\u65e5"\ + "\u571f\u66dc\u65e5"] + ::msgcat::mcset ja MONTHS_FULL [list \ + "1\u6708"\ + "2\u6708"\ + "3\u6708"\ + "4\u6708"\ + "5\u6708"\ + "6\u6708"\ + "7\u6708"\ + "8\u6708"\ + "9\u6708"\ + "10\u6708"\ + "11\u6708"\ + "12\u6708"] + ::msgcat::mcset ja BCE "\u7d00\u5143\u524d" + ::msgcat::mcset ja CE "\u897f\u66a6" + ::msgcat::mcset ja AM "\u5348\u524d" + ::msgcat::mcset ja PM "\u5348\u5f8c" + ::msgcat::mcset ja DATE_FORMAT "%Y/%m/%d" + ::msgcat::mcset ja TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset ja TIME_FORMAT_12 "%P %I:%M:%S" + ::msgcat::mcset ja DATE_TIME_FORMAT "%Y/%m/%d %k:%M:%S %z" + ::msgcat::mcset ja LOCALE_DATE_FORMAT "%EY\u5e74%m\u6708%d\u65e5" + ::msgcat::mcset ja LOCALE_TIME_FORMAT "%H\u6642%M\u5206%S\u79d2" + ::msgcat::mcset ja LOCALE_DATE_TIME_FORMAT "%EY\u5e74%m\u6708%d\u65e5 (%a) %H\u6642%M\u5206%S\u79d2 %z" + ::msgcat::mcset ja LOCALE_ERAS "{-9223372036854775808 \u897f\u66a6 0} {-3061011600 \u660e\u6cbb 1867} {-1812186000 \u5927\u6b63 1911} {-1357635600 \u662d\u548c 1925} {600220800 \u5e73\u6210 1988} {1556668800 \u4ee4\u548c 2018}" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kl.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kl.msg new file mode 100644 index 0000000000000000000000000000000000000000..d877bfe6af30d0d4b3dcb51d7b65bade8b5999eb --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kl.msg @@ -0,0 +1,47 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset kl DAYS_OF_WEEK_ABBREV [list \ + "sab"\ + "ata"\ + "mar"\ + "pin"\ + "sis"\ + "tal"\ + "arf"] + ::msgcat::mcset kl DAYS_OF_WEEK_FULL [list \ + "sabaat"\ + "ataasinngorneq"\ + "marlunngorneq"\ + "pingasunngorneq"\ + "sisamanngorneq"\ + "tallimanngorneq"\ + "arfininngorneq"] + ::msgcat::mcset kl MONTHS_ABBREV [list \ + "jan"\ + "feb"\ + "mar"\ + "apr"\ + "maj"\ + "jun"\ + "jul"\ + "aug"\ + "sep"\ + "okt"\ + "nov"\ + "dec"\ + ""] + ::msgcat::mcset kl MONTHS_FULL [list \ + "januari"\ + "februari"\ + "martsi"\ + "aprili"\ + "maji"\ + "juni"\ + "juli"\ + "augustusi"\ + "septemberi"\ + "oktoberi"\ + "novemberi"\ + "decemberi"\ + ""] +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kl_gl.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kl_gl.msg new file mode 100644 index 0000000000000000000000000000000000000000..403aa10f94b0a9441d8ee9606f95c2a44863fe5b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kl_gl.msg @@ -0,0 +1,7 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset kl_GL DATE_FORMAT "%d %b %Y" + ::msgcat::mcset kl_GL TIME_FORMAT "%T" + ::msgcat::mcset kl_GL TIME_FORMAT_12 "%T" + ::msgcat::mcset kl_GL DATE_TIME_FORMAT "%a %d %b %Y %T %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ko.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ko.msg new file mode 100644 index 0000000000000000000000000000000000000000..0cd17a19f328236312146380c7af76156d61fd3f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ko.msg @@ -0,0 +1,55 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ko DAYS_OF_WEEK_ABBREV [list \ + "\uc77c"\ + "\uc6d4"\ + "\ud654"\ + "\uc218"\ + "\ubaa9"\ + "\uae08"\ + "\ud1a0"] + ::msgcat::mcset ko DAYS_OF_WEEK_FULL [list \ + "\uc77c\uc694\uc77c"\ + "\uc6d4\uc694\uc77c"\ + "\ud654\uc694\uc77c"\ + "\uc218\uc694\uc77c"\ + "\ubaa9\uc694\uc77c"\ + "\uae08\uc694\uc77c"\ + "\ud1a0\uc694\uc77c"] + ::msgcat::mcset ko MONTHS_ABBREV [list \ + "1\uc6d4"\ + "2\uc6d4"\ + "3\uc6d4"\ + "4\uc6d4"\ + "5\uc6d4"\ + "6\uc6d4"\ + "7\uc6d4"\ + "8\uc6d4"\ + "9\uc6d4"\ + "10\uc6d4"\ + "11\uc6d4"\ + "12\uc6d4"\ + ""] + ::msgcat::mcset ko MONTHS_FULL [list \ + "1\uc6d4"\ + "2\uc6d4"\ + "3\uc6d4"\ + "4\uc6d4"\ + "5\uc6d4"\ + "6\uc6d4"\ + "7\uc6d4"\ + "8\uc6d4"\ + "9\uc6d4"\ + "10\uc6d4"\ + "11\uc6d4"\ + "12\uc6d4"\ + ""] + ::msgcat::mcset ko AM "\uc624\uc804" + ::msgcat::mcset ko PM "\uc624\ud6c4" + ::msgcat::mcset ko DATE_FORMAT "%Y-%m-%d" + ::msgcat::mcset ko TIME_FORMAT_12 "%P %l:%M:%S" + ::msgcat::mcset ko DATE_TIME_FORMAT "%Y-%m-%d %P %l:%M:%S %z" + ::msgcat::mcset ko LOCALE_DATE_FORMAT "%Y\ub144%B%Od\uc77c" + ::msgcat::mcset ko LOCALE_TIME_FORMAT "%H\uc2dc%M\ubd84%S\ucd08" + ::msgcat::mcset ko LOCALE_DATE_TIME_FORMAT "%A %Y\ub144%B%Od\uc77c%H\uc2dc%M\ubd84%S\ucd08 %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ko_kr.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ko_kr.msg new file mode 100644 index 0000000000000000000000000000000000000000..ea5bbd724890093d3f2da781bc1dfdc0983d48ec --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ko_kr.msg @@ -0,0 +1,8 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ko_KR BCE "\uae30\uc6d0\uc804" + ::msgcat::mcset ko_KR CE "\uc11c\uae30" + ::msgcat::mcset ko_KR DATE_FORMAT "%Y.%m.%d" + ::msgcat::mcset ko_KR TIME_FORMAT_12 "%P %l:%M:%S" + ::msgcat::mcset ko_KR DATE_TIME_FORMAT "%Y.%m.%d %P %l:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kok.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kok.msg new file mode 100644 index 0000000000000000000000000000000000000000..0869f2078bf4f4c3d07247c7e3b48a5390985311 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kok.msg @@ -0,0 +1,39 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset kok DAYS_OF_WEEK_FULL [list \ + "\u0906\u0926\u093f\u0924\u094d\u092f\u0935\u093e\u0930"\ + "\u0938\u094b\u092e\u0935\u093e\u0930"\ + "\u092e\u0902\u0917\u0933\u093e\u0930"\ + "\u092c\u0941\u0927\u0935\u093e\u0930"\ + "\u0917\u0941\u0930\u0941\u0935\u093e\u0930"\ + "\u0936\u0941\u0915\u094d\u0930\u0935\u093e\u0930"\ + "\u0936\u0928\u093f\u0935\u093e\u0930"] + ::msgcat::mcset kok MONTHS_ABBREV [list \ + "\u091c\u093e\u0928\u0947\u0935\u093e\u0930\u0940"\ + "\u092b\u0947\u092c\u0943\u0935\u093e\u0930\u0940"\ + "\u092e\u093e\u0930\u094d\u091a"\ + "\u090f\u092a\u094d\u0930\u093f\u0932"\ + "\u092e\u0947"\ + "\u091c\u0942\u0928"\ + "\u091c\u0941\u0932\u0948"\ + "\u0913\u0917\u0938\u094d\u091f"\ + "\u0938\u0947\u092a\u094d\u091f\u0947\u0902\u092c\u0930"\ + "\u0913\u0915\u094d\u091f\u094b\u092c\u0930"\ + "\u0928\u094b\u0935\u094d\u0939\u0947\u0902\u092c\u0930"\ + "\u0921\u093f\u0938\u0947\u0902\u092c\u0930"] + ::msgcat::mcset kok MONTHS_FULL [list \ + "\u091c\u093e\u0928\u0947\u0935\u093e\u0930\u0940"\ + "\u092b\u0947\u092c\u094d\u0930\u0941\u0935\u093e\u0930\u0940"\ + "\u092e\u093e\u0930\u094d\u091a"\ + "\u090f\u092a\u094d\u0930\u093f\u0932"\ + "\u092e\u0947"\ + "\u091c\u0942\u0928"\ + "\u091c\u0941\u0932\u0948"\ + "\u0913\u0917\u0938\u094d\u091f"\ + "\u0938\u0947\u092a\u094d\u091f\u0947\u0902\u092c\u0930"\ + "\u0913\u0915\u094d\u091f\u094b\u092c\u0930"\ + "\u0928\u094b\u0935\u094d\u0939\u0947\u0902\u092c\u0930"\ + "\u0921\u093f\u0938\u0947\u0902\u092c\u0930"] + ::msgcat::mcset kok AM "\u0915\u094d\u0930\u093f\u0938\u094d\u0924\u092a\u0942\u0930\u094d\u0935" + ::msgcat::mcset kok PM "\u0915\u094d\u0930\u093f\u0938\u094d\u0924\u0936\u0916\u093e" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kok_in.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kok_in.msg new file mode 100644 index 0000000000000000000000000000000000000000..abcb1ff883699c995fc108baf1cb828f712b9032 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kok_in.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset kok_IN DATE_FORMAT "%d %M %Y" + ::msgcat::mcset kok_IN TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset kok_IN DATE_TIME_FORMAT "%d %M %Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kw.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kw.msg new file mode 100644 index 0000000000000000000000000000000000000000..aaf79b3242982053b90567cf4f974e1866051f37 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kw.msg @@ -0,0 +1,47 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset kw DAYS_OF_WEEK_ABBREV [list \ + "Sul"\ + "Lun"\ + "Mth"\ + "Mhr"\ + "Yow"\ + "Gwe"\ + "Sad"] + ::msgcat::mcset kw DAYS_OF_WEEK_FULL [list \ + "De Sul"\ + "De Lun"\ + "De Merth"\ + "De Merher"\ + "De Yow"\ + "De Gwener"\ + "De Sadorn"] + ::msgcat::mcset kw MONTHS_ABBREV [list \ + "Gen"\ + "Whe"\ + "Mer"\ + "Ebr"\ + "Me"\ + "Evn"\ + "Gor"\ + "Est"\ + "Gwn"\ + "Hed"\ + "Du"\ + "Kev"\ + ""] + ::msgcat::mcset kw MONTHS_FULL [list \ + "Mys Genver"\ + "Mys Whevrel"\ + "Mys Merth"\ + "Mys Ebrel"\ + "Mys Me"\ + "Mys Evan"\ + "Mys Gortheren"\ + "Mye Est"\ + "Mys Gwyngala"\ + "Mys Hedra"\ + "Mys Du"\ + "Mys Kevardhu"\ + ""] +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kw_gb.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kw_gb.msg new file mode 100644 index 0000000000000000000000000000000000000000..296768043ace0d2e12e69cbfae2bf65d6602ab5c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/kw_gb.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset kw_GB DATE_FORMAT "%d %B %Y" + ::msgcat::mcset kw_GB TIME_FORMAT_12 "%l:%M:%S %P" + ::msgcat::mcset kw_GB DATE_TIME_FORMAT "%d %B %Y %l:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/lt.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/lt.msg new file mode 100644 index 0000000000000000000000000000000000000000..27b09850bc1f900e1d3a88be05862acd77e8ef31 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/lt.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset lt DAYS_OF_WEEK_ABBREV [list \ + "Sk"\ + "Pr"\ + "An"\ + "Tr"\ + "Kt"\ + "Pn"\ + "\u0160t"] + ::msgcat::mcset lt DAYS_OF_WEEK_FULL [list \ + "Sekmadienis"\ + "Pirmadienis"\ + "Antradienis"\ + "Tre\u010diadienis"\ + "Ketvirtadienis"\ + "Penktadienis"\ + "\u0160e\u0161tadienis"] + ::msgcat::mcset lt MONTHS_ABBREV [list \ + "Sau"\ + "Vas"\ + "Kov"\ + "Bal"\ + "Geg"\ + "Bir"\ + "Lie"\ + "Rgp"\ + "Rgs"\ + "Spa"\ + "Lap"\ + "Grd"\ + ""] + ::msgcat::mcset lt MONTHS_FULL [list \ + "Sausio"\ + "Vasario"\ + "Kovo"\ + "Baland\u017eio"\ + "Gegu\u017e\u0117s"\ + "Bir\u017eelio"\ + "Liepos"\ + "Rugpj\u016b\u010dio"\ + "Rugs\u0117jo"\ + "Spalio"\ + "Lapkri\u010dio"\ + "Gruod\u017eio"\ + ""] + ::msgcat::mcset lt BCE "pr.Kr." + ::msgcat::mcset lt CE "po.Kr." + ::msgcat::mcset lt DATE_FORMAT "%Y.%m.%e" + ::msgcat::mcset lt TIME_FORMAT "%H.%M.%S" + ::msgcat::mcset lt DATE_TIME_FORMAT "%Y.%m.%e %H.%M.%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/lv.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/lv.msg new file mode 100644 index 0000000000000000000000000000000000000000..a037b151cc531d0fbb9f6ec82ca25ce067cc40ea --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/lv.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset lv DAYS_OF_WEEK_ABBREV [list \ + "Sv"\ + "P"\ + "O"\ + "T"\ + "C"\ + "Pk"\ + "S"] + ::msgcat::mcset lv DAYS_OF_WEEK_FULL [list \ + "sv\u0113tdiena"\ + "pirmdiena"\ + "otrdiena"\ + "tre\u0161diena"\ + "ceturdien"\ + "piektdiena"\ + "sestdiena"] + ::msgcat::mcset lv MONTHS_ABBREV [list \ + "Jan"\ + "Feb"\ + "Mar"\ + "Apr"\ + "Maijs"\ + "J\u016bn"\ + "J\u016bl"\ + "Aug"\ + "Sep"\ + "Okt"\ + "Nov"\ + "Dec"\ + ""] + ::msgcat::mcset lv MONTHS_FULL [list \ + "janv\u0101ris"\ + "febru\u0101ris"\ + "marts"\ + "apr\u012blis"\ + "maijs"\ + "j\u016bnijs"\ + "j\u016blijs"\ + "augusts"\ + "septembris"\ + "oktobris"\ + "novembris"\ + "decembris"\ + ""] + ::msgcat::mcset lv BCE "pm\u0113" + ::msgcat::mcset lv CE "m\u0113" + ::msgcat::mcset lv DATE_FORMAT "%Y.%e.%m" + ::msgcat::mcset lv TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset lv DATE_TIME_FORMAT "%Y.%e.%m %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/mk.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/mk.msg new file mode 100644 index 0000000000000000000000000000000000000000..41cf60db81d1f2240f64754bbef96d50634528a2 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/mk.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset mk DAYS_OF_WEEK_ABBREV [list \ + "\u043d\u0435\u0434."\ + "\u043f\u043e\u043d."\ + "\u0432\u0442."\ + "\u0441\u0440\u0435."\ + "\u0447\u0435\u0442."\ + "\u043f\u0435\u0442."\ + "\u0441\u0430\u0431."] + ::msgcat::mcset mk DAYS_OF_WEEK_FULL [list \ + "\u043d\u0435\u0434\u0435\u043b\u0430"\ + "\u043f\u043e\u043d\u0435\u0434\u0435\u043b\u043d\u0438\u043a"\ + "\u0432\u0442\u043e\u0440\u043d\u0438\u043a"\ + "\u0441\u0440\u0435\u0434\u0430"\ + "\u0447\u0435\u0442\u0432\u0440\u0442\u043e\u043a"\ + "\u043f\u0435\u0442\u043e\u043a"\ + "\u0441\u0430\u0431\u043e\u0442\u0430"] + ::msgcat::mcset mk MONTHS_ABBREV [list \ + "\u0458\u0430\u043d."\ + "\u0444\u0435\u0432."\ + "\u043c\u0430\u0440."\ + "\u0430\u043f\u0440."\ + "\u043c\u0430\u0458."\ + "\u0458\u0443\u043d."\ + "\u0458\u0443\u043b."\ + "\u0430\u0432\u0433."\ + "\u0441\u0435\u043f\u0442."\ + "\u043e\u043a\u0442."\ + "\u043d\u043e\u0435\u043c."\ + "\u0434\u0435\u043a\u0435\u043c."\ + ""] + ::msgcat::mcset mk MONTHS_FULL [list \ + "\u0458\u0430\u043d\u0443\u0430\u0440\u0438"\ + "\u0444\u0435\u0432\u0440\u0443\u0430\u0440\u0438"\ + "\u043c\u0430\u0440\u0442"\ + "\u0430\u043f\u0440\u0438\u043b"\ + "\u043c\u0430\u0458"\ + "\u0458\u0443\u043d\u0438"\ + "\u0458\u0443\u043b\u0438"\ + "\u0430\u0432\u0433\u0443\u0441\u0442"\ + "\u0441\u0435\u043f\u0442\u0435\u043c\u0432\u0440\u0438"\ + "\u043e\u043a\u0442\u043e\u043c\u0432\u0440\u0438"\ + "\u043d\u043e\u0435\u043c\u0432\u0440\u0438"\ + "\u0434\u0435\u043a\u0435\u043c\u0432\u0440\u0438"\ + ""] + ::msgcat::mcset mk BCE "\u043f\u0440.\u043d.\u0435." + ::msgcat::mcset mk CE "\u0430\u0435." + ::msgcat::mcset mk DATE_FORMAT "%e.%m.%Y" + ::msgcat::mcset mk TIME_FORMAT "%H:%M:%S %z" + ::msgcat::mcset mk DATE_TIME_FORMAT "%e.%m.%Y %H:%M:%S %z %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/mr.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/mr.msg new file mode 100644 index 0000000000000000000000000000000000000000..cea427a9065c619748b2807040a5314cc0915c1e --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/mr.msg @@ -0,0 +1,39 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset mr DAYS_OF_WEEK_FULL [list \ + "\u0930\u0935\u093f\u0935\u093e\u0930"\ + "\u0938\u094b\u092e\u0935\u093e\u0930"\ + "\u092e\u0902\u0917\u0933\u0935\u093e\u0930"\ + "\u092e\u0902\u0917\u0933\u0935\u093e\u0930"\ + "\u0917\u0941\u0930\u0941\u0935\u093e\u0930"\ + "\u0936\u0941\u0915\u094d\u0930\u0935\u093e\u0930"\ + "\u0936\u0928\u093f\u0935\u093e\u0930"] + ::msgcat::mcset mr MONTHS_ABBREV [list \ + "\u091c\u093e\u0928\u0947\u0935\u093e\u0930\u0940"\ + "\u092b\u0947\u092c\u0943\u0935\u093e\u0930\u0940"\ + "\u092e\u093e\u0930\u094d\u091a"\ + "\u090f\u092a\u094d\u0930\u093f\u0932"\ + "\u092e\u0947"\ + "\u091c\u0942\u0928"\ + "\u091c\u0941\u0932\u0948"\ + "\u0913\u0917\u0938\u094d\u091f"\ + "\u0938\u0947\u092a\u094d\u091f\u0947\u0902\u092c\u0930"\ + "\u0913\u0915\u094d\u091f\u094b\u092c\u0930"\ + "\u0928\u094b\u0935\u094d\u0939\u0947\u0902\u092c\u0930"\ + "\u0921\u093f\u0938\u0947\u0902\u092c\u0930"] + ::msgcat::mcset mr MONTHS_FULL [list \ + "\u091c\u093e\u0928\u0947\u0935\u093e\u0930\u0940"\ + "\u092b\u0947\u092c\u0943\u0935\u093e\u0930\u0940"\ + "\u092e\u093e\u0930\u094d\u091a"\ + "\u090f\u092a\u094d\u0930\u093f\u0932"\ + "\u092e\u0947"\ + "\u091c\u0942\u0928"\ + "\u091c\u0941\u0932\u0948"\ + "\u0913\u0917\u0938\u094d\u091f"\ + "\u0938\u0947\u092a\u094d\u091f\u0947\u0902\u092c\u0930"\ + "\u0913\u0915\u094d\u091f\u094b\u092c\u0930"\ + "\u0928\u094b\u0935\u094d\u0939\u0947\u0902\u092c\u0930"\ + "\u0921\u093f\u0938\u0947\u0902\u092c\u0930"] + ::msgcat::mcset mr AM "BC" + ::msgcat::mcset mr PM "AD" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/mr_in.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/mr_in.msg new file mode 100644 index 0000000000000000000000000000000000000000..1889da5c4525a8c1c5fe1be62bb5bd29746c5d5c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/mr_in.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset mr_IN DATE_FORMAT "%d %M %Y" + ::msgcat::mcset mr_IN TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset mr_IN DATE_TIME_FORMAT "%d %M %Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ms.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ms.msg new file mode 100644 index 0000000000000000000000000000000000000000..e954431b7b7bfc876c3a1c53d22d3843546dee2d --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ms.msg @@ -0,0 +1,47 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ms DAYS_OF_WEEK_ABBREV [list \ + "Aha"\ + "Isn"\ + "Sei"\ + "Rab"\ + "Kha"\ + "Jum"\ + "Sab"] + ::msgcat::mcset ms DAYS_OF_WEEK_FULL [list \ + "Ahad"\ + "Isnin"\ + "Selasa"\ + "Rahu"\ + "Khamis"\ + "Jumaat"\ + "Sabtu"] + ::msgcat::mcset ms MONTHS_ABBREV [list \ + "Jan"\ + "Feb"\ + "Mac"\ + "Apr"\ + "Mei"\ + "Jun"\ + "Jul"\ + "Ogos"\ + "Sep"\ + "Okt"\ + "Nov"\ + "Dis"\ + ""] + ::msgcat::mcset ms MONTHS_FULL [list \ + "Januari"\ + "Februari"\ + "Mac"\ + "April"\ + "Mei"\ + "Jun"\ + "Julai"\ + "Ogos"\ + "September"\ + "Oktober"\ + "November"\ + "Disember"\ + ""] +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ms_my.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ms_my.msg new file mode 100644 index 0000000000000000000000000000000000000000..c1f93d421c0aee7a060f1b4cafda4a819408e14b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ms_my.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ms_MY DATE_FORMAT "%A %d %b %Y" + ::msgcat::mcset ms_MY TIME_FORMAT_12 "%I:%M:%S %z" + ::msgcat::mcset ms_MY DATE_TIME_FORMAT "%A %d %b %Y %I:%M:%S %z %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/mt.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/mt.msg new file mode 100644 index 0000000000000000000000000000000000000000..ddd5446421c107df913ea38e0aed61a48245951a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/mt.msg @@ -0,0 +1,27 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset mt DAYS_OF_WEEK_ABBREV [list \ + "\u0126ad"\ + "Tne"\ + "Tli"\ + "Erb"\ + "\u0126am"\ + "\u0120im"] + ::msgcat::mcset mt MONTHS_ABBREV [list \ + "Jan"\ + "Fra"\ + "Mar"\ + "Apr"\ + "Mej"\ + "\u0120un"\ + "Lul"\ + "Awi"\ + "Set"\ + "Ott"\ + "Nov"] + ::msgcat::mcset mt BCE "QK" + ::msgcat::mcset mt CE "" + ::msgcat::mcset mt DATE_FORMAT "%A, %e ta %B, %Y" + ::msgcat::mcset mt TIME_FORMAT_12 "%l:%M:%S %P" + ::msgcat::mcset mt DATE_TIME_FORMAT "%A, %e ta %B, %Y %l:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/nb.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/nb.msg new file mode 100644 index 0000000000000000000000000000000000000000..90d49a3394915f3f78b63fe09ee78b88266d6e95 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/nb.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset nb DAYS_OF_WEEK_ABBREV [list \ + "s\u00f8"\ + "ma"\ + "ti"\ + "on"\ + "to"\ + "fr"\ + "l\u00f8"] + ::msgcat::mcset nb DAYS_OF_WEEK_FULL [list \ + "s\u00f8ndag"\ + "mandag"\ + "tirsdag"\ + "onsdag"\ + "torsdag"\ + "fredag"\ + "l\u00f8rdag"] + ::msgcat::mcset nb MONTHS_ABBREV [list \ + "jan"\ + "feb"\ + "mar"\ + "apr"\ + "mai"\ + "jun"\ + "jul"\ + "aug"\ + "sep"\ + "okt"\ + "nov"\ + "des"\ + ""] + ::msgcat::mcset nb MONTHS_FULL [list \ + "januar"\ + "februar"\ + "mars"\ + "april"\ + "mai"\ + "juni"\ + "juli"\ + "august"\ + "september"\ + "oktober"\ + "november"\ + "desember"\ + ""] + ::msgcat::mcset nb BCE "f.Kr." + ::msgcat::mcset nb CE "e.Kr." + ::msgcat::mcset nb DATE_FORMAT "%e. %B %Y" + ::msgcat::mcset nb TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset nb DATE_TIME_FORMAT "%e. %B %Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/nl.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/nl.msg new file mode 100644 index 0000000000000000000000000000000000000000..4c5c675518623c91e6883bcbe78fade21d5482ab --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/nl.msg @@ -0,0 +1,50 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset nl DAYS_OF_WEEK_ABBREV [list \ + "zo"\ + "ma"\ + "di"\ + "wo"\ + "do"\ + "vr"\ + "za"] + ::msgcat::mcset nl DAYS_OF_WEEK_FULL [list \ + "zondag"\ + "maandag"\ + "dinsdag"\ + "woensdag"\ + "donderdag"\ + "vrijdag"\ + "zaterdag"] + ::msgcat::mcset nl MONTHS_ABBREV [list \ + "jan"\ + "feb"\ + "mrt"\ + "apr"\ + "mei"\ + "jun"\ + "jul"\ + "aug"\ + "sep"\ + "okt"\ + "nov"\ + "dec"\ + ""] + ::msgcat::mcset nl MONTHS_FULL [list \ + "januari"\ + "februari"\ + "maart"\ + "april"\ + "mei"\ + "juni"\ + "juli"\ + "augustus"\ + "september"\ + "oktober"\ + "november"\ + "december"\ + ""] + ::msgcat::mcset nl DATE_FORMAT "%e %B %Y" + ::msgcat::mcset nl TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset nl DATE_TIME_FORMAT "%e %B %Y %k:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/nl_be.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/nl_be.msg new file mode 100644 index 0000000000000000000000000000000000000000..4b19670fc6dc2c3a4412fa8f49b2de77347b5cc3 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/nl_be.msg @@ -0,0 +1,7 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset nl_BE DATE_FORMAT "%d-%m-%y" + ::msgcat::mcset nl_BE TIME_FORMAT "%T" + ::msgcat::mcset nl_BE TIME_FORMAT_12 "%T" + ::msgcat::mcset nl_BE DATE_TIME_FORMAT "%a %d %b %Y %T %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/nn.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/nn.msg new file mode 100644 index 0000000000000000000000000000000000000000..bd61ac9493955b92806bfa55c43c769d5c522cb4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/nn.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset nn DAYS_OF_WEEK_ABBREV [list \ + "su"\ + "m\u00e5"\ + "ty"\ + "on"\ + "to"\ + "fr"\ + "lau"] + ::msgcat::mcset nn DAYS_OF_WEEK_FULL [list \ + "sundag"\ + "m\u00e5ndag"\ + "tysdag"\ + "onsdag"\ + "torsdag"\ + "fredag"\ + "laurdag"] + ::msgcat::mcset nn MONTHS_ABBREV [list \ + "jan"\ + "feb"\ + "mar"\ + "apr"\ + "mai"\ + "jun"\ + "jul"\ + "aug"\ + "sep"\ + "okt"\ + "nov"\ + "des"\ + ""] + ::msgcat::mcset nn MONTHS_FULL [list \ + "januar"\ + "februar"\ + "mars"\ + "april"\ + "mai"\ + "juni"\ + "juli"\ + "august"\ + "september"\ + "oktober"\ + "november"\ + "desember"\ + ""] + ::msgcat::mcset nn BCE "f.Kr." + ::msgcat::mcset nn CE "e.Kr." + ::msgcat::mcset nn DATE_FORMAT "%e. %B %Y" + ::msgcat::mcset nn TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset nn DATE_TIME_FORMAT "%e. %B %Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/pl.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/pl.msg new file mode 100644 index 0000000000000000000000000000000000000000..d206f4b71a7879a4d7b859f6ae2bd42854fabc21 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/pl.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset pl DAYS_OF_WEEK_ABBREV [list \ + "N"\ + "Pn"\ + "Wt"\ + "\u015ar"\ + "Cz"\ + "Pt"\ + "So"] + ::msgcat::mcset pl DAYS_OF_WEEK_FULL [list \ + "niedziela"\ + "poniedzia\u0142ek"\ + "wtorek"\ + "\u015broda"\ + "czwartek"\ + "pi\u0105tek"\ + "sobota"] + ::msgcat::mcset pl MONTHS_ABBREV [list \ + "sty"\ + "lut"\ + "mar"\ + "kwi"\ + "maj"\ + "cze"\ + "lip"\ + "sie"\ + "wrz"\ + "pa\u017a"\ + "lis"\ + "gru"\ + ""] + ::msgcat::mcset pl MONTHS_FULL [list \ + "stycze\u0144"\ + "luty"\ + "marzec"\ + "kwiecie\u0144"\ + "maj"\ + "czerwiec"\ + "lipiec"\ + "sierpie\u0144"\ + "wrzesie\u0144"\ + "pa\u017adziernik"\ + "listopad"\ + "grudzie\u0144"\ + ""] + ::msgcat::mcset pl BCE "p.n.e." + ::msgcat::mcset pl CE "n.e." + ::msgcat::mcset pl DATE_FORMAT "%Y-%m-%d" + ::msgcat::mcset pl TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset pl DATE_TIME_FORMAT "%Y-%m-%d %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/pt.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/pt.msg new file mode 100644 index 0000000000000000000000000000000000000000..96fdb35a682eae0a5344a20f31a5d3ed6e1f9207 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/pt.msg @@ -0,0 +1,50 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset pt DAYS_OF_WEEK_ABBREV [list \ + "Dom"\ + "Seg"\ + "Ter"\ + "Qua"\ + "Qui"\ + "Sex"\ + "S\u00e1b"] + ::msgcat::mcset pt DAYS_OF_WEEK_FULL [list \ + "Domingo"\ + "Segunda-feira"\ + "Ter\u00e7a-feira"\ + "Quarta-feira"\ + "Quinta-feira"\ + "Sexta-feira"\ + "S\u00e1bado"] + ::msgcat::mcset pt MONTHS_ABBREV [list \ + "Jan"\ + "Fev"\ + "Mar"\ + "Abr"\ + "Mai"\ + "Jun"\ + "Jul"\ + "Ago"\ + "Set"\ + "Out"\ + "Nov"\ + "Dez"\ + ""] + ::msgcat::mcset pt MONTHS_FULL [list \ + "Janeiro"\ + "Fevereiro"\ + "Mar\u00e7o"\ + "Abril"\ + "Maio"\ + "Junho"\ + "Julho"\ + "Agosto"\ + "Setembro"\ + "Outubro"\ + "Novembro"\ + "Dezembro"\ + ""] + ::msgcat::mcset pt DATE_FORMAT "%d-%m-%Y" + ::msgcat::mcset pt TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset pt DATE_TIME_FORMAT "%d-%m-%Y %k:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/pt_br.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/pt_br.msg new file mode 100644 index 0000000000000000000000000000000000000000..86843279bd7e7059565f6009010fd78f76dd928c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/pt_br.msg @@ -0,0 +1,7 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset pt_BR DATE_FORMAT "%d-%m-%Y" + ::msgcat::mcset pt_BR TIME_FORMAT "%T" + ::msgcat::mcset pt_BR TIME_FORMAT_12 "%T" + ::msgcat::mcset pt_BR DATE_TIME_FORMAT "%a %d %b %Y %T %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ro.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ro.msg new file mode 100644 index 0000000000000000000000000000000000000000..bdd7c6197222ebe646efabcaf0ec00ca50348aa7 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ro.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ro DAYS_OF_WEEK_ABBREV [list \ + "D"\ + "L"\ + "Ma"\ + "Mi"\ + "J"\ + "V"\ + "S"] + ::msgcat::mcset ro DAYS_OF_WEEK_FULL [list \ + "duminic\u0103"\ + "luni"\ + "mar\u0163i"\ + "miercuri"\ + "joi"\ + "vineri"\ + "s\u00eemb\u0103t\u0103"] + ::msgcat::mcset ro MONTHS_ABBREV [list \ + "Ian"\ + "Feb"\ + "Mar"\ + "Apr"\ + "Mai"\ + "Iun"\ + "Iul"\ + "Aug"\ + "Sep"\ + "Oct"\ + "Nov"\ + "Dec"\ + ""] + ::msgcat::mcset ro MONTHS_FULL [list \ + "ianuarie"\ + "februarie"\ + "martie"\ + "aprilie"\ + "mai"\ + "iunie"\ + "iulie"\ + "august"\ + "septembrie"\ + "octombrie"\ + "noiembrie"\ + "decembrie"\ + ""] + ::msgcat::mcset ro BCE "d.C." + ::msgcat::mcset ro CE "\u00ee.d.C." + ::msgcat::mcset ro DATE_FORMAT "%d.%m.%Y" + ::msgcat::mcset ro TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset ro DATE_TIME_FORMAT "%d.%m.%Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ru.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ru.msg new file mode 100644 index 0000000000000000000000000000000000000000..65b075d6b01c7899e7c9d4bcfe76a8707b012b3b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ru.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ru DAYS_OF_WEEK_ABBREV [list \ + "\u0412\u0441"\ + "\u041f\u043d"\ + "\u0412\u0442"\ + "\u0421\u0440"\ + "\u0427\u0442"\ + "\u041f\u0442"\ + "\u0421\u0431"] + ::msgcat::mcset ru DAYS_OF_WEEK_FULL [list \ + "\u0432\u043e\u0441\u043a\u0440\u0435\u0441\u0435\u043d\u044c\u0435"\ + "\u043f\u043e\u043d\u0435\u0434\u0435\u043b\u044c\u043d\u0438\u043a"\ + "\u0432\u0442\u043e\u0440\u043d\u0438\u043a"\ + "\u0441\u0440\u0435\u0434\u0430"\ + "\u0447\u0435\u0442\u0432\u0435\u0440\u0433"\ + "\u043f\u044f\u0442\u043d\u0438\u0446\u0430"\ + "\u0441\u0443\u0431\u0431\u043e\u0442\u0430"] + ::msgcat::mcset ru MONTHS_ABBREV [list \ + "\u044f\u043d\u0432"\ + "\u0444\u0435\u0432"\ + "\u043c\u0430\u0440"\ + "\u0430\u043f\u0440"\ + "\u043c\u0430\u0439"\ + "\u0438\u044e\u043d"\ + "\u0438\u044e\u043b"\ + "\u0430\u0432\u0433"\ + "\u0441\u0435\u043d"\ + "\u043e\u043a\u0442"\ + "\u043d\u043e\u044f"\ + "\u0434\u0435\u043a"\ + ""] + ::msgcat::mcset ru MONTHS_FULL [list \ + "\u042f\u043d\u0432\u0430\u0440\u044c"\ + "\u0424\u0435\u0432\u0440\u0430\u043b\u044c"\ + "\u041c\u0430\u0440\u0442"\ + "\u0410\u043f\u0440\u0435\u043b\u044c"\ + "\u041c\u0430\u0439"\ + "\u0418\u044e\u043d\u044c"\ + "\u0418\u044e\u043b\u044c"\ + "\u0410\u0432\u0433\u0443\u0441\u0442"\ + "\u0421\u0435\u043d\u0442\u044f\u0431\u0440\u044c"\ + "\u041e\u043a\u0442\u044f\u0431\u0440\u044c"\ + "\u041d\u043e\u044f\u0431\u0440\u044c"\ + "\u0414\u0435\u043a\u0430\u0431\u0440\u044c"\ + ""] + ::msgcat::mcset ru BCE "\u0434\u043e \u043d.\u044d." + ::msgcat::mcset ru CE "\u043d.\u044d." + ::msgcat::mcset ru DATE_FORMAT "%d.%m.%Y" + ::msgcat::mcset ru TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset ru DATE_TIME_FORMAT "%d.%m.%Y %k:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ru_ua.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ru_ua.msg new file mode 100644 index 0000000000000000000000000000000000000000..6e1f8a86e8dea968b603d101395847edb7bb62ff --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ru_ua.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ru_UA DATE_FORMAT "%d.%m.%Y" + ::msgcat::mcset ru_UA TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset ru_UA DATE_TIME_FORMAT "%d.%m.%Y %k:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sh.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sh.msg new file mode 100644 index 0000000000000000000000000000000000000000..6ee0fc7f40c711e254f713ab86a3c8be654b5f49 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sh.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset sh DAYS_OF_WEEK_ABBREV [list \ + "Ned"\ + "Pon"\ + "Uto"\ + "Sre"\ + "\u010cet"\ + "Pet"\ + "Sub"] + ::msgcat::mcset sh DAYS_OF_WEEK_FULL [list \ + "Nedelja"\ + "Ponedeljak"\ + "Utorak"\ + "Sreda"\ + "\u010cetvrtak"\ + "Petak"\ + "Subota"] + ::msgcat::mcset sh MONTHS_ABBREV [list \ + "Jan"\ + "Feb"\ + "Mar"\ + "Apr"\ + "Maj"\ + "Jun"\ + "Jul"\ + "Avg"\ + "Sep"\ + "Okt"\ + "Nov"\ + "Dec"\ + ""] + ::msgcat::mcset sh MONTHS_FULL [list \ + "Januar"\ + "Februar"\ + "Mart"\ + "April"\ + "Maj"\ + "Juni"\ + "Juli"\ + "Avgust"\ + "Septembar"\ + "Oktobar"\ + "Novembar"\ + "Decembar"\ + ""] + ::msgcat::mcset sh BCE "p. n. e." + ::msgcat::mcset sh CE "n. e." + ::msgcat::mcset sh DATE_FORMAT "%d.%m.%Y." + ::msgcat::mcset sh TIME_FORMAT "%k.%M.%S" + ::msgcat::mcset sh DATE_TIME_FORMAT "%d.%m.%Y. %k.%M.%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sk.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sk.msg new file mode 100644 index 0000000000000000000000000000000000000000..9b2f0aadd2de5b7bd3aedf9e1fdc47caf6704a07 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sk.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset sk DAYS_OF_WEEK_ABBREV [list \ + "Ne"\ + "Po"\ + "Ut"\ + "St"\ + "\u0160t"\ + "Pa"\ + "So"] + ::msgcat::mcset sk DAYS_OF_WEEK_FULL [list \ + "Nede\u013ee"\ + "Pondelok"\ + "Utorok"\ + "Streda"\ + "\u0160tvrtok"\ + "Piatok"\ + "Sobota"] + ::msgcat::mcset sk MONTHS_ABBREV [list \ + "jan"\ + "feb"\ + "mar"\ + "apr"\ + "m\u00e1j"\ + "j\u00fan"\ + "j\u00fal"\ + "aug"\ + "sep"\ + "okt"\ + "nov"\ + "dec"\ + ""] + ::msgcat::mcset sk MONTHS_FULL [list \ + "janu\u00e1r"\ + "febru\u00e1r"\ + "marec"\ + "apr\u00edl"\ + "m\u00e1j"\ + "j\u00fan"\ + "j\u00fal"\ + "august"\ + "september"\ + "okt\u00f3ber"\ + "november"\ + "december"\ + ""] + ::msgcat::mcset sk BCE "pred n.l." + ::msgcat::mcset sk CE "n.l." + ::msgcat::mcset sk DATE_FORMAT "%e.%m.%Y" + ::msgcat::mcset sk TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset sk DATE_TIME_FORMAT "%e.%m.%Y %k:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sl.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sl.msg new file mode 100644 index 0000000000000000000000000000000000000000..42bc5097a77ceb8028b1b766a8a2df35305bcf55 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sl.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset sl DAYS_OF_WEEK_ABBREV [list \ + "Ned"\ + "Pon"\ + "Tor"\ + "Sre"\ + "\u010cet"\ + "Pet"\ + "Sob"] + ::msgcat::mcset sl DAYS_OF_WEEK_FULL [list \ + "Nedelja"\ + "Ponedeljek"\ + "Torek"\ + "Sreda"\ + "\u010cetrtek"\ + "Petek"\ + "Sobota"] + ::msgcat::mcset sl MONTHS_ABBREV [list \ + "jan"\ + "feb"\ + "mar"\ + "apr"\ + "maj"\ + "jun"\ + "jul"\ + "avg"\ + "sep"\ + "okt"\ + "nov"\ + "dec"\ + ""] + ::msgcat::mcset sl MONTHS_FULL [list \ + "januar"\ + "februar"\ + "marec"\ + "april"\ + "maj"\ + "junij"\ + "julij"\ + "avgust"\ + "september"\ + "oktober"\ + "november"\ + "december"\ + ""] + ::msgcat::mcset sl BCE "pr.n.\u0161." + ::msgcat::mcset sl CE "po Kr." + ::msgcat::mcset sl DATE_FORMAT "%Y.%m.%e" + ::msgcat::mcset sl TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset sl DATE_TIME_FORMAT "%Y.%m.%e %k:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sq.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sq.msg new file mode 100644 index 0000000000000000000000000000000000000000..8fb1fce966c58953ec08d24eb5f600eb5db68332 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sq.msg @@ -0,0 +1,54 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset sq DAYS_OF_WEEK_ABBREV [list \ + "Die"\ + "H\u00ebn"\ + "Mar"\ + "M\u00ebr"\ + "Enj"\ + "Pre"\ + "Sht"] + ::msgcat::mcset sq DAYS_OF_WEEK_FULL [list \ + "e diel"\ + "e h\u00ebn\u00eb"\ + "e mart\u00eb"\ + "e m\u00ebrkur\u00eb"\ + "e enjte"\ + "e premte"\ + "e shtun\u00eb"] + ::msgcat::mcset sq MONTHS_ABBREV [list \ + "Jan"\ + "Shk"\ + "Mar"\ + "Pri"\ + "Maj"\ + "Qer"\ + "Kor"\ + "Gsh"\ + "Sht"\ + "Tet"\ + "N\u00ebn"\ + "Dhj"\ + ""] + ::msgcat::mcset sq MONTHS_FULL [list \ + "janar"\ + "shkurt"\ + "mars"\ + "prill"\ + "maj"\ + "qershor"\ + "korrik"\ + "gusht"\ + "shtator"\ + "tetor"\ + "n\u00ebntor"\ + "dhjetor"\ + ""] + ::msgcat::mcset sq BCE "p.e.r." + ::msgcat::mcset sq CE "n.e.r." + ::msgcat::mcset sq AM "PD" + ::msgcat::mcset sq PM "MD" + ::msgcat::mcset sq DATE_FORMAT "%Y-%m-%d" + ::msgcat::mcset sq TIME_FORMAT_12 "%l:%M:%S.%P" + ::msgcat::mcset sq DATE_TIME_FORMAT "%Y-%m-%d %l:%M:%S.%P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sr.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sr.msg new file mode 100644 index 0000000000000000000000000000000000000000..757666875e32ebe79728b293425faaec96117238 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sr.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset sr DAYS_OF_WEEK_ABBREV [list \ + "\u041d\u0435\u0434"\ + "\u041f\u043e\u043d"\ + "\u0423\u0442\u043e"\ + "\u0421\u0440\u0435"\ + "\u0427\u0435\u0442"\ + "\u041f\u0435\u0442"\ + "\u0421\u0443\u0431"] + ::msgcat::mcset sr DAYS_OF_WEEK_FULL [list \ + "\u041d\u0435\u0434\u0435\u0459\u0430"\ + "\u041f\u043e\u043d\u0435\u0434\u0435\u0459\u0430\u043a"\ + "\u0423\u0442\u043e\u0440\u0430\u043a"\ + "\u0421\u0440\u0435\u0434\u0430"\ + "\u0427\u0435\u0442\u0432\u0440\u0442\u0430\u043a"\ + "\u041f\u0435\u0442\u0430\u043a"\ + "\u0421\u0443\u0431\u043e\u0442\u0430"] + ::msgcat::mcset sr MONTHS_ABBREV [list \ + "\u0408\u0430\u043d"\ + "\u0424\u0435\u0431"\ + "\u041c\u0430\u0440"\ + "\u0410\u043f\u0440"\ + "\u041c\u0430\u0458"\ + "\u0408\u0443\u043d"\ + "\u0408\u0443\u043b"\ + "\u0410\u0432\u0433"\ + "\u0421\u0435\u043f"\ + "\u041e\u043a\u0442"\ + "\u041d\u043e\u0432"\ + "\u0414\u0435\u0446"\ + ""] + ::msgcat::mcset sr MONTHS_FULL [list \ + "\u0408\u0430\u043d\u0443\u0430\u0440"\ + "\u0424\u0435\u0431\u0440\u0443\u0430\u0440"\ + "\u041c\u0430\u0440\u0442"\ + "\u0410\u043f\u0440\u0438\u043b"\ + "\u041c\u0430\u0458"\ + "\u0408\u0443\u043d\u0438"\ + "\u0408\u0443\u043b\u0438"\ + "\u0410\u0432\u0433\u0443\u0441\u0442"\ + "\u0421\u0435\u043f\u0442\u0435\u043c\u0431\u0430\u0440"\ + "\u041e\u043a\u0442\u043e\u0431\u0430\u0440"\ + "\u041d\u043e\u0432\u0435\u043c\u0431\u0430\u0440"\ + "\u0414\u0435\u0446\u0435\u043c\u0431\u0430\u0440"\ + ""] + ::msgcat::mcset sr BCE "\u043f. \u043d. \u0435." + ::msgcat::mcset sr CE "\u043d. \u0435" + ::msgcat::mcset sr DATE_FORMAT "%Y.%m.%e" + ::msgcat::mcset sr TIME_FORMAT "%k.%M.%S" + ::msgcat::mcset sr DATE_TIME_FORMAT "%Y.%m.%e %k.%M.%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sv.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sv.msg new file mode 100644 index 0000000000000000000000000000000000000000..f7a67c6eabd1e1d5968114fb928a3bfc3f981cd0 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sv.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset sv DAYS_OF_WEEK_ABBREV [list \ + "s\u00f6"\ + "m\u00e5"\ + "ti"\ + "on"\ + "to"\ + "fr"\ + "l\u00f6"] + ::msgcat::mcset sv DAYS_OF_WEEK_FULL [list \ + "s\u00f6ndag"\ + "m\u00e5ndag"\ + "tisdag"\ + "onsdag"\ + "torsdag"\ + "fredag"\ + "l\u00f6rdag"] + ::msgcat::mcset sv MONTHS_ABBREV [list \ + "jan"\ + "feb"\ + "mar"\ + "apr"\ + "maj"\ + "jun"\ + "jul"\ + "aug"\ + "sep"\ + "okt"\ + "nov"\ + "dec"\ + ""] + ::msgcat::mcset sv MONTHS_FULL [list \ + "januari"\ + "februari"\ + "mars"\ + "april"\ + "maj"\ + "juni"\ + "juli"\ + "augusti"\ + "september"\ + "oktober"\ + "november"\ + "december"\ + ""] + ::msgcat::mcset sv BCE "f.Kr." + ::msgcat::mcset sv CE "e.Kr." + ::msgcat::mcset sv DATE_FORMAT "%Y-%m-%d" + ::msgcat::mcset sv TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset sv DATE_TIME_FORMAT "%Y-%m-%d %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sw.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sw.msg new file mode 100644 index 0000000000000000000000000000000000000000..b888b43df7009891dd34872cdce6002b961287a9 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/sw.msg @@ -0,0 +1,49 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset sw DAYS_OF_WEEK_ABBREV [list \ + "Jpi"\ + "Jtt"\ + "Jnn"\ + "Jtn"\ + "Alh"\ + "Iju"\ + "Jmo"] + ::msgcat::mcset sw DAYS_OF_WEEK_FULL [list \ + "Jumapili"\ + "Jumatatu"\ + "Jumanne"\ + "Jumatano"\ + "Alhamisi"\ + "Ijumaa"\ + "Jumamosi"] + ::msgcat::mcset sw MONTHS_ABBREV [list \ + "Jan"\ + "Feb"\ + "Mar"\ + "Apr"\ + "Mei"\ + "Jun"\ + "Jul"\ + "Ago"\ + "Sep"\ + "Okt"\ + "Nov"\ + "Des"\ + ""] + ::msgcat::mcset sw MONTHS_FULL [list \ + "Januari"\ + "Februari"\ + "Machi"\ + "Aprili"\ + "Mei"\ + "Juni"\ + "Julai"\ + "Agosti"\ + "Septemba"\ + "Oktoba"\ + "Novemba"\ + "Desemba"\ + ""] + ::msgcat::mcset sw BCE "KK" + ::msgcat::mcset sw CE "BK" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ta.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ta.msg new file mode 100644 index 0000000000000000000000000000000000000000..4abb90ca04180622396b6ffb11f5876b9245900a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ta.msg @@ -0,0 +1,39 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ta DAYS_OF_WEEK_FULL [list \ + "\u0b9e\u0bbe\u0baf\u0bbf\u0bb1\u0bc1"\ + "\u0ba4\u0bbf\u0b99\u0bcd\u0b95\u0bb3\u0bcd"\ + "\u0b9a\u0bc6\u0bb5\u0bcd\u0bb5\u0bbe\u0baf\u0bcd"\ + "\u0baa\u0bc1\u0ba4\u0ba9\u0bcd"\ + "\u0bb5\u0bbf\u0baf\u0bbe\u0bb4\u0ba9\u0bcd"\ + "\u0bb5\u0bc6\u0bb3\u0bcd\u0bb3\u0bbf"\ + "\u0b9a\u0ba9\u0bbf"] + ::msgcat::mcset ta MONTHS_ABBREV [list \ + "\u0b9c\u0ba9\u0bb5\u0bb0\u0bbf"\ + "\u0baa\u0bc6\u0baa\u0bcd\u0bb0\u0bb5\u0bb0\u0bbf"\ + "\u0bae\u0bbe\u0bb0\u0bcd\u0b9a\u0bcd"\ + "\u0b8f\u0baa\u0bcd\u0bb0\u0bb2\u0bcd"\ + "\u0bae\u0bc7"\ + "\u0b9c\u0bc2\u0ba9\u0bcd"\ + "\u0b9c\u0bc2\u0bb2\u0bc8"\ + "\u0b86\u0b95\u0bb8\u0bcd\u0b9f\u0bcd"\ + "\u0b9a\u0bc6\u0baa\u0bcd\u0b9f\u0bae\u0bcd\u0baa\u0bb0\u0bcd"\ + "\u0b85\u0b95\u0bcd\u0b9f\u0bcb\u0baa\u0bb0\u0bcd"\ + "\u0ba8\u0bb5\u0bae\u0bcd\u0baa\u0bb0\u0bcd"\ + "\u0b9f\u0bbf\u0b9a\u0bae\u0bcd\u0baa\u0bb0\u0bcdr"] + ::msgcat::mcset ta MONTHS_FULL [list \ + "\u0b9c\u0ba9\u0bb5\u0bb0\u0bbf"\ + "\u0baa\u0bc6\u0baa\u0bcd\u0bb0\u0bb5\u0bb0\u0bbf"\ + "\u0bae\u0bbe\u0bb0\u0bcd\u0b9a\u0bcd"\ + "\u0b8f\u0baa\u0bcd\u0bb0\u0bb2\u0bcd"\ + "\u0bae\u0bc7"\ + "\u0b9c\u0bc2\u0ba9\u0bcd"\ + "\u0b9c\u0bc2\u0bb2\u0bc8"\ + "\u0b86\u0b95\u0bb8\u0bcd\u0b9f\u0bcd"\ + "\u0b9a\u0bc6\u0baa\u0bcd\u0b9f\u0bae\u0bcd\u0baa\u0bb0\u0bcd"\ + "\u0b85\u0b95\u0bcd\u0b9f\u0bcb\u0baa\u0bb0\u0bcd"\ + "\u0ba8\u0bb5\u0bae\u0bcd\u0baa\u0bb0\u0bcd"\ + "\u0b9f\u0bbf\u0b9a\u0bae\u0bcd\u0baa\u0bb0\u0bcdr"] + ::msgcat::mcset ta AM "\u0b95\u0bbf\u0bae\u0bc1" + ::msgcat::mcset ta PM "\u0b95\u0bbf\u0baa\u0bbf" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ta_in.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ta_in.msg new file mode 100644 index 0000000000000000000000000000000000000000..24590ac410382ab4a7a3a93cbfb9d3704b518906 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/ta_in.msg @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ta_IN DATE_FORMAT "%d %M %Y" + ::msgcat::mcset ta_IN TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset ta_IN DATE_TIME_FORMAT "%d %M %Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/te.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/te.msg new file mode 100644 index 0000000000000000000000000000000000000000..6111473c58fc4c760d0113f2387e9e49957d8622 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/te.msg @@ -0,0 +1,47 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset te DAYS_OF_WEEK_ABBREV [list \ + "\u0c06\u0c26\u0c3f"\ + "\u0c38\u0c4b\u0c2e"\ + "\u0c2e\u0c02\u0c17\u0c33"\ + "\u0c2c\u0c41\u0c27"\ + "\u0c17\u0c41\u0c30\u0c41"\ + "\u0c36\u0c41\u0c15\u0c4d\u0c30"\ + "\u0c36\u0c28\u0c3f"] + ::msgcat::mcset te DAYS_OF_WEEK_FULL [list \ + "\u0c06\u0c26\u0c3f\u0c35\u0c3e\u0c30\u0c02"\ + "\u0c38\u0c4b\u0c2e\u0c35\u0c3e\u0c30\u0c02"\ + "\u0c2e\u0c02\u0c17\u0c33\u0c35\u0c3e\u0c30\u0c02"\ + "\u0c2c\u0c41\u0c27\u0c35\u0c3e\u0c30\u0c02"\ + "\u0c17\u0c41\u0c30\u0c41\u0c35\u0c3e\u0c30\u0c02"\ + "\u0c36\u0c41\u0c15\u0c4d\u0c30\u0c35\u0c3e\u0c30\u0c02"\ + "\u0c36\u0c28\u0c3f\u0c35\u0c3e\u0c30\u0c02"] + ::msgcat::mcset te MONTHS_ABBREV [list \ + "\u0c1c\u0c28\u0c35\u0c30\u0c3f"\ + "\u0c2b\u0c3f\u0c2c\u0c4d\u0c30\u0c35\u0c30\u0c3f"\ + "\u0c2e\u0c3e\u0c30\u0c4d\u0c1a\u0c3f"\ + "\u0c0f\u0c2a\u0c4d\u0c30\u0c3f\u0c32\u0c4d"\ + "\u0c2e\u0c47"\ + "\u0c1c\u0c42\u0c28\u0c4d"\ + "\u0c1c\u0c42\u0c32\u0c48"\ + "\u0c06\u0c17\u0c38\u0c4d\u0c1f\u0c41"\ + "\u0c38\u0c46\u0c2a\u0c4d\u0c1f\u0c46\u0c02\u0c2c\u0c30\u0c4d"\ + "\u0c05\u0c15\u0c4d\u0c1f\u0c4b\u0c2c\u0c30\u0c4d"\ + "\u0c28\u0c35\u0c02\u0c2c\u0c30\u0c4d"\ + "\u0c21\u0c3f\u0c38\u0c46\u0c02\u0c2c\u0c30\u0c4d"\ + ""] + ::msgcat::mcset te MONTHS_FULL [list \ + "\u0c1c\u0c28\u0c35\u0c30\u0c3f"\ + "\u0c2b\u0c3f\u0c2c\u0c4d\u0c30\u0c35\u0c30\u0c3f"\ + "\u0c2e\u0c3e\u0c30\u0c4d\u0c1a\u0c3f"\ + "\u0c0f\u0c2a\u0c4d\u0c30\u0c3f\u0c32\u0c4d"\ + "\u0c2e\u0c47"\ + "\u0c1c\u0c42\u0c28\u0c4d"\ + "\u0c1c\u0c42\u0c32\u0c48"\ + "\u0c06\u0c17\u0c38\u0c4d\u0c1f\u0c41"\ + "\u0c38\u0c46\u0c2a\u0c4d\u0c1f\u0c46\u0c02\u0c2c\u0c30\u0c4d"\ + "\u0c05\u0c15\u0c4d\u0c1f\u0c4b\u0c2c\u0c30\u0c4d"\ + "\u0c28\u0c35\u0c02\u0c2c\u0c30\u0c4d"\ + "\u0c21\u0c3f\u0c38\u0c46\u0c02\u0c2c\u0c30\u0c4d"\ + ""] +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/te_in.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/te_in.msg new file mode 100644 index 0000000000000000000000000000000000000000..61638b5a2513abfd6626bc9429fb1f183e689676 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/te_in.msg @@ -0,0 +1,8 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset te_IN AM "\u0c2a\u0c42\u0c30\u0c4d\u0c35\u0c3e\u0c39\u0c4d\u0c28" + ::msgcat::mcset te_IN PM "\u0c05\u0c2a\u0c30\u0c3e\u0c39\u0c4d\u0c28" + ::msgcat::mcset te_IN DATE_FORMAT "%d/%m/%Y" + ::msgcat::mcset te_IN TIME_FORMAT_12 "%I:%M:%S %P" + ::msgcat::mcset te_IN DATE_TIME_FORMAT "%d/%m/%Y %I:%M:%S %P %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/th.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/th.msg new file mode 100644 index 0000000000000000000000000000000000000000..7486c35a68f7a5abbb2e085cbf4a5285dc3c612b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/th.msg @@ -0,0 +1,54 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset th DAYS_OF_WEEK_ABBREV [list \ + "\u0e2d\u0e32."\ + "\u0e08."\ + "\u0e2d."\ + "\u0e1e."\ + "\u0e1e\u0e24."\ + "\u0e28."\ + "\u0e2a."] + ::msgcat::mcset th DAYS_OF_WEEK_FULL [list \ + "\u0e27\u0e31\u0e19\u0e2d\u0e32\u0e17\u0e34\u0e15\u0e22\u0e4c"\ + "\u0e27\u0e31\u0e19\u0e08\u0e31\u0e19\u0e17\u0e23\u0e4c"\ + "\u0e27\u0e31\u0e19\u0e2d\u0e31\u0e07\u0e04\u0e32\u0e23"\ + "\u0e27\u0e31\u0e19\u0e1e\u0e38\u0e18"\ + "\u0e27\u0e31\u0e19\u0e1e\u0e24\u0e2b\u0e31\u0e2a\u0e1a\u0e14\u0e35"\ + "\u0e27\u0e31\u0e19\u0e28\u0e38\u0e01\u0e23\u0e4c"\ + "\u0e27\u0e31\u0e19\u0e40\u0e2a\u0e32\u0e23\u0e4c"] + ::msgcat::mcset th MONTHS_ABBREV [list \ + "\u0e21.\u0e04."\ + "\u0e01.\u0e1e."\ + "\u0e21\u0e35.\u0e04."\ + "\u0e40\u0e21.\u0e22."\ + "\u0e1e.\u0e04."\ + "\u0e21\u0e34.\u0e22."\ + "\u0e01.\u0e04."\ + "\u0e2a.\u0e04."\ + "\u0e01.\u0e22."\ + "\u0e15.\u0e04."\ + "\u0e1e.\u0e22."\ + "\u0e18.\u0e04."\ + ""] + ::msgcat::mcset th MONTHS_FULL [list \ + "\u0e21\u0e01\u0e23\u0e32\u0e04\u0e21"\ + "\u0e01\u0e38\u0e21\u0e20\u0e32\u0e1e\u0e31\u0e19\u0e18\u0e4c"\ + "\u0e21\u0e35\u0e19\u0e32\u0e04\u0e21"\ + "\u0e40\u0e21\u0e29\u0e32\u0e22\u0e19"\ + "\u0e1e\u0e24\u0e29\u0e20\u0e32\u0e04\u0e21"\ + "\u0e21\u0e34\u0e16\u0e38\u0e19\u0e32\u0e22\u0e19"\ + "\u0e01\u0e23\u0e01\u0e0e\u0e32\u0e04\u0e21"\ + "\u0e2a\u0e34\u0e07\u0e2b\u0e32\u0e04\u0e21"\ + "\u0e01\u0e31\u0e19\u0e22\u0e32\u0e22\u0e19"\ + "\u0e15\u0e38\u0e25\u0e32\u0e04\u0e21"\ + "\u0e1e\u0e24\u0e28\u0e08\u0e34\u0e01\u0e32\u0e22\u0e19"\ + "\u0e18\u0e31\u0e19\u0e27\u0e32\u0e04\u0e21"\ + ""] + ::msgcat::mcset th BCE "\u0e25\u0e17\u0e35\u0e48" + ::msgcat::mcset th CE "\u0e04.\u0e28." + ::msgcat::mcset th AM "\u0e01\u0e48\u0e2d\u0e19\u0e40\u0e17\u0e35\u0e48\u0e22\u0e07" + ::msgcat::mcset th PM "\u0e2b\u0e25\u0e31\u0e07\u0e40\u0e17\u0e35\u0e48\u0e22\u0e07" + ::msgcat::mcset th DATE_FORMAT "%e/%m/%Y" + ::msgcat::mcset th TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset th DATE_TIME_FORMAT "%e/%m/%Y %k:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/tr.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/tr.msg new file mode 100644 index 0000000000000000000000000000000000000000..7b2ecf97d890c810b35b37fe972cbb2b2983b41a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/tr.msg @@ -0,0 +1,50 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset tr DAYS_OF_WEEK_ABBREV [list \ + "Paz"\ + "Pzt"\ + "Sal"\ + "\u00c7ar"\ + "Per"\ + "Cum"\ + "Cmt"] + ::msgcat::mcset tr DAYS_OF_WEEK_FULL [list \ + "Pazar"\ + "Pazartesi"\ + "Sal\u0131"\ + "\u00c7ar\u015famba"\ + "Per\u015fembe"\ + "Cuma"\ + "Cumartesi"] + ::msgcat::mcset tr MONTHS_ABBREV [list \ + "Oca"\ + "\u015eub"\ + "Mar"\ + "Nis"\ + "May"\ + "Haz"\ + "Tem"\ + "A\u011fu"\ + "Eyl"\ + "Eki"\ + "Kas"\ + "Ara"\ + ""] + ::msgcat::mcset tr MONTHS_FULL [list \ + "Ocak"\ + "\u015eubat"\ + "Mart"\ + "Nisan"\ + "May\u0131s"\ + "Haziran"\ + "Temmuz"\ + "A\u011fustos"\ + "Eyl\u00fcl"\ + "Ekim"\ + "Kas\u0131m"\ + "Aral\u0131k"\ + ""] + ::msgcat::mcset tr DATE_FORMAT "%d.%m.%Y" + ::msgcat::mcset tr TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset tr DATE_TIME_FORMAT "%d.%m.%Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/uk.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/uk.msg new file mode 100644 index 0000000000000000000000000000000000000000..7d4c64a0c3e93386e0d86118e5323b7a439f9b2a --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/uk.msg @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset uk DAYS_OF_WEEK_ABBREV [list \ + "\u043d\u0434"\ + "\u043f\u043d"\ + "\u0432\u0442"\ + "\u0441\u0440"\ + "\u0447\u0442"\ + "\u043f\u0442"\ + "\u0441\u0431"] + ::msgcat::mcset uk DAYS_OF_WEEK_FULL [list \ + "\u043d\u0435\u0434\u0456\u043b\u044f"\ + "\u043f\u043e\u043d\u0435\u0434\u0456\u043b\u043e\u043a"\ + "\u0432\u0456\u0432\u0442\u043e\u0440\u043e\u043a"\ + "\u0441\u0435\u0440\u0435\u0434\u0430"\ + "\u0447\u0435\u0442\u0432\u0435\u0440"\ + "\u043f'\u044f\u0442\u043d\u0438\u0446\u044f"\ + "\u0441\u0443\u0431\u043e\u0442\u0430"] + ::msgcat::mcset uk MONTHS_ABBREV [list \ + "\u0441\u0456\u0447"\ + "\u043b\u044e\u0442"\ + "\u0431\u0435\u0440"\ + "\u043a\u0432\u0456\u0442"\ + "\u0442\u0440\u0430\u0432"\ + "\u0447\u0435\u0440\u0432"\ + "\u043b\u0438\u043f"\ + "\u0441\u0435\u0440\u043f"\ + "\u0432\u0435\u0440"\ + "\u0436\u043e\u0432\u0442"\ + "\u043b\u0438\u0441\u0442"\ + "\u0433\u0440\u0443\u0434"\ + ""] + ::msgcat::mcset uk MONTHS_FULL [list \ + "\u0441\u0456\u0447\u043d\u044f"\ + "\u043b\u044e\u0442\u043e\u0433\u043e"\ + "\u0431\u0435\u0440\u0435\u0437\u043d\u044f"\ + "\u043a\u0432\u0456\u0442\u043d\u044f"\ + "\u0442\u0440\u0430\u0432\u043d\u044f"\ + "\u0447\u0435\u0440\u0432\u043d\u044f"\ + "\u043b\u0438\u043f\u043d\u044f"\ + "\u0441\u0435\u0440\u043f\u043d\u044f"\ + "\u0432\u0435\u0440\u0435\u0441\u043d\u044f"\ + "\u0436\u043e\u0432\u0442\u043d\u044f"\ + "\u043b\u0438\u0441\u0442\u043e\u043f\u0430\u0434\u0430"\ + "\u0433\u0440\u0443\u0434\u043d\u044f"\ + ""] + ::msgcat::mcset uk BCE "\u0434\u043e \u043d.\u0435." + ::msgcat::mcset uk CE "\u043f\u0456\u0441\u043b\u044f \u043d.\u0435." + ::msgcat::mcset uk DATE_FORMAT "%e/%m/%Y" + ::msgcat::mcset uk TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset uk DATE_TIME_FORMAT "%e/%m/%Y %k:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/vi.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/vi.msg new file mode 100644 index 0000000000000000000000000000000000000000..c98b2a6a7d9ca24c3cb18b9f1e2eca4aa9ad82a1 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/vi.msg @@ -0,0 +1,50 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset vi DAYS_OF_WEEK_ABBREV [list \ + "Th 2"\ + "Th 3"\ + "Th 4"\ + "Th 5"\ + "Th 6"\ + "Th 7"\ + "CN"] + ::msgcat::mcset vi DAYS_OF_WEEK_FULL [list \ + "Th\u01b0\u0301 hai"\ + "Th\u01b0\u0301 ba"\ + "Th\u01b0\u0301 t\u01b0"\ + "Th\u01b0\u0301 n\u0103m"\ + "Th\u01b0\u0301 s\u00e1u"\ + "Th\u01b0\u0301 ba\u0309y"\ + "Chu\u0309 nh\u00e2\u0323t"] + ::msgcat::mcset vi MONTHS_ABBREV [list \ + "Thg 1"\ + "Thg 2"\ + "Thg 3"\ + "Thg 4"\ + "Thg 5"\ + "Thg 6"\ + "Thg 7"\ + "Thg 8"\ + "Thg 9"\ + "Thg 10"\ + "Thg 11"\ + "Thg 12"\ + ""] + ::msgcat::mcset vi MONTHS_FULL [list \ + "Th\u00e1ng m\u00f4\u0323t"\ + "Th\u00e1ng hai"\ + "Th\u00e1ng ba"\ + "Th\u00e1ng t\u01b0"\ + "Th\u00e1ng n\u0103m"\ + "Th\u00e1ng s\u00e1u"\ + "Th\u00e1ng ba\u0309y"\ + "Th\u00e1ng t\u00e1m"\ + "Th\u00e1ng ch\u00edn"\ + "Th\u00e1ng m\u01b0\u01a1\u0300i"\ + "Th\u00e1ng m\u01b0\u01a1\u0300i m\u00f4\u0323t"\ + "Th\u00e1ng m\u01b0\u01a1\u0300i hai"\ + ""] + ::msgcat::mcset vi DATE_FORMAT "%d %b %Y" + ::msgcat::mcset vi TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset vi DATE_TIME_FORMAT "%d %b %Y %H:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/zh.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/zh.msg new file mode 100644 index 0000000000000000000000000000000000000000..b799a3261aa1b34120bc75b20b1441e07d41d79b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/zh.msg @@ -0,0 +1,55 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset zh DAYS_OF_WEEK_ABBREV [list \ + "\u661f\u671f\u65e5"\ + "\u661f\u671f\u4e00"\ + "\u661f\u671f\u4e8c"\ + "\u661f\u671f\u4e09"\ + "\u661f\u671f\u56db"\ + "\u661f\u671f\u4e94"\ + "\u661f\u671f\u516d"] + ::msgcat::mcset zh DAYS_OF_WEEK_FULL [list \ + "\u661f\u671f\u65e5"\ + "\u661f\u671f\u4e00"\ + "\u661f\u671f\u4e8c"\ + "\u661f\u671f\u4e09"\ + "\u661f\u671f\u56db"\ + "\u661f\u671f\u4e94"\ + "\u661f\u671f\u516d"] + ::msgcat::mcset zh MONTHS_ABBREV [list \ + "\u4e00\u6708"\ + "\u4e8c\u6708"\ + "\u4e09\u6708"\ + "\u56db\u6708"\ + "\u4e94\u6708"\ + "\u516d\u6708"\ + "\u4e03\u6708"\ + "\u516b\u6708"\ + "\u4e5d\u6708"\ + "\u5341\u6708"\ + "\u5341\u4e00\u6708"\ + "\u5341\u4e8c\u6708"\ + ""] + ::msgcat::mcset zh MONTHS_FULL [list \ + "\u4e00\u6708"\ + "\u4e8c\u6708"\ + "\u4e09\u6708"\ + "\u56db\u6708"\ + "\u4e94\u6708"\ + "\u516d\u6708"\ + "\u4e03\u6708"\ + "\u516b\u6708"\ + "\u4e5d\u6708"\ + "\u5341\u6708"\ + "\u5341\u4e00\u6708"\ + "\u5341\u4e8c\u6708"\ + ""] + ::msgcat::mcset zh BCE "\u516c\u5143\u524d" + ::msgcat::mcset zh CE "\u516c\u5143" + ::msgcat::mcset zh AM "\u4e0a\u5348" + ::msgcat::mcset zh PM "\u4e0b\u5348" + ::msgcat::mcset zh LOCALE_NUMERALS "\u3007 \u4e00 \u4e8c \u4e09 \u56db \u4e94 \u516d \u4e03 \u516b \u4e5d \u5341 \u5341\u4e00 \u5341\u4e8c \u5341\u4e09 \u5341\u56db \u5341\u4e94 \u5341\u516d \u5341\u4e03 \u5341\u516b \u5341\u4e5d \u4e8c\u5341 \u5eff\u4e00 \u5eff\u4e8c \u5eff\u4e09 \u5eff\u56db \u5eff\u4e94 \u5eff\u516d \u5eff\u4e03 \u5eff\u516b \u5eff\u4e5d \u4e09\u5341 \u5345\u4e00 \u5345\u4e8c \u5345\u4e09 \u5345\u56db \u5345\u4e94 \u5345\u516d \u5345\u4e03 \u5345\u516b \u5345\u4e5d \u56db\u5341 \u56db\u5341\u4e00 \u56db\u5341\u4e8c \u56db\u5341\u4e09 \u56db\u5341\u56db \u56db\u5341\u4e94 \u56db\u5341\u516d \u56db\u5341\u4e03 \u56db\u5341\u516b \u56db\u5341\u4e5d \u4e94\u5341 \u4e94\u5341\u4e00 \u4e94\u5341\u4e8c \u4e94\u5341\u4e09 \u4e94\u5341\u56db \u4e94\u5341\u4e94 \u4e94\u5341\u516d \u4e94\u5341\u4e03 \u4e94\u5341\u516b \u4e94\u5341\u4e5d \u516d\u5341 \u516d\u5341\u4e00 \u516d\u5341\u4e8c \u516d\u5341\u4e09 \u516d\u5341\u56db \u516d\u5341\u4e94 \u516d\u5341\u516d \u516d\u5341\u4e03 \u516d\u5341\u516b \u516d\u5341\u4e5d \u4e03\u5341 \u4e03\u5341\u4e00 \u4e03\u5341\u4e8c \u4e03\u5341\u4e09 \u4e03\u5341\u56db \u4e03\u5341\u4e94 \u4e03\u5341\u516d \u4e03\u5341\u4e03 \u4e03\u5341\u516b \u4e03\u5341\u4e5d \u516b\u5341 \u516b\u5341\u4e00 \u516b\u5341\u4e8c \u516b\u5341\u4e09 \u516b\u5341\u56db \u516b\u5341\u4e94 \u516b\u5341\u516d \u516b\u5341\u4e03 \u516b\u5341\u516b \u516b\u5341\u4e5d \u4e5d\u5341 \u4e5d\u5341\u4e00 \u4e5d\u5341\u4e8c \u4e5d\u5341\u4e09 \u4e5d\u5341\u56db \u4e5d\u5341\u4e94 \u4e5d\u5341\u516d \u4e5d\u5341\u4e03 \u4e5d\u5341\u516b \u4e5d\u5341\u4e5d" + ::msgcat::mcset zh LOCALE_DATE_FORMAT "\u516c\u5143%Y\u5e74%B%Od\u65e5" + ::msgcat::mcset zh LOCALE_TIME_FORMAT "%OH\u65f6%OM\u5206%OS\u79d2" + ::msgcat::mcset zh LOCALE_DATE_TIME_FORMAT "%A %Y\u5e74%B%Od\u65e5%OH\u65f6%OM\u5206%OS\u79d2 %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/zh_cn.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/zh_cn.msg new file mode 100644 index 0000000000000000000000000000000000000000..d62ce77500921c2a33ae0a6e899e51bf30bff462 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/zh_cn.msg @@ -0,0 +1,7 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset zh_CN DATE_FORMAT "%Y-%m-%e" + ::msgcat::mcset zh_CN TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset zh_CN TIME_FORMAT_12 "%P%I\u65f6%M\u5206%S\u79d2" + ::msgcat::mcset zh_CN DATE_TIME_FORMAT "%Y-%m-%e %k:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/zh_hk.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/zh_hk.msg new file mode 100644 index 0000000000000000000000000000000000000000..badb1dd32bff8ff90f4091728d472fc118a17f7f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/zh_hk.msg @@ -0,0 +1,28 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset zh_HK DAYS_OF_WEEK_ABBREV [list \ + "\u65e5"\ + "\u4e00"\ + "\u4e8c"\ + "\u4e09"\ + "\u56db"\ + "\u4e94"\ + "\u516d"] + ::msgcat::mcset zh_HK MONTHS_ABBREV [list \ + "1\u6708"\ + "2\u6708"\ + "3\u6708"\ + "4\u6708"\ + "5\u6708"\ + "6\u6708"\ + "7\u6708"\ + "8\u6708"\ + "9\u6708"\ + "10\u6708"\ + "11\u6708"\ + "12\u6708"\ + ""] + ::msgcat::mcset zh_HK DATE_FORMAT "%Y\u5e74%m\u6708%e\u65e5" + ::msgcat::mcset zh_HK TIME_FORMAT_12 "%P%I:%M:%S" + ::msgcat::mcset zh_HK DATE_TIME_FORMAT "%Y\u5e74%m\u6708%e\u65e5 %P%I:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/zh_sg.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/zh_sg.msg new file mode 100644 index 0000000000000000000000000000000000000000..a2f3e39d8d21ea13661da244af688157bd46773b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/zh_sg.msg @@ -0,0 +1,8 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset zh_SG AM "\u4e0a\u5348" + ::msgcat::mcset zh_SG PM "\u4e2d\u5348" + ::msgcat::mcset zh_SG DATE_FORMAT "%d %B %Y" + ::msgcat::mcset zh_SG TIME_FORMAT_12 "%P %I:%M:%S" + ::msgcat::mcset zh_SG DATE_TIME_FORMAT "%d %B %Y %P %I:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/zh_tw.msg b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/zh_tw.msg new file mode 100644 index 0000000000000000000000000000000000000000..e0796b11d5fc283a20e26ebff97a94269ff7e36f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/msgs/zh_tw.msg @@ -0,0 +1,8 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset zh_TW BCE "\u6c11\u570b\u524d" + ::msgcat::mcset zh_TW CE "\u6c11\u570b" + ::msgcat::mcset zh_TW DATE_FORMAT "%Y/%m/%e" + ::msgcat::mcset zh_TW TIME_FORMAT_12 "%P %I:%M:%S" + ::msgcat::mcset zh_TW DATE_TIME_FORMAT "%Y/%m/%e %P %I:%M:%S %z" +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/opt0.4/optparse.tcl b/physworld_p1_20261018/envs/p1/lib/tcl8.6/opt0.4/optparse.tcl new file mode 100644 index 0000000000000000000000000000000000000000..454b9239598b262f3fc8eb19d82a8da83ed6b42c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/opt0.4/optparse.tcl @@ -0,0 +1,1072 @@ +# optparse.tcl -- +# +# (private) Option parsing package +# Primarily used internally by the safe:: code. +# +# WARNING: This code will go away in a future release +# of Tcl. It is NOT supported and you should not rely +# on it. If your code does rely on this package you +# may directly incorporate this code into your application. + +package require Tcl 8.5- +# When this version number changes, update the pkgIndex.tcl file +# and the install directory in the Makefiles. +package provide opt 0.4.8 + +namespace eval ::tcl { + + # Exported APIs + namespace export OptKeyRegister OptKeyDelete OptKeyError OptKeyParse \ + OptProc OptProcArgGiven OptParse \ + Lempty Lget \ + Lassign Lvarpop Lvarpop1 Lvarset Lvarincr \ + SetMax SetMin + + +################# Example of use / 'user documentation' ################### + + proc OptCreateTestProc {} { + + # Defines ::tcl::OptParseTest as a test proc with parsed arguments + # (can't be defined before the code below is loaded (before "OptProc")) + + # Every OptProc give usage information on "procname -help". + # Try "tcl::OptParseTest -help" and "tcl::OptParseTest -a" and + # then other arguments. + # + # example of 'valid' call: + # ::tcl::OptParseTest save -4 -pr 23 -libsok SybTcl\ + # -nostatics false ch1 + OptProc OptParseTest { + {subcommand -choice {save print} "sub command"} + {arg1 3 "some number"} + {-aflag} + {-intflag 7} + {-weirdflag "help string"} + {-noStatics "Not ok to load static packages"} + {-nestedloading1 true "OK to load into nested children"} + {-nestedloading2 -boolean true "OK to load into nested children"} + {-libsOK -choice {Tk SybTcl} + "List of packages that can be loaded"} + {-precision -int 12 "Number of digits of precision"} + {-intval 7 "An integer"} + {-scale -float 1.0 "Scale factor"} + {-zoom 1.0 "Zoom factor"} + {-arbitrary foobar "Arbitrary string"} + {-random -string 12 "Random string"} + {-listval -list {} "List value"} + {-blahflag -blah abc "Funny type"} + {arg2 -boolean "a boolean"} + {arg3 -choice "ch1 ch2"} + {?optarg? -list {} "optional argument"} + } { + foreach v [info locals] { + puts stderr [format "%14s : %s" $v [set $v]] + } + } + } + +################### No User serviceable part below ! ############### + + # Array storing the parsed descriptions + variable OptDesc + array set OptDesc {} + # Next potentially free key id (numeric) + variable OptDescN 0 + +# Inside algorithm/mechanism description: +# (not for the faint hearted ;-) +# +# The argument description is parsed into a "program tree" +# It is called a "program" because it is the program used by +# the state machine interpreter that use that program to +# actually parse the arguments at run time. +# +# The general structure of a "program" is +# notation (pseudo bnf like) +# name :== definition defines "name" as being "definition" +# { x y z } means list of x, y, and z +# x* means x repeated 0 or more time +# x+ means "x x*" +# x? means optionally x +# x | y means x or y +# "cccc" means the literal string +# +# program :== { programCounter programStep* } +# +# programStep :== program | singleStep +# +# programCounter :== {"P" integer+ } +# +# singleStep :== { instruction parameters* } +# +# instruction :== single element list +# +# (the difference between singleStep and program is that \ +# llength [lindex $program 0] >= 2 +# while +# llength [lindex $singleStep 0] == 1 +# ) +# +# And for this application: +# +# singleStep :== { instruction varname {hasBeenSet currentValue} type +# typeArgs help } +# instruction :== "flags" | "value" +# type :== knowType | anyword +# knowType :== "string" | "int" | "boolean" | "boolflag" | "float" +# | "choice" +# +# for type "choice" typeArgs is a list of possible choices, the first one +# is the default value. for all other types the typeArgs is the default value +# +# a "boolflag" is the type for a flag whose presence or absence, without +# additional arguments means respectively true or false (default flag type). +# +# programCounter is the index in the list of the currently processed +# programStep (thus starting at 1 (0 is {"P" prgCounterValue}). +# If it is a list it points toward each currently selected programStep. +# (like for "flags", as they are optional, form a set and programStep). + +# Performance/Implementation issues +# --------------------------------- +# We use tcl lists instead of arrays because with tcl8.0 +# they should start to be much faster. +# But this code use a lot of helper procs (like Lvarset) +# which are quite slow and would be helpfully optimized +# for instance by being written in C. Also our struture +# is complex and there is maybe some places where the +# string rep might be calculated at great exense. to be checked. + +# +# Parse a given description and saves it here under the given key +# generate a unused keyid if not given +# +proc ::tcl::OptKeyRegister {desc {key ""}} { + variable OptDesc + variable OptDescN + if {[string equal $key ""]} { + # in case a key given to us as a parameter was a number + while {[info exists OptDesc($OptDescN)]} {incr OptDescN} + set key $OptDescN + incr OptDescN + } + # program counter + set program [list [list "P" 1]] + + # are we processing flags (which makes a single program step) + set inflags 0 + + set state {} + + # flag used to detect that we just have a single (flags set) subprogram. + set empty 1 + + foreach item $desc { + if {$state == "args"} { + # more items after 'args'... + return -code error "'args' special argument must be the last one" + } + set res [OptNormalizeOne $item] + set state [lindex $res 0] + if {$inflags} { + if {$state == "flags"} { + # add to 'subprogram' + lappend flagsprg $res + } else { + # put in the flags + # structure for flag programs items is a list of + # {subprgcounter {prg flag 1} {prg flag 2} {...}} + lappend program $flagsprg + # put the other regular stuff + lappend program $res + set inflags 0 + set empty 0 + } + } else { + if {$state == "flags"} { + set inflags 1 + # sub program counter + first sub program + set flagsprg [list [list "P" 1] $res] + } else { + lappend program $res + set empty 0 + } + } + } + if {$inflags} { + if {$empty} { + # We just have the subprogram, optimize and remove + # unneeded level: + set program $flagsprg + } else { + lappend program $flagsprg + } + } + + set OptDesc($key) $program + + return $key +} + +# +# Free the storage for that given key +# +proc ::tcl::OptKeyDelete {key} { + variable OptDesc + unset OptDesc($key) +} + + # Get the parsed description stored under the given key. + proc OptKeyGetDesc {descKey} { + variable OptDesc + if {![info exists OptDesc($descKey)]} { + return -code error "Unknown option description key \"$descKey\"" + } + set OptDesc($descKey) + } + +# Parse entry point for ppl who don't want to register with a key, +# for instance because the description changes dynamically. +# (otherwise one should really use OptKeyRegister once + OptKeyParse +# as it is way faster or simply OptProc which does it all) +# Assign a temporary key, call OptKeyParse and then free the storage +proc ::tcl::OptParse {desc arglist} { + set tempkey [OptKeyRegister $desc] + set ret [catch {uplevel 1 [list ::tcl::OptKeyParse $tempkey $arglist]} res] + OptKeyDelete $tempkey + return -code $ret $res +} + +# Helper function, replacement for proc that both +# register the description under a key which is the name of the proc +# (and thus unique to that code) +# and add a first line to the code to call the OptKeyParse proc +# Stores the list of variables that have been actually given by the user +# (the other will be sets to their default value) +# into local variable named "Args". +proc ::tcl::OptProc {name desc body} { + set namespace [uplevel 1 [list ::namespace current]] + if {[string match "::*" $name] || [string equal $namespace "::"]} { + # absolute name or global namespace, name is the key + set key $name + } else { + # we are relative to some non top level namespace: + set key "${namespace}::${name}" + } + OptKeyRegister $desc $key + uplevel 1 [list ::proc $name args "set Args \[::tcl::OptKeyParse $key \$args\]\n$body"] + return $key +} +# Check that a argument has been given +# assumes that "OptProc" has been used as it will check in "Args" list +proc ::tcl::OptProcArgGiven {argname} { + upvar Args alist + expr {[lsearch $alist $argname] >=0} +} + + ####### + # Programs/Descriptions manipulation + + # Return the instruction word/list of a given step/(sub)program + proc OptInstr {lst} { + lindex $lst 0 + } + # Is a (sub) program or a plain instruction ? + proc OptIsPrg {lst} { + expr {[llength [OptInstr $lst]]>=2} + } + # Is this instruction a program counter or a real instr + proc OptIsCounter {item} { + expr {[lindex $item 0]=="P"} + } + # Current program counter (2nd word of first word) + proc OptGetPrgCounter {lst} { + Lget $lst {0 1} + } + # Current program counter (2nd word of first word) + proc OptSetPrgCounter {lstName newValue} { + upvar $lstName lst + set lst [lreplace $lst 0 0 [concat "P" $newValue]] + } + # returns a list of currently selected items. + proc OptSelection {lst} { + set res {} + foreach idx [lrange [lindex $lst 0] 1 end] { + lappend res [Lget $lst $idx] + } + return $res + } + + # Advance to next description + proc OptNextDesc {descName} { + uplevel 1 [list Lvarincr $descName {0 1}] + } + + # Get the current description, eventually descend + proc OptCurDesc {descriptions} { + lindex $descriptions [OptGetPrgCounter $descriptions] + } + # get the current description, eventually descend + # through sub programs as needed. + proc OptCurDescFinal {descriptions} { + set item [OptCurDesc $descriptions] + # Descend untill we get the actual item and not a sub program + while {[OptIsPrg $item]} { + set item [OptCurDesc $item] + } + return $item + } + # Current final instruction adress + proc OptCurAddr {descriptions {start {}}} { + set adress [OptGetPrgCounter $descriptions] + lappend start $adress + set item [lindex $descriptions $adress] + if {[OptIsPrg $item]} { + return [OptCurAddr $item $start] + } else { + return $start + } + } + # Set the value field of the current instruction + proc OptCurSetValue {descriptionsName value} { + upvar $descriptionsName descriptions + # get the current item full adress + set adress [OptCurAddr $descriptions] + # use the 3th field of the item (see OptValue / OptNewInst) + lappend adress 2 + Lvarset descriptions $adress [list 1 $value] + # ^hasBeenSet flag + } + + # empty state means done/paste the end of the program + proc OptState {item} { + lindex $item 0 + } + + # current state + proc OptCurState {descriptions} { + OptState [OptCurDesc $descriptions] + } + + ####### + # Arguments manipulation + + # Returns the argument that has to be processed now + proc OptCurrentArg {lst} { + lindex $lst 0 + } + # Advance to next argument + proc OptNextArg {argsName} { + uplevel 1 [list Lvarpop1 $argsName] + } + ####### + + + + + + # Loop over all descriptions, calling OptDoOne which will + # eventually eat all the arguments. + proc OptDoAll {descriptionsName argumentsName} { + upvar $descriptionsName descriptions + upvar $argumentsName arguments +# puts "entered DoAll" + # Nb: the places where "state" can be set are tricky to figure + # because DoOne sets the state to flagsValue and return -continue + # when needed... + set state [OptCurState $descriptions] + # We'll exit the loop in "OptDoOne" or when state is empty. + while 1 { + set curitem [OptCurDesc $descriptions] + # Do subprograms if needed, call ourselves on the sub branch + while {[OptIsPrg $curitem]} { + OptDoAll curitem arguments +# puts "done DoAll sub" + # Insert back the results in current tree + Lvarset1nc descriptions [OptGetPrgCounter $descriptions]\ + $curitem + OptNextDesc descriptions + set curitem [OptCurDesc $descriptions] + set state [OptCurState $descriptions] + } +# puts "state = \"$state\" - arguments=($arguments)" + if {[Lempty $state]} { + # Nothing left to do, we are done in this branch: + break + } + # The following statement can make us terminate/continue + # as it use return -code {break, continue, return and error} + # codes + OptDoOne descriptions state arguments + # If we are here, no special return code where issued, + # we'll step to next instruction : +# puts "new state = \"$state\"" + OptNextDesc descriptions + set state [OptCurState $descriptions] + } + } + + # Process one step for the state machine, + # eventually consuming the current argument. + proc OptDoOne {descriptionsName stateName argumentsName} { + upvar $argumentsName arguments + upvar $descriptionsName descriptions + upvar $stateName state + + # the special state/instruction "args" eats all + # the remaining args (if any) + if {($state == "args")} { + if {![Lempty $arguments]} { + # If there is no additional arguments, leave the default value + # in. + OptCurSetValue descriptions $arguments + set arguments {} + } +# puts "breaking out ('args' state: consuming every reminding args)" + return -code break + } + + if {[Lempty $arguments]} { + if {$state == "flags"} { + # no argument and no flags : we're done +# puts "returning to previous (sub)prg (no more args)" + return -code return + } elseif {$state == "optValue"} { + set state next; # not used, for debug only + # go to next state + return + } else { + return -code error [OptMissingValue $descriptions] + } + } else { + set arg [OptCurrentArg $arguments] + } + + switch $state { + flags { + # A non-dash argument terminates the options, as does -- + + # Still a flag ? + if {![OptIsFlag $arg]} { + # don't consume the argument, return to previous prg + return -code return + } + # consume the flag + OptNextArg arguments + if {[string equal "--" $arg]} { + # return from 'flags' state + return -code return + } + + set hits [OptHits descriptions $arg] + if {$hits > 1} { + return -code error [OptAmbigous $descriptions $arg] + } elseif {$hits == 0} { + return -code error [OptFlagUsage $descriptions $arg] + } + set item [OptCurDesc $descriptions] + if {[OptNeedValue $item]} { + # we need a value, next state is + set state flagValue + } else { + OptCurSetValue descriptions 1 + } + # continue + return -code continue + } + flagValue - + value { + set item [OptCurDesc $descriptions] + # Test the values against their required type + if {[catch {OptCheckType $arg\ + [OptType $item] [OptTypeArgs $item]} val]} { + return -code error [OptBadValue $item $arg $val] + } + # consume the value + OptNextArg arguments + # set the value + OptCurSetValue descriptions $val + # go to next state + if {$state == "flagValue"} { + set state flags + return -code continue + } else { + set state next; # not used, for debug only + return ; # will go on next step + } + } + optValue { + set item [OptCurDesc $descriptions] + # Test the values against their required type + if {![catch {OptCheckType $arg\ + [OptType $item] [OptTypeArgs $item]} val]} { + # right type, so : + # consume the value + OptNextArg arguments + # set the value + OptCurSetValue descriptions $val + } + # go to next state + set state next; # not used, for debug only + return ; # will go on next step + } + } + # If we reach this point: an unknown + # state as been entered ! + return -code error "Bug! unknown state in DoOne \"$state\"\ + (prg counter [OptGetPrgCounter $descriptions]:\ + [OptCurDesc $descriptions])" + } + +# Parse the options given the key to previously registered description +# and arguments list +proc ::tcl::OptKeyParse {descKey arglist} { + + set desc [OptKeyGetDesc $descKey] + + # make sure -help always give usage + if {[string equal -nocase "-help" $arglist]} { + return -code error [OptError "Usage information:" $desc 1] + } + + OptDoAll desc arglist + + if {![Lempty $arglist]} { + return -code error [OptTooManyArgs $desc $arglist] + } + + # Analyse the result + # Walk through the tree: + OptTreeVars $desc "#[expr {[info level]-1}]" +} + + # determine string length for nice tabulated output + proc OptTreeVars {desc level {vnamesLst {}}} { + foreach item $desc { + if {[OptIsCounter $item]} continue + if {[OptIsPrg $item]} { + set vnamesLst [OptTreeVars $item $level $vnamesLst] + } else { + set vname [OptVarName $item] + upvar $level $vname var + if {[OptHasBeenSet $item]} { +# puts "adding $vname" + # lets use the input name for the returned list + # it is more usefull, for instance you can check that + # no flags at all was given with expr + # {![string match "*-*" $Args]} + lappend vnamesLst [OptName $item] + set var [OptValue $item] + } else { + set var [OptDefaultValue $item] + } + } + } + return $vnamesLst + } + + +# Check the type of a value +# and emit an error if arg is not of the correct type +# otherwise returns the canonical value of that arg (ie 0/1 for booleans) +proc ::tcl::OptCheckType {arg type {typeArgs ""}} { +# puts "checking '$arg' against '$type' ($typeArgs)" + + # only types "any", "choice", and numbers can have leading "-" + + switch -exact -- $type { + int { + if {![string is integer -strict $arg]} { + error "not an integer" + } + return $arg + } + float { + return [expr {double($arg)}] + } + script - + list { + # if llength fail : malformed list + if {[llength $arg]==0 && [OptIsFlag $arg]} { + error "no values with leading -" + } + return $arg + } + boolean { + if {![string is boolean -strict $arg]} { + error "non canonic boolean" + } + # convert true/false because expr/if is broken with "!,... + return [expr {$arg ? 1 : 0}] + } + choice { + if {$arg ni $typeArgs} { + error "invalid choice" + } + return $arg + } + any { + return $arg + } + string - + default { + if {[OptIsFlag $arg]} { + error "no values with leading -" + } + return $arg + } + } + return neverReached +} + + # internal utilities + + # returns the number of flags matching the given arg + # sets the (local) prg counter to the list of matches + proc OptHits {descName arg} { + upvar $descName desc + set hits 0 + set hitems {} + set i 1 + + set larg [string tolower $arg] + set len [string length $larg] + set last [expr {$len-1}] + + foreach item [lrange $desc 1 end] { + set flag [OptName $item] + # lets try to match case insensitively + # (string length ought to be cheap) + set lflag [string tolower $flag] + if {$len == [string length $lflag]} { + if {[string equal $larg $lflag]} { + # Exact match case + OptSetPrgCounter desc $i + return 1 + } + } elseif {[string equal $larg [string range $lflag 0 $last]]} { + lappend hitems $i + incr hits + } + incr i + } + if {$hits} { + OptSetPrgCounter desc $hitems + } + return $hits + } + + # Extract fields from the list structure: + + proc OptName {item} { + lindex $item 1 + } + proc OptHasBeenSet {item} { + Lget $item {2 0} + } + proc OptValue {item} { + Lget $item {2 1} + } + + proc OptIsFlag {name} { + string match "-*" $name + } + proc OptIsOpt {name} { + string match {\?*} $name + } + proc OptVarName {item} { + set name [OptName $item] + if {[OptIsFlag $name]} { + return [string range $name 1 end] + } elseif {[OptIsOpt $name]} { + return [string trim $name "?"] + } else { + return $name + } + } + proc OptType {item} { + lindex $item 3 + } + proc OptTypeArgs {item} { + lindex $item 4 + } + proc OptHelp {item} { + lindex $item 5 + } + proc OptNeedValue {item} { + expr {![string equal [OptType $item] boolflag]} + } + proc OptDefaultValue {item} { + set val [OptTypeArgs $item] + switch -exact -- [OptType $item] { + choice {return [lindex $val 0]} + boolean - + boolflag { + # convert back false/true to 0/1 because expr !$bool + # is broken.. + if {$val} { + return 1 + } else { + return 0 + } + } + } + return $val + } + + # Description format error helper + proc OptOptUsage {item {what ""}} { + return -code error "invalid description format$what: $item\n\ + should be a list of {varname|-flagname ?-type? ?defaultvalue?\ + ?helpstring?}" + } + + + # Generate a canonical form single instruction + proc OptNewInst {state varname type typeArgs help} { + list $state $varname [list 0 {}] $type $typeArgs $help + # ^ ^ + # | | + # hasBeenSet=+ +=currentValue + } + + # Translate one item to canonical form + proc OptNormalizeOne {item} { + set lg [Lassign $item varname arg1 arg2 arg3] +# puts "called optnormalizeone '$item' v=($varname), lg=$lg" + set isflag [OptIsFlag $varname] + set isopt [OptIsOpt $varname] + if {$isflag} { + set state "flags" + } elseif {$isopt} { + set state "optValue" + } elseif {![string equal $varname "args"]} { + set state "value" + } else { + set state "args" + } + + # apply 'smart' 'fuzzy' logic to try to make + # description writer's life easy, and our's difficult : + # let's guess the missing arguments :-) + + switch $lg { + 1 { + if {$isflag} { + return [OptNewInst $state $varname boolflag false ""] + } else { + return [OptNewInst $state $varname any "" ""] + } + } + 2 { + # varname default + # varname help + set type [OptGuessType $arg1] + if {[string equal $type "string"]} { + if {$isflag} { + set type boolflag + set def false + } else { + set type any + set def "" + } + set help $arg1 + } else { + set help "" + set def $arg1 + } + return [OptNewInst $state $varname $type $def $help] + } + 3 { + # varname type value + # varname value comment + + if {[regexp {^-(.+)$} $arg1 x type]} { + # flags/optValue as they are optional, need a "value", + # on the contrary, for a variable (non optional), + # default value is pointless, 'cept for choices : + if {$isflag || $isopt || ($type == "choice")} { + return [OptNewInst $state $varname $type $arg2 ""] + } else { + return [OptNewInst $state $varname $type "" $arg2] + } + } else { + return [OptNewInst $state $varname\ + [OptGuessType $arg1] $arg1 $arg2] + } + } + 4 { + if {[regexp {^-(.+)$} $arg1 x type]} { + return [OptNewInst $state $varname $type $arg2 $arg3] + } else { + return -code error [OptOptUsage $item] + } + } + default { + return -code error [OptOptUsage $item] + } + } + } + + # Auto magic lazy type determination + proc OptGuessType {arg} { + if { $arg == "true" || $arg == "false" } { + return boolean + } + if {[string is integer -strict $arg]} { + return int + } + if {[string is double -strict $arg]} { + return float + } + return string + } + + # Error messages front ends + + proc OptAmbigous {desc arg} { + OptError "ambigous option \"$arg\", choose from:" [OptSelection $desc] + } + proc OptFlagUsage {desc arg} { + OptError "bad flag \"$arg\", must be one of" $desc + } + proc OptTooManyArgs {desc arguments} { + OptError "too many arguments (unexpected argument(s): $arguments),\ + usage:"\ + $desc 1 + } + proc OptParamType {item} { + if {[OptIsFlag $item]} { + return "flag" + } else { + return "parameter" + } + } + proc OptBadValue {item arg {err {}}} { +# puts "bad val err = \"$err\"" + OptError "bad value \"$arg\" for [OptParamType $item]"\ + [list $item] + } + proc OptMissingValue {descriptions} { +# set item [OptCurDescFinal $descriptions] + set item [OptCurDesc $descriptions] + OptError "no value given for [OptParamType $item] \"[OptName $item]\"\ + (use -help for full usage) :"\ + [list $item] + } + +proc ::tcl::OptKeyError {prefix descKey {header 0}} { + OptError $prefix [OptKeyGetDesc $descKey] $header +} + + # determine string length for nice tabulated output + proc OptLengths {desc nlName tlName dlName} { + upvar $nlName nl + upvar $tlName tl + upvar $dlName dl + foreach item $desc { + if {[OptIsCounter $item]} continue + if {[OptIsPrg $item]} { + OptLengths $item nl tl dl + } else { + SetMax nl [string length [OptName $item]] + SetMax tl [string length [OptType $item]] + set dv [OptTypeArgs $item] + if {[OptState $item] != "header"} { + set dv "($dv)" + } + set l [string length $dv] + # limit the space allocated to potentially big "choices" + if {([OptType $item] != "choice") || ($l<=12)} { + SetMax dl $l + } else { + if {![info exists dl]} { + set dl 0 + } + } + } + } + } + # output the tree + proc OptTree {desc nl tl dl} { + set res "" + foreach item $desc { + if {[OptIsCounter $item]} continue + if {[OptIsPrg $item]} { + append res [OptTree $item $nl $tl $dl] + } else { + set dv [OptTypeArgs $item] + if {[OptState $item] != "header"} { + set dv "($dv)" + } + append res [string trimright [format "\n %-*s %-*s %-*s %s" \ + $nl [OptName $item] $tl [OptType $item] \ + $dl $dv [OptHelp $item]]] + } + } + return $res + } + +# Give nice usage string +proc ::tcl::OptError {prefix desc {header 0}} { + # determine length + if {$header} { + # add faked instruction + set h [list [OptNewInst header Var/FlagName Type Value Help]] + lappend h [OptNewInst header ------------ ---- ----- ----] + lappend h [OptNewInst header {(-help} "" "" {gives this help)}] + set desc [concat $h $desc] + } + OptLengths $desc nl tl dl + # actually output + return "$prefix[OptTree $desc $nl $tl $dl]" +} + + +################ General Utility functions ####################### + +# +# List utility functions +# Naming convention: +# "Lvarxxx" take the list VARiable name as argument +# "Lxxxx" take the list value as argument +# (which is not costly with Tcl8 objects system +# as it's still a reference and not a copy of the values) +# + +# Is that list empty ? +proc ::tcl::Lempty {list} { + expr {[llength $list]==0} +} + +# Gets the value of one leaf of a lists tree +proc ::tcl::Lget {list indexLst} { + if {[llength $indexLst] <= 1} { + return [lindex $list $indexLst] + } + Lget [lindex $list [lindex $indexLst 0]] [lrange $indexLst 1 end] +} +# Sets the value of one leaf of a lists tree +# (we use the version that does not create the elements because +# it would be even slower... needs to be written in C !) +# (nb: there is a non trivial recursive problem with indexes 0, +# which appear because there is no difference between a list +# of 1 element and 1 element alone : [list "a"] == "a" while +# it should be {a} and [listp a] should be 0 while [listp {a b}] would be 1 +# and [listp "a b"] maybe 0. listp does not exist either...) +proc ::tcl::Lvarset {listName indexLst newValue} { + upvar $listName list + if {[llength $indexLst] <= 1} { + Lvarset1nc list $indexLst $newValue + } else { + set idx [lindex $indexLst 0] + set targetList [lindex $list $idx] + # reduce refcount on targetList (not really usefull now, + # could be with optimizing compiler) +# Lvarset1 list $idx {} + # recursively replace in targetList + Lvarset targetList [lrange $indexLst 1 end] $newValue + # put updated sub list back in the tree + Lvarset1nc list $idx $targetList + } +} +# Set one cell to a value, eventually create all the needed elements +# (on level-1 of lists) +variable emptyList {} +proc ::tcl::Lvarset1 {listName index newValue} { + upvar $listName list + if {$index < 0} {return -code error "invalid negative index"} + set lg [llength $list] + if {$index >= $lg} { + variable emptyList + for {set i $lg} {$i<$index} {incr i} { + lappend list $emptyList + } + lappend list $newValue + } else { + set list [lreplace $list $index $index $newValue] + } +} +# same as Lvarset1 but no bound checking / creation +proc ::tcl::Lvarset1nc {listName index newValue} { + upvar $listName list + set list [lreplace $list $index $index $newValue] +} +# Increments the value of one leaf of a lists tree +# (which must exists) +proc ::tcl::Lvarincr {listName indexLst {howMuch 1}} { + upvar $listName list + if {[llength $indexLst] <= 1} { + Lvarincr1 list $indexLst $howMuch + } else { + set idx [lindex $indexLst 0] + set targetList [lindex $list $idx] + # reduce refcount on targetList + Lvarset1nc list $idx {} + # recursively replace in targetList + Lvarincr targetList [lrange $indexLst 1 end] $howMuch + # put updated sub list back in the tree + Lvarset1nc list $idx $targetList + } +} +# Increments the value of one cell of a list +proc ::tcl::Lvarincr1 {listName index {howMuch 1}} { + upvar $listName list + set newValue [expr {[lindex $list $index]+$howMuch}] + set list [lreplace $list $index $index $newValue] + return $newValue +} +# Removes the first element of a list +# and returns the new list value +proc ::tcl::Lvarpop1 {listName} { + upvar $listName list + set list [lrange $list 1 end] +} +# Same but returns the removed element +# (Like the tclX version) +proc ::tcl::Lvarpop {listName} { + upvar $listName list + set el [lindex $list 0] + set list [lrange $list 1 end] + return $el +} +# Assign list elements to variables and return the length of the list +proc ::tcl::Lassign {list args} { + # faster than direct blown foreach (which does not byte compile) + set i 0 + set lg [llength $list] + foreach vname $args { + if {$i>=$lg} break + uplevel 1 [list ::set $vname [lindex $list $i]] + incr i + } + return $lg +} + +# Misc utilities + +# Set the varname to value if value is greater than varname's current value +# or if varname is undefined +proc ::tcl::SetMax {varname value} { + upvar 1 $varname var + if {![info exists var] || $value > $var} { + set var $value + } +} + +# Set the varname to value if value is smaller than varname's current value +# or if varname is undefined +proc ::tcl::SetMin {varname value} { + upvar 1 $varname var + if {![info exists var] || $value < $var} { + set var $value + } +} + + + # everything loaded fine, lets create the test proc: + # OptCreateTestProc + # Don't need the create temp proc anymore: + # rename OptCreateTestProc {} +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/opt0.4/pkgIndex.tcl b/physworld_p1_20261018/envs/p1/lib/tcl8.6/opt0.4/pkgIndex.tcl new file mode 100644 index 0000000000000000000000000000000000000000..23e118cc509b4639c618cda68a42d6f926a1752f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/opt0.4/pkgIndex.tcl @@ -0,0 +1,12 @@ +# Tcl package index file, version 1.1 +# This file is generated by the "pkg_mkIndex -direct" command +# and sourced either when an application starts up or +# by a "package unknown" script. It invokes the +# "package ifneeded" command to set up package-related +# information so that packages will be loaded automatically +# in response to "package require" commands. When this +# script is sourced, the variable $dir must contain the +# full path name of this file's directory. + +if {![package vsatisfies [package provide Tcl] 8.5-]} {return} +package ifneeded opt 0.4.8 [list source [file join $dir optparse.tcl]] diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/package.tcl b/physworld_p1_20261018/envs/p1/lib/tcl8.6/package.tcl new file mode 100644 index 0000000000000000000000000000000000000000..4a7334679f1bcf6629c968eafd8f0d0bd8b5c72c --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/package.tcl @@ -0,0 +1,751 @@ +# package.tcl -- +# +# utility procs formerly in init.tcl which can be loaded on demand +# for package management. +# +# Copyright (c) 1991-1993 The Regents of the University of California. +# Copyright (c) 1994-1998 Sun Microsystems, Inc. +# +# See the file "license.terms" for information on usage and redistribution +# of this file, and for a DISCLAIMER OF ALL WARRANTIES. +# + +namespace eval tcl::Pkg {} + +# ::tcl::Pkg::CompareExtension -- +# +# Used internally by pkg_mkIndex to compare the extension of a file to a given +# extension. On Windows, it uses a case-insensitive comparison because the +# file system can be file insensitive. +# +# Arguments: +# fileName name of a file whose extension is compared +# ext (optional) The extension to compare against; you must +# provide the starting dot. +# Defaults to [info sharedlibextension] +# +# Results: +# Returns 1 if the extension matches, 0 otherwise + +proc tcl::Pkg::CompareExtension {fileName {ext {}}} { + global tcl_platform + if {$ext eq ""} {set ext [info sharedlibextension]} + if {$tcl_platform(platform) eq "windows"} { + return [string equal -nocase [file extension $fileName] $ext] + } else { + # Some unices add trailing numbers after the .so, so + # we could have something like '.so.1.2'. + set root $fileName + while {1} { + set currExt [file extension $root] + if {$currExt eq $ext} { + return 1 + } + + # The current extension does not match; if it is not a numeric + # value, quit, as we are only looking to ignore version number + # extensions. Otherwise we might return 1 in this case: + # tcl::Pkg::CompareExtension foo.so.bar .so + # which should not match. + + if {![string is integer -strict [string range $currExt 1 end]]} { + return 0 + } + set root [file rootname $root] + } + } +} + +# pkg_mkIndex -- +# This procedure creates a package index in a given directory. The package +# index consists of a "pkgIndex.tcl" file whose contents are a Tcl script that +# sets up package information with "package require" commands. The commands +# describe all of the packages defined by the files given as arguments. +# +# Arguments: +# -direct (optional) If this flag is present, the generated +# code in pkgMkIndex.tcl will cause the package to be +# loaded when "package require" is executed, rather +# than lazily when the first reference to an exported +# procedure in the package is made. +# -verbose (optional) Verbose output; the name of each file that +# was successfully rocessed is printed out. Additionally, +# if processing of a file failed a message is printed. +# -load pat (optional) Preload any packages whose names match +# the pattern. Used to handle DLLs that depend on +# other packages during their Init procedure. +# dir - Name of the directory in which to create the index. +# args - Any number of additional arguments, each giving +# a glob pattern that matches the names of one or +# more shared libraries or Tcl script files in +# dir. + +proc pkg_mkIndex {args} { + set usage {"pkg_mkIndex ?-direct? ?-lazy? ?-load pattern? ?-verbose? ?--? dir ?pattern ...?"} + + set argCount [llength $args] + if {$argCount < 1} { + return -code error "wrong # args: should be\n$usage" + } + + set more "" + set direct 1 + set doVerbose 0 + set loadPat "" + for {set idx 0} {$idx < $argCount} {incr idx} { + set flag [lindex $args $idx] + switch -glob -- $flag { + -- { + # done with the flags + incr idx + break + } + -verbose { + set doVerbose 1 + } + -lazy { + set direct 0 + append more " -lazy" + } + -direct { + append more " -direct" + } + -load { + incr idx + set loadPat [lindex $args $idx] + append more " -load $loadPat" + } + -* { + return -code error "unknown flag $flag: should be\n$usage" + } + default { + # done with the flags + break + } + } + } + + set dir [lindex $args $idx] + set patternList [lrange $args [expr {$idx + 1}] end] + if {![llength $patternList]} { + set patternList [list "*.tcl" "*[info sharedlibextension]"] + } + + try { + set fileList [glob -directory $dir -tails -types {r f} -- \ + {*}$patternList] + } on error {msg opt} { + return -options $opt $msg + } + foreach file $fileList { + # For each file, figure out what commands and packages it provides. + # To do this, create a child interpreter, load the file into the + # interpreter, and get a list of the new commands and packages that + # are defined. + + if {$file eq "pkgIndex.tcl"} { + continue + } + + set c [interp create] + + # Load into the child any packages currently loaded in the parent + # interpreter that match the -load pattern. + + if {$loadPat ne ""} { + if {$doVerbose} { + tclLog "currently loaded packages: '[info loaded]'" + tclLog "trying to load all packages matching $loadPat" + } + if {![llength [info loaded]]} { + tclLog "warning: no packages are currently loaded, nothing" + tclLog "can possibly match '$loadPat'" + } + } + foreach pkg [info loaded] { + if {![string match -nocase $loadPat [lindex $pkg 1]]} { + continue + } + if {$doVerbose} { + tclLog "package [lindex $pkg 1] matches '$loadPat'" + } + try { + load [lindex $pkg 0] [lindex $pkg 1] $c + } on error err { + if {$doVerbose} { + tclLog "warning: load [lindex $pkg 0]\ + [lindex $pkg 1]\nfailed with: $err" + } + } on ok {} { + if {$doVerbose} { + tclLog "loaded [lindex $pkg 0] [lindex $pkg 1]" + } + } + if {[lindex $pkg 1] eq "Tk"} { + # Withdraw . if Tk was loaded, to avoid showing a window. + $c eval [list wm withdraw .] + } + } + + $c eval { + # Stub out the package command so packages can require other + # packages. + + rename package __package_orig + proc package {what args} { + switch -- $what { + require { + return; # Ignore transitive requires + } + default { + __package_orig $what {*}$args + } + } + } + proc tclPkgUnknown args {} + package unknown tclPkgUnknown + + # Stub out the unknown command so package can call into each other + # during their initialilzation. + + proc unknown {args} {} + + # Stub out the auto_import mechanism + + proc auto_import {args} {} + + # reserve the ::tcl namespace for support procs and temporary + # variables. This might make it awkward to generate a + # pkgIndex.tcl file for the ::tcl namespace. + + namespace eval ::tcl { + variable dir ;# Current directory being processed + variable file ;# Current file being processed + variable direct ;# -direct flag value + variable x ;# Loop variable + variable debug ;# For debugging + variable type ;# "load" or "source", for -direct + variable namespaces ;# Existing namespaces (e.g., ::tcl) + variable packages ;# Existing packages (e.g., Tcl) + variable origCmds ;# Existing commands + variable newCmds ;# Newly created commands + variable newPkgs {} ;# Newly created packages + } + } + + $c eval [list set ::tcl::dir $dir] + $c eval [list set ::tcl::file $file] + $c eval [list set ::tcl::direct $direct] + + # Download needed procedures into the child because we've just deleted + # the unknown procedure. This doesn't handle procedures with default + # arguments. + + foreach p {::tcl::Pkg::CompareExtension} { + $c eval [list namespace eval [namespace qualifiers $p] {}] + $c eval [list proc $p [info args $p] [info body $p]] + } + + try { + $c eval { + set ::tcl::debug "loading or sourcing" + + # we need to track command defined by each package even in the + # -direct case, because they are needed internally by the + # "partial pkgIndex.tcl" step above. + + proc ::tcl::GetAllNamespaces {{root ::}} { + set list $root + foreach ns [namespace children $root] { + lappend list {*}[::tcl::GetAllNamespaces $ns] + } + return $list + } + + # init the list of existing namespaces, packages, commands + + foreach ::tcl::x [::tcl::GetAllNamespaces] { + set ::tcl::namespaces($::tcl::x) 1 + } + foreach ::tcl::x [package names] { + if {[package provide $::tcl::x] ne ""} { + set ::tcl::packages($::tcl::x) 1 + } + } + set ::tcl::origCmds [info commands] + + # Try to load the file if it has the shared library extension, + # otherwise source it. It's important not to try to load + # files that aren't shared libraries, because on some systems + # (like SunOS) the loader will abort the whole application + # when it gets an error. + + if {[::tcl::Pkg::CompareExtension $::tcl::file [info sharedlibextension]]} { + # The "file join ." command below is necessary. Without + # it, if the file name has no \'s and we're on UNIX, the + # load command will invoke the LD_LIBRARY_PATH search + # mechanism, which could cause the wrong file to be used. + + set ::tcl::debug loading + load [file join $::tcl::dir $::tcl::file] + set ::tcl::type load + } else { + set ::tcl::debug sourcing + source [file join $::tcl::dir $::tcl::file] + set ::tcl::type source + } + + # As a performance optimization, if we are creating direct + # load packages, don't bother figuring out the set of commands + # created by the new packages. We only need that list for + # setting up the autoloading used in the non-direct case. + if {!$::tcl::direct} { + # See what new namespaces appeared, and import commands + # from them. Only exported commands go into the index. + + foreach ::tcl::x [::tcl::GetAllNamespaces] { + if {![info exists ::tcl::namespaces($::tcl::x)]} { + namespace import -force ${::tcl::x}::* + } + + # Figure out what commands appeared + + foreach ::tcl::x [info commands] { + set ::tcl::newCmds($::tcl::x) 1 + } + foreach ::tcl::x $::tcl::origCmds { + unset -nocomplain ::tcl::newCmds($::tcl::x) + } + foreach ::tcl::x [array names ::tcl::newCmds] { + # determine which namespace a command comes from + + set ::tcl::abs [namespace origin $::tcl::x] + + # special case so that global names have no + # leading ::, this is required by the unknown + # command + + set ::tcl::abs \ + [lindex [auto_qualify $::tcl::abs ::] 0] + + if {$::tcl::x ne $::tcl::abs} { + # Name changed during qualification + + set ::tcl::newCmds($::tcl::abs) 1 + unset ::tcl::newCmds($::tcl::x) + } + } + } + } + + # Look through the packages that appeared, and if there is a + # version provided, then record it + + foreach ::tcl::x [package names] { + if {[package provide $::tcl::x] ne "" + && ![info exists ::tcl::packages($::tcl::x)]} { + lappend ::tcl::newPkgs \ + [list $::tcl::x [package provide $::tcl::x]] + } + } + } + } on error msg { + set what [$c eval set ::tcl::debug] + if {$doVerbose} { + tclLog "warning: error while $what $file: $msg" + } + } on ok {} { + set what [$c eval set ::tcl::debug] + if {$doVerbose} { + tclLog "successful $what of $file" + } + set type [$c eval set ::tcl::type] + set cmds [lsort [$c eval array names ::tcl::newCmds]] + set pkgs [$c eval set ::tcl::newPkgs] + if {$doVerbose} { + if {!$direct} { + tclLog "commands provided were $cmds" + } + tclLog "packages provided were $pkgs" + } + if {[llength $pkgs] > 1} { + tclLog "warning: \"$file\" provides more than one package ($pkgs)" + } + foreach pkg $pkgs { + # cmds is empty/not used in the direct case + lappend files($pkg) [list $file $type $cmds] + } + + if {$doVerbose} { + tclLog "processed $file" + } + } + interp delete $c + } + + append index "# Tcl package index file, version 1.1\n" + append index "# This file is generated by the \"pkg_mkIndex$more\" command\n" + append index "# and sourced either when an application starts up or\n" + append index "# by a \"package unknown\" script. It invokes the\n" + append index "# \"package ifneeded\" command to set up package-related\n" + append index "# information so that packages will be loaded automatically\n" + append index "# in response to \"package require\" commands. When this\n" + append index "# script is sourced, the variable \$dir must contain the\n" + append index "# full path name of this file's directory.\n" + + foreach pkg [lsort [array names files]] { + set cmd {} + lassign $pkg name version + lappend cmd ::tcl::Pkg::Create -name $name -version $version + foreach spec [lsort -index 0 $files($pkg)] { + foreach {file type procs} $spec { + if {$direct} { + set procs {} + } + lappend cmd "-$type" [list $file $procs] + } + } + append index "\n[eval $cmd]" + } + + set f [open [file join $dir pkgIndex.tcl] w] + puts $f $index + close $f +} + +# tclPkgSetup -- +# This is a utility procedure use by pkgIndex.tcl files. It is invoked as +# part of a "package ifneeded" script. It calls "package provide" to indicate +# that a package is available, then sets entries in the auto_index array so +# that the package's files will be auto-loaded when the commands are used. +# +# Arguments: +# dir - Directory containing all the files for this package. +# pkg - Name of the package (no version number). +# version - Version number for the package, such as 2.1.3. +# files - List of files that constitute the package. Each +# element is a sub-list with three elements. The first +# is the name of a file relative to $dir, the second is +# "load" or "source", indicating whether the file is a +# loadable binary or a script to source, and the third +# is a list of commands defined by this file. + +proc tclPkgSetup {dir pkg version files} { + global auto_index + + package provide $pkg $version + foreach fileInfo $files { + set f [lindex $fileInfo 0] + set type [lindex $fileInfo 1] + foreach cmd [lindex $fileInfo 2] { + if {$type eq "load"} { + set auto_index($cmd) [list load [file join $dir $f] $pkg] + } else { + set auto_index($cmd) [list source [file join $dir $f]] + } + } + } +} + +# tclPkgUnknown -- +# This procedure provides the default for the "package unknown" function. It +# is invoked when a package that's needed can't be found. It scans the +# auto_path directories and their immediate children looking for pkgIndex.tcl +# files and sources any such files that are found to setup the package +# database. As it searches, it will recognize changes to the auto_path and +# scan any new directories. +# +# Arguments: +# name - Name of desired package. Not used. +# version - Version of desired package. Not used. +# exact - Either "-exact" or omitted. Not used. + +proc tclPkgUnknown {name args} { + global auto_path env + + if {![info exists auto_path]} { + return + } + # Cache the auto_path, because it may change while we run through the + # first set of pkgIndex.tcl files + set old_path [set use_path $auto_path] + while {[llength $use_path]} { + set dir [lindex $use_path end] + + # Make sure we only scan each directory one time. + if {[info exists tclSeenPath($dir)]} { + set use_path [lrange $use_path 0 end-1] + continue + } + set tclSeenPath($dir) 1 + + # Get the pkgIndex.tcl files in subdirectories of auto_path directories. + # - Safe Base interpreters have a restricted "glob" command that + # works in this case. + # - The "catch" was essential when there was no safe glob and every + # call in a safe interp failed; it is retained only for corner + # cases in which the eventual call to glob returns an error. + catch { + foreach file [glob -directory $dir -join -nocomplain \ + * pkgIndex.tcl] { + set dir [file dirname $file] + if {![info exists procdDirs($dir)]} { + try { + source $file + } trap {POSIX EACCES} {} { + # $file was not readable; silently ignore + continue + } on error msg { + tclLog "error reading package index file $file: $msg" + } on ok {} { + set procdDirs($dir) 1 + } + } + } + } + set dir [lindex $use_path end] + if {![info exists procdDirs($dir)]} { + set file [file join $dir pkgIndex.tcl] + # safe interps usually don't have "file exists", + if {([interp issafe] || [file exists $file])} { + try { + source $file + } trap {POSIX EACCES} {} { + # $file was not readable; silently ignore + continue + } on error msg { + tclLog "error reading package index file $file: $msg" + } on ok {} { + set procdDirs($dir) 1 + } + } + } + + set use_path [lrange $use_path 0 end-1] + + # Check whether any of the index scripts we [source]d above set a new + # value for $::auto_path. If so, then find any new directories on the + # $::auto_path, and lappend them to the $use_path we are working from. + # This gives index scripts the (arguably unwise) power to expand the + # index script search path while the search is in progress. + set index 0 + if {[llength $old_path] == [llength $auto_path]} { + foreach dir $auto_path old $old_path { + if {$dir ne $old} { + # This entry in $::auto_path has changed. + break + } + incr index + } + } + + # $index now points to the first element of $auto_path that has + # changed, or the beginning if $auto_path has changed length Scan the + # new elements of $auto_path for directories to add to $use_path. + # Don't add directories we've already seen, or ones already on the + # $use_path. + foreach dir [lrange $auto_path $index end] { + if {![info exists tclSeenPath($dir)] && ($dir ni $use_path)} { + lappend use_path $dir + } + } + set old_path $auto_path + } +} + +# tcl::MacOSXPkgUnknown -- +# This procedure extends the "package unknown" function for MacOSX. It scans +# the Resources/Scripts directories of the immediate children of the auto_path +# directories for pkgIndex files. +# +# Arguments: +# original - original [package unknown] procedure +# name - Name of desired package. Not used. +# version - Version of desired package. Not used. +# exact - Either "-exact" or omitted. Not used. + +proc tcl::MacOSXPkgUnknown {original name args} { + # First do the cross-platform default search + uplevel 1 $original [linsert $args 0 $name] + + # Now do MacOSX specific searching + global auto_path + + if {![info exists auto_path]} { + return + } + # Cache the auto_path, because it may change while we run through the + # first set of pkgIndex.tcl files + set old_path [set use_path $auto_path] + while {[llength $use_path]} { + set dir [lindex $use_path end] + + # Make sure we only scan each directory one time. + if {[info exists tclSeenPath($dir)]} { + set use_path [lrange $use_path 0 end-1] + continue + } + set tclSeenPath($dir) 1 + + # get the pkgIndex files out of the subdirectories + # Safe interpreters do not use tcl::MacOSXPkgUnknown - see init.tcl. + foreach file [glob -directory $dir -join -nocomplain \ + * Resources Scripts pkgIndex.tcl] { + set dir [file dirname $file] + if {![info exists procdDirs($dir)]} { + try { + source $file + } trap {POSIX EACCES} {} { + # $file was not readable; silently ignore + continue + } on error msg { + tclLog "error reading package index file $file: $msg" + } on ok {} { + set procdDirs($dir) 1 + } + } + } + set use_path [lrange $use_path 0 end-1] + + # Check whether any of the index scripts we [source]d above set a new + # value for $::auto_path. If so, then find any new directories on the + # $::auto_path, and lappend them to the $use_path we are working from. + # This gives index scripts the (arguably unwise) power to expand the + # index script search path while the search is in progress. + set index 0 + if {[llength $old_path] == [llength $auto_path]} { + foreach dir $auto_path old $old_path { + if {$dir ne $old} { + # This entry in $::auto_path has changed. + break + } + incr index + } + } + + # $index now points to the first element of $auto_path that has + # changed, or the beginning if $auto_path has changed length Scan the + # new elements of $auto_path for directories to add to $use_path. + # Don't add directories we've already seen, or ones already on the + # $use_path. + foreach dir [lrange $auto_path $index end] { + if {![info exists tclSeenPath($dir)] && ($dir ni $use_path)} { + lappend use_path $dir + } + } + set old_path $auto_path + } +} + +# ::tcl::Pkg::Create -- +# +# Given a package specification generate a "package ifneeded" statement +# for the package, suitable for inclusion in a pkgIndex.tcl file. +# +# Arguments: +# args arguments used by the Create function: +# -name packageName +# -version packageVersion +# -load {filename ?{procs}?} +# ... +# -source {filename ?{procs}?} +# ... +# +# Any number of -load and -source parameters may be +# specified, so long as there is at least one -load or +# -source parameter. If the procs component of a module +# specifier is left off, that module will be set up for +# direct loading; otherwise, it will be set up for lazy +# loading. If both -source and -load are specified, the +# -load'ed files will be loaded first, followed by the +# -source'd files. +# +# Results: +# An appropriate "package ifneeded" statement for the package. + +proc ::tcl::Pkg::Create {args} { + append err(usage) "[lindex [info level 0] 0] " + append err(usage) "-name packageName -version packageVersion" + append err(usage) "?-load {filename ?{procs}?}? ... " + append err(usage) "?-source {filename ?{procs}?}? ..." + + set err(wrongNumArgs) "wrong # args: should be \"$err(usage)\"" + set err(valueMissing) "value for \"%s\" missing: should be \"$err(usage)\"" + set err(unknownOpt) "unknown option \"%s\": should be \"$err(usage)\"" + set err(noLoadOrSource) "at least one of -load and -source must be given" + + # process arguments + set len [llength $args] + if {$len < 6} { + error $err(wrongNumArgs) + } + + # Initialize parameters + array set opts {-name {} -version {} -source {} -load {}} + + # process parameters + for {set i 0} {$i < $len} {incr i} { + set flag [lindex $args $i] + incr i + switch -glob -- $flag { + "-name" - + "-version" { + if {$i >= $len} { + error [format $err(valueMissing) $flag] + } + set opts($flag) [lindex $args $i] + } + "-source" - + "-load" { + if {$i >= $len} { + error [format $err(valueMissing) $flag] + } + lappend opts($flag) [lindex $args $i] + } + default { + error [format $err(unknownOpt) [lindex $args $i]] + } + } + } + + # Validate the parameters + if {![llength $opts(-name)]} { + error [format $err(valueMissing) "-name"] + } + if {![llength $opts(-version)]} { + error [format $err(valueMissing) "-version"] + } + + if {!([llength $opts(-source)] || [llength $opts(-load)])} { + error $err(noLoadOrSource) + } + + # OK, now everything is good. Generate the package ifneeded statment. + set cmdline "package ifneeded $opts(-name) $opts(-version) " + + set cmdList {} + set lazyFileList {} + + # Handle -load and -source specs + foreach key {load source} { + foreach filespec $opts(-$key) { + lassign $filespec filename proclist + + if { [llength $proclist] == 0 } { + set cmd "\[list $key \[file join \$dir [list $filename]\]\]" + lappend cmdList $cmd + } else { + lappend lazyFileList [list $filename $key $proclist] + } + } + } + + if {[llength $lazyFileList]} { + lappend cmdList "\[list tclPkgSetup \$dir $opts(-name)\ + $opts(-version) [list $lazyFileList]\]" + } + append cmdline [join $cmdList "\\n"] + return $cmdline +} + +interp alias {} ::pkg::create {} ::tcl::Pkg::Create diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/parray.tcl b/physworld_p1_20261018/envs/p1/lib/tcl8.6/parray.tcl new file mode 100644 index 0000000000000000000000000000000000000000..a9c2cb15a9bd81339f2d91535b3758bb4785023e --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/parray.tcl @@ -0,0 +1,28 @@ +# parray: +# Print the contents of a global array on stdout. +# +# Copyright (c) 1991-1993 The Regents of the University of California. +# Copyright (c) 1994 Sun Microsystems, Inc. +# +# See the file "license.terms" for information on usage and redistribution +# of this file, and for a DISCLAIMER OF ALL WARRANTIES. +# + +proc parray {a {pattern *}} { + upvar 1 $a array + if {![array exists array]} { + return -code error "\"$a\" isn't an array" + } + set maxl 0 + set names [lsort [array names array $pattern]] + foreach name $names { + if {[string length $name] > $maxl} { + set maxl [string length $name] + } + } + set maxl [expr {$maxl + [string length $a] + 2}] + foreach name $names { + set nameString [format %s(%s) $a $name] + puts stdout [format "%-*s = %s" $maxl $nameString $array($name)] + } +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/safe.tcl b/physworld_p1_20261018/envs/p1/lib/tcl8.6/safe.tcl new file mode 100644 index 0000000000000000000000000000000000000000..59e4c90bb7e0cc38bf8bf4d43001160115f1247b --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/safe.tcl @@ -0,0 +1,1289 @@ +# safe.tcl -- +# +# This file provide a safe loading/sourcing mechanism for safe interpreters. +# It implements a virtual path mechanism to hide the real pathnames from the +# child. It runs in a parent interpreter and sets up data structure and +# aliases that will be invoked when used from a child interpreter. +# +# See the safe.n man page for details. +# +# Copyright (c) 1996-1997 Sun Microsystems, Inc. +# +# See the file "license.terms" for information on usage and redistribution of +# this file, and for a DISCLAIMER OF ALL WARRANTIES. + +# +# The implementation is based on namespaces. These naming conventions are +# followed: +# Private procs starts with uppercase. +# Public procs are exported and starts with lowercase +# + +# Needed utilities package +package require opt 0.4.8 + +# Create the safe namespace +namespace eval ::safe { + # Exported API: + namespace export interpCreate interpInit interpConfigure interpDelete \ + interpAddToAccessPath interpFindInAccessPath setLogCmd +} + +# Helper function to resolve the dual way of specifying staticsok (either +# by -noStatics or -statics 0) +proc ::safe::InterpStatics {} { + foreach v {Args statics noStatics} { + upvar $v $v + } + set flag [::tcl::OptProcArgGiven -noStatics] + if {$flag && (!$noStatics == !$statics) + && ([::tcl::OptProcArgGiven -statics])} { + return -code error\ + "conflicting values given for -statics and -noStatics" + } + if {$flag} { + return [expr {!$noStatics}] + } else { + return $statics + } +} + +# Helper function to resolve the dual way of specifying nested loading +# (either by -nestedLoadOk or -nested 1) +proc ::safe::InterpNested {} { + foreach v {Args nested nestedLoadOk} { + upvar $v $v + } + set flag [::tcl::OptProcArgGiven -nestedLoadOk] + # note that the test here is the opposite of the "InterpStatics" one + # (it is not -noNested... because of the wanted default value) + if {$flag && (!$nestedLoadOk != !$nested) + && ([::tcl::OptProcArgGiven -nested])} { + return -code error\ + "conflicting values given for -nested and -nestedLoadOk" + } + if {$flag} { + # another difference with "InterpStatics" + return $nestedLoadOk + } else { + return $nested + } +} + +#### +# +# API entry points that needs argument parsing : +# +#### + +# Interface/entry point function and front end for "Create" +proc ::safe::interpCreate {args} { + set Args [::tcl::OptKeyParse ::safe::interpCreate $args] + RejectExcessColons $slave + InterpCreate $slave $accessPath \ + [InterpStatics] [InterpNested] $deleteHook +} + +proc ::safe::interpInit {args} { + set Args [::tcl::OptKeyParse ::safe::interpIC $args] + if {![::interp exists $slave]} { + return -code error "\"$slave\" is not an interpreter" + } + RejectExcessColons $slave + InterpInit $slave $accessPath \ + [InterpStatics] [InterpNested] $deleteHook +} + +# Check that the given child is "one of us" +proc ::safe::CheckInterp {child} { + namespace upvar ::safe [VarName $child] state + if {![info exists state] || ![::interp exists $child]} { + return -code error \ + "\"$child\" is not an interpreter managed by ::safe::" + } +} + +# Interface/entry point function and front end for "Configure". This code +# is awfully pedestrian because it would need more coupling and support +# between the way we store the configuration values in safe::interp's and +# the Opt package. Obviously we would like an OptConfigure to avoid +# duplicating all this code everywhere. +# -> TODO (the app should share or access easily the program/value stored +# by opt) + +# This is even more complicated by the boolean flags with no values that +# we had the bad idea to support for the sake of user simplicity in +# create/init but which makes life hard in configure... +# So this will be hopefully written and some integrated with opt1.0 +# (hopefully for tcl8.1 ?) +proc ::safe::interpConfigure {args} { + switch [llength $args] { + 1 { + # If we have exactly 1 argument the semantic is to return all + # the current configuration. We still call OptKeyParse though + # we know that "child" is our given argument because it also + # checks for the "-help" option. + set Args [::tcl::OptKeyParse ::safe::interpIC $args] + CheckInterp $slave + namespace upvar ::safe [VarName $slave] state + + return [join [list \ + [list -accessPath $state(access_path)] \ + [list -statics $state(staticsok)] \ + [list -nested $state(nestedok)] \ + [list -deleteHook $state(cleanupHook)]]] + } + 2 { + # If we have exactly 2 arguments the semantic is a "configure + # get" + lassign $args slave arg + + # get the flag sub program (we 'know' about Opt's internal + # representation of data) + set desc [lindex [::tcl::OptKeyGetDesc ::safe::interpIC] 2] + set hits [::tcl::OptHits desc $arg] + if {$hits > 1} { + return -code error [::tcl::OptAmbigous $desc $arg] + } elseif {$hits == 0} { + return -code error [::tcl::OptFlagUsage $desc $arg] + } + CheckInterp $slave + namespace upvar ::safe [VarName $slave] state + + set item [::tcl::OptCurDesc $desc] + set name [::tcl::OptName $item] + switch -exact -- $name { + -accessPath { + return [list -accessPath $state(access_path)] + } + -statics { + return [list -statics $state(staticsok)] + } + -nested { + return [list -nested $state(nestedok)] + } + -deleteHook { + return [list -deleteHook $state(cleanupHook)] + } + -noStatics { + # it is most probably a set in fact but we would need + # then to jump to the set part and it is not *sure* + # that it is a set action that the user want, so force + # it to use the unambigous -statics ?value? instead: + return -code error\ + "ambigous query (get or set -noStatics ?)\ + use -statics instead" + } + -nestedLoadOk { + return -code error\ + "ambigous query (get or set -nestedLoadOk ?)\ + use -nested instead" + } + default { + return -code error "unknown flag $name (bug)" + } + } + } + default { + # Otherwise we want to parse the arguments like init and + # create did + set Args [::tcl::OptKeyParse ::safe::interpIC $args] + CheckInterp $slave + namespace upvar ::safe [VarName $slave] state + + # Get the current (and not the default) values of whatever has + # not been given: + if {![::tcl::OptProcArgGiven -accessPath]} { + set doreset 0 + set accessPath $state(access_path) + } else { + set doreset 1 + } + if { + ![::tcl::OptProcArgGiven -statics] + && ![::tcl::OptProcArgGiven -noStatics] + } then { + set statics $state(staticsok) + } else { + set statics [InterpStatics] + } + if { + [::tcl::OptProcArgGiven -nested] || + [::tcl::OptProcArgGiven -nestedLoadOk] + } then { + set nested [InterpNested] + } else { + set nested $state(nestedok) + } + if {![::tcl::OptProcArgGiven -deleteHook]} { + set deleteHook $state(cleanupHook) + } + # we can now reconfigure : + InterpSetConfig $slave $accessPath $statics $nested $deleteHook + # auto_reset the child (to completly synch the new access_path) + if {$doreset} { + if {[catch {::interp eval $slave {auto_reset}} msg]} { + Log $slave "auto_reset failed: $msg" + } else { + Log $slave "successful auto_reset" NOTICE + } + + # Sync the paths used to search for Tcl modules. + ::interp eval $slave {tcl::tm::path remove {*}[tcl::tm::list]} + if {[llength $state(tm_path_slave)] > 0} { + ::interp eval $slave [list \ + ::tcl::tm::add {*}[lreverse $state(tm_path_slave)]] + } + + # Remove stale "package ifneeded" data for non-loaded packages. + # - Not for loaded packages, because "package forget" erases + # data from "package provide" as well as "package ifneeded". + # - This is OK because the script cannot reload any version of + # the package unless it first does "package forget". + foreach pkg [::interp eval $slave {package names}] { + if {[::interp eval $slave [list package provide $pkg]] eq ""} { + ::interp eval $slave [list package forget $pkg] + } + } + } + return + } + } +} + +#### +# +# Functions that actually implements the exported APIs +# +#### + +# +# safe::InterpCreate : doing the real job +# +# This procedure creates a safe interpreter and initializes it with the safe +# base aliases. +# NB: child name must be simple alphanumeric string, no spaces, no (), no +# {},... {because the state array is stored as part of the name} +# +# Returns the child name. +# +# Optional Arguments : +# + child name : if empty, generated name will be used +# + access_path: path list controlling where load/source can occur, +# if empty: the parent auto_path will be used. +# + staticsok : flag, if 0 :no static package can be loaded (load {} Xxx) +# if 1 :static packages are ok. +# + nestedok: flag, if 0 :no loading to sub-sub interps (load xx xx sub) +# if 1 : multiple levels are ok. + +# use the full name and no indent so auto_mkIndex can find us +proc ::safe::InterpCreate { + child + access_path + staticsok + nestedok + deletehook + } { + # Create the child. + # If evaluated in ::safe, the interpreter command for foo is ::foo; + # but for foo::bar is safe::foo::bar. So evaluate in :: instead. + if {$child ne ""} { + namespace eval :: [list ::interp create -safe $child] + } else { + # empty argument: generate child name + set child [::interp create -safe] + } + Log $child "Created" NOTICE + + # Initialize it. (returns child name) + InterpInit $child $access_path $staticsok $nestedok $deletehook +} + +# +# InterpSetConfig (was setAccessPath) : +# Sets up child virtual auto_path and corresponding structure within +# the parent. Also sets the tcl_library in the child to be the first +# directory in the path. +# NB: If you change the path after the child has been initialized you +# probably need to call "auto_reset" in the child in order that it gets +# the right auto_index() array values. + +proc ::safe::InterpSetConfig {child access_path staticsok nestedok deletehook} { + global auto_path + + # determine and store the access path if empty + if {$access_path eq ""} { + set access_path $auto_path + + # Make sure that tcl_library is in auto_path and at the first + # position (needed by setAccessPath) + set where [lsearch -exact $access_path [info library]] + if {$where < 0} { + # not found, add it. + set access_path [linsert $access_path 0 [info library]] + Log $child "tcl_library was not in auto_path,\ + added it to slave's access_path" NOTICE + } elseif {$where != 0} { + # not first, move it first + set access_path [linsert \ + [lreplace $access_path $where $where] \ + 0 [info library]] + Log $child "tcl_libray was not in first in auto_path,\ + moved it to front of slave's access_path" NOTICE + } + + # Add 1st level sub dirs (will searched by auto loading from tcl + # code in the child using glob and thus fail, so we add them here + # so by default it works the same). + set access_path [AddSubDirs $access_path] + } + + Log $child "Setting accessPath=($access_path) staticsok=$staticsok\ + nestedok=$nestedok deletehook=($deletehook)" NOTICE + + namespace upvar ::safe [VarName $child] state + + # clear old autopath if it existed + # build new one + # Extend the access list with the paths used to look for Tcl Modules. + # We save the virtual form separately as well, as syncing it with the + # child has to be deferred until the necessary commands are present for + # setup. + + set norm_access_path {} + set slave_access_path {} + set map_access_path {} + set remap_access_path {} + set slave_tm_path {} + + set i 0 + foreach dir $access_path { + set token [PathToken $i] + lappend slave_access_path $token + lappend map_access_path $token $dir + lappend remap_access_path $dir $token + lappend norm_access_path [file normalize $dir] + incr i + } + + set morepaths [::tcl::tm::list] + set firstpass 1 + while {[llength $morepaths]} { + set addpaths $morepaths + set morepaths {} + + foreach dir $addpaths { + # Prevent the addition of dirs on the tm list to the + # result if they are already known. + if {[dict exists $remap_access_path $dir]} { + if {$firstpass} { + # $dir is in [::tcl::tm::list] and belongs in the slave_tm_path. + # Later passes handle subdirectories, which belong in the + # access path but not in the module path. + lappend slave_tm_path [dict get $remap_access_path $dir] + } + continue + } + + set token [PathToken $i] + lappend access_path $dir + lappend slave_access_path $token + lappend map_access_path $token $dir + lappend remap_access_path $dir $token + lappend norm_access_path [file normalize $dir] + if {$firstpass} { + # $dir is in [::tcl::tm::list] and belongs in the slave_tm_path. + # Later passes handle subdirectories, which belong in the + # access path but not in the module path. + lappend slave_tm_path $token + } + incr i + + # [Bug 2854929] + # Recursively find deeper paths which may contain + # modules. Required to handle modules with names like + # 'platform::shell', which translate into + # 'platform/shell-X.tm', i.e arbitrarily deep + # subdirectories. + lappend morepaths {*}[glob -nocomplain -directory $dir -type d *] + } + set firstpass 0 + } + + set state(access_path) $access_path + set state(access_path,map) $map_access_path + set state(access_path,remap) $remap_access_path + set state(access_path,norm) $norm_access_path + set state(access_path,slave) $slave_access_path + set state(tm_path_slave) $slave_tm_path + set state(staticsok) $staticsok + set state(nestedok) $nestedok + set state(cleanupHook) $deletehook + + SyncAccessPath $child + return +} + +# +# +# FindInAccessPath: +# Search for a real directory and returns its virtual Id (including the +# "$") +proc ::safe::interpFindInAccessPath {child path} { + CheckInterp $child + namespace upvar ::safe [VarName $child] state + + if {![dict exists $state(access_path,remap) $path]} { + return -code error "$path not found in access path" + } + + return [dict get $state(access_path,remap) $path] +} + +# +# addToAccessPath: +# add (if needed) a real directory to access path and return its +# virtual token (including the "$"). +proc ::safe::interpAddToAccessPath {child path} { + # first check if the directory is already in there + # (inlined interpFindInAccessPath). + CheckInterp $child + namespace upvar ::safe [VarName $child] state + + if {[dict exists $state(access_path,remap) $path]} { + return [dict get $state(access_path,remap) $path] + } + + # new one, add it: + set token [PathToken [llength $state(access_path)]] + + lappend state(access_path) $path + lappend state(access_path,slave) $token + lappend state(access_path,map) $token $path + lappend state(access_path,remap) $path $token + lappend state(access_path,norm) [file normalize $path] + + SyncAccessPath $child + return $token +} + +# This procedure applies the initializations to an already existing +# interpreter. It is useful when you want to install the safe base aliases +# into a preexisting safe interpreter. +proc ::safe::InterpInit { + child + access_path + staticsok + nestedok + deletehook + } { + # Configure will generate an access_path when access_path is empty. + InterpSetConfig $child $access_path $staticsok $nestedok $deletehook + + # NB we need to add [namespace current], aliases are always absolute + # paths. + + # These aliases let the child load files to define new commands + # This alias lets the child use the encoding names, convertfrom, + # convertto, and system, but not "encoding system " to set the + # system encoding. + # Handling Tcl Modules, we need a restricted form of Glob. + # This alias interposes on the 'exit' command and cleanly terminates + # the child. + + foreach {command alias} { + source AliasSource + load AliasLoad + encoding AliasEncoding + exit interpDelete + glob AliasGlob + } { + ::interp alias $child $command {} [namespace current]::$alias $child + } + + # This alias lets the child have access to a subset of the 'file' + # command functionality. + + ::interp expose $child file + foreach subcommand {dirname extension rootname tail} { + ::interp alias $child ::tcl::file::$subcommand {} \ + ::safe::AliasFileSubcommand $child $subcommand + } + foreach subcommand { + atime attributes copy delete executable exists isdirectory isfile + link lstat mtime mkdir nativename normalize owned readable readlink + rename size stat tempfile type volumes writable + } { + ::interp alias $child ::tcl::file::$subcommand {} \ + ::safe::BadSubcommand $child file $subcommand + } + + # Subcommands of info + foreach {subcommand alias} { + nameofexecutable AliasExeName + } { + ::interp alias $child ::tcl::info::$subcommand \ + {} [namespace current]::$alias $child + } + + # The allowed child variables already have been set by Tcl_MakeSafe(3) + + # Source init.tcl and tm.tcl into the child, to get auto_load and + # other procedures defined: + + if {[catch {::interp eval $child { + source [file join $tcl_library init.tcl] + }} msg opt]} { + Log $child "can't source init.tcl ($msg)" + return -options $opt "can't source init.tcl into slave $child ($msg)" + } + + if {[catch {::interp eval $child { + source [file join $tcl_library tm.tcl] + }} msg opt]} { + Log $child "can't source tm.tcl ($msg)" + return -options $opt "can't source tm.tcl into slave $child ($msg)" + } + + # Sync the paths used to search for Tcl modules. This can be done only + # now, after tm.tcl was loaded. + namespace upvar ::safe [VarName $child] state + if {[llength $state(tm_path_slave)] > 0} { + ::interp eval $child [list \ + ::tcl::tm::add {*}[lreverse $state(tm_path_slave)]] + } + return $child +} + +# Add (only if needed, avoid duplicates) 1 level of sub directories to an +# existing path list. Also removes non directories from the returned +# list. +proc ::safe::AddSubDirs {pathList} { + set res {} + foreach dir $pathList { + if {[file isdirectory $dir]} { + # check that we don't have it yet as a children of a previous + # dir + if {$dir ni $res} { + lappend res $dir + } + foreach sub [glob -directory $dir -nocomplain *] { + if {[file isdirectory $sub] && ($sub ni $res)} { + # new sub dir, add it ! + lappend res $sub + } + } + } + } + return $res +} + +# This procedure deletes a safe interpreter managed by Safe Tcl and cleans up +# associated state. +# - The command will also delete non-Safe-Base interpreters. +# - This is regrettable, but to avoid breaking existing code this should be +# amended at the next major revision by uncommenting "CheckInterp". + +proc ::safe::interpDelete {child} { + Log $child "About to delete" NOTICE + + # CheckInterp $child + namespace upvar ::safe [VarName $child] state + + # When an interpreter is deleted with [interp delete], any sub-interpreters + # are deleted automatically, but this leaves behind their data in the Safe + # Base. To clean up properly, we call safe::interpDelete recursively on each + # Safe Base sub-interpreter, so each one is deleted cleanly and not by + # the automatic mechanism built into [interp delete]. + foreach sub [interp children $child] { + if {[info exists ::safe::[VarName [list $child $sub]]]} { + ::safe::interpDelete [list $child $sub] + } + } + + # If the child has a cleanup hook registered, call it. Check the + # existance because we might be called to delete an interp which has + # not been registered with us at all + + if {[info exists state(cleanupHook)]} { + set hook $state(cleanupHook) + if {[llength $hook]} { + # remove the hook now, otherwise if the hook calls us somehow, + # we'll loop + unset state(cleanupHook) + try { + {*}$hook $child + } on error err { + Log $child "Delete hook error ($err)" + } + } + } + + # Discard the global array of state associated with the child, and + # delete the interpreter. + + if {[info exists state]} { + unset state + } + + # if we have been called twice, the interp might have been deleted + # already + if {[::interp exists $child]} { + ::interp delete $child + Log $child "Deleted" NOTICE + } + + return +} + +# Set (or get) the logging mecanism + +proc ::safe::setLogCmd {args} { + variable Log + set la [llength $args] + if {$la == 0} { + return $Log + } elseif {$la == 1} { + set Log [lindex $args 0] + } else { + set Log $args + } + + if {$Log eq ""} { + # Disable logging completely. Calls to it will be compiled out + # of all users. + proc ::safe::Log {args} {} + } else { + # Activate logging, define proper command. + + proc ::safe::Log {child msg {type ERROR}} { + variable Log + {*}$Log "$type for slave $child : $msg" + return + } + } +} + +# ------------------- END OF PUBLIC METHODS ------------ + +# +# Sets the child auto_path to the parent recorded value. Also sets +# tcl_library to the first token of the virtual path. +# +proc ::safe::SyncAccessPath {child} { + namespace upvar ::safe [VarName $child] state + + set slave_access_path $state(access_path,slave) + ::interp eval $child [list set auto_path $slave_access_path] + + Log $child "auto_path in $child has been set to $slave_access_path"\ + NOTICE + + # This code assumes that info library is the first element in the + # list of auto_path's. See -> InterpSetConfig for the code which + # ensures this condition. + + ::interp eval $child [list \ + set tcl_library [lindex $slave_access_path 0]] +} + +# Returns the virtual token for directory number N. +proc ::safe::PathToken {n} { + # We need to have a ":" in the token string so [file join] on the + # mac won't turn it into a relative path. + return "\$p(:$n:)" ;# Form tested by case 7.2 +} + +# +# translate virtual path into real path +# +proc ::safe::TranslatePath {child path} { + namespace upvar ::safe [VarName $child] state + + # somehow strip the namespaces 'functionality' out (the danger is that + # we would strip valid macintosh "../" queries... : + if {[string match "*::*" $path] || [string match "*..*" $path]} { + return -code error "invalid characters in path $path" + } + + # Use a cached map instead of computed local vars and subst. + + return [string map $state(access_path,map) $path] +} + +# file name control (limit access to files/resources that should be a +# valid tcl source file) +proc ::safe::CheckFileName {child file} { + # This used to limit what can be sourced to ".tcl" and forbid files + # with more than 1 dot and longer than 14 chars, but I changed that + # for 8.4 as a safe interp has enough internal protection already to + # allow sourcing anything. - hobbs + + if {![file exists $file]} { + # don't tell the file path + return -code error "no such file or directory" + } + + if {![file readable $file]} { + # don't tell the file path + return -code error "not readable" + } +} + +# AliasFileSubcommand handles selected subcommands of [file] in safe +# interpreters that are *almost* safe. In particular, it just acts to +# prevent discovery of what home directories exist. + +proc ::safe::AliasFileSubcommand {child subcommand name} { + if {[string match ~* $name]} { + set name ./$name + } + tailcall ::interp invokehidden $child tcl:file:$subcommand $name +} + +# AliasGlob is the target of the "glob" alias in safe interpreters. + +proc ::safe::AliasGlob {child args} { + Log $child "GLOB ! $args" NOTICE + set cmd {} + set at 0 + array set got { + -directory 0 + -nocomplain 0 + -join 0 + -tails 0 + -- 0 + } + + if {$::tcl_platform(platform) eq "windows"} { + set dirPartRE {^(.*)[\\/]([^\\/]*)$} + } else { + set dirPartRE {^(.*)/([^/]*)$} + } + + set dir {} + set virtualdir {} + + while {$at < [llength $args]} { + switch -glob -- [set opt [lindex $args $at]] { + -nocomplain - -- - -tails { + lappend cmd $opt + set got($opt) 1 + incr at + } + -join { + set got($opt) 1 + incr at + } + -types - -type { + lappend cmd -types [lindex $args [incr at]] + incr at + } + -directory { + if {$got($opt)} { + return -code error \ + {"-directory" cannot be used with "-path"} + } + set got($opt) 1 + set virtualdir [lindex $args [incr at]] + incr at + } + -* { + Log $child "Safe base rejecting glob option '$opt'" + return -code error "Safe base rejecting glob option '$opt'" + } + default { + break + } + } + if {$got(--)} break + } + + # Get the real path from the virtual one and check that the path is in the + # access path of that child. Done after basic argument processing so that + # we know if -nocomplain is set. + if {$got(-directory)} { + try { + set dir [TranslatePath $child $virtualdir] + DirInAccessPath $child $dir + } on error msg { + Log $child $msg + if {$got(-nocomplain)} return + return -code error "permission denied" + } + if {$got(--)} { + set cmd [linsert $cmd end-1 -directory $dir] + } else { + lappend cmd -directory $dir + } + } else { + # The code after this "if ... else" block would conspire to return with + # no results in this case, if it were allowed to proceed. Instead, + # return now and reduce the number of cases to be considered later. + Log $child {option -directory must be supplied} + if {$got(-nocomplain)} return + return -code error "permission denied" + } + + # Apply the -join semantics ourselves. + if {$got(-join)} { + set args [lreplace $args $at end [join [lrange $args $at end] "/"]] + } + + # Process the pattern arguments. If we've done a join there is only one + # pattern argument. + + set firstPattern [llength $cmd] + foreach opt [lrange $args $at end] { + if {![regexp $dirPartRE $opt -> thedir thefile]} { + set thedir . + # The *.tm search comes here. + } + # "Special" treatment for (joined) argument {*/pkgIndex.tcl}. + # Do the expansion of "*" here, and filter out any directories that are + # not in the access path. The outcome is to lappend to cmd a path of + # the form $virtualdir/subdir/pkgIndex.tcl for each subdirectory subdir, + # after removing any subdir that are not in the access path. + if {($thedir eq "*") && ($thefile eq "pkgIndex.tcl")} { + set mapped 0 + foreach d [glob -directory [TranslatePath $child $virtualdir] \ + -types d -tails *] { + catch { + DirInAccessPath $child \ + [TranslatePath $child [file join $virtualdir $d]] + lappend cmd [file join $d $thefile] + set mapped 1 + } + } + if {$mapped} continue + # Don't [continue] if */pkgIndex.tcl has no matches in the access + # path. The pattern will now receive the same treatment as a + # "non-special" pattern (and will fail because it includes a "*" in + # the directory name). + } + # Any directory pattern that is not an exact (i.e. non-glob) match to a + # directory in the access path will be rejected here. + # - Rejections include any directory pattern that has glob matching + # patterns "*", "?", backslashes, braces or square brackets, (UNLESS + # it corresponds to a genuine directory name AND that directory is in + # the access path). + # - The only "special matching characters" that remain in patterns for + # processing by glob are in the filename tail. + # - [file join $anything ~${foo}] is ~${foo}, which is not an exact + # match to any directory in the access path. Hence directory patterns + # that begin with "~" are rejected here. Tests safe-16.[5-8] check + # that "file join" remains as required and does not expand ~${foo}. + # - Bug [3529949] relates to unwanted expansion of ~${foo} and this is + # how the present code avoids the bug. All tests safe-16.* relate. + try { + DirInAccessPath $child [TranslatePath $child \ + [file join $virtualdir $thedir]] + } on error msg { + Log $child $msg + if {$got(-nocomplain)} continue + return -code error "permission denied" + } + lappend cmd $opt + } + + Log $child "GLOB = $cmd" NOTICE + + if {$got(-nocomplain) && [llength $cmd] eq $firstPattern} { + return + } + try { + # >>>>>>>>>> HERE'S THE CALL TO SAFE INTERP GLOB <<<<<<<<<< + # - Pattern arguments added to cmd have NOT been translated from tokens. + # Only the virtualdir is translated (to dir). + # - In the pkgIndex.tcl case, there is no "*" in the pattern arguments, + # which are a list of names each with tail pkgIndex.tcl. The purpose + # of the call to glob is to remove the names for which the file does + # not exist. + set entries [::interp invokehidden $child glob {*}$cmd] + } on error msg { + # This is the only place that a call with -nocomplain and no invalid + # "dash-options" can return an error. + Log $child $msg + return -code error "script error" + } + + Log $child "GLOB < $entries" NOTICE + + # Translate path back to what the child should see. + set res {} + set l [string length $dir] + foreach p $entries { + if {[string equal -length $l $dir $p]} { + set p [string replace $p 0 [expr {$l-1}] $virtualdir] + } + lappend res $p + } + + Log $child "GLOB > $res" NOTICE + return $res +} + +# AliasSource is the target of the "source" alias in safe interpreters. + +proc ::safe::AliasSource {child args} { + set argc [llength $args] + # Extended for handling of Tcl Modules to allow not only "source + # filename", but "source -encoding E filename" as well. + if {[lindex $args 0] eq "-encoding"} { + incr argc -2 + set encoding [lindex $args 1] + set at 2 + if {$encoding eq "identity"} { + Log $child "attempt to use the identity encoding" + return -code error "permission denied" + } + } else { + set at 0 + set encoding {} + } + if {$argc != 1} { + set msg "wrong # args: should be \"source ?-encoding E? fileName\"" + Log $child "$msg ($args)" + return -code error $msg + } + set file [lindex $args $at] + + # get the real path from the virtual one. + if {[catch { + set realfile [TranslatePath $child $file] + } msg]} { + Log $child $msg + return -code error "permission denied" + } + + # check that the path is in the access path of that child + if {[catch { + FileInAccessPath $child $realfile + } msg]} { + Log $child $msg + return -code error "permission denied" + } + + # Check that the filename exists and is readable. If it is not, deliver + # this -errorcode so that caller in tclPkgUnknown does not write a message + # to tclLog. Has no effect on other callers of ::source, which are in + # "package ifneeded" scripts. + if {[catch { + CheckFileName $child $realfile + } msg]} { + Log $child "$realfile:$msg" + return -code error -errorcode {POSIX EACCES} $msg + } + + # Passed all the tests, lets source it. Note that we do this all manually + # because we want to control [info script] in the child so information + # doesn't leak so much. [Bug 2913625] + set old [::interp eval $child {info script}] + set replacementMsg "script error" + set code [catch { + set f [open $realfile] + fconfigure $f -eofchar "\032 {}" + if {$encoding ne ""} { + fconfigure $f -encoding $encoding + } + set contents [read $f] + close $f + ::interp eval $child [list info script $file] + } msg opt] + if {$code == 0} { + set code [catch {::interp eval $child $contents} msg opt] + set replacementMsg $msg + } + catch {interp eval $child [list info script $old]} + # Note that all non-errors are fine result codes from [source], so we must + # take a little care to do it properly. [Bug 2923613] + if {$code == 1} { + Log $child $msg + return -code error $replacementMsg + } + return -code $code -options $opt $msg +} + +# AliasLoad is the target of the "load" alias in safe interpreters. + +proc ::safe::AliasLoad {child file args} { + set argc [llength $args] + if {$argc > 2} { + set msg "load error: too many arguments" + Log $child "$msg ($argc) {$file $args}" + return -code error $msg + } + + # package name (can be empty if file is not). + set package [lindex $args 0] + + namespace upvar ::safe [VarName $child] state + + # Determine where to load. load use a relative interp path and {} + # means self, so we can directly and safely use passed arg. + set target [lindex $args 1] + if {$target ne ""} { + # we will try to load into a sub sub interp; check that we want to + # authorize that. + if {!$state(nestedok)} { + Log $child "loading to a sub interp (nestedok)\ + disabled (trying to load $package to $target)" + return -code error "permission denied (nested load)" + } + } + + # Determine what kind of load is requested + if {$file eq ""} { + # static package loading + if {$package eq ""} { + set msg "load error: empty filename and no package name" + Log $child $msg + return -code error $msg + } + if {!$state(staticsok)} { + Log $child "static packages loading disabled\ + (trying to load $package to $target)" + return -code error "permission denied (static package)" + } + } else { + # file loading + + # get the real path from the virtual one. + try { + set file [TranslatePath $child $file] + } on error msg { + Log $child $msg + return -code error "permission denied" + } + + # check the translated path + try { + FileInAccessPath $child $file + } on error msg { + Log $child $msg + return -code error "permission denied (path)" + } + } + + try { + return [::interp invokehidden $child load $file $package $target] + } on error msg { + # Some packages return no error message. + set msg0 "load of binary library for package $package failed" + if {$msg eq {}} { + set msg $msg0 + } else { + set msg "$msg0: $msg" + } + Log $child $msg + return -code error $msg + } +} + +# FileInAccessPath raises an error if the file is not found in the list of +# directories contained in the (parent side recorded) child's access path. + +# the security here relies on "file dirname" answering the proper +# result... needs checking ? +proc ::safe::FileInAccessPath {child file} { + namespace upvar ::safe [VarName $child] state + set access_path $state(access_path) + + if {[file isdirectory $file]} { + return -code error "\"$file\": is a directory" + } + set parent [file dirname $file] + + # Normalize paths for comparison since lsearch knows nothing of + # potential pathname anomalies. + set norm_parent [file normalize $parent] + + namespace upvar ::safe [VarName $child] state + if {$norm_parent ni $state(access_path,norm)} { + return -code error "\"$file\": not in access_path" + } +} + +proc ::safe::DirInAccessPath {child dir} { + namespace upvar ::safe [VarName $child] state + set access_path $state(access_path) + + if {[file isfile $dir]} { + return -code error "\"$dir\": is a file" + } + + # Normalize paths for comparison since lsearch knows nothing of + # potential pathname anomalies. + set norm_dir [file normalize $dir] + + namespace upvar ::safe [VarName $child] state + if {$norm_dir ni $state(access_path,norm)} { + return -code error "\"$dir\": not in access_path" + } +} + +# This procedure is used to report an attempt to use an unsafe member of an +# ensemble command. + +proc ::safe::BadSubcommand {child command subcommand args} { + set msg "not allowed to invoke subcommand $subcommand of $command" + Log $child $msg + return -code error -errorcode {TCL SAFE SUBCOMMAND} $msg +} + +# AliasEncoding is the target of the "encoding" alias in safe interpreters. + +proc ::safe::AliasEncoding {child option args} { + # Note that [encoding dirs] is not supported in safe children at all + set subcommands {convertfrom convertto names system} + try { + set option [tcl::prefix match -error [list -level 1 -errorcode \ + [list TCL LOOKUP INDEX option $option]] $subcommands $option] + # Special case: [encoding system] ok, but [encoding system foo] not + if {$option eq "system" && [llength $args]} { + return -code error -errorcode {TCL WRONGARGS} \ + "wrong # args: should be \"encoding system\"" + } + } on error {msg options} { + Log $child $msg + return -options $options $msg + } + tailcall ::interp invokehidden $child encoding $option {*}$args +} + +# Various minor hiding of platform features. [Bug 2913625] + +proc ::safe::AliasExeName {child} { + return "" +} + +# ------------------------------------------------------------------------------ +# Using Interpreter Names with Namespace Qualifiers +# ------------------------------------------------------------------------------ +# (1) We wish to preserve compatibility with existing code, in which Safe Base +# interpreter names have no namespace qualifiers. +# (2) safe::interpCreate and the rest of the Safe Base previously could not +# accept namespace qualifiers in an interpreter name. +# (3) The interp command will accept namespace qualifiers in an interpreter +# name, but accepts distinct interpreters that will have the same command +# name (e.g. foo, ::foo, and :::foo) (bug 66c2e8c974). +# (4) To satisfy these constraints, Safe Base interpreter names will be fully +# qualified namespace names with no excess colons and with the leading "::" +# omitted. +# (5) Trailing "::" implies a namespace tail {}, which interp reads as {{}}. +# Reject such names. +# (6) We could: +# (a) EITHER reject usable but non-compliant names (e.g. excess colons) in +# interpCreate, interpInit; +# (b) OR accept such names and then translate to a compliant name in every +# command. +# The problem with (b) is that the user will expect to use the name with the +# interp command and will find that it is not recognised. +# E.g "interpCreate ::foo" creates interpreter "foo", and the user's name +# "::foo" works with all the Safe Base commands, but "interp eval ::foo" +# fails. +# So we choose (a). +# (7) The command +# namespace upvar ::safe S$child state +# becomes +# namespace upvar ::safe [VarName $child] state +# ------------------------------------------------------------------------------ + +proc ::safe::RejectExcessColons {child} { + set stripped [regsub -all -- {:::*} $child ::] + if {[string range $stripped end-1 end] eq {::}} { + return -code error {interpreter name must not end in "::"} + } + if {$stripped ne $child} { + set msg {interpreter name has excess colons in namespace separators} + return -code error $msg + } + if {[string range $stripped 0 1] eq {::}} { + return -code error {interpreter name must not begin "::"} + } + return +} + +proc ::safe::VarName {child} { + # return S$child + return S[string map {:: @N @ @A} $child] +} + +proc ::safe::Setup {} { + #### + # + # Setup the arguments parsing + # + #### + + # Share the descriptions + set temp [::tcl::OptKeyRegister { + {-accessPath -list {} "access path for the slave"} + {-noStatics "prevent loading of statically linked pkgs"} + {-statics true "loading of statically linked pkgs"} + {-nestedLoadOk "allow nested loading"} + {-nested false "nested loading"} + {-deleteHook -script {} "delete hook"} + }] + + # create case (slave is optional) + ::tcl::OptKeyRegister { + {?slave? -name {} "name of the slave (optional)"} + } ::safe::interpCreate + + # adding the flags sub programs to the command program (relying on Opt's + # internal implementation details) + lappend ::tcl::OptDesc(::safe::interpCreate) $::tcl::OptDesc($temp) + + # init and configure (slave is needed) + ::tcl::OptKeyRegister { + {slave -name {} "name of the slave"} + } ::safe::interpIC + + # adding the flags sub programs to the command program (relying on Opt's + # internal implementation details) + lappend ::tcl::OptDesc(::safe::interpIC) $::tcl::OptDesc($temp) + + # temp not needed anymore + ::tcl::OptKeyDelete $temp + + #### + # + # Default: No logging. + # + #### + + setLogCmd {} + + # Log eventually. + # To enable error logging, set Log to {puts stderr} for instance, + # via setLogCmd. + return +} + +namespace eval ::safe { + # internal variables + + # Log command, set via 'setLogCmd'. Logging is disabled when empty. + variable Log {} + + # The package maintains a state array per child interp under its + # control. The name of this array is S. This array is + # brought into scope where needed, using 'namespace upvar'. The S + # prefix is used to avoid that a child interp called "Log" smashes + # the "Log" variable. + # + # The array's elements are: + # + # access_path : List of paths accessible to the child. + # access_path,norm : Ditto, in normalized form. + # access_path,slave : Ditto, as the path tokens as seen by the child. + # access_path,map : dict ( token -> path ) + # access_path,remap : dict ( path -> token ) + # tm_path_slave : List of TM root directories, as tokens seen by the child. + # staticsok : Value of option -statics + # nestedok : Value of option -nested + # cleanupHook : Value of option -deleteHook +} + +::safe::Setup diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/tclAppInit.c b/physworld_p1_20261018/envs/p1/lib/tcl8.6/tclAppInit.c new file mode 100644 index 0000000000000000000000000000000000000000..552f9e4b2426327929f79700720e085794a2a0f8 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/tclAppInit.c @@ -0,0 +1,176 @@ +/* + * tclAppInit.c -- + * + * Provides a default version of the main program and Tcl_AppInit + * procedure for tclsh and other Tcl-based applications (without Tk). + * + * Copyright (c) 1993 The Regents of the University of California. + * Copyright (c) 1994-1997 Sun Microsystems, Inc. + * Copyright (c) 1998-1999 Scriptics Corporation. + * + * See the file "license.terms" for information on usage and redistribution of + * this file, and for a DISCLAIMER OF ALL WARRANTIES. + */ + +#undef BUILD_tcl +#undef STATIC_BUILD +#include "tcl.h" +#if TCL_MAJOR_VERSION < 9 && TCL_MINOR_VERSION < 7 +# define Tcl_LibraryInitProc Tcl_PackageInitProc +# define Tcl_StaticLibrary Tcl_StaticPackage +#endif + +#ifdef TCL_TEST +extern Tcl_LibraryInitProc Tcltest_Init; +extern Tcl_LibraryInitProc Tcltest_SafeInit; +#endif /* TCL_TEST */ + +#ifdef TCL_XT_TEST +extern void XtToolkitInitialize(void); +extern Tcl_LibraryInitProc Tclxttest_Init; +#endif /* TCL_XT_TEST */ + +/* + * The following #if block allows you to change the AppInit function by using + * a #define of TCL_LOCAL_APPINIT instead of rewriting this entire file. The + * #if checks for that #define and uses Tcl_AppInit if it does not exist. + */ + +#ifndef TCL_LOCAL_APPINIT +#define TCL_LOCAL_APPINIT Tcl_AppInit +#endif +#ifndef MODULE_SCOPE +# define MODULE_SCOPE extern +#endif +MODULE_SCOPE int TCL_LOCAL_APPINIT(Tcl_Interp *); +MODULE_SCOPE int main(int, char **); + +/* + * The following #if block allows you to change how Tcl finds the startup + * script, prime the library or encoding paths, fiddle with the argv, etc., + * without needing to rewrite Tcl_Main() + */ + +#ifdef TCL_LOCAL_MAIN_HOOK +MODULE_SCOPE int TCL_LOCAL_MAIN_HOOK(int *argc, char ***argv); +#endif + +/* + *---------------------------------------------------------------------- + * + * main -- + * + * This is the main program for the application. + * + * Results: + * None: Tcl_Main never returns here, so this procedure never returns + * either. + * + * Side effects: + * Just about anything, since from here we call arbitrary Tcl code. + * + *---------------------------------------------------------------------- + */ + +int +main( + int argc, /* Number of command-line arguments. */ + char *argv[]) /* Values of command-line arguments. */ +{ +#ifdef TCL_XT_TEST + XtToolkitInitialize(); +#endif + +#ifdef TCL_LOCAL_MAIN_HOOK + TCL_LOCAL_MAIN_HOOK(&argc, &argv); +#elif (TCL_MAJOR_VERSION > 8 || TCL_MINOR_VERSION > 6) && (!defined(_WIN32) || defined(UNICODE)) + /* New in Tcl 8.7. This doesn't work on Windows without UNICODE */ + TclZipfs_AppHook(&argc, &argv); +#endif + + Tcl_Main(argc, argv, TCL_LOCAL_APPINIT); + return 0; /* Needed only to prevent compiler warning. */ +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_AppInit -- + * + * This procedure performs application-specific initialization. Most + * applications, especially those that incorporate additional packages, + * will have their own version of this procedure. + * + * Results: + * Returns a standard Tcl completion code, and leaves an error message in + * the interp's result if an error occurs. + * + * Side effects: + * Depends on the startup script. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_AppInit( + Tcl_Interp *interp) /* Interpreter for application. */ +{ + if ((Tcl_Init)(interp) == TCL_ERROR) { + return TCL_ERROR; + } + +#ifdef TCL_XT_TEST + if (Tclxttest_Init(interp) == TCL_ERROR) { + return TCL_ERROR; + } +#endif + +#ifdef TCL_TEST + if (Tcltest_Init(interp) == TCL_ERROR) { + return TCL_ERROR; + } + Tcl_StaticLibrary(interp, "Tcltest", Tcltest_Init, Tcltest_SafeInit); +#endif /* TCL_TEST */ + + /* + * Call the init procedures for included packages. Each call should look + * like this: + * + * if (Mod_Init(interp) == TCL_ERROR) { + * return TCL_ERROR; + * } + * + * where "Mod" is the name of the module. (Dynamically-loadable packages + * should have the same entry-point name.) + */ + + /* + * Call Tcl_CreateCommand for application-specific commands, if they + * weren't already created by the init procedures called above. + */ + + /* + * Specify a user-specific startup file to invoke if the application is + * run interactively. Typically the startup file is "~/.apprc" where "app" + * is the name of the application. If this line is deleted then no + * user-specific startup file will be run under any conditions. + */ + +#ifdef DJGPP + (Tcl_ObjSetVar2)(interp, Tcl_NewStringObj("tcl_rcFileName", -1), NULL, + Tcl_NewStringObj("~/tclsh.rc", -1), TCL_GLOBAL_ONLY); +#else + (Tcl_ObjSetVar2)(interp, Tcl_NewStringObj("tcl_rcFileName", -1), NULL, + Tcl_NewStringObj("~/.tclshrc", -1), TCL_GLOBAL_ONLY); +#endif + + return TCL_OK; +} + +/* + * Local Variables: + * mode: c + * c-basic-offset: 4 + * fill-column: 78 + * End: + */ diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/tclIndex b/physworld_p1_20261018/envs/p1/lib/tcl8.6/tclIndex new file mode 100644 index 0000000000000000000000000000000000000000..0409d9b4636aa5ba762902b9dd87294a342487d6 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/tclIndex @@ -0,0 +1,78 @@ +# Tcl autoload index file, version 2.0 +# -*- tcl -*- +# This file is generated by the "auto_mkindex" command +# and sourced to set up indexing information for one or +# more commands. Typically each line is a command that +# sets an element in the auto_index array, where the +# element name is the name of a command and the value is +# a script that loads the command. + +set auto_index(auto_reset) [list source [file join $dir auto.tcl]] +set auto_index(tcl_findLibrary) [list source [file join $dir auto.tcl]] +set auto_index(auto_mkindex) [list source [file join $dir auto.tcl]] +set auto_index(auto_mkindex_old) [list source [file join $dir auto.tcl]] +set auto_index(::auto_mkindex_parser::init) [list source [file join $dir auto.tcl]] +set auto_index(::auto_mkindex_parser::cleanup) [list source [file join $dir auto.tcl]] +set auto_index(::auto_mkindex_parser::mkindex) [list source [file join $dir auto.tcl]] +set auto_index(::auto_mkindex_parser::hook) [list source [file join $dir auto.tcl]] +set auto_index(::auto_mkindex_parser::slavehook) [list source [file join $dir auto.tcl]] +set auto_index(::auto_mkindex_parser::command) [list source [file join $dir auto.tcl]] +set auto_index(::auto_mkindex_parser::commandInit) [list source [file join $dir auto.tcl]] +set auto_index(::auto_mkindex_parser::fullname) [list source [file join $dir auto.tcl]] +set auto_index(history) [list source [file join $dir history.tcl]] +set auto_index(::tcl::HistAdd) [list source [file join $dir history.tcl]] +set auto_index(::tcl::HistKeep) [list source [file join $dir history.tcl]] +set auto_index(::tcl::HistClear) [list source [file join $dir history.tcl]] +set auto_index(::tcl::HistInfo) [list source [file join $dir history.tcl]] +set auto_index(::tcl::HistRedo) [list source [file join $dir history.tcl]] +set auto_index(::tcl::HistIndex) [list source [file join $dir history.tcl]] +set auto_index(::tcl::HistEvent) [list source [file join $dir history.tcl]] +set auto_index(::tcl::HistChange) [list source [file join $dir history.tcl]] +set auto_index(pkg_mkIndex) [list source [file join $dir package.tcl]] +set auto_index(tclPkgSetup) [list source [file join $dir package.tcl]] +set auto_index(tclPkgUnknown) [list source [file join $dir package.tcl]] +set auto_index(::tcl::MacOSXPkgUnknown) [list source [file join $dir package.tcl]] +set auto_index(::pkg::create) [list source [file join $dir package.tcl]] +set auto_index(parray) [list source [file join $dir parray.tcl]] +set auto_index(::safe::InterpStatics) [list source [file join $dir safe.tcl]] +set auto_index(::safe::InterpNested) [list source [file join $dir safe.tcl]] +set auto_index(::safe::interpCreate) [list source [file join $dir safe.tcl]] +set auto_index(::safe::interpInit) [list source [file join $dir safe.tcl]] +set auto_index(::safe::CheckInterp) [list source [file join $dir safe.tcl]] +set auto_index(::safe::interpConfigure) [list source [file join $dir safe.tcl]] +set auto_index(::safe::InterpCreate) [list source [file join $dir safe.tcl]] +set auto_index(::safe::InterpSetConfig) [list source [file join $dir safe.tcl]] +set auto_index(::safe::interpFindInAccessPath) [list source [file join $dir safe.tcl]] +set auto_index(::safe::interpAddToAccessPath) [list source [file join $dir safe.tcl]] +set auto_index(::safe::InterpInit) [list source [file join $dir safe.tcl]] +set auto_index(::safe::AddSubDirs) [list source [file join $dir safe.tcl]] +set auto_index(::safe::interpDelete) [list source [file join $dir safe.tcl]] +set auto_index(::safe::setLogCmd) [list source [file join $dir safe.tcl]] +set auto_index(::safe::SyncAccessPath) [list source [file join $dir safe.tcl]] +set auto_index(::safe::PathToken) [list source [file join $dir safe.tcl]] +set auto_index(::safe::TranslatePath) [list source [file join $dir safe.tcl]] +set auto_index(::safe::Log) [list source [file join $dir safe.tcl]] +set auto_index(::safe::CheckFileName) [list source [file join $dir safe.tcl]] +set auto_index(::safe::AliasGlob) [list source [file join $dir safe.tcl]] +set auto_index(::safe::AliasSource) [list source [file join $dir safe.tcl]] +set auto_index(::safe::AliasLoad) [list source [file join $dir safe.tcl]] +set auto_index(::safe::FileInAccessPath) [list source [file join $dir safe.tcl]] +set auto_index(::safe::DirInAccessPath) [list source [file join $dir safe.tcl]] +set auto_index(::safe::Subset) [list source [file join $dir safe.tcl]] +set auto_index(::safe::AliasSubset) [list source [file join $dir safe.tcl]] +set auto_index(::safe::AliasEncoding) [list source [file join $dir safe.tcl]] +set auto_index(tcl_wordBreakAfter) [list source [file join $dir word.tcl]] +set auto_index(tcl_wordBreakBefore) [list source [file join $dir word.tcl]] +set auto_index(tcl_endOfWord) [list source [file join $dir word.tcl]] +set auto_index(tcl_startOfNextWord) [list source [file join $dir word.tcl]] +set auto_index(tcl_startOfPreviousWord) [list source [file join $dir word.tcl]] +set auto_index(::tcl::tm::add) [list source [file join $dir tm.tcl]] +set auto_index(::tcl::tm::remove) [list source [file join $dir tm.tcl]] +set auto_index(::tcl::tm::list) [list source [file join $dir tm.tcl]] +set auto_index(::tcl::tm::Defaults) [list source [file join $dir tm.tcl]] +set auto_index(::tcl::tm::UnknownHandler) [list source [file join $dir tm.tcl]] +set auto_index(::tcl::tm::roots) [list source [file join $dir tm.tcl]] +set auto_index(::tcl::tm::path) [list source [file join $dir tm.tcl]] +if {[namespace exists ::tcl::unsupported]} { + set auto_index(timerate) {namespace import ::tcl::unsupported::timerate} +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/tm.tcl b/physworld_p1_20261018/envs/p1/lib/tcl8.6/tm.tcl new file mode 100644 index 0000000000000000000000000000000000000000..c60084cc0376aae17cdd027d2db304b1488c5161 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/tm.tcl @@ -0,0 +1,380 @@ +# -*- tcl -*- +# +# Searching for Tcl Modules. Defines a procedure, declares it as the primary +# command for finding packages, however also uses the former 'package unknown' +# command as a fallback. +# +# Locates all possible packages in a directory via a less restricted glob. The +# targeted directory is derived from the name of the requested package, i.e. +# the TM scan will look only at directories which can contain the requested +# package. It will register all packages it found in the directory so that +# future requests have a higher chance of being fulfilled by the ifneeded +# database without having to come to us again. +# +# We do not remember where we have been and simply rescan targeted directories +# when invoked again. The reasoning is this: +# +# - The only way we get back to the same directory is if someone is trying to +# [package require] something that wasn't there on the first scan. +# +# Either +# 1) It is there now: If we rescan, you get it; if not you don't. +# +# This covers the possibility that the application asked for a package +# late, and the package was actually added to the installation after the +# application was started. It shoukld still be able to find it. +# +# 2) It still is not there: Either way, you don't get it, but the rescan +# takes time. This is however an error case and we dont't care that much +# about it +# +# 3) It was there the first time; but for some reason a "package forget" has +# been run, and "package" doesn't know about it anymore. +# +# This can be an indication that the application wishes to reload some +# functionality. And should work as well. +# +# Note that this also strikes a balance between doing a glob targeting a +# single package, and thus most likely requiring multiple globs of the same +# directory when the application is asking for many packages, and trying to +# glob for _everything_ in all subdirectories when looking for a package, +# which comes with a heavy startup cost. +# +# We scan for regular packages only if no satisfying module was found. + +namespace eval ::tcl::tm { + # Default paths. None yet. + + variable paths {} + + # The regex pattern a file name has to match to make it a Tcl Module. + + set pkgpattern {^([_[:alpha:]][:_[:alnum:]]*)-([[:digit:]].*)[.]tm$} + + # Export the public API + + namespace export path + namespace ensemble create -command path -subcommands {add remove list} +} + +# ::tcl::tm::path implementations -- +# +# Public API to the module path. See specification. +# +# Arguments +# cmd - The subcommand to execute +# args - The paths to add/remove. Must not appear querying the +# path with 'list'. +# +# Results +# No result for subcommands 'add' and 'remove'. A list of paths for +# 'list'. +# +# Sideeffects +# The subcommands 'add' and 'remove' manipulate the list of paths to +# search for Tcl Modules. The subcommand 'list' has no sideeffects. + +proc ::tcl::tm::add {args} { + # PART OF THE ::tcl::tm::path ENSEMBLE + # + # The path is added at the head to the list of module paths. + # + # The command enforces the restriction that no path may be an ancestor + # directory of any other path on the list. If the new path violates this + # restriction an error wil be raised. + # + # If the path is already present as is no error will be raised and no + # action will be taken. + + variable paths + + # We use a copy of the path as source during validation, and extend it as + # well. Because we not only have to detect if the new paths are bogus with + # respect to the existing paths, but also between themselves. Otherwise we + # can still add bogus paths, by specifying them in a single call. This + # makes the use of the new paths simpler as well, a trivial assignment of + # the collected paths to the official state var. + + set newpaths $paths + foreach p $args { + if {$p in $newpaths} { + # Ignore a path already on the list. + continue + } + + # Search for paths which are subdirectories of the new one. If there + # are any then the new path violates the restriction about ancestors. + + set pos [lsearch -glob $newpaths ${p}/*] + # Cannot use "in", we need the position for the message. + if {$pos >= 0} { + return -code error \ + "$p is ancestor of existing module path [lindex $newpaths $pos]." + } + + # Now look for existing paths which are ancestors of the new one. This + # reverse question forces us to loop over the existing paths, as each + # element is the pattern, not the new path :( + + foreach ep $newpaths { + if {[string match ${ep}/* $p]} { + return -code error \ + "$p is subdirectory of existing module path $ep." + } + } + + set newpaths [linsert $newpaths 0 $p] + } + + # The validation of the input is complete and successful, and everything + # in newpaths is either an old path, or added. We can now extend the + # official list of paths, a simple assignment is sufficient. + + set paths $newpaths + return +} + +proc ::tcl::tm::remove {args} { + # PART OF THE ::tcl::tm::path ENSEMBLE + # + # Removes the path from the list of module paths. The command is silently + # ignored if the path is not on the list. + + variable paths + + foreach p $args { + set pos [lsearch -exact $paths $p] + if {$pos >= 0} { + set paths [lreplace $paths $pos $pos] + } + } +} + +proc ::tcl::tm::list {} { + # PART OF THE ::tcl::tm::path ENSEMBLE + + variable paths + return $paths +} + +# ::tcl::tm::UnknownHandler -- +# +# Unknown handler for Tcl Modules, i.e. packages in module form. +# +# Arguments +# original - Original [package unknown] procedure. +# name - Name of desired package. +# version - Version of desired package. Can be the +# empty string. +# exact - Either -exact or ommitted. +# +# Name, version, and exact are used to determine satisfaction. The +# original is called iff no satisfaction was achieved. The name is also +# used to compute the directory to target in the search. +# +# Results +# None. +# +# Sideeffects +# May populate the package ifneeded database with additional provide +# scripts. + +proc ::tcl::tm::UnknownHandler {original name args} { + # Import the list of paths to search for packages in module form. + # Import the pattern used to check package names in detail. + + variable paths + variable pkgpattern + + # Without paths to search we can do nothing. (Except falling back to the + # regular search). + + if {[llength $paths]} { + set pkgpath [string map {:: /} $name] + set pkgroot [file dirname $pkgpath] + if {$pkgroot eq "."} { + set pkgroot "" + } + + # We don't remember a copy of the paths while looping. Tcl Modules are + # unable to change the list while we are searching for them. This also + # simplifies the loop, as we cannot get additional directories while + # iterating over the list. A simple foreach is sufficient. + + set satisfied 0 + foreach path $paths { + if {![interp issafe] && ![file exists $path]} { + continue + } + set currentsearchpath [file join $path $pkgroot] + if {![interp issafe] && ![file exists $currentsearchpath]} { + continue + } + set strip [llength [file split $path]] + + # Get the module files out of the subdirectories. + # - Safe Base interpreters have a restricted "glob" command that + # works in this case. + # - The "catch" was essential when there was no safe glob and every + # call in a safe interp failed; it is retained only for corner + # cases in which the eventual call to glob returns an error. + + catch { + # We always look for _all_ possible modules in the current + # path, to get the max result out of the glob. + + foreach file [glob -nocomplain -directory $currentsearchpath *.tm] { + set pkgfilename [join [lrange [file split $file] $strip end] ::] + + if {![regexp -- $pkgpattern $pkgfilename --> pkgname pkgversion]} { + # Ignore everything not matching our pattern for + # package names. + continue + } + try { + package vcompare $pkgversion 0 + } on error {} { + # Ignore everything where the version part is not + # acceptable to "package vcompare". + continue + } + + if {([package ifneeded $pkgname $pkgversion] ne {}) + && (![interp issafe]) + } { + # There's already a provide script registered for + # this version of this package. Since all units of + # code claiming to be the same version of the same + # package ought to be identical, just stick with + # the one we already have. + # This does not apply to Safe Base interpreters because + # the token-to-directory mapping may have changed. + continue + } + + # We have found a candidate, generate a "provide script" + # for it, and remember it. Note that we are using ::list + # to do this; locally [list] means something else without + # the namespace specifier. + + # NOTE. When making changes to the format of the provide + # command generated below CHECK that the 'LOCATE' + # procedure in core file 'platform/shell.tcl' still + # understands it, or, if not, update its implementation + # appropriately. + # + # Right now LOCATE's implementation assumes that the path + # of the package file is the last element in the list. + + package ifneeded $pkgname $pkgversion \ + "[::list package provide $pkgname $pkgversion];[::list source -encoding utf-8 $file]" + + # We abort in this unknown handler only if we got a + # satisfying candidate for the requested package. + # Otherwise we still have to fallback to the regular + # package search to complete the processing. + + if {($pkgname eq $name) + && [package vsatisfies $pkgversion {*}$args]} { + set satisfied 1 + + # We do not abort the loop, and keep adding provide + # scripts for every candidate in the directory, just + # remember to not fall back to the regular search + # anymore. + } + } + } + } + + if {$satisfied} { + return + } + } + + # Fallback to previous command, if existing. See comment above about + # ::list... + + if {[llength $original]} { + uplevel 1 $original [::linsert $args 0 $name] + } +} + +# ::tcl::tm::Defaults -- +# +# Determines the default search paths. +# +# Arguments +# None +# +# Results +# None. +# +# Sideeffects +# May add paths to the list of defaults. + +proc ::tcl::tm::Defaults {} { + global env tcl_platform + + regexp {^(\d+)\.(\d+)} [package provide Tcl] - major minor + set exe [file normalize [info nameofexecutable]] + + # Note that we're using [::list], not [list] because [list] means + # something other than [::list] in this namespace. + roots [::list \ + [file dirname [info library]] \ + [file join [file dirname [file dirname $exe]] lib] \ + ] + + if {$tcl_platform(platform) eq "windows"} { + set sep ";" + } else { + set sep ":" + } + for {set n $minor} {$n >= 0} {incr n -1} { + foreach ev [::list \ + TCL${major}.${n}_TM_PATH \ + TCL${major}_${n}_TM_PATH \ + ] { + if {![info exists env($ev)]} continue + foreach p [split $env($ev) $sep] { + path add $p + } + } + } + return +} + +# ::tcl::tm::roots -- +# +# Public API to the module path. See specification. +# +# Arguments +# paths - List of 'root' paths to derive search paths from. +# +# Results +# No result. +# +# Sideeffects +# Calls 'path add' to paths to the list of module search paths. + +proc ::tcl::tm::roots {paths} { + regexp {^(\d+)\.(\d+)} [package provide Tcl] - major minor + foreach pa $paths { + set p [file join $pa tcl$major] + for {set n $minor} {$n >= 0} {incr n -1} { + set px [file join $p ${major}.${n}] + if {![interp issafe]} {set px [file normalize $px]} + path add $px + } + set px [file join $p site-tcl] + if {![interp issafe]} {set px [file normalize $px]} + path add $px + } + return +} + +# Initialization. Set up the default paths, then insert the new handler into +# the chain. + +if {![interp issafe]} {::tcl::tm::Defaults} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8.6/word.tcl b/physworld_p1_20261018/envs/p1/lib/tcl8.6/word.tcl new file mode 100644 index 0000000000000000000000000000000000000000..828f13ab3480e09147b6042275a74093764bc7e4 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8.6/word.tcl @@ -0,0 +1,154 @@ +# word.tcl -- +# +# This file defines various procedures for computing word boundaries in +# strings. This file is primarily needed so Tk text and entry widgets behave +# properly for different platforms. +# +# Copyright (c) 1996 Sun Microsystems, Inc. +# Copyright (c) 1998 Scritpics Corporation. +# +# See the file "license.terms" for information on usage and redistribution +# of this file, and for a DISCLAIMER OF ALL WARRANTIES. + +# The following variables are used to determine which characters are +# interpreted as white space. + +if {$::tcl_platform(platform) eq "windows"} { + # Windows style - any but a unicode space char + if {![info exists ::tcl_wordchars]} { + set ::tcl_wordchars {\S} + } + if {![info exists ::tcl_nonwordchars]} { + set ::tcl_nonwordchars {\s} + } +} else { + # Motif style - any unicode word char (number, letter, or underscore) + if {![info exists ::tcl_wordchars]} { + set ::tcl_wordchars {\w} + } + if {![info exists ::tcl_nonwordchars]} { + set ::tcl_nonwordchars {\W} + } +} + +# Arrange for caches of the real matcher REs to be kept, which enables the REs +# themselves to be cached for greater performance (and somewhat greater +# clarity too). + +namespace eval ::tcl { + variable WordBreakRE + array set WordBreakRE {} + + proc UpdateWordBreakREs args { + # Ignores the arguments + global tcl_wordchars tcl_nonwordchars + variable WordBreakRE + + # To keep the RE strings short... + set letter $tcl_wordchars + set space $tcl_nonwordchars + + set WordBreakRE(after) "$letter$space|$space$letter" + set WordBreakRE(before) "^.*($letter$space|$space$letter)" + set WordBreakRE(end) "$space*$letter+$space" + set WordBreakRE(next) "$letter*$space+$letter" + set WordBreakRE(previous) "$space*($letter+)$space*\$" + } + + # Initialize the cache + UpdateWordBreakREs + trace add variable ::tcl_wordchars write ::tcl::UpdateWordBreakREs + trace add variable ::tcl_nonwordchars write ::tcl::UpdateWordBreakREs +} + +# tcl_wordBreakAfter -- +# +# This procedure returns the index of the first word boundary after the +# starting point in the given string, or -1 if there are no more boundaries in +# the given string. The index returned refers to the first character of the +# pair that comprises a boundary. +# +# Arguments: +# str - String to search. +# start - Index into string specifying starting point. + +proc tcl_wordBreakAfter {str start} { + variable ::tcl::WordBreakRE + set result {-1 -1} + regexp -indices -start $start -- $WordBreakRE(after) $str result + return [lindex $result 1] +} + +# tcl_wordBreakBefore -- +# +# This procedure returns the index of the first word boundary before the +# starting point in the given string, or -1 if there are no more boundaries in +# the given string. The index returned refers to the second character of the +# pair that comprises a boundary. +# +# Arguments: +# str - String to search. +# start - Index into string specifying starting point. + +proc tcl_wordBreakBefore {str start} { + variable ::tcl::WordBreakRE + set result {-1 -1} + regexp -indices -- $WordBreakRE(before) [string range $str 0 $start] result + return [lindex $result 1] +} + +# tcl_endOfWord -- +# +# This procedure returns the index of the first end-of-word location after a +# starting index in the given string. An end-of-word location is defined to be +# the first whitespace character following the first non-whitespace character +# after the starting point. Returns -1 if there are no more words after the +# starting point. +# +# Arguments: +# str - String to search. +# start - Index into string specifying starting point. + +proc tcl_endOfWord {str start} { + variable ::tcl::WordBreakRE + set result {-1 -1} + regexp -indices -start $start -- $WordBreakRE(end) $str result + return [lindex $result 1] +} + +# tcl_startOfNextWord -- +# +# This procedure returns the index of the first start-of-word location after a +# starting index in the given string. A start-of-word location is defined to +# be a non-whitespace character following a whitespace character. Returns -1 +# if there are no more start-of-word locations after the starting point. +# +# Arguments: +# str - String to search. +# start - Index into string specifying starting point. + +proc tcl_startOfNextWord {str start} { + variable ::tcl::WordBreakRE + set result {-1 -1} + regexp -indices -start $start -- $WordBreakRE(next) $str result + return [lindex $result 1] +} + +# tcl_startOfPreviousWord -- +# +# This procedure returns the index of the first start-of-word location before +# a starting index in the given string. +# +# Arguments: +# str - String to search. +# start - Index into string specifying starting point. + +proc tcl_startOfPreviousWord {str start} { + variable ::tcl::WordBreakRE + set word {-1 -1} + if {$start > 0} { + regexp -indices -- $WordBreakRE(previous) [string range $str 0 $start-1] \ + result word + } + return [lindex $word 0] +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8/8.4/platform-1.0.19.tm b/physworld_p1_20261018/envs/p1/lib/tcl8/8.4/platform-1.0.19.tm new file mode 100644 index 0000000000000000000000000000000000000000..acaebf268462756ec017159afcc9de6f45bf1c7f --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8/8.4/platform-1.0.19.tm @@ -0,0 +1,450 @@ +# -*- tcl -*- +# ### ### ### ######### ######### ######### +## Overview + +# Heuristics to assemble a platform identifier from publicly available +# information. The identifier describes the platform of the currently +# running tcl shell. This is a mixture of the runtime environment and +# of build-time properties of the executable itself. +# +# Examples: +# <1> A tcl shell executing on a x86_64 processor, but having a +# wordsize of 4 was compiled for the x86 environment, i.e. 32 +# bit, and loaded packages have to match that, and not the +# actual cpu. +# +# <2> The hp/solaris 32/64 bit builds of the core cannot be +# distinguished by looking at tcl_platform. As packages have to +# match the 32/64 information we have to look in more places. In +# this case we inspect the executable itself (magic numbers, +# i.e. fileutil::magic::filetype). +# +# The basic information used comes out of the 'os' and 'machine' +# entries of the 'tcl_platform' array. A number of general and +# os/machine specific transformation are applied to get a canonical +# result. +# +# General +# Only the first element of 'os' is used - we don't care whether we +# are on "Windows NT" or "Windows XP" or whatever. +# +# Machine specific +# % amd64 -> x86_64 +# % arm* -> arm +# % sun4* -> sparc +# % ia32* -> ix86 +# % intel -> ix86 +# % i*86* -> ix86 +# % Power* -> powerpc +# % x86_64 + wordSize 4 => x86 code +# +# OS specific +# % AIX are always powerpc machines +# % HP-UX 9000/800 etc means parisc +# % linux has to take glibc version into account +# % sunos -> solaris, and keep version number +# +# NOTE: A platform like linux glibc 2.3, which can use glibc 2.2 stuff +# has to provide all possible allowed platform identifiers when +# searching search. Ditto a solaris 2.8 platform can use solaris 2.6 +# packages. Etc. This is handled by the other procedure, see below. + +# ### ### ### ######### ######### ######### +## Requirements + +namespace eval ::platform {} + +# ### ### ### ######### ######### ######### +## Implementation + +# -- platform::generic +# +# Assembles an identifier for the generic platform. It leaves out +# details like kernel version, libc version, etc. + +proc ::platform::generic {} { + global tcl_platform + + set plat [string tolower [lindex $tcl_platform(os) 0]] + set cpu $tcl_platform(machine) + + switch -glob -- $cpu { + sun4* { + set cpu sparc + } + intel - + ia32* - + i*86* { + set cpu ix86 + } + x86_64 { + if {$tcl_platform(wordSize) == 4} { + # See Example <1> at the top of this file. + set cpu ix86 + } + } + ppc - + "Power*" { + set cpu powerpc + } + "arm*" { + set cpu arm + } + ia64 { + if {$tcl_platform(wordSize) == 4} { + append cpu _32 + } + } + } + + switch -glob -- $plat { + windows { + if {$tcl_platform(platform) == "unix"} { + set plat cygwin + } else { + set plat win32 + } + if {$cpu eq "amd64"} { + # Do not check wordSize, win32-x64 is an IL32P64 platform. + set cpu x86_64 + } + } + sunos { + set plat solaris + if {[string match "ix86" $cpu]} { + if {$tcl_platform(wordSize) == 8} { + set cpu x86_64 + } + } elseif {![string match "ia64*" $cpu]} { + # sparc + if {$tcl_platform(wordSize) == 8} { + append cpu 64 + } + } + } + darwin { + set plat macosx + # Correctly identify the cpu when running as a 64bit + # process on a machine with a 32bit kernel + if {$cpu eq "ix86"} { + if {$tcl_platform(wordSize) == 8} { + set cpu x86_64 + } + } + } + aix { + set cpu powerpc + if {$tcl_platform(wordSize) == 8} { + append cpu 64 + } + } + hp-ux { + set plat hpux + if {![string match "ia64*" $cpu]} { + set cpu parisc + if {$tcl_platform(wordSize) == 8} { + append cpu 64 + } + } + } + osf1 { + set plat tru64 + } + default { + set plat [lindex [split $plat _-] 0] + } + } + + return "${plat}-${cpu}" +} + +# -- platform::identify +# +# Assembles an identifier for the exact platform, by extending the +# generic identifier. I.e. it adds in details like kernel version, +# libc version, etc., if they are relevant for the loading of +# packages on the platform. + +proc ::platform::identify {} { + global tcl_platform + + set id [generic] + regexp {^([^-]+)-([^-]+)$} $id -> plat cpu + + switch -- $plat { + solaris { + regsub {^5} $tcl_platform(osVersion) 2 text + append plat $text + return "${plat}-${cpu}" + } + macosx { + set major [lindex [split $tcl_platform(osVersion) .] 0] + if {$major > 19} { + set minor [lindex [split $tcl_platform(osVersion) .] 1] + incr major -9 + append plat $major.[expr {$minor - 1}] + } else { + incr major -4 + append plat 10.$major + return "${plat}-${cpu}" + } + return "${plat}-${cpu}" + } + linux { + # Look for the libc*.so and determine its version + # (libc5/6, libc6 further glibc 2.X) + + set v unknown + + # Determine in which directory to look. /lib, or /lib64. + # For that we use the tcl_platform(wordSize). + # + # We could use the 'cpu' info, per the equivalence below, + # that however would be restricted to intel. And this may + # be a arm, mips, etc. system. The wordsize is more + # fundamental. + # + # ix86 <=> (wordSize == 4) <=> 32 bit ==> /lib + # x86_64 <=> (wordSize == 8) <=> 64 bit ==> /lib64 + # + # Do not look into /lib64 even if present, if the cpu + # doesn't fit. + + # TODO: Determine the prefixes (i386, x86_64, ...) for + # other cpus. The path after the generic one is utterly + # specific to intel right now. Ok, on Ubuntu, possibly + # other Debian systems we may apparently be able to query + # the necessary CPU code. If we can't we simply use the + # hardwired fallback. + + switch -exact -- $tcl_platform(wordSize) { + 4 { + lappend bases /lib + if {[catch { + exec dpkg-architecture -qDEB_HOST_MULTIARCH + } res]} { + lappend bases /lib/i386-linux-gnu + } else { + # dpkg-arch returns the full tripled, not just cpu. + lappend bases /lib/$res + } + } + 8 { + lappend bases /lib64 + if {[catch { + exec dpkg-architecture -qDEB_HOST_MULTIARCH + } res]} { + lappend bases /lib/x86_64-linux-gnu + } else { + # dpkg-arch returns the full tripled, not just cpu. + lappend bases /lib/$res + } + } + default { + return -code error "Bad wordSize $tcl_platform(wordSize), expected 4 or 8" + } + } + + foreach base $bases { + if {[LibcVersion $base -> v]} break + } + + append plat -$v + return "${plat}-${cpu}" + } + } + + return $id +} + +proc ::platform::LibcVersion {base _->_ vv} { + upvar 1 $vv v + set libclist [lsort [glob -nocomplain -directory $base libc*]] + + if {![llength $libclist]} { return 0 } + + set libc [lindex $libclist 0] + + # Try executing the library first. This should suceed + # for a glibc library, and return the version + # information. + + if {![catch { + set vdata [lindex [split [exec $libc] \n] 0] + }]} { + regexp {version ([0-9]+(\.[0-9]+)*)} $vdata -> v + foreach {major minor} [split $v .] break + set v glibc${major}.${minor} + return 1 + } else { + # We had trouble executing the library. We are now + # inspecting its name to determine the version + # number. This code by Larry McVoy. + + if {[regexp -- {libc-([0-9]+)\.([0-9]+)} $libc -> major minor]} { + set v glibc${major}.${minor} + return 1 + } + } + return 0 +} + +# -- platform::patterns +# +# Given an exact platform identifier, i.e. _not_ the generic +# identifier it assembles a list of exact platform identifier +# describing platform which should be compatible with the +# input. +# +# I.e. packages for all platforms in the result list should be +# loadable on the specified platform. + +# << Should we add the generic identifier to the list as well ? In +# general it is not compatible I believe. So better not. In many +# cases the exact identifier is identical to the generic one +# anyway. +# >> + +proc ::platform::patterns {id} { + set res [list $id] + if {$id eq "tcl"} {return $res} + + switch -glob -- $id { + solaris*-* { + if {[regexp {solaris([^-]*)-(.*)} $id -> v cpu]} { + if {$v eq ""} {return $id} + foreach {major minor} [split $v .] break + incr minor -1 + for {set j $minor} {$j >= 6} {incr j -1} { + lappend res solaris${major}.${j}-${cpu} + } + } + } + linux*-* { + if {[regexp {linux-glibc([^-]*)-(.*)} $id -> v cpu]} { + foreach {major minor} [split $v .] break + incr minor -1 + for {set j $minor} {$j >= 0} {incr j -1} { + lappend res linux-glibc${major}.${j}-${cpu} + } + } + } + macosx-powerpc { + lappend res macosx-universal + } + macosx-x86_64 { + lappend res macosx-i386-x86_64 + } + macosx-ix86 { + lappend res macosx-universal macosx-i386-x86_64 + } + macosx*-* { + # 10.5+,11.0+ + if {[regexp {macosx([^-]*)-(.*)} $id -> v cpu]} { + + switch -exact -- $cpu { + ix86 { + lappend alt i386-x86_64 + lappend alt universal + } + x86_64 { + if {[lindex [split $::tcl_platform(osVersion) .] 0] < 19} { + set alt i386-x86_64 + } else { + set alt {} + } + } + arm { + lappend alt x86_64 + } + default { set alt {} } + } + + if {$v ne ""} { + foreach {major minor} [split $v .] break + + set res {} + if {$major eq 13} { + # Add 13.0 to 13.minor to patterns. + for {set j $minor} {$j >= 0} {incr j -1} { + lappend res macosx${major}.${j}-${cpu} + foreach a $alt { + lappend res macosx${major}.${j}-$a + } + } + set major 12 + set minor 5 + } + if {$major eq 12} { + # Add 12.0 to 12.minor to patterns. + for {set j $minor} {$j >= 0} {incr j -1} { + lappend res macosx${major}.${j}-${cpu} + foreach a $alt { + lappend res macosx${major}.${j}-$a + } + } + set major 11 + set minor 5 + } + if {$major eq 11} { + # Add 11.0 to 11.minor to patterns. + for {set j $minor} {$j >= 0} {incr j -1} { + lappend res macosx${major}.${j}-${cpu} + foreach a $alt { + lappend res macosx${major}.${j}-$a + } + } + set major 10 + set minor 15 + } + # Add 10.5 to 10.minor to patterns. + for {set j $minor} {$j >= 5} {incr j -1} { + if {$cpu ne "arm"} { + lappend res macosx${major}.${j}-${cpu} + } + foreach a $alt { + lappend res macosx${major}.${j}-$a + } + } + + # Add unversioned patterns for 10.3/10.4 builds. + lappend res macosx-${cpu} + foreach a $alt { + lappend res macosx-$a + } + } else { + # No version, just do unversioned patterns. + foreach a $alt { + lappend res macosx-$a + } + } + } else { + # no v, no cpu ... nothing + } + } + } + lappend res tcl ; # Pure tcl packages are always compatible. + return $res +} + + +# ### ### ### ######### ######### ######### +## Ready + +package provide platform 1.0.19 + +# ### ### ### ######### ######### ######### +## Demo application + +if {[info exists argv0] && ($argv0 eq [info script])} { + puts ==================================== + parray tcl_platform + puts ==================================== + puts Generic\ identification:\ [::platform::generic] + puts Exact\ identification:\ \ \ [::platform::identify] + puts ==================================== + puts Search\ patterns: + puts *\ [join [::platform::patterns [::platform::identify]] \n*\ ] + puts ==================================== + exit 0 +} diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8/8.4/platform/shell-1.1.4.tm b/physworld_p1_20261018/envs/p1/lib/tcl8/8.4/platform/shell-1.1.4.tm new file mode 100644 index 0000000000000000000000000000000000000000..6eb96910188fb832b5ed5d668f3ba4fad9aff92d --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8/8.4/platform/shell-1.1.4.tm @@ -0,0 +1,241 @@ + +# -*- tcl -*- +# ### ### ### ######### ######### ######### +## Overview + +# Higher-level commands which invoke the functionality of this package +# for an arbitrary tcl shell (tclsh, wish, ...). This is required by a +# repository as while the tcl shell executing packages uses the same +# platform in general as a repository application there can be +# differences in detail (i.e. 32/64 bit builds). + +# ### ### ### ######### ######### ######### +## Requirements + +package require platform +namespace eval ::platform::shell {} + +# ### ### ### ######### ######### ######### +## Implementation + +# -- platform::shell::generic + +proc ::platform::shell::generic {shell} { + # Argument is the path to a tcl shell. + + CHECK $shell + LOCATE base out + + set code {} + # Forget any pre-existing platform package, it might be in + # conflict with this one. + lappend code {package forget platform} + # Inject our platform package + lappend code [list source $base] + # Query and print the architecture + lappend code {puts [platform::generic]} + # And done + lappend code {exit 0} + + set arch [RUN $shell [join $code \n]] + + if {$out} {file delete -force $base} + return $arch +} + +# -- platform::shell::identify + +proc ::platform::shell::identify {shell} { + # Argument is the path to a tcl shell. + + CHECK $shell + LOCATE base out + + set code {} + # Forget any pre-existing platform package, it might be in + # conflict with this one. + lappend code {package forget platform} + # Inject our platform package + lappend code [list source $base] + # Query and print the architecture + lappend code {puts [platform::identify]} + # And done + lappend code {exit 0} + + set arch [RUN $shell [join $code \n]] + + if {$out} {file delete -force $base} + return $arch +} + +# -- platform::shell::platform + +proc ::platform::shell::platform {shell} { + # Argument is the path to a tcl shell. + + CHECK $shell + + set code {} + lappend code {puts $tcl_platform(platform)} + lappend code {exit 0} + + return [RUN $shell [join $code \n]] +} + +# ### ### ### ######### ######### ######### +## Internal helper commands. + +proc ::platform::shell::CHECK {shell} { + if {![file exists $shell]} { + return -code error "Shell \"$shell\" does not exist" + } + if {![file executable $shell]} { + return -code error "Shell \"$shell\" is not executable (permissions)" + } + return +} + +proc ::platform::shell::LOCATE {bv ov} { + upvar 1 $bv base $ov out + + # Locate the platform package for injection into the specified + # shell. We are using package management to find it, whereever it + # is, instead of using hardwired relative paths. This allows us to + # install the two packages as TMs without breaking the code + # here. If the found package is wrapped we copy the code somewhere + # where the spawned shell will be able to read it. + + # This code is brittle, it needs has to adapt to whatever changes + # are made to the TM code, i.e. the provide statement generated by + # tm.tcl + + set pl [package ifneeded platform [package require platform]] + set base [lindex $pl end] + + set out 0 + if {[lindex [file system $base]] ne "native"} { + set temp [TEMP] + file copy -force $base $temp + set base $temp + set out 1 + } + return +} + +proc ::platform::shell::RUN {shell code} { + set c [TEMP] + set cc [open $c w] + puts $cc $code + close $cc + + set e [TEMP] + + set code [catch { + exec $shell $c 2> $e + } res] + + file delete $c + + if {$code} { + append res \n[read [set chan [open $e r]]][close $chan] + file delete $e + return -code error "Shell \"$shell\" is not executable ($res)" + } + + file delete $e + return $res +} + +proc ::platform::shell::TEMP {} { + set prefix platform + + # This code is copied out of Tcllib's fileutil package. + # (TempFile/tempfile) + + set tmpdir [DIR] + + set chars "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" + set nrand_chars 10 + set maxtries 10 + set access [list RDWR CREAT EXCL TRUNC] + set permission 0600 + set channel "" + set checked_dir_writable 0 + set mypid [pid] + for {set i 0} {$i < $maxtries} {incr i} { + set newname $prefix + for {set j 0} {$j < $nrand_chars} {incr j} { + append newname [string index $chars \ + [expr {int(rand()*62)}]] + } + set newname [file join $tmpdir $newname] + if {[file exists $newname]} { + after 1 + } else { + if {[catch {open $newname $access $permission} channel]} { + if {!$checked_dir_writable} { + set dirname [file dirname $newname] + if {![file writable $dirname]} { + return -code error "Directory $dirname is not writable" + } + set checked_dir_writable 1 + } + } else { + # Success + close $channel + return [file normalize $newname] + } + } + } + if {$channel ne ""} { + return -code error "Failed to open a temporary file: $channel" + } else { + return -code error "Failed to find an unused temporary file name" + } +} + +proc ::platform::shell::DIR {} { + # This code is copied out of Tcllib's fileutil package. + # (TempDir/tempdir) + + global tcl_platform env + + set attempdirs [list] + + foreach tmp {TMPDIR TEMP TMP} { + if { [info exists env($tmp)] } { + lappend attempdirs $env($tmp) + } + } + + switch $tcl_platform(platform) { + windows { + lappend attempdirs "C:\\TEMP" "C:\\TMP" "\\TEMP" "\\TMP" + } + macintosh { + set tmpdir $env(TRASH_FOLDER) ;# a better place? + } + default { + lappend attempdirs \ + [file join / tmp] \ + [file join / var tmp] \ + [file join / usr tmp] + } + } + + lappend attempdirs [pwd] + + foreach tmp $attempdirs { + if { [file isdirectory $tmp] && [file writable $tmp] } { + return [file normalize $tmp] + } + } + + # Fail if nothing worked. + return -code error "Unable to determine a proper directory for temporary files" +} + +# ### ### ### ######### ######### ######### +## Ready + +package provide platform::shell 1.1.4 diff --git a/physworld_p1_20261018/envs/p1/lib/tcl8/8.5/msgcat-1.6.1.tm b/physworld_p1_20261018/envs/p1/lib/tcl8/8.5/msgcat-1.6.1.tm new file mode 100644 index 0000000000000000000000000000000000000000..fa91a3740ef6f7c296674ed4251cc9c36fe08379 --- /dev/null +++ b/physworld_p1_20261018/envs/p1/lib/tcl8/8.5/msgcat-1.6.1.tm @@ -0,0 +1,1210 @@ +# msgcat.tcl -- +# +# This file defines various procedures which implement a +# message catalog facility for Tcl programs. It should be +# loaded with the command "package require msgcat". +# +# Copyright (c) 2010-2015 Harald Oehlmann. +# Copyright (c) 1998-2000 Ajuba Solutions. +# Copyright (c) 1998 Mark Harrison. +# +# See the file "license.terms" for information on usage and redistribution +# of this file, and for a DISCLAIMER OF ALL WARRANTIES. + +package require Tcl 8.5- +# When the version number changes, be sure to update the pkgIndex.tcl file, +# and the installation directory in the Makefiles. +package provide msgcat 1.6.1 + +namespace eval msgcat { + namespace export mc mcexists mcload mclocale mcmax mcmset mcpreferences mcset\ + mcunknown mcflset mcflmset mcloadedlocales mcforgetpackage\ + mcpackageconfig mcpackagelocale + + # Records the list of locales to search + variable Loclist {} + + # List of currently loaded locales + variable LoadedLocales {} + + # Records the locale of the currently sourced message catalogue file + variable FileLocale + + # Configuration values per Package (e.g. client namespace). + # The dict key is of the form "