Self:\n \"\"\"\n Generate triangle strips and/or polylines from\n input polygons, triangle strips, and lines.\n\n Input polygons are assembled into triangle strips only if they are triangles;\n other types of polygons are passed through to the output and not stripped.\n Use mesh.triangulate() to triangulate non-triangular polygons prior to running\n this filter if you need to strip all the data.\n\n Also note that if triangle strips or polylines are present in the input\n they are passed through and not joined nor extended.\n If you wish to strip these use mesh.triangulate() to fragment the input\n into triangles and lines prior to applying join().\n\n Args:\n polys (bool):\n polygonal segments will be joined if they are contiguous\n reset (bool):\n reset points ordering\n\n Warning:\n If triangle strips or polylines exist in the input data\n they will be passed through to the output data.\n This filter will only construct triangle strips if triangle polygons\n are available; and will only construct polylines if lines are available.\n\n Examples:\n ```python\n from vedo import *\n c1 = Cylinder(pos=(0,0,0), r=2, height=3, axis=(1,.0,0), alpha=.1).triangulate()\n c2 = Cylinder(pos=(0,0,2), r=1, height=2, axis=(0,.3,1), alpha=.1).triangulate()\n intersect = c1.intersect_with(c2).join(reset=True)\n spline = Spline(intersect).c('blue').lw(5)\n show(c1, c2, spline, intersect.labels('id'), axes=1).close()\n ```\n \n \"\"\"\n sf = vtki.new(\"Stripper\")\n sf.SetPassThroughCellIds(True)\n sf.SetPassThroughPointIds(True)\n sf.SetJoinContiguousSegments(polys)\n sf.SetInputData(self.dataset)\n sf.Update()\n if reset:\n poly = sf.GetOutput()\n cpd = vtki.new(\"CleanPolyData\")\n cpd.PointMergingOn()\n cpd.ConvertLinesToPointsOn()\n cpd.ConvertPolysToLinesOn()\n cpd.ConvertStripsToPolysOn()\n cpd.SetInputData(poly)\n cpd.Update()\n poly = cpd.GetOutput()\n vpts = poly.GetCell(0).GetPoints().GetData()\n poly.GetPoints().SetData(vpts)\n else:\n poly = sf.GetOutput()\n\n self._update(poly)\n\n self.pipeline = OperationNode(\n \"join\", parents=[self], comment=f\"#pts {self.dataset.GetNumberOfPoints()}\"\n )\n return self\n\n def join_segments(self, closed=True, tol=1e-03) -> list:\n \"\"\"\n Join line segments into contiguous lines.\n Useful to call with `triangulate()` method.\n\n Returns:\n list of `shapes.Lines`\n\n Examples:\n ```python\n from vedo import *\n msh = Torus().alpha(0.1).wireframe()\n intersection = msh.intersect_with_plane(normal=[1,1,1]).c('purple5')\n slices = [s.clone().triangulate() for s in intersection.join_segments()]\n show(msh, intersection, slices, axes=1, viewup='z')\n ```\n \n \"\"\"\n tol0 = tol\n vlines = []\n for _ipiece, outline in enumerate(self.split(must_share_edge=False)):\n outline.clean()\n pts = outline.coordinates\n if len(pts) < 3:\n continue\n avesize = outline.average_size()\n lines = outline.lines\n if not lines:\n continue\n tol = avesize / pts.shape[0] * tol0\n\n # Precompute integer grid keys (points within tol share the same key).\n pt_keys = list(map(tuple, np.round(pts / tol).astype(int)))\n\n # Build lookup lists keyed by grid cell. Lists (not plain dicts) are required\n # because T-junctions produce multiple segments at the same key; plain-dict\n # assignment silently drops all but the last one.\n # Store (original_index, line) so \"first unconsumed\" matches the original's\n # linear-scan order, reproducing identical traversal at branch points.\n fwd: dict = {}\n rev: dict = {}\n for i, line in enumerate(lines):\n k0, k1 = pt_keys[line[0]], pt_keys[line[-1]]\n if k0 not in fwd:\n fwd[k0] = []\n fwd[k0].append((i, line))\n if k1 not in rev:\n rev[k1] = []\n rev[k1].append((i, line))\n\n consumed: set = set()\n k = 0\n joinedpts = [pts[k]]\n\n for _ in range(len(lines)):\n pk = pts[k]\n cur_key = pt_keys[k]\n\n # Merge fwd and rev candidates for this key, deduplicate, then sort by\n # original segment index. This reproduces the original's linear-scan\n # order: for each segment (lowest index first) try the forward direction\n # first, then reverse — matching the original's exact traversal at\n # T-junctions and near-duplicate junction points.\n seen_cands: set = set()\n candidates = []\n for orig_i, line in fwd.get(cur_key, []) + rev.get(cur_key, []):\n if orig_i not in consumed and orig_i not in seen_cands:\n seen_cands.add(orig_i)\n candidates.append((orig_i, line))\n candidates.sort(key=lambda x: x[0])\n\n found = False\n for orig_i, line in candidates:\n if np.linalg.norm(pts[line[0]] - pk) < tol:\n consumed.add(orig_i)\n for m in range(1, len(line)):\n joinedpts.append(pts[line[m]])\n k = line[-1]\n found = True\n break\n if np.linalg.norm(pts[line[-1]] - pk) < tol:\n consumed.add(orig_i)\n for m in reversed(range(0, len(line) - 1)):\n joinedpts.append(pts[line[m]])\n k = line[0]\n found = True\n break\n\n if not found:\n remaining = len(lines) - len(consumed)\n if remaining > 0:\n vedo.logger.warning(\n f\"join_segments: piece {_ipiece} has {remaining} \"\n \"unjoined segment(s) — possible gap or topology issue\"\n )\n break\n\n if len(joinedpts) > 1:\n newline = vedo.shapes.Line(joinedpts, closed=closed)\n newline.clean()\n newline.actor.SetProperty(self.properties)\n newline.properties = self.properties\n newline.pipeline = OperationNode(\n \"join_segments\",\n parents=[self],\n comment=f\"#pts {newline.dataset.GetNumberOfPoints()}\",\n )\n vlines.append(newline)\n\n return vlines\n\n def join_with_strips(self, b1, closed=True) -> Self:\n \"\"\"\n Join boundary lines by creating a triangle strip between them.\n\n Examples:\n ```python\n from vedo import *\n m1 = Cylinder(cap=False).boundaries()\n m2 = Cylinder(cap=False).boundaries().pos(0.2,0,1)\n strips = m1.join_with_strips(m2)\n show(m1, m2, strips, axes=1).close()\n ```\n \"\"\"\n b0 = self.clone().join()\n b1 = b1.clone().join()\n\n vertices0 = b0.vertices.tolist()\n vertices1 = b1.vertices.tolist()\n\n lines0 = b0.lines\n lines1 = b1.lines\n m = len(lines0)\n if m != len(lines1):\n raise ValueError(\n \"lines must have the same number of points\\n\"\n f\"line has {m} points in b0 and {len(lines1)} in b1\"\n )\n\n strips = []\n points: list[Any] = []\n\n for j in range(m):\n ids0j = list(lines0[j])\n ids1j = list(lines1[j])\n\n n = len(ids0j)\n if n != len(ids1j):\n raise ValueError(\n \"lines must have the same number of points\\n\"\n f\"line {j} has {n} points in b0 and {len(ids1j)} in b1\"\n )\n\n if closed:\n ids0j.append(ids0j[0])\n ids1j.append(ids1j[0])\n vertices0.append(vertices0[ids0j[0]])\n vertices1.append(vertices1[ids1j[0]])\n n = n + 1\n\n strip = [] # create a triangle strip\n npt = len(points)\n for ipt in range(n):\n points.append(vertices0[ids0j[ipt]])\n points.append(vertices1[ids1j[ipt]])\n\n strip = list(range(npt, npt + 2 * n))\n strips.append(strip)\n\n return Mesh([points, [], [], strips], c=\"k6\")\n\n def split_polylines(self) -> Self:\n \"\"\"Split polylines into separate segments.\"\"\"\n tf = vtki.new(\"TriangleFilter\")\n tf.SetPassLines(True)\n tf.SetPassVerts(False)\n tf.SetInputData(self.dataset)\n tf.Update()\n self._update(tf.GetOutput(), reset_locators=False)\n self.lw(0).lighting(\"default\").pickable()\n self.pipeline = OperationNode(\n \"split_polylines\",\n parents=[self],\n comment=f\"#lines {self.dataset.GetNumberOfLines()}\",\n )\n return self\n\n def remove_all_lines(self) -> Self:\n \"\"\"Remove all line elements from the mesh.\"\"\"\n self.dataset.GetLines().Reset()\n return self\n\n def slice(self, origin=(0, 0, 0), normal=(1, 0, 0)) -> Self:\n \"\"\"\n Slice a mesh with a plane and fill the contour.\n\n Examples:\n ```python\n from vedo import *\n msh = Mesh(dataurl+\"bunny.obj\").alpha(0.1).wireframe()\n mslice = msh.slice(normal=[0,1,0.3], origin=[0,0.16,0])\n mslice.c('purple5')\n show(msh, mslice, axes=1)\n ```\n \n\n See also: `join()`, `join_segments()`, `cap()`, `cut_with_plane()`.\n \"\"\"\n intersection = self.intersect_with_plane(origin=origin, normal=normal)\n slices = [s.triangulate() for s in intersection.join_segments()]\n mslices = vedo.pointcloud.merge(slices)\n if mslices:\n mslices.name = \"MeshSlice\"\n mslices.pipeline = OperationNode(\n \"slice\", parents=[self], comment=f\"normal = {normal}\"\n )\n return mslices\n\n def triangulate(self, verts=True, lines=True) -> Self:\n \"\"\"\n Converts mesh polygons into triangles.\n\n If the input mesh is only made of 2D lines (no faces) the output will be a triangulation\n that fills the internal area. The contours may be concave, and may even contain holes,\n i.e. a contour may contain an internal contour winding in the opposite\n direction to indicate that it is a hole.\n\n Args:\n verts (bool):\n if True, break input vertex cells into individual vertex cells (one point per cell).\n If False, the input vertex cells will be ignored.\n lines (bool):\n if True, break input polylines into line segments.\n If False, input lines will be ignored and the output will have no lines.\n \"\"\"\n if self.dataset.GetNumberOfPolys() or self.dataset.GetNumberOfStrips():\n # print(\"Using vtkTriangleFilter\")\n tf = vtki.new(\"TriangleFilter\")\n tf.SetPassLines(lines)\n tf.SetPassVerts(verts)\n\n elif self.dataset.GetNumberOfLines():\n # print(\"Using vtkContourTriangulator\")\n tf = vtki.new(\"ContourTriangulator\")\n tf.TriangulationErrorDisplayOn()\n\n else:\n vedo.logger.debug(\"input in triangulate() seems to be void! Skip.\")\n return self\n\n tf.SetInputData(self.dataset)\n tf.Update()\n self._update(tf.GetOutput(), reset_locators=False)\n self.lw(0).lighting(\"default\").pickable()\n\n self.pipeline = OperationNode(\n \"triangulate\",\n parents=[self],\n comment=f\"#cells {self.dataset.GetNumberOfCells()}\",\n )\n return self\n\n def laplacian_diffusion(self, array_name, dt, num_steps) -> Self:\n \"\"\"\n Diffuse a scalar point array on the mesh surface using the\n cotangent-weighted Laplacian with lumped-mass-matrix normalization\n and unconditionally-stable implicit Euler time integration.\n\n The scheme solves M du/dt = -L u, where L is the cotangent Laplacian\n and M is the diagonal lumped mass matrix (M_ii = 1/3 * sum of adjacent\n triangle areas). This makes `dt` mesh-independent: the same `dt` produces\n the same amount of diffusion regardless of mesh resolution.\n\n Args:\n array_name (str): name of the point array to diffuse.\n dt (float): time step per iteration (any positive value is stable).\n num_steps (int): number of iterations.\n\n See also: `smooth_data()`\n [diffuse_data.py](https://github.com/marcomusy/vedo/tree/master/examples/advanced/diffuse_data.py)\n \"\"\"\n try:\n from scipy.sparse import coo_matrix, diags\n from scipy.sparse.linalg import factorized\n except ImportError:\n vedo.logger.error(\"scipy not found. Cannot run laplacian_diffusion()\")\n return self\n\n points = self.coordinates\n try:\n cells = np.asarray(self.cells, dtype=np.intp)\n if cells.ndim != 2 or cells.shape[1] != 3:\n raise ValueError\n except (ValueError, TypeError):\n vedo.logger.warning(\"laplacian_diffusion: non-triangular mesh, triangulating internally.\")\n cells = np.asarray(self.clone().triangulate().cells, dtype=np.intp)\n\n # Cotangent-weighted Laplacian (vectorized over all triangles)\n p0, p1, p2 = points[cells[:, 0]], points[cells[:, 1]], points[cells[:, 2]]\n e01, e02, e12 = p1 - p0, p2 - p0, p2 - p1\n\n cross = np.cross(e01, e02)\n area2 = np.maximum(np.linalg.norm(cross, axis=1), 1e-12)\n cot0 = np.einsum(\"ij,ij->i\", e01, e02) / area2 # angle at vertex 0, opposite edge 12\n cot1 = np.einsum(\"ij,ij->i\", -e01, e12) / area2 # angle at vertex 1, opposite edge 02\n cot2 = np.einsum(\"ij,ij->i\", -e02, -e12) / area2 # angle at vertex 2, opposite edge 01\n\n n = points.shape[0]\n rows = np.concatenate([cells[:, 0], cells[:, 1], # edge 01, weight cot2\n cells[:, 1], cells[:, 2], # edge 12, weight cot0\n cells[:, 0], cells[:, 2]]) # edge 02, weight cot1\n cols = np.concatenate([cells[:, 1], cells[:, 0],\n cells[:, 2], cells[:, 1],\n cells[:, 2], cells[:, 0]])\n weights = 0.5 * np.concatenate([cot2, cot2, cot0, cot0, cot1, cot1])\n\n # Off-diagonal entries are negative; diagonal set so each row sums to zero\n L = coo_matrix((-weights, (rows, cols)), shape=(n, n)).tocsc()\n L.setdiag(-np.asarray(L.sum(axis=1)).ravel())\n\n # Lumped mass matrix: M_ii = 1/3 * sum of areas of adjacent triangles.\n # Normalising by M makes dt mesh-independent (proper heat-equation scaling).\n areas = area2 / 2\n mass = np.zeros(n)\n np.add.at(mass, cells[:, 0], areas / 3)\n np.add.at(mass, cells[:, 1], areas / 3)\n np.add.at(mass, cells[:, 2], areas / 3)\n M = diags(mass, format=\"csc\")\n\n # Implicit Euler: (M + dt*L) u_{k+1} = M u_k — stable for any dt > 0\n A = M + dt * L\n solve = factorized(A)\n u = self.pointdata[array_name].astype(float)\n for _ in range(int(num_steps)):\n u = solve(M @ u)\n self.pointdata[array_name] = u\n return self\n\n def subdivide(self, n=1, method=0, mel=None) -> Self:\n \"\"\"\n Increase the number of vertices of a surface mesh.\n\n Args:\n n (int):\n number of subdivisions.\n method (int):\n Loop(0), Linear(1), Adaptive(2), Butterfly(3), Centroid(4)\n mel (float):\n Maximum Edge Length (applicable to Adaptive method only).\n \"\"\"\n triangles = vtki.new(\"TriangleFilter\")\n triangles.SetInputData(self.dataset)\n triangles.Update()\n tri_mesh = triangles.GetOutput()\n if method == 0:\n sdf = vtki.new(\"LoopSubdivisionFilter\")\n elif method == 1:\n sdf = vtki.new(\"LinearSubdivisionFilter\")\n elif method == 2:\n sdf = vtki.new(\"AdaptiveSubdivisionFilter\")\n if mel is None:\n mel = (\n self.diagonal_size() / np.sqrt(self.dataset.GetNumberOfPoints()) / n\n )\n sdf.SetMaximumEdgeLength(mel)\n elif method == 3:\n sdf = vtki.new(\"ButterflySubdivisionFilter\")\n elif method == 4:\n sdf = vtki.new(\"DensifyPolyData\")\n else:\n vedo.logger.error(f\"in subdivide() unknown method {method}\")\n raise RuntimeError()\n\n if method != 2:\n sdf.SetNumberOfSubdivisions(n)\n\n sdf.SetInputData(tri_mesh)\n sdf.Update()\n\n self._update(sdf.GetOutput())\n\n self.pipeline = OperationNode(\n \"subdivide\",\n parents=[self],\n comment=f\"#pts {self.dataset.GetNumberOfPoints()}\",\n )\n return self\n\n def decimate(\n self, fraction=0.5, n=None, preserve_volume=True, regularization=0.0\n ) -> Self:\n \"\"\"\n Downsample the number of vertices in a mesh to `fraction`.\n\n This filter preserves the `pointdata` of the input dataset. In previous versions\n of vedo, this decimation algorithm was referred to as quadric decimation.\n\n Args:\n fraction (float):\n the desired target of reduction.\n n (int):\n the desired number of final points\n (`fraction` is recalculated based on it).\n preserve_volume (bool):\n Decide whether to activate volume preservation which greatly\n reduces errors in triangle normal direction.\n regularization (float):\n regularize the point finding algorithm so as to have better quality\n mesh elements at the cost of a slightly lower precision on the\n geometry potentially (mostly at sharp edges).\n Can be useful for decimating meshes that have been triangulated on noisy data.\n\n Note:\n Setting `fraction=0.1` leaves 10% of the original number of vertices.\n Internally the VTK class\n [vtkQuadricDecimation](https://vtk.org/doc/nightly/html/classvtkQuadricDecimation.html)\n is used for this operation.\n\n See also: `decimate_binned()` and `decimate_pro()`.\n \"\"\"\n poly = self.dataset\n if n: # N = desired number of points\n npt = poly.GetNumberOfPoints()\n fraction = n / npt\n if fraction >= 1:\n return self\n\n decimate = vtki.new(\"QuadricDecimation\")\n decimate.SetVolumePreservation(preserve_volume)\n # decimate.AttributeErrorMetricOn()\n if regularization:\n decimate.SetRegularize(True)\n decimate.SetRegularization(regularization)\n\n try:\n decimate.MapPointDataOn()\n except AttributeError:\n pass\n\n decimate.SetTargetReduction(1 - fraction)\n decimate.SetInputData(poly)\n decimate.Update()\n\n self._update(decimate.GetOutput())\n self.metadata[\"decimate_actual_fraction\"] = 1 - decimate.GetActualReduction()\n\n self.pipeline = OperationNode(\n \"decimate\",\n parents=[self],\n comment=f\"#pts {self.dataset.GetNumberOfPoints()}\",\n )\n return self\n\n def decimate_pro(\n self,\n fraction=0.5,\n n=None,\n preserve_topology=True,\n preserve_boundaries=True,\n splitting=False,\n splitting_angle=75,\n feature_angle=0,\n inflection_point_ratio=10,\n vertex_degree=0,\n ) -> Self:\n \"\"\"\n Downsample the number of vertices in a mesh to `fraction`.\n\n This filter preserves the `pointdata` of the input dataset.\n\n Args:\n fraction (float):\n The desired target of reduction.\n Setting `fraction=0.1` leaves 10% of the original number of vertices.\n n (int):\n the desired number of final points (`fraction` is recalculated based on it).\n preserve_topology (bool):\n If on, mesh splitting and hole elimination will not occur.\n This may limit the maximum reduction that may be achieved.\n preserve_boundaries (bool):\n Turn on/off the deletion of vertices on the boundary of a mesh.\n Control whether mesh boundaries are preserved during decimation.\n feature_angle (float):\n Specify the angle that defines a feature.\n This angle is used to define what an edge is\n (i.e., if the surface normal between two adjacent triangles\n is >= FeatureAngle, an edge exists).\n splitting (bool):\n Turn on/off the splitting of the mesh at corners,\n along edges, at non-manifold points, or anywhere else a split is required.\n Turning splitting off will better preserve the original topology of the mesh,\n but you may not obtain the requested reduction.\n splitting_angle (float):\n Specify the angle that defines a sharp edge.\n This angle is used to control the splitting of the mesh.\n A split line exists when the surface normals between two edge connected triangles\n are >= `splitting_angle`.\n inflection_point_ratio (float):\n An inflection point occurs when the ratio of reduction error between two iterations\n is greater than or equal to the `inflection_point_ratio` value.\n vertex_degree (int):\n If the number of triangles connected to a vertex exceeds it then the vertex will be split.\n\n Note:\n Setting `fraction=0.1` leaves 10% of the original number of vertices\n\n See also:\n `decimate()` and `decimate_binned()`.\n \"\"\"\n poly = self.dataset\n if n: # N = desired number of points\n npt = poly.GetNumberOfPoints()\n fraction = n / npt\n if fraction >= 1:\n return self\n\n decimate = vtki.new(\"DecimatePro\")\n decimate.SetPreserveTopology(preserve_topology)\n decimate.SetBoundaryVertexDeletion(not preserve_boundaries)\n if feature_angle:\n decimate.SetFeatureAngle(feature_angle)\n decimate.SetSplitting(splitting)\n decimate.SetSplitAngle(splitting_angle)\n decimate.SetInflectionPointRatio(inflection_point_ratio)\n if vertex_degree:\n decimate.SetDegree(vertex_degree)\n\n decimate.SetTargetReduction(1 - fraction)\n decimate.SetInputData(poly)\n decimate.Update()\n self._update(decimate.GetOutput())\n\n self.pipeline = OperationNode(\n \"decimate_pro\",\n parents=[self],\n comment=f\"#pts {self.dataset.GetNumberOfPoints()}\",\n )\n return self\n\n def decimate_binned(self, divisions=(), use_clustering=False) -> Self:\n \"\"\"\n Downsample the number of vertices in a mesh.\n\n This filter preserves the `celldata` of the input dataset,\n if `use_clustering=True` also the `pointdata` will be preserved in the result.\n\n Args:\n divisions (list):\n number of divisions along x, y and z axes.\n auto_adjust (bool):\n if True, the number of divisions is automatically adjusted to\n create more uniform cells.\n use_clustering (bool):\n use [vtkQuadricClustering](https://vtk.org/doc/nightly/html/classvtkQuadricClustering.html)\n instead of\n [vtkBinnedDecimation](https://vtk.org/doc/nightly/html/classvtkBinnedDecimation.html).\n\n See also: `decimate()` and `decimate_pro()`.\n \"\"\"\n if use_clustering:\n decimate = vtki.new(\"QuadricClustering\")\n decimate.CopyCellDataOn()\n else:\n decimate = vtki.new(\"BinnedDecimation\")\n decimate.ProducePointDataOn()\n decimate.ProduceCellDataOn()\n\n decimate.SetInputData(self.dataset)\n\n if len(divisions) == 0:\n decimate.SetAutoAdjustNumberOfDivisions(1)\n else:\n decimate.SetAutoAdjustNumberOfDivisions(0)\n decimate.SetNumberOfDivisions(divisions)\n decimate.Update()\n\n self._update(decimate.GetOutput())\n self.metadata[\"decimate_binned_divisions\"] = decimate.GetNumberOfDivisions()\n self.pipeline = OperationNode(\n \"decimate_binned\",\n parents=[self],\n comment=f\"#pts {self.dataset.GetNumberOfPoints()}\",\n )\n return self\n\n def generate_random_points(self, n: int, min_radius=0.0) -> Points:\n \"\"\"\n Generate `n` uniformly distributed random points\n inside the polygonal mesh.\n\n A new point data array is added to the output points\n called \"OriginalCellID\" which contains the index of\n the cell ID in which the point was generated.\n\n Args:\n n (int):\n number of points to generate.\n min_radius (float):\n impose a minimum distance between points.\n If `min_radius` is set to 0, the points are\n generated uniformly at random inside the mesh.\n If `min_radius` is set to a positive value,\n the points are generated uniformly at random\n inside the mesh, but points closer than `min_radius`\n to any other point are discarded.\n\n Returns a `vedo.Points` object.\n\n Note:\n Consider using `points.probe(msh)` or\n `points.interpolate_data_from(msh)`\n to interpolate existing mesh data onto the new points.\n\n Examples:\n ```python\n from vedo import *\n msh = Mesh(dataurl + \"panther.stl\").lw(2)\n pts = msh.generate_random_points(20000, min_radius=0.5)\n print(\"Original cell ids:\", pts.pointdata[\"OriginalCellID\"])\n show(pts, msh, axes=1).close()\n ```\n \"\"\"\n cmesh = self.clone().clean().triangulate().compute_cell_size()\n triangles = cmesh.cells\n vertices = cmesh.vertices\n areas = np.asarray(cmesh.celldata[\"Area\"])\n if areas.size == 0 or triangles is None or len(triangles) == 0:\n raise ValueError(\n \"generate_random_points() requires a mesh with valid triangulated cells\"\n )\n cumul = np.cumsum(areas)\n\n out_pts = []\n orig_cell = []\n for _ in range(n):\n # choose a triangle based on area\n random_area = np.random.random() * cumul[-1]\n it = np.searchsorted(cumul, random_area)\n A, B, C = vertices[triangles[it]]\n # calculate the random point in the triangle\n r1, r2 = np.random.random(2)\n if r1 + r2 > 1:\n r1 = 1 - r1\n r2 = 1 - r2\n out_pts.append((1 - r1 - r2) * A + r1 * B + r2 * C)\n orig_cell.append(it)\n nporig_cell = np.array(orig_cell, dtype=np.uint32)\n\n vpts = Points(out_pts)\n vpts.pointdata[\"OriginalCellID\"] = nporig_cell\n\n if min_radius > 0:\n vpts.subsample(min_radius, absolute=True)\n\n vpts.point_size(5).color(\"k1\")\n vpts.name = \"RandomPoints\"\n vpts.pipeline = OperationNode(\n \"generate_random_points\", c=\"#edabab\", parents=[self]\n )\n return vpts\n\n def delete_cells(self, ids: list[int]) -> Self:\n \"\"\"\n Remove cells from the mesh object by their ID.\n Points (vertices) are not removed (you may use `clean()` to remove those).\n \"\"\"\n self.dataset.BuildLinks()\n for cid in ids:\n self.dataset.DeleteCell(cid)\n self.dataset.RemoveDeletedCells()\n self.dataset.Modified()\n self.mapper.Modified()\n self.pipeline = OperationNode(\n \"delete_cells\",\n parents=[self],\n comment=f\"#cells {self.dataset.GetNumberOfCells()}\",\n )\n return self\n\n def delete_cells_by_point_index(self, indices: list[int]) -> Self:\n \"\"\"\n Delete a list of vertices identified by any of their vertex index.\n\n See also `delete_cells()`.\n\n Examples:\n - [delete_mesh_pts.py](https://github.com/marcomusy/vedo/tree/master/examples/basic/delete_mesh_pts.py)\n\n \n \"\"\"\n cell_ids = vtki.vtkIdList()\n self.dataset.BuildLinks()\n for i in np.unique(indices):\n self.dataset.GetPointCells(i, cell_ids)\n for j in range(cell_ids.GetNumberOfIds()):\n self.dataset.DeleteCell(cell_ids.GetId(j))\n\n self.dataset.RemoveDeletedCells()\n self.dataset.Modified()\n self.pipeline = OperationNode(\"delete_cells_by_point_index\", parents=[self])\n return self\n\n def collapse_edges(self, distance: float, iterations=1) -> Self:\n \"\"\"\n Collapse mesh edges that are shorter than `distance`.\n\n Examples:\n ```python\n from vedo import *\n np.random.seed(2)\n grid1 = Grid().add_gaussian_noise(0.8).triangulate().lw(1)\n grid1.celldata['scalar'] = grid1.cell_centers().coordinates[:,1]\n grid2 = grid1.clone().collapse_edges(0.1)\n show(grid1, grid2, N=2, axes=1)\n ```\n \"\"\"\n for _ in range(iterations):\n medges = self.edges\n newpts = self.vertices\n moved = set()\n collapse_pairs = []\n for id0, id1 in medges:\n p0, p1 = newpts[id0], newpts[id1]\n if (\n np.linalg.norm(p1 - p0) < distance\n and id0 not in moved\n and id1 not in moved\n ):\n midpoint = (p0 + p1) / 2\n newpts[id0] = midpoint\n newpts[id1] = midpoint\n moved.add(id0)\n moved.add(id1)\n collapse_pairs.append((id0, id1))\n self.vertices = newpts\n\n # interpolate point data arrays at each collapsed midpoint\n pd = self.dataset.GetPointData()\n for arr_i in range(pd.GetNumberOfArrays()):\n arr = pd.GetArray(arr_i)\n if arr is None:\n continue\n data = vtk2numpy(arr) # writable view into VTK buffer\n for id0, id1 in collapse_pairs:\n data[id0] = (data[id0] + data[id1]) / 2\n arr.Modified()\n pd.Modified()\n\n cpd = vtki.new(\"CleanPolyData\")\n cpd.ConvertLinesToPointsOff()\n cpd.ConvertPolysToLinesOff()\n cpd.ConvertStripsToPolysOff()\n cpd.SetInputData(self.dataset)\n cpd.Update()\n self._update(cpd.GetOutput())\n\n self.pipeline = OperationNode(\n \"collapse_edges\",\n parents=[self],\n comment=f\"#pts {self.dataset.GetNumberOfPoints()}\",\n )\n return self\n\n def compute_adjacency(self) -> list[set]:\n \"\"\"\n Computes the adjacency list for mesh edge-graph.\n\n Returns:\n a list with i-th entry being the set\n of indices of vertices connected by an edge to i-th vertex\n \"\"\"\n inc = [set() for _ in range(self.npoints)]\n arr = self.cells_as_flat_array\n i = 0\n n = len(arr)\n while i < n:\n nc = int(arr[i]); i += 1\n if nc >= 2:\n for j in range(nc):\n inc[arr[i + j]].update((arr[i + (j - 1) % nc], arr[i + (j + 1) % nc]))\n i += nc\n return inc\n\n def find_adjacent_vertices(self, index, depth=1, adjacency_list=None) -> set:\n \"\"\"\n Computes the ball of radius `n` in the mesh' edge-graph metric\n centered at vertex `index`.\n\n Args:\n index (int):\n index of the vertex\n depth (int):\n depth of the search in the edge-graph metric.\n\n Returns:\n the set of indices of the vertices which are at most `depth` edges from vertex `index`.\n \"\"\"\n if adjacency_list is None:\n adjacency_list = self.compute_adjacency()\n k = self.npoints\n if not (0 <= index < k):\n raise IndexError(f\"index {index} out of range [0, {k})\")\n if len(adjacency_list) != k:\n raise ValueError(\n f\"adjacency_list must have {k} entries, got {len(adjacency_list)}\"\n )\n ball = {index}\n i = 0\n while i < depth and len(ball) < k:\n frontier = set()\n for v in ball:\n frontier |= adjacency_list[v]\n ball |= frontier\n i += 1\n return np.array(list(ball), dtype=int)\n\n def smooth(\n self, niter=15, pass_band=0.1, edge_angle=15, feature_angle=60, boundary=False\n ) -> Self:\n \"\"\"\n Adjust mesh point positions using the so-called \"Windowed Sinc\" method.\n\n Args:\n niter (int):\n number of iterations.\n pass_band (float):\n set the pass_band value for the windowed sinc filter.\n edge_angle (float):\n edge angle to control smoothing along edges (either interior or boundary).\n feature_angle (float):\n specifies the feature angle for sharp edge identification.\n boundary (bool):\n specify if boundary should also be smoothed or kept unmodified\n\n Examples:\n - [mesh_smoother1.py](https://github.com/marcomusy/vedo/tree/master/examples/advanced/mesh_smoother1.py)\n\n \n \"\"\"\n cl = vtki.new(\"CleanPolyData\")\n cl.SetInputData(self.dataset)\n cl.Update()\n smf = vtki.new(\"WindowedSincPolyDataFilter\")\n smf.SetInputData(cl.GetOutput())\n smf.SetNumberOfIterations(niter)\n smf.SetEdgeAngle(edge_angle)\n smf.SetFeatureAngle(feature_angle)\n smf.SetPassBand(pass_band)\n smf.NormalizeCoordinatesOn()\n smf.NonManifoldSmoothingOn()\n smf.FeatureEdgeSmoothingOn()\n smf.SetBoundarySmoothing(boundary)\n smf.Update()\n\n self._update(smf.GetOutput())\n\n self.pipeline = OperationNode(\n \"smooth\", parents=[self], comment=f\"#pts {self.dataset.GetNumberOfPoints()}\"\n )\n return self\n\n def fill_holes(self, size=None) -> Self:\n \"\"\"\n Identifies and fills holes in the input mesh.\n Holes are identified by locating boundary edges, linking them together\n into loops, and then triangulating the resulting loops.\n\n Args:\n size (float):\n Approximate limit to the size of the hole that can be filled.\n\n Examples:\n - [fillholes.py](https://github.com/marcomusy/vedo/tree/master/examples/basic/fillholes.py)\n \"\"\"\n fh = vtki.new(\"FillHolesFilter\")\n if not size:\n mb = self.diagonal_size()\n size = mb / 10\n fh.SetHoleSize(size)\n fh.SetInputData(self.dataset)\n fh.Update()\n\n self._update(fh.GetOutput())\n\n self.pipeline = OperationNode(\n \"fill_holes\",\n parents=[self],\n comment=f\"#pts {self.dataset.GetNumberOfPoints()}\",\n )\n return self\n\n def contains(self, point: tuple, tol=1e-05) -> bool:\n \"\"\"\n Return True if point is inside a polydata closed surface.\n\n Note:\n if you have many points to check use `inside_points()` instead.\n\n Examples:\n ```python\n from vedo import *\n s = Sphere().c('green5').alpha(0.5)\n pt = [0.1, 0.2, 0.3]\n print(\"Sphere contains\", pt, s.contains(pt))\n show(s, Point(pt), axes=1).close()\n ```\n \"\"\"\n points = vtki.vtkPoints()\n points.InsertNextPoint(point)\n poly = vtki.vtkPolyData()\n poly.SetPoints(points)\n sep = vtki.new(\"SelectEnclosedPoints\")\n sep.SetTolerance(tol)\n sep.CheckSurfaceOff()\n sep.SetInputData(poly)\n sep.SetSurfaceData(self.dataset)\n sep.Update()\n return bool(sep.IsInside(0))\n\n def inside_points(\n self, pts: Points | list, invert=False, tol=1e-05, return_ids=False\n ) -> Points | np.ndarray:\n \"\"\"\n Return the point cloud that is inside mesh surface as a new Points object.\n\n If return_ids is True a list of IDs is returned and in addition input points\n are marked by a pointdata array named \"IsInside\".\n\n Examples:\n `print(pts.pointdata[\"IsInside\"])`\n\n Examples:\n - [pca_ellipsoid.py](https://github.com/marcomusy/vedo/tree/master/examples/basic/pca_ellipsoid.py)\n\n \n \"\"\"\n if isinstance(pts, Points):\n poly = pts.dataset\n ptsa = pts.coordinates\n else:\n ptsa = np.asarray(pts)\n vpoints = vtki.vtkPoints()\n vpoints.SetData(numpy2vtk(ptsa, dtype=np.float32))\n poly = vtki.vtkPolyData()\n poly.SetPoints(vpoints)\n\n sep = vtki.new(\"SelectEnclosedPoints\")\n # sep = vtki.new(\"ExtractEnclosedPoints()\n sep.SetTolerance(tol)\n sep.SetInputData(poly)\n sep.SetSurfaceData(self.dataset)\n sep.SetInsideOut(invert)\n sep.Update()\n\n varr = sep.GetOutput().GetPointData().GetArray(\"SelectedPoints\")\n mask = vtk2numpy(varr).astype(bool)\n ids = np.array(range(len(ptsa)), dtype=int)[mask]\n\n if isinstance(pts, Points):\n varr.SetName(\"IsInside\")\n pts.dataset.GetPointData().AddArray(varr)\n\n if return_ids:\n return ids\n\n pcl = Points(ptsa[ids])\n pcl.name = \"InsidePoints\"\n\n parents = [self, pts] if isinstance(pts, Points) else [self]\n pcl.pipeline = OperationNode(\n \"inside_points\",\n parents=parents,\n comment=f\"#pts {pcl.dataset.GetNumberOfPoints()}\",\n )\n return pcl\n\n def boundaries(\n self,\n boundary_edges=True,\n manifold_edges=False,\n non_manifold_edges=False,\n feature_angle=None,\n return_point_ids=False,\n return_cell_ids=False,\n cell_edge=False,\n ) -> Self | np.ndarray:\n \"\"\"\n Return the boundary lines of an input mesh.\n Check also `vedo.core.CommonAlgorithms.mark_boundaries()` method.\n\n Args:\n boundary_edges (bool):\n Turn on/off the extraction of boundary edges.\n manifold_edges (bool):\n Turn on/off the extraction of manifold edges.\n non_manifold_edges (bool):\n Turn on/off the extraction of non-manifold edges.\n feature_angle (bool):\n Specify the min angle btw 2 faces for extracting edges.\n return_point_ids (bool):\n return a numpy array of point indices\n return_cell_ids (bool):\n return a numpy array of cell indices\n cell_edge (bool):\n set to `True` if a cell need to share an edge with\n the boundary line, or `False` if a single vertex is enough\n\n Examples:\n - [boundaries.py](https://github.com/marcomusy/vedo/tree/master/examples/basic/boundaries.py)\n\n \n \"\"\"\n fe = vtki.new(\"FeatureEdges\")\n fe.SetBoundaryEdges(boundary_edges)\n fe.SetNonManifoldEdges(non_manifold_edges)\n fe.SetManifoldEdges(manifold_edges)\n try:\n fe.SetPassLines(True) # vtk9.2\n except AttributeError:\n pass\n fe.ColoringOff()\n fe.SetFeatureEdges(False)\n if feature_angle is not None:\n fe.SetFeatureEdges(True)\n fe.SetFeatureAngle(feature_angle)\n\n if return_point_ids or return_cell_ids:\n ids = vtki.new_ids_filter()\n if ids is None:\n vedo.logger.error(\n \"boundaries(): cannot instantiate vtkIdFilter/vtkGenerateIds\"\n )\n raise RuntimeError(\"boundaries(): missing VTK ids filter\")\n ids.SetInputData(self.dataset)\n ids.SetPointIdsArrayName(\"BoundaryIds\")\n ids.SetPointIds(True)\n ids.Update()\n\n fe.SetInputData(ids.GetOutput())\n fe.Update()\n\n vid = fe.GetOutput().GetPointData().GetArray(\"BoundaryIds\")\n npid = vtk2numpy(vid).astype(int)\n\n if return_point_ids:\n return npid\n\n if return_cell_ids:\n n = 1 if cell_edge else 0\n inface = []\n for i, face in enumerate(self.cells):\n # isin = np.any([vtx in npid for vtx in face])\n isin = 0\n for vtx in face:\n isin += int(vtx in npid)\n if isin > n:\n break\n if isin > n:\n inface.append(i)\n return np.array(inface).astype(int)\n\n return self\n\n else:\n fe.SetInputData(self.dataset)\n fe.Update()\n msh = Mesh(fe.GetOutput(), c=\"p\").lw(5).lighting(\"off\")\n msh.name = \"MeshBoundaries\"\n\n msh.pipeline = OperationNode(\n \"boundaries\",\n parents=[self],\n shape=\"octagon\",\n comment=f\"#pts {msh.dataset.GetNumberOfPoints()}\",\n )\n return msh\n\n def imprint(self, loopline, tol=0.01) -> Self:\n \"\"\"\n Imprint the contact surface of one object onto another surface.\n\n Args:\n loopline (vedo.Line):\n a Line object to be imprinted onto the mesh.\n tol (float):\n projection tolerance which controls how close the imprint\n surface must be to the target.\n\n Examples:\n ```python\n from vedo import *\n grid = Grid()#.triangulate()\n circle = Circle(r=0.3, res=24).pos(0.11,0.12)\n line = Line(circle, closed=True, lw=4, c='r4')\n grid.imprint(line)\n show(grid, line, axes=1).close()\n ```\n \n \"\"\"\n loop = vtki.new(\"ContourLoopExtraction\")\n loop.SetInputData(loopline.dataset)\n loop.Update()\n\n clean_loop = vtki.new(\"CleanPolyData\")\n clean_loop.SetInputData(loop.GetOutput())\n clean_loop.Update()\n\n imp = vtki.new(\"ImprintFilter\")\n imp.SetTargetData(self.dataset)\n imp.SetImprintData(clean_loop.GetOutput())\n imp.SetTolerance(tol)\n imp.BoundaryEdgeInsertionOn()\n imp.TriangulateOutputOn()\n imp.Update()\n\n self._update(imp.GetOutput())\n\n self.pipeline = OperationNode(\n \"imprint\",\n parents=[self],\n comment=f\"#pts {self.dataset.GetNumberOfPoints()}\",\n )\n return self\n\n def connected_vertices(self, index: int) -> list[int]:\n \"\"\"Find all vertices connected to an input vertex specified by its index.\n\n Examples:\n - [connected_vtx.py](https://github.com/marcomusy/vedo/tree/master/examples/basic/connected_vtx.py)\n\n \n \"\"\"\n poly = self.dataset\n poly.BuildLinks()\n\n cell_idlist = vtki.vtkIdList()\n poly.GetPointCells(index, cell_idlist)\n\n seen = set()\n for i in range(cell_idlist.GetNumberOfIds()):\n point_idlist = vtki.vtkIdList()\n poly.GetCellPoints(cell_idlist.GetId(i), point_idlist)\n for j in range(point_idlist.GetNumberOfIds()):\n idj = point_idlist.GetId(j)\n if idj != index:\n seen.add(idj)\n\n return list(seen)\n\n def extract_cells(self, ids: list[int]) -> Self:\n \"\"\"\n Extract a subset of cells from a mesh and return it as a new mesh.\n \"\"\"\n selectCells = vtki.new(\"SelectionNode\")\n selectCells.SetFieldType(vtki.get_class(\"SelectionNode\").CELL)\n selectCells.SetContentType(vtki.get_class(\"SelectionNode\").INDICES)\n idarr = vtki.vtkIdTypeArray()\n idarr.SetNumberOfComponents(1)\n idarr.SetNumberOfValues(len(ids))\n for i, v in enumerate(ids):\n idarr.SetValue(i, v)\n selectCells.SetSelectionList(idarr)\n\n selection = vtki.new(\"Selection\")\n selection.AddNode(selectCells)\n\n extractSelection = vtki.new(\"ExtractSelection\")\n extractSelection.SetInputData(0, self.dataset)\n extractSelection.SetInputData(1, selection)\n extractSelection.Update()\n\n gf = vtki.new(\"GeometryFilter\")\n gf.SetInputData(extractSelection.GetOutput())\n gf.Update()\n msh = Mesh(gf.GetOutput())\n msh.copy_properties_from(self)\n return msh\n\n def connected_cells(self, index: int, return_ids=False) -> Self | list[int]:\n \"\"\"Find all cells connected to an input vertex specified by its index.\"\"\"\n dpoly = self.dataset\n dpoly.BuildLinks()\n\n idlist = vtki.vtkIdList()\n dpoly.GetPointCells(index, idlist)\n\n rids = [int(idlist.GetId(k)) for k in range(idlist.GetNumberOfIds())]\n if return_ids:\n return rids\n\n ids = vtki.vtkIdTypeArray()\n ids.SetNumberOfComponents(1)\n for cid in rids:\n ids.InsertNextValue(cid)\n\n selection_node = vtki.new(\"SelectionNode\")\n selection_node.SetFieldType(vtki.get_class(\"SelectionNode\").CELL)\n selection_node.SetContentType(vtki.get_class(\"SelectionNode\").INDICES)\n selection_node.SetSelectionList(ids)\n selection = vtki.new(\"Selection\")\n selection.AddNode(selection_node)\n extractSelection = vtki.new(\"ExtractSelection\")\n extractSelection.SetInputData(0, dpoly)\n extractSelection.SetInputData(1, selection)\n extractSelection.Update()\n gf = vtki.new(\"GeometryFilter\")\n gf.SetInputData(extractSelection.GetOutput())\n gf.Update()\n return Mesh(gf.GetOutput()).lw(1)\n\n def silhouette(\n self, direction=None, border_edges=True, feature_angle=False\n ) -> Self:\n \"\"\"\n Return a new line `Mesh` which corresponds to the outer `silhouette`\n of the input as seen along a specified `direction`, this can also be\n a `vtkCamera` object.\n\n Args:\n direction (list):\n viewpoint direction vector.\n If `None` this is guessed by looking at the minimum\n of the sides of the bounding box.\n border_edges (bool):\n enable or disable generation of border edges\n feature_angle (float):\n minimal angle for sharp edges detection.\n If set to `False` the functionality is disabled.\n\n Examples:\n - [silhouette1.py](https://github.com/marcomusy/vedo/tree/master/examples/basic/silhouette1.py)\n\n \n \"\"\"\n sil = vtki.new(\"PolyDataSilhouette\")\n sil.SetInputData(self.dataset)\n sil.SetBorderEdges(border_edges)\n if feature_angle is False:\n sil.SetEnableFeatureAngle(0)\n else:\n sil.SetEnableFeatureAngle(1)\n sil.SetFeatureAngle(feature_angle)\n\n plt = vedo.current_plotter()\n if direction is None and plt and plt.camera:\n sil.SetCamera(plt.camera)\n m = Mesh()\n m.mapper.SetInputConnection(sil.GetOutputPort())\n\n elif isinstance(direction, vtki.vtkCamera):\n sil.SetCamera(direction)\n m = Mesh()\n m.mapper.SetInputConnection(sil.GetOutputPort())\n\n elif direction == \"2d\":\n sil.SetVector(3.4, 4.5, 5.6) # random\n sil.SetDirectionToSpecifiedVector()\n sil.Update()\n m = Mesh(sil.GetOutput())\n\n elif is_sequence(direction):\n sil.SetVector(direction)\n sil.SetDirectionToSpecifiedVector()\n sil.Update()\n m = Mesh(sil.GetOutput())\n else:\n vedo.logger.error(\n f\"in silhouette() unknown direction type {type(direction)}\"\n )\n vedo.logger.error(\n \"first render the scene with show() or specify camera/direction\"\n )\n return self\n\n m.lw(2).c((0, 0, 0)).lighting(\"off\")\n m.mapper.SetResolveCoincidentTopologyToPolygonOffset()\n m.pipeline = OperationNode(\"silhouette\", parents=[self])\n m.name = \"Silhouette\"\n return m\n\n def isobands(self, n=10, vmin=None, vmax=None) -> Self:\n \"\"\"\n Return a new `Mesh` representing the isobands of the active scalars.\n This is a new mesh where the scalar is now associated to cell faces and\n used to colorize the mesh.\n\n Args:\n n (int):\n number of isobands in the range\n vmin (float):\n minimum of the range\n vmax (float):\n maximum of the range\n\n Examples:\n - [isolines.py](https://github.com/marcomusy/vedo/tree/master/examples/pyplot/isolines.py)\n \"\"\"\n r0, r1 = self.dataset.GetScalarRange()\n if vmin is None:\n vmin = r0\n if vmax is None:\n vmax = r1\n\n if vmin >= vmax:\n vedo.logger.warning(\"isobands(): vmin >= vmax, returning empty mesh\")\n return Mesh()\n\n dx = (vmax - vmin) / float(n)\n bands = []\n b = [vmin, vmin + dx / 2.0, vmin + dx]\n for _ in range(n):\n bands.append(b)\n b = [b[0] + dx, b[1] + dx, b[2] + dx]\n\n bcf = vtki.new(\"BandedPolyDataContourFilter\")\n bcf.SetInputData(self.dataset)\n for i, band in enumerate(bands):\n bcf.SetValue(i, band[2])\n # Value mode: output cell scalars are actual data values, matching the\n # existing lut range [vmin, vmax] so coloring is correct.\n bcf.SetScalarModeToValue()\n bcf.GenerateContourEdgesOff()\n bcf.Update()\n bcf.GetOutput().GetCellData().GetScalars().SetName(\"IsoBands\")\n\n m1 = Mesh(bcf.GetOutput()).compute_normals(cells=True)\n lut = self.mapper.GetLookupTable()\n m1.mapper.SetLookupTable(lut)\n m1.mapper.SetScalarRange(lut.GetRange())\n m1.mapper.SetScalarModeToUseCellData()\n m1.pipeline = OperationNode(\"isobands\", parents=[self])\n m1.name = \"IsoBands\"\n return m1\n\n def isolines(self, n=10, vmin=None, vmax=None) -> Self:\n \"\"\"\n Return a new `Mesh` representing the isolines of the active scalars.\n\n Args:\n n (int, list):\n number of isolines in the range, a list of specific values can also be passed.\n vmin (float):\n minimum of the range\n vmax (float):\n maximum of the range\n\n Examples:\n - [isolines.py](https://github.com/marcomusy/vedo/tree/master/examples/pyplot/isolines.py)\n\n \n \"\"\"\n bcf = vtki.new(\"ContourFilter\")\n bcf.SetInputData(self.dataset)\n r0, r1 = self.dataset.GetScalarRange()\n if vmin is None:\n vmin = r0\n if vmax is None:\n vmax = r1\n if vmin > vmax:\n vedo.logger.warning(\"isolines(): vmin > vmax, returning empty mesh\")\n return Mesh()\n if is_sequence(n):\n i = 0\n for val in n:\n if vmin <= val <= vmax:\n bcf.SetValue(i, val)\n i += 1\n else:\n bcf.GenerateValues(n, vmin, vmax)\n bcf.Update()\n sf = vtki.new(\"Stripper\")\n sf.SetJoinContiguousSegments(True)\n sf.SetInputData(bcf.GetOutput())\n sf.Update()\n cl = vtki.new(\"CleanPolyData\")\n cl.SetInputData(sf.GetOutput())\n cl.Update()\n msh = Mesh(cl.GetOutput(), c=\"k\").lighting(\"off\")\n msh.mapper.SetResolveCoincidentTopologyToPolygonOffset()\n msh.pipeline = OperationNode(\"isolines\", parents=[self])\n msh.name = \"IsoLines\"\n return msh\n\n def extrude(\n self, zshift=1.0, direction=(), rotation=0.0, dr=0.0, cap=True, res=1\n ) -> Self:\n \"\"\"\n Sweep a polygonal data creating a \"skirt\" from free edges and lines, and lines from vertices.\n The input dataset is swept around the z-axis to create new polygonal primitives.\n For example, sweeping a line results in a cylindrical shell, and sweeping a circle creates a torus.\n\n You can control whether the sweep of a 2D object (i.e., polygon or triangle strip)\n is capped with the generating geometry.\n Also, you can control the angle of rotation, and whether translation along the z-axis\n is performed along with the rotation. (Translation is useful for creating \"springs\").\n You also can adjust the radius of the generating geometry using the \"dR\" keyword.\n\n The skirt is generated by locating certain topological features.\n Free edges (edges of polygons or triangle strips only used by one polygon or triangle strips)\n generate surfaces. This is true also of lines or polylines. Vertices generate lines.\n\n This filter can be used to model axisymmetric objects like cylinders, bottles, and wine glasses;\n or translational/rotational symmetric objects like springs or corkscrews.\n\n Args:\n zshift (float):\n translation along the z-axis applied during the sweep (independent of `direction`).\n direction (list):\n two-component ``(dx, dy)`` shear coefficients applied to the output after rotation.\n Each unit of z in the result is sheared by ``dx`` in x and ``dy`` in y.\n Only the first two elements are used; `zshift` is unaffected by this parameter.\n rotation (float):\n set the angle of rotation.\n dr (float):\n set the radius variation in absolute units.\n cap (bool):\n enable or disable capping.\n res (int):\n set the resolution of the generating geometry.\n\n Warning:\n Some polygonal objects have no free edges (e.g., sphere). When swept, this will result\n in two separate surfaces if capping is on, or no surface if capping is off.\n\n Examples:\n - [extrude1.py](https://github.com/marcomusy/vedo/tree/master/examples/basic/extrude1.py)\n\n \n \"\"\"\n rf = vtki.new(\"RotationalExtrusionFilter\")\n rf.SetInputData(self.dataset) # must not be transformed\n rf.SetResolution(res)\n rf.SetCapping(cap)\n rf.SetAngle(rotation)\n rf.SetTranslation(zshift)\n rf.SetDeltaRadius(dr)\n rf.Update()\n\n m = Mesh(rf.GetOutput())\n\n if len(direction) >= 2:\n if len(direction) > 2:\n vedo.logger.warning(\"extrude(): direction uses only the first 2 components (dx, dy)\")\n p = self.pos()\n LT = vedo.LinearTransform()\n LT.translate(-p)\n LT.concatenate([[1, 0, direction[0]], [0, 1, direction[1]], [0, 0, 1]])\n LT.translate(p)\n m.apply_transform(LT)\n\n m.copy_properties_from(self).flat().lighting(\"default\")\n m.pipeline = OperationNode(\n \"extrude\", parents=[self], comment=f\"#pts {m.dataset.GetNumberOfPoints()}\"\n )\n m.name = \"ExtrudedMesh\"\n return m\n\n def extrude_linear(\n self,\n shift: float = 1.0,\n direction: Sequence[float] = (0, 0, 1),\n cap: bool = True,\n use_normal: bool = False,\n ) -> Self:\n \"\"\"\n Linearly extrude polygonal data using ``vtkLinearExtrusionFilter``.\n\n Args:\n shift (float):\n Extrusion scale factor. The total displacement of each point is\n ``shift * direction``, so pass a unit vector in `direction` unless\n intentional scaling via its magnitude is desired.\n direction (list):\n Extrusion vector. Ignored when ``use_normal=True``.\n Should normally be a unit vector; non-unit vectors scale the extrusion distance.\n cap (bool):\n Enable or disable capping.\n use_normal (bool):\n If ``True``, extrude along point normals instead of a fixed vector.\n\n Examples:\n - [extrude2.py](https://github.com/marcomusy/vedo/tree/master/examples/basic/extrude2.py)\n \"\"\"\n lf = vtki.new(\"LinearExtrusionFilter\")\n lf.SetInputData(self.dataset) # must not be transformed\n lf.SetCapping(cap)\n lf.SetScaleFactor(shift)\n\n if use_normal:\n lf.SetExtrusionTypeToNormalExtrusion()\n else:\n lf.SetExtrusionTypeToVectorExtrusion()\n if len(direction) != 3:\n vedo.logger.error(\n \"in extrude_linear(), direction must have 3 components\"\n )\n raise ValueError(\"direction must have 3 components\")\n lf.SetVector(direction[0], direction[1], direction[2])\n\n lf.Update()\n\n m = Mesh(lf.GetOutput())\n m.copy_properties_from(self).flat().lighting(\"default\")\n m.pipeline = OperationNode(\n \"extrude_linear\",\n parents=[self],\n comment=f\"#pts {m.dataset.GetNumberOfPoints()}\",\n )\n m.name = \"LinearExtrudedMesh\"\n return m\n\n def extrude_and_trim_with(\n self,\n surface: \"Mesh\",\n direction=(0, 0, 1),\n strategy=\"all\",\n cap=True,\n cap_strategy=\"max\",\n ) -> Self:\n \"\"\"\n Extrude a Mesh and trim it with an input surface mesh.\n\n Args:\n surface (Mesh):\n the surface mesh to trim with.\n direction (list):\n 3D extrusion direction vector.\n strategy (str):\n either ``\"bound\"`` (boundary edges only) or ``\"all\"`` (all edges).\n cap (bool):\n enable or disable capping.\n cap_strategy (str):\n either ``\"intersect\"``, ``\"min\"``, ``\"max\"``, or ``\"ave\"``\n (intersection, minimum, maximum, or average distance).\n\n The input Mesh is swept along a specified direction forming a \"skirt\"\n from the boundary edges 2D primitives (i.e., edges used by only one polygon);\n and/or from vertices and lines.\n The extent of the sweeping is limited by a second input: defined where\n the sweep intersects a user-specified surface.\n\n Capping of the extrusion can be enabled.\n In this case the input, generating primitive is copied inplace as well\n as to the end of the extrusion skirt.\n (See warnings below on what happens if the intersecting sweep does not\n intersect, or partially intersects the trim surface.)\n\n Note that this method operates in two fundamentally different modes\n based on the extrusion strategy.\n If the strategy is \"boundary_edges\", then only the boundary edges of the input's\n 2D primitives are extruded (verts and lines are extruded to generate lines and quads).\n However, if the extrusions strategy is \"all_edges\", then every edge of the 2D primitives\n is used to sweep out a quadrilateral polygon (again verts and lines are swept to produce lines and quads).\n\n Warning:\n The extrusion direction is assumed to define an infinite line.\n The intersection with the trim surface is along a ray from the - to + direction,\n however only the first intersection is taken.\n Some polygonal objects have no free edges (e.g., sphere). When swept, this will result in two separate\n surfaces if capping is on and \"boundary_edges\" enabled,\n or no surface if capping is off and \"boundary_edges\" is enabled.\n If all the extrusion lines emanating from an extruding primitive do not intersect the trim surface,\n then no output for that primitive will be generated. In extreme cases, it is possible that no output\n whatsoever will be generated.\n\n Examples:\n ```python\n from vedo import *\n sphere = Sphere([-1,0,4]).rotate_x(25).wireframe().color('red5')\n circle = Circle([0,0,0], r=2, res=100).color('b6')\n extruded_circle = circle.extrude_and_trim_with(\n sphere,\n direction=[0,-0.2,1],\n strategy=\"bound\",\n cap=True,\n cap_strategy=\"intersect\",\n )\n circle.lw(3).color(\"tomato\").shift(dz=-0.1)\n show(circle, sphere, extruded_circle, axes=1).close()\n ```\n \"\"\"\n if len(direction) != 3:\n vedo.logger.error(\"extrude_and_trim_with(): direction must have 3 components\")\n raise ValueError(\"direction must have 3 components\")\n\n trimmer = vtki.new(\"TrimmedExtrusionFilter\")\n trimmer.SetInputData(self.dataset)\n trimmer.SetCapping(cap)\n trimmer.SetExtrusionDirection(direction)\n trimmer.SetTrimSurfaceData(surface.dataset)\n if \"bound\" in strategy:\n trimmer.SetExtrusionStrategyToBoundaryEdges()\n elif \"all\" in strategy:\n trimmer.SetExtrusionStrategyToAllEdges()\n else:\n vedo.logger.warning(f\"extrude_and_trim_with(): unknown strategy {strategy!r}\")\n\n if \"intersect\" in cap_strategy:\n trimmer.SetCappingStrategyToIntersection()\n elif \"min\" in cap_strategy:\n trimmer.SetCappingStrategyToMinimumDistance()\n elif \"max\" in cap_strategy:\n trimmer.SetCappingStrategyToMaximumDistance()\n elif \"ave\" in cap_strategy:\n trimmer.SetCappingStrategyToAverageDistance()\n else:\n vedo.logger.warning(\n f\"extrude_and_trim_with(): unknown cap_strategy {cap_strategy!r}\"\n )\n\n trimmer.Update()\n\n m = Mesh(trimmer.GetOutput())\n m.copy_properties_from(self).flat().lighting(\"default\")\n m.pipeline = OperationNode(\n \"extrude_and_trim\",\n parents=[self, surface],\n comment=f\"#pts {m.dataset.GetNumberOfPoints()}\",\n )\n m.name = \"ExtrudedAndTrimmedMesh\"\n return m\n\n def split(\n self, max_regions=1000, flag=False, must_share_edge=False, sort_by_area=True\n ) -> list[Self]:\n \"\"\"\n Split a mesh by connectivity and return the pieces as a list.\n\n Args:\n max_regions (int):\n maximum number of mesh parts to return.\n flag (bool):\n if True, return a list containing only `self` updated in-place\n with a \"RegionId\" array added (on point data normally, on cell\n data when `must_share_edge=True`) instead of splitting into\n separate meshes.\n must_share_edge (bool):\n if True, regions that share only a single point (not a full\n edge) are treated as separate.\n sort_by_area (bool):\n if True, sort the returned pieces by decreasing area.\n Pipeline nodes are only recorded for the first 10 pieces.\n\n Examples:\n - [splitmesh.py](https://github.com/marcomusy/vedo/tree/master/examples/advanced/splitmesh.py)\n\n \n \"\"\"\n pd = self.dataset\n if must_share_edge:\n if pd.GetNumberOfPolys() == 0:\n vedo.logger.warning(\"in split(): no polygons found. Skip.\")\n return [self]\n cf = vtki.new(\"PolyDataEdgeConnectivityFilter\")\n cf.BarrierEdgesOff()\n else:\n cf = vtki.new(\"PolyDataConnectivityFilter\")\n\n cf.SetInputData(pd)\n cf.SetExtractionModeToAllRegions()\n cf.SetColorRegions(True)\n cf.Update()\n out = cf.GetOutput()\n\n if not out.GetNumberOfPoints():\n return [self]\n\n if flag:\n self._update(out)\n self.pipeline = OperationNode(\"split mesh\", parents=[self])\n return [self]\n\n tagged = Mesh(out)\n if must_share_edge:\n arr = tagged.celldata[\"RegionId\"]\n on = \"cells\"\n else:\n arr = tagged.pointdata[\"RegionId\"]\n on = \"points\"\n\n if len(arr) == 0:\n return [self]\n\n n_regions = min(int(arr.max()) + 1, max_regions)\n\n pieces = []\n for t in range(n_regions):\n piece = Mesh(out).threshold(\"RegionId\", t, t, on=on)\n piece.name = f\"MeshRegion{t}\"\n pieces.append((piece, piece.area() if sort_by_area else 0))\n\n if sort_by_area:\n pieces.sort(key=lambda x: x[1], reverse=True)\n\n result = []\n for i, (piece, _) in enumerate(pieces):\n piece.color(i + 1)\n piece.mapper.ScalarVisibilityOff()\n if i < 10:\n piece.pipeline = OperationNode(\n f\"split mesh {i}\",\n parents=[self],\n comment=f\"#pts {piece.dataset.GetNumberOfPoints()}\",\n )\n result.append(piece)\n return result\n\n def extract_largest_region(self) -> Self:\n \"\"\"\n Extract the largest connected part of a mesh and discard all the smaller pieces.\n\n Examples:\n - [largestregion.py](https://github.com/marcomusy/vedo/tree/master/examples/basic/largestregion.py)\n \"\"\"\n conn = vtki.new(\"PolyDataConnectivityFilter\")\n conn.SetExtractionModeToLargestRegion()\n conn.ScalarConnectivityOff()\n conn.SetInputData(self.dataset)\n conn.Update()\n\n m = Mesh(conn.GetOutput())\n m.copy_properties_from(self)\n m.pipeline = OperationNode(\n \"extract_largest_region\",\n parents=[self],\n comment=f\"#pts {m.dataset.GetNumberOfPoints()}\",\n )\n m.name = \"MeshLargestRegion\"\n return m\n\n def boolean(self, operation: str, mesh2, method=0, tol=None) -> Self:\n \"\"\"Volumetric union, intersection and subtraction of surfaces.\n\n Use `operation` for the allowed operations `['plus', 'intersect', 'minus']`.\n\n Two possible algorithms are available.\n Setting `method` to 0 (the default) uses the boolean operation algorithm\n written by Cory Quammen, Chris Weigle, and Russ Taylor (https://doi.org/10.54294/216g01);\n setting `method` to 1 will use the \"loop\" boolean algorithm\n written by Adam Updegrove (https://doi.org/10.1016/j.advengsoft.2016.01.015).\n\n Use `tol` to specify the absolute tolerance used to determine\n when the distance between two points is considered to be zero (defaults to 1e-6).\n\n Examples:\n - [boolean.py](https://github.com/marcomusy/vedo/tree/master/examples/basic/boolean.py)\n\n \n \"\"\"\n if method == 0:\n bf = vtki.new(\"BooleanOperationPolyDataFilter\")\n elif method == 1:\n bf = vtki.new(\"LoopBooleanPolyDataFilter\")\n else:\n raise ValueError(f\"Unknown method={method}\")\n\n poly1 = self.compute_normals().dataset\n poly2 = mesh2.compute_normals().dataset\n\n if operation.lower() in (\"plus\", \"+\"):\n bf.SetOperationToUnion()\n elif operation.lower() == \"intersect\":\n bf.SetOperationToIntersection()\n elif operation.lower() in (\"minus\", \"-\"):\n bf.SetOperationToDifference()\n\n if tol:\n bf.SetTolerance(tol)\n\n bf.SetInputData(0, poly1)\n bf.SetInputData(1, poly2)\n bf.Update()\n\n msh = Mesh(bf.GetOutput(), c=None)\n msh.flat()\n\n msh.pipeline = OperationNode(\n \"boolean \" + operation,\n parents=[self, mesh2],\n shape=\"cylinder\",\n comment=f\"#pts {msh.dataset.GetNumberOfPoints()}\",\n )\n msh.name = self.name + operation + mesh2.name\n return msh\n\n def intersect_with(self, mesh2, tol=1e-06) -> Self:\n \"\"\"\n Intersect this Mesh with the input surface to return a set of lines.\n\n Examples:\n - [surf_intersect.py](https://github.com/marcomusy/vedo/tree/master/examples/basic/surf_intersect.py)\n\n \n \"\"\"\n bf = vtki.new(\"IntersectionPolyDataFilter\")\n bf.SetGlobalWarningDisplay(0)\n bf.SetTolerance(tol)\n bf.SetInputData(0, self.dataset)\n bf.SetInputData(1, mesh2.dataset)\n bf.Update()\n msh = Mesh(bf.GetOutput(), c=\"k\", alpha=1).lighting(\"off\")\n msh.properties.SetLineWidth(3)\n msh.pipeline = OperationNode(\n \"intersect_with\", parents=[self, mesh2], comment=f\"#pts {msh.npoints}\"\n )\n msh.name = \"SurfaceIntersection\"\n return msh\n\n def intersect_with_line(\n self, p0, p1=None, return_ids=False, tol=0\n ) -> np.ndarray | tuple[np.ndarray, np.ndarray]:\n \"\"\"\n Return the list of points intersecting the mesh\n along the segment defined by two points `p0` and `p1`.\n\n `p0` can also be a `Points` object with exactly 2 points,\n in which case `p1` is ignored.\n\n Use `return_ids` to return the cell ids along with point coords.\n Pass `tol` to set the intersection tolerance; rebuilds the locator\n if the tolerance changes.\n\n Examples:\n ```python\n from vedo import *\n s = Spring()\n pts = s.intersect_with_line([0,0,0], [1,0.1,0])\n ln = Line([0,0,0], [1,0.1,0], c='blue')\n ps = Points(pts, r=10, c='r')\n show(s, ln, ps, bg='white').close()\n ```\n \n \"\"\"\n if isinstance(p0, Points):\n coords = p0.coordinates\n if len(coords) != 2:\n raise ValueError(\n f\"intersect_with_line: Points object must have exactly 2 points, got {len(coords)}\"\n )\n p0, p1 = coords[0], coords[1]\n\n p0 = np.asarray(p0, dtype=float)\n p1 = np.asarray(p1, dtype=float)\n\n if not tol:\n tol = mag(p1 - p0) / 10000\n\n if not self.line_locator or self.line_locator.GetTolerance() != tol:\n self.line_locator = vtki.new(\"OBBTree\")\n self.line_locator.SetDataSet(self.dataset)\n self.line_locator.SetTolerance(tol)\n self.line_locator.BuildLocator()\n\n vpts = vtki.vtkPoints()\n idlist = vtki.vtkIdList()\n self.line_locator.IntersectWithLine(p0, p1, vpts, idlist)\n\n n = vpts.GetNumberOfPoints()\n pts2 = np.zeros((n, 3))\n for i in range(n):\n vpts.GetPoint(i, pts2[i])\n\n if return_ids:\n pts_ids = np.array(\n [idlist.GetId(i) for i in range(idlist.GetNumberOfIds())],\n dtype=np.uint32,\n )\n return (pts2, pts_ids)\n\n return pts2\n\n def intersect_with_plane(self, origin=(0, 0, 0), normal=(1, 0, 0)) -> Self:\n \"\"\"\n Intersect this Mesh with a plane to return a set of lines.\n\n Examples:\n ```python\n from vedo import *\n sph = Sphere()\n mi = sph.clone().intersect_with_plane().join()\n print(mi.lines)\n show(sph, mi, axes=1).close()\n ```\n \n \"\"\"\n plane = vtki.new(\"Plane\")\n plane.SetOrigin(origin)\n plane.SetNormal(normal)\n\n cutter = vtki.new(\"PolyDataPlaneCutter\")\n cutter.SetInputData(self.dataset)\n cutter.SetPlane(plane)\n cutter.InterpolateAttributesOn()\n cutter.ComputeNormalsOff()\n cutter.Update()\n\n msh = Mesh(cutter.GetOutput())\n msh.c(\"k\").lw(3).lighting(\"off\")\n msh.pipeline = OperationNode(\n \"intersect_with_plane\",\n parents=[self],\n comment=f\"#pts {msh.dataset.GetNumberOfPoints()}\",\n )\n msh.name = \"PlaneIntersection\"\n return msh\n\n def cut_closed_surface(\n self, origins, normals, invert=False, return_assembly=False\n ) -> Self | vedo.Assembly:\n \"\"\"\n Cut/clip a closed surface mesh with a collection of planes.\n This will produce a new closed surface by creating new polygonal\n faces where the input surface hits the planes.\n\n The orientation of the polygons that form the surface is important.\n Polygons have a front face and a back face, and it's the back face that defines\n the interior or \"solid\" region of the closed surface.\n When a plane cuts through a \"solid\" region, a new cut face is generated,\n but not when a clipping plane cuts through a hole or \"empty\" region.\n This distinction is crucial when dealing with complex surfaces.\n Note that if a simple surface has its back faces pointing outwards,\n then that surface defines a hole in a potentially infinite solid.\n\n Non-manifold surfaces should not be used with this method.\n\n By default the part of the surface on the back side (negative normal side)\n of each plane is kept. Pass `invert=True` to keep the front side instead.\n Note this convention is opposite to `cut_with_planes()`.\n\n Args:\n origins (list):\n list of plane origins\n normals (list):\n list of plane normals, pointing toward the region to be removed\n invert (bool):\n if True, keep the front (positive normal) side instead.\n return_assembly (bool):\n return the cap and the clipped surfaces as a `vedo.Assembly`.\n\n Examples:\n ```python\n from vedo import *\n s = Sphere(res=50).linewidth(1)\n origins = [[-0.7, 0, 0], [0, -0.6, 0]]\n normals = [[-1, 0, 0], [0, -1, 0]]\n s.cut_closed_surface(origins, normals)\n show(s, axes=1).close()\n ```\n \"\"\"\n if len(origins) != len(normals):\n vedo.logger.error(\"cut_closed_surface: origins and normals must have the same length\")\n return self\n\n planes = vtki.new(\"PlaneCollection\")\n for p, n in zip(origins, normals):\n plane = vtki.vtkPlane()\n plane.SetOrigin(vedo.utils.make3d(p))\n plane.SetNormal(vedo.utils.make3d(n))\n planes.AddItem(plane)\n clipper = vtki.new(\"ClipClosedSurface\")\n clipper.SetInputData(self.dataset)\n clipper.SetClippingPlanes(planes)\n clipper.PassPointDataOn()\n clipper.GenerateFacesOn()\n clipper.SetScalarModeToNone()\n clipper.SetInsideOut(not invert)\n\n if return_assembly:\n clipper.GenerateClipFaceOutputOn()\n clipper.Update()\n parts = []\n for i in range(clipper.GetNumberOfOutputPorts()):\n msh = Mesh(clipper.GetOutput(i))\n msh.copy_properties_from(self)\n msh.name = \"CutClosedSurface\"\n msh.pipeline = OperationNode(\n \"cut_closed_surface\",\n parents=[self],\n comment=f\"#pts {msh.dataset.GetNumberOfPoints()}\",\n )\n parts.append(msh)\n asse = vedo.Assembly(parts)\n asse.name = \"CutClosedSurface\"\n return asse\n\n else:\n clipper.GenerateClipFaceOutputOff()\n clipper.Update()\n self._update(clipper.GetOutput())\n self.name = \"CutClosedSurface\"\n self.pipeline = OperationNode(\n \"cut_closed_surface\",\n parents=[self],\n comment=f\"#pts {self.dataset.GetNumberOfPoints()}\",\n )\n return self\n\n def collide_with(self, mesh2, tol=0, return_bool=False) -> Self | bool:\n \"\"\"\n Collide this Mesh with the input surface.\n Information is stored in `ContactCells1` and `ContactCells2`.\n \"\"\"\n ipdf = vtki.new(\"CollisionDetectionFilter\")\n\n transform0 = vtki.vtkTransform()\n transform1 = vtki.vtkTransform()\n\n ipdf.SetCellTolerance(tol)\n ipdf.SetInputData(0, self.dataset)\n ipdf.SetInputData(1, mesh2.dataset)\n ipdf.SetTransform(0, transform0)\n ipdf.SetTransform(1, transform1)\n if return_bool:\n ipdf.SetCollisionModeToFirstContact()\n else:\n ipdf.SetCollisionModeToAllContacts()\n ipdf.Update()\n\n if return_bool:\n return bool(ipdf.GetNumberOfContacts())\n\n msh = Mesh(ipdf.GetContactsOutput(), \"k\", 1).lighting(\"off\")\n msh.metadata[\"ContactCells1\"] = vtk2numpy(\n ipdf.GetOutput(0).GetFieldData().GetArray(\"ContactCells\")\n )\n msh.metadata[\"ContactCells2\"] = vtk2numpy(\n ipdf.GetOutput(1).GetFieldData().GetArray(\"ContactCells\")\n )\n msh.properties.SetLineWidth(3)\n\n msh.pipeline = OperationNode(\n \"collide_with\",\n parents=[self, mesh2],\n comment=f\"#pts {msh.dataset.GetNumberOfPoints()}\",\n )\n msh.name = \"SurfaceCollision\"\n return msh\n\n def geodesic(self, start, end) -> Self:\n \"\"\"\n Dijkstra algorithm to compute the geodesic line.\n Takes as input a polygonal mesh and performs a single source shortest path calculation.\n\n The output mesh contains the array \"VertexIDs\" that contains the ordered list of vertices\n traversed to get from the start vertex to the end vertex.\n\n Args:\n start (int, list):\n start vertex index or close point `[x,y,z]`\n end (int, list):\n end vertex index or close point `[x,y,z]`\n\n Examples:\n - [geodesic_curve.py](https://github.com/marcomusy/vedo/tree/master/examples/advanced/geodesic_curve.py)\n\n \n \"\"\"\n if is_sequence(start):\n cc = self.coordinates\n pa = Points(cc)\n start = pa.closest_point(start, return_point_id=True)\n end = pa.closest_point(end, return_point_id=True)\n\n dijkstra = vtki.new(\"DijkstraGraphGeodesicPath\")\n dijkstra.SetInputData(self.dataset)\n dijkstra.SetStartVertex(end) # inverted in vtk\n dijkstra.SetEndVertex(start)\n dijkstra.Update()\n\n weights = vtki.vtkDoubleArray()\n dijkstra.GetCumulativeWeights(weights)\n\n idlist = dijkstra.GetIdList()\n ids = [idlist.GetId(i) for i in range(idlist.GetNumberOfIds())]\n\n length = weights.GetMaxId() + 1\n arr = np.zeros(length)\n for i in range(length):\n arr[i] = weights.GetTuple(i)[0]\n\n poly = dijkstra.GetOutput()\n\n vdata = numpy2vtk(arr)\n vdata.SetName(\"CumulativeWeights\")\n poly.GetPointData().AddArray(vdata)\n\n vdata2 = numpy2vtk(ids, dtype=np.uint)\n vdata2.SetName(\"VertexIDs\")\n poly.GetPointData().AddArray(vdata2)\n poly.GetPointData().Modified()\n\n dmesh = Mesh(poly).copy_properties_from(self)\n dmesh.lw(3).alpha(1).lighting(\"off\")\n dmesh.name = \"GeodesicLine\"\n\n dmesh.pipeline = OperationNode(\n \"GeodesicLine\",\n parents=[self],\n comment=f\"#steps {poly.GetNumberOfPoints()}\",\n )\n return dmesh\n\n #####################################################################\n ### Stuff returning a Volume object\n #####################################################################\n def binarize(\n self,\n values=(255, 0),\n spacing=None,\n dims=None,\n origin=None,\n ) -> vedo.Volume:\n \"\"\"\n Convert a `Mesh` into a `Volume` where\n the interior voxels value is set to `values[0]` (255 by default), while\n the exterior voxels value is set to `values[1]` (0 by default).\n\n Args:\n values (list):\n background and foreground values.\n spacing (list):\n voxel spacing in x, y and z.\n dims (list):\n dimensions (nr. of voxels) of the output volume.\n origin (list):\n position in space of the (0,0,0) voxel.\n\n Examples:\n - [mesh2volume.py](https://github.com/marcomusy/vedo/tree/master/examples/volumetric/mesh2volume.py)\n\n \n \"\"\"\n if len(values) != 2:\n raise ValueError(\"values must be a list of 2 values\")\n fg_value, bg_value = values\n\n bounds = self.bounds()\n if spacing is None: # compute spacing\n spacing = [0, 0, 0]\n diagonal = np.sqrt(\n (bounds[1] - bounds[0]) ** 2\n + (bounds[3] - bounds[2]) ** 2\n + (bounds[5] - bounds[4]) ** 2\n )\n spacing[0] = spacing[1] = spacing[2] = diagonal / 250.0\n\n if dims is None: # compute dimensions\n dim = [0, 0, 0]\n for i in [0, 1, 2]:\n dim[i] = int(np.ceil((bounds[i * 2 + 1] - bounds[i * 2]) / spacing[i]))\n else:\n dim = dims\n\n white_img = vtki.vtkImageData()\n white_img.SetDimensions(dim)\n white_img.SetSpacing(spacing)\n white_img.SetExtent(0, dim[0] - 1, 0, dim[1] - 1, 0, dim[2] - 1)\n\n if origin is None:\n origin = [0, 0, 0]\n origin[0] = bounds[0] + spacing[0]\n origin[1] = bounds[2] + spacing[1]\n origin[2] = bounds[4] + spacing[2]\n white_img.SetOrigin(origin)\n\n # if direction_matrix is not None:\n # white_img.SetDirectionMatrix(direction_matrix)\n\n white_img.AllocateScalars(vtki.VTK_UNSIGNED_CHAR, 1)\n\n # fill the image with foreground voxels:\n white_img.GetPointData().GetScalars().Fill(fg_value)\n\n # polygonal data --> image stencil:\n pol2stenc = vtki.new(\"PolyDataToImageStencil\")\n pol2stenc.SetInputData(self.dataset)\n pol2stenc.SetOutputOrigin(white_img.GetOrigin())\n pol2stenc.SetOutputSpacing(white_img.GetSpacing())\n pol2stenc.SetOutputWholeExtent(white_img.GetExtent())\n pol2stenc.Update()\n\n # cut the corresponding white image and set the background:\n imgstenc = vtki.new(\"ImageStencil\")\n imgstenc.SetInputData(white_img)\n imgstenc.SetStencilConnection(pol2stenc.GetOutputPort())\n # imgstenc.SetReverseStencil(True)\n imgstenc.SetBackgroundValue(bg_value)\n imgstenc.Update()\n\n vol = vedo.Volume(imgstenc.GetOutput())\n vol.name = \"BinarizedVolume\"\n vol.pipeline = OperationNode(\n \"binarize\",\n parents=[self],\n comment=f\"dims={tuple(vol.dimensions())}\",\n c=\"#e9c46a:#0096c7\",\n )\n return vol\n\n def signed_distance(\n self, bounds=None, dims=(20, 20, 20), invert=False, max_radius=None\n ) -> vedo.Volume:\n \"\"\"\n Compute the `Volume` object whose voxels contains\n the signed distance from the mesh.\n\n Args:\n bounds (list):\n bounds of the output volume\n dims (list):\n dimensions (nr. of voxels) of the output volume\n invert (bool):\n flip the sign\n max_radius (float):\n ignored for meshes (only valid for point clouds); kept for API uniformity\n\n Examples:\n - [volume_from_mesh.py](https://github.com/marcomusy/vedo/tree/master/examples/volumetric/volume_from_mesh.py)\n \"\"\"\n if max_radius is not None:\n vedo.logger.warning(\n \"signed_distance(): max_radius is ignored for meshes (only valid for point clouds).\"\n )\n if bounds is None:\n bounds = self.bounds()\n\n imp = vtki.new(\"ImplicitPolyDataDistance\")\n imp.SetInput(self.dataset)\n\n sample = vtki.new(\"SampleFunction\")\n sample.SetImplicitFunction(imp)\n sample.SetModelBounds(bounds)\n sample.SetSampleDimensions(dims)\n sample.SetOutputScalarTypeToFloat()\n sample.SetScalarArrayName(\"Scalars\")\n sample.Update()\n img = sample.GetOutput()\n\n if invert:\n mat = vtki.new(\"ImageMathematics\")\n mat.SetInput1Data(img)\n mat.SetOperationToMultiplyByK()\n mat.SetConstantK(-1)\n mat.Update()\n img = mat.GetOutput()\n\n vol = vedo.Volume(img)\n vol.name = \"SignedVolume\"\n\n vol.pipeline = OperationNode(\n \"signed_distance\",\n parents=[self],\n comment=f\"dims={tuple(vol.dimensions())}\",\n c=\"#e9c46a:#0096c7\",\n )\n return vol\n\n def tetralize(\n self,\n side=0.02,\n nmax=300_000,\n gap=None,\n subsample=False,\n uniform=True,\n seed=0,\n debug=False,\n ) -> vedo.TetMesh:\n \"\"\"\n Tetralize a closed polygonal mesh. Return a `TetMesh`.\n\n Args:\n side (float):\n desired side of the single tetras as fraction of the bounding box diagonal.\n Typical values are in the range (0.01 - 0.03)\n nmax (int):\n maximum random numbers to be sampled in the bounding box\n gap (float):\n keep this minimum distance from the surface,\n if None an automatic choice is made.\n subsample (bool):\n subsample input surface, the geometry might be affected\n (the number of original faces reduced), but higher tet quality might be obtained.\n uniform (bool):\n generate tets more uniformly packed in the interior of the mesh\n seed (int):\n random number generator seed\n debug (bool):\n show an intermediate plot with sampled points\n\n Examples:\n - [tetralize_surface.py](https://github.com/marcomusy/vedo/tree/master/examples/volumetric/tetralize_surface.py)\n\n \n \"\"\"\n surf = self.clone().clean().compute_normals()\n d = surf.diagonal_size()\n rng = np.random.default_rng(seed)\n if gap is None:\n gap = side * d * np.sqrt(2 / 3)\n n = int(min((1 / side) ** 3, nmax))\n\n # fill the space w/ points\n x0, x1, y0, y1, z0, z1 = surf.bounds()\n\n if uniform:\n pts = vedo.utils.pack_spheres([x0, x1, y0, y1, z0, z1], side * d * 1.42)\n if len(pts) > nmax:\n rng.shuffle(pts)\n pts = pts[:nmax]\n pts += (\n rng.normal(size=(len(pts), 3)) * side * d * 1.42 / 100\n ) # some small jitter\n else:\n disp = np.array([x0 + x1, y0 + y1, z0 + z1]) / 2\n pts = (rng.random((n, 3)) - 0.5) * np.array(\n [x1 - x0, y1 - y0, z1 - z0]\n ) + disp\n\n normals = surf.celldata[\"Normals\"]\n cc = surf.cell_centers().coordinates\n subpts = cc - normals * gap * 1.05\n pts = pts.tolist() + subpts.tolist()\n\n if debug:\n print(\".. tetralize(): subsampling and cleaning\")\n\n fillpts = surf.inside_points(pts)\n fillpts.subsample(side)\n\n if gap > 0:\n fillpts.distance_to(surf)\n fillpts.threshold(\"Distance\", above=gap)\n\n surf_closed = surf.clone() if subsample else surf\n if subsample:\n surf.subsample(side)\n\n merged_fs = vedo.merge(fillpts, surf)\n tmesh = merged_fs.generate_delaunay3d()\n tcenters = tmesh.cell_centers().coordinates\n\n ids = surf_closed.inside_points(tcenters, return_ids=True)\n ins = np.zeros(tmesh.ncells)\n ins[ids] = 1\n\n if debug:\n edges = self.edges\n points = self.coordinates\n elen = mag(points[edges][:, 0, :] - points[edges][:, 1, :])\n histo = vedo.pyplot.histogram(\n elen, xtitle=\"edge length\", xlim=(0, 3 * side * d)\n )\n print(\".. edges min, max\", elen.min(), elen.max())\n fillpts.cmap(\"bone\")\n vedo.show(\n [\n [\n f\"This is a debug plot.\\n\\nGenerated points: {n}\\ngap: {gap}\",\n surf.wireframe().alpha(0.2),\n vedo.addons.Axes(surf),\n fillpts,\n Points(subpts).c(\"r4\").ps(3),\n ],\n [\n f\"Edges mean length: {np.mean(elen)}\\n\\nPress q to continue\",\n histo,\n ],\n ],\n N=2,\n sharecam=False,\n new=True,\n ).close()\n print(\".. thresholding\")\n\n tmesh.celldata[\"inside\"] = ins.astype(np.uint8)\n tmesh.threshold(\"inside\", above=0.9)\n tmesh.celldata.remove(\"inside\")\n\n if debug:\n print(f\".. tetralize() completed, ntets = {tmesh.ncells}\")\n\n tmesh.pipeline = OperationNode(\n \"tetralize\",\n parents=[self],\n comment=f\"#tets = {tmesh.ncells}\",\n c=\"#e9c46a:#9e2a2b\",\n )\n return tmesh\n"}}},{"rowIdx":122699,"cells":{"sha256":{"kind":"string","value":"309deae66f37bbf6abdeb8e85b9ad2bc3b5045ff94d07822d7533a7b1e9aa7df"},"language":{"kind":"string","value":"Python"},"size":{"kind":"number","value":107642,"string":"107,642"},"lines":{"kind":"number","value":2580,"string":"2,580"},"content":{"kind":"string","value":"\"\"\"Filesystem tests for installing the bundled agent skills into a project.\n\nThe install command writes into a directory that belongs to the user rather than to this\npackage, which makes most of what it does a promise about what it will *not* touch: a\nsecond run must not rewrite an unchanged copy, an edited copy must survive being refused,\na directory Great Expectations never created must be byte-for-byte untouched even under\n``--force``, and a write that fails must leave nothing behind. None of those promises can\nbe checked by reading the report a run returns -- a report is what the installer *says*\nit did -- so every assertion below is made against the filesystem: bytes, link targets,\nownership manifests, modification times and inode numbers.\n\nEach check is a function returning a list of problems, and each one is paired with a test\nthat runs the same check against a deliberately broken build of the installer -- copying\nthat dereferences symlinks, an ownership check that trusts every directory, a staged\nwrite that goes straight to the destination -- and asserts the check reports it. A\nfilesystem check that quietly stopped comparing anything would otherwise keep passing\nforever while asserting nothing, which is the failure mode these tests exist to prevent.\n\nEverything runs against directories built under ``tmp_path``. Nothing here installs into\nthe checkout, and nothing reaches the network.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport argparse\nimport contextlib\nimport dataclasses\nimport hashlib\nimport importlib.util\nimport itertools\nimport json\nimport pathlib\nimport shutil\nimport stat\nimport types\nfrom collections.abc import Iterator, Sequence\nfrom typing import Callable, Final\n\nimport pytest\n\nimport great_expectations\nfrom great_expectations import __main__ as command_line\nfrom great_expectations.agent_skills import installer\nfrom great_expectations.agent_skills.installer import (\n MANIFEST_NAME,\n InstallMode,\n SkillFailureKind,\n SkillInstallFailure,\n SkillInstallReport,\n SkillTarget,\n install_skills,\n)\n\npytestmark = [pytest.mark.unit]\n\nPROJECT_ROOT: Final = pathlib.Path(__file__).parents[2]\nBUNDLED_SKILLS_ROOT: Final = PROJECT_ROOT / \"great_expectations\" / \".agents\" / \"skills\"\n\nENTRY_DOCUMENT: Final = \"SKILL.md\"\nREFERENCE_DIR: Final = \"references\"\nSTAGING_PREFIX: Final = \".gx-tmp-\"\n\nALL_TARGETS: Final = (SkillTarget.AGENTS, SkillTarget.CLAUDE)\n\n#: Number of skills the package is known to bundle. Guards the checks over the real\n#: bundle against a discovery bug reducing them to nothing.\nMIN_BUNDLED_SKILLS: Final = 2\n\n#: Two synthetic skills into two target directories. Every check over the synthetic\n#: bundle asserts it had at least this many destinations to look at, so a scenario that\n#: silently stopped installing anything cannot pass by comparing empty sets.\nMIN_DESTINATIONS: Final = 4\n\n#: Versions the synthetic package claims. Neither is a real release, so a check that\n#: read the real version by accident fails rather than passes.\nINSTALLED_VERSION: Final = \"1.3.0.test\"\nEARLIER_VERSION: Final = \"1.2.0.test\"\n\nFILE: Final = \"file\"\nLINK: Final = \"link\"\nDIRECTORY: Final = \"directory\"\n\n#: How deep the synthetic bundle really goes (``references/guide.md``). A walk that\n#: descended through the symlink cycles below would report paths far deeper than this.\nREAL_TREE_DEPTH: Final = 2\n#: Depth reached by a link-following walk before the demonstration below gives up. Well\n#: past the real depth and well short of the point where the kernel refuses to resolve\n#: any more symlink components.\nCYCLE_DEPTH_EVIDENCE: Final = 8\n#: Entries the link-following demonstration is allowed to visit before it is cut off. A\n#: walk that terminates on its own never reaches this.\nCYCLE_WALK_LIMIT: Final = 400\n\n\n# ---------------------------------------------------------------------------\n# Recording what is on disk, independently of the code under test.\n# ---------------------------------------------------------------------------\n\n\n@dataclasses.dataclass(frozen=True)\nclass Entry:\n \"\"\"One path in a tree, as the filesystem holds it.\n\n Identity is deliberately recorded twice over: ``kind`` and ``payload`` say what the\n user would read, while ``mtime_ns`` and ``inode`` say whether it was written. A run\n that rewrote a file with identical bytes changes the second pair and not the first,\n and \"already up to date\" is a claim about both.\n \"\"\"\n\n kind: str\n #: Link target for a link, a hash of the bytes for a file, empty for a directory.\n payload: str\n size: int\n mtime_ns: int\n inode: int\n\n\ndef walk(root: pathlib.Path) -> Iterator[pathlib.Path]:\n \"\"\"Yield every path below ``root`` without following links.\n\n Spelled out here rather than borrowed from the installer: a test that measured the\n filesystem with the code under test would report a broken walk as an unchanged tree.\n \"\"\"\n pending = [root]\n while pending:\n for entry in sorted(pending.pop().iterdir()):\n yield entry\n if entry.is_dir() and not entry.is_symlink():\n pending.append(entry)\n\n\ndef snapshot(root: pathlib.Path) -> dict[str, Entry]:\n \"\"\"Record a whole tree, keyed by path relative to ``root``.\"\"\"\n recorded: dict[str, Entry] = {}\n for path in walk(root):\n stats = path.lstat()\n if path.is_symlink():\n kind, payload, size = LINK, str(path.readlink()), 0\n elif path.is_file():\n payload_bytes = path.read_bytes()\n kind, payload, size = (\n FILE,\n hashlib.sha256(payload_bytes).hexdigest(),\n len(payload_bytes),\n )\n else:\n kind, payload, size = DIRECTORY, \"\", 0\n recorded[path.relative_to(root).as_posix()] = Entry(\n kind=kind, payload=payload, size=size, mtime_ns=stats.st_mtime_ns, inode=stats.st_ino\n )\n return recorded\n\n\ndef contents(recorded: dict[str, Entry]) -> dict[str, tuple[str, str]]:\n \"\"\"Reduce a snapshot to what a reader would see, dropping when it was written.\"\"\"\n return {name: (entry.kind, entry.payload) for name, entry in recorded.items()}\n\n\ndef describe(entry: Entry) -> str:\n if entry.kind == LINK:\n return f\"a link to {entry.payload}\"\n if entry.kind == FILE:\n return f\"a file of {entry.size} bytes ({entry.payload[:12]})\"\n return \"a directory\"\n\n\n# ---------------------------------------------------------------------------\n# The synthetic package the scenarios install from.\n# ---------------------------------------------------------------------------\n\n\n@dataclasses.dataclass(frozen=True)\nclass Bundle:\n \"\"\"A stand-in for the skills directory inside an installed package.\"\"\"\n\n root: pathlib.Path\n names: tuple[str, ...]\n\n @property\n def skills(self) -> list[pathlib.Path]:\n return [self.root / name for name in self.names]\n\n def source_for(self, destination: pathlib.Path) -> pathlib.Path:\n return self.root / destination.name\n\n\n@pytest.fixture\ndef bundle(tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch) -> Bundle:\n \"\"\"A package bundling two skills, with a directory that is not one alongside them.\n\n Synthetic rather than the real content because the scenarios need to change what the\n package holds -- an upgrade adds a file, a defective packaging run drops an entry\n document -- and because a check that reads the real bundle would change meaning every\n time the shipped guidance is edited. The real bundle is covered separately.\n \"\"\"\n root = tmp_path / \"site-packages\" / \"great_expectations\" / \".agents\" / \"skills\"\n names = (\"gx-first-skill\", \"gx-second-skill\")\n for index, name in enumerate(names):\n skill = root / name\n (skill / REFERENCE_DIR).mkdir(parents=True)\n (skill / ENTRY_DOCUMENT).write_text(\n f\"---\\nname: {name}\\n---\\n\\n# {name}\\n\\nSee `{REFERENCE_DIR}/guide.md`.\\n\",\n encoding=\"utf-8\",\n )\n (skill / REFERENCE_DIR / \"guide.md\").write_text(f\"# guide {index}\\n\", encoding=\"utf-8\")\n not_a_skill = root / \"shared-fragments\"\n not_a_skill.mkdir()\n (not_a_skill / \"fragment.md\").write_text(\"# not a skill: no entry document\\n\", encoding=\"utf-8\")\n\n monkeypatch.setattr(installer, \"_bundled_skills_root\", lambda: root)\n monkeypatch.setattr(great_expectations, \"__version__\", INSTALLED_VERSION)\n return Bundle(root=root, names=names)\n\n\n@pytest.fixture\ndef bundle_with_links(bundle: Bundle) -> Bundle:\n \"\"\"The same package, with a skill holding an ordinary link and a dangling one.\n\n Both belong here: a link that resolves is what a build step or a packaging tool\n leaves behind, and a link that does not is what an upgrade leaves behind when the\n file it pointed at is dropped. Neither may abort an install, and neither may make an\n installed copy hash differently from the skill it was copied from.\n \"\"\"\n references = bundle.root / bundle.names[0] / REFERENCE_DIR\n (references / \"shared.md\").symlink_to(pathlib.Path(\"guide.md\"))\n (references / \"dropped.md\").symlink_to(pathlib.Path(\"gone.md\"))\n return bundle\n\n\n@pytest.fixture\ndef project(tmp_path: pathlib.Path) -> pathlib.Path:\n root = tmp_path / \"project\"\n root.mkdir()\n return root\n\n\ndef expected_destinations(\n project: pathlib.Path, bundle: Bundle, targets: Sequence[SkillTarget] = ALL_TARGETS\n) -> list[pathlib.Path]:\n return [project / target.value / name for target in targets for name in bundle.names]\n\n\ndef stamp_manifest_version(destination: pathlib.Path, version: str) -> None:\n \"\"\"Rewrite the version an installed skill records, leaving its content alone.\n\n This is what an installed skill looks like after the package is upgraded: the tree\n still matches the hash its own manifest recorded, so it is unmodified, but it is no\n longer what this version of the package would install. The manifest is excluded from\n the hash, so editing it here does not make the destination look edited.\n \"\"\"\n path = destination / MANIFEST_NAME\n manifest = json.loads(path.read_text(encoding=\"utf-8\"))\n manifest[\"gx_version\"] = version\n path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + \"\\n\", encoding=\"utf-8\")\n\n\n@contextlib.contextmanager\ndef made_unreadable(path: pathlib.Path) -> Iterator[None]:\n \"\"\"Take away every permission on ``path`` for the duration, then give them back.\"\"\"\n original = stat.S_IMODE(path.lstat().st_mode)\n path.chmod(0o000)\n try:\n yield\n finally:\n path.chmod(original)\n\n\ndef is_readable(path: pathlib.Path) -> bool:\n try:\n list(path.iterdir())\n except OSError:\n return False\n return True\n\n\n# ---------------------------------------------------------------------------\n# Checks. Each returns the problems it found, so the same code can be asserted\n# empty against the real installer and non-empty against a broken one.\n# ---------------------------------------------------------------------------\n\n\ndef describe_report(report: SkillInstallReport) -> str:\n failed = \", \".join(f\"{failure.destination}: {failure.kind.value}\" for failure in report.failed)\n return (\n f\"installed={[str(path) for path in report.installed]},\"\n f\" up_to_date={[str(path) for path in report.up_to_date]},\"\n f\" replaced={[str(path) for path in report.replaced]},\"\n f\" failed=[{failed}]\"\n )\n\n\ndef failure_for(\n report: SkillInstallReport, destination: pathlib.Path\n) -> SkillInstallFailure | None:\n for failure in report.failed:\n if failure.destination == destination:\n return failure\n return None\n\n\ndef partition_problems(report: SkillInstallReport, expected: Sequence[pathlib.Path]) -> list[str]:\n \"\"\"Every destination the run considered must appear in exactly one outcome.\n\n A caller reports the whole run by printing the four fields, so a destination in two\n of them is reported twice and one in none of them is never mentioned at all.\n \"\"\"\n if not expected:\n return [\"the run considered no destinations, so its partition proves nothing\"]\n groups = {\n \"installed\": tuple(report.installed),\n \"up_to_date\": tuple(report.up_to_date),\n \"replaced\": tuple(report.replaced),\n \"failed\": tuple(failure.destination for failure in report.failed),\n }\n problems: list[str] = []\n for destination in sorted(set(expected).union(*(set(group) for group in groups.values()))):\n appearances = [\n name for name, group in groups.items() for path in group if path == destination\n ]\n if len(appearances) > 1:\n problems.append(f\"{destination} is reported in {sorted(appearances)}, not in one.\")\n elif not appearances:\n problems.append(f\"{destination} is reported in no outcome; the run must place it.\")\n elif destination not in expected:\n problems.append(\n f\"{destination} is reported as {appearances[0]} but is not a destination\"\n \" this run had to consider.\"\n )\n return problems\n\n\ndef manifest_problems(\n destination: pathlib.Path, source: pathlib.Path, version: str, mode: InstallMode\n) -> list[str]:\n \"\"\"The ownership manifest must record who installed this, at which version and how.\"\"\"\n path = destination / MANIFEST_NAME\n try:\n manifest = json.loads(path.read_text(encoding=\"utf-8\"))\n except (OSError, json.JSONDecodeError) as error:\n return [f\"{path}: no readable ownership manifest ({error}).\"]\n expected = {\n \"managed_by\": \"great_expectations\",\n \"gx_version\": version,\n \"content_sha256\": installer._tree_digest(source),\n \"mode\": mode.value,\n }\n return [\n f\"{path}: {field} is {manifest.get(field)!r}, expected {value!r}.\"\n for field, value in expected.items()\n if manifest.get(field) != value\n ]\n\n\ndef difference_problems(\n source: pathlib.Path,\n destination: pathlib.Path,\n expected: dict[str, tuple[str, str]],\n actual: dict[str, tuple[str, str]],\n) -> list[str]:\n problems: list[str] = []\n for name in sorted(set(expected) - set(actual)):\n problems.append(f\"{destination}: {name} is missing; {source} holds it.\")\n for name in sorted(set(actual) - set(expected)):\n problems.append(f\"{destination}: {name} was installed but is not part of {source}.\")\n for name in sorted(set(actual) & set(expected)):\n if actual[name] != expected[name]:\n problems.append(\n f\"{destination}: {name} is {actual[name][0]} ({actual[name][1][:12]}) but\"\n f\" {source / name} is {expected[name][0]} ({expected[name][1][:12]}).\"\n )\n return problems\n\n\ndef installed_copy_problems(\n source: pathlib.Path, destination: pathlib.Path, version: str\n) -> list[str]:\n \"\"\"A copy install must reproduce the bundled skill entry for entry.\n\n The digests are compared as well as the trees, because the digest is what every later\n run decides on: a copy that reads the same but hashes differently is reported as\n edited for ever afterwards.\n \"\"\"\n if destination.is_symlink() or not destination.is_dir():\n return [f\"{destination} is not a directory; a copy install must create one.\"]\n expected = contents(snapshot(source))\n if not expected:\n return [f\"{source} holds nothing, so comparing {destination} against it proves nothing.\"]\n actual = contents(snapshot(destination))\n problems: list[str] = []\n if actual.pop(MANIFEST_NAME, None) is None:\n problems.append(\n f\"{destination} holds no {MANIFEST_NAME}; nothing records who installed it.\"\n )\n problems += difference_problems(source, destination, expected, actual)\n problems += manifest_problems(destination, source, version, InstallMode.COPY)\n installed_digest = installer._tree_digest(destination)\n if installed_digest != installer._tree_digest(source):\n problems.append(\n f\"{destination} hashes to {installed_digest[:12]} but {source} hashes to\"\n f\" {installer._tree_digest(source)[:12]}; every later run would call this copy edited.\"\n )\n return problems\n\n\ndef linked_install_problems(\n source: pathlib.Path, destination: pathlib.Path, version: str\n) -> list[str]:\n \"\"\"A symlink install must be a real directory of links into the installed package.\n\n Not a single link to the package: the ownership manifest is written into the\n destination, and a link would put it inside the installed package instead.\n \"\"\"\n if destination.is_symlink() or not destination.is_dir():\n return [f\"{destination} is not a directory; a symlink install must create one.\"]\n expected = {entry.name for entry in source.iterdir()}\n if not expected:\n return [f\"{source} holds nothing to link to.\"]\n actual = {entry.name: entry for entry in destination.iterdir() if entry.name != MANIFEST_NAME}\n problems: list[str] = []\n if set(actual) != expected:\n problems.append(f\"{destination} links {sorted(actual)}; {source} holds {sorted(expected)}.\")\n for name, entry in sorted(actual.items()):\n if not entry.is_symlink():\n problems.append(\n f\"{entry} is a real file or directory rather than a link into {source}.\"\n )\n elif entry.readlink() != source / name:\n problems.append(f\"{entry} links to {entry.readlink()}, not to {source / name}.\")\n problems += entry_document_readable_problems(source, destination)\n problems += manifest_problems(destination, source, version, InstallMode.SYMLINK)\n return problems\n\n\ndef entry_document_readable_problems(source: pathlib.Path, destination: pathlib.Path) -> list[str]:\n \"\"\"The entry document must read back through the destination, or no agent finds it.\"\"\"\n try:\n installed = (destination / ENTRY_DOCUMENT).read_bytes()\n except OSError as error:\n return [f\"{destination / ENTRY_DOCUMENT} cannot be read: {error}.\"]\n if installed != (source / ENTRY_DOCUMENT).read_bytes():\n return [f\"{destination / ENTRY_DOCUMENT} does not read back as {source / ENTRY_DOCUMENT}.\"]\n return []\n\n\ndef unchanged_problems(destination: pathlib.Path, before: dict[str, Entry]) -> list[str]:\n \"\"\"Nothing under ``destination`` may have been read back differently, or rewritten.\"\"\"\n if not before:\n return [f\"{destination} held nothing before the run, so comparing it proves nothing.\"]\n if destination.is_symlink() or not destination.is_dir():\n return [\n f\"{destination} is no longer a directory; it held {len(before)} entries\"\n \" before the run and has to hold them still.\"\n ]\n after = snapshot(destination)\n problems: list[str] = []\n for name in sorted(set(after) - set(before)):\n problems.append(\n f\"{destination}: {name} appeared ({describe(after[name])}) in an untouched run.\"\n )\n for name in sorted(set(before) - set(after)):\n problems.append(f\"{destination}: {name} was removed ({describe(before[name])}).\")\n for name in sorted(set(before) & set(after)):\n old, new = before[name], after[name]\n if (new.kind, new.payload) != (old.kind, old.payload):\n problems.append(\n f\"{destination}: {name} was rewritten: {describe(old)} became {describe(new)}.\"\n )\n elif (new.mtime_ns, new.inode) != (old.mtime_ns, old.inode):\n problems.append(\n f\"{destination}: {name} was written again with the same content\"\n \" (its modification time or inode changed); an untouched run writes nothing.\"\n )\n return problems\n\n\ndef staging_remnant_problems(project: pathlib.Path) -> list[str]:\n \"\"\"No half-written tree may be left beside a destination once a run has returned.\"\"\"\n problems: list[str] = []\n for target in ALL_TARGETS:\n parent = project / target.value\n if not parent.is_dir():\n continue\n for entry in sorted(parent.iterdir()):\n if entry.name.startswith(STAGING_PREFIX):\n problems.append(\n f\"{entry} was left behind; a run must remove what it staged before returning.\"\n )\n return problems\n\n\ndef reason_problems(failure: SkillInstallFailure, mentions: Sequence[str] = ()) -> list[str]:\n problems: list[str] = []\n if not failure.reason.strip():\n problems.append(f\"{failure.destination}: the failure carries no reason to show the user.\")\n problems += [\n f\"{failure.destination}: the reason does not name {mention}: {failure.reason}\"\n for mention in mentions\n if mention not in failure.reason\n ]\n return problems\n\n\ndef refusal_problems(\n report: SkillInstallReport,\n destination: pathlib.Path,\n kind: SkillFailureKind,\n mentions: Sequence[str] = (),\n) -> list[str]:\n failure = failure_for(report, destination)\n if failure is None:\n return [\n f\"{destination} must be reported as failed with {kind.value};\"\n f\" got {describe_report(report)}\"\n ]\n if failure.kind is not kind:\n return [f\"{destination} was refused as {failure.kind.value}, expected {kind.value}.\"]\n return reason_problems(failure, mentions)\n\n\n# ---------------------------------------------------------------------------\n# Scenarios: setup, one or two runs, and the filesystem afterwards.\n# ---------------------------------------------------------------------------\n\n\ndef fresh_install_problems(project: pathlib.Path, bundle: Bundle) -> list[str]:\n report = install_skills(project, targets=ALL_TARGETS)\n expected = expected_destinations(project, bundle)\n problems = non_vacuity_problems(expected)\n problems += partition_problems(report, expected)\n if set(report.installed) != set(expected):\n problems.append(\n f\"a first run must install every destination; got {describe_report(report)}\"\n )\n for destination in expected:\n problems += installed_copy_problems(\n bundle.source_for(destination), destination, INSTALLED_VERSION\n )\n for target in ALL_TARGETS:\n stray = project / target.value / \"shared-fragments\"\n if stray.exists():\n problems.append(f\"{stray}: a directory holding no {ENTRY_DOCUMENT} is not a skill.\")\n problems += staging_remnant_problems(project)\n return problems\n\n\ndef non_vacuity_problems(expected: Sequence[pathlib.Path]) -> list[str]:\n if len(expected) < MIN_DESTINATIONS:\n return [\n f\"expected at least {MIN_DESTINATIONS} destinations to check, got\"\n f\" {[str(path) for path in expected]}\"\n ]\n return []\n\n\ndef idempotency_problems(project: pathlib.Path, bundle: Bundle, mode: InstallMode) -> list[str]:\n first = install_skills(project, targets=ALL_TARGETS, mode=mode)\n expected = expected_destinations(project, bundle)\n problems = non_vacuity_problems(expected)\n if first.failed:\n return [\n *problems,\n f\"the first run must succeed before idempotency means anything;\"\n f\" got {describe_report(first)}\",\n ]\n before = {destination: snapshot(destination) for destination in expected}\n\n second = install_skills(project, targets=ALL_TARGETS, mode=mode)\n\n problems += partition_problems(second, expected)\n if set(second.up_to_date) != set(expected):\n problems.append(\n f\"a second run must leave every destination alone; got {describe_report(second)}\"\n )\n for destination, recorded in before.items():\n problems += unchanged_problems(destination, recorded)\n problems += staging_remnant_problems(project)\n return problems\n\n\n@dataclasses.dataclass(frozen=True)\nclass InstalledProject:\n \"\"\"A project with every skill installed, and what everything looked like then.\n\n Both sides are recorded, the project and the package, because the questions a\n re-run answers are all comparisons between the two: what the destination held when\n it was installed, and what the package ships now.\n \"\"\"\n\n project: pathlib.Path\n bundle: Bundle\n destinations: list[pathlib.Path]\n installed: dict[pathlib.Path, dict[str, Entry]]\n bundled: dict[str, dict[str, tuple[str, str]]]\n\n\ndef install_and_record(project: pathlib.Path, bundle: Bundle) -> InstalledProject:\n \"\"\"Install every skill and record the state a later run will be measured against.\"\"\"\n install_skills(project, targets=ALL_TARGETS)\n destinations = expected_destinations(project, bundle)\n return InstalledProject(\n project=project,\n bundle=bundle,\n destinations=destinations,\n installed={destination: snapshot(destination) for destination in destinations},\n bundled={skill.name: contents(snapshot(skill)) for skill in bundle.skills},\n )\n\n\ndef rewrite_bundled_skills(bundle: Bundle) -> None:\n \"\"\"Change what the package ships, leaving its version alone.\n\n Kept separate from the version so that either can be moved without the other. A\n release changes both; a source checkout or an editable install changes only this,\n and that is the case in which the recorded hash is the only thing that notices.\n \"\"\"\n for skill in bundle.skills:\n (skill / ENTRY_DOCUMENT).write_text(\n f\"---\\nname: {skill.name}\\n---\\n\\n# {skill.name}, rewritten since the install\\n\",\n encoding=\"utf-8\",\n )\n (skill / REFERENCE_DIR / \"added.md\").write_text(\n \"# added since the install\\n\", encoding=\"utf-8\"\n )\n\n\ndef replacement_problems(\n state: InstalledProject, report: SkillInstallReport, content_changed: bool\n) -> list[str]:\n \"\"\"Every destination must now hold what the package holds.\n\n ``content_changed`` is a dimension the caller sets, not something this decides: a\n run can reach here because the version moved, because the content moved, or because\n both did, and a check that assumed one of those would stop being able to tell the\n others apart. It is verified before it is used -- a \"content moved\" run in which the\n package did not actually change proves nothing, and neither does a \"version only\"\n run in which the content moved as well.\n \"\"\"\n problems = non_vacuity_problems(state.destinations)\n problems += partition_problems(report, state.destinations)\n if set(report.replaced) != set(state.destinations):\n problems.append(f\"every installed skill must be replaced; got {describe_report(report)}\")\n for destination in state.destinations:\n source = state.bundle.source_for(destination)\n moved = contents(snapshot(source)) != state.bundled[source.name]\n if moved is not content_changed:\n problems.append(\n f\"{source} {'changed' if moved else 'did not change'} since the install,\"\n f\" which is not the run this is checking (content_changed={content_changed}).\"\n )\n problems += installed_copy_problems(source, destination, great_expectations.__version__)\n if content_changed:\n problems += arrival_problems(destination, state.installed[destination])\n problems += staging_remnant_problems(state.project)\n return problems\n\n\ndef arrival_problems(destination: pathlib.Path, before: dict[str, Entry]) -> list[str]:\n \"\"\"The new content has to have reached the destination, not just the manifest.\n\n A run that rewrote the ownership manifest and nothing else reports every destination\n as replaced and leaves the user reading the skill they had before.\n \"\"\"\n was = {name: (entry.kind, entry.payload) for name, entry in before.items()}\n now = contents(snapshot(destination))\n if {name: entry for name, entry in was.items() if name != MANIFEST_NAME} == {\n name: entry for name, entry in now.items() if name != MANIFEST_NAME\n }:\n return [\n f\"{destination} holds exactly what it held before the run: the changed skill\"\n \" never reached the project, whatever the report says.\"\n ]\n return []\n\n\n@dataclasses.dataclass(frozen=True)\nclass EditedSkill:\n \"\"\"An installed skill the user has since edited, and the run's other destinations.\"\"\"\n\n project: pathlib.Path\n bundle: Bundle\n edited: pathlib.Path\n others: list[pathlib.Path]\n before: dict[str, Entry]\n\n\ndef install_and_edit(project: pathlib.Path, bundle: Bundle) -> EditedSkill:\n \"\"\"Install every skill, then add a file to one of the installed copies.\n\n The edit and the package version are deliberately left as two separate dimensions.\n A setup that always bumped the version alongside the edit would leave \"the user\n edited this\" and \"this is from an older release\" indistinguishable, and no test built\n on it could show which of the two a refusal -- or a repair -- was really keyed on.\n \"\"\"\n install_skills(project, targets=ALL_TARGETS)\n edited = project / SkillTarget.AGENTS.value / bundle.names[0]\n (edited / REFERENCE_DIR / \"notes.md\").write_text(\"notes the user added\\n\", encoding=\"utf-8\")\n expected = expected_destinations(project, bundle)\n return EditedSkill(\n project=project,\n bundle=bundle,\n edited=edited,\n others=[destination for destination in expected if destination != edited],\n before=snapshot(edited),\n )\n\n\ndef edited_skill_problems(\n state: EditedSkill, report: SkillInstallReport, force: bool, stale: bool\n) -> list[str]:\n \"\"\"What a re-run must have done to an edited copy, and to everything around it.\n\n ``stale`` says only whether the package moved on since the install, which changes\n what happens to the destinations that were *not* edited. The edited one's outcome is\n the same either way, and that is the contract: ownership is decided before staleness,\n so a run that compared versions first would replace an edited copy and lose the edits\n on the very command that is supposed to be safe to re-run.\n \"\"\"\n expected = [state.edited, *state.others]\n problems = non_vacuity_problems(expected)\n problems += partition_problems(report, expected)\n untouched = report.replaced if stale else report.up_to_date\n if set(untouched) - {state.edited} != set(state.others):\n expectation = \"brought up to the new version\" if stale else \"left up to date\"\n problems.append(\n f\"the destinations that were not edited must be {expectation};\"\n f\" got {describe_report(report)}\"\n )\n if force:\n if state.edited not in report.replaced:\n problems.append(f\"--force must replace {state.edited}; got {describe_report(report)}\")\n problems += forced_repair_problems(state)\n else:\n problems += refusal_problems(report, state.edited, SkillFailureKind.LOCALLY_MODIFIED)\n problems += unchanged_problems(state.edited, state.before)\n problems += staging_remnant_problems(state.project)\n return problems\n\n\ndef forced_repair_problems(state: EditedSkill) -> list[str]:\n \"\"\"After ``--force``, the edited copy must be the bundled skill and nothing else.\"\"\"\n problems: list[str] = []\n if (state.edited / REFERENCE_DIR / \"notes.md\").exists():\n problems.append(f\"{state.edited} still holds the edit --force was asked to overwrite.\")\n problems += installed_copy_problems(\n state.bundle.source_for(state.edited), state.edited, great_expectations.__version__\n )\n return problems\n\n\n#: An ownership manifest that parses, and names an owner that is not this package.\nANOTHER_OWNERS_MANIFEST: Final = json.dumps(\n {\"managed_by\": \"some-other-tool\", \"gx_version\": INSTALLED_VERSION, \"mode\": \"copy\"},\n indent=2,\n sort_keys=True,\n)\n\n#: Bytes that are not text at all: what a truncated write, a compressed file restored\n#: under the wrong name, or an editor saving in another encoding leaves behind.\nUNDECODABLE_MANIFEST: Final = b'{\"managed_by\": \"\\xff\\xfegreat_expectations\"}'\n\n#: Every way a destination can fail to prove that Great Expectations installed it, one\n#: per branch that decides it: absent or unreadable, bytes that will not decode, text\n#: that will not parse, JSON that is not a mapping, and a mapping naming another owner.\n#: Ownership that cannot be proved is ownership by someone else, so all of these have to\n#: be refused identically -- and none of them may end the run, since the manifest is read\n#: before the point at which a destination's problems start being caught.\nUNPROVEN_OWNERSHIP: Final = [\n pytest.param(None, id=\"no_manifest\"),\n pytest.param(UNDECODABLE_MANIFEST, id=\"undecodable\"),\n pytest.param(\"{ this never parsed\", id=\"unparseable\"),\n pytest.param('[\"great_expectations\"]', id=\"not_a_mapping\"),\n pytest.param(ANOTHER_OWNERS_MANIFEST, id=\"another_owner\"),\n]\n\n\ndef undecodable_problems(manifest: bytes) -> list[str]:\n \"\"\"The bytes have to be undecodable, or the case they stand for is not being tested.\"\"\"\n try:\n manifest.decode(\"utf-8\")\n except UnicodeDecodeError:\n return []\n return [f\"{manifest!r} decodes as UTF-8, so it does not stand for a manifest that cannot.\"]\n\n\ndef foreign_destination_problems(\n project: pathlib.Path, bundle: Bundle, force: bool, manifest: str | bytes | None = None\n) -> list[str]:\n \"\"\"A destination this package did not install is never replaced, with or without force.\n\n ``manifest`` is what sits at the ownership manifest's path: nothing, or a file that\n fails to prove ownership -- as text that cannot be decoded, cannot be parsed, or\n parses into something that is not this package's. A directory another tool manages is\n the case that looks most like one of ours, since it holds a manifest and that\n manifest parses, so only the recorded owner tells them apart.\n \"\"\"\n foreign = project / SkillTarget.CLAUDE.value / bundle.names[0]\n foreign.mkdir(parents=True)\n (foreign / ENTRY_DOCUMENT).write_text(\"---\\nname: mine\\n---\\n\\n# a skill I wrote\\n\", \"utf-8\")\n (foreign / \"notes.md\").write_text(\"notes of my own\\n\", encoding=\"utf-8\")\n expected = expected_destinations(project, bundle)\n problems = non_vacuity_problems(expected)\n if isinstance(manifest, bytes):\n (foreign / MANIFEST_NAME).write_bytes(manifest)\n problems += undecodable_problems(manifest)\n elif manifest is not None:\n (foreign / MANIFEST_NAME).write_text(manifest, encoding=\"utf-8\")\n before = snapshot(foreign)\n\n try:\n report = install_skills(project, targets=ALL_TARGETS, force=force)\n except Exception as error:\n # Caught rather than allowed to end the test, because \"the run did not survive\n # this destination\" is the finding, and the module's whole promise is that a\n # problem with one skill is reported instead of raised.\n return [\n *problems,\n \"a destination that cannot be read as one of ours must cost that destination\"\n f\" and no more; the run raised {error!r}\",\n ]\n\n problems += partition_problems(report, expected)\n problems += refusal_problems(report, foreign, SkillFailureKind.FOREIGN_DESTINATION)\n problems += unchanged_problems(foreign, before)\n others = [destination for destination in expected if destination != foreign]\n if set(report.installed) != set(others):\n problems.append(\n f\"refusing one destination must not stop the others; got {describe_report(report)}\"\n )\n for destination in others:\n problems += installed_copy_problems(\n bundle.source_for(destination), destination, INSTALLED_VERSION\n )\n problems += staging_remnant_problems(project)\n return problems\n\n\ndef write_failure_problems(project: pathlib.Path, bundle: Bundle) -> list[str]:\n \"\"\"A failed first write must disclose itself and leave nothing at the destination.\"\"\"\n expected = expected_destinations(project, bundle)\n problems = non_vacuity_problems(expected)\n\n report = install_skills(project, targets=ALL_TARGETS)\n\n problems += partition_problems(report, expected)\n for destination in expected:\n problems += refusal_problems(report, destination, SkillFailureKind.WRITE_FAILED)\n if destination.exists() or destination.is_symlink():\n problems.append(\n f\"{destination} exists after a write that failed; a run that could not\"\n \" finish must leave nothing an agent could read.\"\n )\n problems += staging_remnant_problems(project)\n return problems\n\n\ndef failed_replacement_problems(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n) -> list[str]:\n \"\"\"A failed replacement must leave the skill that was already installed intact.\"\"\"\n monkeypatch.setattr(great_expectations, \"__version__\", EARLIER_VERSION)\n install_skills(project, targets=ALL_TARGETS)\n expected = expected_destinations(project, bundle)\n problems = non_vacuity_problems(expected)\n before = {destination: snapshot(destination) for destination in expected}\n monkeypatch.setattr(great_expectations, \"__version__\", INSTALLED_VERSION)\n break_writing(monkeypatch)\n\n report = install_skills(project, targets=ALL_TARGETS)\n\n problems += partition_problems(report, expected)\n for destination in expected:\n problems += refusal_problems(report, destination, SkillFailureKind.WRITE_FAILED)\n problems += unchanged_problems(destination, before[destination])\n problems += staging_remnant_problems(project)\n return problems\n\n\ndef swap_failure_problems(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch, restore: bool = True\n) -> list[str]:\n \"\"\"A rename that fails while the destination is briefly absent must put it back.\n\n Replacing an existing skill cannot be one rename, because renaming onto a non-empty\n directory is not allowed: the old tree is moved aside first, and between the two\n renames the destination does not exist. A failure in that window is the only way this\n module can lose a skill it was asked to update, so the previous contents are moved\n back and the failure is reported against that destination alone.\n \"\"\"\n monkeypatch.setattr(great_expectations, \"__version__\", EARLIER_VERSION)\n install_skills(project, targets=ALL_TARGETS)\n expected = expected_destinations(project, bundle)\n problems = non_vacuity_problems(expected)\n before = {destination: snapshot(destination) for destination in expected}\n monkeypatch.setattr(great_expectations, \"__version__\", INSTALLED_VERSION)\n break_the_swap(monkeypatch, restore=restore)\n\n report = install_skills(project, targets=ALL_TARGETS)\n\n problems += partition_problems(report, expected)\n for destination in expected:\n # The reason names the staging directory the previous contents may be sitting in,\n # which is what makes it worth reading next to a failure that never got that far.\n problems += refusal_problems(\n report, destination, SkillFailureKind.WRITE_FAILED, mentions=[STAGING_PREFIX]\n )\n problems += unchanged_problems(destination, before[destination])\n problems += staging_remnant_problems(project)\n return problems\n\n\ndef remnant_sweep_problems(project: pathlib.Path, bundle: Bundle) -> list[str]:\n \"\"\"A tree left behind by an interrupted run is cleaned up by the next one.\n\n Staging beside the destination is what keeps a crash from producing a half-written\n skill, and it is only free of litter if the leftovers are swept: without this the\n project accumulates a directory per interrupted run, for ever.\n \"\"\"\n install_skills(project, targets=ALL_TARGETS)\n expected = expected_destinations(project, bundle)\n problems = non_vacuity_problems(expected)\n remnant = project / SkillTarget.AGENTS.value / f\"{STAGING_PREFIX}{bundle.names[0]}-9c1f0ae4b2d7\"\n (remnant / REFERENCE_DIR).mkdir(parents=True)\n (remnant / ENTRY_DOCUMENT).write_text(\"half a skill, left by a crash\\n\", encoding=\"utf-8\")\n if not remnant.is_dir():\n return [f\"{remnant} was not created, so sweeping it proves nothing.\"]\n before = {destination: snapshot(destination) for destination in expected}\n\n report = install_skills(project, targets=ALL_TARGETS)\n\n problems += partition_problems(report, expected)\n if set(report.up_to_date) != set(expected):\n problems.append(\n f\"a run over an unchanged project must leave it alone; got {describe_report(report)}\"\n )\n problems += staging_remnant_problems(project)\n for destination in expected:\n problems += unchanged_problems(destination, before[destination])\n return problems\n\n\ndef unreadable_destination_problems(project: pathlib.Path, bundle: Bundle) -> list[str]:\n \"\"\"One path this user cannot read must cost one destination, not the whole run.\"\"\"\n install_skills(project, targets=ALL_TARGETS)\n expected = expected_destinations(project, bundle)\n problems = non_vacuity_problems(expected)\n damaged = project / SkillTarget.AGENTS.value / bundle.names[0]\n unreadable = damaged / REFERENCE_DIR\n before = {destination: snapshot(destination) for destination in expected}\n others = [destination for destination in expected if destination != damaged]\n\n report: SkillInstallReport | None = None\n with made_unreadable(unreadable):\n if is_readable(unreadable):\n return [\n f\"{unreadable} is still readable with no permissions at all, so this check\"\n \" cannot mean anything; it has to run as a user the filesystem restricts.\"\n ]\n try:\n report = install_skills(project, targets=ALL_TARGETS)\n except OSError as error:\n problems.append(\n f\"a path that cannot be read must cost one destination, not the run;\"\n f\" the run raised {error!r}\"\n )\n if report is None:\n return problems\n\n problems += partition_problems(report, expected)\n problems += refusal_problems(\n report, damaged, SkillFailureKind.UNREADABLE_DESTINATION, mentions=[str(unreadable)]\n )\n if set(report.up_to_date) != set(others):\n problems.append(\n f\"every other destination must still be handled; got {describe_report(report)}\"\n )\n for destination in expected:\n problems += unchanged_problems(destination, before[destination])\n return problems\n\n\ndef empty_bundle_problems(project: pathlib.Path) -> list[str]:\n \"\"\"A package that bundles nothing must be refused, not reported as a clean run.\"\"\"\n try:\n report = install_skills(project, targets=ALL_TARGETS)\n except FileNotFoundError as error:\n problems = []\n if \"bundles no agent skills\" not in str(error):\n problems.append(f\"the refusal must say the package bundles no skills; got {error}\")\n if any(project.iterdir()):\n problems.append(f\"{project} must be left alone when there is nothing to install.\")\n return problems\n return [\n \"a package bundling no skills must be refused: a run in which nothing was installed\"\n f\" was reported as a run in which nothing went wrong ({describe_report(report)})\"\n ]\n\n\ndef mode_switch_problems(\n project: pathlib.Path, bundle: Bundle, installed_as: InstallMode, asked_for: InstallMode\n) -> list[str]:\n \"\"\"Re-running in a different mode must convert what is installed, not skip it.\n\n The two modes hold the same content, the same version and the same recorded hash, so\n the only thing that distinguishes an installed copy from an installed link is the\n mode the manifest records. A run that did not compare it would tell a user who asked\n for links that everything was already up to date, and leave them with copies.\n \"\"\"\n install_skills(project, targets=ALL_TARGETS, mode=installed_as)\n expected = expected_destinations(project, bundle)\n problems = non_vacuity_problems(expected)\n\n report = install_skills(project, targets=ALL_TARGETS, mode=asked_for)\n\n problems += partition_problems(report, expected)\n if set(report.replaced) != set(expected):\n problems.append(\n f\"asking for {asked_for.value} where {installed_as.value} is installed must\"\n f\" replace every destination; got {describe_report(report)}\"\n )\n check = linked_install_problems if asked_for is InstallMode.SYMLINK else installed_copy_problems\n for destination in expected:\n problems += check(\n bundle.source_for(destination), destination, great_expectations.__version__\n )\n problems += staging_remnant_problems(project)\n return problems\n\n\ndef symlink_mode_problems(project: pathlib.Path, bundle: Bundle) -> list[str]:\n expected = expected_destinations(project, bundle)\n problems = non_vacuity_problems(expected)\n\n report = install_skills(project, targets=ALL_TARGETS, mode=InstallMode.SYMLINK)\n\n problems += partition_problems(report, expected)\n if set(report.installed) != set(expected):\n problems.append(\n f\"a first run must install every destination; got {describe_report(report)}\"\n )\n for destination in expected:\n problems += linked_install_problems(\n bundle.source_for(destination), destination, INSTALLED_VERSION\n )\n problems += staging_remnant_problems(project)\n return problems\n\n\n# ---------------------------------------------------------------------------\n# Deliberately broken builds of the installer, each modelling a defect the\n# checks above exist to catch.\n# ---------------------------------------------------------------------------\n\n\ndef stop_writing_manifests(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Installs the content but records no ownership, so no later run can tell it is ours.\"\"\"\n monkeypatch.setattr(installer, \"_write_manifest\", lambda *arguments: None)\n\n\ndef dereference_symlinks(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Copies what a link points at instead of the link, the way a plain copytree does.\"\"\"\n real = shutil.copytree\n\n def copytree(source, destination, symlinks=False, *arguments, **keywords):\n keywords.pop(\"symlinks\", None)\n return real(source, destination, False, *arguments, **keywords)\n\n monkeypatch.setattr(shutil, \"copytree\", copytree)\n\n\ndef ignore_the_version_stamp(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Treats every destination as stale, so a second run rewrites what it just wrote.\"\"\"\n monkeypatch.setattr(installer, \"_is_current\", lambda *arguments: False)\n\n\ndef treat_everything_as_current(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Treats every destination as up to date, so an upgrade never reaches the project.\"\"\"\n monkeypatch.setattr(installer, \"_is_current\", lambda *arguments: True)\n\n\ndef stop_comparing_the_recorded_hash(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Compares the version and the mode, but not the content the manifest recorded.\n\n Two releases can ship identical skills, and a source checkout ships changed skills\n under the version it was already carrying, so the recorded hash is the only thing\n that notices content moving without the version moving. Without it, anyone\n developing against an editable install re-runs the command, is told everything is\n up to date, and never sees their change reach the project.\n \"\"\"\n\n def is_current(destination, source, manifest, digest, context):\n if (\n manifest.get(\"gx_version\") != context.version\n or manifest.get(\"mode\") != context.mode.value\n ):\n return False\n if context.mode is InstallMode.SYMLINK:\n return installer._links_point_at(destination, source)\n return True\n\n monkeypatch.setattr(installer, \"_is_current\", is_current)\n\n\ndef ignore_local_edits(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Trusts every managed destination, so the user's edits are silently overwritten.\"\"\"\n monkeypatch.setattr(installer, \"_is_unmodified\", lambda *arguments: True)\n\n\ndef install_nothing(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Reports every destination as written and writes nothing at all.\"\"\"\n monkeypatch.setattr(installer, \"_materialize\", lambda *arguments: None)\n\n\ndef claim_every_directory(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Reads an ownership manifest out of any directory, including the user's own.\"\"\"\n monkeypatch.setattr(\n installer,\n \"read_skill_manifest\",\n lambda directory: {\"managed_by\": \"great_expectations\", \"mode\": InstallMode.COPY.value},\n )\n\n\ndef stop_checking_the_owner(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Accepts any manifest that parses, without asking whose it is.\n\n The narrower slip: a manifest that is missing, unreadable or not a mapping is still\n rejected, so every destination that holds no manifest behaves exactly as before. Only\n a directory another tool manages changes hands -- and it is the case that looks most\n like one of ours.\n \"\"\"\n\n def read_skill_manifest(directory):\n try:\n raw = (directory / MANIFEST_NAME).read_text(encoding=\"utf-8\")\n except (OSError, UnicodeDecodeError):\n return None\n try:\n manifest = json.loads(raw)\n except json.JSONDecodeError:\n return None\n return manifest if isinstance(manifest, dict) else None\n\n monkeypatch.setattr(installer, \"read_skill_manifest\", read_skill_manifest)\n\n\ndef stop_swallowing_undecodable_manifests(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Reads the manifest as text without allowing for bytes that are not text.\n\n Every other way of failing to prove ownership is answered with \"not ours\". This one\n escapes instead -- and it escapes from the one call made before the caller starts\n guarding, so it does not cost a destination, it ends the whole run: every other\n skill and every other target with it, under a traceback rather than a report.\n \"\"\"\n\n def read_skill_manifest(directory):\n try:\n raw = (directory / MANIFEST_NAME).read_text(encoding=\"utf-8\")\n except OSError:\n return None\n try:\n manifest = json.loads(raw)\n except json.JSONDecodeError:\n return None\n if not isinstance(manifest, dict) or manifest.get(\"managed_by\") != \"great_expectations\":\n return None\n return manifest\n\n monkeypatch.setattr(installer, \"read_skill_manifest\", read_skill_manifest)\n\n\ndef ignore_edits_when_deciding_staleness(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Decides staleness without first asking whether the copy was edited.\n\n Production asks \"does this already hold what the run would install?\" only of copies\n that still match their own manifest. Dropping that one conjunction leaves an edited\n copy at the current version looking up to date, so ``--force`` reports success,\n writes nothing, and the edit stays where it is: a repair the command claims to have\n made and did not. Everything else about this build is production's own code.\n \"\"\"\n\n def install_one(source, destination, digest, context):\n if not installer._lexists(destination):\n installer._materialize(source, destination, digest, context)\n return installer._Outcome.INSTALLED\n manifest = installer.read_skill_manifest(destination)\n if manifest is None:\n raise installer._SkillRefusal(\n SkillFailureKind.FOREIGN_DESTINATION, installer._FOREIGN_DESTINATION_REASON\n )\n try:\n unmodified = installer._is_unmodified(destination, manifest)\n current = installer._is_current(destination, source, manifest, digest, context)\n except OSError as error:\n raise installer._SkillRefusal(\n SkillFailureKind.UNREADABLE_DESTINATION,\n installer._unreadable_destination_reason(error),\n ) from error\n if not unmodified and not context.force:\n raise installer._SkillRefusal(\n SkillFailureKind.LOCALLY_MODIFIED, installer._LOCALLY_MODIFIED_REASON\n )\n if current:\n return installer._Outcome.UP_TO_DATE\n installer._materialize(source, destination, digest, context)\n return installer._Outcome.REPLACED\n\n monkeypatch.setattr(installer, \"_install_one\", install_one)\n\n\ndef break_the_swap(monkeypatch: pytest.MonkeyPatch, restore: bool = True) -> None:\n \"\"\"Fails the rename that moves a staged tree into place.\n\n By then the previous tree has already been renamed aside, so this is the one moment\n at which the destination does not exist. ``restore`` leaves the second attempt --\n the one that puts the previous tree back -- working, which is what production\n promises; turning it off models a filesystem that fails that too, and shows what the\n check would have to notice.\n \"\"\"\n real = pathlib.Path.replace\n failed: set[str] = set()\n\n def replace(self, target):\n target = pathlib.Path(target)\n moving_into_place = self.name.startswith(STAGING_PREFIX) and not target.name.startswith(\n STAGING_PREFIX\n )\n if moving_into_place and (not restore or str(target) not in failed):\n failed.add(str(target))\n raise OSError(16, \"Device or resource busy\", str(target))\n return real(self, target)\n\n monkeypatch.setattr(pathlib.Path, \"replace\", replace)\n\n\ndef break_writing(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Fails partway through writing, the way a full disk does: some files, then an error.\"\"\"\n\n def copytree(source, destination, *arguments, **keywords):\n source, destination = pathlib.Path(source), pathlib.Path(destination)\n destination.mkdir(parents=True)\n shutil.copy2(source / ENTRY_DOCUMENT, destination / ENTRY_DOCUMENT)\n raise OSError(28, \"No space left on device\", str(destination))\n\n monkeypatch.setattr(shutil, \"copytree\", copytree)\n\n\ndef leave_staging_behind(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Never cleans up, so a failed write leaves its half-written tree in the project.\"\"\"\n monkeypatch.setattr(installer, \"_remove\", lambda path: None)\n\n\ndef write_without_staging(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Writes straight into the destination, so a failure leaves a half-written skill.\"\"\"\n\n def materialize(source, destination, digest, context):\n installer._remove(destination)\n installer._stage(source, destination, context.mode)\n installer._write_manifest(destination, digest, context)\n\n monkeypatch.setattr(installer, \"_materialize\", materialize)\n\n\ndef abort_on_read_failure(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Lets a read error end the whole run instead of costing one destination.\"\"\"\n real = installer._install_one\n\n def install_one(source, destination, digest, context):\n try:\n return real(source, destination, digest, context)\n except installer._SkillRefusal as refusal:\n if refusal.kind is SkillFailureKind.UNREADABLE_DESTINATION:\n raise OSError(str(refusal)) from refusal\n raise\n\n monkeypatch.setattr(installer, \"_install_one\", install_one)\n\n\ndef treat_unreadable_as_unchanged(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Answers \"has the user edited this?\" with \"no\" when it cannot read the answer.\"\"\"\n real = installer._is_unmodified\n\n def is_unmodified(destination, manifest):\n try:\n return real(destination, manifest)\n except OSError:\n return True\n\n monkeypatch.setattr(installer, \"_is_unmodified\", is_unmodified)\n\n\ndef report_an_empty_bundle_as_success(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Returns no skills where a defective installation should be refused outright.\"\"\"\n monkeypatch.setattr(installer, \"iter_bundled_skills\", lambda: iter(()))\n\n\ndef ignore_the_install_mode(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Compares the version and the content, but not how the skill was installed.\n\n Copies and links carry the same recorded hash -- it describes the package's content,\n which is what both of them serve -- so without the mode a project installed one way\n is reported up to date when the other way is asked for.\n \"\"\"\n\n def is_current(destination, source, manifest, digest, context):\n return (\n manifest.get(\"gx_version\") == context.version\n and manifest.get(\"content_sha256\") == digest\n )\n\n monkeypatch.setattr(installer, \"_is_current\", is_current)\n\n\ndef trust_links_without_looking(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Assumes installed links still point into the package, wherever it has got to.\"\"\"\n monkeypatch.setattr(installer, \"_links_point_at\", lambda destination, source: True)\n\n\ndef copy_where_links_were_asked_for(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Ignores symlink mode and copies, so the install stops tracking the package.\"\"\"\n\n def stage(source, staging, mode):\n shutil.copytree(source, staging, symlinks=True)\n\n monkeypatch.setattr(installer, \"_stage\", stage)\n\n\ndef refuse_to_make_links(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"A platform that permits symlinks only for privileged accounts.\"\"\"\n\n def symlink_to(self, target, target_is_directory=False):\n raise OSError(1, \"Operation not permitted\", str(self))\n\n monkeypatch.setattr(pathlib.Path, \"symlink_to\", symlink_to)\n\n\ndef hide_failures(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Drops the refusals from the report the command exits on.\"\"\"\n real = command_line.install_skills\n\n def install(*arguments, **keywords):\n return dataclasses.replace(real(*arguments, **keywords), failed=())\n\n monkeypatch.setattr(command_line, \"install_skills\", install)\n\n\ndef hide_the_outcome_group(monkeypatch: pytest.MonkeyPatch, group: str) -> None:\n \"\"\"Empties one whole outcome out of the report the command prints.\n\n Indistinguishable, from the printing code's side, from a build that stopped printing\n that group: the destinations are installed correctly either way, the command still\n exits 0, and the only thing lost is the user being told.\n \"\"\"\n real = command_line.install_skills\n\n def install(*arguments, **keywords):\n return dataclasses.replace(real(*arguments, **keywords), **{group: ()})\n\n monkeypatch.setattr(command_line, \"install_skills\", install)\n\n\ndef label_failures_by_appearance(monkeypatch: pytest.MonkeyPatch) -> None:\n \"\"\"Derives the failure kind from the destination afterwards instead of recording it.\n\n This is the heuristic the typed failure kind replaced: a destination that exists and\n holds an ownership manifest is called edited. A destination whose subdirectory could\n not be read satisfies both conditions, which is exactly why the kind cannot be\n recovered after the fact.\n \"\"\"\n real = command_line.install_skills\n\n def install(*arguments, **keywords):\n report = real(*arguments, **keywords)\n return dataclasses.replace(\n report,\n failed=tuple(\n dataclasses.replace(failure, kind=SkillFailureKind.LOCALLY_MODIFIED)\n if failure.destination.exists()\n and installer.read_skill_manifest(failure.destination) is not None\n else failure\n for failure in report.failed\n ),\n )\n\n monkeypatch.setattr(command_line, \"install_skills\", install)\n\n\n# ---------------------------------------------------------------------------\n# A first run.\n# ---------------------------------------------------------------------------\n\n\ndef test_a_first_run_installs_every_skill_into_every_target(project: pathlib.Path, bundle: Bundle):\n assert not fresh_install_problems(project, bundle)\n\n\ndef test_a_first_run_without_ownership_manifests_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n stop_writing_manifests(monkeypatch)\n\n problems = fresh_install_problems(project, bundle)\n\n assert [problem for problem in problems if MANIFEST_NAME in problem]\n\n\ndef test_the_skills_this_package_bundles_install_as_exact_copies(project: pathlib.Path):\n \"\"\"The real bundle, found the way an installed package is: through the import system.\n\n The digest comparison inside is the claim the rest of the installer rests on. If a\n bundled skill does not hash to the same value once installed -- which is what happens\n the moment a copy stops preserving something the hash describes -- then no run after\n the first can tell an untouched install from one the user edited.\n \"\"\"\n skills = list(installer.iter_bundled_skills())\n assert len(skills) >= MIN_BUNDLED_SKILLS, f\"found {[skill.name for skill in skills]}\"\n assert {skill.parent for skill in skills} == {BUNDLED_SKILLS_ROOT}, (\n f\"the package resolved its skills to {sorted({str(skill.parent) for skill in skills})},\"\n f\" not to {BUNDLED_SKILLS_ROOT}\"\n )\n\n report = install_skills(project, targets=ALL_TARGETS)\n\n expected = [project / target.value / skill.name for target in ALL_TARGETS for skill in skills]\n assert not partition_problems(report, expected)\n assert set(report.installed) == set(expected), describe_report(report)\n problems = [\n problem\n for destination in expected\n for problem in installed_copy_problems(\n BUNDLED_SKILLS_ROOT / destination.name,\n destination,\n great_expectations.__version__,\n )\n ]\n assert not problems, \"\\n\".join(problems)\n\n\ndef test_a_copy_that_dereferenced_a_link_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n \"\"\"Dereferencing is the one copying defect a report cannot show: every file arrives.\n\n What arrives is a real file where the package holds a link, so the copy hashes\n differently from the skill it was copied from and every later run calls it edited.\n \"\"\"\n (bundle.root / bundle.names[0] / REFERENCE_DIR / \"shared.md\").symlink_to(\n pathlib.Path(\"guide.md\")\n )\n dereference_symlinks(monkeypatch)\n\n problems = fresh_install_problems(project, bundle)\n\n assert [problem for problem in problems if \"hashes to\" in problem]\n assert [problem for problem in problems if \"shared.md\" in problem]\n\n\ndef test_a_copy_that_dereferenced_a_dangling_link_is_reported(\n project: pathlib.Path, bundle_with_links: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n \"\"\"The same defect meeting a link to a file the package no longer ships: it cannot\n copy at all, and the skill never reaches the project.\n \"\"\"\n dereference_symlinks(monkeypatch)\n\n problems = fresh_install_problems(project, bundle_with_links)\n\n assert [problem for problem in problems if \"is not a directory\" in problem]\n\n\n# ---------------------------------------------------------------------------\n# The report accounts for every destination exactly once.\n# ---------------------------------------------------------------------------\n\n\ndef test_every_destination_lands_in_exactly_one_outcome(project: pathlib.Path, bundle: Bundle):\n \"\"\"One run producing all four outcomes at once, which is when a partition can slip.\"\"\"\n install_skills(project, targets=ALL_TARGETS)\n first, second = bundle.names\n edited = project / SkillTarget.AGENTS.value / first\n (edited / REFERENCE_DIR / \"notes.md\").write_text(\"notes the user added\\n\", encoding=\"utf-8\")\n removed = project / SkillTarget.CLAUDE.value / first\n shutil.rmtree(removed)\n stale = project / SkillTarget.CLAUDE.value / second\n stamp_manifest_version(stale, EARLIER_VERSION)\n untouched = project / SkillTarget.AGENTS.value / second\n\n report = install_skills(project, targets=ALL_TARGETS)\n\n expected = expected_destinations(project, bundle)\n assert not non_vacuity_problems(expected)\n assert not partition_problems(report, expected)\n assert report.installed == (removed,), describe_report(report)\n assert report.up_to_date == (untouched,), describe_report(report)\n assert report.replaced == (stale,), describe_report(report)\n assert [failure.destination for failure in report.failed] == [edited], describe_report(report)\n problems = [\n problem\n for destination in (removed, stale, untouched)\n for problem in installed_copy_problems(\n bundle.source_for(destination), destination, INSTALLED_VERSION\n )\n ]\n assert not problems, \"\\n\".join(problems)\n\n\ndef test_a_destination_reported_twice_is_caught(tmp_path: pathlib.Path):\n destination = tmp_path / SkillTarget.AGENTS.value / \"gx-first-skill\"\n report = SkillInstallReport(\n installed=(destination,), up_to_date=(destination,), replaced=(), failed=()\n )\n\n problems = partition_problems(report, [destination])\n\n assert [problem for problem in problems if \"installed\" in problem and \"up_to_date\" in problem]\n\n\ndef test_a_destination_reported_nowhere_is_caught(tmp_path: pathlib.Path):\n destination = tmp_path / SkillTarget.AGENTS.value / \"gx-first-skill\"\n report = SkillInstallReport(installed=(), up_to_date=(), replaced=(), failed=())\n\n problems = partition_problems(report, [destination])\n\n assert [problem for problem in problems if \"no outcome\" in problem]\n\n\n# ---------------------------------------------------------------------------\n# Running it again.\n# ---------------------------------------------------------------------------\n\n\ndef test_a_second_run_leaves_every_installed_skill_untouched(project: pathlib.Path, bundle: Bundle):\n assert not idempotency_problems(project, bundle, InstallMode.COPY)\n\n\ndef test_a_second_run_that_rewrote_the_same_content_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n \"\"\"A rewrite with identical bytes is invisible in the content and in the report.\"\"\"\n ignore_the_version_stamp(monkeypatch)\n\n problems = idempotency_problems(project, bundle, InstallMode.COPY)\n\n assert [problem for problem in problems if \"leave every destination alone\" in problem]\n assert [problem for problem in problems if \"written again with the same content\" in problem]\n\n\ndef test_a_skill_holding_links_installs_and_stays_up_to_date(\n project: pathlib.Path, bundle_with_links: Bundle\n):\n \"\"\"Ordinary and dangling links alike: copied as links, and a no-op on the next run.\"\"\"\n assert not fresh_install_problems(project, bundle_with_links)\n assert not idempotency_problems(project, bundle_with_links, InstallMode.COPY)\n\n\n# ---------------------------------------------------------------------------\n# Running it after an upgrade.\n# ---------------------------------------------------------------------------\n\n\ndef test_a_new_version_alone_replaces_the_installed_skills(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n \"\"\"Two releases can ship byte-identical skills, and the install still has to say so:\n what the destination records is which version put it there.\n \"\"\"\n monkeypatch.setattr(great_expectations, \"__version__\", EARLIER_VERSION)\n state = install_and_record(project, bundle)\n monkeypatch.setattr(great_expectations, \"__version__\", INSTALLED_VERSION)\n\n report = install_skills(project, targets=ALL_TARGETS)\n\n assert not replacement_problems(state, report, content_changed=False)\n\n\ndef test_changed_content_alone_replaces_the_installed_skills(project: pathlib.Path, bundle: Bundle):\n \"\"\"The everyday case for anyone working on the skills themselves: an editable\n install or a source checkout ships changed content under an unchanged version, so\n the version stamp cannot be what decides whether the project is out of date.\n \"\"\"\n state = install_and_record(project, bundle)\n rewrite_bundled_skills(bundle)\n\n report = install_skills(project, targets=ALL_TARGETS)\n\n assert not replacement_problems(state, report, content_changed=True)\n\n\ndef test_content_that_never_reached_the_project_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n \"\"\"The check must fail against a build that compares everything but the content.\"\"\"\n state = install_and_record(project, bundle)\n rewrite_bundled_skills(bundle)\n stop_comparing_the_recorded_hash(monkeypatch)\n\n report = install_skills(project, targets=ALL_TARGETS)\n\n problems = replacement_problems(state, report, content_changed=True)\n assert [problem for problem in problems if \"must be replaced\" in problem]\n assert [problem for problem in problems if \"added.md is missing\" in problem]\n assert [problem for problem in problems if \"never reached the project\" in problem]\n\n\ndef test_an_upgrade_that_moves_both_replaces_the_installed_skills(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n \"\"\"A real release moves both at once, which must behave as either one alone does.\"\"\"\n monkeypatch.setattr(great_expectations, \"__version__\", EARLIER_VERSION)\n state = install_and_record(project, bundle)\n rewrite_bundled_skills(bundle)\n monkeypatch.setattr(great_expectations, \"__version__\", INSTALLED_VERSION)\n\n report = install_skills(project, targets=ALL_TARGETS)\n\n assert not replacement_problems(state, report, content_changed=True)\n\n\ndef test_an_upgrade_left_unapplied_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n monkeypatch.setattr(great_expectations, \"__version__\", EARLIER_VERSION)\n state = install_and_record(project, bundle)\n rewrite_bundled_skills(bundle)\n monkeypatch.setattr(great_expectations, \"__version__\", INSTALLED_VERSION)\n treat_everything_as_current(monkeypatch)\n\n report = install_skills(project, targets=ALL_TARGETS)\n\n problems = replacement_problems(state, report, content_changed=True)\n assert [problem for problem in problems if \"added.md is missing\" in problem]\n\n\n# ---------------------------------------------------------------------------\n# Destinations the run must not overwrite.\n# ---------------------------------------------------------------------------\n\n\ndef test_a_skill_edited_after_it_was_installed_is_refused(project: pathlib.Path, bundle: Bundle):\n \"\"\"The package has not moved on, so nothing but the edit can explain the refusal.\"\"\"\n state = install_and_edit(project, bundle)\n\n report = install_skills(project, targets=ALL_TARGETS)\n\n assert not edited_skill_problems(state, report, force=False, stale=False)\n\n\ndef test_an_edited_skill_survives_an_upgrade(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n \"\"\"The dangerous case: the version moved on, so replacing would look justified.\"\"\"\n monkeypatch.setattr(great_expectations, \"__version__\", EARLIER_VERSION)\n state = install_and_edit(project, bundle)\n monkeypatch.setattr(great_expectations, \"__version__\", INSTALLED_VERSION)\n\n report = install_skills(project, targets=ALL_TARGETS)\n\n assert not edited_skill_problems(state, report, force=False, stale=True)\n\n\ndef test_an_overwritten_local_edit_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n monkeypatch.setattr(great_expectations, \"__version__\", EARLIER_VERSION)\n state = install_and_edit(project, bundle)\n monkeypatch.setattr(great_expectations, \"__version__\", INSTALLED_VERSION)\n ignore_local_edits(monkeypatch)\n\n report = install_skills(project, targets=ALL_TARGETS)\n\n problems = edited_skill_problems(state, report, force=False, stale=True)\n assert [problem for problem in problems if \"LOCALLY_MODIFIED\" in problem.upper()]\n assert [problem for problem in problems if \"notes.md was removed\" in problem]\n\n\ndef test_force_repairs_an_edited_skill_at_the_same_version(project: pathlib.Path, bundle: Bundle):\n \"\"\"``--force`` is a repair as much as an upgrade path.\n\n The edited copy is the version this package would install anyway, so nothing about it\n is stale: the only thing to fix is the edit. A run that decided what to write by\n comparing versions alone would find nothing to do here and say so, leaving the edit\n in place under a command that reported success.\n \"\"\"\n state = install_and_edit(project, bundle)\n\n report = install_skills(project, targets=ALL_TARGETS, force=True)\n\n assert not edited_skill_problems(state, report, force=True, stale=False)\n\n\ndef test_a_forced_repair_that_wrote_nothing_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n \"\"\"The check must fail against a build that decides staleness before ownership.\"\"\"\n state = install_and_edit(project, bundle)\n ignore_edits_when_deciding_staleness(monkeypatch)\n\n report = install_skills(project, targets=ALL_TARGETS, force=True)\n\n problems = edited_skill_problems(state, report, force=True, stale=False)\n assert [problem for problem in problems if \"--force must replace\" in problem]\n assert [problem for problem in problems if \"still holds the edit\" in problem]\n\n\ndef test_force_replaces_an_edited_skill_across_an_upgrade(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n monkeypatch.setattr(great_expectations, \"__version__\", EARLIER_VERSION)\n state = install_and_edit(project, bundle)\n monkeypatch.setattr(great_expectations, \"__version__\", INSTALLED_VERSION)\n\n report = install_skills(project, targets=ALL_TARGETS, force=True)\n\n assert not edited_skill_problems(state, report, force=True, stale=True)\n\n\ndef test_a_forced_replacement_that_wrote_nothing_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n \"\"\"The report says replaced either way; only the destination shows which is true.\"\"\"\n state = install_and_edit(project, bundle)\n install_nothing(monkeypatch)\n\n report = install_skills(project, targets=ALL_TARGETS, force=True)\n\n problems = edited_skill_problems(state, report, force=True, stale=False)\n assert [problem for problem in problems if \"still holds the edit\" in problem]\n\n\n@pytest.mark.parametrize(\"manifest\", UNPROVEN_OWNERSHIP)\n@pytest.mark.parametrize(\"force\", [False, True], ids=[\"without_force\", \"with_force\"])\ndef test_a_directory_great_expectations_did_not_install_is_never_overwritten(\n project: pathlib.Path, bundle: Bundle, force: bool, manifest: str | bytes | None\n):\n assert not foreign_destination_problems(project, bundle, force=force, manifest=manifest)\n\n\ndef test_an_overwritten_foreign_directory_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n claim_every_directory(monkeypatch)\n\n problems = foreign_destination_problems(project, bundle, force=True)\n\n assert [problem for problem in problems if \"notes.md was removed\" in problem]\n\n\ndef test_a_manifest_that_ends_the_run_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n \"\"\"The check must fail against a build where one unreadable manifest ends everything.\n\n The ownership manifest is read before the point at which a destination's problems\n start being caught, so a way of failing that raises instead of answering does not\n cost one destination: it costs the run, and every skill that would have been\n installed after it, under a traceback rather than a report.\n \"\"\"\n stop_swallowing_undecodable_manifests(monkeypatch)\n\n problems = foreign_destination_problems(\n project, bundle, force=True, manifest=UNDECODABLE_MANIFEST\n )\n\n assert [problem for problem in problems if \"cost that destination and no more\" in problem]\n\n\ndef test_a_directory_managed_by_another_tool_being_adopted_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n \"\"\"A manifest that parses is not a manifest that belongs to this package.\n\n The check must fail against a build that accepts any well-formed manifest, because\n such a directory is indistinguishable from one of ours by everything except the owner\n it records -- and adopting it overwrites whatever the other tool put there.\n \"\"\"\n stop_checking_the_owner(monkeypatch)\n\n problems = foreign_destination_problems(\n project, bundle, force=True, manifest=ANOTHER_OWNERS_MANIFEST\n )\n\n assert [problem for problem in problems if \"FOREIGN_DESTINATION\" in problem.upper()]\n assert [problem for problem in problems if \"notes.md was removed\" in problem]\n\n\n# ---------------------------------------------------------------------------\n# Writes that fail.\n# ---------------------------------------------------------------------------\n\n\ndef test_a_failed_write_leaves_nothing_at_the_destination(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n break_writing(monkeypatch)\n\n assert not write_failure_problems(project, bundle)\n\n\ndef test_a_half_written_tree_left_in_the_project_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n break_writing(monkeypatch)\n leave_staging_behind(monkeypatch)\n\n problems = write_failure_problems(project, bundle)\n\n assert [problem for problem in problems if STAGING_PREFIX in problem]\n\n\ndef test_a_failed_replacement_leaves_the_installed_skill_intact(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n assert not failed_replacement_problems(project, bundle, monkeypatch)\n\n\ndef test_a_replacement_written_without_staging_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n \"\"\"Writing in place is what makes a failure visible to an agent as a truncated skill.\"\"\"\n write_without_staging(monkeypatch)\n\n problems = failed_replacement_problems(project, bundle, monkeypatch)\n\n assert [problem for problem in problems if \"was removed\" in problem]\n\n\ndef test_a_failed_swap_puts_the_previous_skill_back(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n assert not swap_failure_problems(project, bundle, monkeypatch)\n\n\ndef test_a_failed_swap_that_lost_the_previous_skill_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n \"\"\"Without the restore the destination simply stops existing, which is the whole\n reason the previous tree is moved aside rather than deleted.\n \"\"\"\n problems = swap_failure_problems(project, bundle, monkeypatch, restore=False)\n\n assert [problem for problem in problems if \"no longer a directory\" in problem]\n\n\ndef test_a_remnant_of_an_interrupted_run_is_swept(project: pathlib.Path, bundle: Bundle):\n assert not remnant_sweep_problems(project, bundle)\n\n\ndef test_a_remnant_left_in_the_project_for_ever_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n leave_staging_behind(monkeypatch)\n\n problems = remnant_sweep_problems(project, bundle)\n\n assert [problem for problem in problems if STAGING_PREFIX in problem]\n\n\n# ---------------------------------------------------------------------------\n# Destinations that cannot be read.\n# ---------------------------------------------------------------------------\n\n\ndef test_an_unreadable_destination_costs_one_destination_not_the_run(\n project: pathlib.Path, bundle: Bundle\n):\n assert not unreadable_destination_problems(project, bundle)\n\n\ndef test_a_read_failure_that_ended_the_run_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n abort_on_read_failure(monkeypatch)\n\n problems = unreadable_destination_problems(project, bundle)\n\n assert [problem for problem in problems if \"cost one destination, not the run\" in problem]\n\n\ndef test_a_read_failure_reported_as_up_to_date_is_caught(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n \"\"\"Answering an unanswerable question is worse than failing: nothing tells the user.\"\"\"\n treat_unreadable_as_unchanged(monkeypatch)\n\n problems = unreadable_destination_problems(project, bundle)\n\n assert [problem for problem in problems if \"UNREADABLE_DESTINATION\" in problem.upper()]\n\n\n# ---------------------------------------------------------------------------\n# A package with nothing to install.\n# ---------------------------------------------------------------------------\n\n\ndef test_a_package_without_a_bundle_directory_is_refused(\n project: pathlib.Path, tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch\n):\n location = tmp_path / \"site-packages\" / \"great_expectations\"\n location.mkdir(parents=True)\n assert not (location / \".agents\").exists()\n monkeypatch.setattr(\n importlib.util,\n \"find_spec\",\n lambda name: types.SimpleNamespace(submodule_search_locations=[str(location)]),\n )\n\n assert not empty_bundle_problems(project)\n\n\ndef test_a_package_whose_bundle_holds_no_skills_is_refused(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n \"\"\"A partly packaged installation: the reference files shipped, the entry documents\n did not. Every directory is still there, so only the entry document tells them apart.\n \"\"\"\n for skill in bundle.skills:\n (skill / ENTRY_DOCUMENT).unlink()\n assert list(bundle.root.iterdir()), f\"{bundle.root} must still hold directories\"\n\n assert not empty_bundle_problems(project)\n\n\ndef test_an_empty_bundle_reported_as_a_clean_run_is_caught(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n report_an_empty_bundle_as_success(monkeypatch)\n\n problems = empty_bundle_problems(project)\n\n assert [problem for problem in problems if \"nothing went wrong\" in problem]\n\n\ndef test_a_project_root_that_is_not_a_directory_is_refused(tmp_path: pathlib.Path, bundle: Bundle):\n missing = tmp_path / \"no-such-project\"\n with pytest.raises(NotADirectoryError, match=\"not an existing directory\"):\n install_skills(missing)\n assert not missing.exists()\n\n a_file = tmp_path / \"a-file\"\n a_file.write_text(\"the user pointed at a file\\n\", encoding=\"utf-8\")\n with pytest.raises(NotADirectoryError, match=\"not an existing directory\"):\n install_skills(a_file)\n assert a_file.read_text(encoding=\"utf-8\") == \"the user pointed at a file\\n\"\n\n\n# ---------------------------------------------------------------------------\n# Walking a tree that points at itself.\n# ---------------------------------------------------------------------------\n\n\n@pytest.fixture\ndef bundle_with_cycles(bundle: Bundle) -> Bundle:\n \"\"\"A skill linking to its own directory, to its parent, and to itself.\"\"\"\n skill = bundle.root / bundle.names[0]\n (skill / \"itself\").symlink_to(skill, target_is_directory=True)\n (skill / REFERENCE_DIR / \"upwards\").symlink_to(skill, target_is_directory=True)\n (skill / REFERENCE_DIR / \"here\").symlink_to(skill / REFERENCE_DIR, target_is_directory=True)\n return bundle\n\n\ndef walk_following_links(root: pathlib.Path) -> Iterator[str]:\n \"\"\"The same walk, following symlinked directories: the defect, kept as evidence.\"\"\"\n pending = [root]\n while pending:\n for entry in sorted(pending.pop().iterdir()):\n yield entry.relative_to(root).as_posix()\n if entry.is_dir():\n pending.append(entry)\n\n\ndef deepest(paths: Sequence[str]) -> int:\n return max(len(pathlib.PurePosixPath(path).parts) for path in paths)\n\n\ndef test_the_walk_behind_the_digest_terminates_on_symlink_cycles(bundle_with_cycles: Bundle):\n # Capped rather than drained: a walk that started following links would otherwise be\n # detected by this test hanging, and a hang is a much worse signal than a failure.\n skill = bundle_with_cycles.root / bundle_with_cycles.names[0]\n\n walked = sorted(\n relpath for relpath, _ in itertools.islice(installer._walk(skill), CYCLE_WALK_LIMIT)\n )\n\n assert len(walked) < CYCLE_WALK_LIMIT, \"the walk was still going when it was cut off\"\n assert {\"itself\", f\"{REFERENCE_DIR}/upwards\", f\"{REFERENCE_DIR}/here\"} <= set(walked)\n assert len(walked) == len(set(walked)), f\"the walk visited a path twice: {walked}\"\n assert deepest(walked) <= REAL_TREE_DEPTH, walked\n\n\ndef test_a_walk_that_followed_links_would_not_terminate(bundle_with_cycles: Bundle):\n \"\"\"Why the walk above is written out rather than delegated to a recursive glob.\"\"\"\n skill = bundle_with_cycles.root / bundle_with_cycles.names[0]\n\n walked: list[str] = []\n with contextlib.suppress(OSError): # the kernel gives up on the link chain eventually\n for relpath in walk_following_links(skill):\n walked.append(relpath)\n if len(walked) >= CYCLE_WALK_LIMIT or deepest(walked) > CYCLE_DEPTH_EVIDENCE:\n break\n\n assert deepest(walked) > CYCLE_DEPTH_EVIDENCE, (\n f\"the following walk stopped at depth {deepest(walked)}, so it proves nothing\"\n )\n\n\ndef test_a_skill_with_symlink_cycles_installs_and_stays_up_to_date(\n project: pathlib.Path, bundle_with_cycles: Bundle\n):\n assert not fresh_install_problems(project, bundle_with_cycles)\n assert not idempotency_problems(project, bundle_with_cycles, InstallMode.COPY)\n\n\n# ---------------------------------------------------------------------------\n# Symlink mode.\n# ---------------------------------------------------------------------------\n\n\ndef test_symlink_mode_creates_a_directory_of_working_links(project: pathlib.Path, bundle: Bundle):\n assert not symlink_mode_problems(project, bundle)\n assert not idempotency_problems(project, bundle, InstallMode.SYMLINK)\n\n\ndef test_copies_where_links_were_asked_for_are_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n copy_where_links_were_asked_for(monkeypatch)\n\n problems = symlink_mode_problems(project, bundle)\n\n assert [problem for problem in problems if \"rather than a link\" in problem]\n\n\n@pytest.mark.parametrize(\n [\"installed_as\", \"asked_for\"],\n [\n pytest.param(InstallMode.COPY, InstallMode.SYMLINK, id=\"copies_to_links\"),\n pytest.param(InstallMode.SYMLINK, InstallMode.COPY, id=\"links_to_copies\"),\n ],\n)\ndef test_asking_for_the_other_mode_converts_the_installed_skills(\n project: pathlib.Path, bundle: Bundle, installed_as: InstallMode, asked_for: InstallMode\n):\n # Keep both directions. Only ``links_to_copies`` rests on the recorded mode: going\n # the other way, the freshness check calls ``readlink()`` on a real file, gets an\n # OSError and reports the destination stale anyway, so that direction would still\n # pass if the mode were never compared at all.\n assert not mode_switch_problems(project, bundle, installed_as, asked_for)\n\n\ndef test_an_install_left_in_the_mode_it_was_not_asked_for_is_reported(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n ignore_the_install_mode(monkeypatch)\n\n problems = mode_switch_problems(project, bundle, InstallMode.COPY, InstallMode.SYMLINK)\n\n assert [problem for problem in problems if \"must replace every destination\" in problem]\n assert [problem for problem in problems if \"rather than a link\" in problem]\n\n\ndef test_a_symlink_install_is_refreshed_when_the_package_moves(\n project: pathlib.Path,\n bundle: Bundle,\n tmp_path: pathlib.Path,\n monkeypatch: pytest.MonkeyPatch,\n):\n \"\"\"Same version, same content, same mode -- and every link points at nothing.\n\n Moving the environment is the one way an installed symlink goes wrong that no hash\n can see: the content it describes has not changed, only the path it lives at, so the\n links themselves are the only thing left to compare.\n \"\"\"\n install_skills(project, targets=ALL_TARGETS, mode=InstallMode.SYMLINK)\n moved = tmp_path / \"relocated-environment\" / \".agents\" / \"skills\"\n moved.parent.mkdir(parents=True)\n shutil.move(str(bundle.root), str(moved))\n relocated = Bundle(root=moved, names=bundle.names)\n monkeypatch.setattr(installer, \"_bundled_skills_root\", lambda: moved)\n expected = expected_destinations(project, relocated)\n assert not [\n destination for destination in expected if (destination / ENTRY_DOCUMENT).exists()\n ], \"the installed links must be dangling before the re-run, or nothing is being fixed\"\n\n report = install_skills(project, targets=ALL_TARGETS, mode=InstallMode.SYMLINK)\n\n assert not partition_problems(report, expected)\n assert set(report.replaced) == set(expected), describe_report(report)\n problems = [\n problem\n for destination in expected\n for problem in linked_install_problems(\n relocated.source_for(destination), destination, INSTALLED_VERSION\n )\n ]\n assert not problems, \"\\n\".join(problems)\n\n\ndef test_links_left_pointing_at_a_package_that_moved_are_reported(\n project: pathlib.Path,\n bundle: Bundle,\n tmp_path: pathlib.Path,\n monkeypatch: pytest.MonkeyPatch,\n):\n install_skills(project, targets=ALL_TARGETS, mode=InstallMode.SYMLINK)\n moved = tmp_path / \"relocated-environment\" / \".agents\" / \"skills\"\n moved.parent.mkdir(parents=True)\n shutil.move(str(bundle.root), str(moved))\n relocated = Bundle(root=moved, names=bundle.names)\n monkeypatch.setattr(installer, \"_bundled_skills_root\", lambda: moved)\n trust_links_without_looking(monkeypatch)\n\n report = install_skills(project, targets=ALL_TARGETS, mode=InstallMode.SYMLINK)\n\n expected = expected_destinations(project, relocated)\n problems = [\n problem\n for destination in expected\n for problem in linked_install_problems(\n relocated.source_for(destination), destination, INSTALLED_VERSION\n )\n ]\n assert set(report.up_to_date) == set(expected), describe_report(report)\n assert [problem for problem in problems if \"links to\" in problem]\n\n\ndef replace_a_link_with_a_file(destination: pathlib.Path) -> None:\n \"\"\"What an editor that \"saves through\" a symlink leaves behind.\"\"\"\n entry = destination / ENTRY_DOCUMENT\n content = entry.read_bytes()\n entry.unlink()\n entry.write_bytes(content)\n\n\ndef remove_every_link(destination: pathlib.Path) -> None:\n \"\"\"What a user clearing out a skill by hand leaves behind: the manifest, alone.\"\"\"\n for entry in destination.iterdir():\n if entry.name != MANIFEST_NAME:\n entry.unlink()\n\n\nDAMAGED_LINKS: Final = [\n pytest.param(replace_a_link_with_a_file, id=\"link_replaced_by_a_file\"),\n pytest.param(remove_every_link, id=\"links_removed\"),\n]\n\n\ndef damaged_links_problems(\n project: pathlib.Path,\n bundle: Bundle,\n monkeypatch: pytest.MonkeyPatch,\n damage: Callable[[pathlib.Path], None],\n defect: Callable[[pytest.MonkeyPatch], None] | None = None,\n) -> list[str]:\n \"\"\"A symlink install the user has interfered with is refused, not quietly rebuilt.\n\n Symlink installs are judged structurally rather than by content -- the content lives\n in the package and changes legitimately on every upgrade -- so the link set is the\n whole of the record. ``damage`` is a parameter rather than a fixed step because that\n record has more than one way to stop being true, and a single one of them stands in\n for the others only until someone changes the code.\n \"\"\"\n install_skills(project, targets=ALL_TARGETS, mode=InstallMode.SYMLINK)\n destination = project / SkillTarget.AGENTS.value / bundle.names[0]\n intact = snapshot(destination)\n damage(destination)\n before = snapshot(destination)\n problems = []\n if before == intact:\n problems.append(f\"{destination} was not changed, so refusing it proves nothing.\")\n if not (destination / MANIFEST_NAME).is_file():\n problems.append(\n f\"{destination} lost its {MANIFEST_NAME}, so it would be refused as a\"\n \" directory this package never installed rather than as an edited one.\"\n )\n if defect is not None:\n defect(monkeypatch)\n\n report = install_skills(project, targets=ALL_TARGETS, mode=InstallMode.SYMLINK)\n\n problems += refusal_problems(report, destination, SkillFailureKind.LOCALLY_MODIFIED)\n problems += unchanged_problems(destination, before)\n return problems\n\n\n@pytest.mark.parametrize(\"damage\", DAMAGED_LINKS)\ndef test_a_damaged_symlink_install_counts_as_a_local_edit(\n project: pathlib.Path,\n bundle: Bundle,\n monkeypatch: pytest.MonkeyPatch,\n damage: Callable[[pathlib.Path], None],\n):\n assert not damaged_links_problems(project, bundle, monkeypatch, damage)\n\n\n@pytest.mark.parametrize(\"damage\", DAMAGED_LINKS)\ndef test_a_damaged_symlink_install_treated_as_intact_is_reported(\n project: pathlib.Path,\n bundle: Bundle,\n monkeypatch: pytest.MonkeyPatch,\n damage: Callable[[pathlib.Path], None],\n):\n problems = damaged_links_problems(\n project, bundle, monkeypatch, damage, defect=ignore_local_edits\n )\n\n assert [problem for problem in problems if \"LOCALLY_MODIFIED\" in problem.upper()]\n\n\ndef test_a_platform_that_refuses_links_is_reported_per_skill(\n project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch\n):\n refuse_to_make_links(monkeypatch)\n\n report = install_skills(project, targets=ALL_TARGETS, mode=InstallMode.SYMLINK)\n\n expected = expected_destinations(project, bundle)\n assert not non_vacuity_problems(expected)\n assert not partition_problems(report, expected)\n problems = [\n problem\n for destination in expected\n for problem in refusal_problems(report, destination, SkillFailureKind.SYMLINKS_UNSUPPORTED)\n ]\n assert not problems, \"\\n\".join(problems)\n assert [destination for destination in expected if destination.exists()] == []\n assert not staging_remnant_problems(project)\n\n\n# ---------------------------------------------------------------------------\n# The command around the installer.\n# ---------------------------------------------------------------------------\n\n\ndef unwrapped(text: str) -> str:\n \"\"\"Collapse the command's line wrapping so a sentence can be looked for whole.\"\"\"\n return \" \".join(text.split())\n\n\ndef displayed(destination: pathlib.Path, project: pathlib.Path) -> str:\n return str(destination.relative_to(project))\n\n\ndef test_the_command_installs_and_exits_zero(\n project: pathlib.Path, bundle: Bundle, capsys: pytest.CaptureFixture[str]\n):\n status = command_line.main([\"skills\", \"install\", \"--project-root\", str(project)])\n\n output = capsys.readouterr().out\n assert status == 0\n expected = expected_destinations(project, bundle)\n assert not non_vacuity_problems(expected)\n problems = [\n problem\n for destination in expected\n for problem in installed_copy_problems(\n bundle.source_for(destination), destination, INSTALLED_VERSION\n )\n ]\n assert not problems, \"\\n\".join(problems)\n for destination in expected:\n assert displayed(destination, project) in output\n\n\ndef refused_destination_problems(\n project: pathlib.Path, bundle: Bundle, capsys: pytest.CaptureFixture[str]\n) -> list[str]:\n \"\"\"One destination refused, the rest installed: the run a script must not read as clean.\"\"\"\n foreign = project / SkillTarget.CLAUDE.value / bundle.names[0]\n foreign.mkdir(parents=True)\n (foreign / \"notes.md\").write_text(\"a directory the user made\\n\", encoding=\"utf-8\")\n before = snapshot(foreign)\n expected = expected_destinations(project, bundle)\n problems = non_vacuity_problems(expected)\n\n status = command_line.main([\"skills\", \"install\", \"--project-root\", str(project)])\n\n output = capsys.readouterr().out\n if status == 0:\n problems.append(\n \"a run that refused a destination must exit nonzero, or a script goes on to\"\n \" run an agent that is missing a skill\"\n )\n problems += unchanged_problems(foreign, before)\n if displayed(foreign, project) not in output:\n problems.append(f\"{foreign} is missing from the report the command printed.\")\n for destination in expected:\n if destination == foreign:\n continue\n problems += installed_copy_problems(\n bundle.source_for(destination), destination, INSTALLED_VERSION\n )\n if displayed(destination, project) not in output:\n problems.append(f\"{destination} is missing from the report the command printed.\")\n return problems\n\n\ndef test_the_command_exits_nonzero_when_any_destination_was_refused(\n project: pathlib.Path, bundle: Bundle, capsys: pytest.CaptureFixture[str]\n):\n assert not refused_destination_problems(project, bundle, capsys)\n\n\ndef test_a_command_that_hid_a_refusal_is_caught(\n project: pathlib.Path,\n bundle: Bundle,\n capsys: pytest.CaptureFixture[str],\n monkeypatch: pytest.MonkeyPatch,\n):\n hide_failures(monkeypatch)\n\n problems = refused_destination_problems(project, bundle, capsys)\n\n assert [problem for problem in problems if \"exit nonzero\" in problem]\n\n\ndef reported_destination_problems(\n project: pathlib.Path, bundle: Bundle, capsys: pytest.CaptureFixture[str], outcome: str\n) -> list[str]:\n \"\"\"A run must name every destination it considered, whatever became of it.\n\n ``outcome`` is what this run does to the destinations, and it is the caller's to set:\n the two runs that change nothing visible at the destination -- leaving a skill alone\n and bringing it up to a new version -- are the two whose output is the only evidence\n the user gets. A first install is not a substitute for either, because it is the one\n case where the destination appearing on disk says what happened by itself.\n \"\"\"\n version = EARLIER_VERSION if outcome == \"updated\" else INSTALLED_VERSION\n with expected_package_version(version):\n command_line.main([\"skills\", \"install\", \"--project-root\", str(project)])\n capsys.readouterr()\n expected = expected_destinations(project, bundle)\n problems = non_vacuity_problems(expected)\n # Anchored on the filesystem rather than on the previous run's output: the manifests\n # decide what the second run must do, so this is what makes the run under test the\n # run this is named for.\n for destination in expected:\n problems += manifest_problems(\n destination, bundle.source_for(destination), version, InstallMode.COPY\n )\n\n status = command_line.main([\"skills\", \"install\", \"--project-root\", str(project)])\n\n output = capsys.readouterr().out\n if status != 0:\n problems.append(f\"a run that {outcome} every skill must exit 0; got {status}\")\n for destination in expected:\n if displayed(destination, project) not in output:\n problems.append(\n f\"{destination} was {outcome} and the command's report does not name it,\"\n f\" so nothing tells the user it happened. Printed:\\n{output}\"\n )\n return problems\n\n\n@contextlib.contextmanager\ndef expected_package_version(version: str) -> Iterator[None]:\n \"\"\"Run a block with the package claiming ``version``, then put it back.\"\"\"\n with pytest.MonkeyPatch.context() as patch:\n patch.setattr(great_expectations, \"__version__\", version)\n yield\n\n\n@pytest.mark.parametrize(\n \"outcome\",\n [\"left alone\", \"updated\"],\n ids=[\"already_up_to_date\", \"updated_by_an_upgrade\"],\n)\ndef test_the_command_names_every_destination_it_considered(\n project: pathlib.Path, bundle: Bundle, capsys: pytest.CaptureFixture[str], outcome: str\n):\n assert not reported_destination_problems(project, bundle, capsys, outcome)\n\n\n@pytest.mark.parametrize(\n [\"outcome\", \"group\"],\n [\n pytest.param(\"left alone\", \"up_to_date\", id=\"already_up_to_date\"),\n pytest.param(\"updated\", \"replaced\", id=\"updated_by_an_upgrade\"),\n ],\n)\ndef test_an_outcome_group_missing_from_the_report_is_caught(\n project: pathlib.Path,\n bundle: Bundle,\n capsys: pytest.CaptureFixture[str],\n monkeypatch: pytest.MonkeyPatch,\n outcome: str,\n group: str,\n):\n \"\"\"A group that stopped being printed is invisible: the command still exits 0 and\n the destinations are still correct on disk, and the user is simply not told.\n \"\"\"\n hide_the_outcome_group(monkeypatch, group)\n\n problems = reported_destination_problems(project, bundle, capsys, outcome)\n\n assert [problem for problem in problems if \"does not name it\" in problem]\n\n\n@contextlib.contextmanager\ndef an_edited_skill(project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch):\n install_skills(project, targets=ALL_TARGETS)\n edited = project / SkillTarget.AGENTS.value / bundle.names[0]\n (edited / REFERENCE_DIR / \"notes.md\").write_text(\"notes the user added\\n\", encoding=\"utf-8\")\n yield\n\n\n@contextlib.contextmanager\ndef a_foreign_directory(project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch):\n foreign = project / SkillTarget.AGENTS.value / bundle.names[0]\n foreign.mkdir(parents=True)\n (foreign / \"notes.md\").write_text(\"a directory the user made\\n\", encoding=\"utf-8\")\n yield\n\n\n@contextlib.contextmanager\ndef an_unreadable_skill(project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch):\n install_skills(project, targets=ALL_TARGETS)\n unreadable = project / SkillTarget.AGENTS.value / bundle.names[0] / REFERENCE_DIR\n with made_unreadable(unreadable):\n if is_readable(unreadable):\n pytest.fail(f\"{unreadable} is readable with no permissions at all; check the user\")\n yield\n\n\n@contextlib.contextmanager\ndef a_write_that_fails(project: pathlib.Path, bundle: Bundle, monkeypatch: pytest.MonkeyPatch):\n break_writing(monkeypatch)\n yield\n\n\n@pytest.mark.parametrize(\n [\"prepare\", \"kind\", \"explains_edits\"],\n [\n pytest.param(an_edited_skill, SkillFailureKind.LOCALLY_MODIFIED, True, id=\"edited\"),\n pytest.param(\n a_foreign_directory, SkillFailureKind.FOREIGN_DESTINATION, False, id=\"foreign\"\n ),\n pytest.param(\n an_unreadable_skill, SkillFailureKind.UNREADABLE_DESTINATION, False, id=\"unreadable\"\n ),\n pytest.param(a_write_that_fails, SkillFailureKind.WRITE_FAILED, False, id=\"write_failed\"),\n ],\n)\ndef test_the_command_explains_local_edits_only_where_a_skill_was_edited(\n project: pathlib.Path,\n bundle: Bundle,\n capsys: pytest.CaptureFixture[str],\n monkeypatch: pytest.MonkeyPatch,\n prepare: Callable[..., contextlib.AbstractContextManager[None]],\n kind: SkillFailureKind,\n explains_edits: bool,\n):\n \"\"\"Advice meant for one kind of failure sends the user hunting at the others.\n\n The explanation of what counts as an edit is keyed on the recorded failure kind, and\n it has to be: an edited destination and one whose subdirectory could not be read both\n still exist and both still hold a valid ownership manifest.\n \"\"\"\n with prepare(project, bundle, monkeypatch):\n report = install_skills(project, targets=ALL_TARGETS)\n assert report.failed, \"this scenario must produce a failure to explain\"\n assert {failure.kind for failure in report.failed} == {kind}, describe_report(report)\n capsys.readouterr()\n\n status = command_line.main([\"skills\", \"install\", \"--project-root\", str(project)])\n\n output = unwrapped(capsys.readouterr().out)\n assert status == 1\n assert unwrapped(command_line._FAILURE_FOOTER) in output\n assert unwrapped(command_line._LOCAL_EDIT_FOOTER)\n assert (unwrapped(command_line._LOCAL_EDIT_FOOTER) in output) is explains_edits\n\n\ndef test_a_failure_kind_derived_after_the_fact_is_caught(\n project: pathlib.Path,\n bundle: Bundle,\n capsys: pytest.CaptureFixture[str],\n monkeypatch: pytest.MonkeyPatch,\n):\n \"\"\"The disproved heuristic, kept executable: it calls a permission error an edit.\"\"\"\n install_skills(project, targets=ALL_TARGETS)\n label_failures_by_appearance(monkeypatch)\n unreadable = project / SkillTarget.AGENTS.value / bundle.names[0] / REFERENCE_DIR\n\n with made_unreadable(unreadable):\n assert not is_readable(unreadable)\n capsys.readouterr()\n status = command_line.main([\"skills\", \"install\", \"--project-root\", str(project)])\n\n assert status == 1\n assert unwrapped(command_line._LOCAL_EDIT_FOOTER) in unwrapped(capsys.readouterr().out)\n\n\ndef raise_no_working_directory() -> pathlib.Path:\n raise FileNotFoundError(2, \"No such file or directory\")\n\n\n@pytest.mark.parametrize(\n \"arguments\",\n [[], [\"skills\"], [\"skills\", \"install\"], [\"skills\", \"list\"]],\n ids=[\"root\", \"skills\", \"install\", \"list\"],\n)\ndef test_help_never_reads_the_working_directory(\n arguments: list[str], capsys: pytest.CaptureFixture[str], monkeypatch: pytest.MonkeyPatch\n):\n \"\"\"Help has to work from a directory that no longer exists, which is where a user\n who has just deleted a build directory reaches for it.\n \"\"\"\n monkeypatch.setattr(pathlib.Path, \"cwd\", staticmethod(raise_no_working_directory))\n\n with pytest.raises(SystemExit) as exit_status:\n command_line.main([*arguments, \"--help\"])\n\n assert exit_status.value.code == 0\n assert \"usage:\" in capsys.readouterr().out\n\n\ndef test_a_working_directory_resolved_while_defining_the_arguments_is_caught(\n monkeypatch: pytest.MonkeyPatch,\n):\n \"\"\"Why the default is resolved when it is used and not when it is declared.\"\"\"\n monkeypatch.setattr(pathlib.Path, \"cwd\", staticmethod(raise_no_working_directory))\n parser = argparse.ArgumentParser()\n\n with pytest.raises(FileNotFoundError):\n parser.add_argument(\"--project-root\", type=pathlib.Path, default=pathlib.Path.cwd())\n\n\ndef test_a_deleted_working_directory_is_reported_rather_than_raised(\n capsys: pytest.CaptureFixture[str], monkeypatch: pytest.MonkeyPatch\n):\n monkeypatch.setattr(pathlib.Path, \"cwd\", staticmethod(raise_no_working_directory))\n\n status = command_line.main([\"skills\", \"install\"])\n\n assert status == 1\n error = unwrapped(capsys.readouterr().err)\n assert \"current directory\" in error\n assert \"--project-root\" in error\n\n\ndef test_the_listing_reports_each_skill_against_the_given_project(\n project: pathlib.Path, bundle: Bundle, capsys: pytest.CaptureFixture[str]\n):\n \"\"\"A listing that could only ever describe the working directory would contradict an\n install aimed somewhere else.\n \"\"\"\n assert command_line.main([\"skills\", \"install\", \"--project-root\", str(project)]) == 0\n capsys.readouterr()\n\n assert command_line.main([\"skills\", \"list\", \"--project-root\", str(project)]) == 0\n\n output = capsys.readouterr().out\n for name in bundle.names:\n assert name in output\n for target in ALL_TARGETS:\n assert target.value in output\n assert INSTALLED_VERSION in output\n\n\ndef test_the_listing_shows_skills_installed_by_another_version(\n project: pathlib.Path, bundle: Bundle, capsys: pytest.CaptureFixture[str]\n):\n install_skills(project, targets=ALL_TARGETS)\n for destination in expected_destinations(project, bundle):\n stamp_manifest_version(destination, EARLIER_VERSION)\n capsys.readouterr()\n\n assert command_line.main([\"skills\", \"list\", \"--project-root\", str(project)]) == 0\n\n output = capsys.readouterr().out\n assert EARLIER_VERSION in output\n assert INSTALLED_VERSION in output\n\n\ndef test_the_listing_refuses_a_project_that_is_not_a_directory(\n tmp_path: pathlib.Path, bundle: Bundle, capsys: pytest.CaptureFixture[str]\n):\n status = command_line.main([\"skills\", \"list\", \"--project-root\", str(tmp_path / \"nowhere\")])\n\n assert status == 1\n assert \"not an existing directory\" in unwrapped(capsys.readouterr().err)\n"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":1226,"numItemsPerPage":100,"numTotalItems":421275,"offset":122600,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sInJlcG9JZHMiOlsiNmFiODVhOGYzODBjYmQ4YzAzYWQ5MjY3Il0sImlhdCI6MTc5MjYzMzk5NCwianRpIjoiZjYzNmE4NGYtYTAyMy00NGIzLTgzMGItZjhjMGMzOGE2Mzk0Iiwic3ViIjoiL2RhdGFzZXRzL09wZW5TY2llbnRpZmljQ29kZVJlZ2lzdHJ5L0RhdGFiYXNlIiwiZXhwIjoxNzkyNjM3NTk0LCJpc3MiOiJodHRwczovL2h1Z2dpbmdmYWNlLmNvIn0.97Nx1JvaVDE5j5dLYU8aFywv-TieYAG05QWbuPk9dj_mVcXCfKj_4OlGDCvXugaJCaRbAed_UJnzputMZGTRCQ","displayUrls":true,"splitSizeSummaries":[{"config":"scripts","split":"train","numRows":421275,"numBytesParquet":711571201}]},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
sha256 stringlengths 64 64 | language stringclasses 27
values | size int32 1 491k | lines int32 1 21.8k | content stringlengths 1 200k |
|---|---|---|---|---|
d2b21effc42aad4914a71336eeff2bf4173d5d93808820c2d1854ea44ad8e882 | Python | 91,552 | 2,530 | import functools
from collections import OrderedDict
from collections import defaultdict
from collections import deque
from collections import namedtuple
import numpy as np
import pytest
from absl.testing import parameterized
from keras.src import backend
from keras.src import ops
from keras.src import testing
from k... |
0bbf75363370781fe6429ddc40d18dffa713bae812bfe1a709d3136afc22c5c6 | Python | 91,810 | 2,345 | """
Generate white-light synthetic cluster frames for the completeness pipeline.
Paths are configurable via environment variables (no hardcoded absolute paths):
COMP_MAIN_DIR - main run directory (default: project root)
COMP_FITS_PATH - LEGUS FITS images root
COMP_PSF_PATH - PSF files directory
COMP... |
b82ef917a5c66aaa38f8919262c04cc3c08616289ca3ea726c9c8bdb94e948de | Python | 91,872 | 2,883 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
from __future__ import annotations
import os
import shutil
import time
import re
_ANSI_RE = re.compile(r"\x1b\[[0-9;]*[mK]")
from collections.abc import MutableSequence
import numpy as np
from vtkmodules.util.numpy_support import numpy_to_vtk, vtk_to_numpy
from vtkmodule... |
8235f72ec938a6be14e333f78c289f13f90f3022a59be06fd365ba3f8d3c1001 | Python | 91,904 | 1,361 | import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_scatter import scatter, scatter_min, scatter_max, scatter_log_softmax, scatter_softmax
from torch_cluster import radius_graph
from tqdm import tqdm
from copy import deepcopy
from .build_rotamers import RotamerBuilder
from .ligand_featurizati... |
ad2ee8c90c687e4cab538984f6c5974bf439bca64d561eade24a0c09e731e73c | Python | 91,949 | 1,994 | """PyTorch ResNet
This started as a copy of https://github.com/pytorch/vision 'resnet.py' (BSD-3-Clause) with
additional dropout and dynamic global avg/max pool.
ResNeXt, SE-ResNeXt, SENet, and MXNet Gluon stem/downsample variants, tiered stems added by Ross Wightman
Copyright 2019, Ross Wightman
"""
import math
fro... |
0e0a85567d76c75161d4eb78a25eaee40732223fa9b68aff9c27a9a4c46a9edc | Python | 91,972 | 2,294 | # cython: language_level=3
# cython: profile=True
# cython: linetrace=True
# Time-stamp: <2025-10-16 17:09:16 Tao Liu>
"""Compute MACS3 peak-calling scores and helper statistics.
This code is free software; you can redistribute it and/or modify it
under the terms of the BSD License (see the file LICENSE included with... |
eb87d4f43a3a3641a99e8d95782f468db80049fb61f1942cb1e345738a7ad763 | Python | 92,075 | 1,909 | #!/usr/bin/env python3
"""
ANO Feature Optimization (FO) - ANO Framework Module 4
======================================================
PURPOSE:
Module 4 implements Feature Optimization (FO), the first ANO optimization strategy.
It searches for the optimal combination of molecular descriptors to maximize
prediction a... |
678aed92b379514b8eb7cb97a36dc0fe7712bddfe6b349169649383f1210c826 | Python | 92,121 | 1,751 | import numpy as np
import time
from copy import deepcopy
from MEArecTemplate.tools import (select_templates, find_overlapping_templates, get_binary_cat,
resample_templates, jitter_templates, pad_templates, get_templates_features,
compute_modulation, annotate_overlappi... |
c97fb7fcadc5a0c58e821a0f11dc0e32320598a2c3f722abe60452f4165faac4 | Python | 92,178 | 1,824 | import torch
import torch.utils.data
from torch.cuda.amp import autocast
import numpy as np
import copy
import os
import time
import tifffile
import natsort
import pathlib
import gc
import torch.multiprocessing as mp
import platform
import queue
import csv
import ailoc.common
# from ailoc.common import local_tifffile
... |
59a3e07305e298bdedba2bbc0186d4cb1129f57945aff70b7ddae58a68b93bb2 | Python | 92,430 | 2,653 | """Plotting functions for AnnData."""
from __future__ import annotations
from collections import OrderedDict
from collections.abc import Collection, Mapping, Sequence
from itertools import pairwise, product
from types import NoneType
from typing import TYPE_CHECKING, NamedTuple, TypedDict, cast
import numpy as np
im... |
417bffbbcbec75f979c272194f82044b5510c8439d3cea1643513956d14ca254 | Python | 92,447 | 2,350 | """Base controller to make clustering GUIs."""
# ------------------------------------------------------------------------------
# Imports
# ------------------------------------------------------------------------------
import inspect
import logging
import os
import shutil
from functools import partial
from pathlib i... |
221a7bad745c8db20ac3c08e9bdc1278f57d0111976d217d8065c0327d90f8a5 | Python | 92,628 | 2,607 | #-------------------------------------------------------------------
# tarfile.py
#-------------------------------------------------------------------
# Copyright (C) 2002 Lars Gustaebel <lars@gustaebel.de>
# All rights reserved.
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy ... |
31679f1221b255741f4139aef4f67f32b1ac751f945acf481343f1231bdea6a4 | Python | 92,922 | 2,020 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
This experiment was created using PsychoPy3 Experiment Builder (v2022.2.5),
on March 03, 2023, at 16:18
If you publish work using this script the most relevant publication is:
Peirce J, Gray JR, Simpson S, MacAskill M, Höchenberger R, Sogo H, Kastman E, ... |
1c4266bf78336fdd5824e72a8d82fd8804807cd75b0409d4f7324ee7fd506518 | Python | 92,968 | 1,913 | import torch
import torch.nn.functional as F
import numpy as np
from federated_learning.config.config import *
from federated_learning.models.cnn import CNNMnist
from federated_learning.models.resnet import ResNet50Alzheimer, ResNet18Alzheimer
from federated_learning.models.vae import VAE, GradientVAE
from federated_le... |
c5f17c4ef00b9110bd5ccd6ac841b373e57b6c63641a4ec79f272e7d7e9ecd4e | Python | 93,051 | 1,926 | """
This module defines environment variables used in MLflow.
MLflow's environment variables adhere to the following naming conventions:
- Public variables: environment variable names begin with `MLFLOW_`
- Internal-use variables: For variables used only internally, names start with `_MLFLOW_`
"""
import os
import war... |
f8eb8d996f8b26e7b98a1d82c30a780af22149acc380ea0e06229b13aa4b1cae | Python | 93,140 | 2,450 | """Parse the dbSNP JSON files into VCF and a rsID map file
"""
from gwas_norm import (
__version__,
__name__ as pkg_name,
crossmap
)
from gwas_norm.variants.common import SequenceError
from gwas_norm.variants import norm
from gwas_norm.map_file.dbsnp import clinvar
from merge_sort import chunks, merge
from ... |
8e70b75da24a8ace606be15413dae1ff5373dee9d56ab69514ba5d69dba52eb8 | Python | 93,177 | 2,685 | """
Python implementation of the io module.
"""
import os
import abc
import codecs
import errno
import stat
import sys
# Import _thread instead of threading to reduce startup cost
from _thread import allocate_lock as Lock
if sys.platform in {'win32', 'cygwin'}:
from msvcrt import setmode as _setmode
else:
_set... |
df994e409fb62a13513791381cea84bf362af034702ee176a5ba4f0a8cf54a60 | Python | 93,184 | 2,583 | # -*- coding: utf-8 -*-
from __future__ import annotations
import os.path
import time
from typing import Any
from typing_extensions import Self
import numpy as np
import vedo.vtkclasses as vtki # a wrapper for lazy imports
import vedo
from vedo import utils
from vedo import addons
from vedo.core.summary import forma... |
8097c6a592fd993ee4958379dfbe3841113984039d6c6cbe5af8d67163201710 | Python | 93,186 | 2,525 | """Test the file readers in `merit.ipd.files`
"""
from itertools import zip_longest
from typing import (
Union, List, Tuple
)
from sortedcontainers import SortedList
from merit.ipd.files import ReaderHandler
try:
from typing import Self
except ImportError:
from typing_extensions import Self
from merit.i... |
5de02add311cd6107b393d7b63696800ddec10e2e42fcfb2237433aca1b01eaa | Python | 93,215 | 1,930 | #!/usr/bin/env python3
"""
ANO Model Optimization (MO) - ANO Framework Module 5
====================================================
PURPOSE:
Module 5 implements Model Optimization (MO), optimizing neural network architecture
while keeping features fixed to fingerprints only (no descriptors).
KEY FEATURES:
1. **Archi... |
18219c71710c1ec19ee79b6f5c8ebe72f482e630c568d28c247c5a025a129e72 | Python | 93,412 | 2,692 | """
Python implementation of the io module.
"""
import os
import abc
import codecs
import errno
import stat
import sys
# Import _thread instead of threading to reduce startup cost
from _thread import allocate_lock as Lock
if sys.platform in {'win32', 'cygwin'}:
from msvcrt import setmode as _setmode
else:
_set... |
bcc8d00ebadd684aba19169e853e6f23bc36d609ae0c8119912f1e39e9f0c1e9 | Python | 93,486 | 2,890 | '''"Executable documentation" for the pickle module.
Extensive comments about the pickle protocols and pickle-machine opcodes
can be found here. Some functions meant for external use:
genops(pickle)
Generate all the opcodes in a pickle, as (opcode, arg, position) triples.
dis(pickle, out=None, memo=None, indentl... |
d7d7b66e5755369eb1834b85c2925748652a80f582c69cf60a5e49b6be0b6c5b | Python | 93,533 | 2,114 | import copy
import io
import os
import tempfile
from contextlib import contextmanager
from pathlib import Path
import re
import sys
import argparse
import datetime
import ntpath
import yaml
import torch
import pooch
import torch.distributed as dist
from shutil import copyfile
import numpy as np
import importlib
from ya... |
19db592219997ea599caf4456198aa6f394d526af1e3ae36bb953dd6d576ef50 | Python | 93,593 | 1,927 | # SPDX-License-Identifier: Apache-2.0
"""
Classes to get, save and load (static or time dependent) connection matrices and sample submatrices from them
authors: Michael Reimann, András Ecker
last modified: 01.2022
"""
import h5py
import numpy as np
import pandas as pd
from scipy import sparse, stats
from .circuit_mod... |
fe8ac5bd58badf2373f6b4537d180e50b37b40103df471a93ea9ed897c6de26d | Python | 93,929 | 2,568 | #!/usr/bin/env python3
#-------------------------------------------------------------------
# tarfile.py
#-------------------------------------------------------------------
# Copyright (C) 2002 Lars Gustaebel <lars@gustaebel.de>
# All rights reserved.
#
# Permission is hereby granted, free of charge, to any pers... |
7223043c2a03d11cb7303f7e3ff64acf62450424b1d735f73c8ec3c31478f323 | Python | 93,942 | 2,336 | # -*- coding: utf-8 -*-
"""
ROI.py - Interactive graphics items for GraphicsView (ROI widgets)
Copyright 2010 Luke Campagnola
Distributed under MIT/X11 license. See license.txt for more infomation.
Implements a series of graphics items which display movable/scalable/rotatable shapes
for use as region-of-interest mar... |
af64c759ddb2de4d9dccb0b98f2180c8d00507e079b9baa74a7ee5e1f8c16899 | Python | 94,031 | 2,368 | """Functions/classes that control the stages of the normalisation process.
"""
# NOTE: Docstrings OK
# Standard Python packages
# import pprint as pp
import csv
import gzip
import os
import shutil
import tempfile
import warnings
# 3rd party packages
import pysam
# 3rd party packages
from Bio import bgzf
from tqdm im... |
52f2db9734ab336fec531ccdc16e43658ec29136cf552087ed393bbd6103042b | Python | 94,055 | 1,257 | __author__ = "Simon Nilsson; sronilsson@gmail.com"
import ctypes
import math
import os
import platform
from copy import copy, deepcopy
from tkinter import *
from typing import List, Optional, Union
import cv2
import numpy as np
import pandas as pd
from PIL import Image, ImageTk
from scipy.spatial.distance import cdis... |
a65a1fb4301ae82de8b307a8d698f327a79b8fa66c8f053f4ddeff52c87020c4 | Python | 94,154 | 2,364 | from __future__ import annotations
import os
ENV = {"TF_FORCE_UNIFIED_MEMORY":"1", "XLA_PYTHON_CLIENT_MEM_FRACTION":"4.0"}
for k,v in ENV.items():
if k not in os.environ: os.environ[k] = v
import warnings
from Bio import BiopythonDeprecationWarning # what can possibly go wrong...
warnings.simplefilter(action='ign... |
15fe8ea5af6fcc5883c0d0d1ecf6d04a61bc4108ce9af34ace573060170e5e2f | Python | 94,262 | 1,960 | #!/usr/bin/env python3
"""
ANO Network Optimization MOFO - ANO Framework Module 7
======================================================
Developer: Lee, Seungjin (arer90)
PURPOSE:
Module 7 implements MOFO (Model Optimization -> Feature Optimization) strategy.
It first optimizes the neural network architecture with al... |
0393ced435ebd3c4cb5e46d75313a13a4a0f9a0e2a8273fd2c74a05591e01d23 | Python | 94,404 | 1,635 | # Configuration file for the Sphinx documentation builder.
#
# For the full list of built-in configuration values, see the documentation:
# https://www.sphinx-doc.org/en/master/usage/configuration.html
# -- Project information -----------------------------------------------------
# https://www.sphinx-doc.org/en/master... |
519c9c9c18864430956eb296a923c3c5f2fdfd1894b0860834404d7008010218 | Python | 94,454 | 2,582 | #!/usr/bin/env python3
#-------------------------------------------------------------------
# tarfile.py
#-------------------------------------------------------------------
# Copyright (C) 2002 Lars Gustaebel <lars@gustaebel.de>
# All rights reserved.
#
# Permission is hereby granted, free of charge, to any pers... |
b95080c6c9b9b8dfe09869610057eef44de1300946eb0141bff3bc050902e515 | Python | 94,571 | 2,310 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Mar 16 10:27:44 2026
@author: kongxiangyu
"""
import sys
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import matplotlib.colors as mcolors
from src.utils import load_as_pickle,save_as_pickle
from analysis.e... |
e869f1c2f976a2a8f861b3439ec73cb0a02217a4d531c2863aed27ecded8a2f1 | Python | 94,845 | 1,889 | __author__ = "Simon Nilsson; sronilsson@gmail.com"
import math
import multiprocessing as mp
import os
import time
from typing import Optional, Tuple, Union
try:
from typing import Literal
except:
from typing_extensions import Literal
try:
import cupy as cp
from cupyx.scipy.ndimage import rotate
excep... |
b9f3ba717869883c0a21663608e35009ce66f61edbee34d2c47b26c7c20928e6 | Python | 95,138 | 2,143 | """ Vision Transformer (ViT) in PyTorch
A PyTorch implement of Vision Transformers as described in:
'An Image Is Worth 16 x 16 Words: Transformers for Image Recognition at Scale'
- https://arxiv.org/abs/2010.11929
`How to train your ViT? Data, Augmentation, and Regularization in Vision Transformers`
- https:... |
844ae9583cc9fd6a7d47a47097a279f5cbd68a5476eca9fd9838ae3878ca4e09 | Python | 95,324 | 2,553 | """
This script analyzes behavioral data from FED3 experiments, focusing on transitions
between different states (e.g., left/right pokes) and learning performance. It
includes functions to split data into blocks, calculate transition statistics,
visualize learning trends, and assess learning scores.
"""
import os
from ... |
776a08c2bfe1a0e3585e0eaf192bc44cf4007c756dc40bb7a632c4890e3f1744 | Python | 95,659 | 1,956 | import pathlib
from pathlib import Path
import copy
import warnings
from typing import List, Optional, Union, Tuple, Dict, Any, Callable, Iterable
import numpy as np
from tqdm.auto import tqdm
import scipy.sparse
import sparse
from . import helpers, util
"""
Classes for importing data into the roicat package.
Conv... |
33d2ed1ec873c77ccbccd5732dc7580b0a61b023dbc412d9c7a8a49312734ec9 | Python | 95,807 | 1,912 | import json
import os
import re
import time
import warnings
import numpy as np
from multiprocessing import Pool, cpu_count
import math
import matplotlib.pylab as plt
import pandas as pd
import pydicom as dicom
import nibabel as nib
import json
import json5
from scipy.ndimage import zoom
from pyviz_comms import extensio... |
9706393a1f3e028c035b700d83fca63f831ab5b82ad4e7e28bd490bad55a2049 | Python | 95,936 | 793 | #!/usr/bin/env python
from numpy import *
data_1=[array([3.523968,4.61725,5.009932,4.781034]),
array([6.634649,8.511027]),
array([5.299169,2.91673,4.618188,2.633355,2.685078]),
array([3.531018,3.453191]),
array([7.066488,6.28976,6.814411]),
array([8.1,8.4,13.224225,5.757449,10.1,7.805418,10.1,5.795456,1.887426]),
ar... |
37dda01d260af6be84a22bf51070331f3b16eb0410b7d97b631dafc6a73f2360 | Python | 95,946 | 6,684 | names_ = [
"AARON",
"Aarón",
"ABBIE",
"ABBY",
"ABDUL",
"ABDULLAH",
"ABE",
"Abel",
"ABIGAIL",
"Abraham",
"ABRAM",
"ABU",
"Abundio",
"ACHILLES",
"ACTON",
"ADA",
"ADAH",
"ADALBERTO",
"ADALINE",
"ADAM",
"Adamaris",
"ADAN",
"Adán",
... |
adfc1a9d3a6d4f04b2704e3e3fe41ab0f9b377e5d56207afcadce3944cc106ef | Python | 95,946 | 4,383 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from pip._vendor.chardet.sbcharsetprober import SingleByteCharSetModel
# 3: Positive
# 2: Likely
# 1: Unlikely
# 0: Negative
TURKISH_LANG_MODEL = {
23: { # 'A'
23: 0, # 'A'
37: 0, # 'B'
47: 0, # 'C'
39: 0, # 'D'
29: 0, #... |
ec1e1dcd5a6e670b004165f978baa787d5b24134799bca39ea0370e067801bcd | Python | 95,992 | 793 | #!/usr/bin/env python
from numpy import *
data_1=[array([2.657485,4.129912,4.380033,3.172819]),
array([6.50294,10.991822]),
array([5.113638,2.742798,4.502155,3.355231,2.992726]),
array([3.467839,3.427282]),
array([5.835269,6.721129,7.98197]),
array([8.1,8.4,12.689526,5.787908,10.1,6.821768,10.1,5.728776,2.945997]),
... |
055fb0c6e59ee4ae83090d4709797cce41353ce65f2fb774860e38aede6c2173 | Python | 96,011 | 2,334 | import argparse
import csv
import json
import os
import re
from pathlib import Path
import airsim
import numpy as np
import time
import math
import dataclasses
import torch
from dataclasses import dataclass, field
from typing import List, Tuple, Optional, Dict
# Public release: do not assume a user-specific AirSim se... |
62ab0fff1908dee507a82f34909ad84c371a294182f611673c89aedb0fbe3f02 | Python | 96,015 | 2,521 | # Author: Steven J. Bethard <steven.bethard@gmail.com>.
# New maintainer as of 29 August 2019: Raymond Hettinger <raymond.hettinger@gmail.com>
"""Command-line parsing library
This module is an optparse-inspired command-line parsing library that:
- handles both optional and positional arguments
- produces hi... |
dd8317e3772e6b548452a4903bf8d566334b18bb7c85796870483f7d2bb1837a | Python | 96,031 | 2,600 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Oct 22 17:32:43 2025
@author: ekoderman
"""
from sklearn.base import BaseEstimator, ClassifierMixin
from xgbordinal import XGBOrdinal
import numpy as np
from collections import Counter
from sklearn.metrics import recall_score
# --- Wrapper to make XGBO... |
19e519c44f1b59a26d6a93088b030300d1f57e7d30e0680f9fd2ddf6935b70cc | Python | 96,299 | 2,467 | #!/usr/bin/env python3
"""Full reproduction pipeline for the PsiAudit paper.
Runs the complete experimental battery used in the manuscript: the two-regime
audit, the scaling study, the comparative diagnostics, the multi-seed
replication with confidence intervals, the sensitivity sweep and H_G-gate
ablation, the ... |
4d97e89db7161dd1aec6e59a083d0cae5dc81d50e26871e4396ce35f7f3c48de | Python | 96,341 | 2,636 | """
Program for presenting visual stimuli to retinal neurons for eletrophysiology experiments.
"""
# Copyright (C) 2018 Alexander Tomlinson
# Distributed under the terms of the GNU General Public License (GPL).
import copy
import os
import pickle
import subprocess
import sys
import traceback
from math import ceil
fro... |
a43629fb2580a822e1c61cbdf02eeb6a756d9eebfd62f5c5d292f2b208652b43 | Python | 96,820 | 2,192 | from pathlib import Path
import warnings
import copy
from typing import Dict, Any, Optional, Union, List, Tuple, Callable, Iterable, Iterator, Type
import datetime
import collections
import importlib
import numpy as np
import scipy.sparse
from tqdm.auto import tqdm
import torch
import richfile as rf
from . import he... |
94cd6a672a8d747cbba0675d6a26b1ac40247407eec3d8ab5ce8785634fc4ee7 | Python | 97,273 | 2,534 | """
Tests for the data_tools module
"""
from merit.example_data import dummy_summary_data as dsd
from merit.gwas import dataset, utils as data_tools
from merit import errors as merit_errors, constants as con
from itertools import permutations
import pandas as pd
import numpy as np
import pytest
import decimal
import r... |
6fe3ad9b91e1060d9615fab1207a92397c1b01b4a7d19807a2a98e29dbf08a2e | Python | 97,278 | 2,219 | #!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and its affiliates.
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import math
import random
from os import path as osp
import magnum as mn
import numpy as np
import pytest
import... |
6828112d06266b9c172e13f98a3fd06678d5712e6647408719eea175f565c9e9 | Python | 97,535 | 2,923 | #!/usr/bin/python
# Handle unicode encoding
import csv
import errno
import getpass
import itertools
import locale
import os
import platform
import threading
import time
import shlex
import socket
import sys
import tempfile
import urllib2
from optparse import OptionParser, OptionGroup, SUPPRESS_HELP
from re import co... |
4343f1070b8c3d908a7eaa813d133f87a761a578a4acbf878e7c54192402f109 | Python | 97,657 | 2,017 | #!/usr/bin/env python3
"""
ANO Network Optimization FOMO - ANO Framework Module 6
======================================================
Developer: Lee, Seungjin (arer90)
PURPOSE:
Module 6 implements FOMO (Feature Optimization -> Model Optimization) strategy.
It uses the best features from Module 4, then optimizes th... |
0e82574a85809fa1b7e0ce7e05230ff0a95ce196713cfbed47ab79bccb37ab0f | Python | 97,714 | 2,575 | # Author: Steven J. Bethard <steven.bethard@gmail.com>.
# New maintainer as of 29 August 2019: Raymond Hettinger <raymond.hettinger@gmail.com>
"""Command-line parsing library
This module is an optparse-inspired command-line parsing library that:
- handles both optional and positional arguments
- produces hi... |
1118f2ada746c68493f6c5482b226fb4dccee0b7b315fc8226a9d10dd7476882 | Python | 97,832 | 2,578 | import re
import warnings
import numpy as np
import pytest
from keras.src import backend
from keras.src import testing
from keras.src.losses import losses
class MeanSquaredErrorTest(testing.TestCase):
def test_config(self):
self.run_class_serialization_test(losses.MeanSquaredError(name="mymse"))
de... |
7c04bfea19039dc1fa9e632ad0556e8e3ef59ef67845daf295968f2b78c2afdf | Python | 97,901 | 2,649 | # cython: language_level=3
# cython: profile=True
# Time-stamp: <2024-10-15 16:18:23 Tao Liu>
"""Module for BedGraph data class.
This code is free software; you can redistribute it and/or modify it
under the terms of the BSD License (see the file LICENSE included with
the distribution).
"""
# -----------------------... |
429ea1bea3800bd0726e640df89e5fcbfcbcfe9b6bf9baf3ae082a9bafee72eb | Python | 97,918 | 2,398 | """
This module contains a collection of fundamental building blocks for convolutional neural networks, primarily designed for biomedical image segmentation architectures like U-Nets and their variants.
It provides modular components for various operations, including:
- **Convolutional Layers:** Basic `ConvBlock` and... |
ccc970473b7386d7533cf70ed8b21d88b2dd4e61ffeeeae6156935aaec2d3442 | Python | 98,108 | 2,335 | from __future__ import with_statement
import os, time, threading, pickle, shutil
from collections import Counter
import java
from java.util import ArrayList, HashSet, Stack
from java.util.concurrent.atomic import AtomicInteger
from java.awt import Polygon, Rectangle, Color, Point
from java.awt.geom import Area, Affine... |
1af4eb4cd228633afee65e1c2050293fdb31ba7505aa16f3a7383e17e1d1096d | Python | 98,236 | 2,235 | # -*- coding: utf-8 -*-
'''
Document Module
'''
from __future__ import division
from collections import OrderedDict
from time import time
from uuid import uuid4
import numpy as np
import pkg_resources
from dipy.utils.optpkg import optional_package
from .fitted_modeling_framework import (
FittedMultiCompartmentMo... |
bf19ddc20ecbafa707d11f5db8694066ae1e401a29a1d8787a838e503378d6de | Python | 98,310 | 2,873 | # 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',
'... |
a8e2b93f226e8d0ad91adc143be24ebd401574f7709b6542dfe1e310983dcb77 | Python | 98,699 | 2,861 | """
GUI for pyStim
"""
# Copyright (C) 2018 Alexander Tomlinson
# Distributed under the terms of the GNU General Public License (GPL).
# must first turn pyglet shadow windows off to avoid conflict between wxPython
# and psychopy.visual on OSX
from sys import platform
if platform == 'darwin':
import pyglet
py... |
0f33cfe933c61bff8f57bb6ab29bbf77c76eb9eaa6eee37ee5e434687530d468 | Python | 98,776 | 4,383 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from pip._vendor.chardet.sbcharsetprober import SingleByteCharSetModel
# 3: Positive
# 2: Likely
# 1: Unlikely
# 0: Negative
HEBREW_LANG_MODEL = {
50: { # 'a'
50: 0, # 'a'
60: 1, # 'c'
61: 1, # 'd'
42: 1, # 'e'
53: 1, # ... |
9ed532db71da3c3604d4e434e1289c8a2512e03ef696a6bcf6ff06b24bfb79f7 | Python | 98,934 | 2,173 | """
QSAR AD Visualization Module - FIXED PATH VERSION
This module contains visualization functions for Applicability Domain analysis.
Fixed version with consistent path structure.
"""
# Import performance analyzer with error handling
try:
from .ad_performance_analysis import ADPerformanceAnalyzer
AD_PERFORMAN... |
dd915b7b0533f8dde19352584ee1ee04d91620cd824cf147a8852f5ec5ae6429 | Python | 98,939 | 3,107 | """Shared argparse helpers for pipeline command-line wrappers."""
from __future__ import annotations
import argparse
import hashlib
import json
import os
import re
import secrets
import stat
from collections.abc import Callable, Mapping
from dataclasses import dataclass
from functools import partial
from importlib.re... |
8846048f2ae98d7341bcfc4e81658543ba9291d469dd7ab981bcfce2b4b5a148 | Python | 99,132 | 2,891 | # 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',
'... |
f25758672154147b546421d5305b63d60b851d6bdc0c147a15627c6a3d47c9dc | Python | 99,341 | 2,383 | from __future__ import annotations
import configparser
import copy
import logging
import os
import pathlib
import sys
import uuid
import warnings
import webbrowser
from abc import ABC, abstractmethod
from collections import OrderedDict
from typing import (
TYPE_CHECKING,
Any,
Callable,
Dict,
List,
... |
4beb8d4358a10bbe72841bd2bb1db880b159bf743272d3300ba3b12c9757f9bc | Python | 99,571 | 4,398 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from pip._vendor.chardet.sbcharsetprober import SingleByteCharSetModel
# 3: Positive
# 2: Likely
# 1: Unlikely
# 0: Negative
GREEK_LANG_MODEL = {
60: { # 'e'
60: 2, # 'e'
55: 1, # 'o'
58: 2, # 't'
36: 1, # '·'
61: 0, # '... |
df63ee69f20c3842ac1f6a7c868dfff2e1b6142afe57681b2bf1f4324a646c60 | Python | 100,047 | 2,522 | import math
import warnings
import numpy as np
from typing import Literal, Optional
from math import ceil
from .base import minimum_spike_dtype
from .basesorting import SpikeVectorSortingSegment
from .numpyextractors import NumpySorting
from probeinterface import Probe, generate_linear_probe, generate_multi_columns_p... |
85cf6589b65a1e60a3bd1eacf9e3fe2d8fbd7822e79cf758aa79cc13c39caa07 | Python | 100,071 | 2,523 | """
Collate narrative simulation figures into a single combined plot.
Regenerates all plots from underlying data for visual consistency.
Layout:
- a) PCA plot (left, square)
- Right of PCA, two rows:
- Row 1: b) Bergman/Roediger data, c) Cosine distances to topic centroid
- Row 2: d) Frac new words by temp, e) Fra... |
17853f43f755792383eb0bdc8ca593b944008530d5af56ebbeee94f040324346 | Python | 100,076 | 1,819 | import warnings
import torch
import numpy as np
import time
import collections
import matplotlib.pyplot as plt
import datetime
import random
from tqdm import tqdm
import copy
import collections
import scipy
import os
import ailoc.common
import ailoc.simulation
import ailoc.lunar
class Lunar_LocLearning(ailoc.common.... |
4f8ad3cb6f16657f623ae5e8e15f7341eab1ee3adfdbb80fffc3eccd56756a0f | Python | 100,296 | 2,931 | # -*- coding: utf-8 -*-
# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
# vi: set ft=python sts=4 ts=4 sw=4 et:
"""SPM wrappers for preprocessing data
"""
import os
from copy import deepcopy
# Third-party imports
import numpy as np
# Local imports
from ...utils.filemanip import (
fname_p... |
4a15379412d24369ef641526fbccb3636326b6500a9e5c254cdbf0e096c15139 | Python | 100,582 | 2,577 | """
helper classes and functions
"""
from merit.ensembl import ensembl_errors, constants, coords
from itertools import combinations
import sys
import pprint as pp
# The codes for unknown indels
UNKNOWN_INDEL_REF = 'R'
UNKNOWN_INDEL_INSERTION = 'I'
UNKNOWN_INDEL_DELETION = 'D'
UNKNOWN_INDEL_ALTS = [UNKNOWN_INDEL_INSERT... |
8d1a5f86334c468df202969a87df233dc25c1449f8696f24a986e922b2cfdefd | Python | 101,280 | 2,774 | """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 me... |
e6f0837a5348a2f9ccb3f4f1d11a09e6a08518e993d79dcb37dbe48bef8cc1a7 | Python | 101,351 | 2,042 | """
Optic Lobe Cross-Dataset Matching: Iterative Connectivity Alignment
Assigns FAFB cell_type labels to BANC optic lobe neurons by iteratively
comparing type-level connectivity profiles between the two datasets.
Algorithm:
1. FAFB types are ground truth (fixed centroids)
2. BANC neurons initialized from SeaTable... |
544197bfc14ea6e186e08d7c98a3dae011401d52f1b02896df6724e11ed1637e | Python | 101,585 | 2,782 | """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 me... |
ee917db29ebaf985ad80c7924d29fee26459dba0dd9c644432fa94d3cbf7488c | Python | 102,119 | 2,364 | """ The EfficientNet Family in PyTorch
An implementation of EfficienNet that covers variety of related models with efficient architectures:
* EfficientNet-V2
- `EfficientNetV2: Smaller Models and Faster Training` - https://arxiv.org/abs/2104.00298
* EfficientNet (B0-B8, L2 + Tensorflow pretrained AutoAug/RandAug/A... |
46d247ec365db26687ab22b8e8a9269e4e70407889c093cf252aaa225a5e6517 | Python | 102,498 | 4,650 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from pip._vendor.chardet.sbcharsetprober import SingleByteCharSetModel
# 3: Positive
# 2: Likely
# 1: Unlikely
# 0: Negative
HUNGARIAN_LANG_MODEL = {
28: { # 'A'
28: 0, # 'A'
40: 1, # 'B'
54: 1, # 'C'
45: 2, # 'D'
32: 1, ... |
5d207863134360b010a90e78d03a5bb0ad76b69bdbb94bb5385873cbd90cc35f | Python | 103,185 | 2,497 | ################################### File paths need to be adjusted for each utiliy plot in case used ########################################################################
# %%
###################################### Change in Baseline (Delta Na_i) ####################################################################... |
6a187a2bc2329cbc31a6efe5763f554b57286741f153036887e617737d9c7bb0 | Python | 103,225 | 3,023 | # emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
# vi: set ft=python sts=4 ts=4 sw=4 et:
"""SPM wrappers for preprocessing data"""
import os
from copy import deepcopy
# Third-party imports
import numpy as np
# Local imports
from ...utils.filemanip import (
fname_presuffix,
ensure_lis... |
475c171e750cb5e8e9c342671ff24ef177586ac304eb08d5aa9d733fb4ca2e08 | Python | 103,312 | 4,383 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from pip._vendor.chardet.sbcharsetprober import SingleByteCharSetModel
# 3: Positive
# 2: Likely
# 1: Unlikely
# 0: Negative
THAI_LANG_MODEL = {
5: { # 'ก'
5: 2, # 'ก'
30: 2, # 'ข'
24: 2, # 'ค'
8: 2, # 'ง'
26: 2, # 'จ'
... |
96a7b322fca3eb480934278c74050f91006546d8e49eaac0dd6030215f8442c1 | Python | 103,361 | 2,265 | import torch
import torch.nn.functional as F
import os
import sqlite3
import numpy as np
from copy import deepcopy
from typing import Optional, Dict, List, Any, Union
from huggingface_hub import HfApi
from transformers import Trainer, TrainingArguments, EarlyStoppingCallback, EvalPrediction, TrainerCallback
from datacl... |
8cd13bea52d7a33fadd2ec22588e10360ea959bd53b3436e90f8f22dbc173c95 | Python | 103,478 | 2,866 | import numbers
import warnings
import numpy as np
from keras.src import backend
from keras.src import ops
from keras.src import tree
from keras.src.api_export import keras_export
from keras.src.backend.common.backend_utils import canonicalize_axis
from keras.src.losses.loss import Loss
from keras.src.losses.loss impo... |
65d7fb70f3815d6bd4ae2de5eacf839a96417a026b9d6ea3950b21188170a97d | Python | 103,633 | 1,073 |
import google.protobuf
from packaging.version import Version
if Version(google.protobuf.__version__).major >= 5:
# -*- coding: utf-8 -*-
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: model_registry.proto
# Protobuf Python Version: 5.26.0
"""Generated protocol buffer code."""
from goo... |
16fff52a081d3814fe40d2b76c4f118f0947b49b602583d9f992618df1842ae2 | Python | 103,702 | 2,472 | # Copyright 2024 ByteDance and/or its affiliates.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or ... |
d14e6782e6fabcab617cb42c36e55effdc6a4256004c613bbefa1de618651861 | Python | 103,824 | 1,207 | __author__ = "Simon Nilsson; sronilsson@gmail.com"
from simba.utils.printing import (SimbaTimer, stdout_information,
stdout_success, stdout_warning)
load_timer = SimbaTimer(start=True)
import os.path
import warnings
warnings.filterwarnings("ignore", category=FutureWarning)
warnings.... |
d191d99b4578b9346d3043e8752d2090c771b6ab4a19814a834faabf44e93a07 | Python | 103,985 | 2,986 | from unittest import mock
import jax
import numpy as np
import pytest
from absl.testing import parameterized
import keras
from keras.src import backend
from keras.src import initializers
from keras.src import layers
from keras.src import losses
from keras.src import metrics
from keras.src import models
from keras.src... |
fbffe0a47c12720af3a87aa4231cec4eff0aa04a55259c776b2dcabc9cd51a80 | Python | 104,543 | 2,793 | # Module doctest.
# Released to the public domain 16-Jan-2001, by Tim Peters (tim@python.org).
# Major enhancements and refactoring by:
# Jim Fulton
# Edward Loper
# Provided as-is; use at your own risk; no warranty; no promises; enjoy!
r"""Module doctest -- a framework for running examples in docstrings.
In... |
bbcd360aac71512cfc7b346cf754f50ae67e48fda3266e0cc1d6e4df79a0506b | Python | 104,546 | 2,793 | # Module doctest.
# Released to the public domain 16-Jan-2001, by Tim Peters (tim@python.org).
# Major enhancements and refactoring by:
# Jim Fulton
# Edward Loper
# Provided as-is; use at your own risk; no warranty; no promises; enjoy!
r"""Module doctest -- a framework for running examples in docstrings.
In... |
e6893c103168a8fcc1f304a2240889090d842c6f51de877197a4354c8b7c13aa | Python | 105,305 | 1,808 | #!/usr/bin/env python3
import sys
import os
import os.path as osp
sys.path.append(os.getcwd())
import string
import functools
import socket
import getpass
import argparse
import collections
import json
import random
import math
import itertools
from collections import OrderedDict
import copy
from types import SimpleNam... |
229957b599770139141d891dc559abc41904399d0a21e93a61e6bfa39c274716 | Python | 105,369 | 2,624 | from merit import constants as con, errors
from merit.utils import analysis_tools
from merit.gwas import utils
from merit.ipd import ipd_tools
from merit.wrappers import qctool
from tqdm import tqdm
from pybgen import PyBGEN
import pandas as pd
import numpy as np
import numpy.ma as ma
import math
import warnings
import... |
f393647f30af3bc58d4d75e8d3d179a0cdef4edbfcfd440efa3603a61d937161 | Python | 105,420 | 1,064 |
import google.protobuf
from packaging.version import Version
if Version(google.protobuf.__version__).major >= 5:
# -*- coding: utf-8 -*-
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: databricks_tracing.proto
# Protobuf Python Version: 5.26.0
"""Generated protocol buffer code."""
from... |
ae4f42269bb13b46ce6dba0972fea03605aea2c61999df2a10476ce72ec34bf6 | Python | 105,697 | 4,650 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from pip._vendor.chardet.sbcharsetprober import SingleByteCharSetModel
# 3: Positive
# 2: Likely
# 1: Unlikely
# 0: Negative
BULGARIAN_LANG_MODEL = {
63: { # 'e'
63: 1, # 'e'
45: 0, # '\xad'
31: 0, # 'А'
32: 0, # 'Б'
35: ... |
62aed4388e4de27cd5220bb5f5e02197cb92b32d0d40ffab85bec1154b1ef949 | Python | 105,916 | 2,514 | #!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and its affiliates.
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
# NOTE: This example requires the GUI viewer, which is built by default.
# If you built in headless mode (HABITAT_... |
1c8003eec5555a866b5dae29d96f9610f027912a339bfd1bf9055e0c532fb928 | Python | 105,948 | 3,444 | # Copyright 2017 Google LLC.
#
# 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.
#
#... |
d90226d6351f85e74a5f6062686c53723304b71743f3148046697d4c647384a5 | Python | 106,508 | 2,698 | """
Drift estimation via image registration.
Supports phase correlation and ECC (Enhanced Correlation Coefficient).
Key fixes included:
- Pass 1 stores *absolute* (reference->frame) drift WITHOUT per-frame clamping.
- Pass 2 estimates *residual* after Pass 1 pre-alignment, then adds it to Pass 1 deltas.
- Optional pe... |
a3fee6c76b5de2ab675364e66df9b96ebd8b462a6ab7d9099e7459029940da1f | Python | 106,569 | 2,744 | #!/usr/bin/env python3
"""Generate Python documentation in HTML or text for interactive use.
At the Python interactive prompt, calling help(thing) on a Python object
documents the object, and calling help() starts up an interactive
help session.
Or, at the shell command line outside of Python:
Run "pydoc <name>" to ... |
4ffee5fc84407dc8f76b35b53fdc81577a37368858382d39399fdb5d2b76ab0c | Python | 106,672 | 2,566 | """
Python implementation of the coloc R package.
See the original R code here (06-04-2021 last update):
`Here <https://github.com/chr1swallace/coloc/blob/main/R/split.R>`__.
Relevant documentation:
`Here <https://chr1swallace.github.io/coloc/articles/a02_data.html>`__.
And relevant papers:
`Here <https:... |
bf3d7d4d8ce40faab3a0798df354a493c677d9d308df97fb6f3f9c58987ce85f | Python | 106,714 | 2,768 | from tabulate import tabulate
import pandas as pd
import numpy as np
from timeit import default_timer as dt
from copy import deepcopy
import functools
from typing import List, Tuple, Optional, Dict, Any, Callable, Union
from skimage.measure import regionprops_table, _regionprops_utils
from skimage import measure
from s... |
f32f8b681ce9ea2b9c13ab04f084d097eae7c7dcad3dff2322c49f1703809c02 | Python | 106,959 | 3,003 | """Header value parser implementing various email-related RFC parsing rules.
The parsing methods defined in this module implement various email related
parsing rules. Principal among them is RFC 5322, which is the followon
to RFC 2822 and primarily a clarification of the former. It also implements
RFC 2047 encoded w... |
e05bd476b3a0d242c2d8bd508125860ca625f460f968fc73254fa3ff96a319d4 | Python | 106,991 | 2,884 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
from __future__ import annotations
from collections.abc import MutableSequence
from typing import Any
from typing_extensions import Self
import numpy as np
import vedo.vtkclasses as vtki # a wrapper for lazy imports
import vedo
from vedo.core import input as input_util... |
309deae66f37bbf6abdeb8e85b9ad2bc3b5045ff94d07822d7533a7b1e9aa7df | Python | 107,642 | 2,580 | """Filesystem tests for installing the bundled agent skills into a project.
The install command writes into a directory that belongs to the user rather than to this
package, which makes most of what it does a promise about what it will *not* touch: a
second run must not rewrite an unchanged copy, an edited copy must s... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.