inputs stringlengths 312 52k | targets stringlengths 1 3.1k ⌀ | block_type stringclasses 11
values | scenario stringclasses 7
values |
|---|---|---|---|
<filename>ollama-python/ollama/_client.py<fim_prefix>import os
import io
import json
import httpx
import binascii
import platform
import urllib.parse
from os import PathLike
from pathlib import Path
from hashlib import sha256
from base64 import b64encode, b64decode
from typing import Any, AnyStr, Union, Optional, Sequ... | httpx.HTTPStatusError as e:
e.response.read()
raise ResponseError(e.response.text, e.response.status_code) from None | CATCH | prefix_suffix_full_complete_current_block_with_evidence |
<filename>ollama-python/ollama/_client.py<fim_prefix>import os
import io
import json
import httpx
import binascii
import platform
import urllib.parse
from os import PathLike
from pathlib import Path
from hashlib import sha256
from base64 import b64encode, b64decode
from typing import Any, AnyStr, Union, Optional, Sequ... | line in io.StringIO(modelfile):
command, _, args = line.partition(' ')
if command.upper() not in ['FROM', 'ADAPTER']:
print(line, end='', file=out)
continue
path = Path(args.strip()).expanduser()
path = path if path.is_absolute() else base / path
if path.exists():
... | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>ollama-python/ollama/_client.py<fim_prefix>import os
import io
import json
import httpx
import binascii
import platform
import urllib.parse
from os import PathLike
from pathlib import Path
from hashlib import sha256
from base64 import b64encode, b64decode
from typing import Any, AnyStr, Union, Optional, Sequ... | message in messages or []:
if not isinstance(message, dict):
raise TypeError('messages must be a list of strings')
if not (role := message.get('role')) or role not in ['system', 'user', 'assistant']:
raise RequestError('messages must contain a role and it must be one of "system", "user", or... | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>ollama-python/ollama/_client.py<fim_prefix>import os
import io
import json
import httpx
import binascii
import platform
import urllib.parse
from os import PathLike
from pathlib import Path
from hashlib import sha256
from base64 import b64encode, b64decode
from typing import Any, AnyStr, Union, Optional, Sequ... | line in r.iter_lines():
partial = json.loads(line)
if e := partial.get('error'):
raise ResponseError(e)
yield partial | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>ollama-python/ollama/_client.py<fim_prefix>import os
import io
import json
import httpx
import binascii
import platform
import urllib.parse
from os import PathLike
from pathlib import Path
from hashlib import sha256
from base64 import b64encode, b64decode
from typing import Any, AnyStr, Union, Optional, Sequ... | line in io.StringIO(modelfile):
command, _, args = line.partition(' ')
if command.upper() not in ['FROM', 'ADAPTER']:
print(line, end='', file=out)
continue
path = Path(args.strip()).expanduser()
path = path if path.is_absolute() else base / path
if path.exists():
... | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>ollama-python/ollama/_client.py<fim_prefix>import os
import io
import json
import httpx
import binascii
import platform
import urllib.parse
from os import PathLike
from pathlib import Path
from hashlib import sha256
from base64 import b64encode, b64decode
from typing import Any, AnyStr, Union, Optional, Sequ... | message in messages or []:
if not isinstance(message, dict):
raise TypeError('messages must be a list of Message or dict-like objects')
if not (role := message.get('role')) or role not in ['system', 'user', 'assistant']:
raise RequestError('messages must contain a role and it must be one of... | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>ollama-python/ollama/_client.py<fim_prefix>import os
import io
import json
import httpx
import binascii
import platform
import urllib.parse
from os import PathLike
from pathlib import Path
from hashlib import sha256
from base64 import b64encode, b64decode
from typing import Any, AnyStr, Union, Optional, Sequ... | for line in r.aiter_lines():
partial = json.loads(line)
if e := partial.get('error'):
raise ResponseError(e)
yield partial | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>ollama-python/ollama/_client.py<fim_prefix>import os
import io
import json
import httpx
import binascii
import platform
import urllib.parse
from os import PathLike
from pathlib import Path
from hashlib import sha256
from base64 import b64encode, b64decode
from typing import Any, AnyStr, Union, Optional, Sequ... | for line in r.aiter_lines():
partial = json.loads(line)
if e := partial.get('error'):
raise ResponseError(e)
yield partial | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>ollama-python/ollama/_client.py<fim_prefix>import os
import io
import json
import httpx
import binascii
import platform
import urllib.parse
from os import PathLike
from pathlib import Path
from hashlib import sha256
from base64 import b64encode, b64decode
from typing import Any, AnyStr, Union, Optional, Sequ... | def inner():
async with self._client.stream(method, url, **kwargs) as r:
try:
r.raise_for_status()
except httpx.HTTPStatusError as e:
e.response.read()
raise ResponseError(e.response.text, e.response.status_code) from None
async for line in r.aiter_lines():
... | METHOD | prefix_suffix_full_complete_current_block_with_evidence |
<filename>ollama-python/ollama/_client.py<fim_prefix>import os
import io
import json
import httpx
import binascii
import platform
import urllib.parse
from os import PathLike
from pathlib import Path
from hashlib import sha256
from base64 import b64encode, b64decode
from typing import Any, AnyStr, Union, Optional, Sequ... | def upload_bytes():
with open(path, 'rb') as r:
while True:
chunk = r.read(32 * 1024)
if not chunk:
break
yield chunk | METHOD | prefix_suffix_full_complete_current_block_with_evidence |
<filename>ollama-python/ollama/_client.py<fim_prefix>import os
import io
import json
import httpx
import binascii
import platform
import urllib.parse
from os import PathLike
from pathlib import Path
from hashlib import sha256
from base64 import b64encode, b64decode
from typing import Any, AnyStr, Union, Optional, Sequ... | True:
chunk = r.read(32 * 1024)
if not chunk:
break
yield chunk | WHILE | prefix_suffix_full_complete_current_block_with_evidence |
<filename>ollama-python/ollama/_client.py<fim_prefix>import os
import io
import json
import httpx
import binascii
import platform
import urllib.parse
from os import PathLike
from pathlib import Path
from hashlib import sha256
from base64 import b64encode, b64decode
from typing import Any, AnyStr, Union, Optional, Sequ... | True:
chunk = r.read(32 * 1024)
if not chunk:
break
sha256sum.update(chunk) | WHILE | prefix_suffix_full_complete_current_block_with_evidence |
<filename>ollama-python/ollama/_client.py<fim_prefix>import os
import io
import json
import httpx
import binascii
import platform
import urllib.parse
from os import PathLike
from pathlib import Path
from hashlib import sha256
from base64 import b64encode, b64decode
from typing import Any, AnyStr, Union, Optional, Sequ... | True:
chunk = r.read(32 * 1024)
if not chunk:
break
sha256sum.update(chunk) | WHILE | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/iris_response/conv_filter_bank.py<fim_prefix>from typing import List, Tuple
import numpy as np
from pydantic import root_validator, validator
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import IrisFilterResponse, NormalizedIris
from iris.io.validators import... | convolution to a given normalized iris image with the filter and probe schema.
Args:
img_filter (ImageFilter): filter used for convolution.
probe_schema (ProbeSchema): probe schema used for convolution.
normalization_output (NormalizedIris): Output of the normalization proc... | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/geometry_refinement/contour_points_filter.py<fim_prefix>import cv2
import numpy as np
from pydantic import Field
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import GeometryPolygons, NoiseMask
class ContourPointNoiseEyeballDistanceFilter(Algorithm):
"""I... | polygon refinement by filtering out those iris/pupil polygons points which are to close to eyeball or noise.
Args:
polygons (GeometryPolygons): Polygons to refine.
geometry_mask (NoiseMask): Geometry noise mask.
Returns:
GeometryPolygons: Refined geometry polygons.... | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/eye_properties_estimation/iris_bbox_calculator.py<fim_prefix>from numbers import Number
from typing import Tuple, Union
import numpy as np
from pydantic import validator
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import BoundingBox, GeometryPolygons, IRImag... | parameters.
WARNING: Depending on wether `buffer` is a float or an int, behaviour differs.
`buffer=2.0` => the iris size will be multiplied by 2., `buffer=2` => 2 pixels padding will be added.
Args:
buffer (Union[int, float, Tuple[Number, Number]], optional): Iris buffer in pixels... | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/normalization/common.py<fim_prefix>from typing import Tuple
import numpy as np
from pydantic import NonNegativeInt
from iris.io.dataclasses import GeometryPolygons
from iris.utils import common
def generate_iris_mask(extrapolated_contours: GeometryPolygons, noise_mask: np.ndarray)... | interpolation points coordinates.
Args:
image (np.ndarray): Original, not normalized image.
pixel_x (float): Pixel x coordinate.
pixel_y (float): Pixel y coordinate.
Returns:
Tuple[float, float, float, float]: Tuple with interpolation points coordinates... | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/callbacks/pipeline_trace.py<fim_prefix>from __future__ import annotations
from typing import Any, Dict, Iterable, List, Optional
from iris.callbacks.callback_interface import Callback
from iris.io.class_configs import Algorithm
from iris.orchestration.pipeline_dataclasses import PipelineN... | stored error.
Returns:
Optional[Exception]: error.
""" | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/validators/cross_object_validators.py<fim_prefix>import numpy as np
from pydantic import Field
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import EyeCenters, GeometryPolygons, IRImage
from iris.io.errors import ExtrapolatedPolygonsInsideImageValidatorError, E... | parameters.
Args:
min_distance_to_border (float, optional): Minimum allowed distance to image boundary.
Defaults to 0.0 (Eye centers can be at the image border).
""" | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/callbacks/pipeline_trace.py<fim_prefix>from __future__ import annotations
from typing import Any, Dict, Iterable, List, Optional
from iris.callbacks.callback_interface import Callback
from iris.io.class_configs import Algorithm
from iris.orchestration.pipeline_dataclasses import PipelineN... | result_name result.
Args:
result_name (str): Result name.
Raises:
PipelineCallTraceStorageError: Raised if result_name is not found.
Returns:
Any: Result object.
""" | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/geometry_refinement/smoothing.py<fim_prefix>from typing import List, Tuple
import numpy as np
from pydantic import Field
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import EyeCenters, GeometryPolygons
from iris.io.errors import GeometryRefinementError
from i... | contour into arcs.
Args:
polygon (np.ndarray): Contour polygon.
center_xy (Tuple[float, float]): Polygon's center.
Returns:
Tuple[List[np.ndarray], int]: Tuple with: (list of list of vertices, number of gaps detected in a contour).
""" | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/eye_properties_estimation/pupil_iris_property_calculator.py<fim_prefix>from typing import List
from pydantic import Field
from iris.callbacks.callback_interface import Callback
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import EyeCenters, GeometryPolygons, ... | parameters.
Args:
min_pupil_diameter (float): minimum pupil diameter. Defaults to 1.0.
min_iris_diameter (float): minimum iris diameter. Defaults to 150.0.
callbacks (List[Callback]): callbacks list. Defaults to [].
""" | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/vectorization/contouring.py<fim_prefix>from typing import Callable, List
import cv2
import numpy as np
from pydantic import NonNegativeFloat
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import GeometryMask, GeometryPolygons
from iris.io.errors import Vectoriz... | parameters.
Args:
contour_filters (List[Callable[[List[np.ndarray]], List[np.ndarray]]], optional): List of filter functions used to filter out noise in polygons.
Defaults to [ContouringAlgorithm.filter_polygon_areas].
""" | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/iris_response/probe_schemas/regular_probe_schema.py<fim_prefix>from typing import List, Literal, Optional, Tuple, Union
import numpy as np
from pydantic import Field, PositiveInt, confloat, fields, validator
from iris.io.errors import ProbeSchemaError
from iris.nodes.iris_response.p... | = phis.flatten() | STATEMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/eye_properties_estimation/occlusion_calculator.py<fim_prefix>from typing import List, Tuple
import numpy as np
from pydantic import Field
from iris.callbacks.callback_interface import Callback
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import EyeCenters, Ey... | = common.contour_to_mask(extrapolated_polygons.pupil_array, mask_shape=(img_w, img_h)) | STATEMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/normalization/nonlinear_normalization.py<fim_prefix>from typing import Collection, Tuple
import numpy as np
from pydantic import Field
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import EyeOrientation, GeometryPolygons, IRImage, NoiseMask, NormalizedIris
fro... | = src_points.shape[0:2] | STATEMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/utils/common.py<fim_prefix>from typing import Tuple
import cv2
import numpy as np
def contour_to_mask(vertices: np.ndarray, mask_shape: Tuple[int, int]) -> np.ndarray:
"""Generate binary mask based on polygon's vertices.
Args:
vertices (np.ndarray): Vertices points array... | height = mask_shape | STATEMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/eye_properties_estimation/bisectors_method.py<fim_prefix>from typing import Tuple
import numpy as np
from pydantic import Field
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import EyeCenters, GeometryPolygons
from iris.io.errors import EyeCentersEstimationErr... | = norms > min_distance_between_sector_points_in_px | STATEMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/iris_response/probe_schemas/regular_probe_schema.py<fim_prefix>from typing import List, Literal, Optional, Tuple, Union
import numpy as np
from pydantic import Field, PositiveInt, confloat, fields, validator
from iris.io.errors import ProbeSchemaError
from iris.nodes.iris_response.p... | = np.linspace(0, 1, self.params.n_cols, endpoint=False) | STATEMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/normalization/common.py<fim_prefix>from typing import Tuple
import numpy as np
from pydantic import NonNegativeInt
from iris.io.dataclasses import GeometryPolygons
from iris.utils import common
def generate_iris_mask(extrapolated_contours: GeometryPolygons, noise_mask: np.ndarray)... | xmin, ymin, xmax, ymax | STATEMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/iris_response/image_filters/gabor_filters.py<fim_prefix>from typing import Any, Dict, Tuple
import numpy as np
from pydantic import Field, conint, root_validator, validator
import iris.io.validators as pydantic_v
from iris.io.errors import ImageFilterError
from iris.nodes.iris_respo... | = np.mean(envelope, axis=-1) | STATEMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/io/validators.py<fim_prefix>from typing import Any, Callable, Dict, Iterable, List
import numpy as np
from pydantic import fields
# ----- validators -----
def is_odd(cls: type, v: int, field: fields.ModelField) -> int:
"""Check that kernel size are odd numbers.
Args:
cl... | values | STATEMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/vectorization/contouring.py<fim_prefix>from typing import Callable, List
import cv2
import numpy as np
from pydantic import NonNegativeFloat
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import GeometryMask, GeometryPolygons
from iris.io.errors import Vectoriz... | filtered_polygons | STATEMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/iris_response_refinement/fragile_bits_refinement.py<fim_prefix>from typing import Literal, Tuple
import numpy as np
from pydantic import confloat
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import IrisFilterResponse
class FragileBitRefinement(Algorithm):
... | iris_response, iris_mask in zip(iris_filter_response.iris_responses, iris_filter_response.mask_responses):
if self.params.fragile_type == "cartesian":
mask_value_real = np.abs(np.real(iris_response)) >= self.params.value_threshold[0]
mask_value_imaginary = np.abs(np.imag(iri... | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/geometry_refinement/smoothing.py<fim_prefix>from typing import List, Tuple
import numpy as np
from pydantic import Field
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import EyeCenters, GeometryPolygons
from iris.io.errors import GeometryRefinementError
from i... | i in range(-kernel_offset, kernel_offset + 1):
stacked_signals.append(np.roll(signal, i)) | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/eye_properties_estimation/bisectors_method.py<fim_prefix>from typing import Tuple
import numpy as np
from pydantic import Field
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import EyeCenters, GeometryPolygons
from iris.io.errors import EyeCentersEstimationErr... | _ in range(self.params.max_iterations):
random_indices = np.random.choice(len(polygon), size=(self.params.num_bisectors, 2))
first_drawn_points = polygon[random_indices[:, 0]]
second_drawn_points = polygon[random_indices[:, 1]]
norms = np.linalg.norm(first_drawn_points... | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/io/dataclasses.py<fim_prefix>from __future__ import annotations
from typing import Any, Dict, List, Literal, Tuple
import numpy as np
from pydantic import Field, NonNegativeInt, root_validator, validator
from iris.io import validators as v
from iris.io.class_configs import ImmutableModel... | index, name in self.index2class.items():
if name == class_name:
return index | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/iris_response/conv_filter_bank.py<fim_prefix>from typing import List, Tuple
import numpy as np
from pydantic import root_validator, validator
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import IrisFilterResponse, NormalizedIris
from iris.io.validators import... | i_filter, i_schema in zip(self.params.filters, self.params.probe_schemas):
iris_response, mask_response = self._convolve(i_filter, i_schema, normalization_output)
iris_responses.append(iris_response)
mask_responses.append(mask_response) | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/callbacks/pipeline_trace.py<fim_prefix>from __future__ import annotations
from typing import Any, Dict, Iterable, List, Optional
from iris.callbacks.callback_interface import Callback
from iris.io.class_configs import Algorithm
from iris.orchestration.pipeline_dataclasses import PipelineN... | result_name in self._storage.keys():
self._storage[result_name] = None | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/geometry_refinement/contour_interpolation.py<fim_prefix>from typing import List
import numpy as np
from pydantic import Field
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import GeometryPolygons
class ContourInterpolation(Algorithm):
"""Implementation o... | (x1, y1), (x2, y2), num_point in zip(previous_boundary, polygon, num_points):
x.append(np.linspace(x1, x2, num=num_point, endpoint=False))
y.append(np.linspace(y1, y2, num=num_point, endpoint=False)) | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/normalization/perspective_normalization.py<fim_prefix>from typing import Collection, List, Tuple
import cv2
import numpy as np
from pydantic import Field, validator
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import EyeOrientation, GeometryPolygons, IRImage,... | radius in self.params.intermediate_radiuses:
ring = pupil_points + radius * (iris_points - pupil_points)
ring = np.vstack([ring, ring[0]])
src_points.append(ring) | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/normalization/perspective_normalization.py<fim_prefix>from typing import Collection, List, Tuple
import cv2
import numpy as np
from pydantic import Field, validator
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import EyeOrientation, GeometryPolygons, IRImage,... | angle_point_idx in range(src_points.shape[1] - 1):
for ring_idx in range(src_points.shape[0] - 1):
current_src, current_dst = self._correspondence_rois_coords(
angle_idx=angle_point_idx,
ring_idx=ring_idx,
src_points=src_points,
... | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/encoder/iris_encoder.py<fim_prefix>from typing import List
import numpy as np
from pydantic import Field
from iris.callbacks.callback_interface import Callback
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import IrisFilterResponse, IrisTemplate
class IrisEn... | iris_response, mask_response in zip(response.iris_responses, response.mask_responses):
mask_code = mask_response >= self.params.mask_threshold
iris_code = np.stack([iris_response.real > 0, iris_response.imag > 0], axis=-1)
mask_code = np.stack([mask_code, mask_code], axis=-1)
... | FOR | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/iris_response/image_filters/gabor_filters.py<fim_prefix>from typing import Any, Dict, Tuple
import numpy as np
from pydantic import Field, conint, root_validator, validator
import iris.io.validators as pydantic_v
from iris.io.errors import ImageFilterError
from iris.nodes.iris_respo... | self.params.dc_correction:
# Step 1: calculate mean value of Gabor Wavelet
g_mean = np.mean(np.real(kernel_values), axis=-1)
# Step 2: define gaussian offset
correction_term_mean = np.mean(envelope, axis=-1)
# Step 3: substract gaussian
kernel_val... | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/normalization/common.py<fim_prefix>from typing import Tuple
import numpy as np
from pydantic import NonNegativeInt
from iris.io.dataclasses import GeometryPolygons
from iris.utils import common
def generate_iris_mask(extrapolated_contours: GeometryPolygons, noise_mask: np.ndarray)... | xmin == xmax and not xmax == img_w - 1:
xmax += 1 | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/iris_response/probe_schemas/regular_probe_schema.py<fim_prefix>from typing import List, Literal, Optional, Tuple, Union
import numpy as np
from pydantic import Field, PositiveInt, confloat, fields, validator
from iris.io.errors import ProbeSchemaError
from iris.nodes.iris_response.p... | isinstance(self.params.boundary_phi, List):
phi = np.linspace(
0 + self.params.boundary_phi[0], 1 - self.params.boundary_phi[1], self.params.n_cols, endpoint=True
) | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/geometry_refinement/smoothing.py<fim_prefix>from typing import List, Tuple
import numpy as np
from pydantic import Field
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import EyeCenters, GeometryPolygons
from iris.io.errors import GeometryRefinementError
from i... | gap_indices.size < 2:
return [polygon], gap_indices.size | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/io/dataclasses.py<fim_prefix>from __future__ import annotations
from typing import Any, Dict, List, Literal, Tuple
import numpy as np
from pydantic import Field, NonNegativeInt, root_validator, validator
from iris.io import validators as v
from iris.io.class_configs import ImmutableModel... | name == class_name:
return index | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/normalization/common.py<fim_prefix>from typing import Tuple
import numpy as np
from pydantic import NonNegativeInt
from iris.io.dataclasses import GeometryPolygons
from iris.utils import common
def generate_iris_mask(extrapolated_contours: GeometryPolygons, noise_mask: np.ndarray)... | xmin == xmax and not xmax == img_w - 1:
xmax += 1 | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/iris_response/probe_schemas/regular_probe_schema.py<fim_prefix>from typing import List, Literal, Optional, Tuple, Union
import numpy as np
from pydantic import Field, PositiveInt, confloat, fields, validator
from iris.io.errors import ProbeSchemaError
from iris.nodes.iris_response.p... | self.params.boundary_phi == "periodic-left":
phi = np.linspace(0, 1, self.params.n_cols, endpoint=False) | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/io/validators.py<fim_prefix>from typing import Any, Callable, Dict, Iterable, List
import numpy as np
from pydantic import fields
# ----- validators -----
def is_odd(cls: type, v: int, field: fields.ModelField) -> int:
"""Check that kernel size are odd numbers.
Args:
cl... | len(values[field1]) != len(values[field2]):
raise ValueError(
f"{cls.__name__}: {field1} and {field2} length mismatch, "
f"resp. {len(values[field1])} and {len(values[field2])}"
) | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/normalization/common.py<fim_prefix>from typing import Tuple
import numpy as np
from pydantic import NonNegativeInt
from iris.io.dataclasses import GeometryPolygons
from iris.utils import common
def generate_iris_mask(extrapolated_contours: GeometryPolygons, noise_mask: np.ndarray)... | ymin == ymax and not ymax == img_h - 1:
ymax += 1 | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/iris_response/image_filters/gabor_filters.py<fim_prefix>from typing import Any, Dict, Tuple
import numpy as np
from pydantic import Field, conint, root_validator, validator
import iris.io.validators as pydantic_v
from iris.io.errors import ImageFilterError
from iris.nodes.iris_respo... | norm_real > 0:
kernel_values.real /= norm_real | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/iris_response/image_filters/gabor_filters.py<fim_prefix>from typing import Any, Dict, Tuple
import numpy as np
from pydantic import Field, conint, root_validator, validator
import iris.io.validators as pydantic_v
from iris.io.errors import ImageFilterError
from iris.nodes.iris_respo... | normalize kernel values | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/utils/math.py<fim_prefix>import math
from typing import Dict, Tuple
import numpy as np
def area(array: np.ndarray) -> float:
"""Shoelace formula for simple polygon area calculation.
WARNING: This formula only works for simple polygons, i.e planar polygon without self-intersectio... | fmt: on | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/iris_response/image_filters/gabor_filters.py<fim_prefix>from typing import Any, Dict, Tuple
import numpy as np
from pydantic import Field, conint, root_validator, validator
import iris.io.validators as pydantic_v
from iris.io.errors import ImageFilterError
from iris.nodes.iris_respo... | calculate kernel values | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/eye_properties_estimation/bisectors_method.py<fim_prefix>from typing import Tuple
import numpy as np
from pydantic import Field
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import EyeCenters, GeometryPolygons
from iris.io.errors import EyeCentersEstimationErr... | Add perpendicular vector to center and normalize | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/geometry_estimation/lsq_ellipse_fit_with_refinement.py<fim_prefix>from typing import List
import cv2
import numpy as np
from pydantic import Field
from iris.callbacks.callback_interface import Callback
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import Geome... | Rotate such that 0 degree is parallel with x-axis and array is clockwise | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/iris_response/image_filters/gabor_filters.py<fim_prefix>from typing import Any, Dict, Tuple
import numpy as np
from pydantic import Field, conint, root_validator, validator
import iris.io.validators as pydantic_v
from iris.io.errors import ImageFilterError
from iris.nodes.iris_respo... | convert to polar coordinates | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/iris_response/probe_schemas/regular_probe_schema.py<fim_prefix>from typing import List, Literal, Optional, Tuple, Union
import numpy as np
from pydantic import Field, PositiveInt, confloat, fields, validator
from iris.io.errors import ProbeSchemaError
from iris.nodes.iris_response.p... | if image_shape provided: verify that values lie on pixel values | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/eye_properties_estimation/bisectors_method.py<fim_prefix>from typing import Tuple
import numpy as np
from pydantic import Field
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import EyeCenters, GeometryPolygons
from iris.io.errors import EyeCentersEstimationErr... | Flip xs with ys and flip sign of on of them to create a 90deg rotation | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/iris_response/image_filters/gabor_filters.py<fim_prefix>from typing import Any, Dict, Tuple
import numpy as np
from pydantic import Field, conint, root_validator, validator
import iris.io.validators as pydantic_v
from iris.io.errors import ImageFilterError
from iris.nodes.iris_respo... | Step 1: calculate mean value of Gabor Wavelet | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/iris_response/image_filters/gabor_filters.py<fim_prefix>from typing import Any, Dict, Tuple
import numpy as np
from pydantic import Field, conint, root_validator, validator
import iris.io.validators as pydantic_v
from iris.io.errors import ImageFilterError
from iris.nodes.iris_respo... | calculate carrier and envelope | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/normalization/perspective_normalization.py<fim_prefix>from typing import Collection, List, Tuple
import cv2
import numpy as np
from pydantic import Field, validator
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import EyeOrientation, GeometryPolygons, IRImage,... |
img_x, img_y = map(int, image_xy)
normalized_mask_roi[shifted_y, shifted_x] = iris_mask[img_y, img_x] | TRY | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/normalization/common.py<fim_prefix>from typing import Tuple
import numpy as np
from pydantic import NonNegativeInt
from iris.io.dataclasses import GeometryPolygons
from iris.utils import common
def generate_iris_mask(extrapolated_contours: GeometryPolygons, noise_mask: np.ndarray)... |
return image[int(pixel_y), int(pixel_x)] | TRY | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/normalization/common.py<fim_prefix>from typing import Tuple
import numpy as np
from pydantic import NonNegativeInt
from iris.io.dataclasses import GeometryPolygons
from iris.utils import common
def generate_iris_mask(extrapolated_contours: GeometryPolygons, noise_mask: np.ndarray)... |
return image[int(pixel_y), int(pixel_x)] | TRY | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/normalization/common.py<fim_prefix>from typing import Tuple
import numpy as np
from pydantic import NonNegativeInt
from iris.io.dataclasses import GeometryPolygons
from iris.utils import common
def generate_iris_mask(extrapolated_contours: GeometryPolygons, noise_mask: np.ndarray)... | IndexError:
return 0.0 | CATCH | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/normalization/perspective_normalization.py<fim_prefix>from typing import Collection, List, Tuple
import cv2
import numpy as np
from pydantic import Field, validator
from iris.io.class_configs import Algorithm
from iris.io.dataclasses import EyeOrientation, GeometryPolygons, IRImage,... | IndexError:
normalized_mask_roi[shifted_y, shifted_x] = False | CATCH | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/normalization/common.py<fim_prefix>from typing import Tuple
import numpy as np
from pydantic import NonNegativeInt
from iris.io.dataclasses import GeometryPolygons
from iris.utils import common
def generate_iris_mask(extrapolated_contours: GeometryPolygons, noise_mask: np.ndarray)... | IndexError:
return 0.0 | CATCH | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/normalization/common.py<fim_prefix>from typing import Tuple
import numpy as np
from pydantic import NonNegativeInt
from iris.io.dataclasses import GeometryPolygons
from iris.utils import common
def generate_iris_mask(extrapolated_contours: GeometryPolygons, noise_mask: np.ndarray)... | get_pixel_intensity(image: np.ndarray, pixel_x: float, pixel_y: float) -> float:
"""Get the intensity value of a pixel from an intensity image.
Args:
image (np.ndarray): Intensity image.
pixel_x (float): Pixel x coordinate.
pixel_y (float): Pixel y coordinate.
... | METHOD | prefix_suffix_full_complete_current_block_with_evidence |
<filename>open-iris/src/iris/nodes/normalization/common.py<fim_prefix>from typing import Tuple
import numpy as np
from pydantic import NonNegativeInt
from iris.io.dataclasses import GeometryPolygons
from iris.utils import common
def generate_iris_mask(extrapolated_contours: GeometryPolygons, noise_mask: np.ndarray)... | get_interpolation_points_coords(
image: np.ndarray, pixel_x: float, pixel_y: float
) -> Tuple[float, float, float, float]:
"""Extract interpolation points coordinates.
Args:
image (np.ndarray): Original, not normalized image.
pixel_x (float): Pixel x coordinate.
... | METHOD | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/postings.py<fim_prefix>"""Tokenized, searchable text as a pandas dtype."""
import pandas as pd
import numbers
from pandas.api.extensions import ExtensionDtype, ExtensionArray, register_extension_dtype
from pandas.api.types import is_list_like
from pandas.api.extensions import take
impo... | a mask on the postings array indicating which elements contain all terms.""" | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/utils/roaringish.py<fim_prefix>"""Roaring-ish bit array for storing sorted integers in numpy array.
See - https://softwaredoug.com/blog/2024/01/21/search-array-phrase-algorithm
"""
import numpy as np
import sortednp as snp
import logging
import numbers
from typing import Optional, Tup... | an encoded bit array into keys / payloads.""" | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/utils/roaringish.py<fim_prefix>"""Roaring-ish bit array for storing sorted integers in numpy array.
See - https://softwaredoug.com/blog/2024/01/21/search-array-phrase-algorithm
"""
import numpy as np
import sortednp as snp
import logging
import numbers
from typing import Optional, Tup... | keys to range or np.ndarray of uint64.""" | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/phrase/middle_out.py<fim_prefix>"""Encode positions in bits along with some neighboring information for wrapping.
See this notebook for motivation:
https://colab.research.google.com/drive/10tIEkdlCE_1J_CcgEcV0jkLfBc-0H4am?authuser=1#scrollTo=XWzy-n9dF3PG
"""
import numpy as np
impor... | bigram matches between two encoded arrays.
Returns:
--------
count: number of matches per doc
rhs_next: the next rhs array to continue matching
""" | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/postings.py<fim_prefix>"""Tokenized, searchable text as a pandas dtype."""
import pandas as pd
import numbers
from pandas.api.extensions import ExtensionDtype, ExtensionArray, register_extension_dtype
from pandas.api.types import is_list_like
from pandas.api.extensions import take
impo... | a boolean numpy array indicating which elements contain the given term.""" | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/utils/roaringish.py<fim_prefix>"""Roaring-ish bit array for storing sorted integers in numpy array.
See - https://softwaredoug.com/blog/2024/01/21/search-array-phrase-algorithm
"""
import numpy as np
import sortednp as snp
import logging
import numbers
from typing import Optional, Tup... | payload MSBs from encoded.""" | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/solr.py<fim_prefix>"""Utility functions for Solr users of searcharray."""
import re
import pandas as pd
import numpy as np
from typing import List, Optional, Dict, Tuple
from searcharray.postings import SearchArray
from searcharray.similarity import Similarity, default_bm25
def parse... | edismax search over dataframe with searcharray fields.
Parameters
----------
q : str
The query string
mm : str
The minimum should match spec
qf : list
The fields to search
pf : list
The fields to search for phrase matches
pf2 : list
The fields to sea... | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/utils/row_viewable_matrix.py<fim_prefix>import numbers
import numpy as np
from searcharray.utils.mat_set import SparseMatSet
from typing import Optional, Union, Dict, List
def rowwise_eq(mat: SparseMatSet, other: SparseMatSet) -> Union[bool, np.ndarray]:
"""Check<fim_suffix>
... | equals on a row-by-row basis.""" | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/solr.py<fim_prefix>"""Utility functions for Solr users of searcharray."""
import re
import pandas as pd
import numpy as np
from typing import List, Optional, Dict, Tuple
from searcharray.postings import SearchArray
from searcharray.similarity import Similarity, default_bm25
def parse... | Solr's qf, pf, pf2, pf3 field boosts.""" | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/postings.py<fim_prefix>"""Tokenized, searchable text as a pandas dtype."""
import pandas as pd
import numbers
from pandas.api.extensions import ExtensionDtype, ExtensionArray, register_extension_dtype
from pandas.api.types import is_list_like
from pandas.api.extensions import take
impo... | each doc using a similarity function.
Parameters
----------
token : str or list of str of what to search (already tokenized)
similarity : How to score the documents. Default is BM25.
""" | BLOCK_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/phrase/middle_out.py<fim_prefix>"""Encode positions in bits along with some neighboring information for wrapping.
See this notebook for motivation:
https://colab.research.google.com/drive/10tIEkdlCE_1J_CcgEcV0jkLfBc-0H4am?authuser=1#scrollTo=XWzy-n9dF3PG
"""
import numpy as np
impor... | Find adjacent matches | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/postings.py<fim_prefix>"""Tokenized, searchable text as a pandas dtype."""
import pandas as pd
import numbers
from pandas.api.extensions import ExtensionDtype, ExtensionArray, register_extension_dtype
from pandas.api.types import is_list_like
from pandas.api.extensions import take
impo... | When other is a scalar value | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/postings.py<fim_prefix>"""Tokenized, searchable text as a pandas dtype."""
import pandas as pd
import numbers
from pandas.api.extensions import ExtensionDtype, ExtensionArray, register_extension_dtype
from pandas.api.types import is_list_like
from pandas.api.extensions import take
impo... | For expensive toknes, we compute doc freq first, so we | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/solr.py<fim_prefix>"""Utility functions for Solr users of searcharray."""
import re
import pandas as pd
import numpy as np
from typing import List, Optional, Dict, Tuple
from searcharray.postings import SearchArray
from searcharray.similarity import Similarity, default_bm25
def parse... | otherwise, simple expression | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/phrase/middle_out.py<fim_prefix>"""Encode positions in bits along with some neighboring information for wrapping.
See this notebook for motivation:
https://colab.research.google.com/drive/10tIEkdlCE_1J_CcgEcV0jkLfBc-0H4am?authuser=1#scrollTo=XWzy-n9dF3PG
"""
import numpy as np
impor... | ceiling divide | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/postings.py<fim_prefix>"""Tokenized, searchable text as a pandas dtype."""
import pandas as pd
import numbers
from pandas.api.extensions import ExtensionDtype, ExtensionArray, register_extension_dtype
from pandas.api.types import is_list_like
from pandas.api.extensions import take
impo... | (not looking at positions, maybe we should?) | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/similarity.py<fim_prefix>"""Similarity functions given term stats."""
from typing import Protocol
import numpy as np
class Similarity(Protocol):
"""Similarity function protocol."""
def __call__(self, term_freqs: np.ndarray, doc_freqs: np.ndarray, doc_lens: np.ndarray,
... | Sum doc freqs | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/postings.py<fim_prefix>"""Tokenized, searchable text as a pandas dtype."""
import pandas as pd
import numbers
from pandas.api.extensions import ExtensionDtype, ExtensionArray, register_extension_dtype
from pandas.api.types import is_list_like
from pandas.api.extensions import take
impo... | Count number of rows where the term appears | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/phrase/middle_out.py<fim_prefix>"""Encode positions in bits along with some neighboring information for wrapping.
See this notebook for motivation:
https://colab.research.google.com/drive/10tIEkdlCE_1J_CcgEcV0jkLfBc-0H4am?authuser=1#scrollTo=XWzy-n9dF3PG
"""
import numpy as np
impor... | Combine lhs and rhs matches from two strategies | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/utils/roaringish.py<fim_prefix>"""Roaring-ish bit array for storing sorted integers in numpy array.
See - https://softwaredoug.com/blog/2024/01/21/search-array-phrase-algorithm
"""
import numpy as np
import sortednp as snp
import logging
import numbers
from typing import Optional, Tup... | UNFORTUNATE COPY | LINE_COMMENT | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/postings.py<fim_prefix>"""Tokenized, searchable text as a pandas dtype."""
import pandas as pd
import numbers
from pandas.api.extensions import ExtensionDtype, ExtensionArray, register_extension_dtype
from pandas.api.types import is_list_like
from pandas.api.extensions import take
impo... | slop == 1 and len(tokens) == len(set(tokens)):
phrase_freqs = np.zeros(len(self))
try:
doc_ids = self.term_mat.rows
term_ids = [self.term_dict.get_term_id(token) for token in tokens]
return self.posns.phrase_freqs(term_ids, doc_ids=doc_ids,
... | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/postings.py<fim_prefix>"""Tokenized, searchable text as a pandas dtype."""
import pandas as pd
import numbers
from pandas.api.extensions import ExtensionDtype, ExtensionArray, register_extension_dtype
from pandas.api.types import is_list_like
from pandas.api.extensions import take
impo... | isinstance(token, list):
term_freq = self.phrase_freq(token)
else:
term_freq = self.termfreqs(token) | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/utils/roaringish.py<fim_prefix>"""Roaring-ish bit array for storing sorted integers in numpy array.
See - https://softwaredoug.com/blog/2024/01/21/search-array-phrase-algorithm
"""
import numpy as np
import sortednp as snp
import logging
import numbers
from typing import Optional, Tup... | isinstance(keys, numbers.Number):
return np.asarray([keys], dtype=np.uint64)
elif isinstance(keys, list):
return np.asarray(keys, dtype=np.uint64)
elif isinstance(keys, np.ndarray):
return keys.astype(np.uint64)
elif isinstance(keys, range) and len(keys) > 0:
# UNFORTUNATE C... | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/postings.py<fim_prefix>"""Tokenized, searchable text as a pandas dtype."""
import pandas as pd
import numbers
from pandas.api.extensions import ExtensionDtype, ExtensionArray, register_extension_dtype
from pandas.api.types import is_list_like
from pandas.api.extensions import take
impo... | isinstance(token, str):
return token
elif isinstance(token, list) and len(token) == 1:
return token[0]
elif isinstance(token, list):
return token
else:
raise TypeError("Expected a string or list of strings for phrases") | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/solr.py<fim_prefix>"""Utility functions for Solr users of searcharray."""
import re
import pandas as pd
import numpy as np
from typing import List, Optional, Dict, Tuple
from searcharray.postings import SearchArray
from searcharray.similarity import Similarity, default_bm25
def parse... | num_clauses <= upper_bound:
return result
else:
result = parse_min_should_match(num_clauses, parts[1]) | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/solr.py<fim_prefix>"""Utility functions for Solr users of searcharray."""
import re
import pandas as pd
import numpy as np
from typing import List, Optional, Dict, Tuple
from searcharray.postings import SearchArray
from searcharray.similarity import Similarity, default_bm25
def parse... | mm is None:
mm = "1" | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/postings.py<fim_prefix>"""Tokenized, searchable text as a pandas dtype."""
import pandas as pd
import numbers
from pandas.api.extensions import ExtensionDtype, ExtensionArray, register_extension_dtype
from pandas.api.types import is_list_like
from pandas.api.extensions import take
impo... | self.term_mat.subset:
slice_of_rows = self.term_mat.rows
doc_ids, termfreqs = self.posns.termfreqs(term_id,
doc_ids=slice_of_rows)
mask = np.isin(self.term_mat.rows, doc_ids)
matches[mask] = termfr... | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/solr.py<fim_prefix>"""Utility functions for Solr users of searcharray."""
import re
import pandas as pd
import numpy as np
from typing import List, Optional, Dict, Tuple
from searcharray.postings import SearchArray
from searcharray.similarity import Similarity, default_bm25
def parse... | len(phrase_scores) > 0:
phrase_scores = np.sum(phrase_scores, axis=0)
# Add where term_scores > 0
term_match_idx = np.where(qf_scores)[0]
qf_scores[term_match_idx] += phrase_scores[term_match_idx] | IF | prefix_suffix_full_complete_current_block_with_evidence |
<filename>searcharray/searcharray/solr.py<fim_prefix>"""Utility functions for Solr users of searcharray."""
import re
import pandas as pd
import numpy as np
from typing import List, Optional, Dict, Tuple
from searcharray.postings import SearchArray
from searcharray.similarity import Similarity, default_bm25
def parse... | '<' in spec:
# we have conditional spec(s)
space_around_less_than_pattern = re.compile(r'\s*<\s*')
spec = space_around_less_than_pattern.sub('<', spec)
for s in spec.split():
parts = s.split('<', 1)
if len(parts) < 2:
raise ValueError("Invalid 'mm... | IF | prefix_suffix_full_complete_current_block_with_evidence |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.