, +, x, D, d, s, p, *, h, H, 1, 2, 3, 4, 8}\n\n marker_size : `int`, optional\n The size of the markers in points^2.\n marker_face_colour : See Below, optional\n The face (filling) colour of the markers.\n Example options ::\n \n {r, g, b, c, m, k, w}\n or\n (3, ) ndarray\n\n marker_edge_colour : See Below, optional\n The edge colour of the markers.\n Example options ::\n \n {r, g, b, c, m, k, w}\n or \n (3, ) ndarray\n\n marker_edge_width : `float`, optional\n The width of the markers' edge.\n render_numbering : `bool`, optional\n If ``True``, the landmarks will be numbered.\n numbers_horizontal_align : ``{center, right, left}``, optional\n The horizontal alignment of the numbers' texts.\n numbers_vertical_align : ``{center, top, bottom, baseline}``, optional\n The vertical alignment of the numbers' texts.\n numbers_font_name : See Below, optional\n The font of the numbers. Example options ::\n\n {serif, sans-serif, cursive, fantasy, monospace}\n\n numbers_font_size : `int`, optional\n The font size of the numbers.\n numbers_font_style : ``{normal, italic, oblique}``, optional\n The font style of the numbers.\n numbers_font_weight : See Below, optional\n The font weight of the numbers.\n Example options ::\n \n {ultralight, light, normal, regular, book, medium, roman,\n semibold, demibold, demi, bold, heavy, extra bold, black}\n\n numbers_font_colour : See Below, optional\n The font colour of the numbers.\n Example options ::\n\n {r, g, b, c, m, k, w}\n or\n (3, ) ndarray\n\n render_legend : `bool`, optional\n If ``True``, the legend will be rendered.\n legend_title : `str`, optional\n The title of the legend.\n legend_font_name : See below, optional\n The font of the legend. Example options ::\n \n {serif, sans-serif, cursive, fantasy, monospace}\n\n legend_font_style : ``{normal, italic, oblique}``, optional\n The font style of the legend.\n legend_font_size : `int`, optional\n The font size of the legend.\n legend_font_weight : See Below, optional\n The font weight of the legend.\n Example options ::\n \n {ultralight, light, normal, regular, book, medium, roman,\n semibold, demibold, demi, bold, heavy, extra bold, black}\n\n legend_marker_scale : `float`, optional\n The relative size of the legend markers with respect to the original\n legend_location : `int`, optional\n The location of the legend. The predefined values are:\n\n =============== ==\n 'best' 0\n 'upper right' 1\n 'upper left' 2\n 'lower left' 3\n 'lower right' 4\n 'right' 5\n 'center left' 6\n 'center right' 7\n 'lower center' 8\n 'upper center' 9\n 'center' 10\n =============== ==\n\n legend_bbox_to_anchor : (`float`, `float`) `tuple`, optional\n The bbox that the legend will be anchored.\n legend_border_axes_pad : `float`, optional\n The pad between the axes and legend border.\n legend_n_columns : `int`, optional\n The number of the legend's columns.\n legend_horizontal_spacing : `float`, optional\n The spacing between the columns.\n legend_vertical_spacing : `float`, optional\n The vertical space between the legend entries.\n legend_border : `bool`, optional\n If ``True``, a frame will be drawn around the legend.\n legend_border_padding : `float`, optional\n The fractional whitespace inside the legend border.\n legend_shadow : `bool`, optional\n If ``True``, a shadow will be drawn behind legend.\n legend_rounded_corners : `bool`, optional\n If ``True``, the frame's corners will be rounded (fancybox).\n render_axes : `bool`, optional\n If ``True``, the axes will be rendered.\n axes_font_name : See Below, optional\n The font of the axes. Example options ::\n \n {serif, sans-serif, cursive, fantasy, monospace}\n\n axes_font_size : `int`, optional\n The font size of the axes.\n axes_font_style : ``{normal, italic, oblique}``, optional\n The font style of the axes.\n axes_font_weight : See Below, optional\n The font weight of the axes.\n Example options ::\n\n {ultralight, light, normal, regular, book, medium, roman,\n semibold,demibold, demi, bold, heavy, extra bold, black}\n\n axes_x_limits : (`float`, `float`) `tuple` or ``None`` optional\n The limits of the x axis.\n axes_y_limits : (`float`, `float`) `tuple` or ``None`` optional\n The limits of the y axis.\n figure_size : (`float`, `float`) `tuple` or ``None`` optional\n The size of the figure in inches.\n\n Raises\n ------\n ValueError\n If both ``with_labels`` and ``without_labels`` are passed.\n ValueError\n If the landmark manager doesn't contain the provided group label.\n \"\"\"\n from menpo.visualize import view_image_landmarks\n return view_image_landmarks(\n self, channels, False, group, with_labels, without_labels,\n figure_id, new_figure, interpolation, cmap_name, alpha,\n render_lines, line_colour, line_style, line_width,\n render_markers, marker_style, marker_size, marker_face_colour,\n marker_edge_colour, marker_edge_width, render_numbering,\n numbers_horizontal_align, numbers_vertical_align,\n numbers_font_name, numbers_font_size, numbers_font_style,\n numbers_font_weight, numbers_font_colour, render_legend,\n legend_title, legend_font_name, legend_font_style,\n legend_font_size, legend_font_weight, legend_marker_scale,\n legend_location, legend_bbox_to_anchor, legend_border_axes_pad,\n legend_n_columns, legend_horizontal_spacing,\n legend_vertical_spacing, legend_border, legend_border_padding,\n legend_shadow, legend_rounded_corners, render_axes, axes_font_name,\n axes_font_size, axes_font_style, axes_font_weight, axes_x_limits,\n axes_y_limits, figure_size)\n\n def gradient(self, **kwargs):\n r\"\"\"\n Returns an :map:`Image` which is the gradient of this one. In the case\n of multiple channels, it returns the gradient over each axis over\n each channel as a flat `list`. Take care to note the ordering of\n the returned gradient (the gradient over each spatial dimension\n is taken over each channel).\n\n The first axis of the gradient of a 2D, 3-channel image,\n will have length `6`, the ordering being\n ``I[:, 0, 0] = [R0_y, G0_y, B0_y, R0_x, G0_x, B0_x]``. To be clear,\n all the ``y``-gradients are returned over each channel, then all\n the ``x``-gradients.\n\n Returns\n -------\n gradient : :map:`Image`\n The gradient over each axis over each channel. Therefore, the\n gradient of a 2D, single channel image, will have length `2`.\n The length of a 2D, 3-channel image, will have length `6`.\n \"\"\"\n warn('gradient() is deprecated and will be removed in'\n ' the next major version of menpo. '\n 'Please use menpo.feature.gradient instead.',\n MenpoDeprecationWarning)\n\n from menpo.feature import gradient as grad_feature\n return grad_feature(self)\n\n def crop(self, min_indices, max_indices,\n constrain_to_boundary=False):\n r\"\"\"\n Return a cropped copy of this image using the given minimum and\n maximum indices. Landmarks are correctly adjusted so they maintain\n their position relative to the newly cropped image.\n\n Parameters\n ----------\n min_indices : ``(n_dims,)`` `ndarray`\n The minimum index over each dimension.\n max_indices : ``(n_dims,)`` `ndarray`\n The maximum index over each dimension.\n constrain_to_boundary : `bool`, optional\n If ``True`` the crop will be snapped to not go beyond this images\n boundary. If ``False``, an :map:`ImageBoundaryError` will be raised\n if an attempt is made to go beyond the edge of the image.\n\n Returns\n -------\n cropped_image : `type(self)`\n A new instance of self, but cropped.\n\n Raises\n ------\n ValueError\n ``min_indices`` and ``max_indices`` both have to be of length\n ``n_dims``. All ``max_indices`` must be greater than\n ``min_indices``.\n ImageBoundaryError\n Raised if ``constrain_to_boundary=False``, and an attempt is made\n to crop the image in a way that violates the image bounds.\n \"\"\"\n min_indices = np.floor(min_indices)\n max_indices = np.ceil(max_indices)\n if not (min_indices.size == max_indices.size == self.n_dims):\n raise ValueError(\n \"Both min and max indices should be 1D numpy arrays of\"\n \" length n_dims ({})\".format(self.n_dims))\n elif not np.all(max_indices > min_indices):\n raise ValueError(\"All max indices must be greater that the min \"\n \"indices\")\n min_bounded = self.constrain_points_to_bounds(min_indices)\n max_bounded = self.constrain_points_to_bounds(max_indices)\n all_max_bounded = np.all(min_bounded == min_indices)\n all_min_bounded = np.all(max_bounded == max_indices)\n if not (constrain_to_boundary or all_max_bounded or all_min_bounded):\n # points have been constrained and the user didn't want this -\n raise ImageBoundaryError(min_indices, max_indices,\n min_bounded, max_bounded)\n\n new_shape = max_bounded - min_bounded\n return self.warp_to_shape(new_shape, Translation(min_bounded),\n order=0, warp_landmarks=True)\n\n def crop_to_pointcloud(self, pointcloud, boundary=0,\n constrain_to_boundary=True):\n r\"\"\"\n Return a copy of this image cropped so that it is bounded around a\n pointcloud with an optional ``n_pixel`` boundary.\n\n Parameters\n ----------\n pointcloud : :map:`PointCloud`\n The pointcloud to crop around.\n boundary : `int`, optional\n An extra padding to be added all around the landmarks bounds.\n constrain_to_boundary : `bool`, optional\n If ``True`` the crop will be snapped to not go beyond this images\n boundary. If ``False``, an :map`ImageBoundaryError` will be raised\n if an attempt is made to go beyond the edge of the image.\n\n Returns\n -------\n image : :map:`Image`\n A copy of this image cropped to the bounds of the pointcloud.\n\n Raises\n ------\n ImageBoundaryError\n Raised if ``constrain_to_boundary=False``, and an attempt is made\n to crop the image in a way that violates the image bounds.\n \"\"\"\n min_indices, max_indices = pointcloud.bounds(boundary=boundary)\n return self.crop(min_indices, max_indices,\n constrain_to_boundary=constrain_to_boundary)\n\n def crop_to_landmarks(self, group=None, label=None, boundary=0,\n constrain_to_boundary=True):\n r\"\"\"\n Return a copy of this image cropped so that it is bounded around a set\n of landmarks with an optional ``n_pixel`` boundary\n\n Parameters\n ----------\n group : `str`, optional\n The key of the landmark set that should be used. If ``None``\n and if there is only one set of landmarks, this set will be used.\n label : `str`, optional\n The label of of the landmark manager that you wish to use. If\n ``None`` all landmarks in the group are used.\n boundary : `int`, optional\n An extra padding to be added all around the landmarks bounds.\n constrain_to_boundary : `bool`, optional\n If ``True`` the crop will be snapped to not go beyond this images\n boundary. If ``False``, an :map`ImageBoundaryError` will be raised\n if an attempt is made to go beyond the edge of the image.\n\n Returns\n -------\n image : :map:`Image`\n A copy of this image cropped to its landmarks.\n\n Raises\n ------\n ImageBoundaryError\n Raised if ``constrain_to_boundary=False``, and an attempt is made\n to crop the image in a way that violates the image bounds.\n \"\"\"\n pc = self.landmarks[group][label]\n return self.crop_to_pointcloud(\n pc, boundary=boundary, constrain_to_boundary=constrain_to_boundary)\n\n def crop_to_pointcloud_proportion(self, pointcloud, boundary_proportion,\n minimum=True,\n constrain_to_boundary=True):\n r\"\"\"\n Return a copy of this image cropped so that it is bounded around a\n pointcloud with an optional ``n_pixel`` boundary.\n\n Parameters\n ----------\n boundary_proportion : `float`\n Additional padding to be added all around the landmarks\n bounds defined as a proportion of the landmarks range. See\n the minimum parameter for a definition of how the range is\n calculated.\n pointcloud : :map:`PointCloud`\n The pointcloud to crop around.\n minimum : `bool`, optional\n If ``True`` the specified proportion is relative to the minimum\n value of the pointclouds' per-dimension range; if ``False`` w.r.t.\n the maximum value of the pointclouds' per-dimension range.\n constrain_to_boundary : `bool`, optional\n If ``True``, the crop will be snapped to not go beyond this images\n boundary. If ``False``, an :map:`ImageBoundaryError` will be raised\n if an attempt is made to go beyond the edge of the image.\n\n Returns\n -------\n image : :map:`Image`\n A copy of this image cropped to the border proportional to\n the pointcloud spread or range.\n\n Raises\n ------\n ImageBoundaryError\n Raised if ``constrain_to_boundary=False``, and an attempt is made\n to crop the image in a way that violates the image bounds.\n \"\"\"\n if minimum:\n boundary = boundary_proportion * np.min(pointcloud.range())\n else:\n boundary = boundary_proportion * np.max(pointcloud.range())\n return self.crop_to_pointcloud(\n pointcloud, boundary=boundary,\n constrain_to_boundary=constrain_to_boundary)\n\n def crop_to_landmarks_proportion(self, boundary_proportion,\n group=None, label=None, minimum=True,\n constrain_to_boundary=True):\n r\"\"\"\n Crop this image to be bounded around a set of landmarks with a\n border proportional to the landmark spread or range.\n\n Parameters\n ----------\n boundary_proportion : `float`\n Additional padding to be added all around the landmarks\n bounds defined as a proportion of the landmarks range. See\n the minimum parameter for a definition of how the range is\n calculated.\n group : `str`, optional\n The key of the landmark set that should be used. If ``None``\n and if there is only one set of landmarks, this set will be used.\n label : `str`, optional\n The label of of the landmark manager that you wish to use. If\n ``None`` all landmarks in the group are used.\n minimum : `bool`, optional\n If ``True`` the specified proportion is relative to the minimum\n value of the landmarks' per-dimension range; if ``False`` w.r.t. the\n maximum value of the landmarks' per-dimension range.\n constrain_to_boundary : `bool`, optional\n If ``True``, the crop will be snapped to not go beyond this images\n boundary. If ``False``, an :map:`ImageBoundaryError` will be raised\n if an attempt is made to go beyond the edge of the image.\n\n Returns\n -------\n image : :map:`Image`\n This image, cropped to its landmarks with a border proportional to\n the landmark spread or range.\n\n Raises\n ------\n ImageBoundaryError\n Raised if ``constrain_to_boundary=False``, and an attempt is made\n to crop the image in a way that violates the image bounds.\n \"\"\"\n pc = self.landmarks[group][label]\n return self.crop_to_pointcloud_proportion(\n pc, boundary_proportion, minimum=minimum,\n constrain_to_boundary=constrain_to_boundary)\n\n def _propagate_crop_to_inplace(self, cropped):\n # helper method that sets self's state to the result of a crop call.\n # only needed for the deprecation period of the inplace crop methods.\n self.pixels = cropped.pixels\n self.landmarks = cropped.landmarks\n if hasattr(self, 'mask'):\n self.mask = cropped.mask\n return self\n\n def crop_inplace(self, *args, **kwargs):\n r\"\"\"\n Deprecated: please use :meth:`crop` instead.\n \"\"\"\n warn('crop_inplace() is deprecated and will be removed in the next '\n 'major version of menpo. '\n 'Please use crop() instead.', MenpoDeprecationWarning)\n cropped = self.crop(*args, **kwargs)\n return self._propagate_crop_to_inplace(cropped)\n\n def crop_to_landmarks_inplace(self, *args, **kwargs):\n r\"\"\"\n Deprecated: please use :meth:`crop_to_landmarks` instead.\n \"\"\"\n warn('crop_to_landmarks_inplace() is deprecated and will be removed in'\n ' the next major version of menpo. '\n 'Please use crop_to_landmarks() instead.',\n MenpoDeprecationWarning)\n cropped = self.crop_to_landmarks(*args, **kwargs)\n return self._propagate_crop_to_inplace(cropped)\n\n def crop_to_landmarks_proportion_inplace(self, *args, **kwargs):\n r\"\"\"\n Deprecated: please use :meth:`crop_to_landmarks_proportion` instead.\n \"\"\"\n warn('crop_to_landmarks_proportion_inplace() is deprecated and will be'\n ' removed in the next major version of menpo. Please use '\n 'crop_to_landmarks_proportion() instead.',\n MenpoDeprecationWarning)\n cropped = self.crop_to_landmarks_proportion(*args, **kwargs)\n return self._propagate_crop_to_inplace(cropped)\n\n def constrain_points_to_bounds(self, points):\n r\"\"\"\n Constrains the points provided to be within the bounds of this image.\n\n Parameters\n ----------\n points : ``(d,)`` `ndarray`\n Points to be snapped to the image boundaries.\n\n Returns\n -------\n bounded_points : ``(d,)`` `ndarray`\n Points snapped to not stray outside the image edges.\n \"\"\"\n bounded_points = points.copy()\n # check we don't stray under any edges\n bounded_points[bounded_points < 0] = 0\n # check we don't stray over any edges\n shape = np.array(self.shape)\n over_image = (shape - bounded_points) < 0\n bounded_points[over_image] = shape[over_image]\n return bounded_points\n\n def extract_patches(self, patch_centers, patch_size=(16, 16),\n sample_offsets=None, as_single_array=False):\n r\"\"\"\n Extract a set of patches from an image. Given a set of patch centers\n and a patch size, patches are extracted from within the image, centred\n on the given coordinates. Sample offsets denote a set of offsets to\n extract from within a patch. This is very useful if you want to extract\n a dense set of features around a set of landmarks and simply sample the\n same grid of patches around the landmarks.\n\n If sample offsets are used, to access the offsets for each patch you\n need to slice the resulting `list`. So for 2 offsets, the first centers\n offset patches would be ``patches[:2]``.\n\n Currently only 2D images are supported.\n\n Parameters\n ----------\n patch_centers : :map:`PointCloud`\n The centers to extract patches around.\n patch_size : ``(1, n_dims)`` `tuple` or `ndarray`, optional\n The size of the patch to extract\n sample_offsets : ``(n_offsets, n_dims)`` `ndarray` or ``None``, optional\n The offsets to sample from within a patch. So ``(0, 0)`` is the\n centre of the patch (no offset) and ``(1, 0)`` would be sampling the\n patch from 1 pixel up the first axis away from the centre.\n If ``None``, then no offsets are applied.\n as_single_array : `bool`, optional\n If ``True``, an ``(n_center * n_offset, self.shape...)``\n `ndarray`, thus a single numpy array is returned containing each\n patch. If ``False``, a `list` of :map:`Image` objects is returned\n representing each patch.\n\n Returns\n -------\n patches : `list` or `ndarray`\n Returns the extracted patches. Returns a list if\n ``as_single_array=True`` and an `ndarray` if\n ``as_single_array=False``.\n\n Raises\n ------\n ValueError\n If image is not 2D\n \"\"\"\n if self.n_dims != 2:\n raise ValueError('Only two dimensional patch extraction is '\n 'currently supported.')\n\n if sample_offsets is None:\n sample_offsets = np.zeros([1, 2], dtype=np.intp)\n else:\n sample_offsets = np.require(sample_offsets, dtype=np.intp)\n\n single_array = extract_patches(self.pixels, patch_centers.points,\n np.asarray(patch_size, dtype=np.intp),\n sample_offsets)\n\n if as_single_array:\n return single_array\n else:\n return [Image(o, copy=False) for p in single_array for o in p]\n\n def extract_patches_around_landmarks(\n self, group=None, label=None, patch_size=(16, 16),\n sample_offsets=None, as_single_array=False):\n r\"\"\"\n Extract patches around landmarks existing on this image. Provided the\n group label and optionally the landmark label extract a set of patches.\n\n See `extract_patches` for more information.\n\n Currently only 2D images are supported.\n\n Parameters\n ----------\n group : `str` or ``None``, optional\n The landmark group to use as patch centres.\n label : `str` or ``None``, optional\n The landmark label within the group to use as centres.\n patch_size : `tuple` or `ndarray`, optional\n The size of the patch to extract\n sample_offsets : ``(n_offsets, n_dims)`` `ndarray` or ``None``, optional\n The offsets to sample from within a patch. So ``(0, 0)`` is the\n centre of the patch (no offset) and ``(1, 0)`` would be sampling the\n patch from 1 pixel up the first axis away from the centre.\n If ``None``, then no offsets are applied.\n as_single_array : `bool`, optional\n If ``True``, an ``(n_center * n_offset, self.shape...)``\n `ndarray`, thus a single numpy array is returned containing each\n patch. If ``False``, a `list` of :map:`Image` objects is returned\n representing each patch.\n\n Returns\n -------\n patches : `list` or `ndarray`\n Returns the extracted patches. Returns a list if\n ``as_single_array=True`` and an `ndarray` if\n ``as_single_array=False``.\n\n Raises\n ------\n ValueError\n If image is not 2D\n \"\"\"\n return self.extract_patches(self.landmarks[group][label],\n patch_size=patch_size,\n sample_offsets=sample_offsets,\n as_single_array=as_single_array)\n\n def warp_to_mask(self, template_mask, transform, warp_landmarks=False,\n order=1, mode='constant', cval=0.0, batch_size=None):\n r\"\"\"\n Return a copy of this image warped into a different reference space.\n\n Note that warping into a mask is slower than warping into a full image.\n If you don't need a non-linear mask, consider :meth:``warp_to_shape``\n instead.\n\n Parameters\n ----------\n template_mask : :map:`BooleanImage`\n Defines the shape of the result, and what pixels should be sampled.\n transform : :map:`Transform`\n Transform **from the template space back to this image**.\n Defines, for each pixel location on the template, which pixel\n location should be sampled from on this image.\n warp_landmarks : `bool`, optional\n If ``True``, result will have the same landmark dictionary\n as ``self``, but with each landmark updated to the warped position.\n order : `int`, optional\n The order of interpolation. The order has to be in the range [0,5]\n\n ========= =====================\n Order Interpolation\n ========= =====================\n 0 Nearest-neighbor\n 1 Bi-linear *(default)*\n 2 Bi-quadratic\n 3 Bi-cubic\n 4 Bi-quartic\n 5 Bi-quintic\n ========= =====================\n\n mode : ``{constant, nearest, reflect, wrap}``, optional\n Points outside the boundaries of the input are filled according\n to the given mode.\n cval : `float`, optional\n Used in conjunction with mode ``constant``, the value outside\n the image boundaries.\n batch_size : `int` or ``None``, optional\n This should only be considered for large images. Setting this\n value can cause warping to become much slower, particular for\n cached warps such as Piecewise Affine. This size indicates\n how many points in the image should be warped at a time, which\n keeps memory usage low. If ``None``, no batching is used and all\n points are warped at once.\n\n Returns\n -------\n warped_image : :map:`MaskedImage`\n A copy of this image, warped.\n \"\"\"\n if self.n_dims != transform.n_dims:\n raise ValueError(\n \"Trying to warp a {}D image with a {}D transform \"\n \"(they must match)\".format(self.n_dims, transform.n_dims))\n template_points = template_mask.true_indices()\n points_to_sample = transform.apply(template_points,\n batch_size=batch_size)\n sampled = self.sample(points_to_sample,\n order=order, mode=mode, cval=cval)\n\n # set any nan values to 0\n sampled[np.isnan(sampled)] = 0\n # build a warped version of the image\n warped_image = self._build_warped_to_mask(template_mask, sampled)\n if warp_landmarks and self.has_landmarks:\n warped_image.landmarks = self.landmarks\n transform.pseudoinverse().apply_inplace(warped_image.landmarks)\n if hasattr(self, 'path'):\n warped_image.path = self.path\n return warped_image\n\n def _build_warped_to_mask(self, template_mask, sampled_pixel_values):\n r\"\"\"\n Builds the warped image from the template mask and sampled pixel values.\n Overridden for :map:`BooleanImage` as we can't use the usual\n :meth:`from_vector_inplace` method. All other :map:`Image` classes\n share the :map:`Image` implementation.\n\n Parameters\n ----------\n template_mask : :map:`BooleanImage` or 2D `bool ndarray`\n Mask for warping.\n sampled_pixel_values : ``(n_true_pixels_in_mask,)`` `ndarray`\n Sampled value to rebuild the masked image from.\n \"\"\"\n from menpo.image import MaskedImage\n warped_image = MaskedImage.init_blank(template_mask.shape,\n n_channels=self.n_channels,\n mask=template_mask)\n warped_image.from_vector_inplace(sampled_pixel_values.ravel())\n return warped_image\n\n def sample(self, points_to_sample, order=1, mode='constant', cval=0.0):\n r\"\"\"\n Sample this image at the given sub-pixel accurate points. The input\n PointCloud should have the same number of dimensions as the image e.g.\n a 2D PointCloud for a 2D multi-channel image. A numpy array will be\n returned the has the values for every given point across each channel\n of the image.\n\n Parameters\n ----------\n points_to_sample : :map:`PointCloud`\n Array of points to sample from the image. Should be\n `(n_points, n_dims)`\n order : `int`, optional\n The order of interpolation. The order has to be in the range [0,5].\n See warp_to_shape for more information.\n mode : ``{constant, nearest, reflect, wrap}``, optional\n Points outside the boundaries of the input are filled according\n to the given mode.\n cval : `float`, optional\n Used in conjunction with mode ``constant``, the value outside\n the image boundaries.\n\n Returns\n -------\n sampled_pixels : (`n_points`, `n_channels`) `ndarray`\n The interpolated values taken across every channel of the image.\n \"\"\"\n # The public interface is a PointCloud, but when this is used internally\n # a numpy array is passed. So let's just treat the PointCloud as a\n # 'special case' and not document the ndarray ability.\n if isinstance(points_to_sample, PointCloud):\n points_to_sample = points_to_sample.points\n return scipy_interpolation(self.pixels, points_to_sample,\n order=order, mode=mode, cval=cval)\n\n def warp_to_shape(self, template_shape, transform, warp_landmarks=False,\n order=1, mode='constant', cval=0.0, batch_size=None):\n \"\"\"\n Return a copy of this image warped into a different reference space.\n\n Parameters\n ----------\n template_shape : `tuple` or `ndarray`\n Defines the shape of the result, and what pixel indices should be\n sampled (all of them).\n transform : :map:`Transform`\n Transform **from the template_shape space back to this image**.\n Defines, for each index on template_shape, which pixel location\n should be sampled from on this image.\n warp_landmarks : `bool`, optional\n If ``True``, result will have the same landmark dictionary\n as self, but with each landmark updated to the warped position.\n order : `int`, optional\n The order of interpolation. The order has to be in the range [0,5]\n \n ========= ====================\n Order Interpolation\n ========= ====================\n 0 Nearest-neighbor\n 1 Bi-linear *(default)*\n 2 Bi-quadratic\n 3 Bi-cubic\n 4 Bi-quartic\n 5 Bi-quintic\n ========= ====================\n\n mode : ``{constant, nearest, reflect, wrap}``, optional\n Points outside the boundaries of the input are filled according\n to the given mode.\n cval : `float`, optional\n Used in conjunction with mode ``constant``, the value outside\n the image boundaries.\n batch_size : `int` or ``None``, optional\n This should only be considered for large images. Setting this\n value can cause warping to become much slower, particular for\n cached warps such as Piecewise Affine. This size indicates\n how many points in the image should be warped at a time, which\n keeps memory usage low. If ``None``, no batching is used and all\n points are warped at once.\n\n Returns\n -------\n warped_image : `type(self)`\n A copy of this image, warped.\n \"\"\"\n template_shape = np.array(template_shape, dtype=np.int)\n if (isinstance(transform, Affine) and order in range(4) and\n self.n_dims == 2):\n\n # we are going to be able to go fast.\n\n if isinstance(transform, Translation) and order == 0:\n # an integer translation (e.g. a crop) If this lies entirely\n # in the bounds then we can just do a copy. We need to match\n # the behavior of cython_interpolation exactly, which means\n # matching its rounding behavior too:\n t = transform.translation_component.copy()\n pos_t = t > 0.0\n t[pos_t] += 0.5\n t[~pos_t] -= 0.5\n min_ = t.astype(np.int)\n max_ = template_shape + min_\n if np.all(max_ <= np.array(self.shape)) and np.all(min_ >= 0):\n # we have a crop - slice the pixels.\n warped_pixels = self.pixels[:,\n int(min_[0]):int(max_[0]),\n int(min_[1]):int(max_[1])].copy()\n return self._build_warp_to_shape(warped_pixels,\n transform,\n warp_landmarks)\n # we couldn't do the crop, but skimage has an optimised Cython\n # interpolation for 2D affine warps - let's use that\n sampled = cython_interpolation(self.pixels, template_shape,\n transform, order=order,\n mode=mode, cval=cval)\n else:\n template_points = indices_for_image_of_shape(template_shape)\n points_to_sample = transform.apply(template_points,\n batch_size=batch_size)\n sampled = self.sample(points_to_sample,\n order=order, mode=mode, cval=cval)\n\n # set any nan values to 0\n sampled[np.isnan(sampled)] = 0\n # build a warped version of the image\n warped_pixels = sampled.reshape(\n (self.n_channels,) + tuple(template_shape))\n\n return self._build_warp_to_shape(warped_pixels, transform,\n warp_landmarks)\n\n def _build_warp_to_shape(self, warped_pixels, transform, warp_landmarks):\n # factored out common logic from the different paths we can take in\n # warp_to_shape. Rebuilds an image post-warp, adjusting landmarks\n # as necessary.\n warped_image = Image(warped_pixels, copy=False)\n\n # warp landmarks if requested.\n if warp_landmarks and self.has_landmarks:\n warped_image.landmarks = self.landmarks\n transform.pseudoinverse().apply_inplace(warped_image.landmarks)\n if hasattr(self, 'path'):\n warped_image.path = self.path\n return warped_image\n\n def rescale(self, scale, round='ceil', order=1):\n r\"\"\"\n Return a copy of this image, rescaled by a given factor.\n Landmarks are rescaled appropriately.\n\n Parameters\n ----------\n scale : `float` or `tuple` of `floats`\n The scale factor. If a tuple, the scale to apply to each dimension.\n If a single `float`, the scale will be applied uniformly across\n each dimension.\n round: ``{ceil, floor, round}``, optional\n Rounding function to be applied to floating point shapes.\n order : `int`, optional\n The order of interpolation. The order has to be in the range [0,5]\n\n ========= ====================\n Order Interpolation\n ========= ====================\n 0 Nearest-neighbor\n 1 Bi-linear *(default)*\n 2 Bi-quadratic\n 3 Bi-cubic\n 4 Bi-quartic\n 5 Bi-quintic\n ========= ====================\n\n Returns\n -------\n rescaled_image : ``type(self)``\n A copy of this image, rescaled.\n\n Raises\n ------\n ValueError:\n If less scales than dimensions are provided.\n If any scale is less than or equal to 0.\n \"\"\"\n # Pythonic way of converting to list if we are passed a single float\n try:\n if len(scale) < self.n_dims:\n raise ValueError(\n 'Must provide a scale per dimension.'\n '{} scales were provided, {} were expected.'.format(\n len(scale), self.n_dims\n )\n )\n except TypeError: # Thrown when len() is called on a float\n scale = [scale] * self.n_dims\n\n # Make sure we have a numpy array\n scale = np.asarray(scale)\n for s in scale:\n if s <= 0:\n raise ValueError('Scales must be positive floats.')\n\n transform = NonUniformScale(scale)\n # use the scale factor to make the template mask bigger\n # while respecting the users rounding preference.\n template_shape = round_image_shape(transform.apply(self.shape),\n round)\n # due to image indexing, we can't just apply the pseudoinverse\n # transform to achieve the scaling we want though!\n # Consider a 3x rescale on a 2x4 image. Looking at each dimension:\n # H 2 -> 6 so [0-1] -> [0-5] = 5/1 = 5x\n # W 4 -> 12 [0-3] -> [0-11] = 11/3 = 3.67x\n # => need to make the correct scale per dimension!\n shape = np.array(self.shape, dtype=np.float)\n # scale factors = max_index_after / current_max_index\n # (note that max_index = length - 1, as 0 based)\n scale_factors = (scale * shape - 1) / (shape - 1)\n inverse_transform = NonUniformScale(scale_factors).pseudoinverse()\n # for rescaling we enforce that mode is nearest to avoid num. errors\n return self.warp_to_shape(template_shape, inverse_transform,\n warp_landmarks=True, order=order,\n mode='nearest')\n\n def rescale_to_diagonal(self, diagonal, round='ceil'):\n r\"\"\"\n Return a copy of this image, rescaled so that the it's diagonal is a\n new size.\n\n Parameters\n ----------\n diagonal: `int`\n The diagonal size of the new image.\n round: ``{ceil, floor, round}``, optional\n Rounding function to be applied to floating point shapes.\n\n Returns\n -------\n rescaled_image : type(self)\n A copy of this image, rescaled.\n \"\"\"\n return self.rescale(diagonal / self.diagonal(), round=round)\n\n def rescale_to_reference_shape(self, reference_shape, group=None,\n label=None, round='ceil', order=1):\n r\"\"\"\n Deprecated: please use :meth:`rescale_to_pointcloud` instead.\n \"\"\"\n warn('rescale_to_reference_shape() is deprecated and will be removed '\n 'in the next major version of menpo. '\n 'Please use rescale_to_pointcloud() instead.',\n MenpoDeprecationWarning)\n return self.rescale_to_pointcloud(reference_shape, group=group,\n label=label, round=round, order=order)\n\n def rescale_to_pointcloud(self, pointcloud, group=None,\n label=None, round='ceil', order=1):\n r\"\"\"\n Return a copy of this image, rescaled so that the scale of a\n particular group of landmarks matches the scale of the passed\n reference pointcloud.\n\n Parameters\n ----------\n pointcloud: :map:`PointCloud`\n The reference pointcloud to which the landmarks specified by\n ``group`` will be scaled to match.\n group : `str`, optional\n The key of the landmark set that should be used. If ``None``,\n and if there is only one set of landmarks, this set will be used.\n label : `str`, optional\n The label of of the landmark manager that you wish to use. If\n ``None`` all landmarks in the group are used.\n round: ``{ceil, floor, round}``, optional\n Rounding function to be applied to floating point shapes.\n order : `int`, optional\n The order of interpolation. The order has to be in the range [0,5]\n\n ========= ====================\n Order Interpolation\n ========= ====================\n 0 Nearest-neighbor\n 1 Bi-linear *(default)*\n 2 Bi-quadratic\n 3 Bi-cubic\n 4 Bi-quartic\n 5 Bi-quintic\n ========= ====================\n\n Returns\n -------\n rescaled_image : ``type(self)``\n A copy of this image, rescaled.\n \"\"\"\n pc = self.landmarks[group][label]\n scale = AlignmentUniformScale(pc, pointcloud).as_vector().copy()\n return self.rescale(scale, round=round, order=order)\n\n def rescale_landmarks_to_diagonal_range(self, diagonal_range, group=None,\n label=None, round='ceil', order=1):\n r\"\"\"\n Return a copy of this image, rescaled so that the ``diagonal_range`` of\n the bounding box containing its landmarks matches the specified\n ``diagonal_range`` range.\n\n Parameters\n ----------\n diagonal_range: ``(n_dims,)`` `ndarray`\n The diagonal_range range that we want the landmarks of the returned\n image to have.\n group : `str`, optional\n The key of the landmark set that should be used. If ``None``\n and if there is only one set of landmarks, this set will be used.\n label: `str`, optional\n The label of of the landmark manager that you wish to use. If\n ``None`` all landmarks in the group are used.\n round : ``{ceil, floor, round}``, optional\n Rounding function to be applied to floating point shapes.\n order : `int`, optional\n The order of interpolation. The order has to be in the range [0,5]\n\n ========= =====================\n Order Interpolation\n ========= =====================\n 0 Nearest-neighbor\n 1 Bi-linear *(default)*\n 2 Bi-quadratic\n 3 Bi-cubic\n 4 Bi-quartic\n 5 Bi-quintic\n ========= =====================\n\n Returns\n -------\n rescaled_image : ``type(self)``\n A copy of this image, rescaled.\n \"\"\"\n x, y = self.landmarks[group][label].range()\n scale = diagonal_range / np.sqrt(x ** 2 + y ** 2)\n return self.rescale(scale, round=round, order=order)\n\n def resize(self, shape, order=1):\n r\"\"\"\n Return a copy of this image, resized to a particular shape.\n All image information (landmarks, and mask in the case of\n :map:`MaskedImage`) is resized appropriately.\n\n Parameters\n ----------\n shape : `tuple`\n The new shape to resize to.\n order : `int`, optional\n The order of interpolation. The order has to be in the range [0,5]\n\n ========= =====================\n Order Interpolation\n ========= =====================\n 0 Nearest-neighbor\n 1 Bi-linear *(default)*\n 2 Bi-quadratic\n 3 Bi-cubic\n 4 Bi-quartic\n 5 Bi-quintic\n ========= =====================\n\n Returns\n -------\n resized_image : ``type(self)``\n A copy of this image, resized.\n\n Raises\n ------\n ValueError:\n If the number of dimensions of the new shape does not match\n the number of dimensions of the image.\n \"\"\"\n shape = np.asarray(shape, dtype=np.float)\n if len(shape) != self.n_dims:\n raise ValueError(\n 'Dimensions must match.'\n '{} dimensions provided, {} were expected.'.format(\n shape.shape, self.n_dims))\n scales = shape / self.shape\n # Have to round the shape when scaling to deal with floating point\n # errors. For example, if we want (250, 250), we need to ensure that\n # we get (250, 250) even if the number we obtain is 250 to some\n # floating point inaccuracy.\n return self.rescale(scales, round='round', order=order)\n\n def zoom(self, scale, cval=0.0):\n r\"\"\"\n Zoom this image about the centre point. ``scale`` values greater\n than 1.0 denote zooming **in** to the image and values less than\n 1.0 denote zooming **out** of the image. The size of the image will not\n change, if you wish to scale an image, please see :meth:`rescale`.\n\n Parameters\n ----------\n scale : `float`\n ``scale > 1.0`` denotes zooming in. Thus the image will appear\n larger and areas at the edge of the zoom will be 'cropped' out.\n ``scale < 1.0`` denotes zooming out. The image will be padded\n by the value of ``cval``.\n cval : ``float``, optional\n The value to be set outside the rotated image boundaries.\n \"\"\"\n t = scale_about_centre(self, 1.0 / scale)\n return self.warp_to_shape(self.shape, t, cval=cval)\n\n def rotate_ccw_about_centre(self, theta, degrees=True, cval=0.0):\n r\"\"\"\n Return a rotation of this image clockwise about its centre.\n\n Parameters\n ----------\n theta : `float`\n The angle of rotation about the origin.\n degrees : `bool`, optional\n If ``True``, `theta` is interpreted as a degree. If ``False``,\n ``theta`` is interpreted as radians.\n cval : ``float``, optional\n The value to be set outside the rotated image boundaries.\n\n Returns\n -------\n rotated_image : ``type(self)``\n The rotated image.\n \"\"\"\n if self.n_dims != 2:\n raise ValueError('Image rotation is presently only supported on '\n '2D images')\n\n r_about_centre = rotate_ccw_about_centre(self, theta, degrees=degrees)\n return self.warp_to_shape(self.shape, r_about_centre.pseudoinverse(),\n warp_landmarks=True, cval=cval)\n\n def pyramid(self, n_levels=3, downscale=2):\n r\"\"\"\n Return a rescaled pyramid of this image. The first image of the\n pyramid will be the original, unmodified, image, and counts as level 1.\n\n Parameters\n ----------\n n_levels : `int`, optional\n Total number of levels in the pyramid, including the original\n unmodified image\n downscale : `float`, optional\n Downscale factor.\n\n Yields\n ------\n image_pyramid: `generator`\n Generator yielding pyramid layers as :map:`Image` objects.\n \"\"\"\n image = self\n yield image\n for _ in range(n_levels - 1):\n image = image.rescale(1.0 / downscale)\n yield image\n\n def gaussian_pyramid(self, n_levels=3, downscale=2, sigma=None):\n r\"\"\"\n Return the gaussian pyramid of this image. The first image of the\n pyramid will be the original, unmodified, image, and counts as level 1.\n\n Parameters\n ----------\n n_levels : `int`, optional\n Total number of levels in the pyramid, including the original\n unmodified image\n downscale : `float`, optional\n Downscale factor.\n sigma : `float`, optional\n Sigma for gaussian filter. Default is ``downscale / 3.`` which\n corresponds to a filter mask twice the size of the scale factor\n that covers more than 99% of the gaussian distribution.\n\n Yields\n ------\n image_pyramid: `generator`\n Generator yielding pyramid layers as :map:`Image` objects.\n \"\"\"\n from menpo.feature import gaussian_filter\n if sigma is None:\n sigma = downscale / 3.\n image = self\n yield image\n for level in range(n_levels - 1):\n image = gaussian_filter(image, sigma).rescale(1.0 / downscale)\n yield image\n\n def as_greyscale(self, mode='luminosity', channel=None):\n r\"\"\"\n Returns a greyscale version of the image. If the image does *not*\n represent a 2D RGB image, then the ``luminosity`` mode will fail.\n\n Parameters\n ----------\n mode : ``{average, luminosity, channel}``, optional\n ============== =====================================================\n mode Greyscale Algorithm\n ============== =====================================================\n average Equal average of all channels\n luminosity Calculates the luminance using the CCIR 601 formula:\n | .. math:: Y' = 0.2989 R' + 0.5870 G' + 0.1140 B'\n channel A specific channel is chosen as the intensity value.\n ============== =====================================================\n\n channel: `int`, optional\n The channel to be taken. Only used if mode is ``channel``.\n\n Returns\n -------\n greyscale_image : :map:`MaskedImage`\n A copy of this image in greyscale.\n \"\"\"\n greyscale = self.copy()\n if mode == 'luminosity':\n if self.n_dims != 2:\n raise ValueError(\"The 'luminosity' mode only works on 2D RGB\"\n \"images. {} dimensions found, \"\n \"2 expected.\".format(self.n_dims))\n elif self.n_channels != 3:\n raise ValueError(\"The 'luminosity' mode only works on RGB\"\n \"images. {} channels found, \"\n \"3 expected.\".format(self.n_channels))\n # Only compute the coefficients once.\n global _greyscale_luminosity_coef\n if _greyscale_luminosity_coef is None:\n _greyscale_luminosity_coef = np.linalg.inv(\n np.array([[1.0, 0.956, 0.621],\n [1.0, -0.272, -0.647],\n [1.0, -1.106, 1.703]]))[0, :]\n pixels = np.einsum('i,ikl->kl', _greyscale_luminosity_coef,\n greyscale.pixels)\n elif mode == 'average':\n pixels = np.mean(greyscale.pixels, axis=0)\n elif mode == 'channel':\n if channel is None:\n raise ValueError(\"For the 'channel' mode you have to provide\"\n \" a channel index\")\n pixels = greyscale.pixels[channel, ...]\n else:\n raise ValueError(\"Unknown mode {} - expected 'luminosity', \"\n \"'average' or 'channel'.\".format(mode))\n\n greyscale.pixels = pixels[None, ...]\n return greyscale\n\n def as_PILImage(self):\n r\"\"\"\n Return a PIL copy of the image. Depending on the image data type,\n different operations are performed:\n\n ========= ===========================================\n dtype Processing\n ========= ===========================================\n uint8 No processing, directly converted to PIL\n bool Scale by 255, convert to uint8\n float32 Scale by 255, convert to uint8\n float64 Scale by 255, convert to uint8\n OTHER Raise ValueError\n ========= ===========================================\n\n Image must only have 1 or 3 channels and be 2 dimensional.\n Non `uint8` images must be in the rage ``[0, 1]`` to be converted.\n\n Returns\n -------\n pil_image : `PILImage`\n PIL copy of image\n\n Raises\n ------\n ValueError\n If image is not 2D and 1 channel or 3 channels.\n ValueError\n If pixels data type is not `float32`, `float64`, `bool` or `uint8`\n ValueError\n If pixels data type is `float32` or `float64` and the pixel\n range is outside of ``[0, 1]``\n \"\"\"\n if self.n_dims != 2 or self.n_channels not in [1, 3]:\n raise ValueError(\n 'Can only convert greyscale or RGB 2D images. '\n 'Received a {} channel {}D image.'.format(self.n_channels,\n self.n_dims))\n\n # Slice off the channel for greyscale images\n if self.n_channels == 1:\n pixels = self.pixels[0]\n else:\n pixels = channels_to_back(self.pixels)\n if pixels.dtype in [np.float64, np.float32, np.bool]: # Type check\n if np.any((self.pixels < 0) | (self.pixels > 1)): # Range check\n raise ValueError('Pixel values are outside the range '\n '[0, 1] - ({}, {}).'.format(self.pixels.min(),\n self.pixels.max()))\n else:\n pixels = (pixels * 255).astype(np.uint8)\n if pixels.dtype != np.uint8:\n raise ValueError('Unexpected data type - {}.'.format(pixels.dtype))\n return PILImage.fromarray(pixels)\n\n def rolled_channels(self):\n r\"\"\"\n Returns the pixels matrix, with the channels rolled to the back axis.\n This may be required for interacting with external code bases that\n require images to have channels as the last axis, rather than the\n menpo convention of channels as the first axis.\n\n Returns\n -------\n rolled_channels : `ndarray`\n Pixels with channels as the back (last) axis.\n \"\"\"\n return channels_to_back(self)\n\n def __str__(self):\n return ('{} {}D Image with {} channel{}'.format(\n self._str_shape(), self.n_dims, self.n_channels,\n 's' * (self.n_channels > 1)))\n\n @property\n def has_landmarks_outside_bounds(self):\n \"\"\"\n Indicates whether there are landmarks located outside the image bounds.\n\n :type: `bool`\n \"\"\"\n if self.landmarks.has_landmarks:\n for l_group in self.landmarks:\n pc = self.landmarks[l_group].lms.points\n if np.any(np.logical_or(self.shape - pc < 1, pc < 0)):\n return True\n return False\n\n def constrain_landmarks_to_bounds(self):\n r\"\"\"\n Move landmarks that are located outside the image bounds on the bounds.\n \"\"\"\n if self.has_landmarks_outside_bounds:\n for l_group in self.landmarks:\n l = self.landmarks[l_group]\n for k in range(l.lms.points.shape[1]):\n tmp = l.lms.points[:, k]\n tmp[tmp < 0] = 0\n tmp[tmp > self.shape[k] - 1] = self.shape[k] - 1\n l.lms.points[:, k] = tmp\n self.landmarks[l_group] = l\n\n def normalize_std_inplace(self, mode='all', **kwargs):\n r\"\"\"\n Normalizes this image such that its pixel values have zero mean and\n unit variance.\n\n Parameters\n ----------\n mode : ``{all, per_channel}``, optional\n If ``all``, the normalization is over all channels. If\n ``per_channel``, each channel individually is mean centred and\n normalized in variance.\n \"\"\"\n self._normalize_inplace(np.std, mode=mode)\n\n def normalize_norm_inplace(self, mode='all', **kwargs):\n r\"\"\"\n Normalizes this image such that its pixel values have zero mean and\n its norm equals 1.\n\n Parameters\n ----------\n mode : ``{all, per_channel}``, optional\n If ``all``, the normalization is over all channels. If\n ``per_channel``, each channel individually is mean centred and\n normalized in variance.\n \"\"\"\n def scale_func(pixels, axis=None):\n return np.linalg.norm(pixels, axis=axis, **kwargs)\n\n self._normalize_inplace(scale_func, mode=mode)\n\n def _normalize_inplace(self, scale_func, mode='all'):\n pixels = self.as_vector(keep_channels=True)\n if mode == 'all':\n centered_pixels = pixels - np.mean(pixels)\n scale_factor = scale_func(centered_pixels)\n\n elif mode == 'per_channel':\n centered_pixels = pixels - np.mean(pixels, axis=1)[..., None]\n scale_factor = scale_func(centered_pixels, axis=1)[..., None]\n else:\n raise ValueError(\"mode has to be 'all' or 'per_channel' - '{}' \"\n \"was provided instead\".format(mode))\n\n if np.any(scale_factor == 0):\n raise ValueError(\"Image has 0 variance - can't be \"\n \"normalized\")\n else:\n self.from_vector_inplace(centered_pixels / scale_factor)\n\n def rescale_pixels(self, minimum, maximum, per_channel=True):\n r\"\"\"A copy of this image with pixels linearly rescaled to fit a range.\n\n Note that the only pixels that will considered and rescaled are those\n that feature in the vectorized form of this image. If you want to use\n this routine on all the pixels in a :map:`MaskedImage`, consider\n using `as_unmasked()` prior to this call.\n\n Parameters\n ----------\n minimum: `float`\n The minimal value of the rescaled pixels\n maximum: `float`\n The maximal value of the rescaled pixels\n per_channel: `boolean`, optional\n If ``True``, each channel will be rescaled independently. If\n ``False``, the scaling will be over all channels.\n\n Returns\n -------\n rescaled_image: ``type(self)``\n A copy of this image with pixels linearly rescaled to fit in the\n range provided.\n \"\"\"\n v = self.as_vector(keep_channels=True).T\n if per_channel:\n min_, max_ = v.min(axis=0), v.max(axis=0)\n else:\n min_, max_ = v.min(), v.max()\n sf = ((maximum - minimum) * 1.0) / (max_ - min_)\n v_new = ((v - min_) * sf) + minimum\n return self.from_vector(v_new.T.ravel())\n\n\ndef round_image_shape(shape, round):\n if round not in ['ceil', 'round', 'floor']:\n raise ValueError('round must be either ceil, round or floor')\n # Ensure that the '+' operator means concatenate tuples\n return tuple(getattr(np, round)(shape).astype(np.int))\n"},"domain":{"kind":"string","value":"codeparrot/github-code-clean"}}},{"rowIdx":227193,"cells":{"text":{"kind":"string","value":"# -*- coding: utf-8 -*-\nimport unittest\nimport pickle\nimport cPickle\nimport StringIO\nimport cStringIO\nimport pickletools\nimport copy_reg\nimport sys\n\nfrom test import test_support as support\nfrom test.test_support import TestFailed, verbose, have_unicode, TESTFN\ntry:\n from test.test_support import _2G, _1M, precisionbigmemtest\nexcept ImportError:\n # this import might fail when run on older Python versions by test_xpickle\n _2G = _1M = 0\n def precisionbigmemtest(*args, **kwargs):\n return lambda self: None\n\n# Tests that try a number of pickle protocols should have a\n# for proto in protocols:\n# kind of outer loop.\nassert pickle.HIGHEST_PROTOCOL == cPickle.HIGHEST_PROTOCOL == 2\nprotocols = range(pickle.HIGHEST_PROTOCOL + 1)\n\n# Copy of test.test_support.run_with_locale. This is needed to support Python\n# 2.4, which didn't include it. This is all to support test_xpickle, which\n# bounces pickled objects through older Python versions to test backwards\n# compatibility.\ndef run_with_locale(catstr, *locales):\n def decorator(func):\n def inner(*args, **kwds):\n try:\n import locale\n category = getattr(locale, catstr)\n orig_locale = locale.setlocale(category)\n except AttributeError:\n # if the test author gives us an invalid category string\n raise\n except:\n # cannot retrieve original locale, so do nothing\n locale = orig_locale = None\n else:\n for loc in locales:\n try:\n locale.setlocale(category, loc)\n break\n except:\n pass\n\n # now run the function, resetting the locale on exceptions\n try:\n return func(*args, **kwds)\n finally:\n if locale and orig_locale:\n locale.setlocale(category, orig_locale)\n inner.func_name = func.func_name\n inner.__doc__ = func.__doc__\n return inner\n return decorator\n\ndef no_tracing(func):\n \"\"\"Decorator to temporarily turn off tracing for the duration of a test.\"\"\"\n if not hasattr(sys, 'gettrace'):\n return func\n else:\n def wrapper(*args, **kwargs):\n original_trace = sys.gettrace()\n try:\n sys.settrace(None)\n return func(*args, **kwargs)\n finally:\n sys.settrace(original_trace)\n wrapper.__name__ = func.__name__\n return wrapper\n\n\n# Return True if opcode code appears in the pickle, else False.\ndef opcode_in_pickle(code, pickle):\n for op, dummy, dummy in pickletools.genops(pickle):\n if op.code == code:\n return True\n return False\n\n# Return the number of times opcode code appears in pickle.\ndef count_opcode(code, pickle):\n n = 0\n for op, dummy, dummy in pickletools.genops(pickle):\n if op.code == code:\n n += 1\n return n\n\nclass UnseekableIO(StringIO.StringIO):\n def peek(self, *args):\n raise NotImplementedError\n\n def seek(self, *args):\n raise NotImplementedError\n\n def tell(self):\n raise NotImplementedError\n\n# We can't very well test the extension registry without putting known stuff\n# in it, but we have to be careful to restore its original state. Code\n# should do this:\n#\n# e = ExtensionSaver(extension_code)\n# try:\n# fiddle w/ the extension registry's stuff for extension_code\n# finally:\n# e.restore()\n\nclass ExtensionSaver:\n # Remember current registration for code (if any), and remove it (if\n # there is one).\n def __init__(self, code):\n self.code = code\n if code in copy_reg._inverted_registry:\n self.pair = copy_reg._inverted_registry[code]\n copy_reg.remove_extension(self.pair[0], self.pair[1], code)\n else:\n self.pair = None\n\n # Restore previous registration for code.\n def restore(self):\n code = self.code\n curpair = copy_reg._inverted_registry.get(code)\n if curpair is not None:\n copy_reg.remove_extension(curpair[0], curpair[1], code)\n pair = self.pair\n if pair is not None:\n copy_reg.add_extension(pair[0], pair[1], code)\n\nclass C:\n def __cmp__(self, other):\n return cmp(self.__dict__, other.__dict__)\n\nclass D(C):\n def __init__(self, arg):\n pass\n\nclass E(C):\n def __getinitargs__(self):\n return ()\n\nclass H(object):\n pass\n\n# Hashable mutable key\nclass K(object):\n def __init__(self, value):\n self.value = value\n\n def __reduce__(self):\n # Shouldn't support the recursion itself\n return K, (self.value,)\n\nimport __main__\n__main__.C = C\nC.__module__ = \"__main__\"\n__main__.D = D\nD.__module__ = \"__main__\"\n__main__.E = E\nE.__module__ = \"__main__\"\n__main__.H = H\nH.__module__ = \"__main__\"\n__main__.K = K\nK.__module__ = \"__main__\"\n\nclass myint(int):\n def __init__(self, x):\n self.str = str(x)\n\nclass initarg(C):\n\n def __init__(self, a, b):\n self.a = a\n self.b = b\n\n def __getinitargs__(self):\n return self.a, self.b\n\nclass metaclass(type):\n pass\n\nclass use_metaclass(object):\n __metaclass__ = metaclass\n\nclass pickling_metaclass(type):\n def __eq__(self, other):\n return (type(self) == type(other) and\n self.reduce_args == other.reduce_args)\n\n def __reduce__(self):\n return (create_dynamic_class, self.reduce_args)\n\n __hash__ = None\n\ndef create_dynamic_class(name, bases):\n result = pickling_metaclass(name, bases, dict())\n result.reduce_args = (name, bases)\n return result\n\n# DATA0 .. DATA2 are the pickles we expect under the various protocols, for\n# the object returned by create_data().\n\n# break into multiple strings to avoid confusing font-lock-mode\nDATA0 = \"\"\"(lp1\nI0\naL1L\naF2\nac__builtin__\ncomplex\np2\n\"\"\" + \\\n\"\"\"(F3\nF0\ntRp3\naI1\naI-1\naI255\naI-255\naI-256\naI65535\naI-65535\naI-65536\naI2147483647\naI-2147483647\naI-2147483648\na\"\"\" + \\\n\"\"\"(S'abc'\np4\ng4\n\"\"\" + \\\n\"\"\"(i__main__\nC\np5\n\"\"\" + \\\n\"\"\"(dp6\nS'foo'\np7\nI1\nsS'bar'\np8\nI2\nsbg5\ntp9\nag9\naI5\na.\n\"\"\"\n\n# Disassembly of DATA0.\nDATA0_DIS = \"\"\"\\\n 0: ( MARK\n 1: l LIST (MARK at 0)\n 2: p PUT 1\n 5: I INT 0\n 8: a APPEND\n 9: L LONG 1L\n 13: a APPEND\n 14: F FLOAT 2.0\n 17: a APPEND\n 18: c GLOBAL '__builtin__ complex'\n 39: p PUT 2\n 42: ( MARK\n 43: F FLOAT 3.0\n 46: F FLOAT 0.0\n 49: t TUPLE (MARK at 42)\n 50: R REDUCE\n 51: p PUT 3\n 54: a APPEND\n 55: I INT 1\n 58: a APPEND\n 59: I INT -1\n 63: a APPEND\n 64: I INT 255\n 69: a APPEND\n 70: I INT -255\n 76: a APPEND\n 77: I INT -256\n 83: a APPEND\n 84: I INT 65535\n 91: a APPEND\n 92: I INT -65535\n 100: a APPEND\n 101: I INT -65536\n 109: a APPEND\n 110: I INT 2147483647\n 122: a APPEND\n 123: I INT -2147483647\n 136: a APPEND\n 137: I INT -2147483648\n 150: a APPEND\n 151: ( MARK\n 152: S STRING 'abc'\n 159: p PUT 4\n 162: g GET 4\n 165: ( MARK\n 166: i INST '__main__ C' (MARK at 165)\n 178: p PUT 5\n 181: ( MARK\n 182: d DICT (MARK at 181)\n 183: p PUT 6\n 186: S STRING 'foo'\n 193: p PUT 7\n 196: I INT 1\n 199: s SETITEM\n 200: S STRING 'bar'\n 207: p PUT 8\n 210: I INT 2\n 213: s SETITEM\n 214: b BUILD\n 215: g GET 5\n 218: t TUPLE (MARK at 151)\n 219: p PUT 9\n 222: a APPEND\n 223: g GET 9\n 226: a APPEND\n 227: I INT 5\n 230: a APPEND\n 231: . STOP\nhighest protocol among opcodes = 0\n\"\"\"\n\nDATA1 = (']q\\x01(K\\x00L1L\\nG@\\x00\\x00\\x00\\x00\\x00\\x00\\x00'\n 'c__builtin__\\ncomplex\\nq\\x02(G@\\x08\\x00\\x00\\x00\\x00\\x00'\n '\\x00G\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00tRq\\x03K\\x01J\\xff\\xff'\n '\\xff\\xffK\\xffJ\\x01\\xff\\xff\\xffJ\\x00\\xff\\xff\\xffM\\xff\\xff'\n 'J\\x01\\x00\\xff\\xffJ\\x00\\x00\\xff\\xffJ\\xff\\xff\\xff\\x7fJ\\x01\\x00'\n '\\x00\\x80J\\x00\\x00\\x00\\x80(U\\x03abcq\\x04h\\x04(c__main__\\n'\n 'C\\nq\\x05oq\\x06}q\\x07(U\\x03fooq\\x08K\\x01U\\x03barq\\tK\\x02ubh'\n '\\x06tq\\nh\\nK\\x05e.'\n )\n\n# Disassembly of DATA1.\nDATA1_DIS = \"\"\"\\\n 0: ] EMPTY_LIST\n 1: q BINPUT 1\n 3: ( MARK\n 4: K BININT1 0\n 6: L LONG 1L\n 10: G BINFLOAT 2.0\n 19: c GLOBAL '__builtin__ complex'\n 40: q BINPUT 2\n 42: ( MARK\n 43: G BINFLOAT 3.0\n 52: G BINFLOAT 0.0\n 61: t TUPLE (MARK at 42)\n 62: R REDUCE\n 63: q BINPUT 3\n 65: K BININT1 1\n 67: J BININT -1\n 72: K BININT1 255\n 74: J BININT -255\n 79: J BININT -256\n 84: M BININT2 65535\n 87: J BININT -65535\n 92: J BININT -65536\n 97: J BININT 2147483647\n 102: J BININT -2147483647\n 107: J BININT -2147483648\n 112: ( MARK\n 113: U SHORT_BINSTRING 'abc'\n 118: q BINPUT 4\n 120: h BINGET 4\n 122: ( MARK\n 123: c GLOBAL '__main__ C'\n 135: q BINPUT 5\n 137: o OBJ (MARK at 122)\n 138: q BINPUT 6\n 140: } EMPTY_DICT\n 141: q BINPUT 7\n 143: ( MARK\n 144: U SHORT_BINSTRING 'foo'\n 149: q BINPUT 8\n 151: K BININT1 1\n 153: U SHORT_BINSTRING 'bar'\n 158: q BINPUT 9\n 160: K BININT1 2\n 162: u SETITEMS (MARK at 143)\n 163: b BUILD\n 164: h BINGET 6\n 166: t TUPLE (MARK at 112)\n 167: q BINPUT 10\n 169: h BINGET 10\n 171: K BININT1 5\n 173: e APPENDS (MARK at 3)\n 174: . STOP\nhighest protocol among opcodes = 1\n\"\"\"\n\nDATA2 = ('\\x80\\x02]q\\x01(K\\x00\\x8a\\x01\\x01G@\\x00\\x00\\x00\\x00\\x00\\x00\\x00'\n 'c__builtin__\\ncomplex\\nq\\x02G@\\x08\\x00\\x00\\x00\\x00\\x00\\x00G\\x00'\n '\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x86Rq\\x03K\\x01J\\xff\\xff\\xff\\xffK'\n '\\xffJ\\x01\\xff\\xff\\xffJ\\x00\\xff\\xff\\xffM\\xff\\xffJ\\x01\\x00\\xff\\xff'\n 'J\\x00\\x00\\xff\\xffJ\\xff\\xff\\xff\\x7fJ\\x01\\x00\\x00\\x80J\\x00\\x00\\x00'\n '\\x80(U\\x03abcq\\x04h\\x04(c__main__\\nC\\nq\\x05oq\\x06}q\\x07(U\\x03foo'\n 'q\\x08K\\x01U\\x03barq\\tK\\x02ubh\\x06tq\\nh\\nK\\x05e.')\n\n# Disassembly of DATA2.\nDATA2_DIS = \"\"\"\\\n 0: \\x80 PROTO 2\n 2: ] EMPTY_LIST\n 3: q BINPUT 1\n 5: ( MARK\n 6: K BININT1 0\n 8: \\x8a LONG1 1L\n 11: G BINFLOAT 2.0\n 20: c GLOBAL '__builtin__ complex'\n 41: q BINPUT 2\n 43: G BINFLOAT 3.0\n 52: G BINFLOAT 0.0\n 61: \\x86 TUPLE2\n 62: R REDUCE\n 63: q BINPUT 3\n 65: K BININT1 1\n 67: J BININT -1\n 72: K BININT1 255\n 74: J BININT -255\n 79: J BININT -256\n 84: M BININT2 65535\n 87: J BININT -65535\n 92: J BININT -65536\n 97: J BININT 2147483647\n 102: J BININT -2147483647\n 107: J BININT -2147483648\n 112: ( MARK\n 113: U SHORT_BINSTRING 'abc'\n 118: q BINPUT 4\n 120: h BINGET 4\n 122: ( MARK\n 123: c GLOBAL '__main__ C'\n 135: q BINPUT 5\n 137: o OBJ (MARK at 122)\n 138: q BINPUT 6\n 140: } EMPTY_DICT\n 141: q BINPUT 7\n 143: ( MARK\n 144: U SHORT_BINSTRING 'foo'\n 149: q BINPUT 8\n 151: K BININT1 1\n 153: U SHORT_BINSTRING 'bar'\n 158: q BINPUT 9\n 160: K BININT1 2\n 162: u SETITEMS (MARK at 143)\n 163: b BUILD\n 164: h BINGET 6\n 166: t TUPLE (MARK at 112)\n 167: q BINPUT 10\n 169: h BINGET 10\n 171: K BININT1 5\n 173: e APPENDS (MARK at 5)\n 174: . STOP\nhighest protocol among opcodes = 2\n\"\"\"\n\ndef create_data():\n c = C()\n c.foo = 1\n c.bar = 2\n x = [0, 1L, 2.0, 3.0+0j]\n # Append some integer test cases at cPickle.c's internal size\n # cutoffs.\n uint1max = 0xff\n uint2max = 0xffff\n int4max = 0x7fffffff\n x.extend([1, -1,\n uint1max, -uint1max, -uint1max-1,\n uint2max, -uint2max, -uint2max-1,\n int4max, -int4max, -int4max-1])\n y = ('abc', 'abc', c, c)\n x.append(y)\n x.append(y)\n x.append(5)\n return x\n\n\nclass AbstractUnpickleTests(unittest.TestCase):\n # Subclass must define self.loads, self.error.\n\n _testdata = create_data()\n\n def assert_is_copy(self, obj, objcopy, msg=None):\n \"\"\"Utility method to verify if two objects are copies of each others.\n \"\"\"\n if msg is None:\n msg = \"{!r} is not a copy of {!r}\".format(obj, objcopy)\n self.assertEqual(obj, objcopy, msg=msg)\n self.assertIs(type(obj), type(objcopy), msg=msg)\n if hasattr(obj, '__dict__'):\n self.assertDictEqual(obj.__dict__, objcopy.__dict__, msg=msg)\n self.assertIsNot(obj.__dict__, objcopy.__dict__, msg=msg)\n if hasattr(obj, '__slots__'):\n self.assertListEqual(obj.__slots__, objcopy.__slots__, msg=msg)\n for slot in obj.__slots__:\n self.assertEqual(\n hasattr(obj, slot), hasattr(objcopy, slot), msg=msg)\n self.assertEqual(getattr(obj, slot, None),\n getattr(objcopy, slot, None), msg=msg)\n\n def check_unpickling_error(self, errors, data):\n try:\n try:\n self.loads(data)\n except:\n if support.verbose > 1:\n exc_type, exc, tb = sys.exc_info()\n print '%-32r - %s: %s' % (data, exc_type.__name__, exc)\n raise\n except errors:\n pass\n else:\n try:\n exc_name = errors.__name__\n except AttributeError:\n exc_name = str(errors)\n raise self.failureException('%s not raised' % exc_name)\n\n def test_load_from_canned_string(self):\n expected = self._testdata\n for canned in DATA0, DATA1, DATA2:\n got = self.loads(canned)\n self.assert_is_copy(expected, got)\n\n def test_garyp(self):\n self.check_unpickling_error(self.error, 'garyp')\n\n def test_maxint64(self):\n maxint64 = (1L << 63) - 1\n data = 'I' + str(maxint64) + '\\n.'\n got = self.loads(data)\n self.assertEqual(got, maxint64)\n\n # Try too with a bogus literal.\n data = 'I' + str(maxint64) + 'JUNK\\n.'\n self.check_unpickling_error(ValueError, data)\n\n def test_insecure_strings(self):\n insecure = [\"abc\", \"2 + 2\", # not quoted\n #\"'abc' + 'def'\", # not a single quoted string\n \"'abc\", # quote is not closed\n \"'abc\\\"\", # open quote and close quote don't match\n \"'abc' ?\", # junk after close quote\n \"'\\\\'\", # trailing backslash\n # issue #17710\n \"'\", '\"',\n \"' \", '\" ',\n '\\'\"', '\"\\'',\n \" ''\", ' \"\"',\n ' ',\n # some tests of the quoting rules\n #\"'abc\\\"\\''\",\n #\"'\\\\\\\\a\\'\\'\\'\\\\\\'\\\\\\\\\\''\",\n ]\n for s in insecure:\n buf = \"S\" + s + \"\\n.\"\n self.check_unpickling_error(ValueError, buf)\n\n def test_correctly_quoted_string(self):\n goodpickles = [(\"S''\\n.\", ''),\n ('S\"\"\\n.', ''),\n ('S\"\\\\n\"\\n.', '\\n'),\n (\"S'\\\\n'\\n.\", '\\n')]\n for p, expected in goodpickles:\n self.assertEqual(self.loads(p), expected)\n\n def test_load_classic_instance(self):\n # See issue5180. Test loading 2.x pickles that\n # contain an instance of old style class.\n for X, args in [(C, ()), (D, ('x',)), (E, ())]:\n xname = X.__name__.encode('ascii')\n # Protocol 0 (text mode pickle):\n \"\"\"\n 0: ( MARK\n 1: i INST '__main__ X' (MARK at 0)\n 13: p PUT 0\n 16: ( MARK\n 17: d DICT (MARK at 16)\n 18: p PUT 1\n 21: b BUILD\n 22: . STOP\n \"\"\"\n pickle0 = (\"(i__main__\\n\"\n \"X\\n\"\n \"p0\\n\"\n \"(dp1\\nb.\").replace('X', xname)\n self.assert_is_copy(X(*args), self.loads(pickle0))\n\n # Protocol 1 (binary mode pickle)\n \"\"\"\n 0: ( MARK\n 1: c GLOBAL '__main__ X'\n 13: q BINPUT 0\n 15: o OBJ (MARK at 0)\n 16: q BINPUT 1\n 18: } EMPTY_DICT\n 19: q BINPUT 2\n 21: b BUILD\n 22: . STOP\n \"\"\"\n pickle1 = ('(c__main__\\n'\n 'X\\n'\n 'q\\x00oq\\x01}q\\x02b.').replace('X', xname)\n self.assert_is_copy(X(*args), self.loads(pickle1))\n\n # Protocol 2 (pickle2 = '\\x80\\x02' + pickle1)\n \"\"\"\n 0: \\x80 PROTO 2\n 2: ( MARK\n 3: c GLOBAL '__main__ X'\n 15: q BINPUT 0\n 17: o OBJ (MARK at 2)\n 18: q BINPUT 1\n 20: } EMPTY_DICT\n 21: q BINPUT 2\n 23: b BUILD\n 24: . STOP\n \"\"\"\n pickle2 = ('\\x80\\x02(c__main__\\n'\n 'X\\n'\n 'q\\x00oq\\x01}q\\x02b.').replace('X', xname)\n self.assert_is_copy(X(*args), self.loads(pickle2))\n\n def test_load_str(self):\n # From Python 2: pickle.dumps('a\\x00\\xa0', protocol=0)\n self.assertEqual(self.loads(\"S'a\\\\x00\\\\xa0'\\n.\"), 'a\\x00\\xa0')\n # From Python 2: pickle.dumps('a\\x00\\xa0', protocol=1)\n self.assertEqual(self.loads('U\\x03a\\x00\\xa0.'), 'a\\x00\\xa0')\n # From Python 2: pickle.dumps('a\\x00\\xa0', protocol=2)\n self.assertEqual(self.loads('\\x80\\x02U\\x03a\\x00\\xa0.'), 'a\\x00\\xa0')\n\n def test_load_unicode(self):\n # From Python 2: pickle.dumps(u'π', protocol=0)\n self.assertEqual(self.loads('V\\\\u03c0\\n.'), u'π')\n # From Python 2: pickle.dumps(u'π', protocol=1)\n self.assertEqual(self.loads('X\\x02\\x00\\x00\\x00\\xcf\\x80.'), u'π')\n # From Python 2: pickle.dumps(u'π', protocol=2)\n self.assertEqual(self.loads('\\x80\\x02X\\x02\\x00\\x00\\x00\\xcf\\x80.'), u'π')\n\n def test_constants(self):\n self.assertIsNone(self.loads('N.'))\n self.assertIs(self.loads('\\x88.'), True)\n self.assertIs(self.loads('\\x89.'), False)\n self.assertIs(self.loads('I01\\n.'), True)\n self.assertIs(self.loads('I00\\n.'), False)\n\n def test_misc_get(self):\n self.check_unpickling_error(self.error, 'g0\\np0\\n')\n self.check_unpickling_error(self.error, 'h\\x00q\\x00')\n\n def test_get(self):\n pickled = '((lp100000\\ng100000\\nt.'\n unpickled = self.loads(pickled)\n self.assertEqual(unpickled, ([],)*2)\n self.assertIs(unpickled[0], unpickled[1])\n\n def test_binget(self):\n pickled = '(]q\\xffh\\xfft.'\n unpickled = self.loads(pickled)\n self.assertEqual(unpickled, ([],)*2)\n self.assertIs(unpickled[0], unpickled[1])\n\n def test_long_binget(self):\n pickled = '(]r\\x00\\x00\\x01\\x00j\\x00\\x00\\x01\\x00t.'\n unpickled = self.loads(pickled)\n self.assertEqual(unpickled, ([],)*2)\n self.assertIs(unpickled[0], unpickled[1])\n\n def test_dup(self):\n pickled = '((l2t.'\n unpickled = self.loads(pickled)\n self.assertEqual(unpickled, ([],)*2)\n self.assertIs(unpickled[0], unpickled[1])\n\n def test_bad_stack(self):\n badpickles = [\n '.', # STOP\n '0', # POP\n '1', # POP_MARK\n '2', # DUP\n # '(2', # PyUnpickler doesn't raise\n 'R', # REDUCE\n ')R',\n 'a', # APPEND\n 'Na',\n 'b', # BUILD\n 'Nb',\n 'd', # DICT\n 'e', # APPENDS\n # '(e', # PyUnpickler raises AttributeError\n 'i__builtin__\\nlist\\n', # INST\n 'l', # LIST\n 'o', # OBJ\n '(o',\n 'p1\\n', # PUT\n 'q\\x00', # BINPUT\n 'r\\x00\\x00\\x00\\x00', # LONG_BINPUT\n 's', # SETITEM\n 'Ns',\n 'NNs',\n 't', # TUPLE\n 'u', # SETITEMS\n # '(u', # PyUnpickler doesn't raise\n '}(Nu',\n '\\x81', # NEWOBJ\n ')\\x81',\n '\\x85', # TUPLE1\n '\\x86', # TUPLE2\n 'N\\x86',\n '\\x87', # TUPLE3\n 'N\\x87',\n 'NN\\x87',\n ]\n for p in badpickles:\n self.check_unpickling_error(self.bad_stack_errors, p)\n\n def test_bad_mark(self):\n badpickles = [\n # 'N(.', # STOP\n 'N(2', # DUP\n 'c__builtin__\\nlist\\n)(R', # REDUCE\n 'c__builtin__\\nlist\\n()R',\n ']N(a', # APPEND\n # BUILD\n 'c__builtin__\\nValueError\\n)R}(b',\n 'c__builtin__\\nValueError\\n)R(}b',\n '(Nd', # DICT\n 'N(p1\\n', # PUT\n 'N(q\\x00', # BINPUT\n 'N(r\\x00\\x00\\x00\\x00', # LONG_BINPUT\n '}NN(s', # SETITEM\n '}N(Ns',\n '}(NNs',\n '}((u', # SETITEMS\n # NEWOBJ\n 'c__builtin__\\nlist\\n)(\\x81',\n 'c__builtin__\\nlist\\n()\\x81',\n 'N(\\x85', # TUPLE1\n 'NN(\\x86', # TUPLE2\n 'N(N\\x86',\n 'NNN(\\x87', # TUPLE3\n 'NN(N\\x87',\n 'N(NN\\x87',\n ]\n for p in badpickles:\n self.check_unpickling_error(self.bad_mark_errors, p)\n\n def test_truncated_data(self):\n self.check_unpickling_error(EOFError, '')\n self.check_unpickling_error(EOFError, 'N')\n badpickles = [\n 'F', # FLOAT\n 'F0.0',\n 'F0.00',\n 'G', # BINFLOAT\n 'G\\x00\\x00\\x00\\x00\\x00\\x00\\x00',\n 'I', # INT\n 'I0',\n 'J', # BININT\n 'J\\x00\\x00\\x00',\n 'K', # BININT1\n 'L', # LONG\n 'L0',\n 'L10',\n 'L0L',\n 'L10L',\n 'M', # BININT2\n 'M\\x00',\n # 'P', # PERSID\n # 'Pabc',\n 'S', # STRING\n \"S'abc'\",\n 'T', # BINSTRING\n 'T\\x03\\x00\\x00',\n 'T\\x03\\x00\\x00\\x00',\n 'T\\x03\\x00\\x00\\x00ab',\n 'U', # SHORT_BINSTRING\n 'U\\x03',\n 'U\\x03ab',\n 'V', # UNICODE\n 'Vabc',\n 'X', # BINUNICODE\n 'X\\x03\\x00\\x00',\n 'X\\x03\\x00\\x00\\x00',\n 'X\\x03\\x00\\x00\\x00ab',\n '(c', # GLOBAL\n '(c__builtin__',\n '(c__builtin__\\n',\n '(c__builtin__\\nlist',\n 'Ng', # GET\n 'Ng0',\n '(i', # INST\n '(i__builtin__',\n '(i__builtin__\\n',\n '(i__builtin__\\nlist',\n 'Nh', # BINGET\n 'Nj', # LONG_BINGET\n 'Nj\\x00\\x00\\x00',\n 'Np', # PUT\n 'Np0',\n 'Nq', # BINPUT\n 'Nr', # LONG_BINPUT\n 'Nr\\x00\\x00\\x00',\n '\\x80', # PROTO\n '\\x82', # EXT1\n '\\x83', # EXT2\n '\\x84\\x01',\n '\\x84', # EXT4\n '\\x84\\x01\\x00\\x00',\n '\\x8a', # LONG1\n '\\x8b', # LONG4\n '\\x8b\\x00\\x00\\x00',\n ]\n for p in badpickles:\n self.check_unpickling_error(self.truncated_errors, p)\n\n\nclass AbstractPickleTests(unittest.TestCase):\n # Subclass must define self.dumps, self.loads.\n\n _testdata = AbstractUnpickleTests._testdata\n\n def setUp(self):\n pass\n\n def test_misc(self):\n # test various datatypes not tested by testdata\n for proto in protocols:\n x = myint(4)\n s = self.dumps(x, proto)\n y = self.loads(s)\n self.assertEqual(x, y)\n\n x = (1, ())\n s = self.dumps(x, proto)\n y = self.loads(s)\n self.assertEqual(x, y)\n\n x = initarg(1, x)\n s = self.dumps(x, proto)\n y = self.loads(s)\n self.assertEqual(x, y)\n\n # XXX test __reduce__ protocol?\n\n def test_roundtrip_equality(self):\n expected = self._testdata\n for proto in protocols:\n s = self.dumps(expected, proto)\n got = self.loads(s)\n self.assertEqual(expected, got)\n\n # There are gratuitous differences between pickles produced by\n # pickle and cPickle, largely because cPickle starts PUT indices at\n # 1 and pickle starts them at 0. See XXX comment in cPickle's put2() --\n # there's a comment with an exclamation point there whose meaning\n # is a mystery. cPickle also suppresses PUT for objects with a refcount\n # of 1.\n def dont_test_disassembly(self):\n from pickletools import dis\n\n for proto, expected in (0, DATA0_DIS), (1, DATA1_DIS):\n s = self.dumps(self._testdata, proto)\n filelike = cStringIO.StringIO()\n dis(s, out=filelike)\n got = filelike.getvalue()\n self.assertEqual(expected, got)\n\n def test_recursive_list(self):\n l = []\n l.append(l)\n for proto in protocols:\n s = self.dumps(l, proto)\n x = self.loads(s)\n self.assertIsInstance(x, list)\n self.assertEqual(len(x), 1)\n self.assertIs(x[0], x)\n\n def test_recursive_tuple_and_list(self):\n t = ([],)\n t[0].append(t)\n for proto in protocols:\n s = self.dumps(t, proto)\n x = self.loads(s)\n self.assertIsInstance(x, tuple)\n self.assertEqual(len(x), 1)\n self.assertIsInstance(x[0], list)\n self.assertEqual(len(x[0]), 1)\n self.assertIs(x[0][0], x)\n\n def test_recursive_dict(self):\n d = {}\n d[1] = d\n for proto in protocols:\n s = self.dumps(d, proto)\n x = self.loads(s)\n self.assertIsInstance(x, dict)\n self.assertEqual(x.keys(), [1])\n self.assertIs(x[1], x)\n\n def test_recursive_dict_key(self):\n d = {}\n k = K(d)\n d[k] = 1\n for proto in protocols:\n s = self.dumps(d, proto)\n x = self.loads(s)\n self.assertIsInstance(x, dict)\n self.assertEqual(len(x.keys()), 1)\n self.assertIsInstance(x.keys()[0], K)\n self.assertIs(x.keys()[0].value, x)\n\n def test_recursive_list_subclass(self):\n y = MyList()\n y.append(y)\n s = self.dumps(y, 2)\n x = self.loads(s)\n self.assertIsInstance(x, MyList)\n self.assertEqual(len(x), 1)\n self.assertIs(x[0], x)\n\n def test_recursive_dict_subclass(self):\n d = MyDict()\n d[1] = d\n s = self.dumps(d, 2)\n x = self.loads(s)\n self.assertIsInstance(x, MyDict)\n self.assertEqual(x.keys(), [1])\n self.assertIs(x[1], x)\n\n def test_recursive_dict_subclass_key(self):\n d = MyDict()\n k = K(d)\n d[k] = 1\n s = self.dumps(d, 2)\n x = self.loads(s)\n self.assertIsInstance(x, MyDict)\n self.assertEqual(len(x.keys()), 1)\n self.assertIsInstance(x.keys()[0], K)\n self.assertIs(x.keys()[0].value, x)\n\n def test_recursive_inst(self):\n i = C()\n i.attr = i\n for proto in protocols:\n s = self.dumps(i, proto)\n x = self.loads(s)\n self.assertIsInstance(x, C)\n self.assertEqual(dir(x), dir(i))\n self.assertIs(x.attr, x)\n\n def test_recursive_multi(self):\n l = []\n d = {1:l}\n i = C()\n i.attr = d\n l.append(i)\n for proto in protocols:\n s = self.dumps(l, proto)\n x = self.loads(s)\n self.assertIsInstance(x, list)\n self.assertEqual(len(x), 1)\n self.assertEqual(dir(x[0]), dir(i))\n self.assertEqual(x[0].attr.keys(), [1])\n self.assertTrue(x[0].attr[1] is x)\n\n def check_recursive_collection_and_inst(self, factory):\n h = H()\n y = factory([h])\n h.attr = y\n for proto in protocols:\n s = self.dumps(y, proto)\n x = self.loads(s)\n self.assertIsInstance(x, type(y))\n self.assertEqual(len(x), 1)\n self.assertIsInstance(list(x)[0], H)\n self.assertIs(list(x)[0].attr, x)\n\n def test_recursive_list_and_inst(self):\n self.check_recursive_collection_and_inst(list)\n\n def test_recursive_tuple_and_inst(self):\n self.check_recursive_collection_and_inst(tuple)\n\n def test_recursive_dict_and_inst(self):\n self.check_recursive_collection_and_inst(dict.fromkeys)\n\n def test_recursive_set_and_inst(self):\n self.check_recursive_collection_and_inst(set)\n\n def test_recursive_frozenset_and_inst(self):\n self.check_recursive_collection_and_inst(frozenset)\n\n def test_recursive_list_subclass_and_inst(self):\n self.check_recursive_collection_and_inst(MyList)\n\n def test_recursive_tuple_subclass_and_inst(self):\n self.check_recursive_collection_and_inst(MyTuple)\n\n def test_recursive_dict_subclass_and_inst(self):\n self.check_recursive_collection_and_inst(MyDict.fromkeys)\n\n if have_unicode:\n def test_unicode(self):\n endcases = [u'', u'<\\\\u>', u'<\\\\\\u1234>', u'<\\n>',\n u'<\\\\>', u'<\\\\\\U00012345>',\n # surrogates\n u'<\\udc80>']\n for proto in protocols:\n for u in endcases:\n p = self.dumps(u, proto)\n u2 = self.loads(p)\n self.assertEqual(u2, u)\n\n def test_unicode_high_plane(self):\n t = u'\\U00012345'\n for proto in protocols:\n p = self.dumps(t, proto)\n t2 = self.loads(p)\n self.assertEqual(t2, t)\n\n def test_ints(self):\n import sys\n for proto in protocols:\n n = sys.maxint\n while n:\n for expected in (-n, n):\n s = self.dumps(expected, proto)\n n2 = self.loads(s)\n self.assertEqual(expected, n2)\n n = n >> 1\n\n def test_long(self):\n for proto in protocols:\n # 256 bytes is where LONG4 begins.\n for nbits in 1, 8, 8*254, 8*255, 8*256, 8*257:\n nbase = 1L << nbits\n for npos in nbase-1, nbase, nbase+1:\n for n in npos, -npos:\n pickle = self.dumps(n, proto)\n got = self.loads(pickle)\n self.assertEqual(n, got)\n # Try a monster. This is quadratic-time in protos 0 & 1, so don't\n # bother with those.\n nbase = long(\"deadbeeffeedface\", 16)\n nbase += nbase << 1000000\n for n in nbase, -nbase:\n p = self.dumps(n, 2)\n got = self.loads(p)\n self.assertEqual(n, got)\n\n def test_float(self):\n test_values = [0.0, 4.94e-324, 1e-310, 7e-308, 6.626e-34, 0.1, 0.5,\n 3.14, 263.44582062374053, 6.022e23, 1e30]\n test_values = test_values + [-x for x in test_values]\n for proto in protocols:\n for value in test_values:\n pickle = self.dumps(value, proto)\n got = self.loads(pickle)\n self.assertEqual(value, got)\n\n @run_with_locale('LC_ALL', 'de_DE', 'fr_FR')\n def test_float_format(self):\n # make sure that floats are formatted locale independent\n self.assertEqual(self.dumps(1.2)[0:3], 'F1.')\n\n def test_reduce(self):\n pass\n\n def test_getinitargs(self):\n pass\n\n def test_metaclass(self):\n a = use_metaclass()\n for proto in protocols:\n s = self.dumps(a, proto)\n b = self.loads(s)\n self.assertEqual(a.__class__, b.__class__)\n\n def test_dynamic_class(self):\n a = create_dynamic_class(\"my_dynamic_class\", (object,))\n copy_reg.pickle(pickling_metaclass, pickling_metaclass.__reduce__)\n for proto in protocols:\n s = self.dumps(a, proto)\n b = self.loads(s)\n self.assertEqual(a, b)\n self.assertIs(a.__class__, b.__class__)\n\n def test_structseq(self):\n import time\n import os\n\n t = time.localtime()\n for proto in protocols:\n s = self.dumps(t, proto)\n u = self.loads(s)\n self.assertEqual(t, u)\n if hasattr(os, \"stat\"):\n t = os.stat(os.curdir)\n s = self.dumps(t, proto)\n u = self.loads(s)\n self.assertEqual(t, u)\n if hasattr(os, \"statvfs\"):\n t = os.statvfs(os.curdir)\n s = self.dumps(t, proto)\n u = self.loads(s)\n self.assertEqual(t, u)\n\n # Tests for protocol 2\n\n def test_proto(self):\n build_none = pickle.NONE + pickle.STOP\n for proto in protocols:\n expected = build_none\n if proto >= 2:\n expected = pickle.PROTO + chr(proto) + expected\n p = self.dumps(None, proto)\n self.assertEqual(p, expected)\n\n oob = protocols[-1] + 1 # a future protocol\n badpickle = pickle.PROTO + chr(oob) + build_none\n try:\n self.loads(badpickle)\n except ValueError, detail:\n self.assertTrue(str(detail).startswith(\n \"unsupported pickle protocol\"))\n else:\n self.fail(\"expected bad protocol number to raise ValueError\")\n\n def test_long1(self):\n x = 12345678910111213141516178920L\n for proto in protocols:\n s = self.dumps(x, proto)\n y = self.loads(s)\n self.assertEqual(x, y)\n self.assertEqual(opcode_in_pickle(pickle.LONG1, s), proto >= 2)\n\n def test_long4(self):\n x = 12345678910111213141516178920L << (256*8)\n for proto in protocols:\n s = self.dumps(x, proto)\n y = self.loads(s)\n self.assertEqual(x, y)\n self.assertEqual(opcode_in_pickle(pickle.LONG4, s), proto >= 2)\n\n def test_short_tuples(self):\n # Map (proto, len(tuple)) to expected opcode.\n expected_opcode = {(0, 0): pickle.TUPLE,\n (0, 1): pickle.TUPLE,\n (0, 2): pickle.TUPLE,\n (0, 3): pickle.TUPLE,\n (0, 4): pickle.TUPLE,\n\n (1, 0): pickle.EMPTY_TUPLE,\n (1, 1): pickle.TUPLE,\n (1, 2): pickle.TUPLE,\n (1, 3): pickle.TUPLE,\n (1, 4): pickle.TUPLE,\n\n (2, 0): pickle.EMPTY_TUPLE,\n (2, 1): pickle.TUPLE1,\n (2, 2): pickle.TUPLE2,\n (2, 3): pickle.TUPLE3,\n (2, 4): pickle.TUPLE,\n }\n a = ()\n b = (1,)\n c = (1, 2)\n d = (1, 2, 3)\n e = (1, 2, 3, 4)\n for proto in protocols:\n for x in a, b, c, d, e:\n s = self.dumps(x, proto)\n y = self.loads(s)\n self.assertEqual(x, y, (proto, x, s, y))\n expected = expected_opcode[proto, len(x)]\n self.assertEqual(opcode_in_pickle(expected, s), True)\n\n def test_singletons(self):\n # Map (proto, singleton) to expected opcode.\n expected_opcode = {(0, None): pickle.NONE,\n (1, None): pickle.NONE,\n (2, None): pickle.NONE,\n\n (0, True): pickle.INT,\n (1, True): pickle.INT,\n (2, True): pickle.NEWTRUE,\n\n (0, False): pickle.INT,\n (1, False): pickle.INT,\n (2, False): pickle.NEWFALSE,\n }\n for proto in protocols:\n for x in None, False, True:\n s = self.dumps(x, proto)\n y = self.loads(s)\n self.assertTrue(x is y, (proto, x, s, y))\n expected = expected_opcode[proto, x]\n self.assertEqual(opcode_in_pickle(expected, s), True)\n\n def test_newobj_tuple(self):\n x = MyTuple([1, 2, 3])\n x.foo = 42\n x.bar = \"hello\"\n for proto in protocols:\n s = self.dumps(x, proto)\n y = self.loads(s)\n self.assertEqual(tuple(x), tuple(y))\n self.assertEqual(x.__dict__, y.__dict__)\n\n def test_newobj_list(self):\n x = MyList([1, 2, 3])\n x.foo = 42\n x.bar = \"hello\"\n for proto in protocols:\n s = self.dumps(x, proto)\n y = self.loads(s)\n self.assertEqual(list(x), list(y))\n self.assertEqual(x.__dict__, y.__dict__)\n\n def test_newobj_generic(self):\n for proto in protocols:\n for C in myclasses:\n B = C.__base__\n x = C(C.sample)\n x.foo = 42\n s = self.dumps(x, proto)\n y = self.loads(s)\n detail = (proto, C, B, x, y, type(y))\n self.assertEqual(B(x), B(y), detail)\n self.assertEqual(x.__dict__, y.__dict__, detail)\n\n def test_newobj_proxies(self):\n # NEWOBJ should use the __class__ rather than the raw type\n import weakref\n classes = myclasses[:]\n # Cannot create weakproxies to these classes\n for c in (MyInt, MyLong, MyStr, MyTuple):\n classes.remove(c)\n for proto in protocols:\n for C in classes:\n B = C.__base__\n x = C(C.sample)\n x.foo = 42\n p = weakref.proxy(x)\n s = self.dumps(p, proto)\n y = self.loads(s)\n self.assertEqual(type(y), type(x)) # rather than type(p)\n detail = (proto, C, B, x, y, type(y))\n self.assertEqual(B(x), B(y), detail)\n self.assertEqual(x.__dict__, y.__dict__, detail)\n\n # Register a type with copy_reg, with extension code extcode. Pickle\n # an object of that type. Check that the resulting pickle uses opcode\n # (EXT[124]) under proto 2, and not in proto 1.\n\n def produce_global_ext(self, extcode, opcode):\n e = ExtensionSaver(extcode)\n try:\n copy_reg.add_extension(__name__, \"MyList\", extcode)\n x = MyList([1, 2, 3])\n x.foo = 42\n x.bar = \"hello\"\n\n # Dump using protocol 1 for comparison.\n s1 = self.dumps(x, 1)\n self.assertIn(__name__, s1)\n self.assertIn(\"MyList\", s1)\n self.assertEqual(opcode_in_pickle(opcode, s1), False)\n\n y = self.loads(s1)\n self.assertEqual(list(x), list(y))\n self.assertEqual(x.__dict__, y.__dict__)\n\n # Dump using protocol 2 for test.\n s2 = self.dumps(x, 2)\n self.assertNotIn(__name__, s2)\n self.assertNotIn(\"MyList\", s2)\n self.assertEqual(opcode_in_pickle(opcode, s2), True)\n\n y = self.loads(s2)\n self.assertEqual(list(x), list(y))\n self.assertEqual(x.__dict__, y.__dict__)\n\n finally:\n e.restore()\n\n def test_global_ext1(self):\n self.produce_global_ext(0x00000001, pickle.EXT1) # smallest EXT1 code\n self.produce_global_ext(0x000000ff, pickle.EXT1) # largest EXT1 code\n\n def test_global_ext2(self):\n self.produce_global_ext(0x00000100, pickle.EXT2) # smallest EXT2 code\n self.produce_global_ext(0x0000ffff, pickle.EXT2) # largest EXT2 code\n self.produce_global_ext(0x0000abcd, pickle.EXT2) # check endianness\n\n def test_global_ext4(self):\n self.produce_global_ext(0x00010000, pickle.EXT4) # smallest EXT4 code\n self.produce_global_ext(0x7fffffff, pickle.EXT4) # largest EXT4 code\n self.produce_global_ext(0x12abcdef, pickle.EXT4) # check endianness\n\n def test_list_chunking(self):\n n = 10 # too small to chunk\n x = range(n)\n for proto in protocols:\n s = self.dumps(x, proto)\n y = self.loads(s)\n self.assertEqual(x, y)\n num_appends = count_opcode(pickle.APPENDS, s)\n self.assertEqual(num_appends, proto > 0)\n\n n = 2500 # expect at least two chunks when proto > 0\n x = range(n)\n for proto in protocols:\n s = self.dumps(x, proto)\n y = self.loads(s)\n self.assertEqual(x, y)\n num_appends = count_opcode(pickle.APPENDS, s)\n if proto == 0:\n self.assertEqual(num_appends, 0)\n else:\n self.assertTrue(num_appends >= 2)\n\n def test_dict_chunking(self):\n n = 10 # too small to chunk\n x = dict.fromkeys(range(n))\n for proto in protocols:\n s = self.dumps(x, proto)\n y = self.loads(s)\n self.assertEqual(x, y)\n num_setitems = count_opcode(pickle.SETITEMS, s)\n self.assertEqual(num_setitems, proto > 0)\n\n n = 2500 # expect at least two chunks when proto > 0\n x = dict.fromkeys(range(n))\n for proto in protocols:\n s = self.dumps(x, proto)\n y = self.loads(s)\n self.assertEqual(x, y)\n num_setitems = count_opcode(pickle.SETITEMS, s)\n if proto == 0:\n self.assertEqual(num_setitems, 0)\n else:\n self.assertTrue(num_setitems >= 2)\n\n def test_simple_newobj(self):\n x = SimpleNewObj.__new__(SimpleNewObj, 0xface) # avoid __init__\n x.abc = 666\n for proto in protocols:\n s = self.dumps(x, proto)\n if proto < 1:\n self.assertIn('\\nI64206', s) # INT\n else:\n self.assertIn('M\\xce\\xfa', s) # BININT2\n self.assertEqual(opcode_in_pickle(pickle.NEWOBJ, s), proto >= 2)\n y = self.loads(s) # will raise TypeError if __init__ called\n self.assertEqual(y.abc, 666)\n self.assertEqual(x.__dict__, y.__dict__)\n\n def test_complex_newobj(self):\n x = ComplexNewObj.__new__(ComplexNewObj, 0xface) # avoid __init__\n x.abc = 666\n for proto in protocols:\n s = self.dumps(x, proto)\n if proto < 1:\n self.assertIn('\\nI64206', s) # INT\n elif proto < 2:\n self.assertIn('M\\xce\\xfa', s) # BININT2\n else:\n self.assertIn('U\\x04FACE', s) # SHORT_BINSTRING\n self.assertEqual(opcode_in_pickle(pickle.NEWOBJ, s), proto >= 2)\n y = self.loads(s) # will raise TypeError if __init__ called\n self.assertEqual(y.abc, 666)\n self.assertEqual(x.__dict__, y.__dict__)\n\n def test_newobj_list_slots(self):\n x = SlotList([1, 2, 3])\n x.foo = 42\n x.bar = \"hello\"\n s = self.dumps(x, 2)\n y = self.loads(s)\n self.assertEqual(list(x), list(y))\n self.assertEqual(x.__dict__, y.__dict__)\n self.assertEqual(x.foo, y.foo)\n self.assertEqual(x.bar, y.bar)\n\n def test_reduce_overrides_default_reduce_ex(self):\n for proto in protocols:\n x = REX_one()\n self.assertEqual(x._reduce_called, 0)\n s = self.dumps(x, proto)\n self.assertEqual(x._reduce_called, 1)\n y = self.loads(s)\n self.assertEqual(y._reduce_called, 0)\n\n def test_reduce_ex_called(self):\n for proto in protocols:\n x = REX_two()\n self.assertEqual(x._proto, None)\n s = self.dumps(x, proto)\n self.assertEqual(x._proto, proto)\n y = self.loads(s)\n self.assertEqual(y._proto, None)\n\n def test_reduce_ex_overrides_reduce(self):\n for proto in protocols:\n x = REX_three()\n self.assertEqual(x._proto, None)\n s = self.dumps(x, proto)\n self.assertEqual(x._proto, proto)\n y = self.loads(s)\n self.assertEqual(y._proto, None)\n\n def test_reduce_ex_calls_base(self):\n for proto in protocols:\n x = REX_four()\n self.assertEqual(x._proto, None)\n s = self.dumps(x, proto)\n self.assertEqual(x._proto, proto)\n y = self.loads(s)\n self.assertEqual(y._proto, proto)\n\n def test_reduce_calls_base(self):\n for proto in protocols:\n x = REX_five()\n self.assertEqual(x._reduce_called, 0)\n s = self.dumps(x, proto)\n self.assertEqual(x._reduce_called, 1)\n y = self.loads(s)\n self.assertEqual(y._reduce_called, 1)\n\n @no_tracing\n def test_bad_getattr(self):\n # Issue #3514: crash when there is an infinite loop in __getattr__\n x = BadGetattr()\n for proto in protocols:\n self.assertRaises(RuntimeError, self.dumps, x, proto)\n\n def test_reduce_bad_iterator(self):\n # Issue4176: crash when 4th and 5th items of __reduce__()\n # are not iterators\n class C(object):\n def __reduce__(self):\n # 4th item is not an iterator\n return list, (), None, [], None\n class D(object):\n def __reduce__(self):\n # 5th item is not an iterator\n return dict, (), None, None, []\n\n # Protocol 0 in Python implementation is less strict and also accepts\n # iterables.\n for proto in protocols:\n try:\n self.dumps(C(), proto)\n except (AttributeError, pickle.PicklingError, cPickle.PicklingError):\n pass\n try:\n self.dumps(D(), proto)\n except (AttributeError, pickle.PicklingError, cPickle.PicklingError):\n pass\n\n def test_many_puts_and_gets(self):\n # Test that internal data structures correctly deal with lots of\n # puts/gets.\n keys = (\"aaa\" + str(i) for i in xrange(100))\n large_dict = dict((k, [4, 5, 6]) for k in keys)\n obj = [dict(large_dict), dict(large_dict), dict(large_dict)]\n\n for proto in protocols:\n dumped = self.dumps(obj, proto)\n loaded = self.loads(dumped)\n self.assertEqual(loaded, obj,\n \"Failed protocol %d: %r != %r\"\n % (proto, obj, loaded))\n\n def test_attribute_name_interning(self):\n # Test that attribute names of pickled objects are interned when\n # unpickling.\n for proto in protocols:\n x = C()\n x.foo = 42\n x.bar = \"hello\"\n s = self.dumps(x, proto)\n y = self.loads(s)\n x_keys = sorted(x.__dict__)\n y_keys = sorted(y.__dict__)\n for x_key, y_key in zip(x_keys, y_keys):\n self.assertIs(x_key, y_key)\n\n def test_large_pickles(self):\n # Test the correctness of internal buffering routines when handling\n # large data.\n for proto in protocols:\n data = (1, min, 'xy' * (30 * 1024), len)\n dumped = self.dumps(data, proto)\n loaded = self.loads(dumped)\n self.assertEqual(len(loaded), len(data))\n self.assertEqual(loaded, data)\n\n def _check_pickling_with_opcode(self, obj, opcode, proto):\n pickled = self.dumps(obj, proto)\n self.assertTrue(opcode_in_pickle(opcode, pickled))\n unpickled = self.loads(pickled)\n self.assertEqual(obj, unpickled)\n\n def test_appends_on_non_lists(self):\n # Issue #17720\n obj = REX_six([1, 2, 3])\n for proto in protocols:\n if proto == 0:\n self._check_pickling_with_opcode(obj, pickle.APPEND, proto)\n else:\n self._check_pickling_with_opcode(obj, pickle.APPENDS, proto)\n\n def test_setitems_on_non_dicts(self):\n obj = REX_seven({1: -1, 2: -2, 3: -3})\n for proto in protocols:\n if proto == 0:\n self._check_pickling_with_opcode(obj, pickle.SETITEM, proto)\n else:\n self._check_pickling_with_opcode(obj, pickle.SETITEMS, proto)\n\n\n# Test classes for reduce_ex\n\nclass REX_one(object):\n _reduce_called = 0\n def __reduce__(self):\n self._reduce_called = 1\n return REX_one, ()\n # No __reduce_ex__ here, but inheriting it from object\n\nclass REX_two(object):\n _proto = None\n def __reduce_ex__(self, proto):\n self._proto = proto\n return REX_two, ()\n # No __reduce__ here, but inheriting it from object\n\nclass REX_three(object):\n _proto = None\n def __reduce_ex__(self, proto):\n self._proto = proto\n return REX_two, ()\n def __reduce__(self):\n raise TestFailed, \"This __reduce__ shouldn't be called\"\n\nclass REX_four(object):\n _proto = None\n def __reduce_ex__(self, proto):\n self._proto = proto\n return object.__reduce_ex__(self, proto)\n # Calling base class method should succeed\n\nclass REX_five(object):\n _reduce_called = 0\n def __reduce__(self):\n self._reduce_called = 1\n return object.__reduce__(self)\n # This one used to fail with infinite recursion\n\nclass REX_six(object):\n \"\"\"This class is used to check the 4th argument (list iterator) of\n the reduce protocol.\n \"\"\"\n def __init__(self, items=None):\n if items is None:\n items = []\n self.items = items\n def __eq__(self, other):\n return type(self) is type(other) and self.items == other.items\n def append(self, item):\n self.items.append(item)\n def extend(self, items):\n for item in items:\n self.append(item)\n def __reduce__(self):\n return type(self), (), None, iter(self.items), None\n\nclass REX_seven(object):\n \"\"\"This class is used to check the 5th argument (dict iterator) of\n the reduce protocol.\n \"\"\"\n def __init__(self, table=None):\n if table is None:\n table = {}\n self.table = table\n def __eq__(self, other):\n return type(self) is type(other) and self.table == other.table\n def __setitem__(self, key, value):\n self.table[key] = value\n def __reduce__(self):\n return type(self), (), None, None, iter(self.table.items())\n\n# Test classes for newobj\n\nclass MyInt(int):\n sample = 1\n\nclass MyLong(long):\n sample = 1L\n\nclass MyFloat(float):\n sample = 1.0\n\nclass MyComplex(complex):\n sample = 1.0 + 0.0j\n\nclass MyStr(str):\n sample = \"hello\"\n\nclass MyUnicode(unicode):\n sample = u\"hello \\u1234\"\n\nclass MyTuple(tuple):\n sample = (1, 2, 3)\n\nclass MyList(list):\n sample = [1, 2, 3]\n\nclass MyDict(dict):\n sample = {\"a\": 1, \"b\": 2}\n\nmyclasses = [MyInt, MyLong, MyFloat,\n MyComplex,\n MyStr, MyUnicode,\n MyTuple, MyList, MyDict]\n\n\nclass SlotList(MyList):\n __slots__ = [\"foo\"]\n\nclass SimpleNewObj(int):\n def __init__(self, *args, **kwargs):\n # raise an error, to make sure this isn't called\n raise TypeError(\"SimpleNewObj.__init__() didn't expect to get called\")\n def __eq__(self, other):\n return int(self) == int(other) and self.__dict__ == other.__dict__\n\nclass ComplexNewObj(SimpleNewObj):\n def __getnewargs__(self):\n return ('%X' % self, 16)\n\nclass BadGetattr:\n def __getattr__(self, key):\n self.foo\n\nclass AbstractPickleModuleTests(unittest.TestCase):\n\n def test_dump_closed_file(self):\n import os\n f = open(TESTFN, \"w\")\n try:\n f.close()\n self.assertRaises(ValueError, self.module.dump, 123, f)\n finally:\n os.remove(TESTFN)\n\n def test_load_closed_file(self):\n import os\n f = open(TESTFN, \"w\")\n try:\n f.close()\n self.assertRaises(ValueError, self.module.dump, 123, f)\n finally:\n os.remove(TESTFN)\n\n def test_load_from_and_dump_to_file(self):\n stream = cStringIO.StringIO()\n data = [123, {}, 124]\n self.module.dump(data, stream)\n stream.seek(0)\n unpickled = self.module.load(stream)\n self.assertEqual(unpickled, data)\n\n def test_highest_protocol(self):\n # Of course this needs to be changed when HIGHEST_PROTOCOL changes.\n self.assertEqual(self.module.HIGHEST_PROTOCOL, 2)\n\n def test_callapi(self):\n f = cStringIO.StringIO()\n # With and without keyword arguments\n self.module.dump(123, f, -1)\n self.module.dump(123, file=f, protocol=-1)\n self.module.dumps(123, -1)\n self.module.dumps(123, protocol=-1)\n self.module.Pickler(f, -1)\n self.module.Pickler(f, protocol=-1)\n\n def test_incomplete_input(self):\n s = StringIO.StringIO(\"X''.\")\n self.assertRaises(EOFError, self.module.load, s)\n\n def test_restricted(self):\n # issue7128: cPickle failed in restricted mode\n builtins = {self.module.__name__: self.module,\n '__import__': __import__}\n d = {}\n teststr = \"def f(): {0}.dumps(0)\".format(self.module.__name__)\n exec teststr in {'__builtins__': builtins}, d\n d['f']()\n\n def test_bad_input(self):\n # Test issue4298\n s = '\\x58\\0\\0\\0\\x54'\n self.assertRaises(EOFError, self.module.loads, s)\n\n\nclass AbstractPersistentPicklerTests(unittest.TestCase):\n\n # This class defines persistent_id() and persistent_load()\n # functions that should be used by the pickler. All even integers\n # are pickled using persistent ids.\n\n def persistent_id(self, object):\n if isinstance(object, int) and object % 2 == 0:\n self.id_count += 1\n return str(object)\n elif object == \"test_false_value\":\n self.false_count += 1\n return \"\"\n else:\n return None\n\n def persistent_load(self, oid):\n if not oid:\n self.load_false_count += 1\n return \"test_false_value\"\n else:\n self.load_count += 1\n object = int(oid)\n assert object % 2 == 0\n return object\n\n def test_persistence(self):\n L = range(10) + [\"test_false_value\"]\n for proto in protocols:\n self.id_count = 0\n self.false_count = 0\n self.load_false_count = 0\n self.load_count = 0\n self.assertEqual(self.loads(self.dumps(L, proto)), L)\n self.assertEqual(self.id_count, 5)\n self.assertEqual(self.false_count, 1)\n self.assertEqual(self.load_count, 5)\n self.assertEqual(self.load_false_count, 1)\n\nclass AbstractPicklerUnpicklerObjectTests(unittest.TestCase):\n\n pickler_class = None\n unpickler_class = None\n\n def setUp(self):\n assert self.pickler_class\n assert self.unpickler_class\n\n def test_clear_pickler_memo(self):\n # To test whether clear_memo() has any effect, we pickle an object,\n # then pickle it again without clearing the memo; the two serialized\n # forms should be different. If we clear_memo() and then pickle the\n # object again, the third serialized form should be identical to the\n # first one we obtained.\n data = [\"abcdefg\", \"abcdefg\", 44]\n f = cStringIO.StringIO()\n pickler = self.pickler_class(f)\n\n pickler.dump(data)\n first_pickled = f.getvalue()\n\n # Reset StringIO object.\n f.seek(0)\n f.truncate()\n\n pickler.dump(data)\n second_pickled = f.getvalue()\n\n # Reset the Pickler and StringIO objects.\n pickler.clear_memo()\n f.seek(0)\n f.truncate()\n\n pickler.dump(data)\n third_pickled = f.getvalue()\n\n self.assertNotEqual(first_pickled, second_pickled)\n self.assertEqual(first_pickled, third_pickled)\n\n def test_priming_pickler_memo(self):\n # Verify that we can set the Pickler's memo attribute.\n data = [\"abcdefg\", \"abcdefg\", 44]\n f = cStringIO.StringIO()\n pickler = self.pickler_class(f)\n\n pickler.dump(data)\n first_pickled = f.getvalue()\n\n f = cStringIO.StringIO()\n primed = self.pickler_class(f)\n primed.memo = pickler.memo\n\n primed.dump(data)\n primed_pickled = f.getvalue()\n\n self.assertNotEqual(first_pickled, primed_pickled)\n\n def test_priming_unpickler_memo(self):\n # Verify that we can set the Unpickler's memo attribute.\n data = [\"abcdefg\", \"abcdefg\", 44]\n f = cStringIO.StringIO()\n pickler = self.pickler_class(f)\n\n pickler.dump(data)\n first_pickled = f.getvalue()\n\n f = cStringIO.StringIO()\n primed = self.pickler_class(f)\n primed.memo = pickler.memo\n\n primed.dump(data)\n primed_pickled = f.getvalue()\n\n unpickler = self.unpickler_class(cStringIO.StringIO(first_pickled))\n unpickled_data1 = unpickler.load()\n\n self.assertEqual(unpickled_data1, data)\n\n primed = self.unpickler_class(cStringIO.StringIO(primed_pickled))\n primed.memo = unpickler.memo\n unpickled_data2 = primed.load()\n\n primed.memo.clear()\n\n self.assertEqual(unpickled_data2, data)\n self.assertTrue(unpickled_data2 is unpickled_data1)\n\n def test_reusing_unpickler_objects(self):\n data1 = [\"abcdefg\", \"abcdefg\", 44]\n f = cStringIO.StringIO()\n pickler = self.pickler_class(f)\n pickler.dump(data1)\n pickled1 = f.getvalue()\n\n data2 = [\"abcdefg\", 44, 44]\n f = cStringIO.StringIO()\n pickler = self.pickler_class(f)\n pickler.dump(data2)\n pickled2 = f.getvalue()\n\n f = cStringIO.StringIO()\n f.write(pickled1)\n f.seek(0)\n unpickler = self.unpickler_class(f)\n self.assertEqual(unpickler.load(), data1)\n\n f.seek(0)\n f.truncate()\n f.write(pickled2)\n f.seek(0)\n self.assertEqual(unpickler.load(), data2)\n\n def _check_multiple_unpicklings(self, ioclass, seekable):\n for proto in protocols:\n data1 = [(x, str(x)) for x in xrange(2000)] + [\"abcde\", len]\n f = ioclass()\n pickler = self.pickler_class(f, protocol=proto)\n pickler.dump(data1)\n pickled = f.getvalue()\n\n N = 5\n f = ioclass(pickled * N)\n unpickler = self.unpickler_class(f)\n for i in xrange(N):\n if seekable:\n pos = f.tell()\n self.assertEqual(unpickler.load(), data1)\n if seekable:\n self.assertEqual(f.tell(), pos + len(pickled))\n self.assertRaises(EOFError, unpickler.load)\n\n def test_multiple_unpicklings_seekable(self):\n self._check_multiple_unpicklings(StringIO.StringIO, True)\n\n def test_multiple_unpicklings_unseekable(self):\n self._check_multiple_unpicklings(UnseekableIO, False)\n\n def test_unpickling_buffering_readline(self):\n # Issue #12687: the unpickler's buffering logic could fail with\n # text mode opcodes.\n import io\n data = list(xrange(10))\n for proto in protocols:\n for buf_size in xrange(1, 11):\n f = io.BufferedRandom(io.BytesIO(), buffer_size=buf_size)\n pickler = self.pickler_class(f, protocol=proto)\n pickler.dump(data)\n f.seek(0)\n unpickler = self.unpickler_class(f)\n self.assertEqual(unpickler.load(), data)\n\n\nclass BigmemPickleTests(unittest.TestCase):\n\n # Memory requirements: 1 byte per character for input strings, 1 byte\n # for pickled data, 1 byte for unpickled strings, 1 byte for internal\n # buffer and 1 byte of free space for resizing of internal buffer.\n\n @precisionbigmemtest(size=_2G + 100*_1M, memuse=5)\n def test_huge_strlist(self, size):\n chunksize = 2**20\n data = []\n while size > chunksize:\n data.append('x' * chunksize)\n size -= chunksize\n chunksize += 1\n data.append('y' * size)\n\n try:\n for proto in protocols:\n try:\n pickled = self.dumps(data, proto)\n res = self.loads(pickled)\n self.assertEqual(res, data)\n finally:\n res = None\n pickled = None\n finally:\n data = None\n"},"domain":{"kind":"string","value":"codeparrot/github-code-clean"}}},{"rowIdx":227194,"cells":{"text":{"kind":"string","value":"# Rekall Memory Forensics\n# Copyright (C) 2007,2008 Volatile Systems\n# Copyright 2013 Google Inc. All Rights Reserved.\n#\n# Copyright (C) 2005,2006 4tphi Research\n# Author: {npetroni,awalters}@4tphi.net (Nick Petroni and AAron Walters)\n# Author: Michael Cohen scudette@gmail.com.\n#\n# This program is free software; you can redistribute it and/or modify\n# it under the terms of the GNU General Public License as published by\n# the Free Software Foundation; either version 2 of the License, or (at\n# your option) any later version.\n#\n# This program is distributed in the hope that it will be useful, but\n# WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n# General Public License for more details.\n#\n# You should have received a copy of the GNU General Public License\n# along with this program; if not, write to the Free Software\n# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n#\n\n\"\"\"\nThe Rekall Memory Forensics object system.\n\n\"\"\"\n__author__ = (\"Michael Cohen <scudette@gmail.com> based on original code \"\n \"by AAron Walters and Brendan Dolan-Gavitt with contributions \"\n \"by Mike Auty\")\n\nimport atexit\nimport inspect\nimport json\nimport logging\nimport pdb\nimport operator\nimport os\nimport struct\nimport StringIO\nimport copy\n\nimport traceback\n\nfrom rekall import addrspace\nfrom rekall import registry\nfrom rekall import utils\nfrom rekall.ui import renderer\n\n\nclass ProfileLog(object):\n # Point this environment variable into a filename we will use to store\n # profiling results.\n ENVIRONMENT_VAR = \"DEBUG_PROFILE\"\n\n class JSONEncoder(json.JSONEncoder):\n def default(self, obj): # pylint: disable=method-hidden\n if isinstance(obj, set):\n return sorted(obj)\n\n return json.JSONEncoder.default(self, obj)\n\n @staticmethod\n def as_set(obj):\n for k in obj:\n if isinstance(obj[k], list):\n obj[k] = set(obj[k])\n\n return obj\n\n def __init__(self):\n self.data = {}\n self.filename = os.environ.get(self.ENVIRONMENT_VAR)\n if self.filename:\n # Ensure we update the object access log when we exit.\n atexit.register(self._DumpData)\n\n def _MergeData(self, data):\n for profile, structs in data.items():\n if profile not in self.data:\n self.data[profile] = data[profile]\n else:\n for c_struct, fields in structs.items():\n if c_struct not in self.data[profile]:\n self.data[profile][c_struct] = fields\n else:\n self.data[profile][c_struct].update(fields)\n\n def _DumpData(self):\n try:\n with utils.FileLock(open(self.filename, \"rb\")) as fd:\n self._MergeData(json.loads(\n fd.read(), object_hook=self.JSONEncoder.as_set))\n\n with open(self.filename, \"wb\") as fd:\n fd.write(json.dumps(self.data, cls=self.JSONEncoder))\n\n except (IOError, ValueError):\n pass\n\n logging.info(\"Updating object access database %s\", self.filename)\n with open(self.filename, \"wb\") as fd:\n fd.write(json.dumps(self.data, cls=self.JSONEncoder))\n\n def LogFieldAccess(self, profile, obj_type, field_name):\n # Do nothing unless the environment is set.\n if self.is_active():\n profile = self.data.setdefault(profile, {})\n fields = profile.setdefault(obj_type, set())\n if field_name:\n fields.add(field_name)\n\n def LogConstant(self, profile, name):\n self.LogFieldAccess(profile, \"Constants\", name)\n\n @staticmethod\n def is_active():\n return bool(os.environ.get(ProfileLog.ENVIRONMENT_VAR))\n\n\n# This is used to store Struct member access when the DEBUG_PROFILE environment\n# variable is set.\nACCESS_LOG = ProfileLog()\n\n\nclass Curry(object):\n def __init__(self, curry_target, *args, **kwargs):\n self._target = curry_target\n self._kwargs = kwargs\n self._args = args\n self._default_arguments = kwargs.pop(\"default_arguments\", [])\n self.__doc__ = self._target.__doc__\n self.__wrapped__ = self._target\n\n def __call__(self, *args, **kwargs):\n # Merge the kwargs with the new kwargs\n new_kwargs = self._kwargs.copy()\n new_kwargs.update(kwargs)\n return self._target(*(self._args + args), **new_kwargs)\n\n def get_default_arguments(self):\n \"\"\"Return a list of default args for the target.\"\"\"\n if self._default_arguments is not None:\n return self._default_arguments\n\n args, _, _, defaults = inspect.getargspec(self._target)\n if defaults:\n return args[-len(defaults):]\n\n return []\n\n def __getattr__(self, attr):\n return getattr(self._target, attr)\n\n\nclass NoneObject(object):\n \"\"\"A magical object which is like None but swallows bad\n dereferences, __getattr__, iterators etc to return itself.\n\n Instantiate with the reason for the error.\n \"\"\"\n __metaclass__ = registry.UniqueObjectIdMetaclass\n\n def __init__(self, reason=\"None Object\", *args, **kwargs):\n # Often None objects are instantiated on purpose so its not really that\n # important to see their reason.\n if kwargs.get(\"log\"):\n logging.log(logging.WARN, reason)\n self.reason = unicode(reason)\n self.strict = kwargs.get(\"strict\")\n self.args = args\n if self.strict:\n self.bt = ''.join(traceback.format_stack()[:-2])\n\n def __str__(self):\n return unicode(self).encode('utf-8')\n\n def __unicode__(self):\n # If we are strict we blow up here\n if self.strict:\n if \"%\" in self.reason:\n reason = self.reason % self.args\n else:\n reason = self.reason.format(*self.args)\n logging.error(\"%s\\n%s\", reason, self.bt)\n\n return \"-\"\n\n def FormatReason(self):\n if \"%\" in self.reason:\n return self.reason % self.args\n else:\n return self.reason.format(*self.args)\n\n def __repr__(self):\n return \"<%s>\" % self.FormatReason()\n\n def __setitem__(self, item, other):\n return\n\n def __format__(self, formatstring):\n \"\"\"We suppress output for all format operators.\"\"\"\n formatstring = formatstring.replace(\"d\", \"s\")\n formatstring = formatstring.replace(\"x\", \"s\")\n formatstring = formatstring.replace(\"#\", \"\")\n return (\"{0:%s}\" % formatstring).format(\"-\")\n\n def write(self, _):\n \"\"\"Write procedure only ever returns False\"\"\"\n return False\n\n # Behave like an empty set\n def __iter__(self):\n return iter([])\n\n def __len__(self):\n return 0\n\n def __getattr__(self, attr):\n # By returning self for any unknown attribute and ensuring the self is\n # callable, we cover both properties and methods Override NotImplemented\n # functions in object with self\n return self\n\n def __bool__(self):\n return False\n\n def __nonzero__(self):\n return False\n\n # Comparisons.\n def __eq__(self, other):\n return other is None\n\n def __ne__(self, other):\n return other is not None\n\n def __gt__(self, _):\n return False\n\n __lt__ = __gt__\n __le__ = __gt__\n __ge__ = __gt__\n\n # Make us subscriptable obj[j]\n def __getitem__(self, item):\n return self\n\n def __call__(self, *arg, **kwargs):\n return self\n\n def __int__(self):\n return -1\n\n __add__ = __call__\n __sub__ = __call__\n __mul__ = __call__\n __floordiv__ = __call__\n __mod__ = __call__\n __div__ = __call__\n __divmod__ = __call__\n __pow__ = __call__\n __lshift__ = __call__\n __rshift__ = __call__\n __and__ = __call__\n __xor__ = __call__\n __or__ = __call__\n\n __radd__ = __call__\n __rsub__ = __call__\n __rmul__ = __call__\n __rfloordiv__ = __call__\n __rmod__ = __call__\n __rdivmod__ = __call__\n __rpow__ = __call__\n __rlshift__ = __call__\n __rrshift__ = __call__\n __rand__ = __call__\n __rxor__ = __call__\n __ror__ = __call__\n\n # Override these methods too.\n dereference_as = __call__\n __getitem__ = __call__\n\n\nclass Error(Exception):\n \"\"\"All object related exceptions come from this one.\"\"\"\n\n\nclass ProfileError(Error):\n \"\"\"Errors in setting the profile.\"\"\"\n\n\nclass BaseObject(object):\n __metaclass__ = registry.UniqueObjectIdMetaclass\n\n obj_parent = NoneObject(\"No parent\")\n obj_name = NoneObject(\"No name\")\n obj_producers = None\n\n # BaseObject implementations may take arbitrary **kwargs. The usual\n # programming pattern is to define the keywords each class takes explicitely\n # as as a generic **kwargs parameter. Then call the baseclass and pass the\n # kwargs down. Any **kwargs which arrive here are not handled, and represent\n # an error in the vtype specifications.\n def __init__(self, type_name=None, offset=0, vm=None, profile=None,\n parent=None, name='', context=None, session=None, **kwargs):\n \"\"\"Constructor for Base object.\n\n Args:\n type_name: The name of the type of this object. This different\n from the class name, since the same class may implement many types\n (e.g. Struct implements every instance in the vtype definition).\n\n offset: The offset within the address space to this object exists.\n\n vm: The address space this object uses to read itself from.\n\n profile: The profile this object may use to dereference other\n types.\n\n parent: The object which created this object.\n\n name: The name of this object.\n\n context: An opaque dict which is passed to all objects created from\n this object. This dict may contain context specific information\n which each derived instance can use.\n\n kwargs: Arbitrary args this object may accept - these can be passed in\n the vtype language definition.\n \"\"\"\n if kwargs:\n session.logging.error(\"Unknown keyword args %s for %s\",\n kwargs, self.__class__.__name__)\n\n if session is None:\n raise RuntimeError(\"Session must be provided\")\n\n if profile is None:\n profile = session.profile\n\n self.obj_type = type_name or self.__class__.__name__\n\n # 64 bit addresses are always sign extended, so we need to clear the top\n # bits.\n self.obj_offset = Pointer.integer_to_address(int(offset or 0))\n self.obj_vm = vm\n self.obj_parent = parent\n self.obj_name = name\n self.obj_profile = profile\n self.obj_context = context or {}\n\n if not session:\n raise ValueError(\"Session must be provided.\")\n\n self.obj_session = session\n self.obj_producers = set()\n\n @utils.safe_property\n def obj_size(self):\n return 0\n\n @utils.safe_property\n def obj_end(self):\n return self.obj_offset + self.obj_size\n\n def GetData(self):\n \"\"\"Returns the raw data of this object.\"\"\"\n return self.obj_vm.read(self.obj_offset, self.obj_size)\n\n @utils.safe_property\n def parents(self):\n \"\"\"Returns all the parents of this object.\"\"\"\n obj = self\n while obj.obj_parent:\n obj = obj.obj_parent\n yield obj\n\n def proxied(self):\n return None\n\n def write(self, value):\n \"\"\"Function for writing the object back to disk\"\"\"\n pass\n\n def __nonzero__(self):\n \"\"\"This method is called when we test the truth value of an Object.\n\n In rekall we consider an object to have True truth value only when it is\n a valid object. Its possible for example to have a Pointer object which\n is not valid - this will have a truth value of False.\n\n You should be testing for validity like this:\n if X:\n # object is valid\n\n Do not test for validity like this:\n\n if int(X) == 0:\n\n or\n\n if X is None:\n .....\n\n the later form is not going to work when X is a NoneObject.\n \"\"\"\n return self.is_valid()\n\n def __eq__(self, other):\n return self.v() == other or (\n # Same object type\n (self.__class__ == other.__class__) and\n\n # Same physical memory backing the two objects. Note that often two\n # objects may exist in different address spaces, but be mapped to\n # the same physical memory. In Rekall we assume these two objects\n # are actually equivalent since they share the same physical memory.\n (self.obj_vm.base == other.obj_vm.base) and\n (self.obj_vm.vtop(self.obj_offset) ==\n other.obj_vm.vtop(other.obj_offset)))\n\n def __hash__(self):\n # This needs to be the same as the object we proxy so that we can mix\n # with native types in sets and dicts. For example:\n # pids = set([1,2,3])\n # if task.UniqueProcessId in pids: ....\n return hash(self.v())\n\n @utils.safe_property\n def indices(self):\n \"\"\"Returns (usually 1) representation(s) of self usable as dict keys.\n\n Using full base objects for indexing can be slow, especially with\n Structs. This method returns a representation of the object that is\n a suitable key - either the value of a primitive type, or the memory\n address of the more complex ones.\n \"\"\"\n return (self.v(),)\n\n @classmethod\n def getproperties(cls):\n \"\"\"Return all members that are intended to represent some data.\"\"\"\n for name in dir(cls):\n candidate = getattr(cls, name)\n if isinstance(candidate, property):\n yield name, candidate\n\n def m(self, memname):\n return NoneObject(\"No member {0}\", memname)\n\n def is_valid(self):\n return True\n\n def deref(self, vm=None):\n \"\"\"An alias for dereference - less to type.\"\"\"\n return self.dereference(vm=vm)\n\n def dereference(self, vm=None):\n _ = vm\n return NoneObject(\"Can't dereference {0}\", self.obj_name)\n\n def reference(self):\n \"\"\"Produces a pointer to this object.\n\n This is the same as the C & operator and is the opposite of deref().\n \"\"\"\n return self.obj_profile.Pointer(value=self.obj_offset, vm=self.obj_vm,\n target=self.obj_type)\n\n def cast(self, type_name=None, vm=None, **kwargs):\n # Allow the caller to also change the offset, overriding the current\n # object.\n offset = kwargs.pop(\"offset\", self.obj_offset)\n profile_obj = kwargs.pop(\"profile\", self.obj_profile)\n\n return profile_obj.Object(\n type_name=type_name or self.obj_type, offset=offset,\n vm=vm or self.obj_vm, parent=self.obj_parent,\n context=self.obj_context, **kwargs)\n\n def v(self, vm=None):\n \"\"\" Do the actual reading and decoding of this member\n\n When vm is specified, we are asked to evaluate this object is another\n address space than the one it was created on. Derived classes should\n allow for this.\n \"\"\"\n _ = vm\n return NoneObject(\"No value for {0}\", self.obj_name)\n\n def __str__(self):\n return utils.SmartStr(unicode(self))\n\n def __unicode__(self):\n fd = StringIO.StringIO()\n ui_renderer = renderer.BaseRenderer.classes[\"TextRenderer\"](\n session=self.obj_session, fd=fd)\n with ui_renderer.start():\n ui_renderer.format(\"{}\", self)\n\n return utils.SmartUnicode(fd.getvalue())\n\n def __repr__(self):\n # Is this a prototype? (See profile.GetPrototype for explanation.)\n if self.obj_offset == 0 and self.obj_name == \"Prototype\":\n return \"%s Prototype\" % self.__class__.__name__\n\n return \"[{0} {1}] @ 0x{2:08X}\".format(\n self.__class__.__name__, self.obj_name,\n self.obj_offset)\n\n def __dir__(self):\n \"\"\"Hide any members with _.\"\"\"\n result = self.__dict__.keys() + dir(self.__class__)\n\n return result\n\n def __format__(self, formatspec):\n if not formatspec:\n formatspec = \"s\"\n\n if formatspec[-1] in \"xdXD\":\n return format(int(self), formatspec)\n\n return object.__format__(self, formatspec)\n\n\ndef CreateMixIn(mixin):\n def make_method(name):\n def method(self, *args, **kw):\n proxied = self.proxied()\n try:\n # Try to coerce the other in case its also a proxied\n # class\n args = list(args)\n args[0] = args[0].proxied()\n except (AttributeError, IndexError):\n pass\n\n try:\n method = getattr(operator, name)\n args = [proxied] + args\n except AttributeError:\n method = getattr(proxied, name)\n\n return method(*args, **kw)\n\n return method\n\n for name in mixin._specials: # pylint: disable=protected-access\n setattr(mixin, name, make_method(name))\n\n\nclass NumericProxyMixIn(object):\n \"\"\" This MixIn implements the numeric protocol \"\"\"\n _specials = [\n # Number protocols\n '__add__', '__sub__', '__mul__',\n '__floordiv__', '__mod__', '__divmod__',\n '__pow__', '__lshift__', '__rshift__',\n '__and__', '__xor__', '__or__', '__div__',\n '__truediv__', '__radd__', '__rsub__',\n '__rmul__', '__rdiv__', '__rtruediv__',\n '__rfloordiv__', '__rmod__', '__rdivmod__',\n '__rpow__', '__rlshift__',\n '__rrshift__', '__rand__', '__rxor__', '__ror__',\n '__neg__', '__pos__',\n '__abs__', '__invert__', '__int__', '__long__',\n '__float__', '__oct__', '__hex__',\n\n # Comparisons\n '__lt__', '__le__', '__eq__', '__ge__', '__gt__', '__index__',\n ]\n\n def __ne__(self, other):\n return not self == other\n\n\nclass StringProxyMixIn(object):\n \"\"\"This MixIn implements proxying for strings.\"\"\"\n _specials = [\n # Comparisons\n '__lt__', '__le__', '__eq__', '__ge__', '__gt__', '__index__',\n ]\n\n def __ne__(self, other):\n return not self == other\n\n\nCreateMixIn(NumericProxyMixIn)\nCreateMixIn(StringProxyMixIn)\n\n\nclass NativeType(NumericProxyMixIn, BaseObject):\n def __init__(self, value=None, format_string=None, session=None,\n profile=None, **kwargs):\n # If a value is specified, we dont technically need a profile at all.\n if value is not None and profile is None:\n profile = NoneObject()\n\n super(NativeType, self).__init__(\n session=session, profile=profile, **kwargs)\n self.format_string = format_string\n if callable(value):\n value = value(self.obj_parent)\n\n self.value = value\n\n def write(self, data):\n \"\"\"Writes the data back into the address space\"\"\"\n output = struct.pack(self.format_string, int(data))\n return self.obj_vm.write(self.obj_offset, output)\n\n def proxied(self):\n return self.v()\n\n def __radd__(self, other):\n return long(other) + self.v()\n\n def __rsub__(self, other):\n return long(other) - self.v()\n\n @utils.safe_property\n def obj_size(self):\n return struct.calcsize(self.format_string)\n\n def v(self, vm=None):\n if self.value is not None:\n return self.value\n\n data = self.obj_vm.read(self.obj_offset, self.obj_size)\n if not data:\n return NoneObject(\"Unable to read {0} bytes from {1}\",\n self.obj_size, self.obj_offset)\n\n # Cache this for next time.\n (self.value,) = struct.unpack(self.format_string, data)\n\n return self.value\n\n def cdecl(self):\n return self.obj_name\n\n def __repr__(self):\n try:\n return \" [{0}:{1}]: 0x{2:08X}\".format(self.obj_type, self.obj_name,\n self.v())\n except ValueError:\n return \" [{0}:{1}]: {2}\".format(self.obj_type, self.obj_name,\n repr(self.v()))\n\n\nclass Bool(NativeType):\n pass\n\n\nclass BitField(NativeType):\n \"\"\" A class splitting an integer into a bunch of bit. \"\"\"\n\n def __init__(self, start_bit=0, end_bit=32, target=None,\n native_type=None, **kwargs):\n super(BitField, self).__init__(**kwargs)\n\n # TODO: Fully deprecate this parameter.\n if native_type:\n target = native_type\n\n self._proxy = self.obj_profile.Object(\n target or \"address\", offset=self.obj_offset, vm=self.obj_vm,\n context=self.obj_context)\n\n self.target = target\n self.start_bit = start_bit\n self.end_bit = end_bit\n self.mask = ((1 << end_bit) - 1) ^ ((1 << start_bit) - 1)\n\n @utils.safe_property\n def obj_size(self):\n return self._proxy.obj_size\n\n def v(self, vm=None):\n i = self._proxy.v()\n return (i & ((1 << self.end_bit) - 1)) >> self.start_bit\n\n def write(self, data):\n # To write we need to read the proxy, set the bits and then write the\n # proxy again.\n return 0\n\n def __repr__(self):\n return \" [{0}({1}-{2}):{3}]: 0x{4:08X}\".format(\n self.obj_type, self.start_bit, self.end_bit, self.obj_name,\n self.v())\n\n def __nonzero__(self):\n return bool(self._proxy.v() & self.mask)\n\n\nclass Pointer(NativeType):\n \"\"\"A pointer reads an 'address' object from the address space.\"\"\"\n\n def __init__(self, target=None, target_args=None, value=None, **kwargs):\n \"\"\"Constructor.\n\n Args:\n target: The name of the target object (A string). We use the profile\n to instantiate it.\n target_args: The target will receive these as kwargs.\n \"\"\"\n super(Pointer, self).__init__(value=value, **kwargs)\n\n if value is not None:\n self.obj_offset = NoneObject(\"No address specified\")\n\n # We parse the address using the profile since address is a different\n # size on different platforms.\n self._proxy = self.obj_profile.Object(\n \"address\", offset=self.obj_offset, value=value,\n vm=self.obj_vm, context=self.obj_context)\n\n # We just hold on to these so we can construct the objects later.\n self.target = target\n self.target_args = target_args or {}\n self.target_size = 0\n self.kwargs = kwargs\n\n @utils.safe_property\n def obj_size(self):\n return self._proxy.obj_size\n\n def v(self, vm=None):\n # 64 bit addresses are always sign extended so we need to clear the top\n # bits.\n return Pointer.integer_to_address(self._proxy.v())\n\n def m(self, attr):\n return self.deref().m(attr)\n\n def write(self, data):\n return self._proxy.write(data)\n\n def __eq__(self, other):\n try:\n # Must use __int__() because int(other) when other is a string will\n # convert it to an integer.\n return Pointer.integer_to_address(other.__int__()) == self.v()\n except (ValueError, AttributeError):\n return False\n\n def is_valid(self):\n \"\"\"Returns if what we are pointing to is valid \"\"\"\n # Null pointers are invalid.\n return self.v() != 0\n\n def __getitem__(self, item):\n \"\"\"Indexing a pointer indexes its target.\n\n Note this is different than C which treats pointers as arrays:\n\n struct foobar *p1;\n struct foobar *p2[];\n\n In C:\n p[1] -> struct foobar\n p[2] -> struct foobar *\n\n In Rekall:\n p[1] -> Not allowed since structs do not have [].\n p[2] -> struct foobar.\n \"\"\"\n res = self.dereference()\n return res[item]\n\n def dereference(self, vm=None):\n offset = self.v()\n\n # Casts into the correct AS:\n vm = vm or self.obj_vm\n\n if offset:\n kwargs = copy.deepcopy(self.target_args)\n kwargs.update(dict(offset=offset, session=self.obj_session,\n vm=vm, profile=self.obj_profile,\n parent=self.obj_parent, name=self.obj_name))\n\n if isinstance(self.target, basestring):\n result = self.obj_profile.Object(\n type_name=self.target,\n context=self.obj_context, **kwargs)\n\n elif callable(self.target):\n result = self.target(**kwargs)\n else:\n # Target not valid, return void.\n result = Void(**kwargs)\n\n if result.is_valid():\n return result\n\n return NoneObject(\"Pointer {0} @ {1} invalid\",\n self.obj_name, self.v())\n\n def __dir__(self):\n return dir(self.dereference())\n\n def cdecl(self):\n return \"Pointer {0}\".format(self.v())\n\n def __nonzero__(self):\n \"\"\"This method is used in comparison operations.\n\n This ideas here is to make it possible to easily write a condition such\n as:\n\n while ptr:\n ...\n ptr += 1\n\n Pointers are considered non-zero if they are invalid (i.e. what they\n point to is not mapped in. This is very subtle and might be the wrong\n choice. Note that if the kernel actually maps the zero page in (which\n can happen in some situations), then a null pointer is actually valid.\n \"\"\"\n return bool(self.is_valid())\n\n def __add__(self, other):\n \"\"\"Return a new pointer advanced by this many positions.\n\n Note that as usual for pointer arithmetic, the pointer moves by steps of\n the size of the target.\n \"\"\"\n # Find out our target size for pointer arithmetics.\n self.target_size = (self.target_size or\n self.obj_profile.Object(self.target).obj_size)\n\n offset = self.obj_offset + int(other) * self.target_size\n if not self.obj_vm.is_valid_address(offset):\n return NoneObject(\"Invalid offset\")\n\n return self.__class__(\n target=self.target, target_args=self.target_args,\n offset=offset, vm=self.obj_vm,\n parent=self.obj_parent, session=self.obj_session,\n context=self.obj_context, profile=self.obj_profile)\n\n def __sub__(self, other):\n if isinstance(other, Pointer):\n if not isinstance(other, self.__class__):\n raise TypeError(\"Can not subtract non related pointers.\")\n\n # Find out our target size for pointer arithmetics.\n self.target_size = (self.target_size or\n self.obj_profile.Object(self.target).obj_size)\n\n return (int(self) - int(other)) / self.target_size\n\n return self.__add__(-other)\n\n def __iadd__(self, other):\n # Increment our own offset.\n self.target_size = (self.target_size or self.target().obj_size)\n self.obj_offset += self.target_size * other\n\n def __repr__(self):\n target = self.v()\n target_name = self.obj_session.address_resolver.format_address(\n target)\n if target_name:\n target_name = \" (%s)\" % target_name[0]\n else:\n target_name = \"\"\n\n return \"<%s %s to [%#010x%s] (%s)>\" % (\n self.target, self.__class__.__name__, target,\n target_name, self.obj_name or '')\n\n def __unicode__(self):\n return u\"Pointer to %s\" % self.deref()\n\n @utils.safe_property\n def indices(self):\n return self.dereference().indices\n\n def __getattr__(self, attr):\n # We just dereference ourself\n result = self.dereference()\n\n return getattr(result, attr)\n\n def __iter__(self):\n \"\"\"Delegate the iterator to the target.\"\"\"\n return iter(self.dereference())\n\n def dereference_as(self, target=None, target_args=None, vm=None,\n profile=None, parent=None):\n \"\"\"Dereference ourselves into another type, or address space.\n\n This method allows callers to explicitly override the setting in the\n profile for this pointer.\n\n Args:\n target: The target to override.\n target_args: The args to instantiate this target with.\n vm: The address space to dereference the pointer in.\n profile: If a new profile should be used to instantiate the target.\n \"\"\"\n vm = vm or self.obj_vm\n\n if profile is None:\n profile = self.obj_profile\n\n return profile.Object(\n type_name=target or self.target, offset=self.v(), vm=vm,\n parent=parent or self.obj_parent, context=self.obj_context,\n **(target_args or {}))\n\n @staticmethod\n def integer_to_address(value):\n \"\"\"Addresses only use 48 bits.\"\"\"\n return 0xffffffffffff & int(value)\n\n\nclass Pointer32(Pointer):\n \"\"\"A 32 bit pointer (Even in 64 bit arch).\n\n These kinds of pointers are used most commonly in the Registry code which\n always treats the hives as 32 bit address spaces.\n \"\"\"\n def __init__(self, **kwargs):\n super(Pointer32, self).__init__(**kwargs)\n self._proxy = self._proxy.cast(\"unsigned int\")\n\n\nclass Void(Pointer):\n def __init__(self, **kwargs):\n kwargs['type_name'] = 'unsigned long'\n super(Void, self).__init__(**kwargs)\n\n def v(self, vm=None):\n return self.obj_offset\n\n def dereference(self, vm=None):\n return NoneObject(\"Void reference\")\n\n @utils.safe_property\n def obj_size(self):\n self.obj_session.logging.warning(\n \"Void objects have no size! Are you doing pointer arithmetic on a \"\n \"pointer to void?\")\n return 1\n\n def cdecl(self):\n return \"0x{0:08X}\".format(self.v())\n\n def __repr__(self):\n return \"Void[{0} {1}] (0x{2:08x})\".format(\n self.__class__.__name__, self.obj_name or '', self.v())\n\n def __nonzero__(self):\n return bool(self.dereference())\n\n\nclass Array(BaseObject):\n \"\"\" An array of objects of the same size \"\"\"\n\n target_size = 0\n\n def __init__(self, count=0, target=None, target_args=None,\n target_size=None, max_count=100000, size=0,\n **kwargs):\n \"\"\"Instantiate an array of like items.\n\n Args:\n count: How many items belong to the array (not strictly enforced -\n i.e. it is possible to read past the end). By default the array is\n unbound.\n\n max_count: The maximum size of the array. This is a safety mechanism\n if count is calculated. max_count should be set to an upper bound on\n the size of the array.\n\n target: The name of the element to be instantiated on each point. The\n size of the object returned by this should be the same for all\n members of the array (i.e. all elements should be the same size).\n\n size: The total size of the Array. If this is nonzero we calculate the\n count so that just the right number of items fit in this specified\n size.\n \"\"\"\n super(Array, self).__init__(**kwargs)\n\n # Allow the count to be callable.\n if callable(count):\n count = count(self.obj_parent)\n\n if callable(target_size):\n target_size = target_size(self.obj_parent)\n\n self.count = count\n self.max_count = max_count\n\n if not target:\n raise AttributeError(\"Array must use a target parameter\")\n\n self.target = target\n self.target_args = target_args or {}\n\n self.target_size = target_size\n if self.target_size is None:\n self.target_size = self.obj_profile.Object(\n self.target, offset=self.obj_offset, vm=self.obj_vm,\n profile=self.obj_profile, parent=self,\n **self.target_args).obj_size\n\n if size > 0:\n self.count = size / self.target_size\n\n @utils.safe_property\n def obj_size(self):\n \"\"\"The size of the entire array.\"\"\"\n return self.target_size * self.count\n\n def __iter__(self):\n # If the array is invalid we do not iterate.\n if not self.obj_vm.is_valid_address(self.obj_offset):\n return\n\n for position in utils.xrange(0, self.count):\n # Since we often calculate array counts it is possible to\n # calculate huge arrays. This will then spin here\n # uncontrollably. We use max_count as a safety to break out\n # early - but we need to ensure that users see we hit this\n # artificial limit.\n if position > self.max_count:\n if self.obj_session.GetParameter(\"debug\"):\n pdb.set_trace()\n\n self.obj_session.logging.warn(\n \"%s Array iteration truncated by max_count!\", self.obj_name)\n break\n\n # We don't want to stop on a NoneObject. Its\n # entirely possible that this array contains a bunch of\n # pointers and some of them may not be valid (or paged\n # in). This should not stop us though we just return the\n # invalid pointers to our callers. It's up to the callers\n # to do what they want with the array.\n yield self[position]\n\n def __repr__(self):\n return \"<{3} {0} x {1} @ 0x{2:08X}>\".format(\n self.count, self.target, self.obj_offset, self.__class__.__name__)\n\n def __unicode__(self):\n result = [repr(self)]\n for i, x in enumerate(self):\n result.append(u\"0x%04X %r\" % (i, x))\n\n if len(result) > 10:\n result.append(u\"... More entries hidden\")\n break\n\n return u\"\\n\".join(result)\n\n def __eq__(self, other):\n if not other or self.count != len(other):\n return False\n\n for i in xrange(self.count):\n if not self[i] == other[i]:\n return False\n\n return True\n\n def __getitem__(self, pos):\n # Check for slice object\n if isinstance(pos, slice):\n start, stop, step = pos.indices(self.count)\n return [self[i] for i in xrange(start, stop, step)]\n\n pos = int(pos)\n offset = self.target_size * pos + self.obj_offset\n context = dict(index=pos)\n context.update(self.obj_context)\n\n return self.obj_profile.Object(\n self.target, offset=offset, vm=self.obj_vm,\n parent=self, profile=self.obj_profile,\n name=\"{0}[{1}] \".format(self.obj_name, pos),\n context=context, **self.target_args)\n\n def __setitem__(self, item, value):\n if isinstance(item, int):\n self[item].write(value)\n else:\n super(Array, self).__setitem__(item, value)\n\n def __len__(self):\n return self.count\n\n\nclass PointerArray(Array):\n \"\"\"This is an optimized Array implementation for arrays of Pointers.\n\n The idea is to decode all pointers at once.\n \"\"\"\n\n def __init__(self, **kwargs):\n super(PointerArray, self).__init__(target=\"Pointer\", **kwargs)\n\n if self.target_size == 8:\n self.format_string = \"<\" + \"Q\" * self.count\n else:\n self.format_string = \"<\" + \"I\" * self.count\n\n # Read all the data\n data = self.obj_vm.read(self.obj_offset, self.target_size * self.count)\n self._data = struct.unpack(self.format_string, data)\n\n def __iter__(self):\n for i in xrange(len(self._data)):\n yield self[i]\n\n def __getitem__(self, pos):\n return self.obj_profile.Pointer(value=self._data[pos], vm=self.obj_vm)\n\n\nclass ListArray(Array):\n \"\"\"An array of structs which do not all have the same size.\"\"\"\n\n def __init__(self, maximum_size=None, maximum_offset=None, **kwargs):\n \"\"\"Constructor.\n\n This array may be initialized using one of the following parameters:\n\n maximum_size: The maximum size of the array in bytes.\n maximum_offset: If we reach this offset iteration is terminated.\n count: The total count of items in this list.\n\n max_count: The maximum size of the array. This is a safety mechanism if\n count is calculated. max_count should be set to an upper bound on the\n size of the array.\n \"\"\"\n super(ListArray, self).__init__(**kwargs)\n if callable(maximum_size):\n maximum_size = int(maximum_size(self.obj_parent))\n\n if callable(maximum_offset):\n maximum_offset = int(maximum_offset(self.obj_parent))\n\n # Check the values for sanity.\n if self.count == 0 and maximum_size is None and maximum_offset is None:\n raise TypeError(\n \"One of count, maximum_offset, maximum_size must be specified.\")\n\n if maximum_size is not None:\n maximum_offset = self.obj_offset + maximum_size\n\n self.maximum_offset = maximum_offset\n\n def __len__(self):\n \"\"\"It is generally too expensive to rely on the count of this array.\"\"\"\n raise NotImplementedError\n\n @utils.safe_property\n def obj_size(self):\n \"\"\"It is generally too expensive to rely on the size of this array.\"\"\"\n raise NotImplementedError\n\n def __iter__(self):\n offset = self.obj_offset\n count = 0\n while 1:\n # Exit conditions.\n if self.maximum_offset and offset > self.maximum_offset:\n break\n\n if self.count and count >= self.count:\n break\n\n if count >= self.max_count:\n self.obj_session.logging.warn(\n \"%s ListArray iteration truncated by max_count!\",\n self.obj_name)\n break\n\n item = self.obj_profile.Object(\n self.target, offset=offset, vm=self.obj_vm, parent=self,\n profile=self.obj_profile, context=self.obj_context,\n name=\"{0}[{1}] \".format(self.obj_name, count),\n **self.target_args)\n\n item_size = item.obj_size\n if item_size <= 0:\n break\n\n offset += item_size\n count += 1\n\n yield item\n\n def __getitem__(self, pos):\n for index, item in enumerate(self):\n if index == int(pos):\n return item\n\n return NoneObject(\"Pos seems to be outside the array maximum_size.\")\n\n\nclass BaseAddressComparisonMixIn(object):\n \"\"\"A mixin providing comparison operators for its base offset.\"\"\"\n\n def __comparator__(self, other, method):\n # 64 bit addresses are always sign extended so we need to clear the top\n # bits.\n try:\n other_address = Pointer.integer_to_address(other.__int__())\n except AttributeError:\n other_address = None\n\n return method(Pointer.integer_to_address(self.__int__()), other_address)\n\n def __eq__(self, other):\n return self.__comparator__(other, operator.__eq__)\n\n def __lt__(self, other):\n return self.__comparator__(other, operator.__lt__)\n\n def __gt__(self, other):\n return self.__comparator__(other, operator.__gt__)\n\n def __le__(self, other):\n return self.__comparator__(other, operator.__le__)\n\n def __ge__(self, other):\n return self.__comparator__(other, operator.__ge__)\n\n def __ne__(self, other):\n return self.__comparator__(other, operator.__ne__)\n\n\nclass Struct(BaseAddressComparisonMixIn, BaseObject):\n \"\"\" A Struct is an object which represents a c struct\n\n Structs have members at various fixed relative offsets from our own base\n offset.\n \"\"\"\n\n def __init__(self, members=None, struct_size=0, callable_members=None,\n **kwargs):\n \"\"\" This must be instantiated with a dict of members. The keys\n are the offsets, the values are Curried Object classes that\n will be instantiated when accessed.\n\n Args:\n members: A dict of callables to use for retrieving each member. (Key\n is member name, value is a callable). Normally these are populated\n by the profile system\n\n struct_size: The size of this struct if known (Can be None).\n \"\"\"\n super(Struct, self).__init__(**kwargs)\n ACCESS_LOG.LogFieldAccess(self.obj_profile.name, self.obj_type, None)\n\n self.members = members or {}\n self.callable_members = callable_members or {}\n self.struct_size = struct_size\n self._cache = {}\n\n def __hash__(self):\n return hash(self.indices)\n\n @utils.safe_property\n def indices(self):\n return (\"%s(%#x, vm=%s@%s)\" % (\n self.obj_type,\n self.obj_offset,\n self.obj_vm.vtop(self.obj_offset),\n self.obj_vm.base,\n ),)\n\n def __long__(self):\n return self.obj_offset\n\n def __int__(self):\n \"\"\"Return our offset as an integer.\n\n This allows us to interchange Struct and offsets.\n \"\"\"\n return self.obj_offset\n\n def preamble_size(self):\n \"\"\"The number of bytes before the object which are part of the object.\n\n Some objects are preceeded with data before obj_offset which is still\n considered part of the object. Note that in that case the size of the\n object includes the preamble_size - hence\n\n object_end = obj_offset + obj_size - obj.preamble_size()\n \"\"\"\n return 0\n\n @utils.safe_property\n def obj_size(self):\n if callable(self.struct_size):\n # We must always return an integer, even if NoneObject is returned\n # from the callable.\n return self.struct_size(self) or 0\n\n return self.struct_size\n\n def __repr__(self):\n if self.obj_offset == 0 and self.obj_name == \"Prototype\":\n return \"%s Prototype\" % self.__class__.__name__\n\n return \"[{0} {1}] @ 0x{2:08X}\".format(\n self.obj_type, self.obj_name or '', self.obj_offset)\n\n def __unicode__(self):\n result = self.__repr__() + \"\\n\"\n width_name = 0\n\n fields = []\n # Print all the fields sorted by offset within the struct.\n for k in set(self.members).union(self.callable_members):\n width_name = max(width_name, len(k))\n obj = getattr(self, k)\n if obj == None:\n obj = self.m(k)\n\n fields.append(\n (getattr(obj, \"obj_offset\", self.obj_offset) -\n self.obj_offset, k, utils.SmartUnicode(repr(obj))))\n\n fields.sort()\n\n return result + u\"\\n\".join(\n [u\" 0x%02X %s%s %s\" % (offset, k, \" \" * (width_name - len(k)), v)\n for offset, k, v in fields]) + \"\\n\"\n\n def v(self, vm=None):\n \"\"\" When a struct is evaluated we just return our offset.\n \"\"\"\n return self.obj_offset\n\n def m(self, attr, allow_callable_attributes=False):\n \"\"\"Fetch the member named by attr.\n\n NOTE: When the member does not exist in this struct, we return a\n NoneObject instance. This allows one to write code such as:\n\n struct.m(\"Field1\") or struct.m(\"Field2\") struct.m(\"Field2\")\n\n To access a field which has been renamed in different OS versions.\n\n By default this method does not allow callable methods specified in\n overlays. This is to enable overriding of normal struct members by\n callable properties (otherwise infinite recursion might occur). If you\n really want to call overlays, specify allow_callable_attributes as True.\n \"\"\"\n # Enable to log struct access.\n # ACCESS_LOG.LogFieldAccess(self.obj_profile.name, self.obj_type, attr)\n result = self._cache.get(attr)\n if result is not None:\n return result\n\n # Allow subfields to be gotten via this function.\n if \".\" in attr:\n result = self\n for sub_attr in attr.split(\".\"):\n if allow_callable_attributes:\n result = getattr(result, sub_attr, None)\n if result is None:\n result = NoneObject(\"Attribute %s not found in %s\",\n sub_attr, self.obj_type)\n else:\n result = result.m(sub_attr)\n self._cache[attr] = result\n return result\n\n element = self.members.get(attr)\n if element is not None:\n # Allow the element to be a callable rather than a list - this is\n # useful for aliasing member names\n if callable(element):\n return element(self)\n\n offset, cls = element\n else:\n return NoneObject(u\"Struct {0} has no member {1}\",\n self.obj_name, attr)\n\n if callable(offset):\n # If offset is specified as a callable its an absolute\n # offset\n offset = int(offset(self))\n else:\n # Otherwise its relative to the start of our struct\n offset = int(offset) + int(self.obj_offset)\n\n try:\n result = cls(offset=offset, vm=self.obj_vm, parent=self, name=attr,\n profile=self.obj_profile, context=self.obj_context)\n except Error as e:\n result = NoneObject(str(e))\n\n self._cache[attr] = result\n return result\n\n def multi_m(self, *args, **opts):\n \"\"\"Retrieve a set of fields in order.\n\n If a field is not found, then try the next field in the list until one\n field works. This approach allows us to propose a set of possible fields\n for an attribute to support renaming of struct fields in different\n versions.\n \"\"\"\n allow_callable_attributes = opts.pop(\"allow_callable_attributes\", True)\n for field in args:\n result = self.m(\n field, allow_callable_attributes=allow_callable_attributes)\n if result != None:\n return result\n\n return NoneObject(\"No fields were found.\")\n\n def __getattr__(self, attr):\n result = self.m(attr)\n if result == None:\n raise AttributeError(attr)\n\n return result\n\n def SetMember(self, attr, value):\n \"\"\"Write a value to a member.\"\"\"\n member = self.m(attr)\n # Try to make the member write the new value.\n member.write(value)\n if not hasattr(member, 'write') or not member.write(value):\n raise ValueError(\"Error writing value to member \" + attr)\n\n def walk_list(self, list_member, include_current=True, deref_as=None):\n \"\"\"Walk a single linked list in this struct.\n\n The current object can be optionally yielded as the first element.\n\n Args:\n list_member: The member name which points to the next item in the\n list.\n \"\"\"\n if include_current:\n yield self\n\n seen = set()\n seen.add(self.obj_offset)\n\n item = self\n while True:\n if deref_as:\n item = getattr(item, list_member).dereference_as(deref_as)\n else:\n item = getattr(item, list_member).deref()\n\n # Sometimes in usermode page 0 is mapped, hence bool(item) == True\n # even if item == 0 since bool(item) refers to the pointer's\n # validity.\n if not item or item == 0 or item.obj_offset in seen:\n break\n\n seen.add(item.obj_offset)\n yield item\n\n# Profiles are the interface for creating/interpreting\n# objects\n\nclass ProfileSectionLoader(object):\n \"\"\"A loader for a section in the profile JSON file.\n\n The profile json serialization contains a number of sections, each has a\n well known name (e.g. $CONSTANTS, $FUNCTIONS, $STRUCT). When a profile class\n is initialized, it uses a variety of loaders to handle each section in the\n profile. This allows more complex sections to be introduced and extended.\n \"\"\"\n __metaclass__ = registry.MetaclassRegistry\n __abstract = True\n order = 100\n\n def LoadIntoProfile(self, session, profile, data):\n \"\"\"Loads the data into the profile.\"\"\"\n _ = session, data\n return profile\n\n\n# Some standard profile Loaders.\nclass MetadataProfileSectionLoader(ProfileSectionLoader):\n name = \"$METADATA\"\n order = 1\n\n def LoadIntoProfile(self, session, profile, metadata):\n if profile is not None:\n return profile\n\n profile_type = metadata.get(\"Type\", \"Profile\")\n\n # Support a symlink profile - this is a profile which is a short,\n # human meaningful name for another profile.\n if profile_type == \"Symlink\":\n return session.LoadProfile(metadata.get(\"Target\"))\n\n possible_implementations = [metadata.get(\"ProfileClass\", profile_type)]\n\n # For windows profile we can use a generic PE profile\n # implementation.\n if \"GUID_AGE\" in metadata:\n possible_implementations.append(\"BasicPEProfile\")\n\n if \"PDBFile\" in metadata:\n possible_class_name = metadata[\"PDBFile\"].capitalize().split(\".\")[0]\n possible_implementations.insert(0, possible_class_name)\n\n for impl in possible_implementations:\n profile_cls = Profile.ImplementationByClass(impl)\n if profile_cls:\n break\n\n if profile_cls is None:\n session.logging.warn(\"No profile implementation class %s\" %\n metadata[\"ProfileClass\"])\n\n raise ProfileError(\n \"No profile implementation class %s\" %\n metadata[\"ProfileClass\"])\n\n result = profile_cls(session=session, metadata=metadata)\n\n return result\n\n\nclass ConstantProfileSectionLoader(ProfileSectionLoader):\n name = \"$CONSTANTS\"\n\n def LoadIntoProfile(self, session, profile, constants):\n profile.add_constants(constants_are_addresses=True, constants=constants)\n return profile\n\n\nclass ConstantTypeProfileSectionLoader(ProfileSectionLoader):\n name = \"$CONSTANT_TYPES\"\n\n def LoadIntoProfile(self, session, profile, constant_types):\n profile.constant_types.update(constant_types)\n return profile\n\n\nclass FunctionsProfileSectionLoader(ConstantProfileSectionLoader):\n name = \"$FUNCTIONS\"\n\n\nclass EnumProfileSectionLoader(ProfileSectionLoader):\n name = \"$ENUMS\"\n\n def LoadIntoProfile(self, session, profile, enums):\n profile.add_enums(**enums)\n return profile\n\n\nclass ReverseEnumProfileSectionLoader(ProfileSectionLoader):\n name = \"$REVENUMS\"\n\n def LoadIntoProfile(self, session, profile, reverse_enums):\n profile.add_reverse_enums(**reverse_enums)\n return profile\n\n\nclass StructProfileLoader(ProfileSectionLoader):\n name = \"$STRUCTS\"\n\n def LoadIntoProfile(self, session, profile, types):\n profile.add_types(types)\n return profile\n\n\nclass MergeProfileLoader(ProfileSectionLoader):\n \"\"\"This section specifies a list of profiles to be merged into this one.\"\"\"\n name = \"$MERGE\"\n\n def LoadIntoProfile(self, session, profile, merge_list):\n for merge_target in merge_list:\n merge_profile = session.LoadProfile(merge_target)\n if merge_profile.data:\n profile.LoadProfileFromData(\n merge_profile.data, session=session, profile=profile)\n\n return profile\n\nclass DummyAS(object):\n name = 'dummy'\n volatile = False\n\n def __init__(self, session):\n self.session = session\n\n def is_valid_address(self, _offset):\n return True\n\n def read(self, _, length):\n return \"\\x00\" * length\n\n\nclass Profile(object):\n \"\"\"A collection of types relating to a single compilation unit.\n\n Profiles are usually not instantiated directly. Rather, the profiles are\n loaded from the profile repository using the session.LoadProfile() method.\n \"\"\"\n # This is the list of overlays to be applied to the vtypes when compiling\n # into types.\n overlays = None\n\n # These are the vtypes - they are just a dictionary describing the types\n # using the \"vtype\" language. This dictionary will be compiled into\n # executable code and placed into self.types.\n vtypes = None\n\n # This hold the executable code compiled from the vtypes above.\n types = None\n\n # This is the base class for all profiles.\n __metaclass__ = registry.MetaclassRegistry\n\n # This is a dict of constants\n constants = None\n\n # This is a record of all the modification classes that were applied to this\n # profile.\n applied_modifications = None\n\n # An empty type descriptor.\n EMPTY_DESCRIPTOR = [0, {}]\n\n # The metadata for this profile. This should be specified by derived\n # classes. It is OK To put a (mutable) dict in here. It will not be\n # directly modified by anything.\n METADATA = {}\n\n # The constructor will build this dict of metadata by copying the values\n # from METADATA here.\n _metadata = None\n\n @classmethod\n def LoadProfileFromData(cls, data, session=None, name=None, profile=None):\n \"\"\"Creates a profile directly from a JSON object.\n\n Args:\n data: A data structure of an encoded profile. Described:\n http://www.rekall-forensic.com/docs/development.html#_profile_serializations\n session: A Session object.\n name: The name of the profile.\n profile: An optional initial profile to apply the new sections to. If\n None we create a new profile instance according to the $METADATA\n section.\n\n Returns:\n a Profile() instance.\n\n Raises:\n IOError if we can not load the profile.\n\n \"\"\"\n if \"$METADATA\" not in data:\n data[\"$METADATA\"] = {}\n\n # Data is a dict with sections as keys.\n handlers = []\n for section in data:\n try:\n handlers.append(\n ProfileSectionLoader.classes_by_name[section][0])\n except KeyError:\n # This is not fatal in order to allow new sections to be safely\n # introduced to older binaries.\n session.logging.warn(\n \"Unable to parse profile section %s\", section)\n\n # Sort the handlers in order:\n handlers.sort(key=lambda x: x.order)\n\n # Delegate profile creation to the loaders.\n for handler in handlers:\n profile = handler().LoadIntoProfile(\n session, profile, data[handler.name])\n\n if profile and name:\n profile.name = name\n profile.data = data\n\n return profile\n\n # The common classes that are provided by the object framework. Plugins can\n # extend the framework by registering additional classes here - these\n # classes will be available everywhere profiles are used.\n COMMON_CLASSES = {'BitField': BitField,\n 'Pointer': Pointer,\n 'Pointer32': Pointer32,\n 'Void': Void,\n 'void': Void,\n 'Array': Array,\n 'PointerArray': PointerArray,\n 'ListArray': ListArray,\n 'NativeType': NativeType,\n 'Struct': Struct}\n\n @classmethod\n def Initialize(cls, profile):\n \"\"\"Install required types, classes and constants.\n\n This method should be extended by derived classes. It is a class method\n to allow other profiles to call this method and install the various\n components into their own profiles.\n \"\"\"\n # Basic types used in all profiles.\n profile.add_classes(cls.COMMON_CLASSES)\n\n profile._initialized = True # pylint: disable=protected-access\n\n def __init__(self, name=None, session=None, metadata=None, **kwargs):\n if kwargs:\n session.logging.error(\"Unknown keyword args %s\", kwargs)\n\n if name is None:\n name = self.__class__.__name__\n\n self._metadata = self.METADATA.copy()\n for basecls in reversed(self.__class__.__mro__):\n self._metadata.update(getattr(basecls, \"METADATA\", {}))\n\n self._metadata.update(metadata or {})\n\n self.name = unicode(name)\n self.session = session\n if session is None:\n raise RuntimeError(\"Session must be specified.\")\n\n self.overlays = []\n self.vtypes = {}\n self.constants = {}\n\n # A map from symbol names to the types at that symbol. Key: Symbol name,\n # Value: (target, target_args).\n self.constant_types = {}\n self.constant_addresses = utils.SortedCollection(key=lambda x: x[0])\n self.enums = {}\n self.reverse_enums = {}\n self.applied_modifications = set()\n self.object_classes = {}\n\n # The original JSON data this profile is loaded from.\n self.data = None\n\n # Keep track of all the known types so we can command line complete.\n self.known_types = set()\n\n # This is the local cache of compiled expressions.\n self.flush_cache()\n\n # Call Initialize on demand.\n self._initialized = False\n\n def EnsureInitialized(self):\n if not self._initialized:\n self.Initialize(self)\n\n def flush_cache(self):\n self.types = {}\n\n def copy(self):\n \"\"\"Makes a copy of this profile.\"\"\"\n self.EnsureInitialized()\n\n # pylint: disable=protected-access\n result = self.__class__(name=self.name, session=self.session)\n result.vtypes = self.vtypes.copy()\n result.overlays = self.overlays[:]\n result.enums = self.enums.copy()\n result.reverse_enums = self.reverse_enums.copy()\n result.constants = self.constants.copy()\n result.constant_types = self.constant_types.copy()\n result.constant_addresses = self.constant_addresses.copy()\n\n # Object classes are shallow dicts.\n result.object_classes = self.object_classes.copy()\n result._initialized = self._initialized\n result.known_types = self.known_types.copy()\n result._metadata = self._metadata.copy()\n # pylint: enable=protected-access\n\n return result\n\n def merge(self, other):\n \"\"\"Merges another profile into this one.\n\n The result is that we are able to parse all the types that the other\n profile has.\n \"\"\"\n other.EnsureInitialized()\n\n self.vtypes.update(other.vtypes)\n self.overlays += other.overlays\n self.constants.update(other.constants)\n self.object_classes.update(other.object_classes)\n self.flush_cache()\n self.enums.update(other.enums)\n self.name = u\"%s + %s\" % (self.name, other.name)\n\n # Merge in the other's profile metadata which is not in this profile.\n metadata = other._metadata.copy() # pylint: disable=protected-access\n metadata.update(self._metadata)\n self._metadata = metadata\n\n def merge_symbols(self, other, *args):\n for arg in args:\n if arg in other.vtypes:\n self.vtypes[arg] = other.vtypes[arg]\n\n if arg in other.overlays:\n self.overlays[arg] = other.overlays[arg]\n\n if arg in other.object_classes:\n self.object_classes[arg] = other.object_classes[arg]\n\n self.flush_cache()\n\n def metadata(self, name, default=None):\n \"\"\"Obtain metadata about this profile.\"\"\"\n self.EnsureInitialized()\n return self._metadata.get(name, default)\n\n def set_metadata(self, name, value):\n self._metadata[name] = value\n\n def metadatas(self, *args):\n \"\"\"Obtain metadata about this profile.\"\"\"\n self.EnsureInitialized()\n return tuple([self._metadata.get(x) for x in args])\n\n def has_type(self, type_name):\n # Make sure we are initialized on demand.\n self.EnsureInitialized()\n return type_name in self.vtypes\n\n def has_class(self, class_name):\n # Make sure we are initialized on demand.\n self.EnsureInitialized()\n return class_name in self.object_classes\n\n def add_classes(self, classes_dict=None, **kwargs):\n \"\"\"Add the classes in the dict to our object classes mapping.\"\"\"\n self.flush_cache()\n\n if classes_dict:\n self.object_classes.update(classes_dict)\n\n self.object_classes.update(kwargs)\n self.known_types.update(kwargs)\n\n def add_constant_type(self, constant, target, target_args):\n self.flush_cache()\n self.constant_types[constant] = (target, target_args)\n\n def add_constants(self, constants=None, constants_are_addresses=False, **_):\n \"\"\"Add the kwargs as constants for this profile.\"\"\"\n self.flush_cache()\n\n for k, v in constants.iteritems():\n k = intern(str(k))\n self.constants[k] = v\n if constants_are_addresses:\n try:\n # We need to interpret the value as a pointer.\n address = Pointer.integer_to_address(v)\n existing_value = self.constant_addresses.get(address)\n if existing_value is None:\n self.constant_addresses[address] = k\n elif isinstance(existing_value, list):\n if k not in existing_value:\n existing_value.append(k)\n elif existing_value != k:\n self.constant_addresses[address] = [\n existing_value, k]\n except ValueError:\n pass\n\n def add_reverse_enums(self, **kwargs):\n \"\"\"Add the kwargs as a reverse enum for this profile.\"\"\"\n for k, v in kwargs.iteritems():\n self.reverse_enums[intern(str(k))] = intern(str(v))\n\n def add_enums(self, **kwargs):\n \"\"\"Add the kwargs as an enum for this profile.\"\"\"\n # Alas JSON converts integer keys to strings.\n for k, v in kwargs.iteritems():\n self.enums[intern(str(k))] = enum_definition = {}\n for enum, name in v.items():\n enum_definition[intern(str(enum))] = name\n\n def add_types(self, abstract_types):\n self.flush_cache()\n\n abstract_types = utils.InternObject(abstract_types)\n self.known_types.update(abstract_types)\n\n # we merge the abstract_types with self.vtypes and then recompile\n # the whole thing again. This is essential because\n # definitions may have changed as a result of this call, and\n # we store curried objects (which might keep their previous\n # definitions).\n for k, v in abstract_types.items():\n if isinstance(v, list):\n self.vtypes[k] = v\n\n else:\n original = self.vtypes.get(k, self.EMPTY_DESCRIPTOR)\n original[1].update(v[1])\n if v[0]:\n original[0] = v[0]\n\n self.vtypes[k] = original\n\n def compile_type(self, type_name):\n \"\"\"Compile the specific type and ensure it exists in the type cache.\n\n The type_name here is a reference to the vtypes which are loaded into\n the profile.\n \"\"\"\n # Make sure we are initialized on demand.\n self.EnsureInitialized()\n if type_name in self.types:\n return\n\n original_type_descriptor = type_descriptor = copy.deepcopy(\n self.vtypes.get(type_name, self.EMPTY_DESCRIPTOR))\n\n for overlay in self.overlays:\n type_overlay = copy.deepcopy(overlay.get(type_name))\n type_descriptor = self._apply_type_overlay(\n type_descriptor, type_overlay)\n\n # An overlay which specifies a string as a definition is simply an alias\n # for another struct. We just copy the old struct in place of the\n # aliased one.\n if isinstance(type_descriptor, str):\n self.compile_type(type_descriptor)\n self.types[type_name] = self.types[type_descriptor]\n type_descriptor = self.vtypes[type_descriptor]\n\n if type_descriptor == self.EMPTY_DESCRIPTOR:\n # Mark that this is a pure object - not described by a\n # vtype. E.g. it is purely a class.\n self.types[type_name] = None\n\n else:\n # Now type_overlay will have all the overlays applied on it.\n members = {}\n callable_members = {}\n\n size, field_description = type_descriptor\n\n for k, v in field_description.items():\n k = str(k)\n\n # If the overlay specifies a callable, we place it in the\n # callable_members dict, and revert back to the vtype\n # definition.\n if callable(v):\n callable_members[intern(k)] = v\n\n # If the callable is masking an existing field, revert back\n # to it.\n original_v = original_type_descriptor[1].get(k)\n if original_v:\n members[intern(k)] = (\n original_v[0], self.list_to_type(k, original_v[1]))\n\n elif v[0] == None:\n self.session.logging.warning(\n \"%s has no offset in object %s. Check that vtypes \"\n \"has a concrete definition for it.\",\n k, type_name)\n else:\n members[intern(str(k))] = (\n v[0], self.list_to_type(k, v[1]))\n\n # Allow the class plugins to override the class constructor here\n cls = self.object_classes.get(type_name, Struct)\n\n self.types[intern(str(type_name))] = self._make_struct_callable(\n cls, type_name, members, size, callable_members)\n\n def _make_struct_callable(self, cls, type_name, members, size,\n callable_members):\n \"\"\"Compile the structs class into a callable.\n\n For write support we would like to add a __setattr__ on the struct\n classes. However, in python, once there is a __setattr__ method\n defined on an object, _EVERY_ setattr() operation on the object will\n go through this method - this is a performance killer. Since in this\n case we only want to trap accesses to the member fields, we can create\n a class with @property methods to get and set the attributes. We then\n overlay this class over the original struct class.\n\n The resulting callable will instantiate the derived class (with the\n additional properties) over the provided offset.\n\n Note that due to the JIT compiler, this method is called only once when\n each Struct object is first accessed, so it is not really\n expensive. OTOH the callables we produce here are called many many times\n (Each time the object is instantiated, or a field is accessed) and need\n to be as fast as possible.\n \"\"\"\n # Note that lambdas below must get external parameters through default\n # args:\n # http://stackoverflow.com/questions/938429/scope-of-python-lambda-functions-and-their-parameters/938493#938493\n\n properties = dict(callable_members=callable_members.keys())\n for name in set(members).union(callable_members):\n\n # Do not mask hand written methods with autogenerated properties.\n if hasattr(cls, name):\n continue\n\n cb = callable_members.get(name)\n value = members.get(name)\n\n getter = None\n setter = None\n\n # This happens if the overlay specifies a callable. In that case we\n # install a special property which calls it. However, the callable\n # may still refer to self.m() to get the bare vtype item.\n if cb:\n # Only implement getter for callable fields since setters do\n # not really make sense.\n def CbGetter(self, cb=cb):\n try:\n return cb(self)\n except Exception as e:\n return NoneObject(\"Failed to run callback %s\" % e)\n\n getter = CbGetter\n\n elif value:\n # Specify both getters and setter for the field.\n getter = lambda self, name=name: self.m(name)\n setter = lambda self, v=value, n=name: self.SetMember(n, v)\n\n properties[name] = utils.safe_property(getter, setter, None, name)\n\n # Extend the provided class by attaching the properties to it. We can\n # not just monkeypatch here because cls will be shared between all\n # structs which do not define an explicit extension class. By creating a\n # new temporary class this uses the usual inheritance behaviour to\n # override the methods in cls depending on the members dict, without\n # altering the cls class permanently (This is a kind of metaclass\n # programming).\n derived_cls = type(str(type_name), (cls,), properties)\n\n return Curry(derived_cls,\n type_name=type_name, members=members,\n callable_members=callable_members, struct_size=size)\n\n def legacy_field_descriptor(self, typeList):\n \"\"\"Converts the list expression into a target, target_args notation.\n\n Legacy vtypes use lists to specify the objects. This function is used to\n convert from the legacy format to the more accurate modern\n format. Hopefully the legacy format can be deprecated at some point.\n\n Args:\n typeList: A list of types. e.g. ['pointer64', ['_HMAP_TABLE']]\n\n Returns:\n A target, target_args tuple. Target is the class name which should be\n instantiated, while target_args is a dict of args to be passed to\n this class.\n e.g. 'Pointer', {target=\"_HMAP_TABLE\"}\n \"\"\"\n # This is of the form [ '_HMAP_TABLE' ] - First element is the target\n # name, with no args.\n if len(typeList) == 1:\n target = typeList[0]\n target_args = {}\n\n # This is of the form [ 'pointer' , [ 'foobar' ]]\n # Target is the first item, args is the second item.\n elif typeList[0] == 'pointer' or typeList[0] == 'pointer64':\n target = \"Pointer\"\n target_args = self.legacy_field_descriptor(typeList[1])\n\n # This is an array: [ 'array', count, ['foobar'] ]\n elif typeList[0] == 'array':\n target = \"Array\"\n target_args = self.legacy_field_descriptor(typeList[2])\n target_args['count'] = typeList[1]\n\n elif len(typeList) > 2:\n self.session.logging.error(\"Invalid typeList %s\" % (typeList,))\n\n else:\n target = typeList[0]\n target_args = typeList[1]\n\n return dict(target=target, target_args=target_args)\n\n def list_to_type(self, name, typeList):\n \"\"\"Parses a specification list and returns a VType object.\n\n This function is a bit complex because we support lots of\n different list types for backwards compatibility.\n\n This is the core function which effectively parses the VType language.\n \"\"\"\n # Convert legacy typeList expressions to the modern format.\n target_spec = self.legacy_field_descriptor(typeList)\n\n # The modern format uses a target, target_args notation.\n target = target_spec['target']\n target_args = target_spec['target_args']\n\n # This is currently the recommended way to specify a type:\n # e.g. [ 'Pointer', {target=\"int\"}]\n if isinstance(target_args, dict):\n return Curry(self.Object, type_name=target, name=name,\n **target_args)\n\n # This is of the deprecated form ['class_name', ['arg1', 'arg2']].\n # Since the object framework moved to purely keyword args these are\n # meaningless. Issue a deprecation warning.\n elif isinstance(target_args, list):\n self.session.logging.warning(\n \"Deprecated vtype expression %s for member %s, assuming int\",\n typeList, name)\n\n else:\n # If we get here we have no idea what this list is\n self.session.logging.warning(\n \"Unable to find a type for %s, assuming int\", typeList)\n\n return Curry(self.Object, type_name='int', name=name)\n\n def GetPrototype(self, type_name):\n \"\"\"Return a prototype of objects of type 'type_name'.\n\n A prototype is a dummy object that looks like a type, but uses data\n from the profile to provide a list of members and type information.\n \"\"\"\n self.compile_type(type_name)\n return self.Object(type_name=type_name, name=\"Prototype\",\n vm=DummyAS(self.session))\n\n def get_obj_offset(self, name, member):\n \"\"\" Returns a member's offset within the struct.\n\n Note that this can be wrong if the offset is a callable.\n \"\"\"\n ACCESS_LOG.LogFieldAccess(self.name, name, member)\n\n tmp = self.GetPrototype(name)\n return tmp.members.get(member, NoneObject(\"No member\"))[0]\n\n def get_obj_size(self, name):\n \"\"\"Returns the size of a struct\"\"\"\n tmp = self.GetPrototype(name)\n return tmp.obj_size\n\n def obj_has_member(self, name, member):\n \"\"\"Returns whether an object has a certain member\"\"\"\n ACCESS_LOG.LogFieldAccess(self.name, name, member)\n\n tmp = self.GetPrototype(name)\n return hasattr(tmp, member)\n\n def add_overlay(self, overlay):\n \"\"\"Add an overlay to the current overlay stack.\"\"\"\n self.flush_cache()\n self.overlays.append(copy.deepcopy(overlay))\n self.known_types.update(overlay)\n\n def _apply_type_overlay(self, type_member, overlay):\n \"\"\"Update the overlay with the missing information from type.\n\n If overlay has None in any slot it gets applied from vtype.\n\n Args:\n type_member: A descriptor for a single type struct. This is always of\n the following form:\n\n [StructSize, {\n field_name_1: [.... Field descriptor ...],\n field_name_2: [.... Field descriptor ...],\n }]\n\n overlay: An overlay descriptor for the same type described by\n type_member or a callable which will be used to instantiate the\n required type.\n \"\"\"\n # A None in the overlay allows the vtype to bubble up.\n if overlay is None:\n return type_member\n\n if type_member is None:\n return overlay\n\n # this allows the overlay to just specify a class directly to be\n # instantiated for a particular type.\n if callable(overlay):\n return overlay\n\n # A base string means its an alias of another type.\n if isinstance(overlay, basestring):\n return overlay\n\n # Check the overlay and type descriptor for sanity.\n if len(overlay) != 2 or not isinstance(overlay[1], dict):\n raise RuntimeError(\"Overlay error: Invalid overlay %s\" % overlay)\n\n if len(type_member) != 2 or not isinstance(type_member[1], dict):\n raise RuntimeError(\"VType error: Invalid type descriptor %s\" %\n type_member)\n\n # Allow the overlay to override the struct size.\n if overlay[0] is None:\n overlay[0] = type_member[0]\n\n # The field overlay describes each field in the struct.\n field_overlay = overlay[1]\n\n # Now go over all the fields in the type_member and copy them into the\n # overlay.\n for k, v in type_member[1].items():\n if k not in field_overlay:\n field_overlay[k] = v\n else:\n field_overlay[k] = self._apply_field_overlay(\n v, field_overlay[k])\n\n return overlay\n\n def _apply_field_overlay(self, field_member, field_overlay):\n \"\"\"Update the field overlay with the missing information from type.\n\n If the overlay has None in any slot it gets applied from vtype.\n\n Args:\n field_member: A field descriptor. This can be of the modern form:\n\n [Offset, [TargetName, dict(arg1=value1, arg2=value2)]]\n\n The second part is termed the field descriptor. If the overlay\n specifies a field descriptor it will completely replace the\n vtype's descriptor.\n\n Alternatively we also support the legacy form:\n [TargetName, [values]]\n\n\n Note that if the Target name differs we deem the entire field to\n be overlayed and replace the entire definition with the overlayed\n one.\n\n field_overlay: Can be a field descriptor as above, or a callable - in\n which case this field member will be called when the field is\n accessed.\n \"\"\"\n # A None in the overlay allows the vtype to bubble up.\n if field_overlay is None:\n return field_member\n\n if callable(field_overlay):\n return field_overlay\n\n if callable(field_member):\n return field_member\n\n # Check the overlay and type descriptor for sanity.\n if len(field_overlay) != 2 or not isinstance(field_overlay[1], list):\n raise RuntimeError(\n \"Overlay error: Invalid overlay %s\" % field_overlay)\n\n if len(field_member) != 2 or not isinstance(field_member[1], list):\n raise RuntimeError(\"VType error: Invalid field type descriptor %s\" %\n field_member)\n\n offset, field_description = field_member\n if field_overlay[0] is None:\n field_overlay[0] = offset\n\n if field_overlay[1] is None:\n field_overlay[1] = field_description\n\n return field_overlay\n\n def get_constant(self, constant, is_address=False):\n \"\"\"Retrieve a constant from the profile.\n\n Args:\n constant: The name of the constant to retrieve.\n\n is_address: If true the constant is converted to an address.\n \"\"\"\n ACCESS_LOG.LogConstant(self.name, constant)\n self.EnsureInitialized()\n\n result = self.constants.get(constant)\n if callable(result):\n result = result()\n\n if result is None:\n result = NoneObject(\n \"Constant %s does not exist in profile.\" % constant)\n\n elif is_address:\n result = Pointer.integer_to_address(result)\n\n return result\n\n def get_constant_object(self, constant, target=None, target_args=None,\n vm=None, **kwargs):\n \"\"\"A help function for retrieving pointers from the symbol table.\"\"\"\n self.EnsureInitialized()\n\n if vm is None:\n vm = self.session.GetParameter(\"default_address_space\")\n\n if target is None:\n if constant not in self.constant_types:\n raise TypeError(\"Unknown constant type for %s\" % constant)\n\n # target_args are optional in the profile specification.\n try:\n target, target_args = self.constant_types[constant]\n except ValueError:\n target = self.constant_types[constant][0]\n\n kwargs.update(target_args or {})\n offset = self.get_constant(constant, is_address=True)\n if not offset:\n return offset\n\n result = self.Object(target, profile=self, offset=offset, vm=vm,\n **kwargs)\n return result\n\n def get_constant_by_address(self, address):\n self.EnsureInitialized()\n\n address = Pointer.integer_to_address(address)\n\n lowest_eq, name = self.get_nearest_constant_by_address(address)\n if lowest_eq != address:\n return NoneObject(\"Constant not found\")\n\n return name\n\n def get_nearest_constant_by_address(self, address, below=True):\n \"\"\"Returns the closest constant below or equal to the address.\"\"\"\n self.EnsureInitialized()\n\n address = Pointer.integer_to_address(address)\n\n if below:\n offset, names = self.constant_addresses.get_value_smaller_than(\n address)\n else:\n offset, names = self.constant_addresses.get_value_larger_than(\n address)\n\n if offset is None:\n return -1, NoneObject(\"Constant not found\")\n\n if not isinstance(names, list):\n names = [names]\n\n return offset, names\n\n def get_enum(self, enum_name, field=None):\n result = self.enums.get(enum_name)\n if result and field != None:\n result = result.get(field)\n return result\n\n def get_reverse_enum(self, enum_name, field=None):\n result = self.reverse_enums.get(enum_name)\n if result and field != None:\n result = result.get(field)\n return result\n\n def __dir__(self):\n \"\"\"Support tab completion.\"\"\"\n return sorted(self.__dict__.keys() + list(self.known_types) +\n dir(self.__class__))\n\n def __getattr__(self, attr):\n \"\"\"Make it easier to instantiate individual members.\n\n This method makes it possible to use the form:\n\n self.profile._EPROCESS(vm=self.kernel_address_space, offset=X)\n\n Which is easier to type and works well with attribute completion\n (provided by __dir__).\n \"\"\"\n self.compile_type(attr)\n\n if self.types[attr] is None and attr not in self.object_classes:\n raise AttributeError(\"No such vtype: %s\" % attr)\n\n return Curry(self.Object, attr)\n\n def Object(self, type_name=None, offset=None, vm=None, name=None,\n parent=None, context=None, **kwargs):\n \"\"\" A function which instantiates the object named in type_name (as\n a string) from the type in profile passing optional args of\n kwargs.\n\n Args:\n type_name: The name of the Struct to instantiate (e.g. _EPROCESS).\n\n vm: The address space to instantiate the object onto. If not provided\n we use a dummy null padded address space.\n\n offset: The location in the address space where the object is\n instantiated.\n\n name: An optional name for the object.\n\n context: An opaque dict which is passed to all objects created from\n this object.\n\n parent: The object can maintain a reference to its parent object.\n \"\"\"\n name = name or type_name\n\n # Ensure we are called correctly.\n if name.__class__ not in (unicode, str):\n raise ValueError(\"Type name must be a string\")\n\n if offset is None:\n offset = 0\n if vm is None:\n vm = addrspace.BaseAddressSpace.classes[\"DummyAddressSpace\"](\n size=self.get_obj_size(name) or 0, session=self.session)\n\n else:\n offset = int(offset)\n if vm is None:\n vm = self.session.GetParameter(\"default_address_space\")\n\n kwargs['profile'] = self\n kwargs.setdefault(\"session\", self.session)\n\n # Compile the type on demand.\n self.compile_type(type_name)\n\n # If the cache contains a None, this member is not represented by a\n # vtype (it might be a pure object class or a constant).\n cls = self.types[type_name]\n if cls is not None:\n result = cls(offset=offset, vm=vm, name=name,\n parent=parent, context=context,\n **kwargs)\n\n return result\n\n elif type_name in self.object_classes:\n result = self.object_classes[type_name](\n type_name=type_name,\n offset=offset,\n vm=vm,\n name=name,\n parent=parent,\n context=context,\n **kwargs)\n\n if isinstance(result, Struct):\n # This should not normally happen.\n self.session.logging.error(\n \"Instantiating a Struct class %s without an overlay. \"\n \"Please ensure an overlay is defined.\", type_name)\n\n return result\n\n else:\n # If we get here we have no idea what the type is supposed to be?\n return NoneObject(\"Cant find object %s in profile %s?\",\n type_name, self)\n\n def __unicode__(self):\n return u\"<%s profile %s (%s)>\" % (\n self.metadata(\"arch\"), self.name, self.__class__.__name__)\n\n def __repr__(self):\n return unicode(self)\n\n def integer_to_address(self, virtual_address):\n return virtual_address & self.constants.get(\n \"MaxPointer\", 0xffffffffffff)\n\n\nclass TestProfile(Profile):\n def _SetupProfileFromData(self, data):\n \"\"\"Let the test manipulate the data json object directly.\"\"\"\n self.data = data\n\n def copy(self):\n result = super(TestProfile, self).copy()\n result.data = self.data\n\n return result\n\n\nclass ProfileModification(object):\n \"\"\"A profile modification adds new types to an existing profile.\n\n A ProfileModification must be invoked explicitely. We have these as plugins\n so its easier to find a modification by name. A typical invokation looks\n like:\n\n class myPlugin(plugin.Command):\n def __init__(self, **kwargs):\n super(myPlugin, self).__init__(**kwargs)\n\n # Update the profile with the \"VolRegistrySupport\" implementation.\n self.profile = obj.ProfileModification.classes[\n 'VolRegistrySupport'](self.profile)\n\n Note that this plugin must explicitely apply the correct modification. This\n allows the plugin to choose from a number of different implementations. For\n example, in the above say we have one implementation (i.e. overlays, object\n classes etc) called VolRegistrySupport and another called\n ScudetteRegistrySupport, we can choose between them.\n\n Now suppose that ScudetteRegistrySupport introduces an advanced class with\n extra methods:\n\n class _CM_KEY_INDEX(obj.Struct):\n .....\n def SpecialMethod(...):\n ....\n\n The plugin relies on using this specific implementation (i.e. if we loaded\n the other profile modification, this myPlugin will fail because it will\n attempt to call an undefined method! Essentially by explicitely loading the\n modification, the plugin declares that it relies on the\n ScudetteRegistrySupport implementation, but does not preclude having another\n implementation.\n \"\"\"\n def __new__(cls, profile):\n # Return a copy of the profile.\n result = profile.copy()\n\n # Apply the modification.\n cls.modify(result)\n\n return result\n\n @classmethod\n def modify(cls, profile):\n \"\"\"This class should modify the profile appropritately.\n\n The profile will be a copy of the original profile and will be returned\n to the class caller.\n\n Args:\n A profile to be modified.\n \"\"\"\n\n\nclass Address(BaseObject):\n \"\"\"A BaseObject representing an address.\"\"\"\n"},"domain":{"kind":"string","value":"codeparrot/github-code-clean"}}},{"rowIdx":227195,"cells":{"text":{"kind":"string","value":"# coding: utf-8\nfrom __future__ import unicode_literals\nimport unittest\nimport io\n\nfrom lxml import isoschematron, etree\n\nfrom packtools.catalogs import SCHEMAS\n\n\nSCH = etree.parse(SCHEMAS['sps-1.8'])\n\n\ndef TestPhase(phase_name, cache):\n \"\"\"Factory of parsed Schematron phases.\n\n :param phase_name: the phase name\n :param cache: mapping type\n \"\"\"\n if phase_name not in cache:\n phase = isoschematron.Schematron(SCH, phase=phase_name)\n cache[phase_name] = phase\n\n return cache[phase_name]\n\n\nclass PhaseBasedTestCase(unittest.TestCase):\n cache = {}\n\n def _run_validation(self, sample):\n schematron = TestPhase(self.sch_phase, self.cache)\n return schematron.validate(etree.parse(sample))\n\n\nclass JournalIdTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/journal-meta/journal-id elements.\n\n Ticket #14 makes @journal-id-type=\"publisher-id\" mandatory.\n Ref: https://github.com/scieloorg/scielo_publishing_schema/issues/14\n \"\"\"\n sch_phase = 'phase.journal-id'\n\n def test_case1(self):\n \"\"\"\n presence(@nlm-ta) is True\n presence(@publisher-id) is True\n \"\"\"\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <journal-id journal-id-type=\"nlm-ta\">\n Rev Saude Publica\n </journal-id>\n <journal-id journal-id-type=\"publisher-id\">\n RSP\n </journal-id>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_case2(self):\n \"\"\"\n presence(@nlm-ta) is True\n presence(@publisher-id) is False\n \"\"\"\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <journal-id journal-id-type=\"nlm-ta\">\n Rev Saude Publica\n </journal-id>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_case3(self):\n \"\"\"\n presence(@nlm-ta) is False\n presence(@publisher-id) is True\n \"\"\"\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <journal-id journal-id-type=\"publisher-id\">\n RSP\n </journal-id>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_case4(self):\n \"\"\"\n presence(@nlm-ta) is False\n presence(@publisher-id) is False\n \"\"\"\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <journal-id journal-id-type='doi'>\n 123.plin\n </journal-id>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_publisher_id_cannot_be_empty(self):\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <journal-id journal-id-type=\"publisher-id\"></journal-id>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass JournalTitleGroupTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/journal-meta/journal-title-group elements.\n \"\"\"\n sch_phase = 'phase.journal-title-group'\n\n def test_journal_title_group_is_absent(self):\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\n def test_case1(self):\n \"\"\"\n A: presence(journal-title) is True\n B: presence(abbrev-journal-title[@abbrev-type='publisher']) is True\n A ^ B is True\n \"\"\"\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <journal-title-group>\n <journal-title>\n Revista de Saude Publica\n </journal-title>\n <abbrev-journal-title abbrev-type='publisher'>\n Rev. Saude Publica\n </abbrev-journal-title>\n </journal-title-group>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_case2(self):\n \"\"\"\n A: presence(journal-title) is True\n B: presence(abbrev-journal-title[@abbrev-type='publisher']) is False\n A ^ B is False\n \"\"\"\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <journal-title-group>\n <journal-title>\n Revista de Saude Publica\n </journal-title>\n </journal-title-group>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_case3(self):\n \"\"\"\n A: presence(journal-title) is False\n B: presence(abbrev-journal-title[@abbrev-type='publisher']) is True\n A ^ B is False\n \"\"\"\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <journal-title-group>\n <abbrev-journal-title abbrev-type='publisher'>\n Rev. Saude Publica\n </abbrev-journal-title>\n </journal-title-group>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_case4(self):\n \"\"\"\n A: presence(journal-title) is False\n B: presence(abbrev-journal-title[@abbrev-type='publisher']) is False\n A ^ B is False\n \"\"\"\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <journal-title-group>\n </journal-title-group>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_empty_journal_title(self):\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <journal-title-group>\n <journal-title></journal-title>\n <abbrev-journal-title abbrev-type='publisher'>Rev. Saude Publica</abbrev-journal-title>\n </journal-title-group>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_empty_abbrev_journal_title(self):\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <journal-title-group>\n <journal-title>Revista de Saude Publica</journal-title>\n <abbrev-journal-title abbrev-type='publisher'></abbrev-journal-title>\n </journal-title-group>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass PublisherTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/journal-meta/publisher elements.\n \"\"\"\n sch_phase = 'phase.publisher'\n\n def test_publisher_is_present(self):\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <publisher>\n <publisher-name>British Medical Journal</publisher-name>\n </publisher>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_publisher_is_absent(self):\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_publisher_is_empty(self):\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <publisher>\n <publisher-name></publisher-name>\n </publisher>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass ArticleCategoriesTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/article-meta/article-categories elements.\n \"\"\"\n sch_phase = 'phase.article-categories'\n\n def test_article_categories_is_present(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <article-categories>\n <subj-group>\n <subject>ISO/TC 108</subject>\n <subject>\n SC 2, Measurement and evaluation of...\n </subject>\n </subj-group>\n </article-categories>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_article_categories_is_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass fpage_OR_elocationTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/article-meta/fpage or elocation-id elements.\n \"\"\"\n sch_phase = 'phase.fpage_or_elocation-id'\n\n def test_case1(self):\n \"\"\"\n fpage is True\n elocation-id is True\n fpage v elocation-id is True\n \"\"\"\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <fpage>01</fpage>\n <elocation-id>E27</elocation-id>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_case2(self):\n \"\"\"\n fpage is True\n elocation-id is False\n fpage v elocation-id is True\n \"\"\"\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <fpage>01</fpage>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_case3(self):\n \"\"\"\n fpage is False\n elocation-id is True\n fpage v elocation-id is True\n \"\"\"\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <elocation-id>E27</elocation-id>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_case4(self):\n \"\"\"\n fpage is False\n elocation-id is False\n fpage v elocation-id is False\n \"\"\"\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_empty_fpage(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <fpage></fpage>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_empty_elocationid(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <elocation-id></elocation-id>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass ISSNTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/journal-meta/issn elements.\n \"\"\"\n sch_phase = 'phase.issn'\n\n def test_case1(self):\n \"\"\"\n A: @pub-type='epub' is True\n B: @pub-type='ppub' is True\n A v B is True\n \"\"\"\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <issn pub-type=\"epub\">\n 0959-8138\n </issn>\n <issn pub-type=\"ppub\">\n 0959-813X\n </issn>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_case2(self):\n \"\"\"\n A: @pub-type='epub' is True\n B: @pub-type='ppub' is False\n A v B is True\n \"\"\"\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <issn pub-type=\"epub\">\n 0959-8138\n </issn>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_case3(self):\n \"\"\"\n A: @pub-type='epub' is False\n B: @pub-type='ppub' is True\n A v B is True\n \"\"\"\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <issn pub-type=\"ppub\">\n 0959-813X\n </issn>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_case4(self):\n \"\"\"\n A: @pub-type='epub' is False\n B: @pub-type='ppub' is False\n A v B is False\n \"\"\"\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <issn>\n 0959-813X\n </issn>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_empty_issn(self):\n sample = u\"\"\"<article>\n <front>\n <journal-meta>\n <issn pub-type=\"epub\"></issn>\n </journal-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass ArticleIdTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/article-meta/article-id elements.\n \"\"\"\n sch_phase = 'phase.article-id'\n\n def test_article_id_is_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\n def test_pub_id_type_doi_is_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <article-id pub-id-type='other'>\n 10.1590/1414-431X20143435\n </article-id>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_pub_id_type_doi(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <article-id pub-id-type='doi'>\n 10.1590/1414-431X20143434\n </article-id>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_pub_id_type_doi_is_empty(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <article-id pub-id-type='doi'/>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_invalid_pub_id_type(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <article-id pub-id-type='unknown'>\n 10.1590/1414-431X20143434\n </article-id>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_invalid_pub_id_type_case2(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <article-id pub-id-type='unknown'>\n 10.1590/1414-431X20143434\n </article-id>\n <article-id pub-id-type='doi'>\n 10.1590/1414-431X20143434\n </article-id>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_valid_pub_id_type_values(self):\n for typ in ['doi', 'publisher-id', 'other']:\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <article-id pub-id-type='%s'>\n 10.1590/1414-431X20143433\n </article-id>\n <article-id pub-id-type='doi'>\n 10.1590/1414-431X20143434\n </article-id>\n </article-meta>\n </front>\n </article>\n \"\"\" % typ\n sample = io.BytesIO(sample.encode('utf-8'))\n self.assertTrue(self._run_validation(sample))\n\n\nclass SubjGroupTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/article-meta/article-categories/subj-group elements.\n \"\"\"\n sch_phase = 'phase.subj-group'\n\n def test_subj_group_is_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <article-categories>\n </article-categories>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_without_heading_type(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <article-categories>\n <subj-group subj-group-type=\"kwd\">\n <subject content-type=\"neurosci\">\n Cellular and Molecular Biology\n </subject>\n <subj-group>\n <subject content-type=\"neurosci\">\n Blood and brain barrier\n </subject>\n </subj-group>\n </subj-group>\n </article-categories>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_with_heading_type(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <article-categories>\n <subj-group subj-group-type=\"heading\">\n <subject>\n Cellular and Molecular Biology\n </subject>\n <subj-group>\n <subject content-type=\"neurosci\">\n Blood and brain barrier\n </subject>\n </subj-group>\n </subj-group>\n </article-categories>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_with_heading_in_subarticle_pt(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <article-categories>\n <subj-group subj-group-type=\"heading\">\n <subject>\n Original Article\n </subject>\n <subj-group>\n <subject content-type=\"neurosci\">\n Blood and brain barrier\n </subject>\n </subj-group>\n </subj-group>\n </article-categories>\n </article-meta>\n </front>\n <sub-article xml:lang=\"pt\" article-type=\"translation\" id=\"S01\">\n <front-stub>\n <article-categories>\n <subj-group subj-group-type=\"heading\">\n <subject>Artigos Originais</subject>\n </subj-group>\n </article-categories>\n </front-stub>\n </sub-article>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_with_many_heading_in_subarticle_pt(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <article-categories>\n <subj-group subj-group-type=\"heading\">\n <subject>\n Original Article\n </subject>\n <subj-group>\n <subject content-type=\"neurosci\">\n Blood and brain barrier\n </subject>\n </subj-group>\n </subj-group>\n </article-categories>\n </article-meta>\n </front>\n <sub-article xml:lang=\"pt\" article-type=\"translation\" id=\"S01\">\n <front-stub>\n <article-categories>\n <subj-group subj-group-type=\"heading\">\n <subject>Artigos Originais</subject>\n </subj-group>\n <subj-group subj-group-type=\"heading\">\n <subject>Artigos Piratas</subject>\n </subj-group>\n </article-categories>\n </front-stub>\n </sub-article>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_with_heading_type_in_the_deep(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <article-categories>\n <subj-group>\n <subject>\n Cellular and Molecular Biology\n </subject>\n <subj-group subj-group-type=\"heading\">\n <subject>\n Blood and brain barrier\n </subject>\n </subj-group>\n </subj-group>\n </article-categories>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_with_many_heading_type(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <article-categories>\n <subj-group subj-group-type=\"heading\">\n <subject>\n Cellular and Molecular Biology\n </subject>\n </subj-group>\n <subj-group subj-group-type=\"heading\">\n <subject>\n Blood and brain barrier\n </subject>\n </subj-group>\n </article-categories>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass AbstractLangTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/article-meta/abstract elements.\n \"\"\"\n sch_phase = 'phase.abstract_lang'\n\n def test_is_present(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <abstract>\n <p>Differing socioeconomic positions in...</p>\n </abstract>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_is_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_is_present_with_lang(self):\n sample = u\"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n <article>\n <front>\n <article-meta>\n <abstract xml:lang=\"en\">\n <p>Differing socioeconomic positions in...</p>\n </abstract>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_missing_for_research_article(self):\n sample = u\"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n <article article-type=\"research-article\">\n <front>\n <article-meta>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_research_article(self):\n sample = u\"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n <article article-type=\"research-article\">\n <front>\n <article-meta>\n <abstract>\n <p>Differing socioeconomic positions in...</p>\n </abstract>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_research_article_only_with_transabstract(self):\n sample = u\"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n <article article-type=\"research-article\">\n <front>\n <article-meta>\n <trans-abstract xml:lang=\"en\">\n <p>Differing socioeconomic positions in...</p>\n </trans-abstract>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_missing_for_review_article(self):\n sample = u\"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n <article article-type=\"review-article\">\n <front>\n <article-meta>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_review_article(self):\n sample = u\"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n <article article-type=\"review-article\">\n <front>\n <article-meta>\n <abstract>\n <p>Differing socioeconomic positions in...</p>\n </abstract>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_review_article_only_with_transabstract(self):\n sample = u\"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n <article article-type=\"review-article\">\n <front>\n <article-meta>\n <trans-abstract xml:lang=\"en\">\n <p>Differing socioeconomic positions in...</p>\n </trans-abstract>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n\nclass ArticleTitleLangTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/article-meta/title-group/article-title elements.\n \"\"\"\n sch_phase = 'phase.article-title_lang'\n\n def test_is_present_in_articlemeta(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <title-group>\n <article-title>\n Systematic review of day hospital care...\n </article-title>\n </title-group>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_is_present_in_articlemeta_with_lang(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <title-group>\n <article-title xml:lang=\"en\">\n Systematic review of day hospital care...\n </article-title>\n </title-group>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_is_present_in_elementcitation(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <mixed-citation>Aires M, Paz AA, Perosa CT. Situação de saúde e grau de dependência de pessoas idosas institucionalizadas. <italic>Rev Gaucha Enferm.</italic> 2009;30(3):192-9.</mixed-citation>\n <element-citation publication-type=\"journal\">\n <person-group person-group-type=\"author\">\n <name>\n <surname>Aires</surname>\n <given-names>M</given-names>\n </name>\n <name>\n <surname>Paz</surname>\n <given-names>AA</given-names>\n </name>\n <name>\n <surname>Perosa</surname>\n <given-names>CT</given-names>\n </name>\n </person-group>\n <article-title>Situação de saúde e grau de dependência de pessoas idosas institucionalizadas</article-title>\n <source>Rev Gaucha Enferm</source>\n <year>2009</year>\n <volume>30</volume>\n <issue>3</issue>\n <fpage>192</fpage>\n <lpage>199</lpage>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_is_present_in_elementcitation_with_lang(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <mixed-citation>Aires M, Paz AA, Perosa CT. Situação de saúde e grau de dependência de pessoas idosas institucionalizadas. <italic>Rev Gaucha Enferm.</italic> 2009;30(3):192-9.</mixed-citation>\n <element-citation publication-type=\"journal\">\n <person-group person-group-type=\"author\">\n <name>\n <surname>Aires</surname>\n <given-names>M</given-names>\n </name>\n <name>\n <surname>Paz</surname>\n <given-names>AA</given-names>\n </name>\n <name>\n <surname>Perosa</surname>\n <given-names>CT</given-names>\n </name>\n </person-group>\n <article-title xml:lang=\"pt\">Situação de saúde e grau de dependência de pessoas idosas institucionalizadas</article-title>\n <source>Rev Gaucha Enferm</source>\n <year>2009</year>\n <volume>30</volume>\n <issue>3</issue>\n <fpage>192</fpage>\n <lpage>199</lpage>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass KwdGroupLangTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/article-meta/kwd-group elements.\n \"\"\"\n sch_phase = 'phase.kwd-group_lang'\n\n def test_single_occurence(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <kwd-group>\n <kwd>gene expression</kwd>\n </kwd-group>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_many_occurencies(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <kwd-group xml:lang=\"en\">\n <kwd>gene expression</kwd>\n </kwd-group>\n <kwd-group xml:lang=\"pt\">\n <kwd>expressao do gene</kwd>\n </kwd-group>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_many_occurencies_without_lang(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <kwd-group>\n <kwd>gene expression</kwd>\n </kwd-group>\n <kwd-group>\n <kwd>expressao do gene</kwd>\n </kwd-group>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass AffContentTypeTests(PhaseBasedTestCase):\n \"\"\"Tests for:\n - article/front/article-meta/contrib-group\n - article/front/article-meta\n \"\"\"\n sch_phase = 'phase.aff_contenttypes'\n\n def test_original_is_present(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <aff>\n <institution content-type=\"original\">\n Grupo de ...\n </institution>\n </aff>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_original_is_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <aff>\n <institution>\n Grupo de ...\n </institution>\n </aff>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_many_original(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <aff>\n <institution content-type=\"original\">\n Grupo de ...\n </institution>\n <institution content-type=\"original\">\n Galera de ...\n </institution>\n </aff>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_original_is_present_and_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <aff>\n <institution content-type=\"original\">\n Grupo de ...\n </institution>\n </aff>\n <aff>\n <institution>\n Grupo de ...\n </institution>\n </aff>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_original_is_present_and_present(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <aff>\n <institution content-type=\"original\">\n Grupo de ...\n </institution>\n </aff>\n <aff>\n <institution content-type=\"original\">\n Grupo de ...\n </institution>\n </aff>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_allowed_orgdiv1(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <aff>\n <institution content-type=\"original\">\n Grupo de ...\n </institution>\n <institution content-type=\"orgdiv1\">\n Instituto de Matematica e Estatistica\n </institution>\n </aff>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_allowed_orgdiv2(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <aff>\n <institution content-type=\"original\">\n Grupo de ...\n </institution>\n <institution content-type=\"orgdiv2\">\n Instituto de Matematica e Estatistica\n </institution>\n </aff>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_orgdiv3_is_not_allowed_anymore(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <aff>\n <institution content-type=\"original\">\n Grupo de ...\n </institution>\n <institution content-type=\"orgdiv3\">\n Instituto de Matematica e Estatistica\n </institution>\n </aff>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_allowed_normalized(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <aff>\n <institution content-type=\"original\">\n Grupo de ...\n </institution>\n <institution content-type=\"normalized\">\n Instituto de Matematica e Estatistica\n </institution>\n </aff>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_disallowed_orgdiv4(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <aff>\n <institution content-type=\"original\">\n Grupo de ...\n </institution>\n <institution content-type=\"orgdiv4\">\n Instituto de Matematica e Estatistica\n </institution>\n </aff>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_orgname_inside_contrib_group(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <contrib-group>\n <aff>\n <institution content-type=\"original\">\n Grupo de ...\n </institution>\n <institution content-type=\"orgname\">\n Instituto de Matematica e Estatistica\n </institution>\n </aff>\n </contrib-group>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n\nclass CountsTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/article-meta/counts elements.\n \"\"\"\n sch_phase = 'phase.counts'\n\n def test_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <fpage>0</fpage>\n <lpage>0</lpage>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_table_is_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <counts>\n <ref-count count=\"0\"/>\n <fig-count count=\"0\"/>\n <equation-count count=\"0\"/>\n <page-count count=\"0\"/>\n </counts>\n <fpage>0</fpage>\n <lpage>0</lpage>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_ref_is_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <counts>\n <table-count count=\"0\"/>\n <fig-count count=\"0\"/>\n <equation-count count=\"0\"/>\n <page-count count=\"0\"/>\n </counts>\n <fpage>0</fpage>\n <lpage>0</lpage>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_fig_is_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <counts>\n <table-count count=\"0\"/>\n <ref-count count=\"0\"/>\n <equation-count count=\"0\"/>\n <page-count count=\"0\"/>\n </counts>\n <fpage>0</fpage>\n <lpage>0</lpage>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_equation_is_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <counts>\n <table-count count=\"0\"/>\n <ref-count count=\"0\"/>\n <fig-count count=\"0\"/>\n <page-count count=\"0\"/>\n </counts>\n <fpage>0</fpage>\n <lpage>0</lpage>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_page_is_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <counts>\n <table-count count=\"0\"/>\n <ref-count count=\"0\"/>\n <fig-count count=\"0\"/>\n <equation-count count=\"0\"/>\n </counts>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_tables(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <counts>\n <table-count count=\"1\"/>\n <ref-count count=\"0\"/>\n <fig-count count=\"0\"/>\n <equation-count count=\"0\"/>\n <page-count count=\"0\"/>\n </counts>\n <fpage>0</fpage>\n <lpage>0</lpage>\n </article-meta>\n </front>\n <body>\n <sec>\n <p>\n <table-wrap>\n <table frame=\"hsides\" rules=\"groups\">\n <colgroup width=\"25%\"><col/><col/><col/><col/></colgroup>\n <thead>\n <tr>\n <th style=\"font-weight:normal\" align=\"left\">Modelo</th>\n <th style=\"font-weight:normal\">Estrutura</th>\n <th style=\"font-weight:normal\">Processos</th>\n <th style=\"font-weight:normal\">Resultados</th>\n </tr>\n </thead>\n <tbody>\n <tr>\n <td valign=\"top\">SIPA<sup>1,2</sup></td>\n <td valign=\"top\">Urgência e hospitalar.</td>\n <td valign=\"top\">Realiza triagem para fragilidade.</td>\n <td valign=\"top\">Maior gasto comunitário, menor gasto.</td>\n </tr>\n </tbody>\n </table>\n </table-wrap>\n </p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_tables_as_graphic(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <counts>\n <table-count count=\"1\"/>\n <ref-count count=\"0\"/>\n <fig-count count=\"0\"/>\n <equation-count count=\"0\"/>\n <page-count count=\"0\"/>\n </counts>\n <fpage>0</fpage>\n <lpage>0</lpage>\n </article-meta>\n </front>\n <body>\n <sec>\n <p>\n <table-wrap id=\"t01\">\n <graphic mimetype=\"image\"\n xlink:href=\"1414-431X-bjmbr-1414-431X20142875-gt001\">\n </graphic>\n </table-wrap>\n </p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_ref(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <counts>\n <table-count count=\"0\"/>\n <ref-count count=\"1\"/>\n <fig-count count=\"0\"/>\n <equation-count count=\"0\"/>\n <page-count count=\"0\"/>\n </counts>\n <fpage>0</fpage>\n <lpage>0</lpage>\n </article-meta>\n </front>\n <back>\n <ref-list>\n <title>REFERÊNCIAS</title>\n <ref id=\"B1\">\n <label>1</label>\n <mixed-citation>\n Béland F, Bergman H, Lebel P, Clarfield AM, Tousignant P, ...\n </mixed-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_fig(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <counts>\n <table-count count=\"0\"/>\n <ref-count count=\"0\"/>\n <fig-count count=\"1\"/>\n <equation-count count=\"0\"/>\n <page-count count=\"0\"/>\n </counts>\n <fpage>0</fpage>\n <lpage>0</lpage>\n </article-meta>\n </front>\n <body>\n <sec>\n <p>\n <fig id=\"f01\">\n <label>Figura 1</label>\n <caption>\n <title>Modelo das cinco etapas da pesquisa translacional.</title>\n </caption>\n <graphic xlink:href=\"0034-8910-rsp-48-2-0347-gf01\"/>\n </fig>\n </p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_equation(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <counts>\n <table-count count=\"0\"/>\n <ref-count count=\"0\"/>\n <fig-count count=\"0\"/>\n <equation-count count=\"1\"/>\n <page-count count=\"0\"/>\n </counts>\n <fpage>0</fpage>\n <lpage>0</lpage>\n </article-meta>\n </front>\n <body>\n <sec>\n <disp-formula>\n <tex-math id=\"M1\">\n </tex-math>\n </disp-formula>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_page(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <counts>\n <table-count count=\"0\"/>\n <ref-count count=\"0\"/>\n <fig-count count=\"0\"/>\n <equation-count count=\"0\"/>\n <page-count count=\"11\"/>\n </counts>\n <fpage>140</fpage>\n <lpage>150</lpage>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_page_wrong_count(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <counts>\n <table-count count=\"0\"/>\n <ref-count count=\"0\"/>\n <fig-count count=\"0\"/>\n <equation-count count=\"0\"/>\n <page-count count=\"50\"/>\n </counts>\n <fpage>140</fpage>\n <lpage>150</lpage>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_non_digit_pages(self):\n \"\"\"Non-digit page interval cannot be checked automatically.\n \"\"\"\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <counts>\n <table-count count=\"0\"/>\n <ref-count count=\"0\"/>\n <fig-count count=\"0\"/>\n <equation-count count=\"0\"/>\n <page-count count=\"11\"/>\n </counts>\n <fpage>A140</fpage>\n <lpage>A150</lpage>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_elocationid_pages(self):\n \"\"\"Electronic pagination cannot be checked automatically.\n \"\"\"\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <counts>\n <table-count count=\"0\"/>\n <ref-count count=\"0\"/>\n <fig-count count=\"0\"/>\n <equation-count count=\"0\"/>\n <page-count count=\"11\"/>\n </counts>\n <elocation-id>A140</elocation-id>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n\nclass AuthorNotesTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/article-meta/author-notes elements.\n \"\"\"\n sch_phase = 'phase.fn-group'\n\n def test_allowed_fn_types(self):\n for fn_type in ['author', 'con', 'conflict', 'corresp', 'current-aff',\n 'deceased', 'edited-by', 'equal', 'on-leave', 'participating-researchers',\n 'present-address', 'previously-at', 'study-group-members', 'other']:\n\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <author-notes>\n <fn fn-type=\"%s\">\n <p>foobar</p>\n </fn>\n </author-notes>\n </article-meta>\n </front>\n </article>\n \"\"\" % fn_type\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_disallowed_fn_types(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <author-notes>\n <fn fn-type=\"wtf\">\n <p>foobar</p>\n </fn>\n </author-notes>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass PubDateTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/article-meta/pub-date elements.\n \"\"\"\n sch_phase = 'phase.pub-date'\n\n def test_date_type_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date publication-format=\"electronic\">\n <day>17</day>\n <month>03</month>\n <year>2014</year>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_publication_format_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date date-type=\"pub\">\n <day>17</day>\n <month>03</month>\n <year>2014</year>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_date_type_allowed_values_day_month_year(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date date-type=\"pub\" publication-format=\"electronic\">\n <day>17</day>\n <month>03</month>\n <year>2014</year>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_date_type_allowed_values_day_month(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date date-type=\"pub\" publication-format=\"electronic\">\n <day>17</day>\n <month>03</month>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_date_type_allowed_values_day_year(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date date-type=\"pub\" publication-format=\"electronic\">\n <day>17</day>\n <year>2014</year>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_date_type_allowed_values_month_year(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date date-type=\"pub\" publication-format=\"electronic\">\n <month>03</month>\n <year>2014</year>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_date_type_allowed_values_year(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date date-type=\"pub\" publication-format=\"electronic\">\n <year>2014</year>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_pub_type_disallowed_value(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date date-type=\"unknown\" publication-format=\"electronic\">\n <day>17</day>\n <month>03</month>\n <year>2014</year>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_publication_format_allowed_values(self):\n for value in ['electronic']:\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date date-type=\"pub\" publication-format=\"%s\">\n <day>17</day>\n <month>03</month>\n <year>2014</year>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\" % value\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_publication_format_disallowed_value(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date date-type=\"pub\" publication-format=\"unknown\">\n <day>17</day>\n <month>03</month>\n <year>2014</year>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_date_type_collection_without_pub_is_not_allowed(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date date-type=\"collection\" publication-format=\"electronic\">\n <month>03</month>\n <year>2014</year>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_date_type_collection_containing_month_year(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date date-type=\"pub\" publication-format=\"electronic\">\n <day>17</day>\n <month>03</month>\n <year>2014</year>\n </pub-date>\n <pub-date date-type=\"collection\" publication-format=\"electronic\">\n <month>03</month>\n <year>2015</year>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_date_type_collection_containing_day_month_year(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date date-type=\"pub\" publication-format=\"electronic\">\n <day>17</day>\n <month>03</month>\n <year>2014</year>\n </pub-date>\n <pub-date date-type=\"collection\" publication-format=\"electronic\">\n <day>12</day>\n <month>03</month>\n <year>2015</year>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_date_type_collection_containing_day_year(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date date-type=\"pub\" publication-format=\"electronic\">\n <day>17</day>\n <month>03</month>\n <year>2014</year>\n </pub-date>\n <pub-date date-type=\"collection\" publication-format=\"electronic\">\n <day>12</day>\n <year>2015</year>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_date_type_collection_containing_year(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date date-type=\"pub\" publication-format=\"electronic\">\n <day>17</day>\n <month>03</month>\n <year>2014</year>\n </pub-date>\n <pub-date date-type=\"collection\" publication-format=\"electronic\">\n <year>2015</year>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_date_type_collection_containing_season(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date date-type=\"pub\" publication-format=\"electronic\">\n <day>17</day>\n <month>03</month>\n <year>2014</year>\n </pub-date>\n <pub-date date-type=\"collection\" publication-format=\"electronic\">\n <season>Jan-Feb</season>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_date_type_collection_containing_season_year(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date date-type=\"pub\" publication-format=\"electronic\">\n <day>17</day>\n <month>03</month>\n <year>2014</year>\n </pub-date>\n <pub-date date-type=\"collection\" publication-format=\"electronic\">\n <season>Jan-Feb</season>\n <year>2019</year>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n\nclass VolumeTests(PhaseBasedTestCase):\n \"\"\"Tests for:\n - article/front/article-meta/volume\n - article/back/ref-list/ref/element-citation/volume\n \"\"\"\n sch_phase = 'phase.volume'\n\n def test_absent_in_front(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_present_but_empty_in_front(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <volume></volume>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_present_in_front(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <volume>10</volume>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n\nclass IssueTests(PhaseBasedTestCase):\n \"\"\"Tests for:\n - article/front/article-meta/issue\n - article/back/ref-list/ref/element-citation/issue\n \"\"\"\n sch_phase = 'phase.issue'\n\n def test_absent_in_front(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_present_but_empty_in_front(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <issue></issue>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_present_in_front(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <issue>10</issue>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_special_number_support(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <issue>spe</issue>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_is_present_in_elementcitation(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n <issue>10</issue>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_is_present_twice_in_elementcitation(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n <issue>02</issue>\n <issue>02</issue>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_is_absent_in_elementcitation(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\nclass SupplementTests(PhaseBasedTestCase):\n \"\"\"Tests for:\n - article/front/article-meta/supplement\n \"\"\"\n sch_phase = 'phase.supplement'\n\n def test_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_present(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <supplement>Suppl 2</supplement>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass ElocationIdTests(PhaseBasedTestCase):\n \"\"\"Tests for:\n - article/front/article-meta/elocation-id\n - article/back/ref-list/ref/element-citation/elocation-id\n \"\"\"\n sch_phase = 'phase.elocation-id'\n\n def test_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_with_fpage(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <elocation-id>E27</elocation-id>\n <fpage>12</fpage>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_without_fpage(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <elocation-id>E27</elocation-id>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_absent_back(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_with_fpage_back(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n <elocation-id>E27</elocation-id>\n <fpage>12</fpage>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_without_fpage_back(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n <elocation-id>E27</elocation-id>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_with_and_without_fpage_back(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n <elocation-id>E27</elocation-id>\n <fpage>12</fpage>\n </element-citation>\n </ref>\n <ref>\n <element-citation>\n <elocation-id>E27</elocation-id>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass HistoryTests(PhaseBasedTestCase):\n \"\"\"Tests for:\n - article/front/article-meta/history\n \"\"\"\n sch_phase = 'phase.history'\n\n def test_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_date_type_allowed_values(self):\n for pub_type in ['accepted', 'corrected', 'pub', 'preprint',\n 'retracted', 'received', 'rev-recd', 'rev-request']:\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <history>\n <date date-type=\"%s\">\n <day>17</day>\n <month>03</month>\n <year>2014</year>\n </date>\n </history>\n </article-meta>\n </front>\n </article>\n \"\"\" % pub_type\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_date_type_disallowed_values(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <history>\n <date date-type=\"invalid\">\n <day>17</day>\n <month>03</month>\n <year>2014</year>\n </date>\n </history>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_date_type_allowed_values_multi(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <history>\n <date date-type=\"received\">\n <day>17</day>\n <month>03</month>\n <year>2014</year>\n </date>\n <date date-type=\"accepted\">\n <day>17</day>\n <month>03</month>\n <year>2014</year>\n </date>\n </history>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n\nclass ProductTests(PhaseBasedTestCase):\n \"\"\"Tests for:\n - article/front/article-meta/product\n \"\"\"\n sch_phase = 'phase.product'\n\n def test_absent(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_absent_allowed_types(self):\n for art_type in ['book-review', 'product-review']:\n sample = u\"\"\"<article article-type=\"%s\">\n <front>\n <article-meta>\n </article-meta>\n </front>\n </article>\n \"\"\" % art_type\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_allowed_types(self):\n for art_type in ['book-review']:\n sample = u\"\"\"<article article-type=\"%s\">\n <front>\n <article-meta>\n <product product-type=\"book\">\n <person-group person-group-type=\"author\">\n <name>\n <surname>Sobrenome do autor</surname>\n <given-names>Prenomes do autor</given-names>\n </name>\n </person-group>\n <source>Título do livro</source>\n <year>Ano de publicação</year>\n <publisher-name>Nome da casa publicadora/Editora</publisher-name>\n <publisher-loc>Local de publicação</publisher-loc>\n <page-count count=\"total de paginação do livro (opcional)\"/>\n <isbn>ISBN do livro, se houver</isbn>\n <inline-graphic>1234-5678-rctb-45-05-690-gf01.tif</inline-graphic>\n </product>\n </article-meta>\n </front>\n </article>\n \"\"\" % art_type\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_disallowed_types(self):\n sample = u\"\"\"<article article-type=\"research-article\">\n <front>\n <article-meta>\n <product product-type=\"book\">\n <person-group person-group-type=\"author\">\n <name>\n <surname>Sobrenome do autor</surname>\n <given-names>Prenomes do autor</given-names>\n </name>\n </person-group>\n <source>Título do livro</source>\n <year>Ano de publicação</year>\n <publisher-name>Nome da casa publicadora/Editora</publisher-name>\n <publisher-loc>Local de publicação</publisher-loc>\n <page-count count=\"total de paginação do livro (opcional)\"/>\n <isbn>ISBN do livro, se houver</isbn>\n <inline-graphic>1234-5678-rctb-45-05-690-gf01.tif</inline-graphic>\n </product>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_no_type(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <product product-type=\"book\">\n <person-group person-group-type=\"author\">\n <name>\n <surname>Sobrenome do autor</surname>\n <given-names>Prenomes do autor</given-names>\n </name>\n </person-group>\n <source>Título do livro</source>\n <year>Ano de publicação</year>\n <publisher-name>Nome da casa publicadora/Editora</publisher-name>\n <publisher-loc>Local de publicação</publisher-loc>\n <page-count count=\"total de paginação do livro (opcional)\"/>\n <isbn>ISBN do livro, se houver</isbn>\n <inline-graphic>1234-5678-rctb-45-05-690-gf01.tif</inline-graphic>\n </product>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_product_type(self):\n sample = u\"\"\"<article article-type=\"book-review\">\n <front>\n <article-meta>\n <product>\n <person-group person-group-type=\"author\">\n <name>\n <surname>Sobrenome do autor</surname>\n <given-names>Prenomes do autor</given-names>\n </name>\n </person-group>\n <source>Título do livro</source>\n <year>Ano de publicação</year>\n <publisher-name>Nome da casa publicadora/Editora</publisher-name>\n <publisher-loc>Local de publicação</publisher-loc>\n <page-count count=\"total de paginação do livro (opcional)\"/>\n <isbn>ISBN do livro, se houver</isbn>\n <inline-graphic>1234-5678-rctb-45-05-690-gf01.tif</inline-graphic>\n </product>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_allowed_product_types(self):\n for prod_type in ['book', 'article', 'issue', 'website', 'film',\n 'software', 'hardware', 'other']:\n sample = u\"\"\"<article article-type=\"book-review\">\n <front>\n <article-meta>\n <product product-type=\"%s\">\n <person-group person-group-type=\"author\">\n <name>\n <surname>Sobrenome do autor</surname>\n <given-names>Prenomes do autor</given-names>\n </name>\n </person-group>\n <source>Título do livro</source>\n <year>Ano de publicação</year>\n <publisher-name>Nome da casa publicadora/Editora</publisher-name>\n <publisher-loc>Local de publicação</publisher-loc>\n <page-count count=\"total de paginação do livro (opcional)\"/>\n <isbn>ISBN do livro, se houver</isbn>\n <inline-graphic>1234-5678-rctb-45-05-690-gf01.tif</inline-graphic>\n </product>\n </article-meta>\n </front>\n </article>\n \"\"\" % prod_type\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_disallowed_product_types(self):\n sample = u\"\"\"<article article-type=\"book-review\">\n <front>\n <article-meta>\n <product product-type=\"invalid\">\n <person-group person-group-type=\"author\">\n <name>\n <surname>Sobrenome do autor</surname>\n <given-names>Prenomes do autor</given-names>\n </name>\n </person-group>\n <source>Título do livro</source>\n <year>Ano de publicação</year>\n <publisher-name>Nome da casa publicadora/Editora</publisher-name>\n <publisher-loc>Local de publicação</publisher-loc>\n <page-count count=\"total de paginação do livro (opcional)\"/>\n <isbn>ISBN do livro, se houver</isbn>\n <inline-graphic>1234-5678-rctb-45-05-690-gf01.tif</inline-graphic>\n </product>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_formatting_and_punctuation(self):\n sample = u\"\"\"<article article-type=\"book-review\">\n <front>\n <article-meta>\n <product product-type=\"book\">\n <person-group person-group-type=\"author\">\n <name>\n <surname>Sobrenome do autor</surname>,\n <given-names>Prenomes do autor</given-names>;\n </name>\n </person-group>\n <source>Título do livro</source>,\n <year>Ano de publicação</year>\n <publisher-name>Nome da casa publicadora/Editora</publisher-name>\n <publisher-loc>Local de publicação</publisher-loc>\n <page-count count=\"total de paginação do livro (opcional)\"/>\n <isbn>ISBN do livro, se houver</isbn>\n <inline-graphic>1234-5678-rctb-45-05-690-gf01.tif</inline-graphic>\n </product>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n\nclass SecTitleTests(PhaseBasedTestCase):\n \"\"\"Tests for:\n - article/body/sec/title\n \"\"\"\n sch_phase = 'phase.sectitle'\n\n def test_absent(self):\n sample = u\"\"\"<article>\n <body>\n <sec>\n <p>Foo bar</p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_has_title(self):\n sample = u\"\"\"<article>\n <body>\n <sec>\n <title>Introduction</title>\n <p>Foo bar</p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_has_empty_title(self):\n sample = u\"\"\"<article>\n <body>\n <sec>\n <title></title>\n <p>Foo bar</p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass ParagraphTests(PhaseBasedTestCase):\n \"\"\"Tests for //p\n \"\"\"\n sch_phase = 'phase.paragraph'\n\n def test_sec_without_id(self):\n sample = u\"\"\"<article>\n <body>\n <sec>\n <title>Intro</title>\n <p>Foo bar</p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_sec_with_id(self):\n sample = u\"\"\"<article>\n <body>\n <sec>\n <title>Intro</title>\n <p id=\"p01\">Foo bar</p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_body_without_id(self):\n sample = u\"\"\"<article>\n <body>\n <p>Foo bar</p>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_body_with_id(self):\n sample = u\"\"\"<article>\n <body>\n <p id=\"p01\">Foo bar</p>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass XrefRidTests(PhaseBasedTestCase):\n \"\"\"Tests for //xref[@rid]\n \"\"\"\n sch_phase = 'phase.rid_integrity'\n\n def test_mismatching_rid(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <contrib-group>\n <contrib>\n <xref ref-type=\"aff\" rid=\"aff1\">\n <sup>I</sup>\n </xref>\n </contrib>\n </contrib-group>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_matching_rid(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <contrib-group>\n <contrib>\n <xref ref-type=\"aff\" rid=\"aff1\">\n <sup>I</sup>\n </xref>\n </contrib>\n </contrib-group>\n <aff id=\"aff1\">\n <label>I</label>\n <institution content-type=\"orgname\">\n Secretaria Municipal de Saude de Belo Horizonte\n </institution>\n <addr-line>\n <named-content content-type=\"city\">Belo Horizonte</named-content>\n <named-content content-type=\"state\">MG</named-content>\n </addr-line>\n <country>Brasil</country>\n <institution content-type=\"original\">\n Secretaria Municipal de Saude de Belo Horizonte. Belo Horizonte, MG, Brasil\n </institution>\n </aff>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_mismatching_reftype(self):\n sample = u\"\"\"<article>\n <body>\n <sec>\n <table-wrap id=\"t01\">\n </table-wrap>\n </sec>\n <sec>\n <p>\n <xref ref-type=\"aff\" rid=\"t01\">table 1</xref>\n </p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass XrefRefTypeTests(PhaseBasedTestCase):\n \"\"\"Tests for //xref[@ref-type]\n \"\"\"\n sch_phase = 'phase.xref_reftype_integrity'\n\n def test_allowed_ref_types(self):\n for reftype in ['aff', 'app', 'author-notes', 'bibr', 'contrib',\n 'corresp', 'disp-formula', 'fig', 'fn', 'sec',\n 'supplementary-material', 'table', 'table-fn',\n 'boxed-text']:\n sample = u\"\"\"<article>\n <body>\n <sec>\n <p>\n <xref ref-type=\"%s\">foo</xref>\n </p>\n </sec>\n </body>\n </article>\n \"\"\" % reftype\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_disallowed_ref_types(self):\n for reftype in ['chem', 'kwd', 'list', 'other', 'plate'\n 'scheme', 'statement']:\n sample = u\"\"\"<article>\n <body>\n <sec>\n <p>\n <xref ref-type=\"%s\">foo</xref>\n </p>\n </sec>\n </body>\n </article>\n \"\"\" % reftype\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass CaptionTests(PhaseBasedTestCase):\n \"\"\"Tests for //caption\n \"\"\"\n sch_phase = 'phase.caption'\n\n def test_with_title(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <body>\n <fig id=\"f03\">\n <label>Figura 3</label>\n <caption>\n <title>\n Percentual de atividade mitocondrial.\n </title>\n </caption>\n <graphic xlink:href=\"1234-5678-rctb-45-05-0110-gf01.tif\"/>\n </fig>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_without_title(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <body>\n <fig id=\"f03\">\n <label>Figura 3</label>\n <caption>\n <label>\n Percentual de atividade mitocondrial.\n </label>\n </caption>\n <graphic xlink:href=\"1234-5678-rctb-45-05-0110-gf01.tif\"/>\n </fig>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_with_title_and_more(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <body>\n <fig id=\"f03\">\n <label>Figura 3</label>\n <caption>\n <title>\n Percentual de atividade mitocondrial.\n </title>\n <label>\n Percentual de atividade mitocondrial.\n </label>\n </caption>\n <graphic xlink:href=\"1234-5678-rctb-45-05-0110-gf01.tif\"/>\n </fig>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n\nclass LicenseTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/article-meta/permissions/license element.\n \"\"\"\n sch_phase = 'phase.license'\n\n def test_missing_permissions_elem(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_missing_license(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <permissions>\n </permissions>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_allowed_license_type(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <permissions>\n <license license-type=\"open-access\"\n xlink:href=\"http://creativecommons.org/licenses/by/4.0/\"\n xml:lang=\"en\">\n <license-p>\n This is an open-access article distributed under the terms...\n </license-p>\n </license>\n </permissions>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_disallowed_license_type(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <permissions>\n <license license-type=\"closed-access\"\n xlink:href=\"http://creativecommons.org/licenses/by/4.0/\"\n xml:lang=\"en\">\n <license-p>\n This is an open-access article distributed under the terms...\n </license-p>\n </license>\n </permissions>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_allowed_license_href(self):\n allowed_licenses = [\n 'http://creativecommons.org/licenses/by-nc/4.0/',\n 'http://creativecommons.org/licenses/by-nc/3.0/',\n 'http://creativecommons.org/licenses/by/4.0/',\n 'http://creativecommons.org/licenses/by/3.0/',\n 'http://creativecommons.org/licenses/by-nc-nd/4.0/',\n 'http://creativecommons.org/licenses/by-nc-nd/3.0/',\n 'http://creativecommons.org/licenses/by/3.0/igo/',\n 'http://creativecommons.org/licenses/by-nc/3.0/igo/',\n 'http://creativecommons.org/licenses/by-nc-nd/3.0/igo/',\n ]\n\n for license in allowed_licenses:\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <permissions>\n <license license-type=\"open-access\"\n xlink:href=\"%s\"\n xml:lang=\"en\">\n <license-p>\n This is an open-access article distributed under the terms...\n </license-p>\n </license>\n </permissions>\n </article-meta>\n </front>\n </article>\n \"\"\" % license\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_allowed_license_href_https_scheme(self):\n allowed_licenses = [\n 'https://creativecommons.org/licenses/by-nc/4.0/',\n 'https://creativecommons.org/licenses/by-nc/3.0/',\n 'https://creativecommons.org/licenses/by/4.0/',\n 'https://creativecommons.org/licenses/by/3.0/',\n 'https://creativecommons.org/licenses/by-nc-nd/4.0/',\n 'https://creativecommons.org/licenses/by-nc-nd/3.0/',\n 'https://creativecommons.org/licenses/by/3.0/igo/',\n 'https://creativecommons.org/licenses/by-nc/3.0/igo/',\n 'https://creativecommons.org/licenses/by-nc-nd/3.0/igo/',\n ]\n\n for license in allowed_licenses:\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <permissions>\n <license license-type=\"open-access\"\n xlink:href=\"%s\"\n xml:lang=\"en\">\n <license-p>\n This is an open-access article distributed under the terms...\n </license-p>\n </license>\n </permissions>\n </article-meta>\n </front>\n </article>\n \"\"\" % license\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_disallowed_license_href(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <permissions>\n <license license-type=\"open-access\"\n xlink:href=\"http://opensource.org/licenses/MIT\"\n xml:lang=\"en\">\n <license-p>\n This is an open-access article distributed under the terms...\n </license-p>\n </license>\n </permissions>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_missing_trailing_slash(self):\n allowed_licenses = [\n 'https://creativecommons.org/licenses/by-nc/4.0',\n ]\n\n for license in allowed_licenses:\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <permissions>\n <license license-type=\"open-access\"\n xlink:href=\"%s\"\n xml:lang=\"en\">\n <license-p>\n This is an open-access article distributed under the terms...\n </license-p>\n </license>\n </permissions>\n </article-meta>\n </front>\n </article>\n \"\"\" % license\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_permissions_within_elements_of_the_body(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <permissions>\n <license license-type=\"open-access\"\n xlink:href=\"http://creativecommons.org/licenses/by/4.0/\"\n xml:lang=\"en\">\n <license-p>\n This is an open-access article distributed under the terms...\n </license-p>\n </license>\n </permissions>\n </article-meta>\n </front>\n <body>\n <sec>\n <p>\n <fig id=\"f01\">\n <label>Fig. 1</label>\n <caption>\n <title>título da imagem</title>\n </caption>\n <graphic xlink:href=\"1234-5678-rctb-45-05-0110-gf01.tif\"/>\n <permissions>\n <copyright-statement>Copyright © 2014 SciELO</copyright-statement>\n <copyright-year>2014</copyright-year>\n <copyright-holder>SciELO</copyright-holder>\n <license license-type=\"open-access\"\n xlink:href=\"http://creativecommons.org/licenses/by-nc-sa/4.0/\"\n xml:lang=\"en\">\n <license-p>This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.</license-p>\n </license>\n </permissions>\n </fig>\n </p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_copyrighted_elements_within_the_body(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <permissions>\n <license license-type=\"open-access\"\n xlink:href=\"http://creativecommons.org/licenses/by/4.0/\"\n xml:lang=\"en\">\n <license-p>\n This is an open-access article distributed under the terms...\n </license-p>\n </license>\n </permissions>\n </article-meta>\n </front>\n <body>\n <sec>\n <p>\n <fig id=\"f01\">\n <label>Fig. 1</label>\n <caption>\n <title>título da imagem</title>\n </caption>\n <graphic xlink:href=\"1234-5678-rctb-45-05-0110-gf01.tif\"/>\n <permissions>\n <copyright-statement>Copyright © 2014 SciELO</copyright-statement>\n <copyright-year>2014</copyright-year>\n <copyright-holder>SciELO</copyright-holder>\n </permissions>\n </fig>\n </p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_irrestrict_use_licenses_within_elements_in_the_body(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <permissions>\n <license license-type=\"open-access\"\n xlink:href=\"http://creativecommons.org/licenses/by/4.0/\"\n xml:lang=\"en\">\n <license-p>\n This is an open-access article distributed under the terms...\n </license-p>\n </license>\n </permissions>\n </article-meta>\n </front>\n <body>\n <sec>\n <p>\n <fig id=\"f01\">\n <label>Fig. 1</label>\n <caption>\n <title>título da imagem</title>\n </caption>\n <graphic xlink:href=\"1234-5678-rctb-45-05-0110-gf01.tif\"/>\n <permissions>\n <copyright-statement>Copyright © 2014 SciELO</copyright-statement>\n <copyright-year>2014</copyright-year>\n <copyright-holder>SciELO</copyright-holder>\n <license license-type=\"open-access\"\n xlink:href=\"http://creativecommons.org/licenses/by/2.0/\"\n xml:lang=\"en\">\n <license-p>This is an open-access article distributed under the terms of...</license-p>\n </license>\n </permissions>\n </fig>\n </p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_main_article_copyright_info(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <front>\n <article-meta>\n <permissions>\n <copyright-statement>Copyright © 2014 SciELO</copyright-statement>\n <copyright-year>2014</copyright-year>\n <copyright-holder>SciELO</copyright-holder>\n <license license-type=\"open-access\"\n xlink:href=\"http://creativecommons.org/licenses/by/4.0/\"\n xml:lang=\"en\">\n <license-p>\n This is an open-access article distributed under the terms...\n </license-p>\n </license>\n </permissions>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_lang_mismatch(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\" xml:lang=\"en\">\n <front>\n <article-meta>\n <permissions>\n <license license-type=\"open-access\"\n xlink:href=\"http://creativecommons.org/licenses/by/4.0/\"\n xml:lang=\"pt\">\n <license-p>\n Texto em pt-br...\n </license-p>\n </license>\n </permissions>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_lang_mismatch_is_ignored_if_lang_is_en(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\" xml:lang=\"pt\">\n <front>\n <article-meta>\n <permissions>\n <license license-type=\"open-access\"\n xlink:href=\"http://creativecommons.org/licenses/by/4.0/\"\n xml:lang=\"en\">\n <license-p>\n This is an open-access article distributed under the terms...\n </license-p>\n </license>\n </permissions>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_missing_lang_attribute(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\" xml:lang=\"pt\">\n <front>\n <article-meta>\n <permissions>\n <license license-type=\"open-access\"\n xlink:href=\"http://creativecommons.org/licenses/by/4.0/\">\n <license-p>\n This is an open-access article distributed under the terms...\n </license-p>\n </license>\n </permissions>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass AckTests(PhaseBasedTestCase):\n \"\"\"Tests for article/back/ack element.\n \"\"\"\n sch_phase = 'phase.ack'\n\n def test_with_sec(self):\n sample = u\"\"\"<article>\n <back>\n <ack>\n <sec>\n <p>Some</p>\n </sec>\n </ack>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_without_sec(self):\n sample = u\"\"\"<article>\n <back>\n <ack>\n <title>Acknowledgment</title>\n <p>Some text</p>\n </ack>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n\nclass ElementCitationTests(PhaseBasedTestCase):\n \"\"\"Tests for article/back/ref-list/ref/element-citation element.\n \"\"\"\n sch_phase = 'phase.element-citation'\n\n def test_with_name_outside_persongroup(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation publication-type=\"journal\">\n <name>Foo</name>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_with_name_inside_persongroup(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation publication-type=\"journal\">\n <person-group>\n <name>Foo</name>\n </person-group>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_with_etal_outside_persongroup(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation publication-type=\"journal\">\n <etal>Foo</etal>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_with_etal_inside_persongroup(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation publication-type=\"journal\">\n <person-group>\n <etal>Foo</etal>\n </person-group>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_with_collab_outside_persongroup(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation publication-type=\"journal\">\n <collab>Foo</collab>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_with_collab_inside_persongroup(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation publication-type=\"journal\">\n <person-group>\n <collab>Foo</collab>\n </person-group>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_allowed_publication_types(self):\n for pub_type in ['journal', 'book', 'webpage', 'thesis', 'confproc',\n 'patent', 'software', 'database', 'legal-doc', 'newspaper',\n 'other', 'report']:\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation publication-type=\"%s\">\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\" % pub_type\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_disallowed_publication_types(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation publication-type=\"invalid\">\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_outside_ref(self):\n sample = u\"\"\"<article>\n <body>\n <sec>\n <p>\n <element-citation publication-type=\"journal\">\n <person-group>\n <collab>Foo</collab>\n </person-group>\n </element-citation>\n </p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass ChapterTitleTests(PhaseBasedTestCase):\n \"\"\"Tests for\n - article/back/ref-list/ref/element-citation/chapter-title\n - article/front/article-meta/product/chapter-title\n \"\"\"\n sch_phase = 'phase.chapter-title'\n\n def test_absent_in_element_citation(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_present_in_element_citation(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n <chapter-title>Título do capítulo</chapter-title>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_present_twice_in_element_citation(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n <chapter-title>Título do capítulo</chapter-title>\n <chapter-title> Outro título do capítulo</chapter-title>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_absent_in_product(self):\n sample = u\"\"\"<article article-type=\"book-review\">\n <front>\n <article-meta>\n <product product-type=\"chapter\">\n <person-group person-group-type=\"author\">\n <name>\n <surname>Sobrenome do autor</surname>\n <given-names>Prenomes do autor</given-names>\n </name>\n </person-group>\n <source>Título do livro</source>\n <year>Ano de publicação</year>\n <publisher-name>Nome da casa publicadora/Editora</publisher-name>\n <publisher-loc>Local de publicação</publisher-loc>\n <page-count count=\"total de paginação do livro (opcional)\"/>\n <isbn>ISBN do livro, se houver</isbn>\n <inline-graphic>1234-5678-rctb-45-05-690-gf01.tif</inline-graphic>\n </product>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_present_in_product(self):\n sample = u\"\"\"<article article-type=\"book-review\">\n <front>\n <article-meta>\n <product product-type=\"chapter\">\n <person-group person-group-type=\"author\">\n <name>\n <surname>Sobrenome do autor</surname>\n <given-names>Prenomes do autor</given-names>\n </name>\n </person-group>\n <source>Título do livro</source>\n <chapter-title>Título do capítulo do livro</chapter-title>\n <year>Ano de publicação</year>\n <publisher-name>Nome da casa publicadora/Editora</publisher-name>\n <publisher-loc>Local de publicação</publisher-loc>\n <page-count count=\"total de paginação do livro (opcional)\"/>\n <isbn>ISBN do livro, se houver</isbn>\n <inline-graphic>1234-5678-rctb-45-05-690-gf01.tif</inline-graphic>\n </product>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_present_twice_in_product(self):\n sample = u\"\"\"<article article-type=\"book-review\">\n <front>\n <article-meta>\n <product product-type=\"chapter\">\n <person-group person-group-type=\"author\">\n <name>\n <surname>Sobrenome do autor</surname>\n <given-names>Prenomes do autor</given-names>\n </name>\n </person-group>\n <source>Título do livro</source>\n <chapter-title>Título do capítulo do livro</chapter-title>\n <chapter-title>Outro título do capítulo do livro</chapter-title>\n <year>Ano de publicação</year>\n <publisher-name>Nome da casa publicadora/Editora</publisher-name>\n <publisher-loc>Local de publicação</publisher-loc>\n <page-count count=\"total de paginação do livro (opcional)\"/>\n <isbn>ISBN do livro, se houver</isbn>\n <inline-graphic>1234-5678-rctb-45-05-690-gf01.tif</inline-graphic>\n </product>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass PersonGroupTests(PhaseBasedTestCase):\n \"\"\"Tests for\n - article/back/ref-list/ref/element-citation/person-group\n - article/front/article-meta/product/person-group\n \"\"\"\n sch_phase = 'phase.person-group'\n\n def test_missing_type(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n <person-group>\n <name>Foo</name>\n </person-group>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_missing_type_at_product(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <product>\n <person-group>\n <name>Foo</name>\n </person-group>\n </product>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_with_type(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n <person-group person-group-type=\"author\">\n <name>Foo</name>\n </person-group>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_allowed_types(self):\n for group_type in ['author', 'compiler', 'editor', 'translator']:\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n <person-group person-group-type=\"%s\">\n <name>Foo</name>\n </person-group>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\" % group_type\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_disallowed_type(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n <person-group person-group-type=\"invalid\">\n <name>Foo</name>\n </person-group>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_loose_text_below_element_citation_node(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation publication-type=\"journal\">\n <person-group person-group-type=\"author\">HERE\n <collab>Foo</collab>\n </person-group>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_loose_text_below_product_node(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <product>\n <person-group person-group-type=\"author\">HERE\n <collab>Foo</collab>\n </person-group>\n </product>\n </article-meta>\n </front>\n <back>\n <ref-list>\n <ref>\n <element-citation publication-type=\"journal\">\n <person-group person-group-type=\"author\">\n <collab>Foo</collab>\n </person-group>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass FNGroupTests(PhaseBasedTestCase):\n \"\"\"Tests for article/back/fn-group/fn element.\n \"\"\"\n sch_phase = 'phase.fn-group'\n\n def test_allowed_fn_types(self):\n for fn_type in ['abbr', 'com', 'financial-disclosure', 'supported-by',\n 'presented-at', 'supplementary-material', 'other']:\n\n sample = u\"\"\"<article>\n <back>\n <fn-group>\n <fn fn-type=\"%s\">\n <p>foobar</p>\n </fn>\n </fn-group>\n </back>\n </article>\n \"\"\" % fn_type\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_disallowed_fn_types(self):\n sample = u\"\"\"<article>\n <back>\n <fn-group>\n <fn fn-type=\"invalid\">\n <p>foobar</p>\n </fn>\n </fn-group>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_group_title(self):\n sample = u\"\"\"<article>\n <back>\n <fn-group>\n <title>Notes</title>\n <fn fn-type=\"other\">\n <p>foobar</p>\n </fn>\n </fn-group>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_many_group_titles_are_not_allowed(self):\n sample = u\"\"\"<article>\n <back>\n <fn-group>\n <title>Notes</title>\n <title>Notes again</title>\n <fn fn-type=\"other\">\n <p>foobar</p>\n </fn>\n </fn-group>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass XHTMLTableTests(PhaseBasedTestCase):\n \"\"\"Tests for //table elements.\n \"\"\"\n sch_phase = 'phase.xhtml-table'\n\n def test_valid_toplevel(self):\n for elem in ['caption', 'summary', 'col', 'colgroup', 'thead', 'tfoot', 'tbody']:\n\n sample = u\"\"\"<article>\n <body>\n <sec>\n <p>\n <table>\n <%s></%s>\n </table>\n </p>\n </sec>\n </body>\n </article>\n \"\"\" % (elem, elem)\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_invalid_toplevel(self):\n for elem in ['tr']:\n\n sample = u\"\"\"<article>\n <body>\n <sec>\n <p>\n <table>\n <%s></%s>\n </table>\n </p>\n </sec>\n </body>\n </article>\n \"\"\" % (elem, elem)\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_tbody_upon_th(self):\n sample = u\"\"\"<article>\n <body>\n <sec>\n <p>\n <table>\n <tbody>\n <tr>\n <th>Foo</th>\n </tr>\n </tbody>\n </table>\n </p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_thead_upon_th(self):\n sample = u\"\"\"<article>\n <body>\n <sec>\n <p>\n <table>\n <thead>\n <tr>\n <th>Foo</th>\n </tr>\n </thead>\n </table>\n </p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_thead_upon_td(self):\n sample = u\"\"\"<article>\n <body>\n <sec>\n <p>\n <table>\n <thead>\n <tr>\n <td>Foo</td>\n </tr>\n </thead>\n </table>\n </p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass SupplementaryMaterialMimetypeTests(PhaseBasedTestCase):\n \"\"\"Tests for article//supplementary-material elements.\n \"\"\"\n sch_phase = 'phase.supplementary-material'\n\n def test_case1(self):\n \"\"\"mimetype is True\n mime-subtype is True\n mimetype ^ mime-subtype is True\n \"\"\"\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <body>\n <supplementary-material id=\"S1\"\n xlink:title=\"local_file\"\n xlink:href=\"1471-2105-1-1-s1.pdf\"\n mimetype=\"application\"\n mime-subtype=\"pdf\">\n <label>Additional material</label>\n <caption>\n <p>Supplementary PDF file supplied by authors.</p>\n </caption>\n </supplementary-material>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_case2(self):\n \"\"\"mimetype is True\n mime-subtype is False\n mimetype ^ mime-subtype is False\n \"\"\"\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <body>\n <supplementary-material id=\"S1\"\n xlink:title=\"local_file\"\n xlink:href=\"1471-2105-1-1-s1.pdf\"\n mimetype=\"application\">\n <label>Additional material</label>\n <caption>\n <p>Supplementary PDF file supplied by authors.</p>\n </caption>\n </supplementary-material>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_case3(self):\n \"\"\"mimetype is False\n mime-subtype is True\n mimetype ^ mime-subtype is False\n \"\"\"\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <body>\n <supplementary-material id=\"S1\"\n xlink:title=\"local_file\"\n xlink:href=\"1471-2105-1-1-s1.pdf\"\n mime-subtype=\"pdf\">\n <label>Additional material</label>\n <caption>\n <p>Supplementary PDF file supplied by authors.</p>\n </caption>\n </supplementary-material>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_case4(self):\n \"\"\"mimetype is False\n mime-subtype is False\n mimetype ^ mime-subtype is False\n \"\"\"\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <body>\n <supplementary-material id=\"S1\"\n xlink:title=\"local_file\"\n xlink:href=\"1471-2105-1-1-s1.pdf\">\n <label>Additional material</label>\n <caption>\n <p>Supplementary PDF file supplied by authors.</p>\n </caption>\n </supplementary-material>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass AuthorNotesFNTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/article-meta/author-notes/fn element.\n \"\"\"\n sch_phase = 'phase.fn-group'\n\n def test_allowed_fn_types(self):\n for fn_type in ['author', 'con', 'conflict', 'corresp', 'current-aff',\n 'deceased', 'edited-by', 'equal', 'on-leave',\n 'participating-researchers', 'present-address',\n 'previously-at', 'study-group-members', 'other',\n 'presented-at', 'presented-by']:\n\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <author-notes>\n <fn fn-type=\"%s\">\n <p>foobar</p>\n </fn>\n </author-notes>\n </article-meta>\n </front>\n </article>\n \"\"\" % fn_type\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_disallowed_fn_types(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <author-notes>\n <fn fn-type=\"invalid\">\n <p>foobar</p>\n </fn>\n </author-notes>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass ArticleAttributesTests(PhaseBasedTestCase):\n \"\"\"Tests for article element.\n \"\"\"\n sch_phase = 'phase.article-attrs'\n\n def test_allowed_article_types(self):\n for art_type in ['addendum', 'research-article', 'review-article',\n 'letter', 'article-commentary', 'brief-report', 'rapid-communication',\n 'oration', 'discussion', 'editorial', 'interview', 'correction',\n 'guidelines', 'other', 'obituary', 'case-report', 'book-review',\n 'reply', 'retraction', 'partial-retraction', 'clinical-trial',\n 'announcement', 'calendar', 'in-brief', 'book-received', 'news',\n 'reprint', 'meeting-report', 'abstract', 'product-review',\n 'dissertation', 'translation']:\n\n sample = u\"\"\"<article article-type=\"%s\" xml:lang=\"en\" dtd-version=\"1.0\" specific-use=\"sps-1.8\">\n </article>\n \"\"\" % art_type\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_disallowed_article_type(self):\n sample = u\"\"\"<article article-type=\"invalid\" dtd-version=\"1.0\" specific-use=\"sps-1.8\">\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_missing_article_type(self):\n sample = u\"\"\"<article xml:lang=\"en\" dtd-version=\"1.0\" specific-use=\"sps-1.8\">\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_missing_xmllang(self):\n sample = u\"\"\"<article article-type=\"research-article\" dtd-version=\"1.0\" specific-use=\"sps-1.8\">\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_missing_dtdversion(self):\n sample = u\"\"\"<article article-type=\"research-article\" xml:lang=\"en\" specific-use=\"sps-1.8\">\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_missing_sps_version(self):\n sample = u\"\"\"<article article-type=\"research-article\" dtd-version=\"1.0\" xml:lang=\"en\">\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_invalid_sps_version(self):\n sample = u\"\"\"<article article-type=\"research-article\" dtd-version=\"1.0\" xml:lang=\"en\" specific-use=\"sps-1.0\">\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass NamedContentTests(PhaseBasedTestCase):\n \"\"\"Tests for article/front/article-meta/aff/addr-line/named-content elements.\n \"\"\"\n sch_phase = 'phase.named-content_attrs'\n\n def test_missing_contenttype(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <aff>\n <addr-line>\n <named-content>Foo</named-content>\n </addr-line>\n </aff>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_allowed_contenttype(self):\n for ctype in ['city', 'state']:\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <aff>\n <addr-line>\n <named-content content-type=\"%s\">Foo</named-content>\n </addr-line>\n </aff>\n </article-meta>\n </front>\n </article>\n \"\"\" % ctype\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_disallowed_contenttype(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <aff>\n <addr-line>\n <named-content content-type=\"invalid\">Foo</named-content>\n </addr-line>\n </aff>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass MonthTests(PhaseBasedTestCase):\n \"\"\"Tests for //month elements.\n \"\"\"\n sch_phase = 'phase.month'\n\n def test_range_1_12(self):\n for month in range(1, 13):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date>\n <month>%s</month>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\" % month\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_range_01_12(self):\n for month in range(1, 13):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date>\n <month>%02d</month>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\" % month\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_out_of_range(self):\n for month in [0, 13]:\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date>\n <month>%s</month>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\" % month\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_must_be_integer(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <pub-date>\n <month>January</month>\n </pub-date>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_is_present_in_elementcitation(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n <month>02</month>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_is_present_twice_in_elementcitation(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n <month>02</month>\n <month>02</month>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_is_absent_in_elementcitation(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n\nclass SizeTests(PhaseBasedTestCase):\n \"\"\"Tests for:\n - article/front/article-meta/product/size\n - article/back/ref-list/ref/element-citation/size\n \"\"\"\n sch_phase = 'phase.size'\n\n def test_in_element_citation(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n <size units=\"pages\">2</size>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_in_product(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <product>\n <size units=\"pages\">2</size>\n </product>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_missing_in_element_citation(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_missing_in_product(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <product>\n </product>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_twice_in_element_citation(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n <size units=\"pages\">2</size>\n <size units=\"pages\">2</size>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_twice_in_product(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <product>\n <size units=\"pages\">2</size>\n <size units=\"pages\">2</size>\n </product>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_missing_units_in_product(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <product>\n <size>2</size>\n </product>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_missing_units_in_element_citation(self):\n sample = u\"\"\"<article>\n <back>\n <ref-list>\n <ref>\n <element-citation>\n <size>2</size>\n </element-citation>\n </ref>\n </ref-list>\n </back>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_invalid_units_value(self):\n sample = u\"\"\"<article>\n <front>\n <article-meta>\n <product>\n <size units=\"invalid\">2</size>\n </product>\n </article-meta>\n </front>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass ListTests(PhaseBasedTestCase):\n \"\"\"Tests for list elements.\n \"\"\"\n sch_phase = 'phase.list'\n\n def test_allowed_list_type(self):\n for list_type in ['order', 'bullet', 'alpha-lower', 'alpha-upper',\n 'roman-lower', 'roman-upper', 'simple']:\n sample = u\"\"\"<article>\n <body>\n <sec>\n <p>\n <list list-type=\"%s\">\n <title>Lista Númerica</title>\n <list-item>\n <p>Nullam gravida tellus eget condimentum egestas.</p>\n </list-item>\n <list-item>\n <list list-type=\"%s\">\n <list-item>\n <p>Curabitur luctus lorem ac feugiat pretium.</p>\n </list-item>\n </list>\n </list-item>\n <list-item>\n <p>Donec pulvinar odio ut enim lobortis, eu dignissim elit accumsan.</p>\n </list-item>\n </list>\n </p>\n </sec>\n </body>\n </article>\n \"\"\" % (list_type, list_type)\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_disallowed_list_type(self):\n sample = u\"\"\"<article>\n <body>\n <sec>\n <p>\n <list list-type=\"invalid\">\n <title>Lista Númerica</title>\n <list-item>\n <p>Nullam gravida tellus eget condimentum egestas.</p>\n </list-item>\n <list-item>\n <list list-type=\"invalid\">\n <list-item>\n <p>Curabitur luctus lorem ac feugiat pretium.</p>\n </list-item>\n </list>\n </list-item>\n <list-item>\n <p>Donec pulvinar odio ut enim lobortis, eu dignissim elit accumsan.</p>\n </list-item>\n </list>\n </p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_disallowed_sub_list_type(self):\n sample = u\"\"\"<article>\n <body>\n <sec>\n <p>\n <list list-type=\"order\">\n <title>Lista Númerica</title>\n <list-item>\n <p>Nullam gravida tellus eget condimentum egestas.</p>\n </list-item>\n <list-item>\n <list list-type=\"invalid\">\n <list-item>\n <p>Curabitur luctus lorem ac feugiat pretium.</p>\n </list-item>\n </list>\n </list-item>\n <list-item>\n <p>Donec pulvinar odio ut enim lobortis, eu dignissim elit accumsan.</p>\n </list-item>\n </list>\n </p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_missing_list_type(self):\n sample = u\"\"\"<article>\n <body>\n <sec>\n <p>\n <list>\n <title>Lista Númerica</title>\n <list-item>\n <p>Nullam gravida tellus eget condimentum egestas.</p>\n </list-item>\n <list-item>\n <list>\n <list-item>\n <p>Curabitur luctus lorem ac feugiat pretium.</p>\n </list-item>\n </list>\n </list-item>\n <list-item>\n <p>Donec pulvinar odio ut enim lobortis, eu dignissim elit accumsan.</p>\n </list-item>\n </list>\n </p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_missing_sub_list_type(self):\n sample = u\"\"\"<article>\n <body>\n <sec>\n <p>\n <list list-type=\"order\">\n <title>Lista Númerica</title>\n <list-item>\n <p>Nullam gravida tellus eget condimentum egestas.</p>\n </list-item>\n <list-item>\n <list>\n <list-item>\n <p>Curabitur luctus lorem ac feugiat pretium.</p>\n </list-item>\n </list>\n </list-item>\n <list-item>\n <p>Donec pulvinar odio ut enim lobortis, eu dignissim elit accumsan.</p>\n </list-item>\n </list>\n </p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n\nclass MediaTests(PhaseBasedTestCase):\n \"\"\"Tests for article/body//p/media elements.\n \"\"\"\n sch_phase = 'phase.media_attributes'\n\n def test_missing_mimetype(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <body>\n <p><media mime-subtype=\"mp4\" xlink:href=\"1234-5678-rctb-45-05-0110-m01.mp4\"/></p>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_missing_mime_subtype(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <body>\n <p><media mimetype=\"video\" xlink:href=\"1234-5678-rctb-45-05-0110-m01.mp4\"/></p>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_missing_href(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <body>\n <p><media mimetype=\"video\" mime-subtype=\"mp4\"/></p>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_all_present(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <body>\n <p><media mimetype=\"video\" mime-subtype=\"mp4\" xlink:href=\"1234-5678-rctb-45-05-0110-m01.mp4\"/></p>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n\nclass ExtLinkTests(PhaseBasedTestCase):\n \"\"\"Tests for ext-link elements.\n \"\"\"\n sch_phase = 'phase.ext-link'\n\n def test_complete(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <body>\n <sec>\n <p>Neque porro quisquam est <ext-link ext-link-type=\"uri\" xlink:href=\"http://www.scielo.org\">www.scielo.org</ext-link> qui dolorem ipsum quia</p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_allowed_extlinktype(self):\n for link_type in ['uri', 'clinical-trial' ]:\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <body>\n <sec>\n <p>Neque porro quisquam est <ext-link ext-link-type=\"%s\" xlink:href=\"http://www.scielo.org\">www.scielo.org</ext-link> qui dolorem ipsum quia</p>\n </sec>\n </body>\n </article>\n \"\"\" % link_type\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertTrue(self._run_validation(sample))\n\n def test_disallowed_extlinktype(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <body>\n <sec>\n <p>Neque porro quisquam est <ext-link ext-link-type=\"invalid\" xlink:href=\"http://www.scielo.org\">www.scielo.org</ext-link> qui dolorem ipsum quia</p>\n </sec>\n </body>\n </article>\n \"\"\"\n sample = io.BytesIO(sample.encode('utf-8'))\n\n self.assertFalse(self._run_validation(sample))\n\n def test_missing_extlinktype(self):\n sample = u\"\"\"<article xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n"},"domain":{"kind":"string","value":"codeparrot/github-code-clean"}}},{"rowIdx":227196,"cells":{"text":{"kind":"string","value":"import builtins\nimport copyreg\nimport gc\nimport itertools\nimport math\nimport pickle\nimport sys\nimport types\nimport unittest\nimport warnings\nimport weakref\n\nfrom copy import deepcopy\nfrom test import support\n\n\nclass OperatorsTest(unittest.TestCase):\n\n def __init__(self, *args, **kwargs):\n unittest.TestCase.__init__(self, *args, **kwargs)\n self.binops = {\n 'add': '+',\n 'sub': '-',\n 'mul': '*',\n 'matmul': '@',\n 'truediv': '/',\n 'floordiv': '//',\n 'divmod': 'divmod',\n 'pow': '**',\n 'lshift': '<<',\n 'rshift': '>>',\n 'and': '&',\n 'xor': '^',\n 'or': '|',\n 'cmp': 'cmp',\n 'lt': '<',\n 'le': '<=',\n 'eq': '==',\n 'ne': '!=',\n 'gt': '>',\n 'ge': '>=',\n }\n\n for name, expr in list(self.binops.items()):\n if expr.islower():\n expr = expr + \"(a, b)\"\n else:\n expr = 'a %s b' % expr\n self.binops[name] = expr\n\n self.unops = {\n 'pos': '+',\n 'neg': '-',\n 'abs': 'abs',\n 'invert': '~',\n 'int': 'int',\n 'float': 'float',\n }\n\n for name, expr in list(self.unops.items()):\n if expr.islower():\n expr = expr + \"(a)\"\n else:\n expr = '%s a' % expr\n self.unops[name] = expr\n\n def unop_test(self, a, res, expr=\"len(a)\", meth=\"__len__\"):\n d = {'a': a}\n self.assertEqual(eval(expr, d), res)\n t = type(a)\n m = getattr(t, meth)\n\n # Find method in parent class\n while meth not in t.__dict__:\n t = t.__bases__[0]\n # in some implementations (e.g. PyPy), 'm' can be a regular unbound\n # method object; the getattr() below obtains its underlying function.\n self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])\n self.assertEqual(m(a), res)\n bm = getattr(a, meth)\n self.assertEqual(bm(), res)\n\n def binop_test(self, a, b, res, expr=\"a+b\", meth=\"__add__\"):\n d = {'a': a, 'b': b}\n\n self.assertEqual(eval(expr, d), res)\n t = type(a)\n m = getattr(t, meth)\n while meth not in t.__dict__:\n t = t.__bases__[0]\n # in some implementations (e.g. PyPy), 'm' can be a regular unbound\n # method object; the getattr() below obtains its underlying function.\n self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])\n self.assertEqual(m(a, b), res)\n bm = getattr(a, meth)\n self.assertEqual(bm(b), res)\n\n def sliceop_test(self, a, b, c, res, expr=\"a[b:c]\", meth=\"__getitem__\"):\n d = {'a': a, 'b': b, 'c': c}\n self.assertEqual(eval(expr, d), res)\n t = type(a)\n m = getattr(t, meth)\n while meth not in t.__dict__:\n t = t.__bases__[0]\n # in some implementations (e.g. PyPy), 'm' can be a regular unbound\n # method object; the getattr() below obtains its underlying function.\n self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])\n self.assertEqual(m(a, slice(b, c)), res)\n bm = getattr(a, meth)\n self.assertEqual(bm(slice(b, c)), res)\n\n def setop_test(self, a, b, res, stmt=\"a+=b\", meth=\"__iadd__\"):\n d = {'a': deepcopy(a), 'b': b}\n exec(stmt, d)\n self.assertEqual(d['a'], res)\n t = type(a)\n m = getattr(t, meth)\n while meth not in t.__dict__:\n t = t.__bases__[0]\n # in some implementations (e.g. PyPy), 'm' can be a regular unbound\n # method object; the getattr() below obtains its underlying function.\n self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])\n d['a'] = deepcopy(a)\n m(d['a'], b)\n self.assertEqual(d['a'], res)\n d['a'] = deepcopy(a)\n bm = getattr(d['a'], meth)\n bm(b)\n self.assertEqual(d['a'], res)\n\n def set2op_test(self, a, b, c, res, stmt=\"a[b]=c\", meth=\"__setitem__\"):\n d = {'a': deepcopy(a), 'b': b, 'c': c}\n exec(stmt, d)\n self.assertEqual(d['a'], res)\n t = type(a)\n m = getattr(t, meth)\n while meth not in t.__dict__:\n t = t.__bases__[0]\n # in some implementations (e.g. PyPy), 'm' can be a regular unbound\n # method object; the getattr() below obtains its underlying function.\n self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])\n d['a'] = deepcopy(a)\n m(d['a'], b, c)\n self.assertEqual(d['a'], res)\n d['a'] = deepcopy(a)\n bm = getattr(d['a'], meth)\n bm(b, c)\n self.assertEqual(d['a'], res)\n\n def setsliceop_test(self, a, b, c, d, res, stmt=\"a[b:c]=d\", meth=\"__setitem__\"):\n dictionary = {'a': deepcopy(a), 'b': b, 'c': c, 'd': d}\n exec(stmt, dictionary)\n self.assertEqual(dictionary['a'], res)\n t = type(a)\n while meth not in t.__dict__:\n t = t.__bases__[0]\n m = getattr(t, meth)\n # in some implementations (e.g. PyPy), 'm' can be a regular unbound\n # method object; the getattr() below obtains its underlying function.\n self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])\n dictionary['a'] = deepcopy(a)\n m(dictionary['a'], slice(b, c), d)\n self.assertEqual(dictionary['a'], res)\n dictionary['a'] = deepcopy(a)\n bm = getattr(dictionary['a'], meth)\n bm(slice(b, c), d)\n self.assertEqual(dictionary['a'], res)\n\n def test_lists(self):\n # Testing list operations...\n # Asserts are within individual test methods\n self.binop_test([1], [2], [1,2], \"a+b\", \"__add__\")\n self.binop_test([1,2,3], 2, 1, \"b in a\", \"__contains__\")\n self.binop_test([1,2,3], 4, 0, \"b in a\", \"__contains__\")\n self.binop_test([1,2,3], 1, 2, \"a[b]\", \"__getitem__\")\n self.sliceop_test([1,2,3], 0, 2, [1,2], \"a[b:c]\", \"__getitem__\")\n self.setop_test([1], [2], [1,2], \"a+=b\", \"__iadd__\")\n self.setop_test([1,2], 3, [1,2,1,2,1,2], \"a*=b\", \"__imul__\")\n self.unop_test([1,2,3], 3, \"len(a)\", \"__len__\")\n self.binop_test([1,2], 3, [1,2,1,2,1,2], \"a*b\", \"__mul__\")\n self.binop_test([1,2], 3, [1,2,1,2,1,2], \"b*a\", \"__rmul__\")\n self.set2op_test([1,2], 1, 3, [1,3], \"a[b]=c\", \"__setitem__\")\n self.setsliceop_test([1,2,3,4], 1, 3, [5,6], [1,5,6,4], \"a[b:c]=d\",\n \"__setitem__\")\n\n def test_dicts(self):\n # Testing dict operations...\n self.binop_test({1:2,3:4}, 1, 1, \"b in a\", \"__contains__\")\n self.binop_test({1:2,3:4}, 2, 0, \"b in a\", \"__contains__\")\n self.binop_test({1:2,3:4}, 1, 2, \"a[b]\", \"__getitem__\")\n\n d = {1:2, 3:4}\n l1 = []\n for i in list(d.keys()):\n l1.append(i)\n l = []\n for i in iter(d):\n l.append(i)\n self.assertEqual(l, l1)\n l = []\n for i in d.__iter__():\n l.append(i)\n self.assertEqual(l, l1)\n l = []\n for i in dict.__iter__(d):\n l.append(i)\n self.assertEqual(l, l1)\n d = {1:2, 3:4}\n self.unop_test(d, 2, \"len(a)\", \"__len__\")\n self.assertEqual(eval(repr(d), {}), d)\n self.assertEqual(eval(d.__repr__(), {}), d)\n self.set2op_test({1:2,3:4}, 2, 3, {1:2,2:3,3:4}, \"a[b]=c\",\n \"__setitem__\")\n\n # Tests for unary and binary operators\n def number_operators(self, a, b, skip=[]):\n dict = {'a': a, 'b': b}\n\n for name, expr in self.binops.items():\n if name not in skip:\n name = \"__%s__\" % name\n if hasattr(a, name):\n res = eval(expr, dict)\n self.binop_test(a, b, res, expr, name)\n\n for name, expr in list(self.unops.items()):\n if name not in skip:\n name = \"__%s__\" % name\n if hasattr(a, name):\n res = eval(expr, dict)\n self.unop_test(a, res, expr, name)\n\n def test_ints(self):\n # Testing int operations...\n self.number_operators(100, 3)\n # The following crashes in Python 2.2\n self.assertEqual((1).__bool__(), 1)\n self.assertEqual((0).__bool__(), 0)\n # This returns 'NotImplemented' in Python 2.2\n class C(int):\n def __add__(self, other):\n return NotImplemented\n self.assertEqual(C(5), 5)\n try:\n C() + \"\"\n except TypeError:\n pass\n else:\n self.fail(\"NotImplemented should have caused TypeError\")\n\n def test_floats(self):\n # Testing float operations...\n self.number_operators(100.0, 3.0)\n\n def test_complexes(self):\n # Testing complex operations...\n self.number_operators(100.0j, 3.0j, skip=['lt', 'le', 'gt', 'ge',\n 'int', 'float',\n 'floordiv', 'divmod', 'mod'])\n\n class Number(complex):\n __slots__ = ['prec']\n def __new__(cls, *args, **kwds):\n result = complex.__new__(cls, *args)\n result.prec = kwds.get('prec', 12)\n return result\n def __repr__(self):\n prec = self.prec\n if self.imag == 0.0:\n return \"%.*g\" % (prec, self.real)\n if self.real == 0.0:\n return \"%.*gj\" % (prec, self.imag)\n return \"(%.*g+%.*gj)\" % (prec, self.real, prec, self.imag)\n __str__ = __repr__\n\n a = Number(3.14, prec=6)\n self.assertEqual(repr(a), \"3.14\")\n self.assertEqual(a.prec, 6)\n\n a = Number(a, prec=2)\n self.assertEqual(repr(a), \"3.1\")\n self.assertEqual(a.prec, 2)\n\n a = Number(234.5)\n self.assertEqual(repr(a), \"234.5\")\n self.assertEqual(a.prec, 12)\n\n def test_explicit_reverse_methods(self):\n # see issue 9930\n self.assertEqual(complex.__radd__(3j, 4.0), complex(4.0, 3.0))\n self.assertEqual(float.__rsub__(3.0, 1), -2.0)\n\n @support.impl_detail(\"the module 'xxsubtype' is internal\")\n def test_spam_lists(self):\n # Testing spamlist operations...\n import copy, xxsubtype as spam\n\n def spamlist(l, memo=None):\n import xxsubtype as spam\n return spam.spamlist(l)\n\n # This is an ugly hack:\n copy._deepcopy_dispatch[spam.spamlist] = spamlist\n\n self.binop_test(spamlist([1]), spamlist([2]), spamlist([1,2]), \"a+b\",\n \"__add__\")\n self.binop_test(spamlist([1,2,3]), 2, 1, \"b in a\", \"__contains__\")\n self.binop_test(spamlist([1,2,3]), 4, 0, \"b in a\", \"__contains__\")\n self.binop_test(spamlist([1,2,3]), 1, 2, \"a[b]\", \"__getitem__\")\n self.sliceop_test(spamlist([1,2,3]), 0, 2, spamlist([1,2]), \"a[b:c]\",\n \"__getitem__\")\n self.setop_test(spamlist([1]), spamlist([2]), spamlist([1,2]), \"a+=b\",\n \"__iadd__\")\n self.setop_test(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), \"a*=b\",\n \"__imul__\")\n self.unop_test(spamlist([1,2,3]), 3, \"len(a)\", \"__len__\")\n self.binop_test(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), \"a*b\",\n \"__mul__\")\n self.binop_test(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), \"b*a\",\n \"__rmul__\")\n self.set2op_test(spamlist([1,2]), 1, 3, spamlist([1,3]), \"a[b]=c\",\n \"__setitem__\")\n self.setsliceop_test(spamlist([1,2,3,4]), 1, 3, spamlist([5,6]),\n spamlist([1,5,6,4]), \"a[b:c]=d\", \"__setitem__\")\n # Test subclassing\n class C(spam.spamlist):\n def foo(self): return 1\n a = C()\n self.assertEqual(a, [])\n self.assertEqual(a.foo(), 1)\n a.append(100)\n self.assertEqual(a, [100])\n self.assertEqual(a.getstate(), 0)\n a.setstate(42)\n self.assertEqual(a.getstate(), 42)\n\n @support.impl_detail(\"the module 'xxsubtype' is internal\")\n def test_spam_dicts(self):\n # Testing spamdict operations...\n import copy, xxsubtype as spam\n def spamdict(d, memo=None):\n import xxsubtype as spam\n sd = spam.spamdict()\n for k, v in list(d.items()):\n sd[k] = v\n return sd\n # This is an ugly hack:\n copy._deepcopy_dispatch[spam.spamdict] = spamdict\n\n self.binop_test(spamdict({1:2,3:4}), 1, 1, \"b in a\", \"__contains__\")\n self.binop_test(spamdict({1:2,3:4}), 2, 0, \"b in a\", \"__contains__\")\n self.binop_test(spamdict({1:2,3:4}), 1, 2, \"a[b]\", \"__getitem__\")\n d = spamdict({1:2,3:4})\n l1 = []\n for i in list(d.keys()):\n l1.append(i)\n l = []\n for i in iter(d):\n l.append(i)\n self.assertEqual(l, l1)\n l = []\n for i in d.__iter__():\n l.append(i)\n self.assertEqual(l, l1)\n l = []\n for i in type(spamdict({})).__iter__(d):\n l.append(i)\n self.assertEqual(l, l1)\n straightd = {1:2, 3:4}\n spamd = spamdict(straightd)\n self.unop_test(spamd, 2, \"len(a)\", \"__len__\")\n self.unop_test(spamd, repr(straightd), \"repr(a)\", \"__repr__\")\n self.set2op_test(spamdict({1:2,3:4}), 2, 3, spamdict({1:2,2:3,3:4}),\n \"a[b]=c\", \"__setitem__\")\n # Test subclassing\n class C(spam.spamdict):\n def foo(self): return 1\n a = C()\n self.assertEqual(list(a.items()), [])\n self.assertEqual(a.foo(), 1)\n a['foo'] = 'bar'\n self.assertEqual(list(a.items()), [('foo', 'bar')])\n self.assertEqual(a.getstate(), 0)\n a.setstate(100)\n self.assertEqual(a.getstate(), 100)\n\nclass ClassPropertiesAndMethods(unittest.TestCase):\n\n def assertHasAttr(self, obj, name):\n self.assertTrue(hasattr(obj, name),\n '%r has no attribute %r' % (obj, name))\n\n def assertNotHasAttr(self, obj, name):\n self.assertFalse(hasattr(obj, name),\n '%r has unexpected attribute %r' % (obj, name))\n\n def test_python_dicts(self):\n # Testing Python subclass of dict...\n self.assertTrue(issubclass(dict, dict))\n self.assertIsInstance({}, dict)\n d = dict()\n self.assertEqual(d, {})\n self.assertIs(d.__class__, dict)\n self.assertIsInstance(d, dict)\n class C(dict):\n state = -1\n def __init__(self_local, *a, **kw):\n if a:\n self.assertEqual(len(a), 1)\n self_local.state = a[0]\n if kw:\n for k, v in list(kw.items()):\n self_local[v] = k\n def __getitem__(self, key):\n return self.get(key, 0)\n def __setitem__(self_local, key, value):\n self.assertIsInstance(key, type(0))\n dict.__setitem__(self_local, key, value)\n def setstate(self, state):\n self.state = state\n def getstate(self):\n return self.state\n self.assertTrue(issubclass(C, dict))\n a1 = C(12)\n self.assertEqual(a1.state, 12)\n a2 = C(foo=1, bar=2)\n self.assertEqual(a2[1] == 'foo' and a2[2], 'bar')\n a = C()\n self.assertEqual(a.state, -1)\n self.assertEqual(a.getstate(), -1)\n a.setstate(0)\n self.assertEqual(a.state, 0)\n self.assertEqual(a.getstate(), 0)\n a.setstate(10)\n self.assertEqual(a.state, 10)\n self.assertEqual(a.getstate(), 10)\n self.assertEqual(a[42], 0)\n a[42] = 24\n self.assertEqual(a[42], 24)\n N = 50\n for i in range(N):\n a[i] = C()\n for j in range(N):\n a[i][j] = i*j\n for i in range(N):\n for j in range(N):\n self.assertEqual(a[i][j], i*j)\n\n def test_python_lists(self):\n # Testing Python subclass of list...\n class C(list):\n def __getitem__(self, i):\n if isinstance(i, slice):\n return i.start, i.stop\n return list.__getitem__(self, i) + 100\n a = C()\n a.extend([0,1,2])\n self.assertEqual(a[0], 100)\n self.assertEqual(a[1], 101)\n self.assertEqual(a[2], 102)\n self.assertEqual(a[100:200], (100,200))\n\n def test_metaclass(self):\n # Testing metaclasses...\n class C(metaclass=type):\n def __init__(self):\n self.__state = 0\n def getstate(self):\n return self.__state\n def setstate(self, state):\n self.__state = state\n a = C()\n self.assertEqual(a.getstate(), 0)\n a.setstate(10)\n self.assertEqual(a.getstate(), 10)\n class _metaclass(type):\n def myself(cls): return cls\n class D(metaclass=_metaclass):\n pass\n self.assertEqual(D.myself(), D)\n d = D()\n self.assertEqual(d.__class__, D)\n class M1(type):\n def __new__(cls, name, bases, dict):\n dict['__spam__'] = 1\n return type.__new__(cls, name, bases, dict)\n class C(metaclass=M1):\n pass\n self.assertEqual(C.__spam__, 1)\n c = C()\n self.assertEqual(c.__spam__, 1)\n\n class _instance(object):\n pass\n class M2(object):\n @staticmethod\n def __new__(cls, name, bases, dict):\n self = object.__new__(cls)\n self.name = name\n self.bases = bases\n self.dict = dict\n return self\n def __call__(self):\n it = _instance()\n # Early binding of methods\n for key in self.dict:\n if key.startswith(\"__\"):\n continue\n setattr(it, key, self.dict[key].__get__(it, self))\n return it\n class C(metaclass=M2):\n def spam(self):\n return 42\n self.assertEqual(C.name, 'C')\n self.assertEqual(C.bases, ())\n self.assertIn('spam', C.dict)\n c = C()\n self.assertEqual(c.spam(), 42)\n\n # More metaclass examples\n\n class autosuper(type):\n # Automatically add __super to the class\n # This trick only works for dynamic classes\n def __new__(metaclass, name, bases, dict):\n cls = super(autosuper, metaclass).__new__(metaclass,\n name, bases, dict)\n # Name mangling for __super removes leading underscores\n while name[:1] == \"_\":\n name = name[1:]\n if name:\n name = \"_%s__super\" % name\n else:\n name = \"__super\"\n setattr(cls, name, super(cls))\n return cls\n class A(metaclass=autosuper):\n def meth(self):\n return \"A\"\n class B(A):\n def meth(self):\n return \"B\" + self.__super.meth()\n class C(A):\n def meth(self):\n return \"C\" + self.__super.meth()\n class D(C, B):\n def meth(self):\n return \"D\" + self.__super.meth()\n self.assertEqual(D().meth(), \"DCBA\")\n class E(B, C):\n def meth(self):\n return \"E\" + self.__super.meth()\n self.assertEqual(E().meth(), \"EBCA\")\n\n class autoproperty(type):\n # Automatically create property attributes when methods\n # named _get_x and/or _set_x are found\n def __new__(metaclass, name, bases, dict):\n hits = {}\n for key, val in dict.items():\n if key.startswith(\"_get_\"):\n key = key[5:]\n get, set = hits.get(key, (None, None))\n get = val\n hits[key] = get, set\n elif key.startswith(\"_set_\"):\n key = key[5:]\n get, set = hits.get(key, (None, None))\n set = val\n hits[key] = get, set\n for key, (get, set) in hits.items():\n dict[key] = property(get, set)\n return super(autoproperty, metaclass).__new__(metaclass,\n name, bases, dict)\n class A(metaclass=autoproperty):\n def _get_x(self):\n return -self.__x\n def _set_x(self, x):\n self.__x = -x\n a = A()\n self.assertNotHasAttr(a, \"x\")\n a.x = 12\n self.assertEqual(a.x, 12)\n self.assertEqual(a._A__x, -12)\n\n class multimetaclass(autoproperty, autosuper):\n # Merge of multiple cooperating metaclasses\n pass\n class A(metaclass=multimetaclass):\n def _get_x(self):\n return \"A\"\n class B(A):\n def _get_x(self):\n return \"B\" + self.__super._get_x()\n class C(A):\n def _get_x(self):\n return \"C\" + self.__super._get_x()\n class D(C, B):\n def _get_x(self):\n return \"D\" + self.__super._get_x()\n self.assertEqual(D().x, \"DCBA\")\n\n # Make sure type(x) doesn't call x.__class__.__init__\n class T(type):\n counter = 0\n def __init__(self, *args):\n T.counter += 1\n class C(metaclass=T):\n pass\n self.assertEqual(T.counter, 1)\n a = C()\n self.assertEqual(type(a), C)\n self.assertEqual(T.counter, 1)\n\n class C(object): pass\n c = C()\n try: c()\n except TypeError: pass\n else: self.fail(\"calling object w/o call method should raise \"\n \"TypeError\")\n\n # Testing code to find most derived baseclass\n class A(type):\n def __new__(*args, **kwargs):\n return type.__new__(*args, **kwargs)\n\n class B(object):\n pass\n\n class C(object, metaclass=A):\n pass\n\n # The most derived metaclass of D is A rather than type.\n class D(B, C):\n pass\n self.assertIs(A, type(D))\n\n # issue1294232: correct metaclass calculation\n new_calls = [] # to check the order of __new__ calls\n class AMeta(type):\n @staticmethod\n def __new__(mcls, name, bases, ns):\n new_calls.append('AMeta')\n return super().__new__(mcls, name, bases, ns)\n @classmethod\n def __prepare__(mcls, name, bases):\n return {}\n\n class BMeta(AMeta):\n @staticmethod\n def __new__(mcls, name, bases, ns):\n new_calls.append('BMeta')\n return super().__new__(mcls, name, bases, ns)\n @classmethod\n def __prepare__(mcls, name, bases):\n ns = super().__prepare__(name, bases)\n ns['BMeta_was_here'] = True\n return ns\n\n class A(metaclass=AMeta):\n pass\n self.assertEqual(['AMeta'], new_calls)\n new_calls.clear()\n\n class B(metaclass=BMeta):\n pass\n # BMeta.__new__ calls AMeta.__new__ with super:\n self.assertEqual(['BMeta', 'AMeta'], new_calls)\n new_calls.clear()\n\n class C(A, B):\n pass\n # The most derived metaclass is BMeta:\n self.assertEqual(['BMeta', 'AMeta'], new_calls)\n new_calls.clear()\n # BMeta.__prepare__ should've been called:\n self.assertIn('BMeta_was_here', C.__dict__)\n\n # The order of the bases shouldn't matter:\n class C2(B, A):\n pass\n self.assertEqual(['BMeta', 'AMeta'], new_calls)\n new_calls.clear()\n self.assertIn('BMeta_was_here', C2.__dict__)\n\n # Check correct metaclass calculation when a metaclass is declared:\n class D(C, metaclass=type):\n pass\n self.assertEqual(['BMeta', 'AMeta'], new_calls)\n new_calls.clear()\n self.assertIn('BMeta_was_here', D.__dict__)\n\n class E(C, metaclass=AMeta):\n pass\n self.assertEqual(['BMeta', 'AMeta'], new_calls)\n new_calls.clear()\n self.assertIn('BMeta_was_here', E.__dict__)\n\n # Special case: the given metaclass isn't a class,\n # so there is no metaclass calculation.\n marker = object()\n def func(*args, **kwargs):\n return marker\n class X(metaclass=func):\n pass\n class Y(object, metaclass=func):\n pass\n class Z(D, metaclass=func):\n pass\n self.assertIs(marker, X)\n self.assertIs(marker, Y)\n self.assertIs(marker, Z)\n\n # The given metaclass is a class,\n # but not a descendant of type.\n prepare_calls = [] # to track __prepare__ calls\n class ANotMeta:\n def __new__(mcls, *args, **kwargs):\n new_calls.append('ANotMeta')\n return super().__new__(mcls)\n @classmethod\n def __prepare__(mcls, name, bases):\n prepare_calls.append('ANotMeta')\n return {}\n class BNotMeta(ANotMeta):\n def __new__(mcls, *args, **kwargs):\n new_calls.append('BNotMeta')\n return super().__new__(mcls)\n @classmethod\n def __prepare__(mcls, name, bases):\n prepare_calls.append('BNotMeta')\n return super().__prepare__(name, bases)\n\n class A(metaclass=ANotMeta):\n pass\n self.assertIs(ANotMeta, type(A))\n self.assertEqual(['ANotMeta'], prepare_calls)\n prepare_calls.clear()\n self.assertEqual(['ANotMeta'], new_calls)\n new_calls.clear()\n\n class B(metaclass=BNotMeta):\n pass\n self.assertIs(BNotMeta, type(B))\n self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls)\n prepare_calls.clear()\n self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls)\n new_calls.clear()\n\n class C(A, B):\n pass\n self.assertIs(BNotMeta, type(C))\n self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls)\n new_calls.clear()\n self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls)\n prepare_calls.clear()\n\n class C2(B, A):\n pass\n self.assertIs(BNotMeta, type(C2))\n self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls)\n new_calls.clear()\n self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls)\n prepare_calls.clear()\n\n # This is a TypeError, because of a metaclass conflict:\n # BNotMeta is neither a subclass, nor a superclass of type\n with self.assertRaises(TypeError):\n class D(C, metaclass=type):\n pass\n\n class E(C, metaclass=ANotMeta):\n pass\n self.assertIs(BNotMeta, type(E))\n self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls)\n new_calls.clear()\n self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls)\n prepare_calls.clear()\n\n class F(object(), C):\n pass\n self.assertIs(BNotMeta, type(F))\n self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls)\n new_calls.clear()\n self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls)\n prepare_calls.clear()\n\n class F2(C, object()):\n pass\n self.assertIs(BNotMeta, type(F2))\n self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls)\n new_calls.clear()\n self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls)\n prepare_calls.clear()\n\n # TypeError: BNotMeta is neither a\n # subclass, nor a superclass of int\n with self.assertRaises(TypeError):\n class X(C, int()):\n pass\n with self.assertRaises(TypeError):\n class X(int(), C):\n pass\n\n def test_module_subclasses(self):\n # Testing Python subclass of module...\n log = []\n MT = type(sys)\n class MM(MT):\n def __init__(self, name):\n MT.__init__(self, name)\n def __getattribute__(self, name):\n log.append((\"getattr\", name))\n return MT.__getattribute__(self, name)\n def __setattr__(self, name, value):\n log.append((\"setattr\", name, value))\n MT.__setattr__(self, name, value)\n def __delattr__(self, name):\n log.append((\"delattr\", name))\n MT.__delattr__(self, name)\n a = MM(\"a\")\n a.foo = 12\n x = a.foo\n del a.foo\n self.assertEqual(log, [(\"setattr\", \"foo\", 12),\n (\"getattr\", \"foo\"),\n (\"delattr\", \"foo\")])\n\n # http://python.org/sf/1174712\n try:\n class Module(types.ModuleType, str):\n pass\n except TypeError:\n pass\n else:\n self.fail(\"inheriting from ModuleType and str at the same time \"\n \"should fail\")\n\n def test_multiple_inheritance(self):\n # Testing multiple inheritance...\n class C(object):\n def __init__(self):\n self.__state = 0\n def getstate(self):\n return self.__state\n def setstate(self, state):\n self.__state = state\n a = C()\n self.assertEqual(a.getstate(), 0)\n a.setstate(10)\n self.assertEqual(a.getstate(), 10)\n class D(dict, C):\n def __init__(self):\n type({}).__init__(self)\n C.__init__(self)\n d = D()\n self.assertEqual(list(d.keys()), [])\n d[\"hello\"] = \"world\"\n self.assertEqual(list(d.items()), [(\"hello\", \"world\")])\n self.assertEqual(d[\"hello\"], \"world\")\n self.assertEqual(d.getstate(), 0)\n d.setstate(10)\n self.assertEqual(d.getstate(), 10)\n self.assertEqual(D.__mro__, (D, dict, C, object))\n\n # SF bug #442833\n class Node(object):\n def __int__(self):\n return int(self.foo())\n def foo(self):\n return \"23\"\n class Frag(Node, list):\n def foo(self):\n return \"42\"\n self.assertEqual(Node().__int__(), 23)\n self.assertEqual(int(Node()), 23)\n self.assertEqual(Frag().__int__(), 42)\n self.assertEqual(int(Frag()), 42)\n\n def test_diamond_inheritance(self):\n # Testing multiple inheritance special cases...\n class A(object):\n def spam(self): return \"A\"\n self.assertEqual(A().spam(), \"A\")\n class B(A):\n def boo(self): return \"B\"\n def spam(self): return \"B\"\n self.assertEqual(B().spam(), \"B\")\n self.assertEqual(B().boo(), \"B\")\n class C(A):\n def boo(self): return \"C\"\n self.assertEqual(C().spam(), \"A\")\n self.assertEqual(C().boo(), \"C\")\n class D(B, C): pass\n self.assertEqual(D().spam(), \"B\")\n self.assertEqual(D().boo(), \"B\")\n self.assertEqual(D.__mro__, (D, B, C, A, object))\n class E(C, B): pass\n self.assertEqual(E().spam(), \"B\")\n self.assertEqual(E().boo(), \"C\")\n self.assertEqual(E.__mro__, (E, C, B, A, object))\n # MRO order disagreement\n try:\n class F(D, E): pass\n except TypeError:\n pass\n else:\n self.fail(\"expected MRO order disagreement (F)\")\n try:\n class G(E, D): pass\n except TypeError:\n pass\n else:\n self.fail(\"expected MRO order disagreement (G)\")\n\n # see thread python-dev/2002-October/029035.html\n def test_ex5_from_c3_switch(self):\n # Testing ex5 from C3 switch discussion...\n class A(object): pass\n class B(object): pass\n class C(object): pass\n class X(A): pass\n class Y(A): pass\n class Z(X,B,Y,C): pass\n self.assertEqual(Z.__mro__, (Z, X, B, Y, A, C, object))\n\n # see \"A Monotonic Superclass Linearization for Dylan\",\n # by Kim Barrett et al. (OOPSLA 1996)\n def test_monotonicity(self):\n # Testing MRO monotonicity...\n class Boat(object): pass\n class DayBoat(Boat): pass\n class WheelBoat(Boat): pass\n class EngineLess(DayBoat): pass\n class SmallMultihull(DayBoat): pass\n class PedalWheelBoat(EngineLess,WheelBoat): pass\n class SmallCatamaran(SmallMultihull): pass\n class Pedalo(PedalWheelBoat,SmallCatamaran): pass\n\n self.assertEqual(PedalWheelBoat.__mro__,\n (PedalWheelBoat, EngineLess, DayBoat, WheelBoat, Boat, object))\n self.assertEqual(SmallCatamaran.__mro__,\n (SmallCatamaran, SmallMultihull, DayBoat, Boat, object))\n self.assertEqual(Pedalo.__mro__,\n (Pedalo, PedalWheelBoat, EngineLess, SmallCatamaran,\n SmallMultihull, DayBoat, WheelBoat, Boat, object))\n\n # see \"A Monotonic Superclass Linearization for Dylan\",\n # by Kim Barrett et al. (OOPSLA 1996)\n def test_consistency_with_epg(self):\n # Testing consistency with EPG...\n class Pane(object): pass\n class ScrollingMixin(object): pass\n class EditingMixin(object): pass\n class ScrollablePane(Pane,ScrollingMixin): pass\n class EditablePane(Pane,EditingMixin): pass\n class EditableScrollablePane(ScrollablePane,EditablePane): pass\n\n self.assertEqual(EditableScrollablePane.__mro__,\n (EditableScrollablePane, ScrollablePane, EditablePane, Pane,\n ScrollingMixin, EditingMixin, object))\n\n def test_mro_disagreement(self):\n # Testing error messages for MRO disagreement...\n mro_err_msg = \"\"\"Cannot create a consistent method resolution\norder (MRO) for bases \"\"\"\n\n def raises(exc, expected, callable, *args):\n try:\n callable(*args)\n except exc as msg:\n # the exact msg is generally considered an impl detail\n if support.check_impl_detail():\n if not str(msg).startswith(expected):\n self.fail(\"Message %r, expected %r\" %\n (str(msg), expected))\n else:\n self.fail(\"Expected %s\" % exc)\n\n class A(object): pass\n class B(A): pass\n class C(object): pass\n\n # Test some very simple errors\n raises(TypeError, \"duplicate base class A\",\n type, \"X\", (A, A), {})\n raises(TypeError, mro_err_msg,\n type, \"X\", (A, B), {})\n raises(TypeError, mro_err_msg,\n type, \"X\", (A, C, B), {})\n # Test a slightly more complex error\n class GridLayout(object): pass\n class HorizontalGrid(GridLayout): pass\n class VerticalGrid(GridLayout): pass\n class HVGrid(HorizontalGrid, VerticalGrid): pass\n class VHGrid(VerticalGrid, HorizontalGrid): pass\n raises(TypeError, mro_err_msg,\n type, \"ConfusedGrid\", (HVGrid, VHGrid), {})\n\n def test_object_class(self):\n # Testing object class...\n a = object()\n self.assertEqual(a.__class__, object)\n self.assertEqual(type(a), object)\n b = object()\n self.assertNotEqual(a, b)\n self.assertNotHasAttr(a, \"foo\")\n try:\n a.foo = 12\n except (AttributeError, TypeError):\n pass\n else:\n self.fail(\"object() should not allow setting a foo attribute\")\n self.assertNotHasAttr(object(), \"__dict__\")\n\n class Cdict(object):\n pass\n x = Cdict()\n self.assertEqual(x.__dict__, {})\n x.foo = 1\n self.assertEqual(x.foo, 1)\n self.assertEqual(x.__dict__, {'foo': 1})\n\n def test_object_class_assignment_between_heaptypes_and_nonheaptypes(self):\n class SubType(types.ModuleType):\n a = 1\n\n m = types.ModuleType(\"m\")\n self.assertTrue(m.__class__ is types.ModuleType)\n self.assertFalse(hasattr(m, \"a\"))\n\n m.__class__ = SubType\n self.assertTrue(m.__class__ is SubType)\n self.assertTrue(hasattr(m, \"a\"))\n\n m.__class__ = types.ModuleType\n self.assertTrue(m.__class__ is types.ModuleType)\n self.assertFalse(hasattr(m, \"a\"))\n\n # Make sure that builtin immutable objects don't support __class__\n # assignment, because the object instances may be interned.\n # We set __slots__ = () to ensure that the subclasses are\n # memory-layout compatible, and thus otherwise reasonable candidates\n # for __class__ assignment.\n\n # The following types have immutable instances, but are not\n # subclassable and thus don't need to be checked:\n # NoneType, bool\n\n class MyInt(int):\n __slots__ = ()\n with self.assertRaises(TypeError):\n (1).__class__ = MyInt\n\n class MyFloat(float):\n __slots__ = ()\n with self.assertRaises(TypeError):\n (1.0).__class__ = MyFloat\n\n class MyComplex(complex):\n __slots__ = ()\n with self.assertRaises(TypeError):\n (1 + 2j).__class__ = MyComplex\n\n class MyStr(str):\n __slots__ = ()\n with self.assertRaises(TypeError):\n \"a\".__class__ = MyStr\n\n class MyBytes(bytes):\n __slots__ = ()\n with self.assertRaises(TypeError):\n b\"a\".__class__ = MyBytes\n\n class MyTuple(tuple):\n __slots__ = ()\n with self.assertRaises(TypeError):\n ().__class__ = MyTuple\n\n class MyFrozenSet(frozenset):\n __slots__ = ()\n with self.assertRaises(TypeError):\n frozenset().__class__ = MyFrozenSet\n\n def test_slots(self):\n # Testing __slots__...\n class C0(object):\n __slots__ = []\n x = C0()\n self.assertNotHasAttr(x, \"__dict__\")\n self.assertNotHasAttr(x, \"foo\")\n\n class C1(object):\n __slots__ = ['a']\n x = C1()\n self.assertNotHasAttr(x, \"__dict__\")\n self.assertNotHasAttr(x, \"a\")\n x.a = 1\n self.assertEqual(x.a, 1)\n x.a = None\n self.assertEqual(x.a, None)\n del x.a\n self.assertNotHasAttr(x, \"a\")\n\n class C3(object):\n __slots__ = ['a', 'b', 'c']\n x = C3()\n self.assertNotHasAttr(x, \"__dict__\")\n self.assertNotHasAttr(x, 'a')\n self.assertNotHasAttr(x, 'b')\n self.assertNotHasAttr(x, 'c')\n x.a = 1\n x.b = 2\n x.c = 3\n self.assertEqual(x.a, 1)\n self.assertEqual(x.b, 2)\n self.assertEqual(x.c, 3)\n\n class C4(object):\n \"\"\"Validate name mangling\"\"\"\n __slots__ = ['__a']\n def __init__(self, value):\n self.__a = value\n def get(self):\n return self.__a\n x = C4(5)\n self.assertNotHasAttr(x, '__dict__')\n self.assertNotHasAttr(x, '__a')\n self.assertEqual(x.get(), 5)\n try:\n x.__a = 6\n except AttributeError:\n pass\n else:\n self.fail(\"Double underscored names not mangled\")\n\n # Make sure slot names are proper identifiers\n try:\n class C(object):\n __slots__ = [None]\n except TypeError:\n pass\n else:\n self.fail(\"[None] slots not caught\")\n try:\n class C(object):\n __slots__ = [\"foo bar\"]\n except TypeError:\n pass\n else:\n self.fail(\"['foo bar'] slots not caught\")\n try:\n class C(object):\n __slots__ = [\"foo\\0bar\"]\n except TypeError:\n pass\n else:\n self.fail(\"['foo\\\\0bar'] slots not caught\")\n try:\n class C(object):\n __slots__ = [\"1\"]\n except TypeError:\n pass\n else:\n self.fail(\"['1'] slots not caught\")\n try:\n class C(object):\n __slots__ = [\"\"]\n except TypeError:\n pass\n else:\n self.fail(\"[''] slots not caught\")\n class C(object):\n __slots__ = [\"a\", \"a_b\", \"_a\", \"A0123456789Z\"]\n # XXX(nnorwitz): was there supposed to be something tested\n # from the class above?\n\n # Test a single string is not expanded as a sequence.\n class C(object):\n __slots__ = \"abc\"\n c = C()\n c.abc = 5\n self.assertEqual(c.abc, 5)\n\n # Test unicode slot names\n # Test a single unicode string is not expanded as a sequence.\n class C(object):\n __slots__ = \"abc\"\n c = C()\n c.abc = 5\n self.assertEqual(c.abc, 5)\n\n # _unicode_to_string used to modify slots in certain circumstances\n slots = (\"foo\", \"bar\")\n class C(object):\n __slots__ = slots\n x = C()\n x.foo = 5\n self.assertEqual(x.foo, 5)\n self.assertIs(type(slots[0]), str)\n # this used to leak references\n try:\n class C(object):\n __slots__ = [chr(128)]\n except (TypeError, UnicodeEncodeError):\n pass\n else:\n self.fail(\"[chr(128)] slots not caught\")\n\n # Test leaks\n class Counted(object):\n counter = 0 # counts the number of instances alive\n def __init__(self):\n Counted.counter += 1\n def __del__(self):\n Counted.counter -= 1\n class C(object):\n __slots__ = ['a', 'b', 'c']\n x = C()\n x.a = Counted()\n x.b = Counted()\n x.c = Counted()\n self.assertEqual(Counted.counter, 3)\n del x\n support.gc_collect()\n self.assertEqual(Counted.counter, 0)\n class D(C):\n pass\n x = D()\n x.a = Counted()\n x.z = Counted()\n self.assertEqual(Counted.counter, 2)\n del x\n support.gc_collect()\n self.assertEqual(Counted.counter, 0)\n class E(D):\n __slots__ = ['e']\n x = E()\n x.a = Counted()\n x.z = Counted()\n x.e = Counted()\n self.assertEqual(Counted.counter, 3)\n del x\n support.gc_collect()\n self.assertEqual(Counted.counter, 0)\n\n # Test cyclical leaks [SF bug 519621]\n class F(object):\n __slots__ = ['a', 'b']\n s = F()\n s.a = [Counted(), s]\n self.assertEqual(Counted.counter, 1)\n s = None\n support.gc_collect()\n self.assertEqual(Counted.counter, 0)\n\n # Test lookup leaks [SF bug 572567]\n if hasattr(gc, 'get_objects'):\n class G(object):\n def __eq__(self, other):\n return False\n g = G()\n orig_objects = len(gc.get_objects())\n for i in range(10):\n g==g\n new_objects = len(gc.get_objects())\n self.assertEqual(orig_objects, new_objects)\n\n class H(object):\n __slots__ = ['a', 'b']\n def __init__(self):\n self.a = 1\n self.b = 2\n def __del__(self_):\n self.assertEqual(self_.a, 1)\n self.assertEqual(self_.b, 2)\n with support.captured_output('stderr') as s:\n h = H()\n del h\n self.assertEqual(s.getvalue(), '')\n\n class X(object):\n __slots__ = \"a\"\n with self.assertRaises(AttributeError):\n del X().a\n\n def test_slots_special(self):\n # Testing __dict__ and __weakref__ in __slots__...\n class D(object):\n __slots__ = [\"__dict__\"]\n a = D()\n self.assertHasAttr(a, \"__dict__\")\n self.assertNotHasAttr(a, \"__weakref__\")\n a.foo = 42\n self.assertEqual(a.__dict__, {\"foo\": 42})\n\n class W(object):\n __slots__ = [\"__weakref__\"]\n a = W()\n self.assertHasAttr(a, \"__weakref__\")\n self.assertNotHasAttr(a, \"__dict__\")\n try:\n a.foo = 42\n except AttributeError:\n pass\n else:\n self.fail(\"shouldn't be allowed to set a.foo\")\n\n class C1(W, D):\n __slots__ = []\n a = C1()\n self.assertHasAttr(a, \"__dict__\")\n self.assertHasAttr(a, \"__weakref__\")\n a.foo = 42\n self.assertEqual(a.__dict__, {\"foo\": 42})\n\n class C2(D, W):\n __slots__ = []\n a = C2()\n self.assertHasAttr(a, \"__dict__\")\n self.assertHasAttr(a, \"__weakref__\")\n a.foo = 42\n self.assertEqual(a.__dict__, {\"foo\": 42})\n\n def test_slots_special2(self):\n # Testing __qualname__ and __classcell__ in __slots__\n class Meta(type):\n def __new__(cls, name, bases, namespace, attr):\n self.assertIn(attr, namespace)\n return super().__new__(cls, name, bases, namespace)\n\n class C1:\n def __init__(self):\n self.b = 42\n class C2(C1, metaclass=Meta, attr=\"__classcell__\"):\n __slots__ = [\"__classcell__\"]\n def __init__(self):\n super().__init__()\n self.assertIsInstance(C2.__dict__[\"__classcell__\"],\n types.MemberDescriptorType)\n c = C2()\n self.assertEqual(c.b, 42)\n self.assertNotHasAttr(c, \"__classcell__\")\n c.__classcell__ = 42\n self.assertEqual(c.__classcell__, 42)\n with self.assertRaises(TypeError):\n class C3:\n __classcell__ = 42\n __slots__ = [\"__classcell__\"]\n\n class Q1(metaclass=Meta, attr=\"__qualname__\"):\n __slots__ = [\"__qualname__\"]\n self.assertEqual(Q1.__qualname__, C1.__qualname__[:-2] + \"Q1\")\n self.assertIsInstance(Q1.__dict__[\"__qualname__\"],\n types.MemberDescriptorType)\n q = Q1()\n self.assertNotHasAttr(q, \"__qualname__\")\n q.__qualname__ = \"q\"\n self.assertEqual(q.__qualname__, \"q\")\n with self.assertRaises(TypeError):\n class Q2:\n __qualname__ = object()\n __slots__ = [\"__qualname__\"]\n\n def test_slots_descriptor(self):\n # Issue2115: slot descriptors did not correctly check\n # the type of the given object\n import abc\n class MyABC(metaclass=abc.ABCMeta):\n __slots__ = \"a\"\n\n class Unrelated(object):\n pass\n MyABC.register(Unrelated)\n\n u = Unrelated()\n self.assertIsInstance(u, MyABC)\n\n # This used to crash\n self.assertRaises(TypeError, MyABC.a.__set__, u, 3)\n\n def test_dynamics(self):\n # Testing class attribute propagation...\n class D(object):\n pass\n class E(D):\n pass\n class F(D):\n pass\n D.foo = 1\n self.assertEqual(D.foo, 1)\n # Test that dynamic attributes are inherited\n self.assertEqual(E.foo, 1)\n self.assertEqual(F.foo, 1)\n # Test dynamic instances\n class C(object):\n pass\n a = C()\n self.assertNotHasAttr(a, \"foobar\")\n C.foobar = 2\n self.assertEqual(a.foobar, 2)\n C.method = lambda self: 42\n self.assertEqual(a.method(), 42)\n C.__repr__ = lambda self: \"C()\"\n self.assertEqual(repr(a), \"C()\")\n C.__int__ = lambda self: 100\n self.assertEqual(int(a), 100)\n self.assertEqual(a.foobar, 2)\n self.assertNotHasAttr(a, \"spam\")\n def mygetattr(self, name):\n if name == \"spam\":\n return \"spam\"\n raise AttributeError\n C.__getattr__ = mygetattr\n self.assertEqual(a.spam, \"spam\")\n a.new = 12\n self.assertEqual(a.new, 12)\n def mysetattr(self, name, value):\n if name == \"spam\":\n raise AttributeError\n return object.__setattr__(self, name, value)\n C.__setattr__ = mysetattr\n try:\n a.spam = \"not spam\"\n except AttributeError:\n pass\n else:\n self.fail(\"expected AttributeError\")\n self.assertEqual(a.spam, \"spam\")\n class D(C):\n pass\n d = D()\n d.foo = 1\n self.assertEqual(d.foo, 1)\n\n # Test handling of int*seq and seq*int\n class I(int):\n pass\n self.assertEqual(\"a\"*I(2), \"aa\")\n self.assertEqual(I(2)*\"a\", \"aa\")\n self.assertEqual(2*I(3), 6)\n self.assertEqual(I(3)*2, 6)\n self.assertEqual(I(3)*I(2), 6)\n\n # Test comparison of classes with dynamic metaclasses\n class dynamicmetaclass(type):\n pass\n class someclass(metaclass=dynamicmetaclass):\n pass\n self.assertNotEqual(someclass, object)\n\n def test_errors(self):\n # Testing errors...\n try:\n class C(list, dict):\n pass\n except TypeError:\n pass\n else:\n self.fail(\"inheritance from both list and dict should be illegal\")\n\n try:\n class C(object, None):\n pass\n except TypeError:\n pass\n else:\n self.fail(\"inheritance from non-type should be illegal\")\n class Classic:\n pass\n\n try:\n class C(type(len)):\n pass\n except TypeError:\n pass\n else:\n self.fail(\"inheritance from CFunction should be illegal\")\n\n try:\n class C(object):\n __slots__ = 1\n except TypeError:\n pass\n else:\n self.fail(\"__slots__ = 1 should be illegal\")\n\n try:\n class C(object):\n __slots__ = [1]\n except TypeError:\n pass\n else:\n self.fail(\"__slots__ = [1] should be illegal\")\n\n class M1(type):\n pass\n class M2(type):\n pass\n class A1(object, metaclass=M1):\n pass\n class A2(object, metaclass=M2):\n pass\n try:\n class B(A1, A2):\n pass\n except TypeError:\n pass\n else:\n self.fail(\"finding the most derived metaclass should have failed\")\n\n def test_classmethods(self):\n # Testing class methods...\n class C(object):\n def foo(*a): return a\n goo = classmethod(foo)\n c = C()\n self.assertEqual(C.goo(1), (C, 1))\n self.assertEqual(c.goo(1), (C, 1))\n self.assertEqual(c.foo(1), (c, 1))\n class D(C):\n pass\n d = D()\n self.assertEqual(D.goo(1), (D, 1))\n self.assertEqual(d.goo(1), (D, 1))\n self.assertEqual(d.foo(1), (d, 1))\n self.assertEqual(D.foo(d, 1), (d, 1))\n # Test for a specific crash (SF bug 528132)\n def f(cls, arg): return (cls, arg)\n ff = classmethod(f)\n self.assertEqual(ff.__get__(0, int)(42), (int, 42))\n self.assertEqual(ff.__get__(0)(42), (int, 42))\n\n # Test super() with classmethods (SF bug 535444)\n self.assertEqual(C.goo.__self__, C)\n self.assertEqual(D.goo.__self__, D)\n self.assertEqual(super(D,D).goo.__self__, D)\n self.assertEqual(super(D,d).goo.__self__, D)\n self.assertEqual(super(D,D).goo(), (D,))\n self.assertEqual(super(D,d).goo(), (D,))\n\n # Verify that a non-callable will raise\n meth = classmethod(1).__get__(1)\n self.assertRaises(TypeError, meth)\n\n # Verify that classmethod() doesn't allow keyword args\n try:\n classmethod(f, kw=1)\n except TypeError:\n pass\n else:\n self.fail(\"classmethod shouldn't accept keyword args\")\n\n cm = classmethod(f)\n self.assertEqual(cm.__dict__, {})\n cm.x = 42\n self.assertEqual(cm.x, 42)\n self.assertEqual(cm.__dict__, {\"x\" : 42})\n del cm.x\n self.assertNotHasAttr(cm, \"x\")\n\n @support.refcount_test\n def test_refleaks_in_classmethod___init__(self):\n gettotalrefcount = support.get_attribute(sys, 'gettotalrefcount')\n cm = classmethod(None)\n refs_before = gettotalrefcount()\n for i in range(100):\n cm.__init__(None)\n self.assertAlmostEqual(gettotalrefcount() - refs_before, 0, delta=10)\n\n @support.impl_detail(\"the module 'xxsubtype' is internal\")\n def test_classmethods_in_c(self):\n # Testing C-based class methods...\n import xxsubtype as spam\n a = (1, 2, 3)\n d = {'abc': 123}\n x, a1, d1 = spam.spamlist.classmeth(*a, **d)\n self.assertEqual(x, spam.spamlist)\n self.assertEqual(a, a1)\n self.assertEqual(d, d1)\n x, a1, d1 = spam.spamlist().classmeth(*a, **d)\n self.assertEqual(x, spam.spamlist)\n self.assertEqual(a, a1)\n self.assertEqual(d, d1)\n spam_cm = spam.spamlist.__dict__['classmeth']\n x2, a2, d2 = spam_cm(spam.spamlist, *a, **d)\n self.assertEqual(x2, spam.spamlist)\n self.assertEqual(a2, a1)\n self.assertEqual(d2, d1)\n class SubSpam(spam.spamlist): pass\n x2, a2, d2 = spam_cm(SubSpam, *a, **d)\n self.assertEqual(x2, SubSpam)\n self.assertEqual(a2, a1)\n self.assertEqual(d2, d1)\n with self.assertRaises(TypeError):\n spam_cm()\n with self.assertRaises(TypeError):\n spam_cm(spam.spamlist())\n with self.assertRaises(TypeError):\n spam_cm(list)\n\n def test_staticmethods(self):\n # Testing static methods...\n class C(object):\n def foo(*a): return a\n goo = staticmethod(foo)\n c = C()\n self.assertEqual(C.goo(1), (1,))\n self.assertEqual(c.goo(1), (1,))\n self.assertEqual(c.foo(1), (c, 1,))\n class D(C):\n pass\n d = D()\n self.assertEqual(D.goo(1), (1,))\n self.assertEqual(d.goo(1), (1,))\n self.assertEqual(d.foo(1), (d, 1))\n self.assertEqual(D.foo(d, 1), (d, 1))\n sm = staticmethod(None)\n self.assertEqual(sm.__dict__, {})\n sm.x = 42\n self.assertEqual(sm.x, 42)\n self.assertEqual(sm.__dict__, {\"x\" : 42})\n del sm.x\n self.assertNotHasAttr(sm, \"x\")\n\n @support.refcount_test\n def test_refleaks_in_staticmethod___init__(self):\n gettotalrefcount = support.get_attribute(sys, 'gettotalrefcount')\n sm = staticmethod(None)\n refs_before = gettotalrefcount()\n for i in range(100):\n sm.__init__(None)\n self.assertAlmostEqual(gettotalrefcount() - refs_before, 0, delta=10)\n\n @support.impl_detail(\"the module 'xxsubtype' is internal\")\n def test_staticmethods_in_c(self):\n # Testing C-based static methods...\n import xxsubtype as spam\n a = (1, 2, 3)\n d = {\"abc\": 123}\n x, a1, d1 = spam.spamlist.staticmeth(*a, **d)\n self.assertEqual(x, None)\n self.assertEqual(a, a1)\n self.assertEqual(d, d1)\n x, a1, d2 = spam.spamlist().staticmeth(*a, **d)\n self.assertEqual(x, None)\n self.assertEqual(a, a1)\n self.assertEqual(d, d1)\n\n def test_classic(self):\n # Testing classic classes...\n class C:\n def foo(*a): return a\n goo = classmethod(foo)\n c = C()\n self.assertEqual(C.goo(1), (C, 1))\n self.assertEqual(c.goo(1), (C, 1))\n self.assertEqual(c.foo(1), (c, 1))\n class D(C):\n pass\n d = D()\n self.assertEqual(D.goo(1), (D, 1))\n self.assertEqual(d.goo(1), (D, 1))\n self.assertEqual(d.foo(1), (d, 1))\n self.assertEqual(D.foo(d, 1), (d, 1))\n class E: # *not* subclassing from C\n foo = C.foo\n self.assertEqual(E().foo.__func__, C.foo) # i.e., unbound\n self.assertTrue(repr(C.foo.__get__(C())).startswith(\"<bound method \"))\n\n def test_compattr(self):\n # Testing computed attributes...\n class C(object):\n class computed_attribute(object):\n def __init__(self, get, set=None, delete=None):\n self.__get = get\n self.__set = set\n self.__delete = delete\n def __get__(self, obj, type=None):\n return self.__get(obj)\n def __set__(self, obj, value):\n return self.__set(obj, value)\n def __delete__(self, obj):\n return self.__delete(obj)\n def __init__(self):\n self.__x = 0\n def __get_x(self):\n x = self.__x\n self.__x = x+1\n return x\n def __set_x(self, x):\n self.__x = x\n def __delete_x(self):\n del self.__x\n x = computed_attribute(__get_x, __set_x, __delete_x)\n a = C()\n self.assertEqual(a.x, 0)\n self.assertEqual(a.x, 1)\n a.x = 10\n self.assertEqual(a.x, 10)\n self.assertEqual(a.x, 11)\n del a.x\n self.assertNotHasAttr(a, 'x')\n\n def test_newslots(self):\n # Testing __new__ slot override...\n class C(list):\n def __new__(cls):\n self = list.__new__(cls)\n self.foo = 1\n return self\n def __init__(self):\n self.foo = self.foo + 2\n a = C()\n self.assertEqual(a.foo, 3)\n self.assertEqual(a.__class__, C)\n class D(C):\n pass\n b = D()\n self.assertEqual(b.foo, 3)\n self.assertEqual(b.__class__, D)\n\n @unittest.expectedFailure\n def test_bad_new(self):\n self.assertRaises(TypeError, object.__new__)\n self.assertRaises(TypeError, object.__new__, '')\n self.assertRaises(TypeError, list.__new__, object)\n self.assertRaises(TypeError, object.__new__, list)\n class C(object):\n __new__ = list.__new__\n self.assertRaises(TypeError, C)\n class C(list):\n __new__ = object.__new__\n self.assertRaises(TypeError, C)\n\n def test_object_new(self):\n class A(object):\n pass\n object.__new__(A)\n self.assertRaises(TypeError, object.__new__, A, 5)\n object.__init__(A())\n self.assertRaises(TypeError, object.__init__, A(), 5)\n\n class A(object):\n def __init__(self, foo):\n self.foo = foo\n object.__new__(A)\n object.__new__(A, 5)\n object.__init__(A(3))\n self.assertRaises(TypeError, object.__init__, A(3), 5)\n\n class A(object):\n def __new__(cls, foo):\n return object.__new__(cls)\n object.__new__(A)\n self.assertRaises(TypeError, object.__new__, A, 5)\n object.__init__(A(3))\n object.__init__(A(3), 5)\n\n class A(object):\n def __new__(cls, foo):\n return object.__new__(cls)\n def __init__(self, foo):\n self.foo = foo\n object.__new__(A)\n self.assertRaises(TypeError, object.__new__, A, 5)\n object.__init__(A(3))\n self.assertRaises(TypeError, object.__init__, A(3), 5)\n\n @unittest.expectedFailure\n def test_restored_object_new(self):\n class A(object):\n def __new__(cls, *args, **kwargs):\n raise AssertionError\n self.assertRaises(AssertionError, A)\n class B(A):\n __new__ = object.__new__\n def __init__(self, foo):\n self.foo = foo\n with warnings.catch_warnings():\n warnings.simplefilter('error', DeprecationWarning)\n b = B(3)\n self.assertEqual(b.foo, 3)\n self.assertEqual(b.__class__, B)\n del B.__new__\n self.assertRaises(AssertionError, B)\n del A.__new__\n with warnings.catch_warnings():\n warnings.simplefilter('error', DeprecationWarning)\n b = B(3)\n self.assertEqual(b.foo, 3)\n self.assertEqual(b.__class__, B)\n\n def test_altmro(self):\n # Testing mro() and overriding it...\n class A(object):\n def f(self): return \"A\"\n class B(A):\n pass\n class C(A):\n def f(self): return \"C\"\n class D(B, C):\n pass\n self.assertEqual(A.mro(), [A, object])\n self.assertEqual(A.__mro__, (A, object))\n self.assertEqual(B.mro(), [B, A, object])\n self.assertEqual(B.__mro__, (B, A, object))\n self.assertEqual(C.mro(), [C, A, object])\n self.assertEqual(C.__mro__, (C, A, object))\n self.assertEqual(D.mro(), [D, B, C, A, object])\n self.assertEqual(D.__mro__, (D, B, C, A, object))\n self.assertEqual(D().f(), \"C\")\n\n class PerverseMetaType(type):\n def mro(cls):\n L = type.mro(cls)\n L.reverse()\n return L\n class X(D,B,C,A, metaclass=PerverseMetaType):\n pass\n self.assertEqual(X.__mro__, (object, A, C, B, D, X))\n self.assertEqual(X().f(), \"A\")\n\n try:\n class _metaclass(type):\n def mro(self):\n return [self, dict, object]\n class X(object, metaclass=_metaclass):\n pass\n # In CPython, the class creation above already raises\n # TypeError, as a protection against the fact that\n # instances of X would segfault it. In other Python\n # implementations it would be ok to let the class X\n # be created, but instead get a clean TypeError on the\n # __setitem__ below.\n x = object.__new__(X)\n x[5] = 6\n except TypeError:\n pass\n else:\n self.fail(\"devious mro() return not caught\")\n\n try:\n class _metaclass(type):\n def mro(self):\n return [1]\n class X(object, metaclass=_metaclass):\n pass\n except TypeError:\n pass\n else:\n self.fail(\"non-class mro() return not caught\")\n\n try:\n class _metaclass(type):\n def mro(self):\n return 1\n class X(object, metaclass=_metaclass):\n pass\n except TypeError:\n pass\n else:\n self.fail(\"non-sequence mro() return not caught\")\n\n def test_overloading(self):\n # Testing operator overloading...\n\n class B(object):\n \"Intermediate class because object doesn't have a __setattr__\"\n\n class C(B):\n def __getattr__(self, name):\n if name == \"foo\":\n return (\"getattr\", name)\n else:\n raise AttributeError\n def __setattr__(self, name, value):\n if name == \"foo\":\n self.setattr = (name, value)\n else:\n return B.__setattr__(self, name, value)\n def __delattr__(self, name):\n if name == \"foo\":\n self.delattr = name\n else:\n return B.__delattr__(self, name)\n\n def __getitem__(self, key):\n return (\"getitem\", key)\n def __setitem__(self, key, value):\n self.setitem = (key, value)\n def __delitem__(self, key):\n self.delitem = key\n\n a = C()\n self.assertEqual(a.foo, (\"getattr\", \"foo\"))\n a.foo = 12\n self.assertEqual(a.setattr, (\"foo\", 12))\n del a.foo\n self.assertEqual(a.delattr, \"foo\")\n\n self.assertEqual(a[12], (\"getitem\", 12))\n a[12] = 21\n self.assertEqual(a.setitem, (12, 21))\n del a[12]\n self.assertEqual(a.delitem, 12)\n\n self.assertEqual(a[0:10], (\"getitem\", slice(0, 10)))\n a[0:10] = \"foo\"\n self.assertEqual(a.setitem, (slice(0, 10), \"foo\"))\n del a[0:10]\n self.assertEqual(a.delitem, (slice(0, 10)))\n\n def test_methods(self):\n # Testing methods...\n class C(object):\n def __init__(self, x):\n self.x = x\n def foo(self):\n return self.x\n c1 = C(1)\n self.assertEqual(c1.foo(), 1)\n class D(C):\n boo = C.foo\n goo = c1.foo\n d2 = D(2)\n self.assertEqual(d2.foo(), 2)\n self.assertEqual(d2.boo(), 2)\n self.assertEqual(d2.goo(), 1)\n class E(object):\n foo = C.foo\n self.assertEqual(E().foo.__func__, C.foo) # i.e., unbound\n self.assertTrue(repr(C.foo.__get__(C(1))).startswith(\"<bound method \"))\n\n def test_special_method_lookup(self):\n # The lookup of special methods bypasses __getattr__ and\n # __getattribute__, but they still can be descriptors.\n\n def run_context(manager):\n with manager:\n pass\n def iden(self):\n return self\n def hello(self):\n return b\"hello\"\n def empty_seq(self):\n return []\n def zero(self):\n return 0\n def complex_num(self):\n return 1j\n def stop(self):\n raise StopIteration\n def return_true(self, thing=None):\n return True\n def do_isinstance(obj):\n return isinstance(int, obj)\n def do_issubclass(obj):\n return issubclass(int, obj)\n def do_dict_missing(checker):\n class DictSub(checker.__class__, dict):\n pass\n self.assertEqual(DictSub()[\"hi\"], 4)\n def some_number(self_, key):\n self.assertEqual(key, \"hi\")\n return 4\n def swallow(*args): pass\n def format_impl(self, spec):\n return \"hello\"\n\n # It would be nice to have every special method tested here, but I'm\n # only listing the ones I can remember outside of typeobject.c, since it\n # does it right.\n specials = [\n (\"__bytes__\", bytes, hello, set(), {}),\n (\"__reversed__\", reversed, empty_seq, set(), {}),\n (\"__length_hint__\", list, zero, set(),\n {\"__iter__\" : iden, \"__next__\" : stop}),\n (\"__sizeof__\", sys.getsizeof, zero, set(), {}),\n (\"__instancecheck__\", do_isinstance, return_true, set(), {}),\n (\"__missing__\", do_dict_missing, some_number,\n set((\"__class__\",)), {}),\n (\"__subclasscheck__\", do_issubclass, return_true,\n set((\"__bases__\",)), {}),\n (\"__enter__\", run_context, iden, set(), {\"__exit__\" : swallow}),\n (\"__exit__\", run_context, swallow, set(), {\"__enter__\" : iden}),\n (\"__complex__\", complex, complex_num, set(), {}),\n (\"__format__\", format, format_impl, set(), {}),\n (\"__floor__\", math.floor, zero, set(), {}),\n (\"__trunc__\", math.trunc, zero, set(), {}),\n (\"__trunc__\", int, zero, set(), {}),\n (\"__ceil__\", math.ceil, zero, set(), {}),\n (\"__dir__\", dir, empty_seq, set(), {}),\n (\"__round__\", round, zero, set(), {}),\n ]\n\n class Checker(object):\n def __getattr__(self, attr, test=self):\n test.fail(\"__getattr__ called with {0}\".format(attr))\n def __getattribute__(self, attr, test=self):\n if attr not in ok:\n test.fail(\"__getattribute__ called with {0}\".format(attr))\n return object.__getattribute__(self, attr)\n class SpecialDescr(object):\n def __init__(self, impl):\n self.impl = impl\n def __get__(self, obj, owner):\n record.append(1)\n return self.impl.__get__(obj, owner)\n class MyException(Exception):\n pass\n class ErrDescr(object):\n def __get__(self, obj, owner):\n raise MyException\n\n for name, runner, meth_impl, ok, env in specials:\n class X(Checker):\n pass\n for attr, obj in env.items():\n setattr(X, attr, obj)\n setattr(X, name, meth_impl)\n runner(X())\n\n record = []\n class X(Checker):\n pass\n for attr, obj in env.items():\n setattr(X, attr, obj)\n setattr(X, name, SpecialDescr(meth_impl))\n runner(X())\n self.assertEqual(record, [1], name)\n\n class X(Checker):\n pass\n for attr, obj in env.items():\n setattr(X, attr, obj)\n setattr(X, name, ErrDescr())\n self.assertRaises(MyException, runner, X())\n\n def test_specials(self):\n # Testing special operators...\n # Test operators like __hash__ for which a built-in default exists\n\n # Test the default behavior for static classes\n class C(object):\n def __getitem__(self, i):\n if 0 <= i < 10: return i\n raise IndexError\n c1 = C()\n c2 = C()\n self.assertFalse(not c1)\n self.assertNotEqual(id(c1), id(c2))\n hash(c1)\n hash(c2)\n self.assertEqual(c1, c1)\n self.assertTrue(c1 != c2)\n self.assertFalse(c1 != c1)\n self.assertFalse(c1 == c2)\n # Note that the module name appears in str/repr, and that varies\n # depending on whether this test is run standalone or from a framework.\n self.assertGreaterEqual(str(c1).find('C object at '), 0)\n self.assertEqual(str(c1), repr(c1))\n self.assertNotIn(-1, c1)\n for i in range(10):\n self.assertIn(i, c1)\n self.assertNotIn(10, c1)\n # Test the default behavior for dynamic classes\n class D(object):\n def __getitem__(self, i):\n if 0 <= i < 10: return i\n raise IndexError\n d1 = D()\n d2 = D()\n self.assertFalse(not d1)\n self.assertNotEqual(id(d1), id(d2))\n hash(d1)\n hash(d2)\n self.assertEqual(d1, d1)\n self.assertNotEqual(d1, d2)\n self.assertFalse(d1 != d1)\n self.assertFalse(d1 == d2)\n # Note that the module name appears in str/repr, and that varies\n # depending on whether this test is run standalone or from a framework.\n self.assertGreaterEqual(str(d1).find('D object at '), 0)\n self.assertEqual(str(d1), repr(d1))\n self.assertNotIn(-1, d1)\n for i in range(10):\n self.assertIn(i, d1)\n self.assertNotIn(10, d1)\n # Test overridden behavior\n class Proxy(object):\n def __init__(self, x):\n self.x = x\n def __bool__(self):\n return not not self.x\n def __hash__(self):\n return hash(self.x)\n def __eq__(self, other):\n return self.x == other\n def __ne__(self, other):\n return self.x != other\n def __ge__(self, other):\n return self.x >= other\n def __gt__(self, other):\n return self.x > other\n def __le__(self, other):\n return self.x <= other\n def __lt__(self, other):\n return self.x < other\n def __str__(self):\n return \"Proxy:%s\" % self.x\n def __repr__(self):\n return \"Proxy(%r)\" % self.x\n def __contains__(self, value):\n return value in self.x\n p0 = Proxy(0)\n p1 = Proxy(1)\n p_1 = Proxy(-1)\n self.assertFalse(p0)\n self.assertFalse(not p1)\n self.assertEqual(hash(p0), hash(0))\n self.assertEqual(p0, p0)\n self.assertNotEqual(p0, p1)\n self.assertFalse(p0 != p0)\n self.assertEqual(not p0, p1)\n self.assertTrue(p0 < p1)\n self.assertTrue(p0 <= p1)\n self.assertTrue(p1 > p0)\n self.assertTrue(p1 >= p0)\n self.assertEqual(str(p0), \"Proxy:0\")\n self.assertEqual(repr(p0), \"Proxy(0)\")\n p10 = Proxy(range(10))\n self.assertNotIn(-1, p10)\n for i in range(10):\n self.assertIn(i, p10)\n self.assertNotIn(10, p10)\n\n def test_weakrefs(self):\n # Testing weak references...\n import weakref\n class C(object):\n pass\n c = C()\n r = weakref.ref(c)\n self.assertEqual(r(), c)\n del c\n support.gc_collect()\n self.assertEqual(r(), None)\n del r\n class NoWeak(object):\n __slots__ = ['foo']\n no = NoWeak()\n try:\n weakref.ref(no)\n except TypeError as msg:\n self.assertIn(\"weak reference\", str(msg))\n else:\n self.fail(\"weakref.ref(no) should be illegal\")\n class Weak(object):\n __slots__ = ['foo', '__weakref__']\n yes = Weak()\n r = weakref.ref(yes)\n self.assertEqual(r(), yes)\n del yes\n support.gc_collect()\n self.assertEqual(r(), None)\n del r\n\n def test_properties(self):\n # Testing property...\n class C(object):\n def getx(self):\n return self.__x\n def setx(self, value):\n self.__x = value\n def delx(self):\n del self.__x\n x = property(getx, setx, delx, doc=\"I'm the x property.\")\n a = C()\n self.assertNotHasAttr(a, \"x\")\n a.x = 42\n self.assertEqual(a._C__x, 42)\n self.assertEqual(a.x, 42)\n del a.x\n self.assertNotHasAttr(a, \"x\")\n self.assertNotHasAttr(a, \"_C__x\")\n C.x.__set__(a, 100)\n self.assertEqual(C.x.__get__(a), 100)\n C.x.__delete__(a)\n self.assertNotHasAttr(a, \"x\")\n\n raw = C.__dict__['x']\n self.assertIsInstance(raw, property)\n\n attrs = dir(raw)\n self.assertIn(\"__doc__\", attrs)\n self.assertIn(\"fget\", attrs)\n self.assertIn(\"fset\", attrs)\n self.assertIn(\"fdel\", attrs)\n\n self.assertEqual(raw.__doc__, \"I'm the x property.\")\n self.assertIs(raw.fget, C.__dict__['getx'])\n self.assertIs(raw.fset, C.__dict__['setx'])\n self.assertIs(raw.fdel, C.__dict__['delx'])\n\n for attr in \"fget\", \"fset\", \"fdel\":\n try:\n setattr(raw, attr, 42)\n except AttributeError as msg:\n if str(msg).find('readonly') < 0:\n self.fail(\"when setting readonly attr %r on a property, \"\n \"got unexpected AttributeError msg %r\" % (attr, str(msg)))\n else:\n self.fail(\"expected AttributeError from trying to set readonly %r \"\n \"attr on a property\" % attr)\n\n raw.__doc__ = 42\n self.assertEqual(raw.__doc__, 42)\n\n class D(object):\n __getitem__ = property(lambda s: 1/0)\n\n d = D()\n try:\n for i in d:\n str(i)\n except ZeroDivisionError:\n pass\n else:\n self.fail(\"expected ZeroDivisionError from bad property\")\n\n @unittest.skipIf(sys.flags.optimize >= 2,\n \"Docstrings are omitted with -O2 and above\")\n def test_properties_doc_attrib(self):\n class E(object):\n def getter(self):\n \"getter method\"\n return 0\n def setter(self_, value):\n \"setter method\"\n pass\n prop = property(getter)\n self.assertEqual(prop.__doc__, \"getter method\")\n prop2 = property(fset=setter)\n self.assertEqual(prop2.__doc__, None)\n\n @support.cpython_only\n def test_testcapi_no_segfault(self):\n # this segfaulted in 2.5b2\n try:\n import _testcapi\n except ImportError:\n pass\n else:\n class X(object):\n p = property(_testcapi.test_with_docstring)\n\n def test_properties_plus(self):\n class C(object):\n foo = property(doc=\"hello\")\n @foo.getter\n def foo(self):\n return self._foo\n @foo.setter\n def foo(self, value):\n self._foo = abs(value)\n @foo.deleter\n def foo(self):\n del self._foo\n c = C()\n self.assertEqual(C.foo.__doc__, \"hello\")\n self.assertNotHasAttr(c, \"foo\")\n c.foo = -42\n self.assertHasAttr(c, '_foo')\n self.assertEqual(c._foo, 42)\n self.assertEqual(c.foo, 42)\n del c.foo\n self.assertNotHasAttr(c, '_foo')\n self.assertNotHasAttr(c, \"foo\")\n\n class D(C):\n @C.foo.deleter\n def foo(self):\n try:\n del self._foo\n except AttributeError:\n pass\n d = D()\n d.foo = 24\n self.assertEqual(d.foo, 24)\n del d.foo\n del d.foo\n\n class E(object):\n @property\n def foo(self):\n return self._foo\n @foo.setter\n def foo(self, value):\n raise RuntimeError\n @foo.setter\n def foo(self, value):\n self._foo = abs(value)\n @foo.deleter\n def foo(self, value=None):\n del self._foo\n\n e = E()\n e.foo = -42\n self.assertEqual(e.foo, 42)\n del e.foo\n\n class F(E):\n @E.foo.deleter\n def foo(self):\n del self._foo\n @foo.setter\n def foo(self, value):\n self._foo = max(0, value)\n f = F()\n f.foo = -10\n self.assertEqual(f.foo, 0)\n del f.foo\n\n def test_dict_constructors(self):\n # Testing dict constructor ...\n d = dict()\n self.assertEqual(d, {})\n d = dict({})\n self.assertEqual(d, {})\n d = dict({1: 2, 'a': 'b'})\n self.assertEqual(d, {1: 2, 'a': 'b'})\n self.assertEqual(d, dict(list(d.items())))\n self.assertEqual(d, dict(iter(d.items())))\n d = dict({'one':1, 'two':2})\n self.assertEqual(d, dict(one=1, two=2))\n self.assertEqual(d, dict(**d))\n self.assertEqual(d, dict({\"one\": 1}, two=2))\n self.assertEqual(d, dict([(\"two\", 2)], one=1))\n self.assertEqual(d, dict([(\"one\", 100), (\"two\", 200)], **d))\n self.assertEqual(d, dict(**d))\n\n for badarg in 0, 0, 0j, \"0\", [0], (0,):\n try:\n dict(badarg)\n except TypeError:\n pass\n except ValueError:\n if badarg == \"0\":\n # It's a sequence, and its elements are also sequences (gotta\n # love strings <wink>), but they aren't of length 2, so this\n # one seemed better as a ValueError than a TypeError.\n pass\n else:\n self.fail(\"no TypeError from dict(%r)\" % badarg)\n else:\n self.fail(\"no TypeError from dict(%r)\" % badarg)\n\n try:\n dict({}, {})\n except TypeError:\n pass\n else:\n self.fail(\"no TypeError from dict({}, {})\")\n\n class Mapping:\n # Lacks a .keys() method; will be added later.\n dict = {1:2, 3:4, 'a':1j}\n\n try:\n dict(Mapping())\n except TypeError:\n pass\n else:\n self.fail(\"no TypeError from dict(incomplete mapping)\")\n\n Mapping.keys = lambda self: list(self.dict.keys())\n Mapping.__getitem__ = lambda self, i: self.dict[i]\n d = dict(Mapping())\n self.assertEqual(d, Mapping.dict)\n\n # Init from sequence of iterable objects, each producing a 2-sequence.\n class AddressBookEntry:\n def __init__(self, first, last):\n self.first = first\n self.last = last\n def __iter__(self):\n return iter([self.first, self.last])\n\n d = dict([AddressBookEntry('Tim', 'Warsaw'),\n AddressBookEntry('Barry', 'Peters'),\n AddressBookEntry('Tim', 'Peters'),\n AddressBookEntry('Barry', 'Warsaw')])\n self.assertEqual(d, {'Barry': 'Warsaw', 'Tim': 'Peters'})\n\n d = dict(zip(range(4), range(1, 5)))\n self.assertEqual(d, dict([(i, i+1) for i in range(4)]))\n\n # Bad sequence lengths.\n for bad in [('tooshort',)], [('too', 'long', 'by 1')]:\n try:\n dict(bad)\n except ValueError:\n pass\n else:\n self.fail(\"no ValueError from dict(%r)\" % bad)\n\n def test_dir(self):\n # Testing dir() ...\n junk = 12\n self.assertEqual(dir(), ['junk', 'self'])\n del junk\n\n # Just make sure these don't blow up!\n for arg in 2, 2, 2j, 2e0, [2], \"2\", b\"2\", (2,), {2:2}, type, self.test_dir:\n dir(arg)\n\n # Test dir on new-style classes. Since these have object as a\n # base class, a lot more gets sucked in.\n def interesting(strings):\n return [s for s in strings if not s.startswith('_')]\n\n class C(object):\n Cdata = 1\n def Cmethod(self): pass\n\n cstuff = ['Cdata', 'Cmethod']\n self.assertEqual(interesting(dir(C)), cstuff)\n\n c = C()\n self.assertEqual(interesting(dir(c)), cstuff)\n ## self.assertIn('__self__', dir(C.Cmethod))\n\n c.cdata = 2\n c.cmethod = lambda self: 0\n self.assertEqual(interesting(dir(c)), cstuff + ['cdata', 'cmethod'])\n ## self.assertIn('__self__', dir(c.Cmethod))\n\n class A(C):\n Adata = 1\n def Amethod(self): pass\n\n astuff = ['Adata', 'Amethod'] + cstuff\n self.assertEqual(interesting(dir(A)), astuff)\n ## self.assertIn('__self__', dir(A.Amethod))\n a = A()\n self.assertEqual(interesting(dir(a)), astuff)\n a.adata = 42\n a.amethod = lambda self: 3\n self.assertEqual(interesting(dir(a)), astuff + ['adata', 'amethod'])\n ## self.assertIn('__self__', dir(a.Amethod))\n\n # Try a module subclass.\n class M(type(sys)):\n pass\n minstance = M(\"m\")\n minstance.b = 2\n minstance.a = 1\n default_attributes = ['__name__', '__doc__', '__package__',\n '__loader__', '__spec__']\n names = [x for x in dir(minstance) if x not in default_attributes]\n self.assertEqual(names, ['a', 'b'])\n\n class M2(M):\n def getdict(self):\n return \"Not a dict!\"\n __dict__ = property(getdict)\n\n m2instance = M2(\"m2\")\n m2instance.b = 2\n m2instance.a = 1\n self.assertEqual(m2instance.__dict__, \"Not a dict!\")\n try:\n dir(m2instance)\n except TypeError:\n pass\n\n # Two essentially featureless objects, just inheriting stuff from\n # object.\n self.assertEqual(dir(NotImplemented), dir(Ellipsis))\n\n # Nasty test case for proxied objects\n class Wrapper(object):\n def __init__(self, obj):\n self.__obj = obj\n def __repr__(self):\n return \"Wrapper(%s)\" % repr(self.__obj)\n def __getitem__(self, key):\n return Wrapper(self.__obj[key])\n def __len__(self):\n return len(self.__obj)\n def __getattr__(self, name):\n return Wrapper(getattr(self.__obj, name))\n\n class C(object):\n def __getclass(self):\n return Wrapper(type(self))\n __class__ = property(__getclass)\n\n dir(C()) # This used to segfault\n\n def test_supers(self):\n # Testing super...\n\n class A(object):\n def meth(self, a):\n return \"A(%r)\" % a\n\n self.assertEqual(A().meth(1), \"A(1)\")\n\n class B(A):\n def __init__(self):\n self.__super = super(B, self)\n def meth(self, a):\n return \"B(%r)\" % a + self.__super.meth(a)\n\n self.assertEqual(B().meth(2), \"B(2)A(2)\")\n\n class C(A):\n def meth(self, a):\n return \"C(%r)\" % a + self.__super.meth(a)\n C._C__super = super(C)\n\n self.assertEqual(C().meth(3), \"C(3)A(3)\")\n\n class D(C, B):\n def meth(self, a):\n return \"D(%r)\" % a + super(D, self).meth(a)\n\n self.assertEqual(D().meth(4), \"D(4)C(4)B(4)A(4)\")\n\n # Test for subclassing super\n\n class mysuper(super):\n def __init__(self, *args):\n return super(mysuper, self).__init__(*args)\n\n class E(D):\n def meth(self, a):\n return \"E(%r)\" % a + mysuper(E, self).meth(a)\n\n self.assertEqual(E().meth(5), \"E(5)D(5)C(5)B(5)A(5)\")\n\n class F(E):\n def meth(self, a):\n s = self.__super # == mysuper(F, self)\n return \"F(%r)[%s]\" % (a, s.__class__.__name__) + s.meth(a)\n F._F__super = mysuper(F)\n\n self.assertEqual(F().meth(6), \"F(6)[mysuper]E(6)D(6)C(6)B(6)A(6)\")\n\n # Make sure certain errors are raised\n\n try:\n super(D, 42)\n except TypeError:\n pass\n else:\n self.fail(\"shouldn't allow super(D, 42)\")\n\n try:\n super(D, C())\n except TypeError:\n pass\n else:\n self.fail(\"shouldn't allow super(D, C())\")\n\n try:\n super(D).__get__(12)\n except TypeError:\n pass\n else:\n self.fail(\"shouldn't allow super(D).__get__(12)\")\n\n try:\n super(D).__get__(C())\n except TypeError:\n pass\n else:\n self.fail(\"shouldn't allow super(D).__get__(C())\")\n\n # Make sure data descriptors can be overridden and accessed via super\n # (new feature in Python 2.3)\n\n class DDbase(object):\n def getx(self): return 42\n x = property(getx)\n\n class DDsub(DDbase):\n def getx(self): return \"hello\"\n x = property(getx)\n\n dd = DDsub()\n self.assertEqual(dd.x, \"hello\")\n self.assertEqual(super(DDsub, dd).x, 42)\n\n # Ensure that super() lookup of descriptor from classmethod\n # works (SF ID# 743627)\n\n class Base(object):\n aProp = property(lambda self: \"foo\")\n\n class Sub(Base):\n @classmethod\n def test(klass):\n return super(Sub,klass).aProp\n\n self.assertEqual(Sub.test(), Base.aProp)\n\n # Verify that super() doesn't allow keyword args\n try:\n super(Base, kw=1)\n except TypeError:\n pass\n else:\n self.assertEqual(\"super shouldn't accept keyword args\")\n\n def test_basic_inheritance(self):\n # Testing inheritance from basic types...\n\n class hexint(int):\n def __repr__(self):\n return hex(self)\n def __add__(self, other):\n return hexint(int.__add__(self, other))\n # (Note that overriding __radd__ doesn't work,\n # because the int type gets first dibs.)\n self.assertEqual(repr(hexint(7) + 9), \"0x10\")\n self.assertEqual(repr(hexint(1000) + 7), \"0x3ef\")\n a = hexint(12345)\n self.assertEqual(a, 12345)\n self.assertEqual(int(a), 12345)\n self.assertIs(int(a).__class__, int)\n self.assertEqual(hash(a), hash(12345))\n self.assertIs((+a).__class__, int)\n self.assertIs((a >> 0).__class__, int)\n self.assertIs((a << 0).__class__, int)\n self.assertIs((hexint(0) << 12).__class__, int)\n self.assertIs((hexint(0) >> 12).__class__, int)\n\n class octlong(int):\n __slots__ = []\n def __str__(self):\n return oct(self)\n def __add__(self, other):\n return self.__class__(super(octlong, self).__add__(other))\n __radd__ = __add__\n self.assertEqual(str(octlong(3) + 5), \"0o10\")\n # (Note that overriding __radd__ here only seems to work\n # because the example uses a short int left argument.)\n self.assertEqual(str(5 + octlong(3000)), \"0o5675\")\n a = octlong(12345)\n self.assertEqual(a, 12345)\n self.assertEqual(int(a), 12345)\n self.assertEqual(hash(a), hash(12345))\n self.assertIs(int(a).__class__, int)\n self.assertIs((+a).__class__, int)\n self.assertIs((-a).__class__, int)\n self.assertIs((-octlong(0)).__class__, int)\n self.assertIs((a >> 0).__class__, int)\n self.assertIs((a << 0).__class__, int)\n self.assertIs((a - 0).__class__, int)\n self.assertIs((a * 1).__class__, int)\n self.assertIs((a ** 1).__class__, int)\n self.assertIs((a // 1).__class__, int)\n self.assertIs((1 * a).__class__, int)\n self.assertIs((a | 0).__class__, int)\n self.assertIs((a ^ 0).__class__, int)\n self.assertIs((a & -1).__class__, int)\n self.assertIs((octlong(0) << 12).__class__, int)\n self.assertIs((octlong(0) >> 12).__class__, int)\n self.assertIs(abs(octlong(0)).__class__, int)\n\n # Because octlong overrides __add__, we can't check the absence of +0\n # optimizations using octlong.\n class longclone(int):\n pass\n a = longclone(1)\n self.assertIs((a + 0).__class__, int)\n self.assertIs((0 + a).__class__, int)\n\n # Check that negative clones don't segfault\n a = longclone(-1)\n self.assertEqual(a.__dict__, {})\n self.assertEqual(int(a), -1) # self.assertTrue PyNumber_Long() copies the sign bit\n\n class precfloat(float):\n __slots__ = ['prec']\n def __init__(self, value=0.0, prec=12):\n self.prec = int(prec)\n def __repr__(self):\n return \"%.*g\" % (self.prec, self)\n self.assertEqual(repr(precfloat(1.1)), \"1.1\")\n a = precfloat(12345)\n self.assertEqual(a, 12345.0)\n self.assertEqual(float(a), 12345.0)\n self.assertIs(float(a).__class__, float)\n self.assertEqual(hash(a), hash(12345.0))\n self.assertIs((+a).__class__, float)\n\n class madcomplex(complex):\n def __repr__(self):\n return \"%.17gj%+.17g\" % (self.imag, self.real)\n a = madcomplex(-3, 4)\n self.assertEqual(repr(a), \"4j-3\")\n base = complex(-3, 4)\n self.assertEqual(base.__class__, complex)\n self.assertEqual(a, base)\n self.assertEqual(complex(a), base)\n self.assertEqual(complex(a).__class__, complex)\n a = madcomplex(a) # just trying another form of the constructor\n self.assertEqual(repr(a), \"4j-3\")\n self.assertEqual(a, base)\n self.assertEqual(complex(a), base)\n self.assertEqual(complex(a).__class__, complex)\n self.assertEqual(hash(a), hash(base))\n self.assertEqual((+a).__class__, complex)\n self.assertEqual((a + 0).__class__, complex)\n self.assertEqual(a + 0, base)\n self.assertEqual((a - 0).__class__, complex)\n self.assertEqual(a - 0, base)\n self.assertEqual((a * 1).__class__, complex)\n self.assertEqual(a * 1, base)\n self.assertEqual((a / 1).__class__, complex)\n self.assertEqual(a / 1, base)\n\n class madtuple(tuple):\n _rev = None\n def rev(self):\n if self._rev is not None:\n return self._rev\n L = list(self)\n L.reverse()\n self._rev = self.__class__(L)\n return self._rev\n a = madtuple((1,2,3,4,5,6,7,8,9,0))\n self.assertEqual(a, (1,2,3,4,5,6,7,8,9,0))\n self.assertEqual(a.rev(), madtuple((0,9,8,7,6,5,4,3,2,1)))\n self.assertEqual(a.rev().rev(), madtuple((1,2,3,4,5,6,7,8,9,0)))\n for i in range(512):\n t = madtuple(range(i))\n u = t.rev()\n v = u.rev()\n self.assertEqual(v, t)\n a = madtuple((1,2,3,4,5))\n self.assertEqual(tuple(a), (1,2,3,4,5))\n self.assertIs(tuple(a).__class__, tuple)\n self.assertEqual(hash(a), hash((1,2,3,4,5)))\n self.assertIs(a[:].__class__, tuple)\n self.assertIs((a * 1).__class__, tuple)\n self.assertIs((a * 0).__class__, tuple)\n self.assertIs((a + ()).__class__, tuple)\n a = madtuple(())\n self.assertEqual(tuple(a), ())\n self.assertIs(tuple(a).__class__, tuple)\n self.assertIs((a + a).__class__, tuple)\n self.assertIs((a * 0).__class__, tuple)\n self.assertIs((a * 1).__class__, tuple)\n self.assertIs((a * 2).__class__, tuple)\n self.assertIs(a[:].__class__, tuple)\n\n class madstring(str):\n _rev = None\n def rev(self):\n if self._rev is not None:\n return self._rev\n L = list(self)\n L.reverse()\n self._rev = self.__class__(\"\".join(L))\n return self._rev\n s = madstring(\"abcdefghijklmnopqrstuvwxyz\")\n self.assertEqual(s, \"abcdefghijklmnopqrstuvwxyz\")\n self.assertEqual(s.rev(), madstring(\"zyxwvutsrqponmlkjihgfedcba\"))\n self.assertEqual(s.rev().rev(), madstring(\"abcdefghijklmnopqrstuvwxyz\"))\n for i in range(256):\n s = madstring(\"\".join(map(chr, range(i))))\n t = s.rev()\n u = t.rev()\n self.assertEqual(u, s)\n s = madstring(\"12345\")\n self.assertEqual(str(s), \"12345\")\n self.assertIs(str(s).__class__, str)\n\n base = \"\\x00\" * 5\n s = madstring(base)\n self.assertEqual(s, base)\n self.assertEqual(str(s), base)\n self.assertIs(str(s).__class__, str)\n self.assertEqual(hash(s), hash(base))\n self.assertEqual({s: 1}[base], 1)\n self.assertEqual({base: 1}[s], 1)\n self.assertIs((s + \"\").__class__, str)\n self.assertEqual(s + \"\", base)\n self.assertIs((\"\" + s).__class__, str)\n self.assertEqual(\"\" + s, base)\n self.assertIs((s * 0).__class__, str)\n self.assertEqual(s * 0, \"\")\n self.assertIs((s * 1).__class__, str)\n self.assertEqual(s * 1, base)\n self.assertIs((s * 2).__class__, str)\n self.assertEqual(s * 2, base + base)\n self.assertIs(s[:].__class__, str)\n self.assertEqual(s[:], base)\n self.assertIs(s[0:0].__class__, str)\n self.assertEqual(s[0:0], \"\")\n self.assertIs(s.strip().__class__, str)\n self.assertEqual(s.strip(), base)\n self.assertIs(s.lstrip().__class__, str)\n self.assertEqual(s.lstrip(), base)\n self.assertIs(s.rstrip().__class__, str)\n self.assertEqual(s.rstrip(), base)\n identitytab = {}\n self.assertIs(s.translate(identitytab).__class__, str)\n self.assertEqual(s.translate(identitytab), base)\n self.assertIs(s.replace(\"x\", \"x\").__class__, str)\n self.assertEqual(s.replace(\"x\", \"x\"), base)\n self.assertIs(s.ljust(len(s)).__class__, str)\n self.assertEqual(s.ljust(len(s)), base)\n self.assertIs(s.rjust(len(s)).__class__, str)\n self.assertEqual(s.rjust(len(s)), base)\n self.assertIs(s.center(len(s)).__class__, str)\n self.assertEqual(s.center(len(s)), base)\n self.assertIs(s.lower().__class__, str)\n self.assertEqual(s.lower(), base)\n\n class madunicode(str):\n _rev = None\n def rev(self):\n if self._rev is not None:\n return self._rev\n L = list(self)\n L.reverse()\n self._rev = self.__class__(\"\".join(L))\n return self._rev\n u = madunicode(\"ABCDEF\")\n self.assertEqual(u, \"ABCDEF\")\n self.assertEqual(u.rev(), madunicode(\"FEDCBA\"))\n self.assertEqual(u.rev().rev(), madunicode(\"ABCDEF\"))\n base = \"12345\"\n u = madunicode(base)\n self.assertEqual(str(u), base)\n self.assertIs(str(u).__class__, str)\n self.assertEqual(hash(u), hash(base))\n self.assertEqual({u: 1}[base], 1)\n self.assertEqual({base: 1}[u], 1)\n self.assertIs(u.strip().__class__, str)\n self.assertEqual(u.strip(), base)\n self.assertIs(u.lstrip().__class__, str)\n self.assertEqual(u.lstrip(), base)\n self.assertIs(u.rstrip().__class__, str)\n self.assertEqual(u.rstrip(), base)\n self.assertIs(u.replace(\"x\", \"x\").__class__, str)\n self.assertEqual(u.replace(\"x\", \"x\"), base)\n self.assertIs(u.replace(\"xy\", \"xy\").__class__, str)\n self.assertEqual(u.replace(\"xy\", \"xy\"), base)\n self.assertIs(u.center(len(u)).__class__, str)\n self.assertEqual(u.center(len(u)), base)\n self.assertIs(u.ljust(len(u)).__class__, str)\n self.assertEqual(u.ljust(len(u)), base)\n self.assertIs(u.rjust(len(u)).__class__, str)\n self.assertEqual(u.rjust(len(u)), base)\n self.assertIs(u.lower().__class__, str)\n self.assertEqual(u.lower(), base)\n self.assertIs(u.upper().__class__, str)\n self.assertEqual(u.upper(), base)\n self.assertIs(u.capitalize().__class__, str)\n self.assertEqual(u.capitalize(), base)\n self.assertIs(u.title().__class__, str)\n self.assertEqual(u.title(), base)\n self.assertIs((u + \"\").__class__, str)\n self.assertEqual(u + \"\", base)\n self.assertIs((\"\" + u).__class__, str)\n self.assertEqual(\"\" + u, base)\n self.assertIs((u * 0).__class__, str)\n self.assertEqual(u * 0, \"\")\n self.assertIs((u * 1).__class__, str)\n self.assertEqual(u * 1, base)\n self.assertIs((u * 2).__class__, str)\n self.assertEqual(u * 2, base + base)\n self.assertIs(u[:].__class__, str)\n self.assertEqual(u[:], base)\n self.assertIs(u[0:0].__class__, str)\n self.assertEqual(u[0:0], \"\")\n\n class sublist(list):\n pass\n a = sublist(range(5))\n self.assertEqual(a, list(range(5)))\n a.append(\"hello\")\n self.assertEqual(a, list(range(5)) + [\"hello\"])\n a[5] = 5\n self.assertEqual(a, list(range(6)))\n a.extend(range(6, 20))\n self.assertEqual(a, list(range(20)))\n a[-5:] = []\n self.assertEqual(a, list(range(15)))\n del a[10:15]\n self.assertEqual(len(a), 10)\n self.assertEqual(a, list(range(10)))\n self.assertEqual(list(a), list(range(10)))\n self.assertEqual(a[0], 0)\n self.assertEqual(a[9], 9)\n self.assertEqual(a[-10], 0)\n self.assertEqual(a[-1], 9)\n self.assertEqual(a[:5], list(range(5)))\n\n ## class CountedInput(file):\n ## \"\"\"Counts lines read by self.readline().\n ##\n ## self.lineno is the 0-based ordinal of the last line read, up to\n ## a maximum of one greater than the number of lines in the file.\n ##\n ## self.ateof is true if and only if the final \"\" line has been read,\n ## at which point self.lineno stops incrementing, and further calls\n ## to readline() continue to return \"\".\n ## \"\"\"\n ##\n ## lineno = 0\n ## ateof = 0\n ## def readline(self):\n ## if self.ateof:\n ## return \"\"\n ## s = file.readline(self)\n ## # Next line works too.\n ## # s = super(CountedInput, self).readline()\n ## self.lineno += 1\n ## if s == \"\":\n ## self.ateof = 1\n ## return s\n ##\n ## f = file(name=support.TESTFN, mode='w')\n ## lines = ['a\\n', 'b\\n', 'c\\n']\n ## try:\n ## f.writelines(lines)\n ## f.close()\n ## f = CountedInput(support.TESTFN)\n ## for (i, expected) in zip(range(1, 5) + [4], lines + 2 * [\"\"]):\n ## got = f.readline()\n ## self.assertEqual(expected, got)\n ## self.assertEqual(f.lineno, i)\n ## self.assertEqual(f.ateof, (i > len(lines)))\n ## f.close()\n ## finally:\n ## try:\n ## f.close()\n ## except:\n ## pass\n ## support.unlink(support.TESTFN)\n\n def test_keywords(self):\n # Testing keyword args to basic type constructors ...\n with self.assertRaisesRegex(TypeError, 'keyword argument'):\n int(x=1)\n with self.assertRaisesRegex(TypeError, 'keyword argument'):\n float(x=2)\n with self.assertRaisesRegex(TypeError, 'keyword argument'):\n bool(x=2)\n self.assertEqual(complex(imag=42, real=666), complex(666, 42))\n self.assertEqual(str(object=500), '500')\n self.assertEqual(str(object=b'abc', errors='strict'), 'abc')\n with self.assertRaisesRegex(TypeError, 'keyword argument'):\n tuple(sequence=range(3))\n with self.assertRaisesRegex(TypeError, 'keyword argument'):\n list(sequence=(0, 1, 2))\n # note: as of Python 2.3, dict() no longer has an \"items\" keyword arg\n\n for constructor in (int, float, int, complex, str, str,\n tuple, list):\n try:\n constructor(bogus_keyword_arg=1)\n except TypeError:\n pass\n else:\n self.fail(\"expected TypeError from bogus keyword argument to %r\"\n % constructor)\n\n def test_str_subclass_as_dict_key(self):\n # Testing a str subclass used as dict key ..\n\n class cistr(str):\n \"\"\"Sublcass of str that computes __eq__ case-insensitively.\n\n Also computes a hash code of the string in canonical form.\n \"\"\"\n\n def __init__(self, value):\n self.canonical = value.lower()\n self.hashcode = hash(self.canonical)\n\n def __eq__(self, other):\n if not isinstance(other, cistr):\n other = cistr(other)\n return self.canonical == other.canonical\n\n def __hash__(self):\n return self.hashcode\n\n self.assertEqual(cistr('ABC'), 'abc')\n self.assertEqual('aBc', cistr('ABC'))\n self.assertEqual(str(cistr('ABC')), 'ABC')\n\n d = {cistr('one'): 1, cistr('two'): 2, cistr('tHree'): 3}\n self.assertEqual(d[cistr('one')], 1)\n self.assertEqual(d[cistr('tWo')], 2)\n self.assertEqual(d[cistr('THrEE')], 3)\n self.assertIn(cistr('ONe'), d)\n self.assertEqual(d.get(cistr('thrEE')), 3)\n\n def test_classic_comparisons(self):\n # Testing classic comparisons...\n class classic:\n pass\n\n for base in (classic, int, object):\n class C(base):\n def __init__(self, value):\n self.value = int(value)\n def __eq__(self, other):\n if isinstance(other, C):\n return self.value == other.value\n if isinstance(other, int) or isinstance(other, int):\n return self.value == other\n return NotImplemented\n def __ne__(self, other):\n if isinstance(other, C):\n return self.value != other.value\n if isinstance(other, int) or isinstance(other, int):\n return self.value != other\n return NotImplemented\n def __lt__(self, other):\n if isinstance(other, C):\n return self.value < other.value\n if isinstance(other, int) or isinstance(other, int):\n return self.value < other\n return NotImplemented\n def __le__(self, other):\n if isinstance(other, C):\n return self.value <= other.value\n if isinstance(other, int) or isinstance(other, int):\n return self.value <= other\n return NotImplemented\n def __gt__(self, other):\n if isinstance(other, C):\n return self.value > other.value\n if isinstance(other, int) or isinstance(other, int):\n return self.value > other\n return NotImplemented\n def __ge__(self, other):\n if isinstance(other, C):\n return self.value >= other.value\n if isinstance(other, int) or isinstance(other, int):\n return self.value >= other\n return NotImplemented\n\n c1 = C(1)\n c2 = C(2)\n c3 = C(3)\n self.assertEqual(c1, 1)\n c = {1: c1, 2: c2, 3: c3}\n for x in 1, 2, 3:\n for y in 1, 2, 3:\n for op in \"<\", \"<=\", \"==\", \"!=\", \">\", \">=\":\n self.assertEqual(eval(\"c[x] %s c[y]\" % op),\n eval(\"x %s y\" % op),\n \"x=%d, y=%d\" % (x, y))\n self.assertEqual(eval(\"c[x] %s y\" % op),\n eval(\"x %s y\" % op),\n \"x=%d, y=%d\" % (x, y))\n self.assertEqual(eval(\"x %s c[y]\" % op),\n eval(\"x %s y\" % op),\n \"x=%d, y=%d\" % (x, y))\n\n def test_rich_comparisons(self):\n # Testing rich comparisons...\n class Z(complex):\n pass\n z = Z(1)\n self.assertEqual(z, 1+0j)\n self.assertEqual(1+0j, z)\n class ZZ(complex):\n def __eq__(self, other):\n try:\n return abs(self - other) <= 1e-6\n except:\n return NotImplemented\n zz = ZZ(1.0000003)\n self.assertEqual(zz, 1+0j)\n self.assertEqual(1+0j, zz)\n\n class classic:\n pass\n for base in (classic, int, object, list):\n class C(base):\n def __init__(self, value):\n self.value = int(value)\n def __cmp__(self_, other):\n self.fail(\"shouldn't call __cmp__\")\n def __eq__(self, other):\n if isinstance(other, C):\n return self.value == other.value\n if isinstance(other, int) or isinstance(other, int):\n return self.value == other\n return NotImplemented\n def __ne__(self, other):\n if isinstance(other, C):\n return self.value != other.value\n if isinstance(other, int) or isinstance(other, int):\n return self.value != other\n return NotImplemented\n def __lt__(self, other):\n if isinstance(other, C):\n return self.value < other.value\n if isinstance(other, int) or isinstance(other, int):\n return self.value < other\n return NotImplemented\n def __le__(self, other):\n if isinstance(other, C):\n return self.value <= other.value\n if isinstance(other, int) or isinstance(other, int):\n return self.value <= other\n return NotImplemented\n def __gt__(self, other):\n if isinstance(other, C):\n return self.value > other.value\n if isinstance(other, int) or isinstance(other, int):\n return self.value > other\n return NotImplemented\n def __ge__(self, other):\n if isinstance(other, C):\n return self.value >= other.value\n if isinstance(other, int) or isinstance(other, int):\n return self.value >= other\n return NotImplemented\n c1 = C(1)\n c2 = C(2)\n c3 = C(3)\n self.assertEqual(c1, 1)\n c = {1: c1, 2: c2, 3: c3}\n for x in 1, 2, 3:\n for y in 1, 2, 3:\n for op in \"<\", \"<=\", \"==\", \"!=\", \">\", \">=\":\n self.assertEqual(eval(\"c[x] %s c[y]\" % op),\n eval(\"x %s y\" % op),\n \"x=%d, y=%d\" % (x, y))\n self.assertEqual(eval(\"c[x] %s y\" % op),\n eval(\"x %s y\" % op),\n \"x=%d, y=%d\" % (x, y))\n self.assertEqual(eval(\"x %s c[y]\" % op),\n eval(\"x %s y\" % op),\n \"x=%d, y=%d\" % (x, y))\n\n def test_descrdoc(self):\n # Testing descriptor doc strings...\n from _io import FileIO\n def check(descr, what):\n self.assertEqual(descr.__doc__, what)\n check(FileIO.closed, \"True if the file is closed\") # getset descriptor\n check(complex.real, \"the real part of a complex number\") # member descriptor\n\n def test_doc_descriptor(self):\n # Testing __doc__ descriptor...\n # SF bug 542984\n class DocDescr(object):\n def __get__(self, object, otype):\n if object:\n object = object.__class__.__name__ + ' instance'\n if otype:\n otype = otype.__name__\n return 'object=%s; type=%s' % (object, otype)\n class OldClass:\n __doc__ = DocDescr()\n class NewClass(object):\n __doc__ = DocDescr()\n self.assertEqual(OldClass.__doc__, 'object=None; type=OldClass')\n self.assertEqual(OldClass().__doc__, 'object=OldClass instance; type=OldClass')\n self.assertEqual(NewClass.__doc__, 'object=None; type=NewClass')\n self.assertEqual(NewClass().__doc__, 'object=NewClass instance; type=NewClass')\n\n def test_set_class(self):\n # Testing __class__ assignment...\n class C(object): pass\n class D(object): pass\n class E(object): pass\n class F(D, E): pass\n for cls in C, D, E, F:\n for cls2 in C, D, E, F:\n x = cls()\n x.__class__ = cls2\n self.assertIs(x.__class__, cls2)\n x.__class__ = cls\n self.assertIs(x.__class__, cls)\n def cant(x, C):\n try:\n x.__class__ = C\n except TypeError:\n pass\n else:\n self.fail(\"shouldn't allow %r.__class__ = %r\" % (x, C))\n try:\n delattr(x, \"__class__\")\n except (TypeError, AttributeError):\n pass\n else:\n self.fail(\"shouldn't allow del %r.__class__\" % x)\n cant(C(), list)\n cant(list(), C)\n cant(C(), 1)\n cant(C(), object)\n cant(object(), list)\n cant(list(), object)\n class Int(int): __slots__ = []\n cant(True, int)\n cant(2, bool)\n o = object()\n cant(o, type(1))\n cant(o, type(None))\n del o\n class G(object):\n __slots__ = [\"a\", \"b\"]\n class H(object):\n __slots__ = [\"b\", \"a\"]\n class I(object):\n __slots__ = [\"a\", \"b\"]\n class J(object):\n __slots__ = [\"c\", \"b\"]\n class K(object):\n __slots__ = [\"a\", \"b\", \"d\"]\n class L(H):\n __slots__ = [\"e\"]\n class M(I):\n __slots__ = [\"e\"]\n class N(J):\n __slots__ = [\"__weakref__\"]\n class P(J):\n __slots__ = [\"__dict__\"]\n class Q(J):\n pass\n class R(J):\n __slots__ = [\"__dict__\", \"__weakref__\"]\n\n for cls, cls2 in ((G, H), (G, I), (I, H), (Q, R), (R, Q)):\n x = cls()\n x.a = 1\n x.__class__ = cls2\n self.assertIs(x.__class__, cls2,\n \"assigning %r as __class__ for %r silently failed\" % (cls2, x))\n self.assertEqual(x.a, 1)\n x.__class__ = cls\n self.assertIs(x.__class__, cls,\n \"assigning %r as __class__ for %r silently failed\" % (cls, x))\n self.assertEqual(x.a, 1)\n for cls in G, J, K, L, M, N, P, R, list, Int:\n for cls2 in G, J, K, L, M, N, P, R, list, Int:\n if cls is cls2:\n continue\n cant(cls(), cls2)\n\n # Issue5283: when __class__ changes in __del__, the wrong\n # type gets DECREF'd.\n class O(object):\n pass\n class A(object):\n def __del__(self):\n self.__class__ = O\n l = [A() for x in range(100)]\n del l\n\n def test_set_dict(self):\n # Testing __dict__ assignment...\n class C(object): pass\n a = C()\n a.__dict__ = {'b': 1}\n self.assertEqual(a.b, 1)\n def cant(x, dict):\n try:\n x.__dict__ = dict\n except (AttributeError, TypeError):\n pass\n else:\n self.fail(\"shouldn't allow %r.__dict__ = %r\" % (x, dict))\n cant(a, None)\n cant(a, [])\n cant(a, 1)\n del a.__dict__ # Deleting __dict__ is allowed\n\n class Base(object):\n pass\n def verify_dict_readonly(x):\n \"\"\"\n x has to be an instance of a class inheriting from Base.\n \"\"\"\n cant(x, {})\n try:\n del x.__dict__\n except (AttributeError, TypeError):\n pass\n else:\n self.fail(\"shouldn't allow del %r.__dict__\" % x)\n dict_descr = Base.__dict__[\"__dict__\"]\n try:\n dict_descr.__set__(x, {})\n except (AttributeError, TypeError):\n pass\n else:\n self.fail(\"dict_descr allowed access to %r's dict\" % x)\n\n # Classes don't allow __dict__ assignment and have readonly dicts\n class Meta1(type, Base):\n pass\n class Meta2(Base, type):\n pass\n class D(object, metaclass=Meta1):\n pass\n class E(object, metaclass=Meta2):\n pass\n for cls in C, D, E:\n verify_dict_readonly(cls)\n class_dict = cls.__dict__\n try:\n class_dict[\"spam\"] = \"eggs\"\n except TypeError:\n pass\n else:\n self.fail(\"%r's __dict__ can be modified\" % cls)\n\n # Modules also disallow __dict__ assignment\n class Module1(types.ModuleType, Base):\n pass\n class Module2(Base, types.ModuleType):\n pass\n for ModuleType in Module1, Module2:\n mod = ModuleType(\"spam\")\n verify_dict_readonly(mod)\n mod.__dict__[\"spam\"] = \"eggs\"\n\n # Exception's __dict__ can be replaced, but not deleted\n # (at least not any more than regular exception's __dict__ can\n # be deleted; on CPython it is not the case, whereas on PyPy they\n # can, just like any other new-style instance's __dict__.)\n def can_delete_dict(e):\n try:\n del e.__dict__\n except (TypeError, AttributeError):\n return False\n else:\n return True\n class Exception1(Exception, Base):\n pass\n class Exception2(Base, Exception):\n pass\n for ExceptionType in Exception, Exception1, Exception2:\n e = ExceptionType()\n e.__dict__ = {\"a\": 1}\n self.assertEqual(e.a, 1)\n self.assertEqual(can_delete_dict(e), can_delete_dict(ValueError()))\n\n def test_binary_operator_override(self):\n # Testing overrides of binary operations...\n class I(int):\n def __repr__(self):\n return \"I(%r)\" % int(self)\n def __add__(self, other):\n return I(int(self) + int(other))\n __radd__ = __add__\n def __pow__(self, other, mod=None):\n if mod is None:\n return I(pow(int(self), int(other)))\n else:\n return I(pow(int(self), int(other), int(mod)))\n def __rpow__(self, other, mod=None):\n if mod is None:\n return I(pow(int(other), int(self), mod))\n else:\n return I(pow(int(other), int(self), int(mod)))\n\n self.assertEqual(repr(I(1) + I(2)), \"I(3)\")\n self.assertEqual(repr(I(1) + 2), \"I(3)\")\n self.assertEqual(repr(1 + I(2)), \"I(3)\")\n self.assertEqual(repr(I(2) ** I(3)), \"I(8)\")\n self.assertEqual(repr(2 ** I(3)), \"I(8)\")\n self.assertEqual(repr(I(2) ** 3), \"I(8)\")\n self.assertEqual(repr(pow(I(2), I(3), I(5))), \"I(3)\")\n class S(str):\n def __eq__(self, other):\n return self.lower() == other.lower()\n\n def test_subclass_propagation(self):\n # Testing propagation of slot functions to subclasses...\n class A(object):\n pass\n class B(A):\n pass\n class C(A):\n pass\n class D(B, C):\n pass\n d = D()\n orig_hash = hash(d) # related to id(d) in platform-dependent ways\n A.__hash__ = lambda self: 42\n self.assertEqual(hash(d), 42)\n C.__hash__ = lambda self: 314\n self.assertEqual(hash(d), 314)\n B.__hash__ = lambda self: 144\n self.assertEqual(hash(d), 144)\n D.__hash__ = lambda self: 100\n self.assertEqual(hash(d), 100)\n D.__hash__ = None\n self.assertRaises(TypeError, hash, d)\n del D.__hash__\n self.assertEqual(hash(d), 144)\n B.__hash__ = None\n self.assertRaises(TypeError, hash, d)\n del B.__hash__\n self.assertEqual(hash(d), 314)\n C.__hash__ = None\n self.assertRaises(TypeError, hash, d)\n del C.__hash__\n self.assertEqual(hash(d), 42)\n A.__hash__ = None\n self.assertRaises(TypeError, hash, d)\n del A.__hash__\n self.assertEqual(hash(d), orig_hash)\n d.foo = 42\n d.bar = 42\n self.assertEqual(d.foo, 42)\n self.assertEqual(d.bar, 42)\n def __getattribute__(self, name):\n if name == \"foo\":\n return 24\n return object.__getattribute__(self, name)\n A.__getattribute__ = __getattribute__\n self.assertEqual(d.foo, 24)\n self.assertEqual(d.bar, 42)\n def __getattr__(self, name):\n if name in (\"spam\", \"foo\", \"bar\"):\n return \"hello\"\n raise AttributeError(name)\n B.__getattr__ = __getattr__\n self.assertEqual(d.spam, \"hello\")\n self.assertEqual(d.foo, 24)\n self.assertEqual(d.bar, 42)\n del A.__getattribute__\n self.assertEqual(d.foo, 42)\n del d.foo\n self.assertEqual(d.foo, \"hello\")\n self.assertEqual(d.bar, 42)\n del B.__getattr__\n try:\n d.foo\n except AttributeError:\n pass\n else:\n self.fail(\"d.foo should be undefined now\")\n\n # Test a nasty bug in recurse_down_subclasses()\n class A(object):\n pass\n class B(A):\n pass\n del B\n support.gc_collect()\n A.__setitem__ = lambda *a: None # crash\n\n def test_buffer_inheritance(self):\n # Testing that buffer interface is inherited ...\n\n import binascii\n # SF bug [#470040] ParseTuple t# vs subclasses.\n\n class MyBytes(bytes):\n pass\n base = b'abc'\n m = MyBytes(base)\n # b2a_hex uses the buffer interface to get its argument's value, via\n # PyArg_ParseTuple 't#' code.\n self.assertEqual(binascii.b2a_hex(m), binascii.b2a_hex(base))\n\n class MyInt(int):\n pass\n m = MyInt(42)\n try:\n binascii.b2a_hex(m)\n self.fail('subclass of int should not have a buffer interface')\n except TypeError:\n pass\n\n def test_str_of_str_subclass(self):\n # Testing __str__ defined in subclass of str ...\n import binascii\n import io\n\n class octetstring(str):\n def __str__(self):\n return binascii.b2a_hex(self.encode('ascii')).decode(\"ascii\")\n def __repr__(self):\n return self + \" repr\"\n\n o = octetstring('A')\n self.assertEqual(type(o), octetstring)\n self.assertEqual(type(str(o)), str)\n self.assertEqual(type(repr(o)), str)\n self.assertEqual(ord(o), 0x41)\n self.assertEqual(str(o), '41')\n self.assertEqual(repr(o), 'A repr')\n self.assertEqual(o.__str__(), '41')\n self.assertEqual(o.__repr__(), 'A repr')\n\n capture = io.StringIO()\n # Calling str() or not exercises different internal paths.\n print(o, file=capture)\n print(str(o), file=capture)\n self.assertEqual(capture.getvalue(), '41\\n41\\n')\n capture.close()\n\n def test_keyword_arguments(self):\n # Testing keyword arguments to __init__, __call__...\n def f(a): return a\n self.assertEqual(f.__call__(a=42), 42)\n ba = bytearray()\n bytearray.__init__(ba, 'abc\\xbd\\u20ac',\n encoding='latin1', errors='replace')\n self.assertEqual(ba, b'abc\\xbd?')\n\n def test_recursive_call(self):\n # Testing recursive __call__() by setting to instance of class...\n class A(object):\n pass\n\n A.__call__ = A()\n try:\n A()()\n except RecursionError:\n pass\n else:\n self.fail(\"Recursion limit should have been reached for __call__()\")\n\n def test_delete_hook(self):\n # Testing __del__ hook...\n log = []\n class C(object):\n def __del__(self):\n log.append(1)\n c = C()\n self.assertEqual(log, [])\n del c\n support.gc_collect()\n self.assertEqual(log, [1])\n\n class D(object): pass\n d = D()\n try: del d[0]\n except TypeError: pass\n else: self.fail(\"invalid del() didn't raise TypeError\")\n\n def test_hash_inheritance(self):\n # Testing hash of mutable subclasses...\n\n class mydict(dict):\n pass\n d = mydict()\n try:\n hash(d)\n except TypeError:\n pass\n else:\n self.fail(\"hash() of dict subclass should fail\")\n\n class mylist(list):\n pass\n d = mylist()\n try:\n hash(d)\n except TypeError:\n pass\n else:\n self.fail(\"hash() of list subclass should fail\")\n\n def test_str_operations(self):\n try: 'a' + 5\n except TypeError: pass\n else: self.fail(\"'' + 5 doesn't raise TypeError\")\n\n try: ''.split('')\n except ValueError: pass\n else: self.fail(\"''.split('') doesn't raise ValueError\")\n\n try: ''.join([0])\n except TypeError: pass\n else: self.fail(\"''.join([0]) doesn't raise TypeError\")\n\n try: ''.rindex('5')\n except ValueError: pass\n else: self.fail(\"''.rindex('5') doesn't raise ValueError\")\n\n try: '%(n)s' % None\n except TypeError: pass\n else: self.fail(\"'%(n)s' % None doesn't raise TypeError\")\n\n try: '%(n' % {}\n except ValueError: pass\n else: self.fail(\"'%(n' % {} '' doesn't raise ValueError\")\n\n try: '%*s' % ('abc')\n except TypeError: pass\n else: self.fail(\"'%*s' % ('abc') doesn't raise TypeError\")\n\n try: '%*.*s' % ('abc', 5)\n except TypeError: pass\n else: self.fail(\"'%*.*s' % ('abc', 5) doesn't raise TypeError\")\n\n try: '%s' % (1, 2)\n except TypeError: pass\n else: self.fail(\"'%s' % (1, 2) doesn't raise TypeError\")\n\n try: '%' % None\n except ValueError: pass\n else: self.fail(\"'%' % None doesn't raise ValueError\")\n\n self.assertEqual('534253'.isdigit(), 1)\n self.assertEqual('534253x'.isdigit(), 0)\n self.assertEqual('%c' % 5, '\\x05')\n self.assertEqual('%c' % '5', '5')\n\n def test_deepcopy_recursive(self):\n # Testing deepcopy of recursive objects...\n class Node:\n pass\n a = Node()\n b = Node()\n a.b = b\n b.a = a\n z = deepcopy(a) # This blew up before\n\n def test_uninitialized_modules(self):\n # Testing uninitialized module objects...\n from types import ModuleType as M\n m = M.__new__(M)\n str(m)\n self.assertNotHasAttr(m, \"__name__\")\n self.assertNotHasAttr(m, \"__file__\")\n self.assertNotHasAttr(m, \"foo\")\n self.assertFalse(m.__dict__) # None or {} are both reasonable answers\n m.foo = 1\n self.assertEqual(m.__dict__, {\"foo\": 1})\n\n def test_funny_new(self):\n # Testing __new__ returning something unexpected...\n class C(object):\n def __new__(cls, arg):\n if isinstance(arg, str): return [1, 2, 3]\n elif isinstance(arg, int): return object.__new__(D)\n else: return object.__new__(cls)\n class D(C):\n def __init__(self, arg):\n self.foo = arg\n self.assertEqual(C(\"1\"), [1, 2, 3])\n self.assertEqual(D(\"1\"), [1, 2, 3])\n d = D(None)\n self.assertEqual(d.foo, None)\n d = C(1)\n self.assertIsInstance(d, D)\n self.assertEqual(d.foo, 1)\n d = D(1)\n self.assertIsInstance(d, D)\n self.assertEqual(d.foo, 1)\n\n class C(object):\n @staticmethod\n def __new__(*args):\n return args\n self.assertEqual(C(1, 2), (C, 1, 2))\n class D(C):\n pass\n self.assertEqual(D(1, 2), (D, 1, 2))\n\n class C(object):\n @classmethod\n def __new__(*args):\n return args\n self.assertEqual(C(1, 2), (C, C, 1, 2))\n class D(C):\n pass\n self.assertEqual(D(1, 2), (D, D, 1, 2))\n\n def test_imul_bug(self):\n # Testing for __imul__ problems...\n # SF bug 544647\n class C(object):\n def __imul__(self, other):\n return (self, other)\n x = C()\n y = x\n y *= 1.0\n self.assertEqual(y, (x, 1.0))\n y = x\n y *= 2\n self.assertEqual(y, (x, 2))\n y = x\n y *= 3\n self.assertEqual(y, (x, 3))\n y = x\n y *= 1<<100\n self.assertEqual(y, (x, 1<<100))\n y = x\n y *= None\n self.assertEqual(y, (x, None))\n y = x\n y *= \"foo\"\n self.assertEqual(y, (x, \"foo\"))\n\n def test_copy_setstate(self):\n # Testing that copy.*copy() correctly uses __setstate__...\n import copy\n class C(object):\n def __init__(self, foo=None):\n self.foo = foo\n self.__foo = foo\n def setfoo(self, foo=None):\n self.foo = foo\n def getfoo(self):\n return self.__foo\n def __getstate__(self):\n return [self.foo]\n def __setstate__(self_, lst):\n self.assertEqual(len(lst), 1)\n self_.__foo = self_.foo = lst[0]\n a = C(42)\n a.setfoo(24)\n self.assertEqual(a.foo, 24)\n self.assertEqual(a.getfoo(), 42)\n b = copy.copy(a)\n self.assertEqual(b.foo, 24)\n self.assertEqual(b.getfoo(), 24)\n b = copy.deepcopy(a)\n self.assertEqual(b.foo, 24)\n self.assertEqual(b.getfoo(), 24)\n\n def test_slices(self):\n # Testing cases with slices and overridden __getitem__ ...\n\n # Strings\n self.assertEqual(\"hello\"[:4], \"hell\")\n self.assertEqual(\"hello\"[slice(4)], \"hell\")\n self.assertEqual(str.__getitem__(\"hello\", slice(4)), \"hell\")\n class S(str):\n def __getitem__(self, x):\n return str.__getitem__(self, x)\n self.assertEqual(S(\"hello\")[:4], \"hell\")\n self.assertEqual(S(\"hello\")[slice(4)], \"hell\")\n self.assertEqual(S(\"hello\").__getitem__(slice(4)), \"hell\")\n # Tuples\n self.assertEqual((1,2,3)[:2], (1,2))\n self.assertEqual((1,2,3)[slice(2)], (1,2))\n self.assertEqual(tuple.__getitem__((1,2,3), slice(2)), (1,2))\n class T(tuple):\n def __getitem__(self, x):\n return tuple.__getitem__(self, x)\n self.assertEqual(T((1,2,3))[:2], (1,2))\n self.assertEqual(T((1,2,3))[slice(2)], (1,2))\n self.assertEqual(T((1,2,3)).__getitem__(slice(2)), (1,2))\n # Lists\n self.assertEqual([1,2,3][:2], [1,2])\n self.assertEqual([1,2,3][slice(2)], [1,2])\n self.assertEqual(list.__getitem__([1,2,3], slice(2)), [1,2])\n class L(list):\n def __getitem__(self, x):\n return list.__getitem__(self, x)\n self.assertEqual(L([1,2,3])[:2], [1,2])\n self.assertEqual(L([1,2,3])[slice(2)], [1,2])\n self.assertEqual(L([1,2,3]).__getitem__(slice(2)), [1,2])\n # Now do lists and __setitem__\n a = L([1,2,3])\n a[slice(1, 3)] = [3,2]\n self.assertEqual(a, [1,3,2])\n a[slice(0, 2, 1)] = [3,1]\n self.assertEqual(a, [3,1,2])\n a.__setitem__(slice(1, 3), [2,1])\n self.assertEqual(a, [3,2,1])\n a.__setitem__(slice(0, 2, 1), [2,3])\n self.assertEqual(a, [2,3,1])\n\n def test_subtype_resurrection(self):\n # Testing resurrection of new-style instance...\n\n class C(object):\n container = []\n\n def __del__(self):\n # resurrect the instance\n C.container.append(self)\n\n c = C()\n c.attr = 42\n\n # The most interesting thing here is whether this blows up, due to\n # flawed GC tracking logic in typeobject.c's call_finalizer() (a 2.2.1\n # bug).\n del c\n\n support.gc_collect()\n self.assertEqual(len(C.container), 1)\n\n # Make c mortal again, so that the test framework with -l doesn't report\n # it as a leak.\n del C.__del__\n\n def test_slots_trash(self):\n # Testing slot trash...\n # Deallocating deeply nested slotted trash caused stack overflows\n class trash(object):\n __slots__ = ['x']\n def __init__(self, x):\n self.x = x\n o = None\n for i in range(50000):\n o = trash(o)\n del o\n\n def test_slots_multiple_inheritance(self):\n # SF bug 575229, multiple inheritance w/ slots dumps core\n class A(object):\n __slots__=()\n class B(object):\n pass\n class C(A,B) :\n __slots__=()\n if support.check_impl_detail():\n self.assertEqual(C.__basicsize__, B.__basicsize__)\n self.assertHasAttr(C, '__dict__')\n self.assertHasAttr(C, '__weakref__')\n C().x = 2\n\n def test_rmul(self):\n # Testing correct invocation of __rmul__...\n # SF patch 592646\n class C(object):\n def __mul__(self, other"},"domain":{"kind":"string","value":"codeparrot/github-code-clean"}}},{"rowIdx":227197,"cells":{"text":{"kind":"string","value":"#\n# Custom partitioning classes.\n#\n# Copyright (C) 2012-2014 Red Hat, Inc.\n#\n# This copyrighted material is made available to anyone wishing to use,\n# modify, copy, or redistribute it subject to the terms and conditions of\n# the GNU General Public License v.2, or (at your option) any later version.\n# This program is distributed in the hope that it will be useful, but WITHOUT\n# ANY WARRANTY expressed or implied, including the implied warranties of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General\n# Public License for more details. You should have received a copy of the\n# GNU General Public License along with this program; if not, write to the\n# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\n# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the\n# source code or documentation are not subject to the GNU General Public\n# License and may only be used or replicated with the express permission of\n# Red Hat, Inc.\n#\n# Red Hat Author(s): Chris Lumens <clumens@redhat.com>\n# David Lehman <dlehman@redhat.com>\n# Jiri Konecny <jkonecny@redhat.com>\n#\n\n# TODO:\n# - Deleting an LV is not reflected in available space in the bottom left.\n# - this is only true for preexisting LVs\n# - Device descriptions, suggested sizes, etc. should be moved out into a support file.\n# - Tabbing behavior in the accordion is weird.\n# - Implement striping and mirroring for LVM.\n# - Activating reformat should always enable resize for existing devices.\n\nimport gi\ngi.require_version(\"Gtk\", \"3.0\")\ngi.require_version(\"Gdk\", \"3.0\")\ngi.require_version(\"AnacondaWidgets\", \"3.3\")\n\nfrom gi.repository import Gdk, Gtk\nfrom gi.repository.AnacondaWidgets import MountpointSelector\n\nfrom pykickstart.constants import CLEARPART_TYPE_NONE\n\nfrom pyanaconda.i18n import _, N_, CP_, C_\nfrom pyanaconda.product import productName, productVersion, translated_new_install_name\nfrom pyanaconda.threads import AnacondaThread, threadMgr\nfrom pyanaconda.constants import THREAD_EXECUTE_STORAGE, THREAD_STORAGE, THREAD_CUSTOM_STORAGE_INIT\nfrom pyanaconda.constants import SIZE_UNITS_DEFAULT\nfrom pyanaconda.iutil import lowerASCII\nfrom pyanaconda.bootloader import BootLoaderError\nfrom pyanaconda.kickstart import refreshAutoSwapSize\nfrom pyanaconda import isys\n\nfrom blivet import devicefactory\nfrom blivet.formats import device_formats\nfrom blivet.formats import getFormat\nfrom blivet.formats.fs import FS\nfrom blivet.size import Size\nfrom blivet.devicefactory import DEVICE_TYPE_LVM\nfrom blivet.devicefactory import DEVICE_TYPE_BTRFS\nfrom blivet.devicefactory import DEVICE_TYPE_PARTITION\nfrom blivet.devicefactory import DEVICE_TYPE_MD\nfrom blivet.devicefactory import DEVICE_TYPE_DISK\nfrom blivet.devicefactory import DEVICE_TYPE_LVM_THINP\nfrom blivet.devicefactory import SIZE_POLICY_AUTO\nfrom blivet.devicefactory import is_supported_device_type\nfrom blivet.osinstall import findExistingInstallations, Root\nfrom blivet.autopart import doAutoPartition\nfrom blivet.errors import StorageError\nfrom blivet.errors import NoDisksError\nfrom blivet.errors import NotEnoughFreeSpaceError\nfrom blivet.devicelibs import raid, crypto\nfrom blivet.devices import LUKSDevice, MDRaidArrayDevice, LVMVolumeGroupDevice\nfrom blivet.platform import platform\n\nfrom pyanaconda.storage_utils import ui_storage_logger, device_type_from_autopart\nfrom pyanaconda.storage_utils import DEVICE_TEXT_PARTITION, DEVICE_TEXT_MAP, DEVICE_TEXT_MD\nfrom pyanaconda.storage_utils import PARTITION_ONLY_FORMAT_TYPES, MOUNTPOINT_DESCRIPTIONS\nfrom pyanaconda.storage_utils import NAMED_DEVICE_TYPES, CONTAINER_DEVICE_TYPES\nfrom pyanaconda.storage_utils import SanityError, SanityWarning, LUKSDeviceWithoutKeyError\nfrom pyanaconda.storage_utils import try_populate_devicetree\nfrom pyanaconda import storage_utils\n\nfrom pyanaconda.ui.communication import hubQ\nfrom pyanaconda.ui.gui.spokes import NormalSpoke\nfrom pyanaconda.ui.helpers import StorageChecker\nfrom pyanaconda.ui.gui.spokes.lib.cart import SelectedDisksDialog\nfrom pyanaconda.ui.gui.spokes.lib.passphrase import PassphraseDialog\nfrom pyanaconda.ui.gui.spokes.lib.accordion import update_selector_from_device, Accordion, Page, CreateNewPage, UnknownPage\nfrom pyanaconda.ui.gui.spokes.lib.refresh import RefreshDialog\nfrom pyanaconda.ui.gui.spokes.lib.summary import ActionSummaryDialog\n\nfrom pyanaconda.ui.gui.spokes.lib.custom_storage_helpers import size_from_entry\nfrom pyanaconda.ui.gui.spokes.lib.custom_storage_helpers import validate_label, validate_mountpoint, get_raid_level\nfrom pyanaconda.ui.gui.spokes.lib.custom_storage_helpers import selectedRaidLevel, raidLevelSelection, defaultRaidLevel, requiresRaidSelection, containerRaidLevelsSupported, raidLevelsSupported, defaultContainerRaidLevel\nfrom pyanaconda.ui.gui.spokes.lib.custom_storage_helpers import get_container_type, RAID_NOT_ENOUGH_DISKS\nfrom pyanaconda.ui.gui.spokes.lib.custom_storage_helpers import AddDialog, ConfirmDeleteDialog, DisksDialog, ContainerDialog\n\nfrom pyanaconda.ui.gui.utils import setViewportBackground, fancy_set_sensitive, ignoreEscape\nfrom pyanaconda.ui.gui.utils import really_hide, really_show, timed_action, escape_markup\nfrom pyanaconda.ui.categories.system import SystemCategory\n\nfrom functools import wraps\nfrom itertools import chain\n\nimport logging\nlog = logging.getLogger(\"anaconda\")\n\n__all__ = [\"CustomPartitioningSpoke\"]\n\nNOTEBOOK_LABEL_PAGE = 0\nNOTEBOOK_DETAILS_PAGE = 1\nNOTEBOOK_LUKS_PAGE = 2\nNOTEBOOK_UNEDITABLE_PAGE = 3\nNOTEBOOK_INCOMPLETE_PAGE = 4\n\nNEW_CONTAINER_TEXT = N_(\"Create a new %(container_type)s ...\")\nCONTAINER_TOOLTIP = N_(\"Create or select %(container_type)s\")\n\nDEVICE_CONFIGURATION_ERROR_MSG = N_(\"Device reconfiguration failed. <a href=\\\"\\\">Click for \"\n \"details.</a>\")\nUNRECOVERABLE_ERROR_MSG = N_(\"Storage configuration reset due to unrecoverable \"\n \"error. <a href=\\\"\\\">Click for details.</a>\")\n\ndef dev_type_from_const(dev_type_const):\n \"\"\" Return integer corresponding to name for device type defined as\n a constant in blivet.devicefactory.\n\n :param str dev_type_const: the name of a DEVICE_TYPE_*\n :returns: the corresponding integer code, if there is one\n :rtype: int or NoneType\n \"\"\"\n return getattr(devicefactory, dev_type_const, None)\n\ndef ui_storage_logged(func):\n @wraps(func)\n def decorated(*args, **kwargs):\n with ui_storage_logger():\n return func(*args, **kwargs)\n\n return decorated\n\nclass CustomPartitioningSpoke(NormalSpoke, StorageChecker):\n \"\"\"\n .. inheritance-diagram:: CustomPartitioningSpoke\n :parts: 3\n \"\"\"\n builderObjects = [\"customStorageWindow\", \"containerStore\", \"deviceTypeStore\",\n \"partitionStore\", \"raidStoreFiltered\", \"raidLevelStore\",\n \"addImage\", \"removeImage\", \"settingsImage\",\n \"mountPointCompletion\", \"mountPointStore\", \"fileSystemStore\"]\n mainWidgetName = \"customStorageWindow\"\n uiFile = \"spokes/custom.glade\"\n helpFile = \"CustomSpoke.xml\"\n\n category = SystemCategory\n title = N_(\"MANUAL PARTITIONING\")\n\n # The maximum number of places to show when displaying a size\n MAX_SIZE_PLACES = 2\n\n # If the user enters a smaller size, the GUI changes it to this value\n MIN_SIZE_ENTRY = Size(\"1 MiB\")\n\n def __init__(self, data, storage, payload, instclass):\n StorageChecker.__init__(self, min_ram=isys.MIN_GUI_RAM)\n NormalSpoke.__init__(self, data, storage, payload, instclass)\n\n self._back_already_clicked = False\n self._storage_playground = None\n\n self.passphrase = \"\"\n\n self._devices = []\n self._error = None\n self._hidden_disks = []\n self._fs_types = set() # set of supported fstypes\n self._free_space = Size(0)\n\n self._device_disks = []\n self._device_container_name = None\n self._device_container_raid_level = None\n self._device_container_encrypted = False\n self._device_container_size = SIZE_POLICY_AUTO\n self._device_name_dict = {DEVICE_TYPE_LVM: None,\n DEVICE_TYPE_MD: None,\n DEVICE_TYPE_LVM_THINP: None,\n DEVICE_TYPE_PARTITION: \"\",\n DEVICE_TYPE_BTRFS: \"\",\n DEVICE_TYPE_DISK: \"\"}\n\n self._initialized = False\n\n def apply(self):\n self.clear_errors()\n\n self._unhide_unusable_disks()\n\n new_swaps = (dev for dev in self.get_new_devices() if dev.format.type == \"swap\")\n self.storage.setFstabSwaps(new_swaps)\n\n # update the global passphrase\n self.data.autopart.passphrase = self.passphrase\n\n # make sure any device/passphrase pairs we've obtained are remembered\n for device in self.storage.devices:\n if device.format.type == \"luks\" and not device.format.exists:\n if not device.format.hasKey:\n device.format.passphrase = self.passphrase\n\n self.storage.savePassphrase(device)\n\n hubQ.send_ready(\"StorageSpoke\", True)\n\n @property\n def indirect(self):\n return True\n\n # This spoke has no status since it's not in a hub\n @property\n def status(self):\n return None\n\n def _grabObjects(self):\n self._configureBox = self.builder.get_object(\"configureBox\")\n\n self._partitionsViewport = self.builder.get_object(\"partitionsViewport\")\n self._partitionsNotebook = self.builder.get_object(\"partitionsNotebook\")\n\n # Connect partitionsNotebook focus events to scrolling in the parent viewport\n partitionsNotebookViewport = self.builder.get_object(\"partitionsNotebookViewport\")\n self._partitionsNotebook.set_focus_vadjustment(partitionsNotebookViewport.get_vadjustment())\n\n self._pageLabel = self.builder.get_object(\"pageLabel\")\n\n self._availableSpaceLabel = self.builder.get_object(\"availableSpaceLabel\")\n self._totalSpaceLabel = self.builder.get_object(\"totalSpaceLabel\")\n self._summaryLabel = self.builder.get_object(\"summary_label\")\n\n # Buttons\n self._addButton = self.builder.get_object(\"addButton\")\n self._applyButton = self.builder.get_object(\"applyButton\")\n self._configButton = self.builder.get_object(\"configureButton\")\n self._removeButton = self.builder.get_object(\"removeButton\")\n self._resetButton = self.builder.get_object(\"resetButton\")\n\n # Detailed configuration stuff\n self._encryptCheckbox = self.builder.get_object(\"encryptCheckbox\")\n self._fsCombo = self.builder.get_object(\"fileSystemTypeCombo\")\n self._fsStore = self.builder.get_object(\"fileSystemStore\")\n self._labelEntry = self.builder.get_object(\"labelEntry\")\n self._mountPointEntry = self.builder.get_object(\"mountPointEntry\")\n self._nameEntry = self.builder.get_object(\"nameEntry\")\n self._raidLevelCombo = self.builder.get_object(\"raidLevelCombo\")\n self._raidLevelLabel = self.builder.get_object(\"raidLevelLabel\")\n self._reformatCheckbox = self.builder.get_object(\"reformatCheckbox\")\n self._sizeEntry = self.builder.get_object(\"sizeEntry\")\n self._typeStore = self.builder.get_object(\"deviceTypeStore\")\n self._typeCombo = self.builder.get_object(\"deviceTypeCombo\")\n self._modifyContainerButton = self.builder.get_object(\"modifyContainerButton\")\n self._containerCombo = self.builder.get_object(\"containerCombo\")\n self._containerStore = self.builder.get_object(\"containerStore\")\n self._deviceDescLabel = self.builder.get_object(\"deviceDescLabel\")\n\n # Set the fixed-size properties on the volume group ComboBox renderers to\n # False so that the \"Create a new...\" row can overlap with the free space\n # on the other rows. These properties are not accessible from glade.\n cell_area = self._containerCombo.get_area()\n descRenderer = self.builder.get_object(\"descRenderer\")\n freeSpaceRenderer = self.builder.get_object(\"freeSpaceRenderer\")\n cell_area.cell_set_property(descRenderer, \"fixed-size\", False)\n cell_area.cell_set_property(freeSpaceRenderer, \"fixed-size\", False)\n\n self._passphraseEntry = self.builder.get_object(\"passphraseEntry\")\n\n # Stores\n self._raidStoreFilter = self.builder.get_object(\"raidStoreFiltered\")\n\n # Labels\n self._selectedDeviceLabel = self.builder.get_object(\"selectedDeviceLabel\")\n self._selectedDeviceDescLabel = self.builder.get_object(\"selectedDeviceDescLabel\")\n self._encryptedDeviceLabel = self.builder.get_object(\"encryptedDeviceLabel\")\n self._encryptedDeviceDescLabel = self.builder.get_object(\"encryptedDeviceDescriptionLabel\")\n self._incompleteDeviceLabel = self.builder.get_object(\"incompleteDeviceLabel\")\n self._incompleteDeviceDescLabel = self.builder.get_object(\"incompleteDeviceDescriptionLabel\")\n self._incompleteDeviceOptionsLabel = self.builder.get_object(\"incompleteDeviceOptionsLabel\")\n self._uneditableDeviceLabel = self.builder.get_object(\"uneditableDeviceLabel\")\n self._uneditableDeviceDescLabel = self.builder.get_object(\"uneditableDeviceDescriptionLabel\")\n self._containerLabel = self.builder.get_object(\"containerLabel\")\n\n def initialize(self):\n NormalSpoke.initialize(self)\n self._grabObjects()\n\n setViewportBackground(self.builder.get_object(\"availableSpaceViewport\"), \"#db3279\")\n setViewportBackground(self.builder.get_object(\"totalSpaceViewport\"), \"#60605b\")\n\n self._raidStoreFilter.set_visible_func(self._raid_level_visible)\n\n self._accordion = Accordion()\n self._partitionsViewport.add(self._accordion)\n\n # Connect viewport scrolling with accordion focus events\n self._accordion.set_focus_hadjustment(self._partitionsViewport.get_hadjustment())\n self._accordion.set_focus_vadjustment(self._partitionsViewport.get_vadjustment())\n\n threadMgr.add(AnacondaThread(name=THREAD_CUSTOM_STORAGE_INIT, target=self._initialize))\n\n def _initialize(self):\n \"\"\" Populate the set of valid filesystem types from the format classes.\n\n Restrict the set to ones that we might allow users to select.\n \"\"\"\n _fs_types = []\n for cls in device_formats.values():\n obj = cls()\n\n # btrfs is always handled by on_device_type_changed\n supported_fs = (obj.type != \"btrfs\" and\n obj.type != \"tmpfs\" and\n obj.supported and obj.formattable and\n (isinstance(obj, FS) or\n obj.type in [\"biosboot\", \"prepboot\", \"swap\"]))\n if supported_fs:\n _fs_types.append(obj.name)\n\n self._fs_types = set(_fs_types)\n\n @property\n def _clearpartDevices(self):\n return [d for d in self._devices if d.name in self.data.clearpart.drives and d.partitioned]\n\n @property\n def unusedDevices(self):\n unused_devices = [d for d in self._storage_playground.unusedDevices\n if d.disks and d.mediaPresent and\n not d.partitioned and (d.direct or d.isleaf)]\n # add incomplete VGs and MDs\n incomplete = [d for d in self._storage_playground.devicetree._devices\n if not getattr(d, \"complete\", True)]\n unused_devices.extend(incomplete)\n return unused_devices\n\n @property\n def bootLoaderDevices(self):\n devices = []\n format_types = [\"biosboot\", \"prepboot\"]\n for device in self._devices:\n if device.format.type not in format_types:\n continue\n\n disk_names = (d.name for d in device.disks)\n # bootDrive may not be setup because it IS one of these.\n if not self.data.bootloader.bootDrive or \\\n self.data.bootloader.bootDrive in disk_names:\n devices.append(device)\n\n return devices\n\n @property\n def _currentFreeInfo(self):\n return self._storage_playground.getFreeSpace(clearPartType=CLEARPART_TYPE_NONE)\n\n def _setCurrentFreeSpace(self):\n \"\"\"Add up all the free space on selected disks and return it as a Size.\"\"\"\n self._free_space = sum(f[0] for f in self._currentFreeInfo.values())\n\n def _currentTotalSpace(self):\n \"\"\"Add up the sizes of all selected disks and return it as a Size.\"\"\"\n totalSpace = sum((disk.size for disk in self._clearpartDevices),\n Size(0))\n return totalSpace\n\n def _updateSpaceDisplay(self):\n # Set up the free space/available space displays in the bottom left.\n self._setCurrentFreeSpace()\n\n self._availableSpaceLabel.set_text(str(self._free_space))\n self._totalSpaceLabel.set_text(str(self._currentTotalSpace()))\n\n count = len(self.data.clearpart.drives)\n summary = CP_(\"GUI|Custom Partitioning\",\n \"%d _storage device selected\",\n \"%d _storage devices selected\",\n count) % count\n\n self._summaryLabel.set_text(summary)\n self._summaryLabel.set_use_underline(True)\n\n @ui_storage_logged\n def _hide_unusable_disks(self):\n self._hidden_disks = []\n\n for disk in self._storage_playground.disks:\n if disk.protected or not disk.mediaPresent:\n # hide removable disks containing install media\n self._hidden_disks.append(disk)\n self._storage_playground.devicetree.hide(disk)\n\n def _unhide_unusable_disks(self):\n for disk in reversed(self._hidden_disks):\n self._storage_playground.devicetree.unhide(disk)\n\n def _reset_storage(self):\n self._storage_playground = self.storage.copy()\n self._hide_unusable_disks()\n self._devices = self._storage_playground.devices\n\n def refresh(self):\n self.clear_errors()\n NormalSpoke.refresh(self)\n\n # Make sure the storage spoke execute method has finished before we\n # copy the storage instance.\n for thread_name in [THREAD_EXECUTE_STORAGE, THREAD_STORAGE]:\n threadMgr.wait(thread_name)\n\n self._back_already_clicked = False\n\n self.passphrase = self.data.autopart.passphrase\n self._reset_storage()\n self._do_refresh()\n\n self._updateSpaceDisplay()\n self._applyButton.set_sensitive(False)\n\n def _get_fstype(self, fstypeCombo):\n itr = fstypeCombo.get_active_iter()\n if not itr:\n return None\n\n model = fstypeCombo.get_model()\n return model[itr][0]\n\n def _get_autopart_type(self, autopartTypeCombo):\n itr = autopartTypeCombo.get_active_iter()\n if not itr:\n return None\n\n model = autopartTypeCombo.get_model()\n return model[itr][1]\n\n def _change_autopart_type(self, autopartTypeCombo):\n \"\"\"\n This is called when the autopart type combo on the left hand side of\n custom partitioning is changed. We already know how to handle the case\n where the user changes the type and then clicks the autopart link\n button. This handles the case where the user changes the type and then\n clicks the '+' button.\n\n \"\"\"\n\n self.data.autopart.type = self._get_autopart_type(autopartTypeCombo)\n\n def get_new_devices(self):\n # A device scheduled for formatting only belongs in the new root.\n new_devices = [d for d in self._devices if d.direct and\n not d.format.exists and\n not d.partitioned]\n\n # If mountpoints have been assigned to any existing devices, go ahead\n # and pull those in along with any existing swap devices. It doesn't\n # matter if the formats being mounted exist or not.\n new_mounts = [d for d in self._storage_playground.mountpoints.values() if d.exists]\n if new_mounts or new_devices:\n new_devices.extend(self._storage_playground.mountpoints.values())\n new_devices.extend(self.bootLoaderDevices)\n\n new_devices = list(set(new_devices))\n\n return new_devices\n\n def _set_page_label_text(self):\n if self._accordion.is_multiselection:\n select_tmpl = _(\"%(items_selected)s of %(items_total)s mount points in %(page_name)s\")\n span_tmpl = \"<span size='large' weight='bold' fgcolor='%s'>%s</span>\"\n pages_count = \"\"\n for page in self._accordion.all_pages:\n if not page.members:\n continue\n\n if page.selected_members:\n highlight_color = \"black\"\n page_text_tmpl = select_tmpl\n else:\n highlight_color = \"gray\"\n page_text_tmpl = \"<span fgcolor='gray'>%s</span>\" % escape_markup(select_tmpl)\n\n selected_str = span_tmpl % (escape_markup(highlight_color),\n escape_markup(str(len(page.selected_members))))\n total_str = span_tmpl % (escape_markup(highlight_color),\n escape_markup(str(len(page.members))))\n page_name = span_tmpl % (escape_markup(highlight_color),\n escape_markup(page.pageTitle))\n\n page_line = page_text_tmpl % {\"items_selected\" : selected_str,\n \"items_total\" : total_str,\n \"page_name\" : page_name}\n pages_count += page_line + \"\\n\"\n\n self._pageLabel.set_markup(_(\"Please select a single mount point to edit properties.\\n\\n\"\n \"You have currently selected:\\n\"\n \"%s\") % (pages_count))\n else:\n self._pageLabel.set_text(_(\"When you create mount points for \"\n \"your %(name)s %(version)s installation, you'll be able to \"\n \"view their details here.\") % {\"name\" : productName,\n \"version\" : productVersion})\n def _populate_accordion(self):\n # Make sure we start with a clean state.\n self._accordion.remove_all_pages()\n\n new_devices = self.get_new_devices()\n\n # Now it's time to populate the accordion.\n log.debug(\"ui: devices=%s\", [d.name for d in self._devices])\n log.debug(\"ui: unused=%s\", [d.name for d in self.unusedDevices])\n log.debug(\"ui: new_devices=%s\", [d.name for d in new_devices])\n\n ui_roots = self._storage_playground.roots[:]\n\n # If we've not yet run autopart, add an instance of CreateNewPage. This\n # ensures it's only added once.\n if not new_devices:\n page = CreateNewPage(translated_new_install_name(),\n self.on_create_clicked,\n self._change_autopart_type,\n partitionsToReuse=bool(ui_roots) or bool(self.unusedDevices))\n self._accordion.add_page(page, cb=self.on_page_clicked)\n\n self._partitionsNotebook.set_current_page(NOTEBOOK_LABEL_PAGE)\n self._set_page_label_text()\n\n else:\n swaps = [d for d in new_devices if d.format.type == \"swap\"]\n mounts = dict((d.format.mountpoint, d) for d in new_devices\n if getattr(d.format, \"mountpoint\", None))\n\n for device in new_devices:\n if device in self.bootLoaderDevices:\n mounts[device.format.name] = device\n\n new_root = Root(mounts=mounts, swaps=swaps, name=translated_new_install_name())\n ui_roots.insert(0, new_root)\n\n # Add in all the existing (or autopart-created) operating systems.\n for root in ui_roots:\n # Don't make a page if none of the root's devices are left.\n # Also, only include devices in an old page if the format is intact.\n if not any(d for d in chain(root.swaps, root.mounts.values())\n if d in self._devices and d.disks and\n (root.name == translated_new_install_name() or d.format.exists)):\n continue\n\n page = Page(root.name)\n self._accordion.add_page(page, cb=self.on_page_clicked)\n\n for (mountpoint, device) in root.mounts.items():\n if device not in self._devices or \\\n not device.disks or \\\n (root.name != translated_new_install_name() and not device.format.exists):\n continue\n\n selector = page.add_selector(device, self.on_selector_clicked,\n mountpoint=mountpoint)\n selector.root = root\n\n for device in root.swaps:\n if device not in self._devices or \\\n (root.name != translated_new_install_name() and not device.format.exists):\n continue\n\n selector = page.add_selector(device, self.on_selector_clicked)\n selector.root = root\n\n page.show_all()\n\n # Anything that doesn't go with an OS we understand? Put it in the Other box.\n if self.unusedDevices:\n page = UnknownPage(_(\"Unknown\"))\n self._accordion.add_page(page, cb=self.on_page_clicked)\n\n for u in sorted(self.unusedDevices, key=lambda d: d.name):\n page.add_selector(u, self.on_selector_clicked)\n\n page.show_all()\n\n def _do_refresh(self, mountpointToShow=None):\n # block mountpoint selector signal handler for now\n self._initialized = False\n self._accordion.clear_current_selector()\n\n # Start with buttons disabled, since nothing is selected.\n self._removeButton.set_sensitive(False)\n self._configButton.set_sensitive(False)\n\n # populate the accorion with roots and mount points\n self._populate_accordion()\n\n # And then open the first page by default. Most of the time, this will\n # be fine since it'll be the new installation page.\n self._initialized = True\n firstPage = self._accordion.all_pages[0]\n self._accordion.expand_page(firstPage.pageTitle)\n self._show_mountpoint(page=firstPage, mountpoint=mountpointToShow)\n\n self._applyButton.set_sensitive(False)\n self._resetButton.set_sensitive(len(self._storage_playground.devicetree.findActions()) > 0)\n\n ###\n ### RIGHT HAND SIDE METHODS\n ###\n def add_new_selector(self, device):\n \"\"\" Add an entry for device to the new install Page. \"\"\"\n page = self._accordion.find_page_by_title(translated_new_install_name())\n devices = [device]\n if not page.members:\n # remove the CreateNewPage and replace it with a regular Page\n expander = self._accordion.find_page_by_title(translated_new_install_name()).get_parent()\n expander.remove(expander.get_child())\n\n page = Page(translated_new_install_name())\n expander.add(page)\n\n # also pull in biosboot and prepboot that are on our boot disk\n devices.extend(self.bootLoaderDevices)\n devices = list(set(devices))\n\n for _device in devices:\n page.add_selector(_device, self.on_selector_clicked)\n\n page.show_all()\n\n def _update_selectors(self):\n \"\"\" Update all btrfs selectors' size properties. \"\"\"\n # we're only updating selectors in the new root. problem?\n page = self._accordion.find_page_by_title(translated_new_install_name())\n for selector in page.members:\n update_selector_from_device(selector, selector.device)\n\n def _replace_device(self, **kwargs):\n \"\"\" Create a replacement device and update the device selector. \"\"\"\n selector = kwargs.pop(\"selector\", None)\n dev_type = kwargs.pop(\"device_type\")\n size = kwargs.pop(\"size\")\n new_device = self._storage_playground.factoryDevice(dev_type, size, **kwargs)\n\n self._devices = self._storage_playground.devices\n\n if selector:\n # update the selector with the new device and its size\n update_selector_from_device(selector, new_device)\n\n def _update_device_in_selectors(self, old_device, new_device):\n for s in self._accordion.all_selectors:\n if s._device == old_device:\n update_selector_from_device(s, new_device)\n\n def _update_all_devices_in_selectors(self):\n for s in self._accordion.all_selectors:\n for new_device in self._storage_playground.devices:\n if ((s._device.name == new_device.name) or\n (getattr(s._device, \"req_name\", 1) == getattr(new_device, \"req_name\", 2)) and\n s._device.type == new_device.type and\n s._device.format.type == new_device.format.type):\n update_selector_from_device(s, new_device)\n break\n else:\n log.warning(\"failed to replace device: %s\", s._device)\n\n def _add_device_type(self, dev_type_const):\n self._typeStore.append([_(DEVICE_TEXT_MAP[dev_type_from_const(dev_type_const)]),\n dev_type_const])\n\n def _validate_mountpoint(self, mountpoint, device, device_type, new_fs_type,\n reformat, encrypted, raid_level):\n \"\"\" Validate various aspects of a mountpoint.\n\n :param str mountpoint: the mountpoint\n :param device: blivet.devices.Device instance\n :param int device_type: one of an enumeration of device types\n :param str new_fs_type: string representing the new filesystem type\n :param bool reformat: whether the device is to be reformatted\n :param bool encrypted: whether the device is to be encrypted\n :param raid_level: instance of blivet.devicelibs.raid.RAIDLevel or None\n \"\"\"\n error = None\n if device_type not in (DEVICE_TYPE_PARTITION, DEVICE_TYPE_MD) and \\\n mountpoint == \"/boot/efi\":\n error = (_(\"/boot/efi must be on a device of type %(oneFsType)s or %(anotherFsType)s\")\n % {\"oneFsType\": _(DEVICE_TEXT_PARTITION), \"anotherFsType\": _(DEVICE_TEXT_MD)})\n elif device_type != DEVICE_TYPE_PARTITION and \\\n new_fs_type in PARTITION_ONLY_FORMAT_TYPES:\n error = (_(\"%(fs)s must be on a device of type %(type)s\")\n % {\"fs\" : new_fs_type, \"type\" : _(DEVICE_TEXT_PARTITION)})\n elif mountpoint and encrypted and mountpoint.startswith(\"/boot\"):\n error = _(\"%s cannot be encrypted\") % mountpoint\n elif encrypted and new_fs_type in PARTITION_ONLY_FORMAT_TYPES:\n error = _(\"%s cannot be encrypted\") % new_fs_type\n elif mountpoint == \"/\" and device.format.exists and not reformat:\n error = _(\"You must create a new file system on the root device.\")\n\n if not error and \\\n (raid_level is not None or requiresRaidSelection(device_type)) and \\\n raid_level not in raidLevelsSupported(device_type):\n error = _(\"Device does not support RAID level selection %s.\") % raid_level\n\n if not error and raid_level is not None:\n min_disks = raid_level.min_members\n if len(self._device_disks) < min_disks:\n error = _(RAID_NOT_ENOUGH_DISKS) % {\"level\": raid_level,\n \"min\" : min_disks,\n \"count\": len(self._device_disks)}\n\n return error\n\n def _update_size_props(self):\n self._update_selectors()\n self._updateSpaceDisplay()\n\n def _try_replace_device(self, selector, removed_device, new_device_info,\n old_device_info):\n if removed_device:\n # we don't want to pass the device if we removed it\n new_device_info[\"device\"] = None\n try:\n self._replace_device(selector=selector, **new_device_info)\n return True\n except StorageError as e:\n log.error(\"factoryDevice failed: %s\", e)\n # the factory's error handling has replaced all of the\n # devices with copies, so update the selectors' devices\n # accordingly\n self._update_all_devices_in_selectors()\n self._error = e\n self.set_warning(_(DEVICE_CONFIGURATION_ERROR_MSG))\n\n if not removed_device:\n # nothing more to do\n return True\n else:\n # we have removed the old device so we now have to re-create it\n # the disks need to be updated since we've replaced all\n # of the devices with copies in the devicefactory error\n # handler\n old_disk_names = (d.name for d in old_device_info[\"disks\"])\n old_device_info[\"disks\"] = [self._storage_playground.devicetree.getDeviceByName(n) for n in old_disk_names]\n try:\n self._replace_device(selector=selector, **old_device_info)\n return True\n except StorageError as e:\n # failed to recover.\n self.refresh() # this calls self.clear_errors\n self._error = e\n self.set_warning(_(UNRECOVERABLE_ERROR_MSG))\n return False\n\n @ui_storage_logged\n def _revert_reformat(self, device):\n \"\"\" Revert reformat.\n\n :param device: the device being displayed\n :type device: :class:`blivet.devices.StorageDevice`\n \"\"\"\n use_dev = device.raw_device\n\n # figure out the existing device and reset it\n if not use_dev.format.exists:\n original_device = use_dev\n else:\n original_device = device\n\n log.debug(\"resetting device %s\", original_device.name)\n self._storage_playground.resetDevice(original_device)\n\n @ui_storage_logged\n def _handle_size_change(self, size, old_size, device):\n \"\"\" Handle size change.\n\n :param device: the device being displayed\n :type device: :class:`blivet.devices.StorageDevice`\n \"\"\"\n use_dev = device.raw_device\n\n # If a LUKS device is being displayed, adjust the size\n # to the appropriate size for the raw device.\n use_size = size\n use_old_size = old_size\n if use_dev is not device:\n use_size = size + crypto.LUKS_METADATA_SIZE\n use_old_size = use_dev.size\n\n # bound size to boundaries given by the device\n use_size = use_dev.alignTargetSize(use_size)\n use_size = storage_utils.bound_size(use_size, use_dev, use_old_size)\n use_size = use_dev.alignTargetSize(use_size)\n\n # And then we need to re-check that the max size is actually\n # different from the current size.\n _changed_size = False\n if use_size != device.size and size == device.currentSize:\n # size has been set back to its original value\n actions = self._storage_playground.devicetree.findActions(\n action_type=\"resize\",\n devid=use_dev.id\n )\n for action in reversed(actions):\n self._storage_playground.devicetree.cancelAction(action)\n _changed_size = True\n elif use_size != use_dev.size:\n log.debug(\"scheduling resize of device %s to %s\", use_dev.name, use_size)\n\n try:\n self._storage_playground.resizeDevice(use_dev, use_size)\n except StorageError as e:\n log.error(\"failed to schedule device resize: %s\", e)\n use_dev.size = use_old_size\n self._error = e\n self.set_warning(_(\"Device resize request failed. \"\n \"<a href=\\\"\\\">Click for details.</a>\"))\n else:\n _changed_size = True\n\n if _changed_size:\n log.debug(\"new size: %s\", use_dev.size)\n log.debug(\"target size: %s\", use_dev.targetSize)\n\n # update the selector's size property\n # The selector shows the visible disk, so it is necessary\n # to use device and size, which are the values visible to\n # the user.\n for s in self._accordion.all_selectors:\n if s._device == device:\n s.size = str(device.size)\n\n # update size props of all btrfs devices' selectors\n self._update_size_props()\n\n @ui_storage_logged\n def _handle_encryption_change(self, encrypted, device, old_device, selector):\n if not encrypted:\n log.info(\"removing encryption from %s\", device.name)\n self._storage_playground.destroyDevice(device)\n self._devices.remove(device)\n old_device = device\n device = device.slave\n selector.device = device\n self._update_device_in_selectors(old_device, device)\n else:\n log.info(\"applying encryption to %s\", device.name)\n old_device = device\n new_fmt = getFormat(\"luks\", device=device.path)\n self._storage_playground.formatDevice(device, new_fmt)\n luks_dev = LUKSDevice(\"luks-\" + device.name,\n parents=[device])\n self._storage_playground.createDevice(luks_dev)\n self._devices.append(luks_dev)\n device = luks_dev\n selector.device = device\n self._update_device_in_selectors(old_device, device)\n\n self._devices = self._storage_playground.devices\n\n # possibly changed device and old_device, need to return the new ones\n return (device, old_device)\n\n @ui_storage_logged\n def _do_reformat(self, device, mountpoint, label, changed_encryption,\n encrypted, selector, fs_type):\n self.clear_errors()\n #\n # ENCRYPTION\n #\n old_device = None\n if changed_encryption:\n device, old_device = self._handle_encryption_change(encrypted,\n device, old_device, selector)\n #\n # FORMATTING\n #\n log.info(\"scheduling reformat of %s as %s\", device.name, fs_type)\n old_format = device.format\n new_format = getFormat(fs_type,\n mountpoint=mountpoint, label=label,\n device=device.path)\n try:\n self._storage_playground.formatDevice(device, new_format)\n except (StorageError, ValueError) as e:\n log.error(\"failed to register device format action: %s\", e)\n device.format = old_format\n self._error = e\n self.set_warning(_(\"Device reformat request failed. \"\n \"<a href=\\\"\\\">Click for details.</a>\"))\n else:\n # first, remove this selector from any old install page(s)\n new_selector = None\n for (page, _selector) in self._accordion.all_members:\n if _selector.device in (device, old_device):\n if page.pageTitle == translated_new_install_name():\n new_selector = _selector\n continue\n\n page.remove_selector(_selector)\n if not page.members:\n log.debug(\"removing empty page %s\", page.pageTitle)\n self._accordion.remove_page(page.pageTitle)\n\n # either update the existing selector or add a new one\n if new_selector:\n update_selector_from_device(new_selector, device)\n else:\n self.add_new_selector(device)\n\n # possibly changed device, need to return the new one\n return device\n\n def _save_right_side(self, selector):\n \"\"\" Save settings from RHS and apply changes to the device.\n\n This method must never trigger a call to self._do_refresh.\n \"\"\"\n\n self.clear_errors()\n\n # check if initialized and have something to operate on\n if not self._initialized or not selector:\n return\n\n # only call _save_right_side if on the right page and some changes need\n # to be saved (sensitivity of the Update Settings button reflects that)\n if self._partitionsNotebook.get_current_page() != NOTEBOOK_DETAILS_PAGE or \\\n not self._applyButton.get_sensitive():\n return\n\n device = selector.device\n if device not in self._devices:\n # just-removed device\n return\n\n self._back_already_clicked = False\n\n # dictionaries for many, many pieces of information about the device and\n # requested changes, minimum required entropy for LUKS creation is\n # always the same\n new_device_info = {\"min_luks_entropy\": crypto.MIN_CREATE_ENTROPY}\n old_device_info = {\"min_luks_entropy\": crypto.MIN_CREATE_ENTROPY}\n\n new_device_info[\"device\"] = device\n use_dev = device.raw_device\n\n log.info(\"ui: saving changes to device %s\", device.name)\n\n # TODO: member type (as a device type?)\n\n # NAME\n old_name = getattr(use_dev, \"lvname\", use_dev.name)\n name = old_name\n changed_name = False\n if self._nameEntry.get_sensitive():\n name = self._nameEntry.get_text()\n changed_name = (name != old_name)\n else:\n # name entry insensitive means we don't control the name\n name = None\n\n old_device_info[\"name\"] = old_name\n new_device_info[\"name\"] = name\n\n # SIZE\n old_size = device.size\n\n # If the size text hasn't changed at all from that displayed,\n # assume no change intended.\n if old_size.humanReadable(max_places=self.MAX_SIZE_PLACES) == self._sizeEntry.get_text():\n size = old_size\n else:\n size = size_from_entry(\n self._sizeEntry,\n lower_bound=self.MIN_SIZE_ENTRY,\n units=SIZE_UNITS_DEFAULT\n )\n changed_size = ((use_dev.resizable or not use_dev.exists) and\n size != old_size)\n old_device_info[\"size\"] = old_size\n new_device_info[\"size\"] = size\n\n # DEVICE TYPE\n device_type = self._get_current_device_type()\n old_device_type = devicefactory.get_device_type(device)\n changed_device_type = (old_device_type != device_type)\n old_device_info[\"device_type\"] = old_device_type\n new_device_info[\"device_type\"] = device_type\n\n # REFORMAT\n reformat = self._reformatCheckbox.get_active()\n log.debug(\"reformat: %s\", reformat)\n\n # FS TYPE\n old_fs_type = device.format.type\n fs_type_index = self._fsCombo.get_active()\n fs_type_str = self._fsCombo.get_model()[fs_type_index][0]\n new_fs = getFormat(fs_type_str)\n fs_type = new_fs.type\n changed_fs_type = (old_fs_type != fs_type)\n old_device_info[\"fstype\"] = old_fs_type\n new_device_info[\"fstype\"] = fs_type\n\n # ENCRYPTION\n old_encrypted = isinstance(device, LUKSDevice)\n encrypted = self._encryptCheckbox.get_active() and self._encryptCheckbox.is_sensitive()\n changed_encryption = (old_encrypted != encrypted)\n old_device_info[\"encrypted\"] = old_encrypted\n new_device_info[\"encrypted\"] = encrypted\n\n # FS LABEL\n label = self._labelEntry.get_text()\n old_label = getattr(device.format, \"label\", \"\")\n changed_label = (label != old_label)\n old_device_info[\"label\"] = old_label\n new_device_info[\"label\"] = label\n if changed_label or changed_fs_type:\n error = validate_label(label, new_fs)\n if error:\n self._error = error\n self.set_warning(self._error)\n self._populate_right_side(selector)\n return\n\n # MOUNTPOINT\n mountpoint = None # None means format type is not mountable\n if self._mountPointEntry.get_sensitive():\n mountpoint = self._mountPointEntry.get_text()\n\n old_mountpoint = getattr(device.format, \"mountpoint\", \"\") or \"\"\n old_device_info[\"mountpoint\"] = old_mountpoint\n new_device_info[\"mountpoint\"] = mountpoint\n if mountpoint is not None and (reformat or\n mountpoint != old_mountpoint):\n mountpoints = self._storage_playground.mountpoints.copy()\n if old_mountpoint:\n del mountpoints[old_mountpoint]\n\n error = validate_mountpoint(mountpoint, mountpoints.keys())\n if error:\n self._error = error\n self.set_warning(self._error)\n self._populate_right_side(selector)\n return\n\n if not old_mountpoint:\n # prevent false positives below when \"\" != None\n old_mountpoint = None\n\n changed_mountpoint = (old_mountpoint != mountpoint)\n\n # RAID LEVEL\n raid_level = selectedRaidLevel(self._raidLevelCombo)\n old_raid_level = get_raid_level(device)\n changed_raid_level = (old_device_type == device_type and\n device_type in (DEVICE_TYPE_MD,\n DEVICE_TYPE_BTRFS) and\n old_raid_level is not raid_level)\n old_device_info[\"raid_level\"] = old_raid_level\n new_device_info[\"raid_level\"] = raid_level\n\n ##\n ## VALIDATION\n ##\n error = self._validate_mountpoint(mountpoint, device, device_type,\n fs_type_str, reformat, encrypted,\n raid_level)\n if error:\n self.set_warning(error)\n self._populate_right_side(selector)\n return\n\n # If the device is a btrfs volume, the only things we can set/update\n # are mountpoint and container-wide settings.\n if device_type == DEVICE_TYPE_BTRFS and hasattr(use_dev, \"subvolumes\"):\n size = Size(0)\n changed_size = False\n encrypted = False\n changed_encryption = False\n raid_level = None\n changed_raid_level = False\n\n with ui_storage_logger():\n # create a new factory using the appropriate size and type\n factory = devicefactory.get_device_factory(self._storage_playground,\n device_type, size,\n disks=device.disks,\n encrypted=encrypted,\n raid_level=raid_level,\n min_luks_entropy=crypto.MIN_CREATE_ENTROPY)\n\n # CONTAINER\n changed_container = False\n old_container_name = None\n container_name = self._device_container_name\n container = factory.get_container()\n old_container_encrypted = False\n old_container_raid_level = None\n old_container = None\n old_container_size = SIZE_POLICY_AUTO\n if not changed_device_type:\n old_container = factory.get_container(device=use_dev)\n if old_container:\n old_container_name = old_container.name\n old_container_encrypted = old_container.encrypted\n old_container_raid_level = get_raid_level(old_container)\n old_container_size = getattr(old_container, \"size_policy\",\n old_container.size)\n\n container = factory.get_container(name=container_name)\n if old_container and container_name != old_container.name:\n changed_container = True\n\n old_device_info[\"container_name\"] = old_container_name\n new_device_info[\"container_name\"] = container_name\n\n container_encrypted = self._device_container_encrypted\n old_device_info[\"container_encrypted\"] = old_container_encrypted\n new_device_info[\"container_encrypted\"] = container_encrypted\n changed_container_encrypted = (container_encrypted != old_container_encrypted)\n\n container_raid_level = self._device_container_raid_level\n if container_raid_level not in containerRaidLevelsSupported(device_type):\n container_raid_level = defaultContainerRaidLevel(device_type)\n\n old_device_info[\"container_raid_level\"] = old_container_raid_level\n new_device_info[\"container_raid_level\"] = container_raid_level\n changed_container_raid_level = (old_container_raid_level != container_raid_level)\n\n container_size = self._device_container_size\n old_device_info[\"container_size\"] = old_container_size\n new_device_info[\"container_size\"] = container_size\n changed_container_size = (old_container_size != container_size)\n\n # DISK SET\n old_disks = device.disks\n if hasattr(device, \"req_disks\") and not device.exists:\n old_disks = device.req_disks\n\n disks = self._device_disks[:]\n if container and changed_device_type:\n log.debug(\"overriding disk set with container's\")\n disks = container.disks[:]\n changed_disk_set = (set(old_disks) != set(disks))\n old_device_info[\"disks\"] = old_disks\n new_device_info[\"disks\"] = disks\n log.debug(\"old disks: %s\", [d.name for d in old_disks])\n log.debug(\"new disks: %s\", [d.name for d in disks])\n\n log.debug(\"device: %s\", device)\n already_logged = {\"disks\", \"device\"}\n # log the other changes (old_device_info doesn't have the 'device' key)\n for key in (to_log for to_log in\n old_device_info.keys() if to_log not in already_logged):\n log.debug(\"old %s: %s\", key, old_device_info[key])\n log.debug(\"new %s: %s\", key, new_device_info[key])\n\n # XXX prevent multiple raid or encryption layers?\n\n changed = (changed_name or changed_size or changed_device_type or\n changed_label or changed_mountpoint or changed_disk_set or\n changed_encryption or changed_raid_level or\n changed_fs_type or\n changed_container or changed_container_encrypted or\n changed_container_raid_level or changed_container_size)\n\n # If something has changed but the device does not exist,\n # there is no need to schedule actions on the device.\n # It is only necessary to create a new device object\n # which reflects the current choices.\n if not use_dev.exists:\n if not changed:\n log.debug(\"nothing changed for new device\")\n return\n\n self.clear_errors()\n\n if changed_device_type or changed_container:\n # remove the current device\n self._destroy_device(device)\n if device in self._devices:\n # the removal failed. don't continue.\n log.error(\"device removal failed\")\n return\n removed_device = True\n else:\n removed_device = False\n\n with ui_storage_logger():\n succ = self._try_replace_device(selector, removed_device,\n new_device_info, old_device_info)\n if not succ:\n # failed, nothing more to be done\n return\n\n self._update_device_in_selectors(device, selector.device)\n self._devices = self._storage_playground.devices\n\n # update size properties and the right side\n self._update_size_props()\n self._populate_right_side(selector)\n\n log.debug(\"leaving save_right_side\")\n return\n\n ##\n ## Handle changes to preexisting devices\n ##\n\n # Handle deactivation of the reformat checkbutton after having committed\n # a reformat.\n if not reformat and (not use_dev.format.exists or\n not device.format.exists):\n self._revert_reformat(device)\n\n # Handle size change\n if changed_size:\n self._handle_size_change(size, old_size, device)\n\n # it's possible that reformat is active but fstype is unchanged, in\n # which case we're not going to schedule another reformat unless\n # encryption got toggled\n do_reformat = (reformat and (changed_encryption or\n changed_fs_type or\n device.format.exists))\n\n # Handle reformat\n if do_reformat:\n device = self._do_reformat(device, mountpoint, label, changed_encryption,\n encrypted, selector, fs_type)\n else:\n # Set various attributes that do not require actions.\n if old_label != label and hasattr(device.format, \"label\") and \\\n validate_label(label, device.format) == \"\":\n self.clear_errors()\n log.debug(\"updating label on %s to %s\", device.name, label)\n device.format.label = label\n\n if mountpoint and old_mountpoint != mountpoint:\n self.clear_errors()\n log.debug(\"updating mountpoint of %s to %s\", device.name, mountpoint)\n device.format.mountpoint = mountpoint\n if old_mountpoint:\n update_selector_from_device(selector, device)\n else:\n # add an entry to the new page but do not remove any entries\n # from other pages since we haven't altered the filesystem\n self.add_new_selector(device)\n\n #\n # NAME\n #\n if changed_name:\n self.clear_errors()\n try:\n use_dev.name = name\n except ValueError as e:\n self._error = e\n self.set_error(_(\"Invalid device name: %s\") % name)\n else:\n new_name = use_dev.name\n log.debug(\"changing name of %s to %s\", old_name, new_name)\n if new_name in self._storage_playground.names:\n use_dev.name = old_name\n self.set_info(_(\"Specified name %s already in use.\") % new_name)\n else:\n update_selector_from_device(selector, device)\n\n self._populate_right_side(selector)\n\n def _raid_level_visible(self, model, itr, user_data):\n device_type = self._get_current_device_type()\n raid_level = raid.getRaidLevel(model[itr][1])\n return raid_level in raidLevelsSupported(device_type)\n\n def _populate_raid(self, raid_level):\n \"\"\" Set up the raid-specific portion of the device details.\n\n :param raid_level: RAID level\n :type raid_level: instance of blivet.devicelibs.raid.RAIDLevel or None\n \"\"\"\n device_type = self._get_current_device_type()\n log.debug(\"populate_raid: %s, %s\", device_type, raid_level)\n\n if not raidLevelsSupported(device_type):\n for widget in [self._raidLevelLabel, self._raidLevelCombo]:\n really_hide(widget)\n return\n\n raid_level = raid_level or defaultRaidLevel(device_type)\n raid_level_name = raidLevelSelection(raid_level)\n\n # Set a default RAID level in the combo.\n for (i, row) in enumerate(self._raidLevelCombo.get_model()):\n if row[1] == raid_level_name:\n self._raidLevelCombo.set_active(i)\n break\n for widget in [self._raidLevelLabel, self._raidLevelCombo]:\n really_show(widget)\n\n def _get_current_device_type_name(self):\n \"\"\" Return name for type combo selection.\n\n :returns: the corresponding name extracted from the combo\n :rtype: str or NoneType\n \"\"\"\n itr = self._typeCombo.get_active_iter()\n if not itr:\n return None\n\n # we have the constant name in the second column of the store\n return self._typeStore[itr][1]\n\n def _get_current_device_type(self):\n \"\"\" Return integer for type combo selection.\n\n :returns: the corresponding integer code, a constant in\n blivet.devicefactory.\n :rtype: int or NoneType\n \"\"\"\n device_type_name = self._get_current_device_type_name()\n return dev_type_from_const(device_type_name) if device_type_name else None\n\n def _update_container_info(self, use_dev):\n if hasattr(use_dev, \"vg\"):\n self._device_container_name = use_dev.vg.name\n self._device_container_raid_level = get_raid_level(use_dev.vg)\n self._device_container_encrypted = use_dev.vg.encrypted\n self._device_container_size = use_dev.vg.size_policy\n elif hasattr(use_dev, \"volume\") or hasattr(use_dev, \"subvolumes\"):\n volume = getattr(use_dev, \"volume\", use_dev)\n self._device_container_name = volume.name\n self._device_container_raid_level = get_raid_level(volume)\n self._device_container_encrypted = volume.encrypted\n self._device_container_size = volume.size_policy\n else:\n self._device_container_name = None\n self._device_container_raid_level = None\n self._device_container_encrypted = False\n self._device_container_size = SIZE_POLICY_AUTO\n\n self._device_container_raid_level = self._device_container_raid_level \\\n or defaultContainerRaidLevel(devicefactory.get_device_type(use_dev))\n\n def _setup_fstype_combo(self, device):\n \"\"\" Setup the filesystem combo box.\n\n :param device: blivet.devices.Device instance\n \"\"\"\n type_name = device.format.name\n\n # Possibly unsupported but still required filesystem names\n if device.exists and \\\n device.format.type != device.originalFormat.type and \\\n device.originalFormat.type not in self._fs_types:\n extra_names = (type_name, device.originalFormat.name)\n else:\n extra_names = (type_name,)\n\n names = list(self._fs_types.union(extra_names))\n names.sort()\n\n # Add all desired fileystem type names to the box, sorted alphabetically\n self._fsStore.clear()\n for ty in names:\n self._fsStore.append([ty])\n\n # set the active filesystem type\n idx = next(i for i, data in enumerate(self._fsCombo.get_model()) if data[0] == type_name)\n self._fsCombo.set_active(idx)\n\n # do additional updating handled by other method\n self._update_fstype_combo(devicefactory.get_device_type(device))\n\n def _btrfs_in_typecombo(self, device):\n \"\"\" Whether BTRFS should appear in device type combo box.\n\n :param device: the device being displayed\n :type device: :class:`blivet.devices.StorageDevice`\n :rtype: bool\n :returns: True if BTRFS should appear, otherwise False\n \"\"\"\n device = device.raw_device\n\n # The device is btrfs, so btrfs must be shown.\n if device.format.type == \"btrfs\":\n return True\n\n # Return True if btrfs filesystem is both allowed and supported.\n fmt = getFormat(\"btrfs\")\n return fmt.supported and fmt.formattable and \\\n device.format.type not in PARTITION_ONLY_FORMAT_TYPES + (\"swap\",)\n\n def _setup_device_type_combo(self, device, device_name):\n \"\"\" Set up device type combo.\n\n :param device: the device\n :type device: :class:`blivet.devices.StorageDevice`\n :param str device_name: the device name\n\n :returns: the device type that was decided on\n :rtype: int (an enumeration defined in blivet.devicefactory)\n \"\"\"\n use_dev = device.raw_device\n\n # these device types should always be listed\n should_appear = {\"DEVICE_TYPE_PARTITION\", \"DEVICE_TYPE_LVM\", \"DEVICE_TYPE_LVM_THINP\"}\n\n # only include md if there are two or more disks\n if (use_dev.type == \"mdarray\" or len(self._clearpartDevices) > 1):\n should_appear.add(\"DEVICE_TYPE_MD\")\n\n if self._btrfs_in_typecombo(device):\n should_appear.add(\"DEVICE_TYPE_BTRFS\")\n\n # only include disk if the current device is a disk\n if use_dev.isDisk:\n should_appear.add(\"DEVICE_TYPE_DISK\")\n\n should_appear = set(dt for dt in should_appear if is_supported_device_type(dev_type_from_const(dt)))\n\n # go through the store and remove things that shouldn't be included\n # store.remove() updates or invalidates the passed iterator\n itr = self._typeStore.get_iter_first()\n valid = True\n while itr and valid:\n dev_type_const = self._typeStore[itr][1]\n if dev_type_const not in should_appear:\n valid = self._typeStore.remove(itr)\n elif dev_type_const in should_appear:\n # already seen, shouldn't be added to the list again\n should_appear.remove(dev_type_const)\n itr = self._typeStore.iter_next(itr)\n\n # add missing device types\n for dev_type_const in should_appear:\n self._add_device_type(dev_type_const)\n\n device_type = devicefactory.get_device_type(device)\n\n for _type in self._device_name_dict.keys():\n if _type == device_type:\n self._device_name_dict[_type] = device_name\n continue\n elif _type not in NAMED_DEVICE_TYPES:\n continue\n\n is_swap = device.format.type == \"swap\"\n mountpoint = getattr(device.format, \"mountpoint\", None)\n\n with ui_storage_logger():\n name = self._storage_playground.suggestDeviceName(swap=is_swap,\n mountpoint=mountpoint)\n\n self._device_name_dict[_type] = name\n\n itr = self._typeStore.get_iter_first()\n while itr:\n if dev_type_from_const(self._typeStore[itr][1]) == device_type:\n self._typeCombo.set_active_iter(itr)\n break\n itr = self._typeStore.iter_next(itr)\n else:\n msg = \"Didn't find device type %s in device type combobox\" % device_type\n raise KeyError(msg)\n\n return device_type\n\n def _set_devices_label(self):\n device_disks = self._device_disks\n if not device_disks:\n devices_desc = _(\"No disks assigned\")\n else:\n devices_desc = \"%s (%s)\" % (device_disks[0].description, device_disks[0].name)\n num_disks = len(device_disks)\n if num_disks > 1:\n devices_desc += CP_(\"GUI|Custom Partitioning|Devices\",\n \" and %d other\", \" and %d others\",\n num_disks - 1) % (num_disks - 1)\n self._deviceDescLabel.set_text(devices_desc)\n\n def _populate_right_side(self, selector):\n log.debug(\"populate_right_side: %s\", selector.device)\n\n device = selector.device\n use_dev = device.raw_device\n\n if hasattr(use_dev, \"req_disks\") and not use_dev.exists:\n self._device_disks = use_dev.req_disks[:]\n else:\n self._device_disks = device.disks[:]\n\n self._update_container_info(use_dev)\n\n log.debug(\"updated device_disks to %s\", [d.name for d in self._device_disks])\n log.debug(\"updated device_container_name to %s\", self._device_container_name)\n log.debug(\"updated device_container_raid_level to %s\", self._device_container_raid_level)\n log.debug(\"updated device_container_encrypted to %s\", self._device_container_encrypted)\n log.debug(\"updated device_container_size to %s\", self._device_container_size)\n\n self._selectedDeviceLabel.set_text(selector.props.name)\n desc = _(MOUNTPOINT_DESCRIPTIONS.get(selector.props.name, \"\"))\n self._selectedDeviceDescLabel.set_text(desc)\n\n self._set_devices_label()\n\n device_name = getattr(use_dev, \"lvname\", use_dev.name)\n self._nameEntry.set_text(device_name)\n\n self._mountPointEntry.set_text(getattr(device.format, \"mountpoint\", \"\") or \"\")\n fancy_set_sensitive(self._mountPointEntry, device.format.mountable)\n\n if hasattr(device.format, \"label\"):\n if device.format.label is None:\n device.format.label = \"\"\n self._labelEntry.set_text(device.format.label)\n else:\n self._labelEntry.set_text(\"\")\n fancy_set_sensitive(self._labelEntry, True)\n\n self._sizeEntry.set_text(device.size.humanReadable(max_places=self.MAX_SIZE_PLACES))\n\n self._reformatCheckbox.set_active(not device.format.exists)\n fancy_set_sensitive(self._reformatCheckbox,\n use_dev.exists and not use_dev.formatImmutable)\n\n self._encryptCheckbox.set_active(isinstance(device, LUKSDevice))\n self._encryptCheckbox.set_sensitive(self._reformatCheckbox.get_active())\n ancestors = use_dev.ancestors\n ancestors.remove(use_dev)\n if any(a.format.type == \"luks\" for a in ancestors):\n # The encryption checkbutton should not be sensitive if there is\n # existing encryption below the leaf layer.\n self._encryptCheckbox.set_sensitive(False)\n self._encryptCheckbox.set_active(True)\n self._encryptCheckbox.set_tooltip_text(_(\"The container is encrypted.\"))\n else:\n self._encryptCheckbox.set_tooltip_text(\"\")\n\n # Set up the filesystem type combo.\n self._setup_fstype_combo(device)\n\n # Set up the device type combo.\n device_type = self._setup_device_type_combo(device, device_name)\n\n fancy_set_sensitive(self._fsCombo, self._reformatCheckbox.get_active() and\n device_type != DEVICE_TYPE_BTRFS)\n\n # you can't change the type of an existing device\n fancy_set_sensitive(self._typeCombo, not use_dev.exists)\n fancy_set_sensitive(self._raidLevelCombo, not use_dev.exists)\n\n # FIXME: device encryption should be mutually exclusive with container\n # encryption\n\n # FIXME: device raid should be mutually exclusive with container raid\n\n # you can't encrypt a btrfs subvolume -- only the volume/container\n # XXX CHECKME: encryption of thin logical volumes is not supported at this time\n if device_type in [DEVICE_TYPE_BTRFS, DEVICE_TYPE_LVM_THINP]:\n fancy_set_sensitive(self._encryptCheckbox, False)\n\n # The size entry is only sensitive for resizable existing devices and\n # new devices that are not btrfs subvolumes.\n # Do this after the device type combo is set since\n # on_device_type_changed doesn't account for device existence.\n fancy_set_sensitive(self._sizeEntry, device.resizable or (not device.exists and device.format.type != \"btrfs\"))\n\n if self._sizeEntry.get_sensitive():\n self._sizeEntry.props.has_tooltip = False\n elif device.format.type == \"btrfs\":\n self._sizeEntry.set_tooltip_text(_(\"The space available to this mount point can be changed by modifying the volume below.\"))\n else:\n self._sizeEntry.set_tooltip_text(_(\"This file system may not be resized.\"))\n\n self._populate_raid(get_raid_level(device))\n self._populate_container(device=use_dev)\n # do this last in case this was set sensitive in on_device_type_changed\n if use_dev.exists or use_dev.type == \"btrfs volume\":\n fancy_set_sensitive(self._nameEntry, False)\n\n ###\n ### SIGNAL HANDLERS\n ###\n\n def on_key_pressed(self, widget, event, *args):\n if not event or event and event.type != Gdk.EventType.KEY_RELEASE:\n return\n\n if event.keyval in [Gdk.KEY_Delete, Gdk.KEY_minus]:\n # But we only want delete to work if you have focused a MountpointSelector,\n # and not just any random widget. For those, it's likely the user wants\n # to delete a character.\n if isinstance(self.main_window.get_focus(), MountpointSelector):\n self._removeButton.emit(\"clicked\")\n elif event.keyval == Gdk.KEY_plus:\n # And we only want '+' to work if you don't have a text entry focused, since\n # the user might be entering some free-form text that can include a plus.\n if not isinstance(self.main_window.get_focus(), Gtk.Entry):\n self._addButton.emit(\"clicked\")\n\n def _do_check(self):\n self.clear_errors()\n StorageChecker.errors = []\n StorageChecker.warnings = []\n\n # We can't overwrite the main Storage instance because all the other\n # spokes have references to it that would get invalidated, but we can\n # achieve the same effect by updating/replacing a few key attributes.\n self.storage.devicetree._devices = self._storage_playground.devicetree._devices\n self.storage.devicetree._actions = self._storage_playground.devicetree._actions\n self.storage.devicetree._hidden = self._storage_playground.devicetree._hidden\n self.storage.devicetree.dasd = self._storage_playground.devicetree.dasd\n self.storage.devicetree.names = self._storage_playground.devicetree.names\n self.storage.roots = self._storage_playground.roots\n\n # set up bootloader and check the configuration\n try:\n self.storage.setUpBootLoader()\n except BootLoaderError as e:\n log.error(\"storage configuration failed: %s\", e)\n StorageChecker.errors = str(e).split(\"\\n\")\n self.data.bootloader.bootDrive = \"\"\n\n StorageChecker.checkStorage(self)\n\n if self.errors:\n self.set_warning(_(\"Error checking storage configuration. <a href=\\\"\\\">Click for details</a> or press Done again to continue.\"))\n elif self.warnings:\n self.set_warning(_(\"Warning checking storage configuration. <a href=\\\"\\\">Click for details</a> or press Done again to continue.\"))\n\n # on_info_bar_clicked requires self._error to be set, so set it to the\n # list of all errors and warnings that storage checking found.\n self._error = \"\\n\".join(self.errors + self.warnings)\n\n return self._error == \"\"\n\n def on_back_clicked(self, button):\n # Clear any existing errors\n self.clear_errors()\n\n # Save anything from the currently displayed mountpoint.\n self._save_right_side(self._accordion.current_selector)\n self._applyButton.set_sensitive(False)\n\n # And then display the summary screen. From there, the user will either\n # head back to the hub, or stay on the custom screen.\n self._storage_playground.devicetree.pruneActions()\n self._storage_playground.devicetree.sortActions()\n\n\n # If back has been clicked on once already and no other changes made on the screen,\n # run the storage check now. This handles displaying any errors in the info bar.\n if not self._back_already_clicked:\n self._back_already_clicked = True\n\n # If we hit any errors while saving things above, stop and let the\n # user think about what they have done\n if self._error is not None:\n return\n\n new_luks = [d for d in self._storage_playground.devices\n if d.format.type == \"luks\" and not d.format.exists]\n if new_luks:\n dialog = PassphraseDialog(self.data)\n with self.main_window.enlightbox(dialog.window):\n rc = dialog.run()\n\n if rc != 1:\n # Cancel. Leave the old passphrase set if there was one.\n return\n\n self.passphrase = dialog.passphrase\n\n for luks in new_luks:\n if not luks.format.hasKey:\n luks.format.passphrase = self.passphrase\n\n if not self._do_check():\n return\n\n if len(self._storage_playground.devicetree.findActions()) > 0:\n dialog = ActionSummaryDialog(self.data)\n dialog.refresh(self._storage_playground.devicetree.findActions())\n with self.main_window.enlightbox(dialog.window):\n rc = dialog.run()\n\n if rc != 1:\n # Cancel. Stay on the custom screen.\n return\n\n NormalSpoke.on_back_clicked(self, button)\n\n @ui_storage_logged\n def _add_device(self, dev_info):\n factory = devicefactory.get_device_factory(self._storage_playground,\n dev_info[\"device_type\"], dev_info[\"size\"],\n min_luks_entropy=crypto.MIN_CREATE_ENTROPY)\n container = factory.get_container()\n if container:\n # don't override user-initiated changes to a defined container\n dev_info[\"disks\"] = container.disks\n dev_info.update({\"container_encrypted\": container.encrypted,\n \"container_raid_level\": get_raid_level(container),\n \"container_size\": getattr(container, \"size_policy\",\n container.size)})\n\n # The container is already encrypted\n if container.encrypted:\n dev_info[\"encrypted\"] = False\n\n device_type = dev_info.pop(\"device_type\")\n try:\n self._storage_playground.factoryDevice(device_type,\n **dev_info)\n except StorageError as e:\n log.error(\"factoryDevice failed: %s\", e)\n log.debug(\"trying to find an existing container to use\")\n container = factory.get_container(allow_existing=True)\n log.debug(\"found container %s\", container)\n if container:\n # don't override user-initiated changes to a defined container\n dev_info[\"disks\"] = container.disks\n dev_info.update({\"container_encrypted\": container.encrypted,\n \"container_raid_level\": get_raid_level(container),\n \"container_size\": getattr(container, \"size_policy\",\n container.size),\n \"container_name\": container.name})\n try:\n self._storage_playground.factoryDevice(device_type,\n **dev_info)\n except StorageError as e2:\n log.error(\"factoryDevice failed w/ old container: %s\", e2)\n else:\n type_str = _(DEVICE_TEXT_MAP[device_type])\n self.set_info(_(\"Added new %(type)s to existing \"\n \"container %(name)s.\")\n % {\"type\" : type_str, \"name\" : container.name})\n e = None\n\n # the factory's error handling has replaced all of the devices\n # with copies, so update the selectors' devices accordingly\n self._update_all_devices_in_selectors()\n\n if e:\n self._error = e\n self.set_error(_(\"Failed to add new device. <a href=\\\"\\\">Click for \"\n \"details.</a>\"))\n except OverflowError as e:\n log.error(\"invalid size set for partition\")\n self._error = e\n self.set_error(_(\"Invalid partition size set. Use a valid integer.\"))\n\n def on_add_clicked(self, button):\n self._save_right_side(self._accordion.current_selector)\n\n ## initialize and run the AddDialog\n dialog = AddDialog(self.data,\n mountpoints=self._storage_playground.mountpoints.keys())\n dialog.refresh()\n with self.main_window.enlightbox(dialog.window):\n rc = dialog.run()\n\n if rc != 1:\n # user cancel\n dialog.window.destroy()\n return\n\n self._back_already_clicked = False\n\n ## gather data about the added mountpoint\n # minimum entropy required for LUKS creation is always the same\n # TODO: use instance of a class with properly named attributes\n dev_info = {\"min_luks_entropy\": crypto.MIN_CREATE_ENTROPY}\n\n # create a device of the default type, using any disks, with an\n # appropriate fstype and mountpoint\n dev_info[\"mountpoint\"] = dialog.mountpoint\n log.debug(\"requested size = %s ; available space = %s\", dialog.size, self._free_space)\n\n # if no requested size, or size less than 1 MB, request maximum size\n if dialog.size is None or dialog.size < Size(\"1 MB\"):\n dev_info[\"size\"] = None\n else:\n dev_info[\"size\"] = dialog.size\n\n dev_info[\"fstype\"] = self.storage.getFSType(dev_info[\"mountpoint\"])\n\n # The encryption setting as applied here means \"encrypt leaf devices\".\n # If you want \"encrypt my VG/PVs\" you'll have to either use the autopart\n # button or wait until we have a way to control container-level\n # encryption.\n dev_info[\"encrypted\"] = self.data.autopart.encrypted\n\n # we're doing nothing here to ensure that bootable requests end up on\n # the boot disk, but the weight from platform should take care of this\n\n if lowerASCII(dev_info[\"mountpoint\"]) in (\"swap\", \"biosboot\", \"prepboot\"):\n dev_info[\"mountpoint\"] = None\n\n dev_info[\"device_type\"] = device_type_from_autopart(self.data.autopart.type)\n if (dev_info[\"device_type\"] != DEVICE_TYPE_PARTITION and\n ((dev_info[\"mountpoint\"] and dev_info[\"mountpoint\"].startswith(\"/boot\")) or\n dev_info[\"fstype\"] in PARTITION_ONLY_FORMAT_TYPES)):\n dev_info[\"device_type\"] = DEVICE_TYPE_PARTITION\n\n # we shouldn't create swap on a thinly provisioned volume\n if dev_info[\"fstype\"] == \"swap\" and dev_info[\"device_type\"] == DEVICE_TYPE_LVM_THINP:\n dev_info[\"device_type\"] = DEVICE_TYPE_LVM\n\n # encryption of thinly provisioned volumes isn't supported\n if dev_info[\"encrypted\"] and dev_info[\"device_type\"] == DEVICE_TYPE_LVM_THINP:\n dev_info[\"encrypted\"] = False\n\n # some devices should never be encrypted\n if ((dev_info[\"mountpoint\"] and dev_info[\"mountpoint\"].startswith(\"/boot\")) or\n dev_info[\"fstype\"] in PARTITION_ONLY_FORMAT_TYPES):\n dev_info[\"encrypted\"] = False\n\n dev_info[\"disks\"] = self._clearpartDevices\n\n ## clear errors and try to add the mountpoint/device\n self.clear_errors()\n self._add_device(dev_info)\n\n ## refresh internal state and UI elements\n self._devices = self._storage_playground.devices\n if not self._error:\n self._do_refresh(mountpointToShow=dev_info[\"mountpoint\"] or dev_info[\"fstype\"])\n else:\n self._do_refresh()\n self._updateSpaceDisplay()\n\n @ui_storage_logged\n def _remove_empty_parents(self, device):\n # if this device has parents with no other children, remove them too\n for parent in device.parents:\n if parent.kids == 0 and not parent.isDisk:\n self._destroy_device(parent)\n\n @ui_storage_logged\n def _destroy_device(self, device):\n self.clear_errors()\n is_logical_partition = getattr(device, \"isLogical\", False)\n try:\n if device.isDisk:\n self._storage_playground.initializeDisk(device)\n elif device.direct and not device.isleaf:\n # we shouldn't call this method for with non-leaf devices except\n # for those which are also directly accessible like lvm\n # snapshot origins and btrfs subvolumes that contain other\n # subvolumes\n self._storage_playground.recursiveRemove(device)\n else:\n self._storage_playground.destroyDevice(device)\n except StorageError as e:\n log.error(\"failed to schedule device removal: %s\", e)\n self._error = e\n self.set_warning(_(\"Device removal request failed. <a href=\\\"\\\">Click \"\n \"for details.</a>\"))\n else:\n if is_logical_partition:\n self._storage_playground.removeEmptyExtendedPartitions()\n\n # If we've just removed the last partition and the disklabel is pre-\n # existing, reinitialize the disk.\n if device.type == \"partition\" and device.exists and \\\n device.disk.format.exists:\n if self._storage_playground.shouldClear(device.disk):\n self._storage_playground.initializeDisk(device.disk)\n\n self._devices = self._storage_playground.devices\n\n # should this be in DeviceTree._removeDevice?\n container = None\n if hasattr(device, \"vg\"):\n container = device.vg\n device_type = devicefactory.get_device_type(device)\n elif hasattr(device, \"volume\"):\n container = device.volume\n device_type = DEVICE_TYPE_BTRFS\n\n if not container:\n # no container, just remove empty parents of the device\n self._remove_empty_parents(device)\n return\n\n # adjust container to size of remaining devices, if auto-sized\n if container and not container.exists and \\\n self._storage_playground.devicetree.getChildren(container) and \\\n container.size_policy == SIZE_POLICY_AUTO:\n cont_encrypted = container.encrypted\n cont_raid = get_raid_level(container)\n cont_size = container.size_policy\n cont_name = container.name\n factory = devicefactory.get_device_factory(self._storage_playground,\n device_type, Size(0),\n disks=container.disks,\n container_name=cont_name,\n container_encrypted=cont_encrypted,\n container_raid_level=cont_raid,\n container_size=cont_size,\n min_luks_entropy=crypto.MIN_CREATE_ENTROPY)\n factory.configure()\n\n self._remove_empty_parents(device)\n\n def _show_mountpoint(self, page, mountpoint=None):\n if not self._initialized:\n return\n\n # Make sure there's something displayed on the RHS. If a page and\n # mountpoint within that page is given, display that.\n log.debug(\"show mountpoint: %s\", page.pageTitle)\n if not page.members:\n self._accordion.clear_current_selector()\n return\n\n if not mountpoint and len(self._accordion.selected_items) == 0 \\\n and not page.get_parent().get_expanded():\n self._accordion.select(page.members[0])\n self.on_selector_clicked(None, page.members[0])\n return\n\n\n if mountpoint:\n for member in page.members:\n if member.get_property(\"mountpoint\").lower() == mountpoint.lower():\n self._accordion.select(member)\n self.on_selector_clicked(None, member)\n break\n\n def _show_confirmation_dialog(self, root_name, device, protected_types):\n dialog = ConfirmDeleteDialog(self.data)\n bootpart = device.format.type in protected_types\n snapshots = (device.direct and not device.isleaf)\n checkbox_text = None\n if not self._accordion.is_multiselection:\n if root_name and \"_\" in root_name:\n root_name = root_name.replace(\"_\", \"__\")\n checkbox_text = (C_(\"GUI|Custom Partitioning|Confirm Delete Dialog\",\n \"Delete _all file systems which are only used by %s.\")\n % root_name)\n else:\n checkbox_text = C_(\"GUI|Custom Partitioning|Confirm Delete Dialog\",\n \"Do _not show this dialog for other selected file systems.\")\n dialog.refresh(getattr(device.format, \"mountpoint\", \"\"),\n device.name, checkbox_text=checkbox_text,\n snapshots=snapshots, bootpart=bootpart)\n with self.main_window.enlightbox(dialog.window):\n rc = dialog.run()\n option_checked = dialog.option_checked\n dialog.window.destroy()\n return (rc, option_checked)\n\n def on_remove_clicked(self, button):\n # Nothing selected? Nothing to remove.\n if not self._accordion.is_current_selected and not self._accordion.is_multiselection:\n return\n\n option_checked = False\n part_removed = False\n is_multiselection = self._accordion.is_multiselection\n protected_types = platform.bootStage1ConstraintDict[\"format_types\"]\n for selector in self._accordion.selected_items:\n page = self._accordion.page_for_selector(selector)\n device = selector.device\n root_name = None\n if selector.root:\n root_name = selector.root.name\n elif page:\n root_name = page.pageTitle\n\n log.debug(\"removing device '%s' from page %s\", device, root_name)\n\n if root_name == translated_new_install_name():\n if is_multiselection and not option_checked:\n (rc, option_checked) = self._show_confirmation_dialog(root_name, device, protected_types)\n\n if rc != 1:\n if option_checked:\n break # skip evaluation of all other mountpoints\n continue\n\n if device.exists:\n # This is an existing device that was added to the new page.\n # All we want to do is revert any changes to the device and\n # it will end up back in whatever old pages it came from.\n with ui_storage_logger():\n self._storage_playground.resetDevice(device)\n\n log.debug(\"updated device: %s\", device)\n else:\n # Destroying a non-existing device doesn't require any\n # confirmation.\n self._destroy_device(device)\n else:\n # This is a device that exists on disk and most likely has data\n # on it. Thus, we first need to confirm with the user and then\n # schedule actions to delete the thing.\n # In multiselection user could confirm once for all next\n # selections.\n if not option_checked:\n (rc, option_checked) = self._show_confirmation_dialog(root_name, device, protected_types)\n\n if rc != 1:\n if option_checked:\n break # skip evaluation of all other mountpoints\n continue\n\n if option_checked and not is_multiselection:\n otherpgs = (pg for pg in self._accordion.all_pages\n if pg is not page)\n otherdevs = []\n for otherpg in otherpgs:\n otherdevs.extend(mem._device.id for mem in otherpg.members)\n # We never want to delete known-shared devs here.\n # The same rule applies for selected device. If it's shared do not\n # remove it in other pages when Delete all option is checked.\n for dev in (s._device for s in page.members\n if s._device.id not in otherdevs):\n # we only want to delete boot partitions if they're not\n # shared *and* we have no unknown partitions\n if (not self.unusedDevices or dev.format.type not in protected_types):\n log.debug(\"deleteall: removed %s\", dev.name)\n self._destroy_device(dev)\n else:\n log.debug(\"deleteall: didn't remove %s\", dev.name)\n else:\n self._destroy_device(device)\n\n part_removed = True\n log.info(\"ui: removed device %s\", device.name)\n\n # Now that devices have been removed from the installation root,\n # refreshing the display will have the effect of making them disappear.\n # It's like they never existed.\n if part_removed:\n self._storage_playground.roots = findExistingInstallations(self._storage_playground.devicetree)\n self._updateSpaceDisplay()\n self._do_refresh()\n\n def on_summary_clicked(self, button):\n dialog = SelectedDisksDialog(self.data)\n dialog.refresh(self._clearpartDevices, self._currentFreeInfo,\n showRemove=False, setBoot=False)\n with self.main_window.enlightbox(dialog.window):\n dialog.run()\n\n def on_configure_clicked(self, button):\n selector = self._accordion.current_selector\n if not selector:\n return\n\n device = selector.device\n if device.exists:\n return\n\n if self._get_current_device_type() in CONTAINER_DEVICE_TYPES:\n # disk set management happens through container edit on RHS\n return\n\n self.clear_errors()\n\n dialog = DisksDialog(self.data,\n disks=self._clearpartDevices,\n free=self._currentFreeInfo,\n selected=self._device_disks)\n with self.main_window.enlightbox(dialog.window):\n rc = dialog.run()\n\n if rc != 1:\n return\n\n disks = dialog.selected\n log.debug(\"new disks for %s: %s\", device.name, [d.name for d in disks])\n if not disks:\n self._error = \"No disks selected. Keeping previous disk set.\"\n self.set_info(self._error)\n return\n\n if set(disks) != self._device_disks:\n self._applyButton.set_sensitive(True)\n\n self._device_disks = disks\n self._set_devices_label()\n self._populate_raid(selectedRaidLevel(self._raidLevelCombo))\n\n def _container_encryption_change(self, old_encrypted, new_encrypted):\n if not old_encrypted and new_encrypted:\n # container set to be encrypted, we should make sure the leaf device\n # is not encrypted and make the encryption checkbox insensitive\n self._encryptCheckbox.set_active(False)\n fancy_set_sensitive(self._encryptCheckbox, False)\n elif old_encrypted and not new_encrypted:\n fancy_set_sensitive(self._encryptCheckbox, True)\n\n def run_container_editor(self, container=None, name=None):\n \"\"\" Run container edit dialog and return True if changes were made. \"\"\"\n size = Size(0)\n size_policy = self._device_container_size\n if container:\n container_name = container.name\n size = container.size\n size_policy = container.size_policy\n elif name:\n container_name = name\n if name != self._device_container_name:\n # creating a new container -- switch to the default\n size_policy = SIZE_POLICY_AUTO\n\n dialog = ContainerDialog(self.data,\n device_type=self._get_current_device_type(),\n name=container_name,\n raid_level=self._device_container_raid_level,\n encrypted=self._device_container_encrypted,\n size_policy=size_policy,\n size=size,\n disks=self._clearpartDevices,\n free=self._currentFreeInfo,\n selected=self._device_disks,\n storage=self._storage_playground,\n exists=getattr(container, \"exists\", False))\n\n with self.main_window.enlightbox(dialog.window):\n rc = dialog.run()\n dialog.window.destroy()\n\n if rc != 1:\n return\n\n disks = dialog.selected\n name = dialog.name\n log.debug(\"new disks for %s: %s\", name, [d.name for d in disks])\n if not disks:\n self._error = \"No disks selected. Not saving changes.\"\n self.set_info(self._error)\n return\n\n log.debug(\"new container name: %s\", name)\n if name != container_name and name in self._storage_playground.names:\n self._error = _(\"Volume Group name %s is already in use. Not \"\n \"saving changes.\") % name\n self.set_info(self._error)\n return\n\n if (set(disks) != set(self._device_disks) or\n name != container_name or\n dialog.raid_level != self._device_container_raid_level or\n dialog.encrypted != self._device_container_encrypted or\n dialog.size_policy != self._device_container_size):\n self._applyButton.set_sensitive(True)\n\n log.debug(\"new container raid level: %s\", dialog.raid_level)\n log.debug(\"new container encrypted: %s\", dialog.encrypted)\n log.debug(\"new container size: %s\", dialog.size_policy)\n\n if dialog.encrypted:\n self._container_encryption_change(self._device_container_encrypted,\n dialog.encrypted)\n self._device_disks = disks\n self._device_container_name = name\n self._device_container_raid_level = dialog.raid_level\n self._device_container_encrypted = dialog.encrypted\n self._device_container_size = dialog.size_policy\n self._set_devices_label()\n\n return True\n\n def _container_store_row(self, name, freeSpace=None):\n if freeSpace is not None:\n return [name, _(\"(%s free)\") % freeSpace]\n else:\n return [name, \"\"]\n\n def on_modify_container_clicked(self, button):\n container_name = self._containerStore[self._containerCombo.get_active()][0]\n container = self._storage_playground.devicetree.getDeviceByName(container_name)\n\n # pass the name along with any found vg since we could be modifying a\n # vg that hasn't been instantiated yet\n if not self.run_container_editor(container=container, name=container_name):\n return\n\n log.debug(\"%s -> %s\", container_name, self._device_container_name)\n if container_name == self._device_container_name:\n self.on_update_settings_clicked(None)\n return\n\n log.debug(\"renaming container %s to %s\", container_name, self._device_container_name)\n if container:\n # remove the names of the container and its child devices from the\n # list of already-used names\n for device in chain([container], self._storage_playground.devicetree.getChildren(container)):\n if device.name in self._storage_playground.devicetree.names:\n self._storage_playground.devicetree.names.remove(device.name)\n luks_name = \"luks-%s\" % device.name\n if luks_name in self._storage_playground.devicetree.names:\n self._storage_playground.devicetree.names.remove(luks_name)\n\n try:\n container.name = self._device_container_name\n except ValueError as e:\n self._error = e\n self.set_error(_(\"Invalid device name: %s\") % self._device_container_name)\n self._device_container_name = container_name\n self.on_update_settings_clicked(None)\n return\n else:\n if container.format.type == \"btrfs\":\n container.format.label = self._device_container_name\n finally:\n # add the new names to the list of the already-used names and\n # prevent potential issues with making the devices encrypted\n # later\n for device in chain([container], self._storage_playground.devicetree.getChildren(container)):\n self._storage_playground.devicetree.names.append(device.name)\n luks_name = \"luks-%s\" % device.name\n self._storage_playground.devicetree.names.append(luks_name)\n\n container_exists = getattr(container, \"exists\", False)\n\n # TODO: implement and use function for finding item in combobox\n for idx, data in enumerate(self._containerStore):\n # we're looking for the original vg name\n if data[0] == container_name:\n break\n else:\n # no match found, just update selectors and return\n self._update_selectors()\n self.on_update_settings_clicked(None)\n return\n\n c = self._storage_playground.devicetree.getDeviceByName(self._device_container_name)\n freeSpace = getattr(c, \"freeSpace\", None)\n\n # else branch of for loop above ensures idx is defined\n # pylint: disable=undefined-loop-variable\n self._containerStore.insert(idx, self._container_store_row(self._device_container_name, freeSpace))\n self._containerCombo.set_active(idx)\n self._modifyContainerButton.set_sensitive(not container_exists)\n self._containerStore.remove(self._containerStore.get_iter_from_string(\"%s\" % (idx + 1)))\n\n self._update_selectors()\n self.on_update_settings_clicked(None)\n\n def on_container_changed(self, combo):\n ndx = combo.get_active()\n if ndx == -1:\n return\n\n container_name = self._containerStore[ndx][0]\n\n log.debug(\"new container selection: %s\", container_name)\n if container_name is None:\n return\n\n if self._device_container_name == container_name:\n return\n\n device_type = self._get_current_device_type()\n container_type_name = _(get_container_type(device_type).name).lower()\n new_text = _(NEW_CONTAINER_TEXT) % {\"container_type\": container_type_name}\n create_new_container = container_name == new_text\n user_changed_container = True\n if create_new_container:\n # run the vg editor dialog with a default name and disk set\n hostname = self.data.network.hostname\n name = self._storage_playground.suggestContainerName(hostname=hostname)\n # user_changed_container flips to False if \"cancel\" picked\n user_changed_container = self.run_container_editor(name=name)\n for idx, data in enumerate(self._containerStore):\n if user_changed_container and data[0] == new_text:\n c = self._storage_playground.devicetree.getDeviceByName(self._device_container_name)\n freeSpace = getattr(c, \"freeSpace\", None)\n row = self._container_store_row(self._device_container_name, freeSpace)\n\n self._containerStore.insert(idx, row)\n combo.set_active(idx) # triggers a call to this method\n return\n elif not user_changed_container and data[0] == self._device_container_name:\n combo.set_active(idx)\n return\n # else clause runs if an already existing container is picked\n else:\n self._device_container_name = container_name\n\n if user_changed_container:\n self._applyButton.set_sensitive(True)\n\n container = self._storage_playground.devicetree.getDeviceByName(self._device_container_name)\n container_exists = getattr(container, \"exists\", False) # might not be in the tree\n\n if container:\n self._device_container_raid_level = get_raid_level(container)\n self._device_container_encrypted = container.encrypted\n self._device_container_size = getattr(container, \"size_policy\",\n container.size)\n else:\n self._device_container_raid_level = None\n self._device_container_encrypted = self.data.autopart.encrypted\n self._device_container_size = SIZE_POLICY_AUTO\n\n self._modifyContainerButton.set_sensitive(not container_exists)\n\n def _save_current_page(self, selector = None):\n if selector is None:\n selector = self._accordion.current_selector\n log.debug(\"Saving current selector: %s\", selector.device)\n self._save_right_side(selector)\n\n def on_selector_clicked(self, old_selector, selector):\n if not self._initialized \\\n or ((old_selector or self._accordion.current_selector) # one of them must be set\n and (old_selector is self._accordion.current_selector)): # and they need to differ\n return\n\n # Take care of the previously chosen selector.\n if old_selector:\n self._save_current_page(old_selector)\n\n curr_selector = self._accordion.current_selector\n no_edit = False\n currentPageType = None\n if self._accordion.is_multiselection or not curr_selector:\n currentPageType = NOTEBOOK_LABEL_PAGE\n self._set_page_label_text()\n no_edit = True\n elif curr_selector.device.format.type == \"luks\" and \\\n curr_selector.device.format.exists:\n currentPageType = NOTEBOOK_LUKS_PAGE\n selectedDeviceLabel = self._encryptedDeviceLabel\n selectedDeviceDescLabel = self._encryptedDeviceDescLabel\n no_edit = True\n elif not getattr(curr_selector.device, \"complete\", True):\n currentPageType = NOTEBOOK_INCOMPLETE_PAGE\n selectedDeviceLabel = self._incompleteDeviceLabel\n selectedDeviceDescLabel = self._incompleteDeviceDescLabel\n\n if isinstance(curr_selector.device, MDRaidArrayDevice):\n total = curr_selector.device.memberDevices\n missing = total - len(curr_selector.device.parents)\n txt = _(\"This Software RAID array is missing %(missingMembers)d of %(totalMembers)d member \"\n \"partitions. You can remove it or select a different \"\n \"device.\") % {\"missingMembers\": missing, \"totalMembers\": total}\n elif isinstance(curr_selector.device, LVMVolumeGroupDevice):\n total = curr_selector.device.pvCount\n missing = total - len(curr_selector.device.parents)\n txt = _(\"This LVM Volume Group is missing %(missingPVs)d of %(totalPVs)d physical \"\n \"volumes. You can remove it or select a different \"\n \"device.\") % {\"missingPVs\": missing, \"totalPVs\": total}\n else:\n txt = _(\"This %(type)s device is missing member devices. You can remove it or\"\n \" select a different device.\") % curr_selector.device.type\n\n self._incompleteDeviceOptionsLabel.set_text(txt)\n no_edit = True\n elif devicefactory.get_device_type(curr_selector.device) is None:\n currentPageType = NOTEBOOK_UNEDITABLE_PAGE\n selectedDeviceLabel = self._uneditableDeviceLabel\n selectedDeviceDescLabel = self._uneditableDeviceDescLabel\n no_edit = True\n\n if no_edit:\n self._partitionsNotebook.set_current_page(currentPageType)\n if currentPageType != NOTEBOOK_LABEL_PAGE:\n selectedDeviceLabel.set_text(curr_selector.device.name)\n desc = _(MOUNTPOINT_DESCRIPTIONS.get(curr_selector.device.type, \"\"))\n selectedDeviceDescLabel.set_text(desc)\n\n self._configButton.set_sensitive(False)\n self._removeButton.set_sensitive(True)\n return\n\n # Make sure we're showing details instead of the \"here's how you create\n # a new OS\" label.\n self._partitionsNotebook.set_current_page(NOTEBOOK_DETAILS_PAGE)\n\n # Set up the newly chosen selector.\n self._populate_right_side(curr_selector)\n\n self._applyButton.set_sensitive(False)\n container_device = devicefactory.get_device_type(curr_selector.device) in CONTAINER_DEVICE_TYPES\n self._configButton.set_sensitive(not curr_selector.device.exists and\n not curr_selector.device.protected and\n not container_device)\n self._removeButton.set_sensitive(not curr_selector.device.protected)\n\n def on_page_clicked(self, page, mountpointToShow=None):\n if not self._initialized:\n return\n\n log.debug(\"page clicked: %s\", page.pageTitle)\n if self._accordion.is_current_selected:\n self._save_current_page()\n\n self._show_mountpoint(page=page, mountpoint=mountpointToShow)\n\n # This is called when a Page header is clicked upon so we can support\n # deleting an entire installation at once and displaying something\n # on the RHS.\n if isinstance(page, CreateNewPage):\n # Make sure we're showing \"here's how you create a new OS\" or\n # multiselection label instead of device/mountpoint details.\n self._partitionsNotebook.set_current_page(NOTEBOOK_LABEL_PAGE)\n self._set_page_label_text()\n self._removeButton.set_sensitive(False)\n else:\n self._removeButton.set_sensitive(True)\n\n @ui_storage_logged\n def _do_autopart(self):\n \"\"\"Helper function for on_create_clicked.\n Assumes a non-final context in which at least some errors\n discovered by sanity_check are not considered fatal because they\n will be dealt with later.\n\n Note: There are never any non-existent devices around when this runs.\n \"\"\"\n log.debug(\"running automatic partitioning\")\n self._storage_playground.doAutoPart = True\n self.clear_errors()\n try:\n self._storage_playground.createFreeSpaceSnapshot()\n # doAutoPartitions needs stage1_disk setup so it will reuse existing partitions\n self._storage_playground.setUpBootLoader(early=True)\n\n refreshAutoSwapSize(self._storage_playground)\n doAutoPartition(self._storage_playground, self.data,\n min_luks_entropy=crypto.MIN_CREATE_ENTROPY)\n except NoDisksError as e:\n # No handling should be required for this.\n log.error(\"doAutoPartition failed: %s\", e)\n self._error = e\n self.set_error(_(\"No disks selected.\"))\n except NotEnoughFreeSpaceError as e:\n # No handling should be required for this.\n log.error(\"doAutoPartition failed: %s\", e)\n self._error = e\n self.set_error(_(\"Not enough free space on selected disks.\"))\n except (StorageError, BootLoaderError) as e:\n log.error(\"doAutoPartition failed: %s\", e)\n self._reset_storage()\n self._error = e\n self.set_error(_(\"Automatic partitioning failed. <a href=\\\"\\\">Click \"\n \"for details.</a>\"))\n else:\n self._devices = self._storage_playground.devices\n # mark all new containers for automatic size management\n for device in self._devices:\n if not device.exists and hasattr(device, \"size_policy\"):\n device.size_policy = SIZE_POLICY_AUTO\n finally:\n self._storage_playground.doAutoPart = False\n log.debug(\"finished automatic partitioning\")\n\n exns = storage_utils.sanity_check(self._storage_playground, min_ram=isys.MIN_GUI_RAM)\n errors = [exn for exn in exns if isinstance(exn, SanityError) and not isinstance(exn, LUKSDeviceWithoutKeyError)]\n warnings = [exn for exn in exns if isinstance(exn, SanityWarning)]\n for error in errors:\n log.error(\"%s\", error)\n for warning in warnings:\n log.warning(\"%s\", warning)\n\n if errors:\n messages = \"\\n\".join(str(error) for error in errors)\n log.error(\"doAutoPartition failed: %s\", messages)\n self._reset_storage()\n self._error = messages\n self.set_error(_(\"Automatic partitioning failed. <a href=\\\"\\\">Click \"\n \"for details.</a>\"))\n\n def on_create_clicked(self, button, autopartTypeCombo):\n # Then do autopartitioning. We do not do any clearpart first. This is\n # custom partitioning, so you have to make your own room.\n self._storage_playground.autoPartType = self._get_autopart_type(autopartTypeCombo)\n self._do_autopart()\n\n # Refresh the spoke to make the new partitions appear.\n log.debug(\"refreshing ui\")\n self._do_refresh()\n log.debug(\"finished refreshing ui\")\n log.debug(\"updating space display\")\n self._updateSpaceDisplay()\n log.debug(\"finished updating space display\")\n\n def on_reformat_toggled(self, widget):\n active = widget.get_active()\n\n encrypt_sensitive = active\n if self._accordion.current_selector:\n device = self._accordion.current_selector.device.raw_device\n\n ancestors = device.ancestors\n ancestors.remove(device)\n if any(a.format.type == \"luks\" and a.format.exists for a in ancestors):\n # The encryption checkbutton should not be sensitive if there is\n # existing encryption below the leaf layer.\n encrypt_sensitive = False\n\n # you can't encrypt a btrfs subvolume -- only the volume/container\n device_type = self._get_current_device_type()\n if device_type == DEVICE_TYPE_BTRFS:\n self._encryptCheckbox.set_active(False)\n\n self._encryptCheckbox.set_sensitive(encrypt_sensitive and device_type != DEVICE_TYPE_BTRFS)\n fancy_set_sensitive(self._fsCombo, active)\n\n def on_fs_type_changed(self, combo):\n if not self._initialized:\n return\n\n itr = combo.get_active_iter()\n if not itr:\n return\n\n new_type = self._get_fstype(combo)\n\n fmt = getFormat(new_type)\n fancy_set_sensitive(self._mountPointEntry, fmt.mountable)\n\n def _populate_container(self, device=None):\n \"\"\" Set up the vg widgets for lvm or hide them for other types. \"\"\"\n device_type = self._get_current_device_type()\n if device is None:\n if self._accordion.current_selector is None:\n return\n\n device = self._accordion.current_selector.device\n if device:\n device = device.raw_device\n\n container_size_policy = SIZE_POLICY_AUTO\n if device_type not in CONTAINER_DEVICE_TYPES:\n # just hide the buttons with no meaning for non-container devices\n for widget in [self._containerLabel, self._containerCombo, self._modifyContainerButton]:\n really_hide(widget)\n return\n\n # else really populate the container\n # set up the vg widgets and then bail out\n if devicefactory.get_device_type(device) == device_type:\n _device = device\n else:\n _device = None\n\n with ui_storage_logger():\n factory = devicefactory.get_device_factory(self._storage_playground,\n device_type,\n 0, min_luks_entropy=crypto.MIN_CREATE_ENTROPY)\n container = factory.get_container(device=_device)\n default_container_name = getattr(container, \"name\", None)\n if container:\n container_size_policy = container.size_policy\n\n container_type = get_container_type(device_type)\n self._containerLabel.set_text(C_(\"GUI|Custom Partitioning|Configure|Devices\", container_type.label).title())\n self._containerLabel.set_use_underline(True)\n self._containerStore.clear()\n if device_type == DEVICE_TYPE_BTRFS:\n containers = self._storage_playground.btrfsVolumes\n else:\n containers = self._storage_playground.vgs\n\n default_seen = False\n for c in containers:\n self._containerStore.append(self._container_store_row(c.name, getattr(c, \"freeSpace\", None)))\n if default_container_name and c.name == default_container_name:\n default_seen = True\n self._containerCombo.set_active(containers.index(c))\n\n if default_container_name is None:\n hostname = self.data.network.hostname\n default_container_name = self._storage_playground.suggestContainerName(hostname=hostname)\n\n log.debug(\"default container is %s\", default_container_name)\n self._device_container_name = default_container_name\n self._device_container_size = container_size_policy\n\n if not default_seen:\n self._containerStore.append(self._container_store_row(default_container_name))\n self._containerCombo.set_active(len(self._containerStore) - 1)\n\n self._containerStore.append(self._container_store_row(_(NEW_CONTAINER_TEXT) % {\"container_type\": _(container_type.name).lower()}))\n self._containerCombo.set_tooltip_text(_(CONTAINER_TOOLTIP) % {\"container_type\": _(container_type.name).lower()})\n if default_container_name is None:\n self._containerCombo.set_active(len(self._containerStore) - 1)\n\n for widget in [self._containerLabel, self._containerCombo, self._modifyContainerButton]:\n really_show(widget)\n\n # make the combo and button insensitive for existing LVs\n can_change_container = (device is not None and not device.exists and\n device != container)\n fancy_set_sensitive(self._containerCombo, can_change_container)\n container_exists = getattr(container, \"exists\", False)\n self._modifyContainerButton.set_sensitive(not container_exists)\n\n def _update_fstype_combo(self, device_type):\n \"\"\" Set up device type dependent portion of filesystem combo.\n\n :param int device_type: an int representing the device type\n\n Generally speaking, the filesystem combo can be set up without\n reference to the device type because the choice of filesystem\n combo and of device type is orthogonal.\n\n However, choice of btrfs device type requires choice of btrfs\n filesystem type, and choice of any other device type precludes\n choice of btrfs filesystem type.\n\n Preconditions are:\n * the filesystem combo contains at least the default filesystem\n * the default filesystem is not the same as btrfs\n * if device_type is DEVICE_TYPE_BTRFS, btrfs is supported\n\n This method is idempotent, and must remain so.\n \"\"\"\n # Find unique instance of btrfs in fsCombo, if any.\n model = self._fsCombo.get_model()\n btrfs_iter = ((idx, row) for idx, row in enumerate(model) if row[0] == \"btrfs\")\n btrfs_idx, btrfs_row = next(btrfs_iter, (None, None))\n\n if device_type == DEVICE_TYPE_BTRFS:\n # If no btrfs entry, add one, and select the new entry\n if btrfs_idx is None:\n self._fsStore.append([\"btrfs\"])\n active_index = len(self._fsCombo.get_model()) - 1\n # Otherwise, select the already located btrfs entry\n else:\n active_index = btrfs_idx\n else:\n # Get the currently active index\n active_index = self._fsCombo.get_active()\n\n # If there is a btrfs entry, remove and adjust active_index\n if btrfs_idx is not None:\n self._fsStore.remove(btrfs_row.iter)\n\n # If btrfs previously selected, select default filesystem\n if active_index == btrfs_idx:\n active_index = next(idx for idx, data in enumerate(self._fsCombo.get_model()) if data[0] == self.storage.defaultFSType)\n # Otherwise, shift index left by one if after removed entry\n elif active_index > btrfs_idx:\n active_index = active_index - 1\n # If there is no btrfs entry, stick with user's previous choice\n else:\n pass\n\n self._fsCombo.set_active(active_index)\n fancy_set_sensitive(self._fsCombo, self._reformatCheckbox.get_active() and device_type != DEVICE_TYPE_BTRFS)\n\n def on_device_type_changed(self, combo):\n if combo is not self._typeCombo:\n return\n\n if not self._initialized:\n return\n\n # The name of the device type is more informative than the numeric id\n new_type = self._get_current_device_type_name()\n log.debug(\"device_type_changed: %s\", new_type)\n\n # Quit if no device type is selected.\n if new_type is None:\n return\n\n # The numeric id of the device is what is needed by blivet.\n new_type = dev_type_from_const(new_type)\n\n # Quit if device type name is unrecognized by blivet.\n if new_type is None:\n return\n\n # lvm uses the RHS to set disk set. no foolish minds here.\n exists = self._accordion.current_selector and self._accordion.current_selector.device.exists\n self._configButton.set_sensitive(not exists and new_type not in CONTAINER_DEVICE_TYPES)\n\n # this has to be done before calling populate_raid since it will need\n # the raid level combo to contain the relevant raid levels for the new\n # device type\n self._raidStoreFilter.refilter()\n\n self._populate_raid(defaultRaidLevel(new_type))\n self._populate_container()\n\n fancy_set_sensitive(self._nameEntry, new_type in NAMED_DEVICE_TYPES)\n self._nameEntry.set_text(self._device_name_dict[new_type])\n fancy_set_sensitive(self._sizeEntry, new_type != DEVICE_TYPE_BTRFS)\n\n self._update_fstype_combo(new_type)\n\n def clear_errors(self):\n self._error = None\n self.clear_info()\n\n # This callback is for the button that just resets the UI to anaconda's\n # current understanding of the disk layout.\n def on_reset_clicked(self, *args):\n msg = _(\"Continuing with this action will reset all your partitioning selections \"\n \"to their current on-disk state.\")\n\n dlg = Gtk.MessageDialog(flags=Gtk.DialogFlags.MODAL,\n message_type=Gtk.MessageType.WARNING,\n buttons=Gtk.ButtonsType.NONE,\n message_format=msg)\n dlg.set_decorated(False)\n dlg.add_buttons(C_(\"GUI|Custom Partitioning|Reset Dialog\", \"_Reset selections\"), 0,\n C_(\"GUI|Custom Partitioning|Reset Dialog\", \"_Preserve current selections\"), 1)\n dlg.set_default_response(1)\n\n with self.main_window.enlightbox(dlg):\n rc = dlg.run()\n dlg.destroy()\n\n if rc == 0:\n self.refresh()\n\n # This callback is for the button that has anaconda go back and rescan the\n # disks to pick up whatever changes the user made outside our control.\n def on_refresh_clicked(self, *args):\n dialog = RefreshDialog(self.data, self.storage)\n ignoreEscape(dialog.window)\n with self.main_window.enlightbox(dialog.window):\n rc = dialog.run()\n dialog.window.destroy()\n\n if rc == 1:\n # User hit OK on the dialog, indicating they stayed on the dialog\n # until rescanning completed and now needs to go back to the\n # main storage spoke.\n self.skipTo = \"StorageSpoke\"\n elif rc != 2:\n # User either hit cancel on the dialog or closed it via escape, so\n # there was no rescanning done.\n # NOTE: rc == 2 means the user clicked on the link that takes them\n # back to the hub.\n return\n\n # Can't use this spoke's on_back_clicked method as that will try to\n # save the right hand side, which is no longer valid. The user must\n # go back and select their disks all over again since whatever they\n # did on the shell could have changed what disks are available.\n NormalSpoke.on_back_clicked(self, None)\n\n def on_info_bar_clicked(self, *args):\n log.debug(\"info bar clicked: %s (%s)\", self._error, args)\n if not self._error:\n return\n\n dlg = Gtk.MessageDialog(flags=Gtk.DialogFlags.MODAL,\n message_type=Gtk.MessageType.ERROR,\n buttons=Gtk.ButtonsType.CLOSE,\n message_format=str(self._error))\n dlg.set_decorated(False)\n\n with self.main_window.enlightbox(dlg):\n dlg.run()\n dlg.destroy()\n\n @timed_action(delay=50, threshold=100)\n def on_update_settings_clicked(self, button):\n \"\"\" call _save_right_side, then, perhaps, populate_right_side. \"\"\"\n self._save_right_side(self._accordion.current_selector)\n self._applyButton.set_sensitive(False)\n\n @timed_action(delay=50, threshold=100)\n def on_unlock_clicked(self, *args):\n \"\"\" try to open the luks device, populate, then call _do_refresh. \"\"\"\n self.clear_errors()\n device = self._accordion.current_selector.device\n log.info(\"trying to unlock %s...\", device.name)\n passphrase = self._passphraseEntry.get_text()\n device.format.passphrase = passphrase\n try:\n device.setup()\n device.format.setup()\n except StorageError as e:\n log.error(\"failed to unlock %s: %s\", device.name, e)\n device.teardown(recursive=True)\n self._error = e\n device.format.passphrase = None\n self._passphraseEntry.set_text(\"\")\n self.set_warning(_(\"Failed to unlock encrypted block device. \"\n \"<a href=\\\"\\\">Click for details.</a>\"))\n return\n\n # set the passphrase also to the originalFormat of the device (a\n # different object than '.format', but the same contents)\n device.originalFormat.passphrase = passphrase\n log.info(\"unlocked %s, now going to populate devicetree...\", device.name)\n with ui_storage_logger():\n luks_dev = LUKSDevice(device.format.mapName,\n parents=[device],\n exists=True)\n self._storage_playground.devicetree._addDevice(luks_dev)\n # save the passphrase for possible reset and to try for other devs\n self._storage_playground.savePassphrase(device)\n # XXX What if the user has changed things using the shell?\n try_populate_devicetree(self._storage_playground.devicetree)\n # look for new roots\n self._storage_playground.roots = findExistingInstallations(self._storage_playground.devicetree)\n\n self._devices = self._storage_playground.devices\n self._accordion.clear_current_selector()\n self._do_refresh()\n\n def on_value_changed(self, *args):\n self._applyButton.set_sensitive(True)\n"},"domain":{"kind":"string","value":"codeparrot/github-code-clean"}}},{"rowIdx":227198,"cells":{"text":{"kind":"string","value":"# -*- coding: utf-8 -*-\n#\n# This file is part of Invenio.\n# Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2013, 2014, 2015 CERN.\n#\n# Invenio is free software; you can redistribute it and/or\n# modify it under the terms of the GNU General Public License as\n# published by the Free Software Foundation; either version 2 of the\n# License, or (at your option) any later version.\n#\n# Invenio is distributed in the hope that it will be useful, but\n# WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n# General Public License for more details.\n#\n# You should have received a copy of the GNU General Public License\n# along with Invenio; if not, write to the Free Software Foundation, Inc.,\n# 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.\n\n\"\"\"Format a single record using specified format.\n\nYou can have a look at the various escaping modes available in\nX{BibFormatObject} in function L{escape_field}\n\nStill it is useful sometimes for debugging purpose to use the\nL{BibFormatObject} class directly. For eg:\n\n >>> from invenio.modules.formatter.engine import BibFormatObject\n >>> bfo = BibFormatObject(102)\n >>> bfo.field('245__a')\n The order Rodentia in South America\n >>> from invenio.modules.formatter.format_elements import bfe_title\n >>> bfe_title.format_element(bfo)\n The order Rodentia in South America\n\n@see: bibformat.py, bibformat_utils.py\n\"\"\"\n\nimport re\nimport sys\nimport os\nimport inspect\nimport traceback\nimport cgi\nimport types\n\nfrom flask import has_app_context, current_app\nfrom operator import itemgetter\nfrom six import iteritems\nfrom werkzeug.utils import cached_property\n\nfrom invenio.base.globals import cfg\nfrom invenio.config import \\\n CFG_SITE_LANG, \\\n CFG_BIBFORMAT_CACHED_FORMATS, \\\n CFG_BIBFORMAT_DISABLE_I18N_FOR_CACHED_FORMATS, \\\n CFG_BIBFORMAT_HIDDEN_TAGS\nfrom invenio.ext.logging import \\\n register_exception\nfrom invenio.legacy.bibrecord import \\\n create_record, \\\n record_get_field_instances, \\\n record_get_field_value, \\\n record_get_field_values, \\\n record_xml_output, \\\n record_empty\nfrom . import registry\nfrom .engines import xslt\nfrom .models import Format\nfrom invenio.base.i18n import \\\n language_list_long, \\\n wash_language, \\\n gettext_set_language\nimport invenio.legacy.bibformat.dblayer as bibformat_dblayer\nfrom .config import \\\n CFG_BIBFORMAT_TEMPLATES_DIR, \\\n CFG_BIBFORMAT_FORMAT_TEMPLATE_EXTENSION, \\\n CFG_BIBFORMAT_FORMAT_JINJA_TEMPLATE_EXTENSION, \\\n CFG_BIBFORMAT_FORMAT_OUTPUT_EXTENSION, \\\n CFG_BIBFORMAT_OUTPUTS_PATH, \\\n InvenioBibFormatError\nfrom invenio.modules.formatter.utils import \\\n record_get_xml, \\\n parse_tag\nfrom invenio.utils.html import \\\n HTMLWasher, \\\n CFG_HTML_BUFFER_ALLOWED_TAG_WHITELIST, \\\n CFG_HTML_BUFFER_ALLOWED_ATTRIBUTE_WHITELIST\nfrom invenio.modules.knowledge.api import get_kbr_values\nfrom invenio.ext.template import render_template_to_string\nfrom HTMLParser import HTMLParseError\nfrom invenio.modules.access.engine import acc_authorize_action\nfrom invenio.modules.formatter.registry import template_context_functions\n\n# Cache for data we have already read and parsed\nformat_templates_cache = {}\nformat_elements_cache = {}\nformat_outputs_cache = {}\n\nhtml_field = '<!--HTML-->' # String indicating that field should be\n # treated as HTML (and therefore no escaping of\n # HTML tags should occur.\n # Appears in some field values.\n\nwasher = HTMLWasher() # Used to remove dangerous tags from HTML\n # sources\n\n# Regular expression for finding <lang>...</lang> tag in format templates\npattern_lang = re.compile(r'''\n <lang #<lang tag (no matter case)\n \\s* #any number of white spaces\n > #closing <lang> start tag\n (?P<langs>.*?) #anything but the next group (greedy)\n (</lang\\s*>) #end tag\n ''', re.IGNORECASE | re.DOTALL | re.VERBOSE)\n\n# Builds regular expression for finding each known language in <lang> tags\nln_pattern_text = r\"<(\"\nfor lang in language_list_long(enabled_langs_only=False):\n ln_pattern_text += lang[0] +r\"|\"\n\nln_pattern_text = ln_pattern_text.rstrip(r\"|\")\nln_pattern_text += r\")>(.*?)</\\1>\"\n\nln_pattern = re.compile(ln_pattern_text, re.IGNORECASE | re.DOTALL)\n\n# Regular expression for finding text to be translated\nTRANSLATION_PATTERN = re.compile(r'_\\((?P<word>.*?)\\)_',\n re.IGNORECASE | re.DOTALL | re.VERBOSE)\n\n# Regular expression for finding <name> tag in format templates\npattern_format_template_name = re.compile(r'''\n <name #<name tag (no matter case)\n \\s* #any number of white spaces\n > #closing <name> start tag\n (?P<name>.*?) #name value. any char that is not end tag\n (</name\\s*>)(\\n)? #end tag\n ''', re.IGNORECASE | re.DOTALL | re.VERBOSE)\n\n# Regular expression for finding <description> tag in format templates\npattern_format_template_desc = re.compile(r'''\n <description #<decription tag (no matter case)\n \\s* #any number of white spaces\n > #closing <description> start tag\n (?P<desc>.*?) #description value. any char that is not end tag\n </description\\s*>(\\n)? #end tag\n ''', re.IGNORECASE | re.DOTALL | re.VERBOSE)\n\n# Regular expression for finding <BFE_ > tags in format templates\npattern_tag = re.compile(r'''\n <BFE_ #every special tag starts with <BFE_ (no matter case)\n (?P<function_name>[^/\\s]+) #any char but a space or slash\n \\s* #any number of spaces\n (?P<params>(\\s* #params here\n (?P<param>([^=\\s])*)\\s* #param name: any chars that is not a white space or equality. Followed by space(s)\n =\\s* #equality: = followed by any number of spaces\n (?P<sep>[\\'\"]) #one of the separators\n (?P<value>.*?) #param value: any chars that is not a separator like previous one\n (?P=sep) #same separator as starting one\n )*) #many params\n \\s* #any number of spaces\n (/)?> #end of the tag\n ''', re.IGNORECASE | re.DOTALL | re.VERBOSE)\n\n# Regular expression for finding params inside <BFE_ > tags in format templates\npattern_function_params = re.compile(r'''\n (?P<param>([^=\\s])*)\\s* # Param name: any chars that is not a white space or equality. Followed by space(s)\n =\\s* # Equality: = followed by any number of spaces\n (?P<sep>[\\'\"]) # One of the separators\n (?P<value>.*?) # Param value: any chars that is not a separator like previous one\n (?P=sep) # Same separator as starting one\n ''', re.VERBOSE | re.DOTALL)\n\n# Regular expression for finding format elements \"params\" attributes\n# (defined by @param)\npattern_format_element_params = re.compile(r'''\n @param\\s* # Begins with AT param keyword followed by space(s)\n (?P<name>[^\\s=]*):\\s* # A single keyword and comma, then space(s)\n #(=\\s*(?P<sep>[\\'\"]) # Equality, space(s) and then one of the separators\n #(?P<default>.*?) # Default value: any chars that is not a separator like previous one\n #(?P=sep) # Same separator as starting one\n #)?\\s* # Default value for param is optional. Followed by space(s)\n (?P<desc>.*) # Any text that is not end of line (thanks to MULTILINE parameter)\n ''', re.VERBOSE | re.MULTILINE)\n\n# Regular expression for finding format elements \"see also\" attribute\n# (defined by @see)\npattern_format_element_seealso = re.compile(r'''@see:\\s*(?P<see>.*)''',\n re.VERBOSE | re.MULTILINE)\n\n#Regular expression for finding 2 expressions in quotes, separated by\n#comma (as in template(\"1st\",\"2nd\") )\n#Used when parsing output formats\n# pattern_parse_tuple_in_quotes = re.compile('''\n# (?P<sep1>[\\'\"])\n# (?P<val1>.*)\n# (?P=sep1)\n# \\s*,\\s*\n# (?P<sep2>[\\'\"])\n# (?P<val2>.*)\n# (?P=sep2)\n# ''', re.VERBOSE | re.MULTILINE)\n\nsub_non_alnum = re.compile('[^0-9a-zA-Z]+')\nfix_tag_name = lambda s: sub_non_alnum.sub('_', s.lower())\n\n\nfrom invenio.utils.memoise import memoize\n\n\nclass LazyTemplateContextFunctionsCache(object):\n \"\"\"Loads bibformat elements using plugin builder and caches results.\"\"\"\n\n @cached_property\n def template_context_functions(self):\n \"\"\"Returns template context functions\"\"\"\n modules = template_context_functions\n elem = {}\n for m in modules:\n register_func = getattr(m, 'template_context_function', None)\n if register_func and isinstance(register_func, types.FunctionType):\n elem[m.__name__.split('.')[-1]] = register_func\n\n return elem\n\n @memoize\n def bibformat_elements(self, modules=None):\n \"\"\"Returns bibformat elements.\"\"\"\n if modules is None:\n modules = registry.format_elements\n\n elem = {}\n for m in modules:\n if m is None:\n continue\n name = m.__name__.split('.')[-1]\n if name in elem:\n continue\n filename = m.__file__[:-1] if m.__file__.endswith('.pyc') \\\n else m.__file__\n register_func = getattr(m, 'format_element',\n getattr(m, 'format', None))\n escape_values = getattr(m, 'escape_values', None)\n if register_func and isinstance(register_func, types.FunctionType):\n register_func._escape_values = escape_values\n register_func.__file__ = filename\n elem[name] = register_func\n\n return elem\n\n @cached_property\n def functions(self):\n\n def insert(name):\n def _bfe_element(bfo, **kwargs):\n # convert to utf-8 for legacy app\n kwargs = dict((k, v.encode('utf-8') if isinstance(v, unicode) else v)\n for k, v in iteritems(kwargs))\n format_element = get_format_element(name)\n (out, dummy) = eval_format_element(format_element,\n bfo,\n kwargs)\n # returns unicode for jinja2\n return out.decode('utf-8')\n return _bfe_element\n\n # Old bibformat templates\n tfn_from_files = dict((name.lower(), insert(name.lower()))\n for name in self.bibformat_elements().keys())\n # Update with new template context functions\n tfn_from_files.update(self.template_context_functions)\n\n bfe_from_tags = {}\n if has_app_context():\n from invenio.ext.sqlalchemy import db\n from invenio.modules.search.models import Tag\n\n # get functions from tag table\n bfe_from_tags = dict(('bfe_'+fix_tag_name(name),\n insert(fix_tag_name(name)))\n for name in map(itemgetter(0),\n db.session.query(Tag.name).all()))\n\n # overwrite functions from tag table with functions from files\n bfe_from_tags.update(tfn_from_files)\n return bfe_from_tags\n\nTEMPLATE_CONTEXT_FUNCTIONS_CACHE = LazyTemplateContextFunctionsCache()\n\n\ndef get_format_element_path(filename):\n if filename.endswith('.py'):\n filename = filename[:-3]\n return TEMPLATE_CONTEXT_FUNCTIONS_CACHE.bibformat_elements()[filename].__file__\n\n\ndef format_record(recID, of, ln=CFG_SITE_LANG, verbose=0,\n search_pattern=None, xml_record=None, user_info=None, qid=\"\",\n **kwargs):\n \"\"\"\n Formats a record given output format. Main entry function of\n bibformat engine.\n\n Returns a formatted version of the record in the specified\n language, search pattern, and with the specified output format.\n The function will define which format template must be applied.\n\n You can either specify an record ID to format, or give its xml\n representation. if 'xml_record' is not None, then use it instead\n of recID.\n\n 'user_info' allows to grant access to some functionalities on a\n page depending on the user's priviledges. 'user_info' is the same\n object as the one returned by 'webuser.collect_user_info(req)'\n\n :param recID: the ID of record to format\n :param of: an output format code (or short identifier for the output format)\n :param ln: the language to use to format the record\n :param verbose: the level of verbosity from 0 to 9 (O: silent,\n 5: errors,\n 7: errors and warnings, stop if error in format elements\n 9: errors and warnings, stop if error (debug mode ))\n :param search_pattern: list of strings representing the user request in web interface\n :param xml_record: an xml string representing the record to format\n :param user_info: the information of the user who will view the formatted page\n @return: formatted record\n \"\"\"\n if search_pattern is None:\n search_pattern = []\n\n out = \"\"\n\n ln = wash_language(ln)\n _ = gettext_set_language(ln)\n\n # Temporary workflow (during migration of formats):\n # Call new BibFormat\n # But if format not found for new BibFormat, then call old BibFormat\n\n #Create a BibFormat Object to pass that contain record and context\n bfo = BibFormatObject(recID, ln, search_pattern, xml_record, user_info, of)\n\n if of.lower() != 'xm' and (not bfo.get_record()\n or record_empty(bfo.get_record())):\n # Record only has recid: do not format, excepted\n # for xm format\n return \"\", False\n\n #Find out which format template to use based on record and output format.\n template = decide_format_template(bfo, of)\n if verbose == 9 and template is not None:\n out += \"\"\"\\n<br/><span class=\"quicknote\">\n Using %s template for record %i.\n </span>\"\"\" % (template, recID)\n\n path = registry.format_templates_lookup.get(template)\n\n if template is None or not (\n template.endswith(\".\" + CFG_BIBFORMAT_FORMAT_JINJA_TEMPLATE_EXTENSION)\n or path is None or os.access(path, os.R_OK)\n ):\n # template not found in new BibFormat. Call old one\n if verbose == 9:\n if template is None:\n out += \"\"\"\\n<br/><span class=\"quicknote\">\n No template found for output format %s and record %i.\n (Check invenio.err log file for more details)\n </span>\"\"\" % (of, recID)\n else:\n out += \"\"\"\\n<br/><span class=\"quicknote\">\n Template %s could not be read.\n </span>\"\"\" % (template)\n try:\n raise InvenioBibFormatError(_('No template could be found for output format %(code)s.', code=of))\n except InvenioBibFormatError as exc:\n register_exception(req=bfo.req)\n\n if verbose > 5:\n out += \"\"\"\\n<br/><span class=\"quicknote\">\n %s\n </span>\"\"\" % str(exc)\n\n return out, False\n\n # Format with template\n out_, needs_2nd_pass = format_with_format_template(\n template, bfo, verbose=verbose, extra_context=kwargs)\n\n out += out_\n\n return out, needs_2nd_pass\n\n\ndef format_record_1st_pass(recID, of, ln=CFG_SITE_LANG, verbose=0,\n search_pattern=None, xml_record=None,\n user_info=None, on_the_fly=False,\n save_missing=True, **kwargs):\n \"\"\"\n Format a record in given output format.\n\n Return a formatted version of the record in the specified\n language, search pattern, and with the specified output format.\n The function will define which format template must be applied.\n\n The record to be formatted can be specified with its ID (with\n 'recID' parameter) or given as XML representation (with\n 'xml_record' parameter). If 'xml_record' is specified 'recID' is\n ignored (but should still be given for reference. A dummy recid 0\n or -1 could be used).\n\n 'user_info' allows to grant access to some functionalities on a\n page depending on the user's priviledges. The 'user_info' object\n makes sense only in the case of on-the-fly formatting. 'user_info'\n is the same object as the one returned by\n 'webuser.collect_user_info(req)'\n\n :param recID: the ID of record to format.\n @type recID: int\n :param of: an output format code (or short identifier for the output format)\n @type of: string\n :param ln: the language to use to format the record\n @type ln: string\n :param verbose: the level of verbosity from 0 to 9 (O: silent,\n 5: errors,\n 7: errors and warnings, stop if error in format elements\n 9: errors and warnings, stop if error (debug mode ))\n @type verbose: int\n :param search_pattern: list of strings representing the user request in web interface\n @type search_pattern: list(string)\n :param xml_record: an xml string represention of the record to format\n @type xml_record: string or None\n :param user_info: the information of the user who will view the formatted page (if applicable)\n :param on_the_fly: if False, try to return an already preformatted version of the record in the database\n @type on_the_fly: boolean\n @return: formatted record\n @rtype: string\n \"\"\"\n from invenio.legacy.search_engine import record_exists\n if search_pattern is None:\n search_pattern = []\n\n out = \"\"\n\n if verbose == 9:\n out += \"\"\"\\n<span class=\"quicknote\">\n Formatting record %i with output format %s.\n </span>\"\"\" % (recID, of)\n if not on_the_fly and \\\n (ln == CFG_SITE_LANG or\n of.lower() == 'xm' or\n (of.lower() in CFG_BIBFORMAT_DISABLE_I18N_FOR_CACHED_FORMATS)) and \\\n record_exists(recID) != -1:\n # Try to fetch preformatted record. Only possible for records\n # formatted in CFG_SITE_LANG language (other are never\n # stored), or of='xm' which does not depend on language.\n # Exceptions are made for output formats defined in\n # CFG_BIBFORMAT_DISABLE_I18N_FOR_CACHED_FORMATS, which are\n # always served from the same cache for any language. Also,\n # do not fetch from DB when record has been deleted: we want\n # to return an \"empty\" record in that case\n res, needs_2nd_pass = bibformat_dblayer.get_preformatted_record(recID, of)\n if res is not None:\n # record 'recID' is formatted in 'of', so return it\n if verbose == 9:\n last_updated = bibformat_dblayer.get_preformatted_record_date(recID, of)\n out += \"\"\"\\n<br/><span class=\"quicknote\">\n Found preformatted output for record %i (cache updated on %s).\n </span><br/>\"\"\" % (recID, last_updated)\n if of.lower() == 'xm':\n res = filter_hidden_fields(res, user_info)\n # try to replace language links in pre-cached res, if applicable:\n if ln != CFG_SITE_LANG and of.lower() in CFG_BIBFORMAT_DISABLE_I18N_FOR_CACHED_FORMATS:\n # The following statements try to quickly replace any\n # language arguments in URL links. Not an exact\n # science, but should work most of the time for most\n # of the formats, with not too many false positives.\n # We don't have time to parse output much here.\n res = res.replace('?ln=' + CFG_SITE_LANG, '?ln=' + ln)\n res = res.replace('&ln=' + CFG_SITE_LANG, '&ln=' + ln)\n res = res.replace('&ln=' + CFG_SITE_LANG, '&ln=' + ln)\n out += res\n return out, needs_2nd_pass\n else:\n if verbose == 9:\n out += \"\"\"\\n<br/><span class=\"quicknote\">\n No preformatted output found for record %s.\n </span>\"\"\"% recID\n\n\n # Live formatting of records in all other cases\n if verbose == 9:\n out += \"\"\"\\n<br/><span class=\"quicknote\">\n Formatting record %i on-the-fly.\n </span>\"\"\" % recID\n\n try:\n out_, needs_2nd_pass = format_record(recID=recID,\n of=of,\n ln=ln,\n verbose=verbose,\n search_pattern=search_pattern,\n xml_record=xml_record,\n user_info=user_info,\n **kwargs)\n out += out_\n\n if of.lower() in ('xm', 'xoaimarc'):\n out = filter_hidden_fields(out, user_info, force_filtering=of.lower()=='xoaimarc')\n\n # We have spent time computing this format\n # We want to save this effort if the format is cached\n if save_missing and recID and ln == cfg['CFG_SITE_LANG'] \\\n and of.lower() in cfg['CFG_BIBFORMAT_CACHED_FORMATS'] \\\n and verbose == 0:\n bibformat_dblayer.save_preformatted_record(recID,\n of,\n out,\n needs_2nd_pass)\n\n return out, needs_2nd_pass\n except Exception, e:\n register_exception(prefix=\"An error occured while formatting record %s in %s\" %\n (recID, of),\n alert_admin=True)\n #Failsafe execution mode\n import invenio.legacy.template\n websearch_templates = invenio.legacy.template.load('websearch')\n if verbose == 9:\n out += \"\"\"\\n<br/><span class=\"quicknote\">\n An error occured while formatting record %s. (%s)\n </span>\"\"\" % (recID, str(e))\n if of.lower() == 'hd':\n if verbose == 9:\n out += \"\"\"\\n<br/><span class=\"quicknote\">\n Formatting record %i with websearch_templates.tmpl_print_record_detailed.\n </span><br/>\"\"\" % recID\n return out + websearch_templates.tmpl_print_record_detailed(\n ln=ln,\n recID=recID,\n )\n if verbose == 9:\n out += \"\"\"\\n<br/><span class=\"quicknote\">\n Formatting record %i with websearch_templates.tmpl_print_record_brief.\n </span><br/>\"\"\" % recID\n return out + websearch_templates.tmpl_print_record_brief(ln=ln,\n recID=recID,\n ), False\n\n\ndef format_record_2nd_pass(recID, template, ln=CFG_SITE_LANG,\n search_pattern=None, xml_record=None,\n user_info=None, of=None, verbose=0, **kwargs):\n # Create light bfo object\n bfo = BibFormatObject(recID, ln, search_pattern, xml_record, user_info, of)\n # Translations\n template = translate_template(template, ln)\n # Format template\n r, dummy = format_with_format_template(format_template_filename=None,\n format_template_code=template,\n bfo=bfo,\n verbose=verbose,\n extra_context=kwargs)\n return r\n\n\ndef decide_format_template(bfo, of):\n \"\"\"\n Returns the format template name that should be used for formatting\n given output format and L{BibFormatObject}.\n\n Look at of rules, and take the first matching one.\n If no rule matches, returns None\n\n To match we ignore lettercase and spaces before and after value of\n rule and value of record\n\n :param bfo: a L{BibFormatObject}\n :param of: the code of the output format to use\n @return: name of a format template\n \"\"\"\n\n output_format = get_output_format(of)\n\n for rule in output_format['rules']:\n if rule['field'].startswith('00'):\n # Rule uses controlfield\n values = [bfo.control_field(rule['field']).strip()] #Remove spaces\n else:\n # Rule uses datafield\n values = bfo.fields(rule['field'])\n # loop over multiple occurences, but take the first match\n if len(values) > 0:\n for value in values:\n value = value.strip() #Remove spaces\n pattern = rule['value'].strip() #Remove spaces\n match_obj = re.match(pattern, value, re.IGNORECASE)\n if match_obj is not None and \\\n match_obj.end() == len(value):\n return rule['template']\n template = output_format['default']\n if template != '':\n return template\n else:\n return None\n\n\ndef translate_template(template, ln=CFG_SITE_LANG):\n _ = gettext_set_language(ln)\n\n def translate(match):\n \"\"\"\n Translate matching values\n \"\"\"\n word = match.group(\"word\")\n translated_word = _(word)\n return translated_word\n\n filtered_template = filter_languages(template, ln)\n evaluated_format = TRANSLATION_PATTERN.sub(translate, filtered_template)\n return evaluated_format\n\n\ndef format_with_format_template(format_template_filename, bfo,\n verbose=0, format_template_code=None, qid=\"\",\n extra_context=None):\n \"\"\" Format a record given a\n format template.\n\n Returns a formatted version of the record represented by bfo,\n in the language specified in bfo, and with the specified format template.\n\n If format_template_code is provided, the template will not be loaded from\n format_template_filename (but format_template_filename will still be used to\n determine if bft or xsl transformation applies). This allows to preview format\n code without having to save file on disk.\n\n :param format_template_filename: the dilename of a format template\n :param bfo: the object containing parameters for the current formatting\n :param format_template_code: if not empty, use code as template instead of reading format_template_filename (used for previews)\n :param verbose: the level of verbosity from 0 to 9 (O: silent,\n 5: errors,\n 7: errors and warnings,\n 9: errors and warnings, stop if error (debug mode ))\n @return: formatted text\n \"\"\"\n if format_template_code is not None:\n format_content = str(format_template_code)\n elif not format_template_filename.endswith(\".\" + CFG_BIBFORMAT_FORMAT_JINJA_TEMPLATE_EXTENSION):\n format_content = get_format_template(format_template_filename)['code']\n\n if format_template_filename is None or \\\n format_template_filename.endswith(\".\" + CFG_BIBFORMAT_FORMAT_TEMPLATE_EXTENSION):\n # .bft\n evaluated_format, needs_2nd_pass = eval_format_template_elements(\n format_content,\n bfo,\n verbose)\n if not needs_2nd_pass:\n evaluated_format = translate_template(evaluated_format, bfo.lang)\n\n\n elif format_template_filename.endswith(\".\" + CFG_BIBFORMAT_FORMAT_JINJA_TEMPLATE_EXTENSION):\n evaluated_format = '<!-- empty -->'\n #try:\n from functools import wraps\n from invenio.modules.records.api import \\\n create_record as new_create_record, \\\n get_record as new_get_record\n from flask_login import current_user\n from invenio.base.helpers import unicodifier\n\n def _format_record(recid, of='hb', user_info=current_user, *args, **kwargs):\n from invenio.modules.formatter import format_record\n return format_record(recid, of, user_info=user_info, *args, **kwargs)\n\n # Fixes unicode problems in Jinja2 templates.\n def encode_utf8(f):\n @wraps(f)\n def wrapper(*args, **kwds):\n return unicodifier(f(*args, **kwds))\n return wrapper\n\n if bfo.xml_record is None:\n record = new_get_record(bfo.recID)\n else:\n record = new_create_record(bfo.xml_record, master_format='marc')\n bfo.recID = bfo.recID if bfo.recID else 0\n record.__getitem__ = encode_utf8(record.__getitem__)\n record.get = encode_utf8(record.get)\n\n ctx = TEMPLATE_CONTEXT_FUNCTIONS_CACHE.functions\n if extra_context is not None:\n ctx.update(extra_context)\n\n evaluated_format = render_template_to_string(\n 'format/record/'+format_template_filename,\n recid=bfo.recID,\n record=record,\n format_record=_format_record,\n qid=qid,\n bfo=bfo, **ctx).encode('utf-8')\n needs_2nd_pass = False\n else:\n #.xsl\n if bfo.xml_record:\n # bfo was initialized with a custom MARCXML\n xml_record = '<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n' + \\\n record_xml_output(bfo.record)\n else:\n # Fetch MARCXML. On-the-fly xm if we are now formatting in xm\n xml_record = '<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n' + \\\n record_get_xml(bfo.recID, 'xm', on_the_fly=False)\n\n # Transform MARCXML using stylesheet\n evaluated_format = xslt.format(xml_record, template_source=format_content).decode('utf-8')\n needs_2nd_pass = False\n\n return evaluated_format, needs_2nd_pass\n\n\ndef eval_format_template_elements(format_template, bfo, verbose=0):\n \"\"\"\n Evalutes the format elements of the given template and replace each element with its value.\n\n Prepare the format template content so that we can directly replace the marc code by their value.\n This implies:\n 1. Look for special tags\n 2. replace special tags by their evaluation\n\n :param format_template: the format template code\n :param bfo: the object containing parameters for the current formatting\n :param verbose: the level of verbosity from 0 to 9 (O: silent,\n 5: errors, 7: errors and warnings,\n 9: errors and warnings, stop if error (debug mode ))\n @return: tuple (result, errors)\n \"\"\"\n _ = gettext_set_language(bfo.lang)\n status = {'no_cache': False}\n\n # First define insert_element_code(match), used in re.sub() function\n def insert_element_code(match):\n \"\"\"\n Analyses 'match', interpret the corresponding code, and return the result of the evaluation.\n\n Called by substitution in 'eval_format_template_elements(...)'\n\n :param match: a match object corresponding to the special tag that must be interpreted\n \"\"\"\n\n function_name = match.group(\"function_name\")\n\n # Ignore lang tags the processing is done outside\n if function_name == 'lang':\n return match.group(0)\n\n try:\n format_element = get_format_element(function_name, verbose)\n except Exception as e:\n register_exception(req=bfo.req)\n format_element = None\n if verbose >= 5:\n return '<b><span style=\"color: rgb(255, 0, 0);\">' + \\\n cgi.escape(str(e)).replace('\\n', '<br/>') + \\\n '</span>'\n if format_element is None:\n try:\n raise InvenioBibFormatError(\n _('Could not find format element named %(function_name)s.',\n function_name=function_name))\n except InvenioBibFormatError as exc:\n register_exception(req=bfo.req)\n\n if verbose >= 5:\n return '<b><span style=\"color: rgb(255, 0, 0);\">' + \\\n str(exc.message)+'</span></b>'\n else:\n params = {}\n # Look for function parameters given in format template code\n all_params = match.group('params')\n if all_params is not None:\n function_params_iterator = pattern_function_params.finditer(all_params)\n for param_match in function_params_iterator:\n name = param_match.group('param')\n value = param_match.group('value')\n params[name] = value\n\n if params.get('no_cache') == '1':\n result = match.group(\"function_name\")\n del params['no_cache']\n if params:\n params_str = ' '.join('%s=\"%s\"' % (k, v) for k, v in params.iteritems())\n result = \"<bfe_%s %s />\" % (result, params_str)\n else:\n result = \"<bfe_%s />\" % result\n status['no_cache'] = True\n else:\n # Evaluate element with params and return (Do not return errors)\n result, dummy = eval_format_element(format_element,\n bfo,\n params,\n verbose)\n return result\n\n # Substitute special tags in the format by our own text.\n # Special tags have the form <BNE_format_element_name [param=\"value\"]* />\n fmt = pattern_tag.sub(insert_element_code, format_template)\n return fmt, status['no_cache']\n\n\ndef eval_format_element(format_element, bfo, parameters=None, verbose=0):\n \"\"\"\n Returns the result of the evaluation of the given format element\n name, with given L{BibFormatObject} and parameters. Also returns\n the errors of the evaluation.\n\n :param format_element: a format element structure as returned by get_format_element\n :param bfo: a L{BibFormatObject} used for formatting\n :param parameters: a dict of parameters to be used for formatting. Key is parameter and value is value of parameter\n :param verbose: the level of verbosity from 0 to 9 (O: silent,\n 5: errors,\n 7: errors and warnings,\n 9: errors and warnings, stop if error (debug mode ))\n\n @return: tuple (result, errors)\n \"\"\"\n if parameters is None:\n parameters = {}\n\n errors = []\n #Load special values given as parameters\n prefix = parameters.get('prefix', \"\")\n suffix = parameters.get('suffix', \"\")\n default_value = parameters.get('default', \"\")\n escape = parameters.get('escape', \"\")\n output_text = ''\n\n _ = gettext_set_language(bfo.lang)\n\n # 3 possible cases:\n # a) format element file is found: we execute it\n # b) format element file is not found, but exist in tag table (e.g. bfe_isbn)\n # c) format element is totally unknown. Do nothing or report error\n if format_element is not None and format_element['type'] == \"python\":\n # a) We found an element with the tag name, of type \"python\"\n # Prepare a dict 'params' to pass as parameter to 'format'\n # function of element\n params = {}\n\n # Look for parameters defined in format element\n # Fill them with specified default values and values\n # given as parameters.\n # Also remember if the element overrides the 'escape'\n # parameter\n format_element_overrides_escape = False\n for param in format_element['attrs']['params']:\n name = param['name']\n default = param['default']\n params[name] = parameters.get(name, default)\n if name == 'escape':\n format_element_overrides_escape = True\n\n # Add BibFormatObject\n params['bfo'] = bfo\n\n # Execute function with given parameters and return result.\n function = format_element['code']\n _ = gettext_set_language(bfo.lang)\n\n try:\n output_text = function(**params)\n except Exception as e:\n register_exception(req=bfo.req)\n name = format_element['attrs']['name']\n try:\n raise InvenioBibFormatError(\n _('Error when evaluating format element %(x_name)s '\n 'with parameters %(x_params)s.',\n x_name=name, x_params=str(params)))\n except InvenioBibFormatError, exc:\n errors.append(exc.message)\n\n # Log exception\n message = _(\n \"Error when evaluating format element %(format_element)s with\"\n \" parameters %(parameters)s.\",\n format_element=name,\n parameters=str(params)\n )\n current_app.logger.exception(\n message\n )\n errors.append(message)\n\n # In debug mode - include traceback in output\n if current_app.debug:\n tb = sys.exc_info()[2]\n stack = traceback.format_exception(\n Exception, e, tb, limit=None\n )\n output_text = '<span class=\"well\"><pre style=\"color:red;\">' \\\n '%s\\n\\n%s</pre></span>' % (message, \"\".join(stack))\n\n # None can be returned when evaluating function\n if output_text is None:\n output_text = \"\"\n else:\n try:\n output_text = str(output_text)\n except:\n output_text = output_text.encode('utf-8')\n\n # Escaping:\n # (1) By default, everything is escaped in mode 1\n # (2) If evaluated element has 'escape_values()' function, use\n # its returned value as escape mode, and override (1)\n # (3) If template has a defined parameter 'escape' (in allowed\n # values), use it, and override (1) and (2). If this\n # 'escape' parameter is overriden by the format element\n # (defined in the 'format' function of the element), leave\n # the escaping job to this element\n\n # (1)\n escape_mode = 1\n\n # (2)\n escape_function = format_element['escape_function']\n if escape_function is not None:\n try:\n escape_mode = escape_function(bfo=bfo)\n except Exception as e:\n try:\n raise InvenioBibFormatError(_('Escape mode for format element %(x_name)s could not be retrieved. Using default mode instead.', x_name=name))\n except InvenioBibFormatError as exc:\n register_exception(req=bfo.req)\n errors.append(exc.message)\n\n if verbose >= 5:\n tb = sys.exc_info()[2]\n\n output_text += '<b><span style=\"color: rgb(255, 0, 0);\">'+ \\\n str(exc.message) +'</span></b> '\n # (3)\n if escape in ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']:\n escape_mode = int(escape)\n\n # If escape is equal to 1, then escape all\n # HTML reserved chars.\n if escape_mode > 0 and not format_element_overrides_escape:\n output_text = escape_field(output_text, mode=escape_mode)\n\n # Add prefix and suffix if they have been given as parameters and if\n # the evaluation of element is not empty\n if output_text.strip() != \"\":\n output_text = prefix + output_text + suffix\n\n # Add the default value if output_text is empty\n if output_text == \"\":\n output_text = default_value\n\n return output_text, errors\n\n elif format_element is not None and format_element['type'] == \"field\":\n # b) We have not found an element in files that has the tag\n # name. Then look for it in the table \"tag\"\n #\n # <BFE_LABEL_IN_TAG prefix = \"\" suffix = \"\" separator = \"\"\n # nbMax=\"\" escape=\"0\"/>\n #\n\n # Load special values given as parameters\n separator = parameters.get('separator ', \"\")\n nbMax = parameters.get('nbMax', \"\")\n escape = parameters.get('escape', \"1\") # By default, escape here\n\n # Get the fields tags that have to be printed\n tags = format_element['attrs']['tags']\n\n output_text = []\n\n # Get values corresponding to tags\n for tag in tags:\n p_tag = parse_tag(tag)\n values = record_get_field_values(bfo.get_record(),\n p_tag[0],\n p_tag[1],\n p_tag[2],\n p_tag[3])\n if len(values)>0 and isinstance(values[0], dict):\n #flatten dict to its values only\n values_list = [x.values() for x in values]\n #output_text.extend(values)\n for values in values_list:\n output_text.extend(values)\n else:\n output_text.extend(values)\n\n if nbMax != \"\":\n try:\n nbMax = int(nbMax)\n except ValueError:\n name = format_element['attrs']['name']\n try:\n raise InvenioBibFormatError(_('\"nbMax\" parameter for %(x_param)s must be an \"int\".', x_param=name))\n except InvenioBibFormatError as exc:\n register_exception(req=bfo.req)\n errors.append(exc.message)\n\n if verbose >= 5:\n output_text = output_text.append(exc.message)\n else:\n output_text = output_text[:nbMax]\n\n # Add prefix and suffix if they have been given as parameters and if\n # the evaluation of element is not empty.\n # If evaluation is empty string, return default value if it exists.\n # Else return empty string\n if (\"\".join(output_text)).strip() != \"\":\n # If escape is equal to 1, then escape all\n # HTML reserved chars.\n if escape == '1':\n output_text = cgi.escape(separator.join(output_text))\n else:\n output_text = separator.join(output_text)\n\n output_text = prefix + output_text + suffix\n else:\n #Return default value\n output_text = default_value\n\n return (output_text, errors)\n else:\n # c) Element is unknown\n try:\n raise InvenioBibFormatError(_('Could not find format element named %(format_element)s.', format_element=format_element))\n except InvenioBibFormatError as exc:\n register_exception(req=bfo.req)\n errors.append(exc.message)\n\n if verbose < 5:\n return (\"\", errors)\n elif verbose >= 5:\n if verbose >= 9:\n sys.exit(exc.message)\n return ('<b><span style=\"color: rgb(255, 0, 0);\">' +\n str(exc.message)+'</span></b>', errors)\n\n\ndef filter_languages(format_template, ln=CFG_SITE_LANG):\n \"\"\"\n Filters the language tags that do not correspond to the specified language.\n\n :param format_template: the format template code\n :param ln: the language that is NOT filtered out from the template\n @return: the format template with unnecessary languages filtered out\n \"\"\"\n # First define search_lang_tag(match) and clean_language_tag(match), used\n # in re.sub() function\n def search_lang_tag(match):\n \"\"\"\n Searches for the <lang>...</lang> tag and remove inner localized tags\n such as <en>, <fr>, that are not current_lang.\n\n If current_lang cannot be found inside <lang> ... </lang>, try to use 'CFG_SITE_LANG'\n\n :param match: a match object corresponding to the special tag that must be interpreted\n \"\"\"\n current_lang = ln\n\n def clean_language_tag(match):\n \"\"\"\n Return tag text content if tag language of match is output language.\n\n Called by substitution in 'filter_languages(...)'\n\n :param match: a match object corresponding to the special tag that must be interpreted\n \"\"\"\n if match.group(1) == current_lang:\n return match.group(2)\n else:\n return \"\"\n # End of clean_language_tag\n\n\n lang_tag_content = match.group(\"langs\")\n # Try to find tag with current lang. If it does not exists,\n # then current_lang becomes CFG_SITE_LANG until the end of this\n # replace\n pattern_current_lang = re.compile(r\"<(\" + current_lang +\n r\")\\s*>(.*)(</\" + current_lang + r\"\\s*>)\", re.IGNORECASE | re.DOTALL)\n if re.search(pattern_current_lang, lang_tag_content) is None:\n current_lang = CFG_SITE_LANG\n\n cleaned_lang_tag = ln_pattern.sub(clean_language_tag, lang_tag_content)\n return cleaned_lang_tag.strip()\n # End of search_lang_tag\n\n\n filtered_format_template = pattern_lang.sub(search_lang_tag, format_template)\n return filtered_format_template\n\ndef get_format_template(filename, with_attributes=False):\n \"\"\"\n Returns the structured content of the given formate template.\n\n if 'with_attributes' is true, returns the name and description. Else 'attrs' is not\n returned as key in dictionary (it might, if it has already been loaded previously)::\n {'code':\"<b>Some template code</b>\"\n 'attrs': {'name': \"a name\", 'description': \"a description\"}\n }\n\n :param filename: the filename of an format template\n :param with_attributes: if True, fetch the attributes (names and description) for format'\n @return: strucured content of format template\n \"\"\"\n _ = gettext_set_language(CFG_SITE_LANG)\n\n if not filename.endswith(\".\"+CFG_BIBFORMAT_FORMAT_TEMPLATE_EXTENSION) and \\\n not filename.endswith(\".xsl\"):\n return None\n\n # Get from cache whenever possible\n if filename in format_templates_cache:\n # If we must return with attributes and template exist in\n # cache with attributes then return cache.\n # Else reload with attributes\n if with_attributes and \\\n 'attrs' in format_templates_cache[filename]:\n return format_templates_cache[filename]\n\n format_template = {'code': \"\"}\n try:\n path = registry.format_templates_lookup[filename]\n\n format_file = open(path)\n format_content = format_file.read()\n format_file.close()\n\n # Load format template code\n # Remove name and description\n if filename.endswith(\".\"+CFG_BIBFORMAT_FORMAT_TEMPLATE_EXTENSION):\n code_and_description = pattern_format_template_name.sub(\"\",\n format_content, 1)\n code = pattern_format_template_desc.sub(\"\", code_and_description, 1)\n else:\n code = format_content\n\n format_template['code'] = code\n\n except:\n register_exception()\n\n # Save attributes if necessary\n if with_attributes:\n format_template['attrs'] = get_format_template_attrs(filename)\n\n # Cache and return\n format_templates_cache[filename] = format_template\n return format_template\n\n\ndef get_format_templates(with_attributes=False):\n \"\"\"\n Returns the list of all format templates, as dictionary with filenames as keys\n\n if 'with_attributes' is true, returns the name and description. Else 'attrs' is not\n returned as key in each dictionary (it might, if it has already been loaded previously)::\n\n [{'code':\"<b>Some template code</b>\"\n 'attrs': {'name': \"a name\", 'description': \"a description\"}\n },\n ...\n }\n\n :param with_attributes: if True, fetch the attributes (names and description) for formats\n @return: the list of format templates (with code and info)\n \"\"\"\n format_templates = {}\n\n for filename in registry.format_templates:\n if filename.endswith(\".\"+CFG_BIBFORMAT_FORMAT_TEMPLATE_EXTENSION) or \\\n filename.endswith(\".xsl\"):\n filename = os.path.basename(filename)\n format_templates[filename] = get_format_template(filename,\n with_attributes)\n\n return format_templates\n\ndef get_format_template_attrs(filename):\n \"\"\"\n Returns the attributes of the format template with given filename\n\n The attributes are {'name', 'description'}\n Caution: the function does not check that path exists or\n that the format element is valid.\n :param filename: the name of a format template\n @return: a structure with detailed information about given format template\n \"\"\"\n _ = gettext_set_language(CFG_SITE_LANG)\n attrs = {}\n attrs['name'] = \"\"\n attrs['description'] = \"\"\n try:\n template_file = open(registry.format_templates_lookup[filename])\n code = template_file.read()\n template_file.close()\n\n match = None\n if filename.endswith(\".xsl\"):\n # .xsl\n attrs['name'] = filename[:-4]\n else:\n # .bft\n match = pattern_format_template_name.search(code)\n if match is not None:\n attrs['name'] = match.group('name')\n else:\n attrs['name'] = filename\n\n\n match = pattern_format_template_desc.search(code)\n if match is not None:\n attrs['description'] = match.group('desc').rstrip('.')\n except Exception as e:\n try:\n raise InvenioBibFormatError(_('Could not read format template named %(filename)s. %(error)s.', filename=filename, error=str(e)))\n except InvenioBibFormatError:\n register_exception()\n\n attrs['name'] = filename\n\n return attrs\n\n\ndef get_format_element(element_name, verbose=0, with_built_in_params=False,\n soft_fail=False):\n \"\"\"\n Returns the format element structured content.\n\n Return None if element cannot be loaded (file not found, not readable or\n invalid)\n\n The returned structure is::\n {'attrs': {some attributes in dict. See get_format_element_attrs_from_*}\n 'code': the_function_code,\n 'type':\"field\" or \"python\" depending if element is defined in file or table,\n 'escape_function': the function to call to know if element output must be escaped}\n\n :param element_name: the name of the format element to load\n :param verbose: the level of verbosity from 0 to 9 (O: silent,\n 5: errors,\n 7: errors and warnings,\n 9: errors and warnings, stop if error (debug mode ))\n :param with_built_in_params: if True, load the parameters built in all elements\n @return: a dictionary with format element attributes\n \"\"\"\n _ = gettext_set_language(CFG_SITE_LANG)\n\n # Resolve filename and prepare 'name' as key for the cache\n filename = resolve_format_element_filename(element_name)\n if filename is not None:\n name = filename.upper()\n else:\n name = element_name.upper()\n\n if name in format_elements_cache:\n element = format_elements_cache[name]\n if not with_built_in_params or \\\n (with_built_in_params and\n 'builtin_params' in element['attrs']):\n return element\n\n if filename is None:\n # Element is maybe in tag table\n if bibformat_dblayer.tag_exists_for_name(element_name):\n format_element = {'attrs': get_format_element_attrs_from_table(\n element_name,\n with_built_in_params),\n 'code': None,\n 'escape_function': None,\n 'type': \"field\"}\n # Cache and returns\n format_elements_cache[name] = format_element\n return format_element\n\n elif soft_fail:\n register_exception()\n return None\n else:\n raise InvenioBibFormatError(\n _('Format element %(x_element_name)s could not be found.',\n x_element_name=element_name))\n\n else:\n format_element = {}\n\n module_name = filename\n if module_name.endswith(\".py\"):\n module_name = module_name[:-3]\n\n # Load function 'format_element()' inside element\n try:\n function_format = TEMPLATE_CONTEXT_FUNCTIONS_CACHE.\\\n bibformat_elements()[module_name]\n format_element['code'] = function_format\n except:\n if soft_fail:\n register_exception()\n return None\n else:\n raise\n\n # Load function 'escape_values()' inside element\n format_element['escape_function'] = function_format._escape_values\n\n # Prepare, cache and return\n format_element['attrs'] = get_format_element_attrs_from_function(\n function_format,\n element_name,\n with_built_in_params)\n format_element['type'] = \"python\"\n format_elements_cache[name] = format_element\n return format_element\n\ndef get_format_elements(with_built_in_params=False):\n \"\"\"\n Returns the list of format elements attributes as dictionary structure\n\n Elements declared in files have priority over element declared in 'tag' table\n The returned object has this format::\n {element_name1: {'attrs': {'description':..., 'seealso':...\n 'params':[{'name':..., 'default':..., 'description':...}, ...]\n 'builtin_params':[{'name':..., 'default':..., 'description':...}, ...]\n },\n 'code': code_of_the_element\n },\n element_name2: {...},\n ...}\n\n Returns only elements that could be loaded (not error in code)\n\n @return: a dict of format elements with name as key, and a dict as attributes\n :param with_built_in_params: if True, load the parameters built in all elements\n \"\"\"\n format_elements = {}\n\n mappings = bibformat_dblayer.get_all_name_tag_mappings()\n\n for name in mappings:\n format_elements[name.upper().replace(\" \", \"_\").strip()] = get_format_element(name, with_built_in_params=with_built_in_params)\n\n for module in registry.format_elements:\n filename = os.path.basename(module.__file__)\n filename_test = filename.upper().replace(\" \", \"_\")\n if filename_test.endswith(\".PYC\"):\n filename_test = filename_test[:-1]\n if filename_test.endswith(\".PY\") and not filename.upper().startswith(\"__INIT__.PY\"):\n if filename_test.startswith(\"BFE_\"):\n filename_test = filename_test[4:]\n element_name = filename_test[:-3]\n element = get_format_element(element_name,\n with_built_in_params=with_built_in_params,\n soft_fail=True)\n if element is not None:\n format_elements[element_name] = element\n\n return format_elements\n\ndef get_format_element_attrs_from_function(function, element_name,\n with_built_in_params=False):\n \"\"\"\n Returns the attributes of the function given as parameter.\n\n It looks for standard parameters of the function, default\n values and comments in the docstring.\n\n The attributes are::\n {'name' : \"name of element\" #basically the name of 'name' parameter\n 'description': \"a string description of the element\",\n 'seealso' : [\"element_1.py\", \"element_2.py\", ...] #a list of related elements\n 'params': [{'name':\"param_name\", #a list of parameters for this element (except 'bfo')\n 'default':\"default value\",\n 'description': \"a description\"}, ...],\n 'builtin_params': {name: {'name':\"param_name\",#the parameters builtin for all elem of this kind\n 'default':\"default value\",\n 'description': \"a description\"}, ...},\n }\n :param function: the formatting function of a format element\n :param element_name: the name of the element\n :param with_built_in_params: if True, load the parameters built in all elements\n @return: a structure with detailed information of a function\n \"\"\"\n\n attrs = {}\n attrs['description'] = \"\"\n attrs['name'] = element_name.replace(\" \", \"_\").upper()\n attrs['seealso'] = []\n\n docstring = function.__doc__\n if isinstance(docstring, str):\n # Look for function description in docstring\n #match = pattern_format_element_desc.search(docstring)\n description = docstring.split(\"@param\")[0]\n description = description.split(\"@see:\")[0]\n attrs['description'] = description.strip().rstrip('.')\n\n # Look for @see: in docstring\n match = pattern_format_element_seealso.search(docstring)\n if match is not None:\n elements = match.group('see').rstrip('.').split(\",\")\n for element in elements:\n attrs['seealso'].append(element.strip())\n\n params = {}\n # Look for parameters in function definition\n args, dummy_varargs, dummy_varkw, defaults = inspect.getargspec(function)\n\n # Prepare args and defaults_list such that we can have a mapping\n # from args to defaults\n args.reverse()\n if defaults is not None:\n defaults_list = list(defaults)\n defaults_list.reverse()\n else:\n defaults_list = []\n\n for arg, default in map(None, args, defaults_list):\n if arg == \"bfo\":\n #Don't keep this as parameter. It is hidden to users, and\n #exists in all elements of this kind\n continue\n param = {}\n param['name'] = arg\n if default is None:\n #In case no check is made inside element, we prefer to\n #print \"\" (nothing) than None in output\n param['default'] = \"\"\n else:\n param['default'] = default\n param['description'] = \"(no description provided)\"\n\n params[arg] = param\n\n if isinstance(docstring, str):\n # Look for AT param descriptions in docstring.\n # Add description to existing parameters in params dict\n params_iterator = pattern_format_element_params.finditer(docstring)\n for match in params_iterator:\n name = match.group('name')\n if name in params:\n params[name]['description'] = match.group('desc').rstrip('.')\n\n attrs['params'] = params.values()\n\n # Load built-in parameters if necessary\n if with_built_in_params:\n\n builtin_params = []\n # Add 'prefix' parameter\n param_prefix = {}\n param_prefix['name'] = \"prefix\"\n param_prefix['default'] = \"\"\n param_prefix['description'] = \"\"\"A prefix printed only if the\n record has a value for this element\"\"\"\n builtin_params.append(param_prefix)\n\n # Add 'suffix' parameter\n param_suffix = {}\n param_suffix['name'] = \"suffix\"\n param_suffix['default'] = \"\"\n param_suffix['description'] = \"\"\"A suffix printed only if the\n record has a value for this element\"\"\"\n builtin_params.append(param_suffix)\n\n # Add 'default' parameter\n param_default = {}\n param_default['name'] = \"default\"\n param_default['default'] = \"\"\n param_default['description'] = \"\"\"A default value printed if the\n record has no value for this element\"\"\"\n builtin_params.append(param_default)\n\n # Add 'escape' parameter\n param_escape = {}\n param_escape['name'] = \"escape\"\n param_escape['default'] = \"\"\n param_escape['description'] = \"\"\"0 keeps value as it is. Refer to main\n documentation for escaping modes\n 1 to 7\"\"\"\n builtin_params.append(param_escape)\n\n attrs['builtin_params'] = builtin_params\n\n return attrs\n\ndef get_format_element_attrs_from_table(element_name,\n with_built_in_params=False):\n \"\"\"\n Returns the attributes of the format element with given name in 'tag' table.\n\n Returns None if element_name does not exist in tag table.\n\n The attributes are::\n {'name' : \"name of element\" #basically the name of 'element_name' parameter\n 'description': \"a string description of the element\",\n 'seealso' : [] #a list of related elements. Always empty in this case\n 'params': [], #a list of parameters for this element. Always empty in this case\n 'builtin_params': [{'name':\"param_name\", #the parameters builtin for all elem of this kind\n 'default':\"default value\",\n 'description': \"a description\"}, ...],\n 'tags':[\"950.1\", 203.a] #the list of tags printed by this element\n }\n\n :param element_name: an element name in database\n :param element_name: the name of the element\n :param with_built_in_params: if True, load the parameters built in all elements\n @return: a structure with detailed information of an element found in DB\n \"\"\"\n\n attrs = {}\n tags = bibformat_dblayer.get_tags_from_name(element_name)\n field_label = \"field\"\n if len(tags)>1:\n field_label = \"fields\"\n\n attrs['description'] = \"Prints %s %s of the record\" % (field_label,\n \", \".join(tags))\n attrs['name'] = element_name.replace(\" \", \"_\").upper()\n attrs['seealso'] = []\n attrs['params'] = []\n attrs['tags'] = tags\n\n # Load built-in parameters if necessary\n if with_built_in_params:\n builtin_params = []\n\n # Add 'prefix' parameter\n param_prefix = {}\n param_prefix['name'] = \"prefix\"\n param_prefix['default'] = \"\"\n param_prefix['description'] = \"\"\"A prefix printed only if the\n record has a value for this element\"\"\"\n builtin_params.append(param_prefix)\n\n # Add 'suffix' parameter\n param_suffix = {}\n param_suffix['name'] = \"suffix\"\n param_suffix['default'] = \"\"\n param_suffix['description'] = \"\"\"A suffix printed only if the\n record has a value for this element\"\"\"\n builtin_params.append(param_suffix)\n\n # Add 'separator' parameter\n param_separator = {}\n param_separator['name'] = \"separator\"\n param_separator['default'] = \" \"\n param_separator['description'] = \"\"\"A separator between elements of\n the field\"\"\"\n builtin_params.append(param_separator)\n\n # Add 'nbMax' parameter\n param_nbMax = {}\n param_nbMax['name'] = \"nbMax\"\n param_nbMax['default'] = \"\"\n param_nbMax['description'] = \"\"\"The maximum number of values to\n print for this element. No limit if not\n specified\"\"\"\n builtin_params.append(param_nbMax)\n\n # Add 'default' parameter\n param_default = {}\n param_default['name'] = \"default\"\n param_default['default'] = \"\"\n param_default['description'] = \"\"\"A default value printed if the\n record has no value for this element\"\"\"\n builtin_params.append(param_default)\n\n # Add 'escape' parameter\n param_escape = {}\n param_escape['name'] = \"escape\"\n param_escape['default'] = \"\"\n param_escape['description'] = \"\"\"If set to 1, replaces special\n characters '&', '<' and '>' of this\n element by SGML entities\"\"\"\n builtin_params.append(param_escape)\n\n attrs['builtin_params'] = builtin_params\n\n return attrs\n\ndef get_output_format(code, with_attributes=False, verbose=0):\n \"\"\"\n Returns the structured content of the given output format\n\n If 'with_attributes' is true, also returns the names and description of the output formats,\n else 'attrs' is not returned in dict (it might, if it has already been loaded previously).\n\n if output format corresponding to 'code' is not found return an empty structure.\n\n See get_output_format_attrs() to learn more about the attributes::\n\n {'rules': [ {'field': \"980__a\",\n 'value': \"PREPRINT\",\n 'template': \"filename_a.bft\",\n },\n {...}\n ],\n 'attrs': {'names': {'generic':\"a name\", 'sn':{'en': \"a name\", 'fr':\"un nom\"}, 'ln':{'en':\"a long name\"}}\n 'description': \"a description\"\n 'code': \"fnm1\",\n 'content_type': \"application/ms-excel\",\n 'visibility': 1\n }\n 'default':\"filename_b.bft\"\n }\n\n :param code: the code of an output_format\n :param with_attributes: if True, fetch the attributes (names and description) for format\n :param verbose: the level of verbosity from 0 to 9 (O: silent,\n 5: errors,\n 7: errors and warnings,\n 9: errors and warnings, stop if error (debug mode ))\n @return: strucured content of output format\n \"\"\"\n _ = gettext_set_language(CFG_SITE_LANG)\n output_format = {'rules': [], 'default': \"\"}\n filename = resolve_output_format_filename(code, verbose)\n\n if filename is None:\n try:\n raise InvenioBibFormatError(_('Output format with code %(code)s could not be found.', code=code))\n except InvenioBibFormatError:\n register_exception()\n\n if with_attributes: #Create empty attrs if asked for attributes\n output_format['attrs'] = get_output_format_attrs(code, verbose)\n return output_format\n\n # Get from cache whenever possible\n if filename in format_outputs_cache:\n # If was must return with attributes but cache has not\n # attributes, then load attributes\n if with_attributes and 'attrs' not in format_outputs_cache[filename]:\n format_outputs_cache[filename]['attrs'] = get_output_format_attrs(code, verbose)\n\n return format_outputs_cache[filename]\n\n try:\n if with_attributes:\n output_format['attrs'] = get_output_format_attrs(code, verbose)\n\n path = registry.output_formats_lookup[filename]\n format_file = open(path)\n\n current_tag = ''\n for line in format_file:\n line = line.strip()\n if line == \"\":\n # Ignore blank lines\n continue\n if line.endswith(\":\"):\n # Retrieve tag\n\n # Remove : spaces and eol at the end of line\n clean_line = line.rstrip(\": \\n\\r\")\n # The tag starts at second position\n current_tag = \"\".join(clean_line.split()[1:]).strip()\n elif line.find('---') != -1:\n words = line.split('---')\n template = words[-1].strip()\n condition = ''.join(words[:-1])\n\n output_format['rules'].append({'field': current_tag,\n 'value': condition,\n 'template': template,\n })\n\n elif line.find(':') != -1:\n # Default case\n default = line.split(':')[1].strip()\n output_format['default'] = default\n\n except:\n register_exception()\n\n # Cache and return\n format_outputs_cache[filename] = output_format\n return output_format\n\n\ndef get_output_format_attrs(code, verbose=0):\n \"\"\"Return the attributes of an output format.\n\n The attributes contain 'code', which is the short identifier of the output\n format (to be given as parameter in format_record function to specify the\n output format), 'description', a description of the output format,\n 'visibility' the visibility of the format in the output format list on\n public pages and 'names', the localized names of the output format. If\n 'content_type' is specified then the search_engine will send a file with\n this content type and with result of formatting as content to the user.\n The 'names' dict always contais 'generic', 'ln' (for long name) and 'sn'\n (for short names) keys. 'generic' is the default name for output format.\n 'ln' and 'sn' contain long and short localized names of the output format.\n Only the languages for which a localization exist are used::\n\n {'names': {'generic':\"a name\", 'sn':{'en': \"a name\", 'fr':\"un nom\"},\n 'ln':{'en':\"a long name\"}}\n 'description': \"a description\"\n 'code': \"fnm1\",\n 'content_type': \"application/ms-excel\",\n 'visibility': 1\n }\n\n :param code: the short identifier of the format\n :param verbose: the level of verbosity from 0 to 9 (O: silent,\n 5: errors, 7: errors and warnings,\n 9: errors and warnings, stop if error (debug mode ))\n :return: strucured content of output format attributes\n \"\"\"\n if code.endswith(\".\"+CFG_BIBFORMAT_FORMAT_OUTPUT_EXTENSION):\n code = code[:-(len(CFG_BIBFORMAT_FORMAT_OUTPUT_EXTENSION) + 1)]\n attrs = {'names': {'generic': \"\",\n 'ln': {},\n 'sn': {}},\n 'description': '',\n 'code': code.upper(),\n 'content_type': \"\",\n 'visibility': 1}\n\n filename = resolve_output_format_filename(code, verbose)\n if filename is None:\n return attrs\n\n try:\n format_ = Format.query.filter_by(code=code).one()\n attrs['names']['generic'] = format_.name\n for name in format_.names:\n attrs['names'][name.type][name.ln] = name.value\n attrs['description'] = format_.description\n attrs['content_type'] = format_.content_type\n attrs['visibility'] = format_.visibility\n except Exception:\n current_app.logger.exception(\"Unknown code %s\", code)\n return attrs\n\n\ndef get_output_formats(with_attributes=False):\n \"\"\"\n Return all output format as a dictionary with their filename as key.\n\n If 'with_attributes' is true, also returns the names and description of the\n output formats, else 'attrs' is not returned in dicts (it might, if it has\n already been loaded previously).\n\n See get_output_format_attrs() to learn more on the attributes::\n\n {'filename_1.bfo': {'rules': [ {'field': \"980__a\",\n 'value': \"PREPRINT\",\n 'template': \"filename_a.bft\",\n },\n {...}\n ],\n 'attrs': {'names': {'generic':\"a name\", 'sn':{'en': \"a name\", 'fr':\"un nom\"}, 'ln':{'en':\"a long name\"}}\n 'description': \"a description\"\n 'code': \"fnm1\"\n }\n 'default':\"filename_b.bft\"\n },\n\n 'filename_2.bfo': {...},\n ...\n }\n :param with_attributes: if returned output formats contain detailed info, or not\n @type with_attributes: boolean\n @return: the list of output formats\n \"\"\"\n output_formats = {}\n\n for filename in registry.output_formats_lookup.values():\n filename = os.path.basename(filename)\n if filename.endswith(\".\"+CFG_BIBFORMAT_FORMAT_OUTPUT_EXTENSION):\n code = \"\".join(filename.split(\".\")[:-1])\n if filename in output_formats:\n continue\n output_formats[filename] = get_output_format(code, with_attributes)\n\n return output_formats\n\ndef resolve_format_element_filename(element_name):\n \"\"\"\n Returns the filename of element corresponding to x{element_name}\n\n This is necessary since format templates code call\n elements by ignoring case, for eg. <BFE_AUTHOR> is the\n same as <BFE_author>.\n It is also recommended that format elements filenames are\n prefixed with bfe_ . We need to look for these too.\n\n The name of the element has to start with \"BFE_\".\n\n :param element_name: a name for a format element\n @return: the corresponding filename, with right case\n \"\"\"\n\n if not element_name.endswith(\".py\"):\n name = element_name.replace(\" \", \"_\").upper() +\".PY\"\n else:\n name = element_name.replace(\" \", \"_\").upper()\n\n files = registry.format_elements\n\n for element in files:\n filename = element.__file__\n if filename.endswith('.pyc'):\n filename = filename[:-1]\n basename = os.path.basename(filename)\n\n test_filename = basename.replace(\" \", \"_\").upper()\n\n if test_filename == name or \\\n test_filename == \"BFE_\" + name or \\\n \"BFE_\" + test_filename == name:\n return basename\n\n # No element with that name found\n # Do not log error, as it might be a normal execution case:\n # element can be in database\n return None\n\ndef resolve_output_format_filename(code, verbose=0):\n \"\"\"\n Returns the filename of output corresponding to code\n\n This is necessary since output formats names are not case sensitive\n but most file systems are.\n\n :param code: the code for an output format\n :param verbose: the level of verbosity from 0 to 9 (O: silent,\n 5: errors,\n 7: errors and warnings,\n 9: errors and warnings, stop if error (debug mode ))\n @return: the corresponding filename, with right case, or None if not found\n \"\"\"\n _ = gettext_set_language(CFG_SITE_LANG)\n #Remove non alphanumeric chars (except . and _)\n code = re.sub(r\"[^.0-9a-zA-Z_]\", \"\", code)\n if not code.endswith(\".\"+CFG_BIBFORMAT_FORMAT_OUTPUT_EXTENSION):\n code = re.sub(r\"\\W\", \"\", code)\n code += \".\"+CFG_BIBFORMAT_FORMAT_OUTPUT_EXTENSION\n code = code.upper()\n for filename in registry.output_formats_lookup.keys():\n if filename.upper() == code:\n return filename\n\n # No output format with that name found\n raise InvenioBibFormatError(_('Could not find output format named %(x_code)s.', x_code=code))\n\n if verbose >= 5:\n sys.stderr.write(exc.message)\n if verbose >= 9:\n sys.exit(exc.message)\n return None\n\ndef get_fresh_format_template_filename(name):\n \"\"\"\n Returns a new filename and name for template with given name.\n\n Used when writing a new template to a file, so that the name\n has no space, is unique in template directory\n\n Returns (unique_filename, modified_name)\n\n :param name: name for a format template\n @return: the corresponding filename, and modified name if necessary\n \"\"\"\n #name = re.sub(r\"\\W\", \"\", name) #Remove non alphanumeric chars\n name = name.replace(\" \", \"_\")\n filename = name\n # Remove non alphanumeric chars (except .)\n filename = re.sub(r\"[^.0-9a-zA-Z]\", \"\", filename)\n index = 1\n\n def _get_fullname(filename):\n return filename + '.' + CFG_BIBFORMAT_FORMAT_TEMPLATE_EXTENSION\n\n while _get_fullname(filename) in registry.format_templates_lookup:\n index += 1\n filename = name + str(index)\n\n if index > 1:\n returned_name = (name + str(index)).replace(\"_\", \" \")\n else:\n returned_name = name.replace(\"_\", \" \")\n\n return (_get_fullname(filename), returned_name)\n\ndef get_fresh_output_format_filename(code):\n \"\"\"\n Returns a new filename for output format with given code.\n\n Used when writing a new output format to a file, so that the code\n has no space, is unique in output format directory. The filename\n also need to be at most 6 chars long, as the convention is that\n filename == output format code (+ .extension)\n We return an uppercase code\n Returns (unique_filename, modified_code)\n\n :param code: the code of an output format\n @return: the corresponding filename, and modified code if necessary\n \"\"\"\n _ = gettext_set_language(CFG_SITE_LANG)\n #code = re.sub(r\"\\W\", \"\", code) #Remove non alphanumeric chars\n code = code.upper().replace(\" \", \"_\")\n # Remove non alphanumeric chars (except . and _)\n code = re.sub(r\"[^.0-9a-zA-Z_]\", \"\", code)\n if len(code) > 6:\n code = code[:6]\n\n def _get_fullname(filename):\n return filename + '.' + CFG_BIBFORMAT_FORMAT_OUTPUT_EXTENSION\n\n filename = code\n index = 2\n while _get_fullname(filename) in registry.output_formats_lookup:\n filename = code + str(index)\n if len(filename) > 6:\n filename = code[:-(len(str(index)))]+str(index)\n index += 1\n # We should not try more than 99999... Well I don't see how we\n # could get there.. Sanity check.\n if index >= 99999:\n try:\n raise InvenioBibFormatError(_('Could not find a fresh name for output format %(x_code)s.', x_code=code))\n except InvenioBibFormatError:\n register_exception()\n\n sys.exit(\"Output format cannot be named as %s\" % code)\n\n return (filename + \".\" + CFG_BIBFORMAT_FORMAT_OUTPUT_EXTENSION, filename)\n\ndef clear_caches():\n \"\"\"\n Clear the caches (Output Format, Format Templates and Format Elements).\n\n @return: None\n \"\"\"\n global format_templates_cache, format_elements_cache, format_outputs_cache\n format_templates_cache = {}\n format_elements_cache = {}\n format_outputs_cache = {}\n\nclass BibFormatObject(object):\n \"\"\"\n An object that encapsulates a record and associated methods, and that is given\n as parameter to all format elements 'format' function.\n The object is made specifically for a given formatting, i.e. it includes\n for example the language for the formatting.\n\n The object provides basic accessors to the record. For full access, one can get\n the record with get_record() and then use BibRecord methods on the returned object.\n \"\"\"\n # The record\n record = None\n\n # The language in which the formatting has to be done\n lang = CFG_SITE_LANG\n\n # A list of string describing the context in which the record has\n # to be formatted.\n # It represents the words of the user request in web interface search\n search_pattern = []\n\n # The id of the record\n recID = 0\n\n # The information about the user, as returned by\n # 'webuser.collect_user_info(req)'\n user_info = None\n\n # The format in which the record is being formatted\n output_format = ''\n\n req = None # DEPRECATED: use bfo.user_info instead. Used by WebJournal.\n\n def __init__(self, recID, ln=CFG_SITE_LANG, search_pattern=None,\n xml_record=None, user_info=None, output_format=''):\n \"\"\"\n Creates a new bibformat object, with given record.\n\n You can either specify an record ID to format, or give its xml representation.\n if 'xml_record' is not None, use 'xml_record' instead of recID for the record.\n\n 'user_info' allows to grant access to some functionalities on\n a page depending on the user's priviledges. It is a dictionary\n in the following form::\n\n user_info = {\n 'remote_ip' : '',\n 'remote_host' : '',\n 'referer' : '',\n 'uri' : '',\n 'agent' : '',\n 'uid' : -1,\n 'nickname' : '',\n 'email' : '',\n 'group' : [],\n 'guest' : '1'\n }\n\n :param recID: the id of a record\n :param ln: the language in which the record has to be formatted\n :param search_pattern: list of string representing the request used by the user in web interface\n :param xml_record: a xml string of the record to format\n :param user_info: the information of the user who will view the formatted page\n :param output_format: the output_format used for formatting this record\n \"\"\"\n self.xml_record = None # *Must* remain empty if recid is given\n if xml_record is not None:\n # If record is given as parameter\n self.xml_record = xml_record\n self.record = create_record(xml_record)[0]\n recID = record_get_field_value(self.record, \"001\") or None\n\n try:\n assert isinstance(recID, (int, long, type(None))), 'Argument of wrong type!'\n except AssertionError:\n register_exception(prefix=\"recid needs to be an integer in BibFormatObject\",\n alert_admin=True)\n recID = int(recID)\n self.recID = recID\n self.lang = wash_language(ln)\n if search_pattern is None:\n search_pattern = []\n self.search_pattern = search_pattern\n self.output_format = output_format\n self.user_info = user_info\n if self.user_info is None:\n from invenio.ext.login.legacy_user import UserInfo\n self.user_info = UserInfo(None)\n\n def get_record(self):\n \"\"\"\n Returns the record structure of this L{BibFormatObject} instance\n\n @return: the record structure as defined by BibRecord library\n \"\"\"\n from invenio.legacy.search_engine import get_record\n\n # Create record if necessary\n if self.record is None:\n # on-the-fly creation if current output is xm\n self.record = get_record(self.recID)\n\n return self.record\n\n def control_field(self, tag, escape=0):\n \"\"\"\n Returns the value of control field given by tag in record\n\n :param tag: the marc code of a field\n :param escape: 1 if returned value should be escaped. Else 0.\n @return: value of field tag in record\n \"\"\"\n if self.get_record() is None:\n #Case where BibRecord could not parse object\n return ''\n\n p_tag = parse_tag(tag)\n field_value = record_get_field_value(self.get_record(),\n p_tag[0],\n p_tag[1],\n p_tag[2],\n p_tag[3])\n if escape == 0:\n return field_value\n else:\n return escape_field(field_value, escape)\n\n def field(self, tag, escape=0):\n \"\"\"\n Returns the value of the field corresponding to tag in the\n current record.\n\n If the value does not exist, return empty string. Else\n returns the same as bfo.fields(..)[0] (see docstring below).\n\n 'escape' parameter allows to escape special characters\n of the field. The value of escape can be:\n 0. no escaping\n 1. escape all HTML characters\n 2. remove unsafe HTML tags (Eg. keep <br />)\n 3. Mix of mode 1 and 2. If value of field starts with\n <!-- HTML -->, then use mode 2. Else use mode 1.\n 4. Remove all HTML tags\n 5. Same as 2, with more tags allowed (like <img>)\n 6. Same as 3, with more tags allowed (like <img>)\n 7. Mix of mode 0 and mode 1. If field_value\n starts with <!--HTML-->, then use mode 0.\n Else use mode 1.\n 8. Same as mode 1, but also escape double-quotes\n 9. Same as mode 4, but also escape double-quotes\n\n :param tag: the marc code of a field\n :param escape: 1 if returned value should be escaped. Else 0. (see above for other modes)\n @return: value of field tag in record\n \"\"\"\n list_of_fields = self.fields(tag)\n if len(list_of_fields) > 0:\n # Escaping below\n if escape == 0:\n return list_of_fields[0]\n else:\n return escape_field(list_of_fields[0], escape)\n else:\n return \"\"\n\n def fields(self, tag, escape=0, repeatable_subfields_p=False):\n \"\"\"\n Returns the list of values corresonding to \"tag\".\n\n If tag has an undefined subcode (such as 999C5),\n the function returns a list of dictionaries, whoose keys\n are the subcodes and the values are the values of tag.subcode.\n If the tag has a subcode, simply returns list of values\n corresponding to tag.\n Eg. for given MARC::\n 999C5 $a value_1a $b value_1b\n 999C5 $b value_2b\n 999C5 $b value_3b $b value_3b_bis\n\n >>> bfo.fields('999C5b')\n >>> ['value_1b', 'value_2b', 'value_3b', 'value_3b_bis']\n >>> bfo.fields('999C5')\n >>> [{'a':'value_1a', 'b':'value_1b'},\n {'b':'value_2b'},\n {'b':'value_3b'}]\n\n By default the function returns only one value for each\n subfield (that is it considers that repeatable subfields are\n not allowed). It is why in the above example 'value3b_bis' is\n not shown for bfo.fields('999C5'). (Note that it is not\n defined which of value_3b or value_3b_bis is returned). This\n is to simplify the use of the function, as most of the time\n subfields are not repeatable (in that way we get a string\n instead of a list). You can allow repeatable subfields by\n setting 'repeatable_subfields_p' parameter to True. In\n this mode, the above example would return:\n >>> bfo.fields('999C5b', repeatable_subfields_p=True)\n >>> ['value_1b', 'value_2b', 'value_3b']\n >>> bfo.fields('999C5', repeatable_subfields_p=True)\n >>> [{'a':['value_1a'], 'b':['value_1b']},\n {'b':['value_2b']},\n {'b':['value_3b', 'value3b_bis']}]\n\n NOTICE THAT THE RETURNED STRUCTURE IS DIFFERENT. Also note\n that whatever the value of 'repeatable_subfields_p' is,\n bfo.fields('999C5b') always show all fields, even repeatable\n ones. This is because the parameter has no impact on the\n returned structure (it is always a list).\n\n 'escape' parameter allows to escape special characters\n of the fields. The value of escape can be:\n 0. No escaping\n 1. Escape all HTML characters\n 2. Remove unsafe HTML tags (Eg. keep <br />)\n 3. Mix of mode 1 and 2. If value of field starts with\n <!-- HTML -->, then use mode 2. Else use mode 1.\n 4. Remove all HTML tags\n 5. Same as 2, with more tags allowed (like <img>)\n 6. Same as 3, with more tags allowed (like <img>)\n 7. Mix of mode 0 and mode 1. If field_value\n starts with <!--HTML-->, then use mode 0.\n Else use mode 1.\n 8. Same as mode 1, but also escape double-quotes\n 9. Same as mode 4, but also escape double-quotes\n\n :param tag: the marc code of a field\n :param escape: 1 if returned values should be escaped. Else 0.\n @repeatable_subfields_p if True, returns the list of subfields in the dictionary\n @return: values of field tag in record\n \"\"\"\n\n if self.get_record() is None:\n # Case where BibRecord could not parse object\n return []\n\n p_tag = parse_tag(tag)\n if p_tag[3] != \"\":\n # Subcode has been defined. Simply returns list of values\n values = record_get_field_values(self.get_record(),\n p_tag[0],\n p_tag[1],\n p_tag[2],\n p_tag[3])\n if escape == 0:\n return values\n else:\n return [escape_field(value, escape) for value in values]\n\n else:\n # Subcode is undefined. Returns list of dicts.\n # However it might be the case of a control field.\n\n instances = record_get_field_instances(self.get_record(),\n p_tag[0],\n p_tag[1],\n p_tag[2])\n if repeatable_subfields_p:\n list_of_instances = []\n for instance in instances:\n instance_dict = {}\n for subfield in instance[0]:\n if subfield[0] not in instance_dict:\n instance_dict[subfield[0]] = []\n if escape == 0:\n instance_dict[subfield[0]].append(subfield[1])\n else:\n instance_dict[subfield[0]].append(escape_field(subfield[1], escape))\n list_of_instances.append(instance_dict)\n return list_of_instances\n else:\n if escape == 0:\n return [dict(instance[0]) for instance in instances]\n else:\n return [dict([(subfield[0], escape_field(subfield[1], escape))\n for subfield in instance[0]])\n for instance in instances]\n\n def kb(self, kb, string, default=\"\"):\n \"\"\"\n Returns the value of the \"string\" in the knowledge base \"kb\".\n\n If kb does not exist or string does not exist in kb,\n returns 'default' string or empty string if not specified.\n\n :param kb: a knowledge base name\n :param string: the string we want to translate\n :param default: a default value returned if 'string' not found in 'kb'\n @return: a string value corresponding to translated input with given kb\n \"\"\"\n if not string:\n return default\n\n val = get_kbr_values(kb, searchkey=string, searchtype='e')\n\n try:\n return val[0][0]\n except IndexError:\n return default\n\n\n# Utility functions\n#\n\n\ndef escape_field(value, mode=0):\n \"\"\"\n Utility function used to escape the value of a field in given mode.\n\n - mode 0: no escaping\n - mode 1: escaping all HTML/XML characters (escaped chars are shown as escaped)\n - mode 2: escaping unsafe HTML tags to avoid XSS, but\n keep basic one (such as <br />)\n Escaped tags are removed.\n - mode 3: mix of mode 1 and mode 2. If field_value starts with <!--HTML-->,\n then use mode 2. Else use mode 1.\n - mode 4: escaping all HTML/XML tags (escaped tags are removed)\n - mode 5: same as 2, but allows more tags, like <img>\n - mode 6: same as 3, but allows more tags, like <img>\n - mode 7: mix of mode 0 and mode 1. If field_value starts with <!--HTML-->,\n then use mode 0. Else use mode 1.\n - mode 8: same as mode 1, but also escape double-quotes\n - mode 9: same as mode 4, but also escape double-quotes\n\n :param value: value to escape\n :param mode: escaping mode to use\n @return: an escaped version of X{value} according to chosen X{mode}\n \"\"\"\n if mode == 1:\n return cgi.escape(value)\n elif mode == 8:\n return cgi.escape(value, True)\n elif mode in [2, 5]:\n allowed_attribute_whitelist = CFG_HTML_BUFFER_ALLOWED_ATTRIBUTE_WHITELIST\n allowed_tag_whitelist = CFG_HTML_BUFFER_ALLOWED_TAG_WHITELIST + \\\n ('class',)\n if mode == 5:\n allowed_attribute_whitelist += ('src', 'alt',\n 'width', 'height',\n 'style', 'summary',\n 'border', 'cellspacing',\n 'cellpadding')\n allowed_tag_whitelist += ('img', 'table', 'td',\n 'tr', 'th', 'span', 'caption')\n try:\n return washer.wash(value,\n allowed_attribute_whitelist=\n allowed_attribute_whitelist,\n allowed_tag_whitelist=\n allowed_tag_whitelist\n )\n except HTMLParseError:\n # Parsing failed\n return cgi.escape(value)\n elif mode in [3, 6]:\n if value.lstrip(' \\n').startswith(html_field):\n allowed_attribute_whitelist = CFG_HTML_BUFFER_ALLOWED_ATTRIBUTE_WHITELIST\n allowed_tag_whitelist = CFG_HTML_BUFFER_ALLOWED_TAG_WHITELIST + \\\n ('class',)\n if mode == 6:\n allowed_attribute_whitelist += ('src', 'alt',\n 'width', 'height',\n 'style', 'summary',\n 'border', 'cellspacing',\n 'cellpadding')\n allowed_tag_whitelist += ('img', 'table', 'td',\n 'tr', 'th', 'span', 'caption')\n try:\n return washer.wash(value,\n allowed_attribute_whitelist=\n allowed_attribute_whitelist,\n allowed_tag_whitelist=\n allowed_tag_whitelist\n )\n except HTMLParseError:\n # Parsing failed\n return cgi.escape(value)\n else:\n return cgi.escape(value)\n elif mode in [4, 9]:\n try:\n out = washer.wash(value,\n allowed_attribute_whitelist=[],\n allowed_tag_whitelist=[]\n )\n if mode == 9:\n out = out.replace('\"', '"')\n return out\n except HTMLParseError:\n # Parsing failed\n if mode == 4:\n return cgi.escape(value)\n else:\n return cgi.escape(value, True)\n elif mode == 7:\n if value.lstrip(' \\n').startswith(html_field):\n return value\n else:\n return cgi.escape(value)\n else:\n return value\n\n\ndef make_filter_line(hide_tag):\n \"\"\"Generate a line used for filtering MARCXML.\"\"\"\n hide_tag = str(hide_tag)\n tag = hide_tag[:3]\n ind1 = hide_tag[3:4]\n ind2 = hide_tag[4:5]\n\n if ind1 == \"_\":\n ind1 = \" \"\n if ind2 == \"_\":\n ind2 = \" \"\n\n if not ind1 and not ind2:\n return 'datafield tag=\"%s\"' % tag\n if not ind2 and ind1:\n return 'datafield tag=\"%s\" ind1=\"%s\"' % (tag, ind1)\n return 'datafield tag=\"%s\" ind1=\"%s\" ind2=\"%s\"' % (tag, ind1, ind2)\n\n\ndef filter_hidden_fields(recxml, user_info=None, filter_tags=None,\n force_filtering=False):\n \"\"\"\n Filter out tags specified by filter_tags from MARCXML.\n\n If the user is allowed to run bibedit, then filter nothing, unless\n force_filtering is set to True.\n\n :param recxml: marcxml presentation of the record\n :param user_info: user information; if None, then assume invoked via CLI\n with all rights :param filter_tags: list of MARC tags to\n be filtered :param force_filtering: do we force filtering\n regardless of user rights?\n :return: recxml without the hidden fields\n \"\"\"\n filter_tags = filter_tags or cfg['CFG_BIBFORMAT_HIDDEN_TAGS']\n if force_filtering:\n pass\n else:\n if user_info is None:\n #by default\n return recxml\n else:\n if (acc_authorize_action(user_info, 'runbibedit')[0] == 0):\n #no need to filter\n return recxml\n #filter..\n out = \"\"\n omit = False\n filter_lines = map(make_filter_line, filter_tags)\n for line in recxml.splitlines(True):\n #check if this block needs to be omitted\n for htag in filter_lines:\n if htag in line:\n omit = True\n if not omit:\n out += line\n if omit and ('</datafield>' in line or '</marc:datafield>' in line):\n omit = False\n return out\n"},"domain":{"kind":"string","value":"codeparrot/github-code-clean"}}},{"rowIdx":227199,"cells":{"text":{"kind":"string","value":"# $ANTLR 3.5.1 /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g 2016-03-02 22:50:02\n\nimport sys\nfrom antlr3 import *\nfrom antlr3.compat import set, frozenset\n\n\n\n# for convenience in actions\nHIDDEN = BaseRecognizer.HIDDEN\n\n# token types\nEOF=-1\nT__11=11\nT__12=12\nT__13=13\nT__14=14\nT__15=15\nT__16=16\nT__17=17\nT__18=18\nT__19=19\nT__20=20\nT__21=21\nT__22=22\nT__23=23\nT__24=24\nT__25=25\nT__26=26\nT__27=27\nT__28=28\nT__29=29\nT__30=30\nT__31=31\nT__32=32\nT__33=33\nT__34=34\nT__35=35\nT__36=36\nT__37=37\nT__38=38\nT__39=39\nT__40=40\nT__41=41\nT__42=42\nT__43=43\nT__44=44\nT__45=45\nT__46=46\nT__47=47\nT__48=48\nT__49=49\nT__50=50\nT__51=51\nT__52=52\nT__53=53\nT__54=54\nT__55=55\nT__56=56\nT__57=57\nT__58=58\nT__59=59\nT__60=60\nT__61=61\nT__62=62\nT__63=63\nT__64=64\nT__65=65\nT__66=66\nT__67=67\nT__68=68\nT__69=69\nT__70=70\nT__71=71\nT__72=72\nT__73=73\nT__74=74\nT__75=75\nESC_SEQ=4\nHEX_DIGIT=5\nID=6\nNUMBER=7\nOCTAL_ESC=8\nSTRING=9\nUNICODE_ESC=10\n\n\nclass chabuildlyLexer(Lexer):\n\n grammarFileName = \"/Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g\"\n api_version = 1\n\n def __init__(self, input=None, state=None):\n if state is None:\n state = RecognizerSharedState()\n super(chabuildlyLexer, self).__init__(input, state)\n\n self.delegates = []\n\n self.dfa8 = self.DFA8(\n self, 8,\n eot = self.DFA8_eot,\n eof = self.DFA8_eof,\n min = self.DFA8_min,\n max = self.DFA8_max,\n accept = self.DFA8_accept,\n special = self.DFA8_special,\n transition = self.DFA8_transition\n )\n\n\n\n\n\n\n # $ANTLR start \"T__11\"\n def mT__11(self, ):\n try:\n _type = T__11\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:7:7: ( '(' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:7:9: '('\n pass \n self.match(40)\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__11\"\n\n\n\n # $ANTLR start \"T__12\"\n def mT__12(self, ):\n try:\n _type = T__12\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:8:7: ( ')' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:8:9: ')'\n pass \n self.match(41)\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__12\"\n\n\n\n # $ANTLR start \"T__13\"\n def mT__13(self, ):\n try:\n _type = T__13\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:9:7: ( '*' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:9:9: '*'\n pass \n self.match(42)\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__13\"\n\n\n\n # $ANTLR start \"T__14\"\n def mT__14(self, ):\n try:\n _type = T__14\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:10:7: ( '+' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:10:9: '+'\n pass \n self.match(43)\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__14\"\n\n\n\n # $ANTLR start \"T__15\"\n def mT__15(self, ):\n try:\n _type = T__15\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:11:7: ( ',' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:11:9: ','\n pass \n self.match(44)\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__15\"\n\n\n\n # $ANTLR start \"T__16\"\n def mT__16(self, ):\n try:\n _type = T__16\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:12:7: ( '-' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:12:9: '-'\n pass \n self.match(45)\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__16\"\n\n\n\n # $ANTLR start \"T__17\"\n def mT__17(self, ):\n try:\n _type = T__17\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:13:7: ( '/' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:13:9: '/'\n pass \n self.match(47)\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__17\"\n\n\n\n # $ANTLR start \"T__18\"\n def mT__18(self, ):\n try:\n _type = T__18\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:14:7: ( ':' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:14:9: ':'\n pass \n self.match(58)\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__18\"\n\n\n\n # $ANTLR start \"T__19\"\n def mT__19(self, ):\n try:\n _type = T__19\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:15:7: ( ';' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:15:9: ';'\n pass \n self.match(59)\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__19\"\n\n\n\n # $ANTLR start \"T__20\"\n def mT__20(self, ):\n try:\n _type = T__20\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:16:7: ( '=' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:16:9: '='\n pass \n self.match(61)\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__20\"\n\n\n\n # $ANTLR start \"T__21\"\n def mT__21(self, ):\n try:\n _type = T__21\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:17:7: ( 'add' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:17:9: 'add'\n pass \n self.match(\"add\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__21\"\n\n\n\n # $ANTLR start \"T__22\"\n def mT__22(self, ):\n try:\n _type = T__22\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:18:7: ( 'and' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:18:9: 'and'\n pass \n self.match(\"and\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__22\"\n\n\n\n # $ANTLR start \"T__23\"\n def mT__23(self, ):\n try:\n _type = T__23\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:19:7: ( 'at' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:19:9: 'at'\n pass \n self.match(\"at\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__23\"\n\n\n\n # $ANTLR start \"T__24\"\n def mT__24(self, ):\n try:\n _type = T__24\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:20:7: ( 'background' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:20:9: 'background'\n pass \n self.match(\"background\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__24\"\n\n\n\n # $ANTLR start \"T__25\"\n def mT__25(self, ):\n try:\n _type = T__25\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:21:7: ( 'bool' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:21:9: 'bool'\n pass \n self.match(\"bool\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__25\"\n\n\n\n # $ANTLR start \"T__26\"\n def mT__26(self, ):\n try:\n _type = T__26\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:22:7: ( 'call' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:22:9: 'call'\n pass \n self.match(\"call\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__26\"\n\n\n\n # $ANTLR start \"T__27\"\n def mT__27(self, ):\n try:\n _type = T__27\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:23:7: ( 'circle' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:23:9: 'circle'\n pass \n self.match(\"circle\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__27\"\n\n\n\n # $ANTLR start \"T__28\"\n def mT__28(self, ):\n try:\n _type = T__28\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:24:7: ( 'color' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:24:9: 'color'\n pass \n self.match(\"color\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__28\"\n\n\n\n # $ANTLR start \"T__29\"\n def mT__29(self, ):\n try:\n _type = T__29\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:25:7: ( 'different?' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:25:9: 'different?'\n pass \n self.match(\"different?\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__29\"\n\n\n\n # $ANTLR start \"T__30\"\n def mT__30(self, ):\n try:\n _type = T__30\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:26:7: ( 'draw' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:26:9: 'draw'\n pass \n self.match(\"draw\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__30\"\n\n\n\n # $ANTLR start \"T__31\"\n def mT__31(self, ):\n try:\n _type = T__31\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:27:7: ( 'elif' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:27:9: 'elif'\n pass \n self.match(\"elif\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__31\"\n\n\n\n # $ANTLR start \"T__32\"\n def mT__32(self, ):\n try:\n _type = T__32\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:28:7: ( 'else' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:28:9: 'else'\n pass \n self.match(\"else\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__32\"\n\n\n\n # $ANTLR start \"T__33\"\n def mT__33(self, ):\n try:\n _type = T__33\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:29:7: ( 'end' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:29:9: 'end'\n pass \n self.match(\"end\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__33\"\n\n\n\n # $ANTLR start \"T__34\"\n def mT__34(self, ):\n try:\n _type = T__34\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:30:7: ( 'equals?' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:30:9: 'equals?'\n pass \n self.match(\"equals?\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__34\"\n\n\n\n # $ANTLR start \"T__35\"\n def mT__35(self, ):\n try:\n _type = T__35\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:31:7: ( 'false' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:31:9: 'false'\n pass \n self.match(\"false\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__35\"\n\n\n\n # $ANTLR start \"T__36\"\n def mT__36(self, ):\n try:\n _type = T__36\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:32:7: ( 'from' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:32:9: 'from'\n pass \n self.match(\"from\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__36\"\n\n\n\n # $ANTLR start \"T__37\"\n def mT__37(self, ):\n try:\n _type = T__37\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:33:7: ( 'function' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:33:9: 'function'\n pass \n self.match(\"function\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__37\"\n\n\n\n # $ANTLR start \"T__38\"\n def mT__38(self, ):\n try:\n _type = T__38\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:34:7: ( 'greater?' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:34:9: 'greater?'\n pass \n self.match(\"greater?\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__38\"\n\n\n\n # $ANTLR start \"T__39\"\n def mT__39(self, ):\n try:\n _type = T__39\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:35:7: ( 'height' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:35:9: 'height'\n pass \n self.match(\"height\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__39\"\n\n\n\n # $ANTLR start \"T__40\"\n def mT__40(self, ):\n try:\n _type = T__40\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:36:7: ( 'id' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:36:9: 'id'\n pass \n self.match(\"id\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__40\"\n\n\n\n # $ANTLR start \"T__41\"\n def mT__41(self, ):\n try:\n _type = T__41\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:37:7: ( 'if' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:37:9: 'if'\n pass \n self.match(\"if\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__41\"\n\n\n\n # $ANTLR start \"T__42\"\n def mT__42(self, ):\n try:\n _type = T__42\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:38:7: ( 'less?' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:38:9: 'less?'\n pass \n self.match(\"less?\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__42\"\n\n\n\n # $ANTLR start \"T__43\"\n def mT__43(self, ):\n try:\n _type = T__43\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:39:7: ( 'line' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:39:9: 'line'\n pass \n self.match(\"line\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__43\"\n\n\n\n # $ANTLR start \"T__44\"\n def mT__44(self, ):\n try:\n _type = T__44\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:40:7: ( 'list' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:40:9: 'list'\n pass \n self.match(\"list\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__44\"\n\n\n\n # $ANTLR start \"T__45\"\n def mT__45(self, ):\n try:\n _type = T__45\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:41:7: ( 'max:' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:41:9: 'max:'\n pass \n self.match(\"max:\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__45\"\n\n\n\n # $ANTLR start \"T__46\"\n def mT__46(self, ):\n try:\n _type = T__46\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:42:7: ( 'min:' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:42:9: 'min:'\n pass \n self.match(\"min:\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__46\"\n\n\n\n # $ANTLR start \"T__47\"\n def mT__47(self, ):\n try:\n _type = T__47\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:43:7: ( 'not' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:43:9: 'not'\n pass \n self.match(\"not\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__47\"\n\n\n\n # $ANTLR start \"T__48\"\n def mT__48(self, ):\n try:\n _type = T__48\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:44:7: ( 'number' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:44:9: 'number'\n pass \n self.match(\"number\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__48\"\n\n\n\n # $ANTLR start \"T__49\"\n def mT__49(self, ):\n try:\n _type = T__49\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:45:7: ( 'or' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:45:9: 'or'\n pass \n self.match(\"or\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__49\"\n\n\n\n # $ANTLR start \"T__50\"\n def mT__50(self, ):\n try:\n _type = T__50\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:46:7: ( 'params' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:46:9: 'params'\n pass \n self.match(\"params\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__50\"\n\n\n\n # $ANTLR start \"T__51\"\n def mT__51(self, ):\n try:\n _type = T__51\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:47:7: ( 'point' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:47:9: 'point'\n pass \n self.match(\"point\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__51\"\n\n\n\n # $ANTLR start \"T__52\"\n def mT__52(self, ):\n try:\n _type = T__52\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:48:7: ( 'point-width' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:48:9: 'point-width'\n pass \n self.match(\"point-width\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__52\"\n\n\n\n # $ANTLR start \"T__53\"\n def mT__53(self, ):\n try:\n _type = T__53\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:49:7: ( 'points' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:49:9: 'points'\n pass \n self.match(\"points\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__53\"\n\n\n\n # $ANTLR start \"T__54\"\n def mT__54(self, ):\n try:\n _type = T__54\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:50:7: ( 'polygon' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:50:9: 'polygon'\n pass \n self.match(\"polygon\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__54\"\n\n\n\n # $ANTLR start \"T__55\"\n def mT__55(self, ):\n try:\n _type = T__55\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:51:7: ( 'print' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:51:9: 'print'\n pass \n self.match(\"print\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__55\"\n\n\n\n # $ANTLR start \"T__56\"\n def mT__56(self, ):\n try:\n _type = T__56\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:52:7: ( 'radius' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:52:9: 'radius'\n pass \n self.match(\"radius\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__56\"\n\n\n\n # $ANTLR start \"T__57\"\n def mT__57(self, ):\n try:\n _type = T__57\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:53:7: ( 'random' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:53:9: 'random'\n pass \n self.match(\"random\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__57\"\n\n\n\n # $ANTLR start \"T__58\"\n def mT__58(self, ):\n try:\n _type = T__58\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:54:7: ( 'rectangle' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:54:9: 'rectangle'\n pass \n self.match(\"rectangle\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__58\"\n\n\n\n # $ANTLR start \"T__59\"\n def mT__59(self, ):\n try:\n _type = T__59\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:55:7: ( 'remove' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:55:9: 'remove'\n pass \n self.match(\"remove\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__59\"\n\n\n\n # $ANTLR start \"T__60\"\n def mT__60(self, ):\n try:\n _type = T__60\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:56:7: ( 'repeat' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:56:9: 'repeat'\n pass \n self.match(\"repeat\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__60\"\n\n\n\n # $ANTLR start \"T__61\"\n def mT__61(self, ):\n try:\n _type = T__61\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:57:7: ( 'return' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:57:9: 'return'\n pass \n self.match(\"return\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__61\"\n\n\n\n # $ANTLR start \"T__62\"\n def mT__62(self, ):\n try:\n _type = T__62\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:58:7: ( 'set' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:58:9: 'set'\n pass \n self.match(\"set\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__62\"\n\n\n\n # $ANTLR start \"T__63\"\n def mT__63(self, ):\n try:\n _type = T__63\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:59:7: ( 'shape' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:59:9: 'shape'\n pass \n self.match(\"shape\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__63\"\n\n\n\n # $ANTLR start \"T__64\"\n def mT__64(self, ):\n try:\n _type = T__64\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:60:7: ( 'start' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:60:9: 'start'\n pass \n self.match(\"start\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__64\"\n\n\n\n # $ANTLR start \"T__65\"\n def mT__65(self, ):\n try:\n _type = T__65\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:61:7: ( 'string' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:61:9: 'string'\n pass \n self.match(\"string\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__65\"\n\n\n\n # $ANTLR start \"T__66\"\n def mT__66(self, ):\n try:\n _type = T__66\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:62:7: ( 'to' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:62:9: 'to'\n pass \n self.match(\"to\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__66\"\n\n\n\n # $ANTLR start \"T__67\"\n def mT__67(self, ):\n try:\n _type = T__67\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:63:7: ( 'true' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:63:9: 'true'\n pass \n self.match(\"true\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__67\"\n\n\n\n # $ANTLR start \"T__68\"\n def mT__68(self, ):\n try:\n _type = T__68\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:64:7: ( 'var' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:64:9: 'var'\n pass \n self.match(\"var\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__68\"\n\n\n\n # $ANTLR start \"T__69\"\n def mT__69(self, ):\n try:\n _type = T__69\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:65:7: ( 'while' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:65:9: 'while'\n pass \n self.match(\"while\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__69\"\n\n\n\n # $ANTLR start \"T__70\"\n def mT__70(self, ):\n try:\n _type = T__70\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:66:7: ( 'width' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:66:9: 'width'\n pass \n self.match(\"width\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__70\"\n\n\n\n # $ANTLR start \"T__71\"\n def mT__71(self, ):\n try:\n _type = T__71\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:67:7: ( 'with' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:67:9: 'with'\n pass \n self.match(\"with\")\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__71\"\n\n\n\n # $ANTLR start \"T__72\"\n def mT__72(self, ):\n try:\n _type = T__72\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:68:7: ( 'x' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:68:9: 'x'\n pass \n self.match(120)\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__72\"\n\n\n\n # $ANTLR start \"T__73\"\n def mT__73(self, ):\n try:\n _type = T__73\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:69:7: ( 'y' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:69:9: 'y'\n pass \n self.match(121)\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__73\"\n\n\n\n # $ANTLR start \"T__74\"\n def mT__74(self, ):\n try:\n _type = T__74\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:70:7: ( '{' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:70:9: '{'\n pass \n self.match(123)\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__74\"\n\n\n\n # $ANTLR start \"T__75\"\n def mT__75(self, ):\n try:\n _type = T__75\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:71:7: ( '}' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:71:9: '}'\n pass \n self.match(125)\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"T__75\"\n\n\n\n # $ANTLR start \"ID\"\n def mID(self, ):\n try:\n _type = ID\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:74:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:74:7: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*\n pass \n if (65 <= self.input.LA(1) <= 90) or self.input.LA(1) == 95 or (97 <= self.input.LA(1) <= 122):\n self.input.consume()\n else:\n mse = MismatchedSetException(None, self.input)\n self.recover(mse)\n raise mse\n\n\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:74:31: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*\n while True: #loop1\n alt1 = 2\n LA1_0 = self.input.LA(1)\n\n if ((48 <= LA1_0 <= 57) or (65 <= LA1_0 <= 90) or LA1_0 == 95 or (97 <= LA1_0 <= 122)) :\n alt1 = 1\n\n\n if alt1 == 1:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:\n pass \n if (48 <= self.input.LA(1) <= 57) or (65 <= self.input.LA(1) <= 90) or self.input.LA(1) == 95 or (97 <= self.input.LA(1) <= 122):\n self.input.consume()\n else:\n mse = MismatchedSetException(None, self.input)\n self.recover(mse)\n raise mse\n\n\n\n\n else:\n break #loop1\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"ID\"\n\n\n\n # $ANTLR start \"NUMBER\"\n def mNUMBER(self, ):\n try:\n _type = NUMBER\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:77:8: ( ( '0' .. '9' )+ ( ( '.' ) ( '0' .. '9' )+ )? )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:77:10: ( '0' .. '9' )+ ( ( '.' ) ( '0' .. '9' )+ )?\n pass \n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:77:10: ( '0' .. '9' )+\n cnt2 = 0\n while True: #loop2\n alt2 = 2\n LA2_0 = self.input.LA(1)\n\n if ((48 <= LA2_0 <= 57)) :\n alt2 = 1\n\n\n if alt2 == 1:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:\n pass \n if (48 <= self.input.LA(1) <= 57):\n self.input.consume()\n else:\n mse = MismatchedSetException(None, self.input)\n self.recover(mse)\n raise mse\n\n\n\n\n else:\n if cnt2 >= 1:\n break #loop2\n\n eee = EarlyExitException(2, self.input)\n raise eee\n\n cnt2 += 1\n\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:77:21: ( ( '.' ) ( '0' .. '9' )+ )?\n alt4 = 2\n LA4_0 = self.input.LA(1)\n\n if (LA4_0 == 46) :\n alt4 = 1\n if alt4 == 1:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:77:22: ( '.' ) ( '0' .. '9' )+\n pass \n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:77:22: ( '.' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:77:23: '.'\n pass \n self.match(46)\n\n\n\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:77:27: ( '0' .. '9' )+\n cnt3 = 0\n while True: #loop3\n alt3 = 2\n LA3_0 = self.input.LA(1)\n\n if ((48 <= LA3_0 <= 57)) :\n alt3 = 1\n\n\n if alt3 == 1:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:\n pass \n if (48 <= self.input.LA(1) <= 57):\n self.input.consume()\n else:\n mse = MismatchedSetException(None, self.input)\n self.recover(mse)\n raise mse\n\n\n\n\n else:\n if cnt3 >= 1:\n break #loop3\n\n eee = EarlyExitException(3, self.input)\n raise eee\n\n cnt3 += 1\n\n\n\n\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"NUMBER\"\n\n\n\n # $ANTLR start \"STRING\"\n def mSTRING(self, ):\n try:\n _type = STRING\n _channel = DEFAULT_CHANNEL\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:81:5: ( '\\\"' ( ESC_SEQ |~ ( '\\\\\\\\' | '\\\"' ) )* '\\\"' )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:81:8: '\\\"' ( ESC_SEQ |~ ( '\\\\\\\\' | '\\\"' ) )* '\\\"'\n pass \n self.match(34)\n\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:81:12: ( ESC_SEQ |~ ( '\\\\\\\\' | '\\\"' ) )*\n while True: #loop5\n alt5 = 3\n LA5_0 = self.input.LA(1)\n\n if (LA5_0 == 92) :\n alt5 = 1\n elif ((0 <= LA5_0 <= 33) or (35 <= LA5_0 <= 91) or (93 <= LA5_0 <= 65535)) :\n alt5 = 2\n\n\n if alt5 == 1:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:81:14: ESC_SEQ\n pass \n self.mESC_SEQ()\n\n\n\n elif alt5 == 2:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:81:24: ~ ( '\\\\\\\\' | '\\\"' )\n pass \n if (0 <= self.input.LA(1) <= 33) or (35 <= self.input.LA(1) <= 91) or (93 <= self.input.LA(1) <= 65535):\n self.input.consume()\n else:\n mse = MismatchedSetException(None, self.input)\n self.recover(mse)\n raise mse\n\n\n\n\n else:\n break #loop5\n\n\n self.match(34)\n\n\n\n self._state.type = _type\n self._state.channel = _channel\n finally:\n pass\n\n # $ANTLR end \"STRING\"\n\n\n\n # $ANTLR start \"HEX_DIGIT\"\n def mHEX_DIGIT(self, ):\n try:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:86:11: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:\n pass \n if (48 <= self.input.LA(1) <= 57) or (65 <= self.input.LA(1) <= 70) or (97 <= self.input.LA(1) <= 102):\n self.input.consume()\n else:\n mse = MismatchedSetException(None, self.input)\n self.recover(mse)\n raise mse\n\n\n\n\n\n\n finally:\n pass\n\n # $ANTLR end \"HEX_DIGIT\"\n\n\n\n # $ANTLR start \"ESC_SEQ\"\n def mESC_SEQ(self, ):\n try:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:90:5: ( '\\\\\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\\\\\"' | '\\\\'' | '\\\\\\\\' ) | UNICODE_ESC | OCTAL_ESC )\n alt6 = 3\n LA6_0 = self.input.LA(1)\n\n if (LA6_0 == 92) :\n LA6 = self.input.LA(2)\n if LA6 == 34 or LA6 == 39 or LA6 == 92 or LA6 == 98 or LA6 == 102 or LA6 == 110 or LA6 == 114 or LA6 == 116:\n alt6 = 1\n elif LA6 == 117:\n alt6 = 2\n elif LA6 == 48 or LA6 == 49 or LA6 == 50 or LA6 == 51 or LA6 == 52 or LA6 == 53 or LA6 == 54 or LA6 == 55:\n alt6 = 3\n else:\n nvae = NoViableAltException(\"\", 6, 1, self.input)\n\n raise nvae\n\n\n else:\n nvae = NoViableAltException(\"\", 6, 0, self.input)\n\n raise nvae\n\n\n if alt6 == 1:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:90:9: '\\\\\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\\\\\"' | '\\\\'' | '\\\\\\\\' )\n pass \n self.match(92)\n\n if self.input.LA(1) == 34 or self.input.LA(1) == 39 or self.input.LA(1) == 92 or self.input.LA(1) == 98 or self.input.LA(1) == 102 or self.input.LA(1) == 110 or self.input.LA(1) == 114 or self.input.LA(1) == 116:\n self.input.consume()\n else:\n mse = MismatchedSetException(None, self.input)\n self.recover(mse)\n raise mse\n\n\n\n\n elif alt6 == 2:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:91:9: UNICODE_ESC\n pass \n self.mUNICODE_ESC()\n\n\n\n elif alt6 == 3:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:92:9: OCTAL_ESC\n pass \n self.mOCTAL_ESC()\n\n\n\n\n finally:\n pass\n\n # $ANTLR end \"ESC_SEQ\"\n\n\n\n # $ANTLR start \"OCTAL_ESC\"\n def mOCTAL_ESC(self, ):\n try:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:97:5: ( '\\\\\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\\\\\' ( '0' .. '7' ) )\n alt7 = 3\n LA7_0 = self.input.LA(1)\n\n if (LA7_0 == 92) :\n LA7_1 = self.input.LA(2)\n\n if ((48 <= LA7_1 <= 51)) :\n LA7_2 = self.input.LA(3)\n\n if ((48 <= LA7_2 <= 55)) :\n LA7_4 = self.input.LA(4)\n\n if ((48 <= LA7_4 <= 55)) :\n alt7 = 1\n else:\n alt7 = 2\n\n else:\n alt7 = 3\n\n elif ((52 <= LA7_1 <= 55)) :\n LA7_3 = self.input.LA(3)\n\n if ((48 <= LA7_3 <= 55)) :\n alt7 = 2\n else:\n alt7 = 3\n\n else:\n nvae = NoViableAltException(\"\", 7, 1, self.input)\n\n raise nvae\n\n\n else:\n nvae = NoViableAltException(\"\", 7, 0, self.input)\n\n raise nvae\n\n\n if alt7 == 1:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:97:9: '\\\\\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' )\n pass \n self.match(92)\n\n if (48 <= self.input.LA(1) <= 51):\n self.input.consume()\n else:\n mse = MismatchedSetException(None, self.input)\n self.recover(mse)\n raise mse\n\n\n\n if (48 <= self.input.LA(1) <= 55):\n self.input.consume()\n else:\n mse = MismatchedSetException(None, self.input)\n self.recover(mse)\n raise mse\n\n\n\n if (48 <= self.input.LA(1) <= 55):\n self.input.consume()\n else:\n mse = MismatchedSetException(None, self.input)\n self.recover(mse)\n raise mse\n\n\n\n\n elif alt7 == 2:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:98:9: '\\\\\\\\' ( '0' .. '7' ) ( '0' .. '7' )\n pass \n self.match(92)\n\n if (48 <= self.input.LA(1) <= 55):\n self.input.consume()\n else:\n mse = MismatchedSetException(None, self.input)\n self.recover(mse)\n raise mse\n\n\n\n if (48 <= self.input.LA(1) <= 55):\n self.input.consume()\n else:\n mse = MismatchedSetException(None, self.input)\n self.recover(mse)\n raise mse\n\n\n\n\n elif alt7 == 3:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:99:9: '\\\\\\\\' ( '0' .. '7' )\n pass \n self.match(92)\n\n if (48 <= self.input.LA(1) <= 55):\n self.input.consume()\n else:\n mse = MismatchedSetException(None, self.input)\n self.recover(mse)\n raise mse\n\n\n\n\n\n finally:\n pass\n\n # $ANTLR end \"OCTAL_ESC\"\n\n\n\n # $ANTLR start \"UNICODE_ESC\"\n def mUNICODE_ESC(self, ):\n try:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:104:5: ( '\\\\\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT )\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:104:9: '\\\\\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT\n pass \n self.match(92)\n\n self.match(117)\n\n self.mHEX_DIGIT()\n\n\n self.mHEX_DIGIT()\n\n\n self.mHEX_DIGIT()\n\n\n self.mHEX_DIGIT()\n\n\n\n\n\n finally:\n pass\n\n # $ANTLR end \"UNICODE_ESC\"\n\n\n\n def mTokens(self):\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:8: ( T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | ID | NUMBER | STRING )\n alt8 = 68\n alt8 = self.dfa8.predict(self.input)\n if alt8 == 1:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:10: T__11\n pass \n self.mT__11()\n\n\n\n elif alt8 == 2:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:16: T__12\n pass \n self.mT__12()\n\n\n\n elif alt8 == 3:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:22: T__13\n pass \n self.mT__13()\n\n\n\n elif alt8 == 4:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:28: T__14\n pass \n self.mT__14()\n\n\n\n elif alt8 == 5:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:34: T__15\n pass \n self.mT__15()\n\n\n\n elif alt8 == 6:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:40: T__16\n pass \n self.mT__16()\n\n\n\n elif alt8 == 7:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:46: T__17\n pass \n self.mT__17()\n\n\n\n elif alt8 == 8:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:52: T__18\n pass \n self.mT__18()\n\n\n\n elif alt8 == 9:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:58: T__19\n pass \n self.mT__19()\n\n\n\n elif alt8 == 10:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:64: T__20\n pass \n self.mT__20()\n\n\n\n elif alt8 == 11:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:70: T__21\n pass \n self.mT__21()\n\n\n\n elif alt8 == 12:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:76: T__22\n pass \n self.mT__22()\n\n\n\n elif alt8 == 13:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:82: T__23\n pass \n self.mT__23()\n\n\n\n elif alt8 == 14:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:88: T__24\n pass \n self.mT__24()\n\n\n\n elif alt8 == 15:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:94: T__25\n pass \n self.mT__25()\n\n\n\n elif alt8 == 16:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:100: T__26\n pass \n self.mT__26()\n\n\n\n elif alt8 == 17:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:106: T__27\n pass \n self.mT__27()\n\n\n\n elif alt8 == 18:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:112: T__28\n pass \n self.mT__28()\n\n\n\n elif alt8 == 19:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:118: T__29\n pass \n self.mT__29()\n\n\n\n elif alt8 == 20:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:124: T__30\n pass \n self.mT__30()\n\n\n\n elif alt8 == 21:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:130: T__31\n pass \n self.mT__31()\n\n\n\n elif alt8 == 22:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:136: T__32\n pass \n self.mT__32()\n\n\n\n elif alt8 == 23:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:142: T__33\n pass \n self.mT__33()\n\n\n\n elif alt8 == 24:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:148: T__34\n pass \n self.mT__34()\n\n\n\n elif alt8 == 25:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:154: T__35\n pass \n self.mT__35()\n\n\n\n elif alt8 == 26:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:160: T__36\n pass \n self.mT__36()\n\n\n\n elif alt8 == 27:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:166: T__37\n pass \n self.mT__37()\n\n\n\n elif alt8 == 28:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:172: T__38\n pass \n self.mT__38()\n\n\n\n elif alt8 == 29:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:178: T__39\n pass \n self.mT__39()\n\n\n\n elif alt8 == 30:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:184: T__40\n pass \n self.mT__40()\n\n\n\n elif alt8 == 31:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:190: T__41\n pass \n self.mT__41()\n\n\n\n elif alt8 == 32:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:196: T__42\n pass \n self.mT__42()\n\n\n\n elif alt8 == 33:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:202: T__43\n pass \n self.mT__43()\n\n\n\n elif alt8 == 34:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:208: T__44\n pass \n self.mT__44()\n\n\n\n elif alt8 == 35:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:214: T__45\n pass \n self.mT__45()\n\n\n\n elif alt8 == 36:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:220: T__46\n pass \n self.mT__46()\n\n\n\n elif alt8 == 37:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:226: T__47\n pass \n self.mT__47()\n\n\n\n elif alt8 == 38:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:232: T__48\n pass \n self.mT__48()\n\n\n\n elif alt8 == 39:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:238: T__49\n pass \n self.mT__49()\n\n\n\n elif alt8 == 40:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:244: T__50\n pass \n self.mT__50()\n\n\n\n elif alt8 == 41:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:250: T__51\n pass \n self.mT__51()\n\n\n\n elif alt8 == 42:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:256: T__52\n pass \n self.mT__52()\n\n\n\n elif alt8 == 43:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:262: T__53\n pass \n self.mT__53()\n\n\n\n elif alt8 == 44:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:268: T__54\n pass \n self.mT__54()\n\n\n\n elif alt8 == 45:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:274: T__55\n pass \n self.mT__55()\n\n\n\n elif alt8 == 46:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:280: T__56\n pass \n self.mT__56()\n\n\n\n elif alt8 == 47:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:286: T__57\n pass \n self.mT__57()\n\n\n\n elif alt8 == 48:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:292: T__58\n pass \n self.mT__58()\n\n\n\n elif alt8 == 49:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:298: T__59\n pass \n self.mT__59()\n\n\n\n elif alt8 == 50:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:304: T__60\n pass \n self.mT__60()\n\n\n\n elif alt8 == 51:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:310: T__61\n pass \n self.mT__61()\n\n\n\n elif alt8 == 52:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:316: T__62\n pass \n self.mT__62()\n\n\n\n elif alt8 == 53:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:322: T__63\n pass \n self.mT__63()\n\n\n\n elif alt8 == 54:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:328: T__64\n pass \n self.mT__64()\n\n\n\n elif alt8 == 55:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:334: T__65\n pass \n self.mT__65()\n\n\n\n elif alt8 == 56:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:340: T__66\n pass \n self.mT__66()\n\n\n\n elif alt8 == 57:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:346: T__67\n pass \n self.mT__67()\n\n\n\n elif alt8 == 58:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:352: T__68\n pass \n self.mT__68()\n\n\n\n elif alt8 == 59:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:358: T__69\n pass \n self.mT__69()\n\n\n\n elif alt8 == 60:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:364: T__70\n pass \n self.mT__70()\n\n\n\n elif alt8 == 61:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:370: T__71\n pass \n self.mT__71()\n\n\n\n elif alt8 == 62:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:376: T__72\n pass \n self.mT__72()\n\n\n\n elif alt8 == 63:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:382: T__73\n pass \n self.mT__73()\n\n\n\n elif alt8 == 64:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:388: T__74\n pass \n self.mT__74()\n\n\n\n elif alt8 == 65:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:394: T__75\n pass \n self.mT__75()\n\n\n\n elif alt8 == 66:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:400: ID\n pass \n self.mID()\n\n\n\n elif alt8 == 67:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:403: NUMBER\n pass \n self.mNUMBER()\n\n\n\n elif alt8 == 68:\n # /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g:1:410: STRING\n pass \n self.mSTRING()\n\n\n\n\n\n\n\n\n # lookup tables for DFA #8\n\n DFA8_eot = DFA.unpack(\n u\"\\13\\uffff\\23\\42\\1\\115\\1\\116\\5\\uffff\\2\\42\\1\\121\\17\\42\\1\\142\\1\\143\"\n u\"\\6\\42\\1\\153\\10\\42\\1\\172\\4\\42\\2\\uffff\\1\\u0080\\1\\u0081\\1\\uffff\\11\"\n u\"\\42\\1\\u008b\\6\\42\\2\\uffff\\5\\42\\1\\u0097\\1\\42\\1\\uffff\\12\\42\\1\\u00a3\"\n u\"\\3\\42\\1\\uffff\\1\\42\\1\\u00a8\\3\\42\\2\\uffff\\1\\42\\1\\u00ad\\1\\u00ae\\3\"\n u\"\\42\\1\\u00b2\\1\\u00b3\\1\\u00b4\\1\\uffff\\2\\42\\1\\u00b7\\4\\42\\1\\u00bc\\1\"\n u\"\\u00bd\\3\\uffff\\13\\42\\1\\uffff\\3\\42\\1\\u00cc\\1\\uffff\\2\\42\\1\\u00cf\"\n u\"\\1\\42\\2\\uffff\\1\\42\\1\\u00d2\\1\\42\\3\\uffff\\1\\42\\1\\u00d5\\1\\uffff\\3\"\n u\"\\42\\3\\uffff\\2\\42\\1\\u00dd\\1\\42\\1\\u00df\\6\\42\\1\\u00e6\\1\\u00e7\\1\\42\"\n u\"\\1\\uffff\\1\\u00e9\\1\\u00ea\\1\\uffff\\1\\42\\1\\u00ec\\1\\uffff\\2\\42\\1\\uffff\"\n u\"\\2\\42\\1\\u00f1\\1\\u00f2\\1\\u00f3\\1\\uffff\\1\\u00f4\\1\\uffff\\1\\42\\1\\uffff\"\n u\"\\1\\u00f6\\1\\u00f7\\1\\42\\1\\u00f9\\1\\u00fa\\1\\u00fb\\2\\uffff\\1\\u00fc\\2\"\n u\"\\uffff\\1\\42\\1\\uffff\\1\\42\\1\\uffff\\2\\42\\4\\uffff\\1\\u0101\\2\\uffff\\1\"\n u\"\\42\\4\\uffff\\2\\42\\1\\u0105\\2\\uffff\\3\\42\\1\\uffff\\1\\u0109\\1\\u010a\\3\"\n u\"\\uffff\"\n )\n\n DFA8_eof = DFA.unpack(\n u\"\\u010b\\uffff\"\n )\n\n DFA8_min = DFA.unpack(\n u\"\\1\\42\\12\\uffff\\1\\144\\2\\141\\1\\151\\1\\154\\1\\141\\1\\162\\1\\145\\1\\144\"\n u\"\\1\\145\\1\\141\\1\\157\\1\\162\\2\\141\\1\\145\\1\\157\\1\\141\\1\\150\\2\\60\\5\\uffff\"\n u\"\\2\\144\\1\\60\\1\\143\\1\\157\\1\\154\\1\\162\\1\\154\\1\\146\\1\\141\\1\\151\\1\\144\"\n u\"\\1\\165\\1\\154\\1\\157\\1\\156\\1\\145\\1\\151\\2\\60\\1\\163\\1\\156\\1\\170\\1\\156\"\n u\"\\1\\164\\1\\155\\1\\60\\1\\162\\2\\151\\1\\144\\1\\143\\1\\164\\2\\141\\1\\60\\1\\165\"\n u\"\\1\\162\\1\\151\\1\\144\\2\\uffff\\2\\60\\1\\uffff\\1\\153\\2\\154\\1\\143\\1\\157\"\n u\"\\1\\146\\1\\167\\1\\146\\1\\145\\1\\60\\1\\141\\1\\163\\1\\155\\1\\143\\1\\141\\1\\147\"\n u\"\\2\\uffff\\1\\163\\1\\145\\1\\164\\2\\72\\1\\60\\1\\142\\1\\uffff\\1\\141\\1\\156\"\n u\"\\1\\171\\1\\156\\1\\151\\1\\144\\1\\164\\1\\157\\1\\145\\1\\165\\1\\60\\1\\160\\1\\162\"\n u\"\\1\\151\\1\\uffff\\1\\145\\1\\60\\1\\154\\1\\164\\1\\150\\2\\uffff\\1\\147\\2\\60\"\n u\"\\1\\154\\1\\162\\1\\145\\3\\60\\1\\uffff\\1\\154\\1\\145\\1\\60\\2\\164\\1\\150\\1\"\n u\"\\77\\2\\60\\3\\uffff\\1\\145\\1\\155\\1\\164\\1\\147\\1\\164\\1\\165\\1\\157\\1\\141\"\n u\"\\1\\166\\1\\141\\1\\162\\1\\uffff\\1\\145\\1\\164\\1\\156\\1\\60\\1\\uffff\\1\\145\"\n u\"\\1\\150\\1\\60\\1\\162\\2\\uffff\\1\\145\\1\\60\\1\\162\\3\\uffff\\1\\163\\1\\60\\1\"\n u\"\\uffff\\1\\151\\1\\145\\1\\164\\3\\uffff\\1\\162\\1\\163\\1\\55\\1\\157\\1\\60\\1\"\n u\"\\163\\1\\155\\1\\156\\1\\145\\1\\164\\1\\156\\2\\60\\1\\147\\1\\uffff\\2\\60\\1\\uffff\"\n u\"\\1\\157\\1\\60\\1\\uffff\\1\\145\\1\\77\\1\\uffff\\1\\157\\1\\162\\3\\60\\1\\uffff\"\n u\"\\1\\60\\1\\uffff\\1\\156\\1\\uffff\\2\\60\\1\\147\\3\\60\\2\\uffff\\1\\60\\2\\uffff\"\n u\"\\1\\165\\1\\uffff\\1\\156\\1\\uffff\\1\\156\\1\\77\\4\\uffff\\1\\60\\2\\uffff\\1\"\n u\"\\154\\4\\uffff\\1\\156\\1\\164\\1\\60\\2\\uffff\\1\\145\\1\\144\\1\\77\\1\\uffff\"\n u\"\\2\\60\\3\\uffff\"\n )\n\n DFA8_max = DFA.unpack(\n u\"\\1\\175\\12\\uffff\\1\\164\\2\\157\\1\\162\\1\\161\\1\\165\\1\\162\\1\\145\\1\\146\"\n u\"\\2\\151\\1\\165\\2\\162\\1\\145\\1\\164\\1\\162\\1\\141\\1\\151\\2\\172\\5\\uffff\"\n u\"\\2\\144\\1\\172\\1\\143\\1\\157\\1\\154\\1\\162\\1\\154\\1\\146\\1\\141\\1\\163\\1\"\n u\"\\144\\1\\165\\1\\154\\1\\157\\1\\156\\1\\145\\1\\151\\2\\172\\2\\163\\1\\170\\1\\156\"\n u\"\\1\\164\\1\\155\\1\\172\\1\\162\\1\\154\\1\\151\\1\\156\\2\\164\\1\\141\\1\\162\\1\"\n u\"\\172\\1\\165\\1\\162\\1\\151\\1\\164\\2\\uffff\\2\\172\\1\\uffff\\1\\153\\2\\154\"\n u\"\\1\\143\\1\\157\\1\\146\\1\\167\\1\\146\\1\\145\\1\\172\\1\\141\\1\\163\\1\\155\\1\"\n u\"\\143\\1\\141\\1\\147\\2\\uffff\\1\\163\\1\\145\\1\\164\\2\\72\\1\\172\\1\\142\\1\\uffff\"\n u\"\\1\\141\\1\\156\\1\\171\\1\\156\\1\\151\\1\\144\\1\\164\\1\\157\\1\\145\\1\\165\\1\"\n u\"\\172\\1\\160\\1\\162\\1\\151\\1\\uffff\\1\\145\\1\\172\\1\\154\\1\\164\\1\\150\\2\"\n u\"\\uffff\\1\\147\\2\\172\\1\\154\\1\\162\\1\\145\\3\\172\\1\\uffff\\1\\154\\1\\145\"\n u\"\\1\\172\\2\\164\\1\\150\\1\\77\\2\\172\\3\\uffff\\1\\145\\1\\155\\1\\164\\1\\147\\1\"\n u\"\\164\\1\\165\\1\\157\\1\\141\\1\\166\\1\\141\\1\\162\\1\\uffff\\1\\145\\1\\164\\1\"\n u\"\\156\\1\\172\\1\\uffff\\1\\145\\1\\150\\1\\172\\1\\162\\2\\uffff\\1\\145\\1\\172\"\n u\"\\1\\162\\3\\uffff\\1\\163\\1\\172\\1\\uffff\\1\\151\\1\\145\\1\\164\\3\\uffff\\1\"\n u\"\\162\\1\\163\\1\\172\\1\\157\\1\\172\\1\\163\\1\\155\\1\\156\\1\\145\\1\\164\\1\\156\"\n u\"\\2\\172\\1\\147\\1\\uffff\\2\\172\\1\\uffff\\1\\157\\1\\172\\1\\uffff\\1\\145\\1\"\n u\"\\77\\1\\uffff\\1\\157\\1\\162\\3\\172\\1\\uffff\\1\\172\\1\\uffff\\1\\156\\1\\uffff\"\n u\"\\2\\172\\1\\147\\3\\172\\2\\uffff\\1\\172\\2\\uffff\\1\\165\\1\\uffff\\1\\156\\1\"\n u\"\\uffff\\1\\156\\1\\77\\4\\uffff\\1\\172\\2\\uffff\\1\\154\\4\\uffff\\1\\156\\1\\164\"\n u\"\\1\\172\\2\\uffff\\1\\145\\1\\144\\1\\77\\1\\uffff\\2\\172\\3\\uffff\"\n )\n\n DFA8_accept = DFA.unpack(\n u\"\\1\\uffff\\1\\1\\1\\2\\1\\3\\1\\4\\1\\5\\1\\6\\1\\7\\1\\10\\1\\11\\1\\12\\25\\uffff\\1\"\n u\"\\100\\1\\101\\1\\102\\1\\103\\1\\104\\50\\uffff\\1\\76\\1\\77\\2\\uffff\\1\\15\\20\"\n u\"\\uffff\\1\\36\\1\\37\\7\\uffff\\1\\47\\16\\uffff\\1\\70\\5\\uffff\\1\\13\\1\\14\\11\"\n u\"\\uffff\\1\\27\\11\\uffff\\1\\43\\1\\44\\1\\45\\13\\uffff\\1\\64\\4\\uffff\\1\\72\"\n u\"\\4\\uffff\\1\\17\\1\\20\\3\\uffff\\1\\24\\1\\25\\1\\26\\2\\uffff\\1\\32\\3\\uffff\"\n u\"\\1\\40\\1\\41\\1\\42\\16\\uffff\\1\\71\\2\\uffff\\1\\75\\2\\uffff\\1\\22\\2\\uffff\"\n u\"\\1\\31\\5\\uffff\\1\\52\\1\\uffff\\1\\51\\1\\uffff\\1\\55\\6\\uffff\\1\\65\\1\\66\"\n u\"\\1\\uffff\\1\\73\\1\\74\\1\\uffff\\1\\21\\1\\uffff\\1\\30\\2\\uffff\\1\\35\\1\\46\"\n u\"\\1\\50\\1\\53\\1\\uffff\\1\\56\\1\\57\\1\\uffff\\1\\61\\1\\62\\1\\63\\1\\67\\3\\uffff\"\n u\"\\1\\34\\1\\54\\3\\uffff\\1\\33\\2\\uffff\\1\\23\\1\\60\\1\\16\"\n )\n\n DFA8_special = DFA.unpack(\n u\"\\u010b\\uffff\"\n )\n\n\n DFA8_transition = [\n DFA.unpack(u\"\\1\\44\\5\\uffff\\1\\1\\1\\2\\1\\3\\1\\4\\1\\5\\1\\6\\1\\uffff\\1\\7\\12\"\n u\"\\43\\1\\10\\1\\11\\1\\uffff\\1\\12\\3\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\1\"\n u\"\\13\\1\\14\\1\\15\\1\\16\\1\\17\\1\\20\\1\\21\\1\\22\\1\\23\\2\\42\\1\\24\\1\\25\\1\\26\"\n u\"\\1\\27\\1\\30\\1\\42\\1\\31\\1\\32\\1\\33\\1\\42\\1\\34\\1\\35\\1\\36\\1\\37\\1\\42\\1\"\n u\"\\40\\1\\uffff\\1\\41\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\45\\11\\uffff\\1\\46\\5\\uffff\\1\\47\"),\n DFA.unpack(u\"\\1\\50\\15\\uffff\\1\\51\"),\n DFA.unpack(u\"\\1\\52\\7\\uffff\\1\\53\\5\\uffff\\1\\54\"),\n DFA.unpack(u\"\\1\\55\\10\\uffff\\1\\56\"),\n DFA.unpack(u\"\\1\\57\\1\\uffff\\1\\60\\2\\uffff\\1\\61\"),\n DFA.unpack(u\"\\1\\62\\20\\uffff\\1\\63\\2\\uffff\\1\\64\"),\n DFA.unpack(u\"\\1\\65\"),\n DFA.unpack(u\"\\1\\66\"),\n DFA.unpack(u\"\\1\\67\\1\\uffff\\1\\70\"),\n DFA.unpack(u\"\\1\\71\\3\\uffff\\1\\72\"),\n DFA.unpack(u\"\\1\\73\\7\\uffff\\1\\74\"),\n DFA.unpack(u\"\\1\\75\\5\\uffff\\1\\76\"),\n DFA.unpack(u\"\\1\\77\"),\n DFA.unpack(u\"\\1\\100\\15\\uffff\\1\\101\\2\\uffff\\1\\102\"),\n DFA.unpack(u\"\\1\\103\\3\\uffff\\1\\104\"),\n DFA.unpack(u\"\\1\\105\\2\\uffff\\1\\106\\13\\uffff\\1\\107\"),\n DFA.unpack(u\"\\1\\110\\2\\uffff\\1\\111\"),\n DFA.unpack(u\"\\1\\112\"),\n DFA.unpack(u\"\\1\\113\\1\\114\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\117\"),\n DFA.unpack(u\"\\1\\120\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\1\\122\"),\n DFA.unpack(u\"\\1\\123\"),\n DFA.unpack(u\"\\1\\124\"),\n DFA.unpack(u\"\\1\\125\"),\n DFA.unpack(u\"\\1\\126\"),\n DFA.unpack(u\"\\1\\127\"),\n DFA.unpack(u\"\\1\\130\"),\n DFA.unpack(u\"\\1\\131\\11\\uffff\\1\\132\"),\n DFA.unpack(u\"\\1\\133\"),\n DFA.unpack(u\"\\1\\134\"),\n DFA.unpack(u\"\\1\\135\"),\n DFA.unpack(u\"\\1\\136\"),\n DFA.unpack(u\"\\1\\137\"),\n DFA.unpack(u\"\\1\\140\"),\n DFA.unpack(u\"\\1\\141\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\1\\144\"),\n DFA.unpack(u\"\\1\\145\\4\\uffff\\1\\146\"),\n DFA.unpack(u\"\\1\\147\"),\n DFA.unpack(u\"\\1\\150\"),\n DFA.unpack(u\"\\1\\151\"),\n DFA.unpack(u\"\\1\\152\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\1\\154\"),\n DFA.unpack(u\"\\1\\155\\2\\uffff\\1\\156\"),\n DFA.unpack(u\"\\1\\157\"),\n DFA.unpack(u\"\\1\\160\\11\\uffff\\1\\161\"),\n DFA.unpack(u\"\\1\\162\\11\\uffff\\1\\163\\2\\uffff\\1\\164\\3\\uffff\\1\\165\"),\n DFA.unpack(u\"\\1\\166\"),\n DFA.unpack(u\"\\1\\167\"),\n DFA.unpack(u\"\\1\\170\\20\\uffff\\1\\171\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\1\\173\"),\n DFA.unpack(u\"\\1\\174\"),\n DFA.unpack(u\"\\1\\175\"),\n DFA.unpack(u\"\\1\\176\\17\\uffff\\1\\177\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u0082\"),\n DFA.unpack(u\"\\1\\u0083\"),\n DFA.unpack(u\"\\1\\u0084\"),\n DFA.unpack(u\"\\1\\u0085\"),\n DFA.unpack(u\"\\1\\u0086\"),\n DFA.unpack(u\"\\1\\u0087\"),\n DFA.unpack(u\"\\1\\u0088\"),\n DFA.unpack(u\"\\1\\u0089\"),\n DFA.unpack(u\"\\1\\u008a\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\1\\u008c\"),\n DFA.unpack(u\"\\1\\u008d\"),\n DFA.unpack(u\"\\1\\u008e\"),\n DFA.unpack(u\"\\1\\u008f\"),\n DFA.unpack(u\"\\1\\u0090\"),\n DFA.unpack(u\"\\1\\u0091\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u0092\"),\n DFA.unpack(u\"\\1\\u0093\"),\n DFA.unpack(u\"\\1\\u0094\"),\n DFA.unpack(u\"\\1\\u0095\"),\n DFA.unpack(u\"\\1\\u0096\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\1\\u0098\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u0099\"),\n DFA.unpack(u\"\\1\\u009a\"),\n DFA.unpack(u\"\\1\\u009b\"),\n DFA.unpack(u\"\\1\\u009c\"),\n DFA.unpack(u\"\\1\\u009d\"),\n DFA.unpack(u\"\\1\\u009e\"),\n DFA.unpack(u\"\\1\\u009f\"),\n DFA.unpack(u\"\\1\\u00a0\"),\n DFA.unpack(u\"\\1\\u00a1\"),\n DFA.unpack(u\"\\1\\u00a2\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\1\\u00a4\"),\n DFA.unpack(u\"\\1\\u00a5\"),\n DFA.unpack(u\"\\1\\u00a6\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00a7\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\1\\u00a9\"),\n DFA.unpack(u\"\\1\\u00aa\"),\n DFA.unpack(u\"\\1\\u00ab\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00ac\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\1\\u00af\"),\n DFA.unpack(u\"\\1\\u00b0\"),\n DFA.unpack(u\"\\1\\u00b1\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00b5\"),\n DFA.unpack(u\"\\1\\u00b6\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\1\\u00b8\"),\n DFA.unpack(u\"\\1\\u00b9\"),\n DFA.unpack(u\"\\1\\u00ba\"),\n DFA.unpack(u\"\\1\\u00bb\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00be\"),\n DFA.unpack(u\"\\1\\u00bf\"),\n DFA.unpack(u\"\\1\\u00c0\"),\n DFA.unpack(u\"\\1\\u00c1\"),\n DFA.unpack(u\"\\1\\u00c2\"),\n DFA.unpack(u\"\\1\\u00c3\"),\n DFA.unpack(u\"\\1\\u00c4\"),\n DFA.unpack(u\"\\1\\u00c5\"),\n DFA.unpack(u\"\\1\\u00c6\"),\n DFA.unpack(u\"\\1\\u00c7\"),\n DFA.unpack(u\"\\1\\u00c8\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00c9\"),\n DFA.unpack(u\"\\1\\u00ca\"),\n DFA.unpack(u\"\\1\\u00cb\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00cd\"),\n DFA.unpack(u\"\\1\\u00ce\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\1\\u00d0\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00d1\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\1\\u00d3\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00d4\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00d6\"),\n DFA.unpack(u\"\\1\\u00d7\"),\n DFA.unpack(u\"\\1\\u00d8\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00d9\"),\n DFA.unpack(u\"\\1\\u00da\"),\n DFA.unpack(u\"\\1\\u00db\\2\\uffff\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\"\n u\"\\uffff\\22\\42\\1\\u00dc\\7\\42\"),\n DFA.unpack(u\"\\1\\u00de\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\1\\u00e0\"),\n DFA.unpack(u\"\\1\\u00e1\"),\n DFA.unpack(u\"\\1\\u00e2\"),\n DFA.unpack(u\"\\1\\u00e3\"),\n DFA.unpack(u\"\\1\\u00e4\"),\n DFA.unpack(u\"\\1\\u00e5\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\1\\u00e8\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00eb\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00ed\"),\n DFA.unpack(u\"\\1\\u00ee\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00ef\"),\n DFA.unpack(u\"\\1\\u00f0\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00f5\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\1\\u00f8\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00fd\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00fe\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u00ff\"),\n DFA.unpack(u\"\\1\\u0100\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u0102\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u0103\"),\n DFA.unpack(u\"\\1\\u0104\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\1\\u0106\"),\n DFA.unpack(u\"\\1\\u0107\"),\n DFA.unpack(u\"\\1\\u0108\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\\12\\42\\7\\uffff\\32\\42\\4\\uffff\\1\\42\\1\\uffff\\32\\42\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\"),\n DFA.unpack(u\"\")\n ]\n\n # class definition for DFA #8\n\n class DFA8(DFA):\n pass\n\n\n \n\n\n\ndef main(argv, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr):\n from antlr3.main import LexerMain\n main = LexerMain(chabuildlyLexer)\n\n main.stdin = stdin\n main.stdout = stdout\n main.stderr = stderr\n main.execute(argv)\n\n\n\nif __name__ == '__main__':\n main(sys.argv)\n"},"domain":{"kind":"string","value":"codeparrot/github-code-clean"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":2271,"numItemsPerPage":100,"numTotalItems":228459,"offset":227100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4Njk1MzA3MCwianRpIjoiNTAwNjkzYTctMDE0YS00YmNkLWI2ZTUtNDZiYzM4YjA5YmFkIiwic3ViIjoiL2RhdGFzZXRzL0phY2tCaW5hcnkvTWl4ZWRUZXh0LTIiLCJleHAiOjE3ODY5NTY2NzAsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.xmEu5yxhsyht2Dj_ZmYpJkFbIusPXBUb4vgmwxKLD4Bl6DBVR2H3r7m-f5vvXk5gLdHaNfWfPun5xDC4AOM_BA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":228459,"numBytesParquet":7695109915}]},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
text stringlengths 5.09k 178k | domain stringclasses 106
values |
|---|---|
# Copyright 2010 Google Inc.
#
# 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 agreed to in writing,... | codeparrot/github-code-clean |
# Copyright 2017 The Sonnet Authors. All Rights Reserved.
#
# 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 l... | codeparrot/github-code-clean |
#! /usr/bin/python
# Python ctypes bindings for VLC
#
# Copyright (C) 2009-2012 the VideoLAN team
# $Id: $
#
# Authors: Olivier Aubert <contact at olivieraubert.net>
# Jean Brouwers <MrJean1 at gmail.com>
# Geoff Salmon <geoff.salmon at gmail.com>
#
# This library is free software; you can redistribu... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
""" Sahana Eden Human Resources Management
@copyright: 2011-2015 (c) Sahana Software Foundation
@license: MIT
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the S... | codeparrot/github-code-clean |
# encoding: utf-8
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it w... | codeparrot/github-code-clean |
#!/usr/bin/env python
#
# Copyright 2014 Institute for Theoretical Information Technology,
# RWTH Aachen University
# www.ti.rwth-aachen.de
#
# This is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free S... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
############################ Copyrights and license ############################
# #
# Copyright 2012 Christopher Gilbert <christopher.john.gilbert@gmail.com> #
# Copyright 2012 Steve English <steve.english@naveta... | codeparrot/github-code-clean |
# @INVIENT_COPYRIGHT@
# @MUNTJAC_LICENSE@
try:
from collections import OrderedDict
except ImportError:
from ordereddict import OrderedDict
from muntjac.util \
import OrderedSet
from datetime \
import datetime
from muntjac.ui.abstract_component \
import AbstractComponent
from muntjac.ui.componen... | codeparrot/github-code-clean |
#!/usr/bin/python
#
# Copyright 2010, Michael Cohen <scudette@gmail.com>.
#
# 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 require... | codeparrot/github-code-clean |
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not us... | codeparrot/github-code-clean |
# -*- coding: ISO-8859-1 -*-
import matplotlib.pyplot as mpl
import re
import datetime
import Common
import Metric
import numpy as np
import sys
reload(sys)
sys.setdefaultencoding('ISO-8859-1')
#from matplotlib.dates import *
import os
import inspect
def getAllOutputs():
temp = inspect.getmembers(sys.modules[__name... | codeparrot/github-code-clean |
"""Diff Match and Patch
Copyright 2006 Google Inc.
http://code.google.com/p/google-diff-match-patch/
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
U... | codeparrot/github-code-clean |
"""
Utility function to facilitate testing.
"""
from __future__ import division, absolute_import, print_function
import os
import sys
import re
import operator
import warnings
from functools import partial, wraps
import shutil
import contextlib
from tempfile import mkdtemp, mkstemp
from unittest.case import SkipTest
... | codeparrot/github-code-clean |
""" Test functions for stats module
WRITTEN BY LOUIS LUANGKESORN <lluang@yahoo.com> FOR THE STATS MODULE
BASED ON WILKINSON'S STATISTICS QUIZ
http://www.stanford.edu/~clint/bench/wilk.txt
Additional tests by a host of SciPy developers.
"""
from __future__ import division, print_function, absolute_impo... | codeparrot/github-code-clean |
#!/usr/bin/env python
#
# This is PNCconf, a graphical configuration editor for LinuxCNC
# Copyright 2007 Jeff Epler <jepler@unpythonic.net>
# Pncconf 1.1 revamped by Chris Morley 2014
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public ... | codeparrot/github-code-clean |
import os, random, struct
from zope.interface import implements
from twisted.internet import defer
from twisted.internet.interfaces import IPullProducer
from twisted.python import failure
from twisted.application import service
from twisted.web.error import Error as WebError
from foolscap.api import flushEventualQueue,... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
#
# This file is part of Invenio.
# Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2015 CERN.
#
# Invenio is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; eith... | codeparrot/github-code-clean |
#! /usr/bin/env python
__version__ = '1.4.dev'
# Copyright (c) 2015-2016 Matthieu Moy and others
# Copyright (c) 2012-2014 Michael Haggerty and others
# Derived from contrib/hooks/post-receive-email, which is
# Copyright (c) 2007 Andy Parkins
# and also includes contributions by other authors.
#
# This file is part o... | codeparrot/github-code-clean |
from ChannelSelection import ChannelSelection, BouquetSelector, SilentBouquetSelector
from Components.ActionMap import ActionMap, HelpableActionMap
from Components.ActionMap import NumberActionMap
from Components.Harddisk import harddiskmanager
from Components.Input import Input
from Components.Label import Label
from... | codeparrot/github-code-clean |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# This module is also sponsored by E.T.A.I. (www.etai.fr)
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
ANSIBLE_METADATA = {'metadata_version... | codeparrot/github-code-clean |
#
# LDAP integration test
#
# Copyright (c) 2015 Red Hat, Inc.
# Author: Nikolai Kondrashov <Nikolai.Kondrashov@redhat.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of ... | codeparrot/github-code-clean |
#!/usr/bin/env python3
#
# Unit tests for the multiprocessing package
#
import unittest
import queue as pyqueue
import time
import io
import itertools
import sys
import os
import gc
import errno
import signal
import array
import socket
import random
import logging
import struct
import test.support
import test.script_... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
"""
.. module:: EDI
:synopsis: Deal with EDI files. The Edi class can read and write an .edi
file, the 'standard format' of magnetotellurics. Each section
of the .edi file is given its own class, so the elements of each
section are attributes for easy ... | codeparrot/github-code-clean |
PROJECTIONS_TEMPLATE =\
"""
<projection id="NC_ADAL_ADAR_Generic_GJ" postsynapticPopulation="ADAR" presynapticPopulation="ADAL" synapse="">
<connection id="0" preCellId="../ADAL/0/" postCellId="../ADAR/0/"/>
</projection>
<projection id="NC_ADAL_ADFL_Generic_GJ" postsynapticPopulatio... | codeparrot/github-code-clean |
# Copyright 2012 VMware, Inc.
# All Rights Reserved.
#
# 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 ... | codeparrot/github-code-clean |
import re
import collections
from enum import Enum
from ydk._core._dm_meta_info import _MetaInfoClassMember, _MetaInfoClass, _MetaInfoEnum
from ydk.types import Empty, YList, YLeafList, DELETE, Decimal64, FixedBitsDict
from ydk._core._dm_meta_info import ATTRIBUTE, REFERENCE_CLASS, REFERENCE_LIST, REFERENCE_LEAFLI... | codeparrot/github-code-clean |
# Copyright (c) 2010-2012 OpenStack Foundation
#
# 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 agree... | codeparrot/github-code-clean |
import uuid
from datetime import date, timedelta
from unittest.mock import ANY, MagicMock, Mock
import graphene
import pytest
from django.core.exceptions import ValidationError
from freezegun import freeze_time
from prices import Money, TaxedMoney
from saleor.account.models import CustomerEvent
from saleor.core.permi... | codeparrot/github-code-clean |
# Copyright 2012 VMware, Inc.
# All Rights Reserved
#
# 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 a... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
""" Custom UI Widgets used by the survey application
@copyright: 2011-2013 (c) Sahana Software Foundation
@license: MIT
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to de... | codeparrot/github-code-clean |
#!/usr/bin/env python
# coding: utf-8
#
# Copyright 2007 Google Inc.
#
# 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 ... | codeparrot/github-code-clean |
import json
from unittest import mock
import pytest
from httplib2 import Response
import demistomock as demisto
PROXY_MOCK = {
"proxy": "0.0.0.0"
}
SUCCESS_ASSET_NAME = 'www.google.com'
FAILURE_ASSET_NAME = 'www.xyz.com'
PARAMS = {
'malicious_categories': 'APT-Activity',
'suspicious_categories': 'Obser... | codeparrot/github-code-clean |
# encoding: utf-8
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Deleting model 'StateLaborForceParticipation'
db.delete_table('data_statelaborforceparticipation')
... | codeparrot/github-code-clean |
"""This module contains the HERMES data reduction class.
"""
#Example setup analysis for all channels:
#import hermes
#hermes.go_all('/Users/mireland/data/hermes/140310/data/', '/Users/mireland/tel/hermes/140310/', '/Users/mireland/python/pyhermes/cal/')
#Example setup analysis for a full night: blue
#hm = he... | codeparrot/github-code-clean |
#!/usr/bin/env python
#
# Copyright 2009 Facebook
#
# 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 a... | codeparrot/github-code-clean |
#!/usr/bin/env python
#
# Electrum - lightweight Bitcoin client
# Copyright (C) 2012 thomasv@gitorious
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at... | codeparrot/github-code-clean |
# SECUREAUTH LABS. Copyright 2018 SecureAuth Corporation. All rights reserved.
#
# This software is provided under under a slightly modified version
# of the Apache Software License. See the accompanying LICENSE file
# for more information.
#
# Author: Alberto Solino (@agsolino)
#
# Description:
# [MS-SAMR] Interface... | codeparrot/github-code-clean |
# coding=utf-8
# Author: Nic Wolfe <nic@wolfeden.ca>
# URL: https://sickrage.github.io
#
# This file is part of SickRage.
#
# SickRage is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the Li... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
"""
Bottle is a fast and simple micro-framework for small web applications. It
offers request dispatching (Routes) with url parameter support, templates,
a built-in HTTP Server and adapters for many third party WSGI/HTTP-server and
template engines - all in a single file and with no dependencies... | codeparrot/github-code-clean |
from __future__ import absolute_import, unicode_literals
import json
import logging
import plivo
import six
from collections import OrderedDict
from datetime import datetime
from decimal import Decimal
from django import forms
from django.conf import settings
from django.contrib import messages
from django.contrib.au... | codeparrot/github-code-clean |
# ----------------------------------------------------------------------
# Numenta Platform for Intelligent Computing (NuPIC)
# Copyright (C) 2013, Numenta, Inc. Unless you have an agreement
# with Numenta, Inc., for a separate license for this software code, the
# following terms and conditions apply:
#
# This progra... | codeparrot/github-code-clean |
# Copyright 2009 Google Inc.
#
# 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 agreed to in writing, ... | codeparrot/github-code-clean |
# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# 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 applica... | codeparrot/github-code-clean |
# Copyright 2012 OpenStack Foundation.
# All Rights Reserved.
#
# 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 req... | codeparrot/github-code-clean |
import re
import collections
from enum import Enum
from ydk._core._dm_meta_info import _MetaInfoClassMember, _MetaInfoClass, _MetaInfoEnum
from ydk.types import Empty, YList, YLeafList, DELETE, Decimal64, FixedBitsDict
from ydk._core._dm_meta_info import ATTRIBUTE, REFERENCE_CLASS, REFERENCE_LIST, REFERENCE_LEAFLI... | codeparrot/github-code-clean |
import logging
import re
import string
import struct
from collections import defaultdict
from itertools import count
import capstone
import cle
import networkx
import pyvex
from . import Analysis
from .cfg.cfg_emulated import CFGEmulated
from .ddg import DDG
from .cfg.cfg_fast import CFGFast
from ..knowledge_plugins... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
from south.utils import datetime_utils as datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
# Flag to indicate if this migration is too risky
# to run online and needs to be coordinated for offline
... | codeparrot/github-code-clean |
########################################################################
##
## This file, makepandacore, contains all the global state and
## global functions for the makepanda system.
##
########################################################################
import sys,os,time,stat,string,re,getopt,fnmatch,threading... | codeparrot/github-code-clean |
from __future__ import print_function
import numpy as np
#import sys
import scipy.stats as stats
import numpy.polynomial.polynomial as nppoly
from metallicity import get_keys, printsafemulti
niter = 5 # number of iteations+1 for KD02 methods
k_Ha = 2.535 # CCM Rv=3.1
k_Hb = 3.609 # CCM Rv=3.1
#k_O1=2.661 # CCM... | codeparrot/github-code-clean |
from pybindgen import Module, FileCodeSink, param, retval, cppclass, typehandlers
import pybindgen.settings
import warnings
class ErrorHandler(pybindgen.settings.ErrorHandler):
def handle_error(self, wrapper, exception, traceback_):
warnings.warn("exception %r in wrapper %s" % (exception, wrapper))
... | codeparrot/github-code-clean |
#!/usr/bin/env python2
import unittest, time, ssl
from socket import socket, AF_INET, SOCK_STREAM
from common.unittests import ProtocolTest
from common.astron import *
from common.dcfile import *
from common.tls import *
CONFIG = """\
messagedirector:
bind: 127.0.0.1:57123
threaded: %s
general:
dc_files:
... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
# Authors: Mark Wronkiewicz <wronk.mark@gmail.com>
# Eric Larson <larson.eric.d@gmail.com>
# Jussi Nurminen <jnu@iki.fi>
# License: BSD (3-clause)
from math import factorial
from os import path as op
import numpy as np
from scipy import linalg
from .. import __version__
fr... | codeparrot/github-code-clean |
#! /usr/bin/env python
## -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*-
#
# Copyright (c) 2009 University of Washington
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free ... | codeparrot/github-code-clean |
import _surface
import chimera
try:
import chimera.runCommand
except:
pass
from VolumePath import markerset as ms
try:
from VolumePath import Marker_Set, Link
new_marker_set=Marker_Set
except:
from VolumePath import volume_path_dialog
d= volume_path_dialog(True)
new_marker_set= d.new_marker_set
marker_set... | codeparrot/github-code-clean |
"""scons.Node.FS
File system nodes.
These Nodes represent the canonical external objects that people think
of when they think of building software: files and directories.
This holds a "default_fs" variable that should be initialized with an FS
that can be used by scripts or modules looking for the canonical default.... | codeparrot/github-code-clean |
import heapq, traceback, array, stat, struct
from types import NoneType
from stat import S_IFREG, S_IFDIR
from time import time, strftime, localtime
from zope.interface import implements
from twisted.python import components
from twisted.application import service, strports
from twisted.conch.ssh import factory, keys... | codeparrot/github-code-clean |
# Copyright (c) 2011 X.commerce, a business unit of eBay Inc.
# Copyright 2010 United States Government as represented by the
# Administrator of the National Aeronautics and Space Administration.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file... | codeparrot/github-code-clean |
#!/usr/bin/python
#
# Copyright 2016 Red Hat | Ansible
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
ANSIBLE_METADATA = {'metadata_version': '1.1',
'status': ['prev... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
"""
.. module:: djstripe.stripe_objects
:synopsis: dj-stripe - Abstract model definitions to provide our view of Stripe's objects
.. moduleauthor:: Bill Huneke (@wahuneke)
.. moduleauthor:: Alex Kavanaugh (@kavdev)
.. moduleauthor:: Lee Skillen (@lskillen)
This module is an effort to isolat... | codeparrot/github-code-clean |
"""
Defines the PyAgg Canvas class, where most of the PyAgg functinoality is defined.
"""
##############################
# Startup and imports
# Import future stuff
from __future__ import division
# Import dependencies
import PIL, PIL.Image, PIL.ImageDraw, PIL.ImageFont
import PIL.ImageOps, PIL.ImageChops, PIL.Imag... | codeparrot/github-code-clean |
#
#
# This test is currently disabled. It needs to be changed to not use server
# API classes and instead set up the auth directly, however I just don't have
# the time during the git refactor to do it now.
# jdob, June 12, 2012
#
#
from ConfigParser import SafeConfigParser, NoOptionError
import shutil
import os
impor... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
#
# This file is part of Invenio.
# Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015 CERN.
#
# Invenio is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foun... | codeparrot/github-code-clean |
from Screen import Screen
from ServiceScan import ServiceScan
from Components.config import config, ConfigSubsection, ConfigSelection, \
ConfigYesNo, ConfigInteger, getConfigListEntry, ConfigSlider, ConfigEnableDisable
from Components.ActionMap import NumberActionMap, ActionMap
from Components.ConfigList import Config... | codeparrot/github-code-clean |
import sys
import numpy as np
from scipy import rand
from scipy.linalg import toeplitz, eigvalsh
from scipy.sparse.linalg import eigsh, lobpcg, eigs
from scipy.sparse import lil_matrix, diags, block_diag, csr_matrix, bmat, kron
import matplotlib.pyplot as plt
import argparse
from mpl_toolkits.mplot3d import Axes3D
from... | codeparrot/github-code-clean |
#!/usr/bin/env python
#
# VMEncryption extension
#
# Copyright 2015 Microsoft Corporation
#
# 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
#... | codeparrot/github-code-clean |
# Copyright (c) 2011 X.commerce, a business unit of eBay Inc.
# Copyright 2010 United States Government as represented by the
# Administrator of the National Aeronautics and Space Administration.
# Copyright 2014 IBM Corp.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you... | codeparrot/github-code-clean |
#
# Pyrex - Parse tree nodes
#
import string, sys
import Code
from Errors import error, one_time_warning, InternalError
import Naming
import PyrexTypes
from PyrexTypes import py_object_type, c_int_type, error_type, \
CTypedefType, CFuncType
from Symtab import ModuleScope, LocalScope, \
StructOrUnionScope, P... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
# Authors: Alexandre Gramfort <alexandre.gramfort@inria.fr>
# Matti Hämäläinen <msh@nmr.mgh.harvard.edu>
# Martin Luessi <mluessi@nmr.mgh.harvard.edu>
# Denis Engemann <denis.engemann@gmail.com>
# Teon Brooks <teon.brooks@gmail.com>
# Marijn van Vliet... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
import json
import os
import socket
from datetime import datetime, timedelta
from decimal import Decimal
from django.conf import settings
from django.core import mail
from django.core.files.storage import default_storage as storage
import jingo
import mock
import waffle
from jingo.helpers impo... | codeparrot/github-code-clean |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2003-2013 Edgewall Software
# All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution. The terms
# are also available at http://trac.edgewall.org/wiki/TracLicense.
#
# T... | codeparrot/github-code-clean |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#
#
# Copyright (c) 2008-2011 University of Dundee.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License... | codeparrot/github-code-clean |
#!/usr/bin/env python
#
# (C) 2001 by Argonne National Laboratory.
# See COPYRIGHT in top-level directory.
#
"""
usage:
mpiexec [-h or -help or --help] # get this message
mpiexec -file filename # (or -f) filename contains XML job description
mpiexec [global args] [local args] executable [args]
... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
##############################################################################
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
import re
import os
import sys
import locale
import datetime
import decimal
import copy
import time
import base64
import types
import json
from .._compat import PY2, pjoin, exists, pickle, hashlib_md5, iterkeys, \
iteritems, with_metaclass, to_unicode, integer_types, basestring, \
strin... | codeparrot/github-code-clean |
import json
import os
from datetime import datetime, timedelta
from unittest.mock import Mock, patch
from django import forms
from django.conf import settings
from django.core import mail
from django.db import IntegrityError
from django.utils import translation
import pytest
from waffle.testutils import override_swi... | codeparrot/github-code-clean |
# -----------------------------------------------------------------------------
# ply: yacc.py
#
# Copyright (C) 2001-2009,
# David M. Beazley (Dabeaz LLC)
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions a... | codeparrot/github-code-clean |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author: Andrew Jewett (jewett.aij at g mail)
# http://www.chem.ucsb.edu/~sheagroup
# License: 3-clause BSD License (See LICENSE.TXT)
# Copyright (c) 2012, Regents of the University of California
# All rights reserved.
"""
ltemplify.py
The "ltemplify.py" script... | codeparrot/github-code-clean |
#!/usr/bin/env python
"""
Easy Install
------------
A tool for doing automatic download/extract/build of distutils-based Python
packages. For detailed documentation, see the accompanying EasyInstall.txt
file, or visit the `EasyInstall home page`__.
__ https://setuptools.readthedocs.io/en/latest/easy_install.html
""... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
import six
from nose.plugins.skip import SkipTest
import datetime
import unittest
import uuid
import math
import itertools
import re
import six
try:
import dateutil
except ImportError:
dateutil = None
from decimal import Decimal
from bson import Binary, DBRef, ObjectId
try:
from ... | codeparrot/github-code-clean |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# CAVEAT UTILITOR
#
# This file was automatically generated by Grako.
#
# https://pypi.python.org/pypi/grako/
#
# Any changes you make to it will be overwritten the next time
# the file is generated.
from __future__ import print_function, division, absolute_import, un... | codeparrot/github-code-clean |
import os
import sys
import time
import shlex
import shutil
import random
import inspect
import logging
import asyncio
import pathlib
import traceback
import math
import re
import aiohttp
import discord
import colorlog
from io import BytesIO, StringIO
from functools import wraps
from textwrap import dedent
from datet... | codeparrot/github-code-clean |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''Utilities for Natural Language Processing (NLP):
* Vocabulary and dimension reduction
* Word statistics calculation
* Add a timezone to a datetime
* Slice a django queryset
* Genereate batches from a long list or sequence
* Inverse dict/hashtable lookup
* Generate a val... | codeparrot/github-code-clean |
"""
Mouse class
"""
import re
from openrazer_daemon.hardware.device_base import RazerDeviceBrightnessSuspend as __RazerDeviceBrightnessSuspend, RazerDeviceSpecialBrightnessSuspend as __RazerDeviceSpecialBrightnessSuspend, RazerDevice as __RazerDevice
from openrazer_daemon.misc.battery_notifier import BatteryManager as ... | codeparrot/github-code-clean |
## This file is part of CDS Invenio.
## Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008 CERN.
##
## CDS Invenio is free software; you can redistribute it and/or
## modify it under the terms of the GNU General Public License as
## published by the Free Software Foundation; either version 2 of the
## License, or (... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals, absolute_import
import datetime
import unittest
import shutil
import sys
import tempfile
import os
import json
import pygit2
from mock import patch, MagicMock
sys.path.insert(0, os.path.join(os.path.dirname(
os.path.abspath(__file__)), '..'))
imp... | codeparrot/github-code-clean |
def borders(left, right, *args):
if not args:
return [-left / 2, left / 2, -right / 2, right / 2]
else:
return [left, right, args[0], args[1]]
obstacles = [
{"images": "iso_tree_stump.png",
"borders": borders(0.60, 0.60)},
{"images": "iso_wall_grey_ns.png",
"borders": borde... | codeparrot/github-code-clean |
#!/usr/bin/env python
""" File Catalog Client Command Line Interface. """
__RCSID__ = "$Id$"
import cmd
import commands
import os.path
import time
import sys
from types import DictType, ListType
from DIRAC.Core.Security.ProxyInfo import getProxyInfo
from DIRAC.Core.Utilities.List import uniqueElements
from DIRAC.In... | codeparrot/github-code-clean |
# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
#
# 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 applica... | codeparrot/github-code-clean |
# Copyright 2020 Google
#
# 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
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, soft... | codeparrot/github-code-clean |
# Copyright 2015-2017 Capital One Services, LLC
#
# 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 agreed ... | codeparrot/github-code-clean |
# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# 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 applica... | codeparrot/github-code-clean |
"""
CUDA driver bridge implementation
NOTE:
The new driver implementation uses a *_PendingDeallocs* that help prevents a
crashing the system (particularly OSX) when the CUDA context is corrupted at
resource deallocation. The old approach ties resource management directly
into the object destructor; thus, at corruptio... | codeparrot/github-code-clean |
from __future__ import division
from warnings import warn
import numpy as np
import PIL.Image as PILImage
from menpo.compatibility import basestring
from menpo.base import Vectorizable, MenpoDeprecationWarning
from menpo.shape import PointCloud
from menpo.landmark import Landmarkable
from menpo.transform import (Tran... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
import unittest
import pickle
import cPickle
import StringIO
import cStringIO
import pickletools
import copy_reg
import sys
from test import test_support as support
from test.test_support import TestFailed, verbose, have_unicode, TESTFN
try:
from test.test_support import _2G, _1M, precision... | codeparrot/github-code-clean |
# Rekall Memory Forensics
# Copyright (C) 2007,2008 Volatile Systems
# Copyright 2013 Google Inc. All Rights Reserved.
#
# Copyright (C) 2005,2006 4tphi Research
# Author: {npetroni,awalters}@4tphi.net (Nick Petroni and AAron Walters)
# Author: Michael Cohen scudette@gmail.com.
#
# This program is free software; you ca... | codeparrot/github-code-clean |
# coding: utf-8
from __future__ import unicode_literals
import unittest
import io
from lxml import isoschematron, etree
from packtools.catalogs import SCHEMAS
SCH = etree.parse(SCHEMAS['sps-1.8'])
def TestPhase(phase_name, cache):
"""Factory of parsed Schematron phases.
:param phase_name: the phase name
... | codeparrot/github-code-clean |
import builtins
import copyreg
import gc
import itertools
import math
import pickle
import sys
import types
import unittest
import warnings
import weakref
from copy import deepcopy
from test import support
class OperatorsTest(unittest.TestCase):
def __init__(self, *args, **kwargs):
unittest.TestCase.__i... | codeparrot/github-code-clean |
#
# Custom partitioning classes.
#
# Copyright (C) 2012-2014 Red Hat, Inc.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions of
# the GNU General Public License v.2, or (at your option) any later version.
# This program is d... | codeparrot/github-code-clean |
# -*- coding: utf-8 -*-
#
# This file is part of Invenio.
# Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2013, 2014, 2015 CERN.
#
# Invenio is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 2... | codeparrot/github-code-clean |
# $ANTLR 3.5.1 /Users/montselozanod/Documents/Tec/Compilers/Chabuildly/chabuildly.g 2016-03-02 22:50:02
import sys
from antlr3 import *
from antlr3.compat import set, frozenset
# for convenience in actions
HIDDEN = BaseRecognizer.HIDDEN
# token types
EOF=-1
T__11=11
T__12=12
T__13=13
T__14=14
T__15=15
T__16=16
T__... | codeparrot/github-code-clean |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.