language stringclasses 1 value | repo stringclasses 346 values | path stringlengths 6 201 | class_span dict | source stringlengths 21 2.38M | target stringlengths 1 96 |
|---|---|---|---|---|---|
python | openai__openai-python | src/openai/resources/fine_tuning/jobs/jobs.py | {
"start": 17174,
"end": 33259
} | class ____(AsyncAPIResource):
@cached_property
def checkpoints(self) -> AsyncCheckpoints:
return AsyncCheckpoints(self._client)
@cached_property
def with_raw_response(self) -> AsyncJobsWithRawResponse:
"""
This property can be used as a prefix for any HTTP method call to return
the raw response object instead of the parsed content.
For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
"""
return AsyncJobsWithRawResponse(self)
@cached_property
def with_streaming_response(self) -> AsyncJobsWithStreamingResponse:
"""
An alternative to `.with_raw_response` that doesn't eagerly read the response body.
For more information, see https://www.github.com/openai/openai-python#with_streaming_response
"""
return AsyncJobsWithStreamingResponse(self)
async def create(
self,
*,
model: Union[str, Literal["babbage-002", "davinci-002", "gpt-3.5-turbo", "gpt-4o-mini"]],
training_file: str,
hyperparameters: job_create_params.Hyperparameters | Omit = omit,
integrations: Optional[Iterable[job_create_params.Integration]] | Omit = omit,
metadata: Optional[Metadata] | Omit = omit,
method: job_create_params.Method | Omit = omit,
seed: Optional[int] | Omit = omit,
suffix: Optional[str] | Omit = omit,
validation_file: Optional[str] | Omit = omit,
# Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
# The extra values given here take precedence over values defined on the client or passed to this method.
extra_headers: Headers | None = None,
extra_query: Query | None = None,
extra_body: Body | None = None,
timeout: float | httpx.Timeout | None | NotGiven = not_given,
) -> FineTuningJob:
"""
Creates a fine-tuning job which begins the process of creating a new model from
a given dataset.
Response includes details of the enqueued job including job status and the name
of the fine-tuned models once complete.
[Learn more about fine-tuning](https://platform.openai.com/docs/guides/model-optimization)
Args:
model: The name of the model to fine-tune. You can select one of the
[supported models](https://platform.openai.com/docs/guides/fine-tuning#which-models-can-be-fine-tuned).
training_file: The ID of an uploaded file that contains training data.
See [upload file](https://platform.openai.com/docs/api-reference/files/create)
for how to upload a file.
Your dataset must be formatted as a JSONL file. Additionally, you must upload
your file with the purpose `fine-tune`.
The contents of the file should differ depending on if the model uses the
[chat](https://platform.openai.com/docs/api-reference/fine-tuning/chat-input),
[completions](https://platform.openai.com/docs/api-reference/fine-tuning/completions-input)
format, or if the fine-tuning method uses the
[preference](https://platform.openai.com/docs/api-reference/fine-tuning/preference-input)
format.
See the
[fine-tuning guide](https://platform.openai.com/docs/guides/model-optimization)
for more details.
hyperparameters: The hyperparameters used for the fine-tuning job. This value is now deprecated
in favor of `method`, and should be passed in under the `method` parameter.
integrations: A list of integrations to enable for your fine-tuning job.
metadata: Set of 16 key-value pairs that can be attached to an object. This can be useful
for storing additional information about the object in a structured format, and
querying for objects via API or the dashboard.
Keys are strings with a maximum length of 64 characters. Values are strings with
a maximum length of 512 characters.
method: The method used for fine-tuning.
seed: The seed controls the reproducibility of the job. Passing in the same seed and
job parameters should produce the same results, but may differ in rare cases. If
a seed is not specified, one will be generated for you.
suffix: A string of up to 64 characters that will be added to your fine-tuned model
name.
For example, a `suffix` of "custom-model-name" would produce a model name like
`ft:gpt-4o-mini:openai:custom-model-name:7p4lURel`.
validation_file: The ID of an uploaded file that contains validation data.
If you provide this file, the data is used to generate validation metrics
periodically during fine-tuning. These metrics can be viewed in the fine-tuning
results file. The same data should not be present in both train and validation
files.
Your dataset must be formatted as a JSONL file. You must upload your file with
the purpose `fine-tune`.
See the
[fine-tuning guide](https://platform.openai.com/docs/guides/model-optimization)
for more details.
extra_headers: Send extra headers
extra_query: Add additional query parameters to the request
extra_body: Add additional JSON properties to the request
timeout: Override the client-level default timeout for this request, in seconds
"""
return await self._post(
"/fine_tuning/jobs",
body=await async_maybe_transform(
{
"model": model,
"training_file": training_file,
"hyperparameters": hyperparameters,
"integrations": integrations,
"metadata": metadata,
"method": method,
"seed": seed,
"suffix": suffix,
"validation_file": validation_file,
},
job_create_params.JobCreateParams,
),
options=make_request_options(
extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
),
cast_to=FineTuningJob,
)
async def retrieve(
self,
fine_tuning_job_id: str,
*,
# Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
# The extra values given here take precedence over values defined on the client or passed to this method.
extra_headers: Headers | None = None,
extra_query: Query | None = None,
extra_body: Body | None = None,
timeout: float | httpx.Timeout | None | NotGiven = not_given,
) -> FineTuningJob:
"""
Get info about a fine-tuning job.
[Learn more about fine-tuning](https://platform.openai.com/docs/guides/model-optimization)
Args:
extra_headers: Send extra headers
extra_query: Add additional query parameters to the request
extra_body: Add additional JSON properties to the request
timeout: Override the client-level default timeout for this request, in seconds
"""
if not fine_tuning_job_id:
raise ValueError(f"Expected a non-empty value for `fine_tuning_job_id` but received {fine_tuning_job_id!r}")
return await self._get(
f"/fine_tuning/jobs/{fine_tuning_job_id}",
options=make_request_options(
extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
),
cast_to=FineTuningJob,
)
def list(
self,
*,
after: str | Omit = omit,
limit: int | Omit = omit,
metadata: Optional[Dict[str, str]] | Omit = omit,
# Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
# The extra values given here take precedence over values defined on the client or passed to this method.
extra_headers: Headers | None = None,
extra_query: Query | None = None,
extra_body: Body | None = None,
timeout: float | httpx.Timeout | None | NotGiven = not_given,
) -> AsyncPaginator[FineTuningJob, AsyncCursorPage[FineTuningJob]]:
"""
List your organization's fine-tuning jobs
Args:
after: Identifier for the last job from the previous pagination request.
limit: Number of fine-tuning jobs to retrieve.
metadata: Optional metadata filter. To filter, use the syntax `metadata[k]=v`.
Alternatively, set `metadata=null` to indicate no metadata.
extra_headers: Send extra headers
extra_query: Add additional query parameters to the request
extra_body: Add additional JSON properties to the request
timeout: Override the client-level default timeout for this request, in seconds
"""
return self._get_api_list(
"/fine_tuning/jobs",
page=AsyncCursorPage[FineTuningJob],
options=make_request_options(
extra_headers=extra_headers,
extra_query=extra_query,
extra_body=extra_body,
timeout=timeout,
query=maybe_transform(
{
"after": after,
"limit": limit,
"metadata": metadata,
},
job_list_params.JobListParams,
),
),
model=FineTuningJob,
)
async def cancel(
self,
fine_tuning_job_id: str,
*,
# Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
# The extra values given here take precedence over values defined on the client or passed to this method.
extra_headers: Headers | None = None,
extra_query: Query | None = None,
extra_body: Body | None = None,
timeout: float | httpx.Timeout | None | NotGiven = not_given,
) -> FineTuningJob:
"""
Immediately cancel a fine-tune job.
Args:
extra_headers: Send extra headers
extra_query: Add additional query parameters to the request
extra_body: Add additional JSON properties to the request
timeout: Override the client-level default timeout for this request, in seconds
"""
if not fine_tuning_job_id:
raise ValueError(f"Expected a non-empty value for `fine_tuning_job_id` but received {fine_tuning_job_id!r}")
return await self._post(
f"/fine_tuning/jobs/{fine_tuning_job_id}/cancel",
options=make_request_options(
extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
),
cast_to=FineTuningJob,
)
def list_events(
self,
fine_tuning_job_id: str,
*,
after: str | Omit = omit,
limit: int | Omit = omit,
# Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
# The extra values given here take precedence over values defined on the client or passed to this method.
extra_headers: Headers | None = None,
extra_query: Query | None = None,
extra_body: Body | None = None,
timeout: float | httpx.Timeout | None | NotGiven = not_given,
) -> AsyncPaginator[FineTuningJobEvent, AsyncCursorPage[FineTuningJobEvent]]:
"""
Get status updates for a fine-tuning job.
Args:
after: Identifier for the last event from the previous pagination request.
limit: Number of events to retrieve.
extra_headers: Send extra headers
extra_query: Add additional query parameters to the request
extra_body: Add additional JSON properties to the request
timeout: Override the client-level default timeout for this request, in seconds
"""
if not fine_tuning_job_id:
raise ValueError(f"Expected a non-empty value for `fine_tuning_job_id` but received {fine_tuning_job_id!r}")
return self._get_api_list(
f"/fine_tuning/jobs/{fine_tuning_job_id}/events",
page=AsyncCursorPage[FineTuningJobEvent],
options=make_request_options(
extra_headers=extra_headers,
extra_query=extra_query,
extra_body=extra_body,
timeout=timeout,
query=maybe_transform(
{
"after": after,
"limit": limit,
},
job_list_events_params.JobListEventsParams,
),
),
model=FineTuningJobEvent,
)
async def pause(
self,
fine_tuning_job_id: str,
*,
# Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
# The extra values given here take precedence over values defined on the client or passed to this method.
extra_headers: Headers | None = None,
extra_query: Query | None = None,
extra_body: Body | None = None,
timeout: float | httpx.Timeout | None | NotGiven = not_given,
) -> FineTuningJob:
"""
Pause a fine-tune job.
Args:
extra_headers: Send extra headers
extra_query: Add additional query parameters to the request
extra_body: Add additional JSON properties to the request
timeout: Override the client-level default timeout for this request, in seconds
"""
if not fine_tuning_job_id:
raise ValueError(f"Expected a non-empty value for `fine_tuning_job_id` but received {fine_tuning_job_id!r}")
return await self._post(
f"/fine_tuning/jobs/{fine_tuning_job_id}/pause",
options=make_request_options(
extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
),
cast_to=FineTuningJob,
)
async def resume(
self,
fine_tuning_job_id: str,
*,
# Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
# The extra values given here take precedence over values defined on the client or passed to this method.
extra_headers: Headers | None = None,
extra_query: Query | None = None,
extra_body: Body | None = None,
timeout: float | httpx.Timeout | None | NotGiven = not_given,
) -> FineTuningJob:
"""
Resume a fine-tune job.
Args:
extra_headers: Send extra headers
extra_query: Add additional query parameters to the request
extra_body: Add additional JSON properties to the request
timeout: Override the client-level default timeout for this request, in seconds
"""
if not fine_tuning_job_id:
raise ValueError(f"Expected a non-empty value for `fine_tuning_job_id` but received {fine_tuning_job_id!r}")
return await self._post(
f"/fine_tuning/jobs/{fine_tuning_job_id}/resume",
options=make_request_options(
extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
),
cast_to=FineTuningJob,
)
| AsyncJobs |
python | vyperlang__vyper | vyper/builtins/functions.py | {
"start": 61354,
"end": 66463
} | class ____(_CreateBase):
_id = "create_from_blueprint"
_inputs = [("target", AddressT())]
_kwargs = {
"value": KwargSettings(UINT256_T, zero_value),
"salt": KwargSettings(BYTES32_T, empty_value),
"raw_args": KwargSettings(BoolT(), False, require_literal=True),
"code_offset": KwargSettings(UINT256_T, IRnode.from_list(3, typ=UINT256_T)),
"revert_on_failure": KwargSettings(BoolT(), True, require_literal=True),
}
_has_varargs = True
def _add_gas_estimate(self, args, should_use_create2):
ctor_args = ir_tuple_from_args(args[1:])
# max possible size of init code
maxlen = EIP_170_LIMIT + ctor_args.typ.abi_type.size_bound()
return _create_addl_gas_estimate(maxlen, should_use_create2)
def _build_create_IR(
self, expr, args, context, value, salt, code_offset, raw_args, revert_on_failure
):
target = args[0]
ctor_args = args[1:]
ctor_args = [ensure_in_memory(arg, context) for arg in ctor_args]
if raw_args:
if len(ctor_args) != 1 or not isinstance(ctor_args[0].typ, BytesT):
raise StructureException("raw_args must be used with exactly 1 bytes argument")
with ctor_args[0].cache_when_complex("arg") as (b1, arg):
argbuf = bytes_data_ptr(arg)
argslen = get_bytearray_length(arg)
bufsz = arg.typ.maxlen
return b1.resolve(
self._helper(
argbuf, bufsz, target, value, salt, argslen, code_offset, revert_on_failure
)
)
else:
# encode the varargs
to_encode = ir_tuple_from_args(ctor_args)
# pretend we allocated enough memory for the encoder
# (we didn't, but we are clobbering unused memory so it's safe.)
bufsz = to_encode.typ.abi_type.size_bound()
argbuf = context.new_internal_variable(get_type_for_exact_size(bufsz))
# return a complex expression which writes to memory and returns
# the length of the encoded data
argslen = abi_encode(argbuf, to_encode, context, bufsz=bufsz, returns_len=True)
return self._helper(
argbuf, bufsz, target, value, salt, argslen, code_offset, revert_on_failure
)
def _helper(self, argbuf, bufsz, target, value, salt, argslen, code_offset, revert_on_failure):
# NOTE: we need to invoke the abi encoder before evaluating MSIZE,
# then copy the abi encoded buffer to past-the-end of the initcode
# (since the abi encoder could write to fresh memory).
# it would be good to not require the memory copy, but need
# to evaluate memory safety.
with scope_multi(
(target, value, salt, argslen, code_offset),
("create_target", "create_value", "create_salt", "encoded_args_len", "code_offset"),
) as (b1, (target, value, salt, encoded_args_len, code_offset)):
codesize = IRnode.from_list(["sub", ["extcodesize", target], code_offset])
# copy code to memory starting from msize. we are clobbering
# unused memory so it's safe.
msize = IRnode.from_list(["msize"], location=MEMORY)
with scope_multi((codesize, msize), ("target_codesize", "mem_ofst")) as (
b2,
(codesize, mem_ofst),
):
ir = ["seq"]
# make sure there is code at the target, and that
# code_ofst <= (extcodesize target).
# (note if code_ofst > (extcodesize target), would be
# OOG on the EXTCODECOPY)
# (code_ofst == (extcodesize target) would be empty
# initcode, which we disallow for hygiene reasons -
# same as `create_copy_of` on an empty target).
check_codesize = ["assert", ["sgt", codesize, 0]]
ir.append(
IRnode.from_list(
check_codesize, error_msg="empty target (create_from_blueprint)"
)
)
# copy the target code into memory.
# layout starting from mem_ofst:
# <target initcode> | <abi-encoded args OR arg buffer if raw_arg=True>
ir.append(["extcodecopy", target, mem_ofst, code_offset, codesize])
ir.append(copy_bytes(add_ofst(mem_ofst, codesize), argbuf, encoded_args_len, bufsz))
# theoretically, dst = "msize", but just be safe.
# if len(ctor_args) > 0:
# dst = add_ofst(mem_ofst, codesize)
# encoded_args_len = self._encode_args(dst, ctor_args, context)
# else:
# encoded_args_len = 0
length = ["add", codesize, encoded_args_len]
ir.append(_create_ir(value, mem_ofst, length, salt, revert_on_failure))
return b1.resolve(b2.resolve(ir))
| CreateFromBlueprint |
python | arrow-py__arrow | tests/test_locales.py | {
"start": 167305,
"end": 171688
} | class ____:
def test_singles_mk(self):
assert self.locale._format_timeframe("second", 1) == "bir soniya"
assert self.locale._format_timeframe("minute", 1) == "bir daqiqa"
assert self.locale._format_timeframe("hour", 1) == "bir soat"
assert self.locale._format_timeframe("day", 1) == "bir kun"
assert self.locale._format_timeframe("week", 1) == "bir hafta"
assert self.locale._format_timeframe("month", 1) == "bir oy"
assert self.locale._format_timeframe("year", 1) == "bir yil"
def test_describe_mk(self):
assert self.locale.describe("second", only_distance=True) == "bir soniya"
assert (
self.locale.describe("second", only_distance=False) == "bir soniyadan keyin"
)
assert self.locale.describe("minute", only_distance=True) == "bir daqiqa"
assert (
self.locale.describe("minute", only_distance=False) == "bir daqiqadan keyin"
)
assert self.locale.describe("hour", only_distance=True) == "bir soat"
assert self.locale.describe("hour", only_distance=False) == "bir soatdan keyin"
assert self.locale.describe("day", only_distance=True) == "bir kun"
assert self.locale.describe("day", only_distance=False) == "bir kundan keyin"
assert self.locale.describe("week", only_distance=True) == "bir hafta"
assert self.locale.describe("week", only_distance=False) == "bir haftadan keyin"
assert self.locale.describe("month", only_distance=True) == "bir oy"
assert self.locale.describe("month", only_distance=False) == "bir oydan keyin"
assert self.locale.describe("year", only_distance=True) == "bir yil"
assert self.locale.describe("year", only_distance=False) == "bir yildan keyin"
def test_relative_mk(self):
assert self.locale._format_relative("hozir", "now", 0) == "hozir"
assert (
self.locale._format_relative("1 soniya", "seconds", 1)
== "1 soniyadan keyin"
)
assert (
self.locale._format_relative("1 soniya", "seconds", -1)
== "1 soniyadan avval"
)
assert (
self.locale._format_relative("1 daqiqa", "minutes", 1)
== "1 daqiqadan keyin"
)
assert (
self.locale._format_relative("1 daqiqa", "minutes", -1)
== "1 daqiqadan avval"
)
assert self.locale._format_relative("1 soat", "hours", 1) == "1 soatdan keyin"
assert self.locale._format_relative("1 soat", "hours", -1) == "1 soatdan avval"
assert self.locale._format_relative("1 kun", "days", 1) == "1 kundan keyin"
assert self.locale._format_relative("1 kun", "days", -1) == "1 kundan avval"
assert self.locale._format_relative("1 hafta", "weeks", 1) == "1 haftadan keyin"
assert (
self.locale._format_relative("1 hafta", "weeks", -1) == "1 haftadan avval"
)
assert self.locale._format_relative("1 oy", "months", 1) == "1 oydan keyin"
assert self.locale._format_relative("1 oy", "months", -1) == "1 oydan avval"
assert self.locale._format_relative("1 yil", "years", 1) == "1 yildan keyin"
assert self.locale._format_relative("1 yil", "years", -1) == "1 yildan avval"
def test_plurals_mk(self):
assert self.locale._format_timeframe("now", 0) == "hozir"
assert self.locale._format_timeframe("second", 1) == "bir soniya"
assert self.locale._format_timeframe("seconds", 30) == "30 soniya"
assert self.locale._format_timeframe("minute", 1) == "bir daqiqa"
assert self.locale._format_timeframe("minutes", 40) == "40 daqiqa"
assert self.locale._format_timeframe("hour", 1) == "bir soat"
assert self.locale._format_timeframe("hours", 23) == "23 soat"
assert self.locale._format_timeframe("days", 12) == "12 kun"
assert self.locale._format_timeframe("week", 1) == "bir hafta"
assert self.locale._format_timeframe("weeks", 38) == "38 hafta"
assert self.locale._format_timeframe("month", 1) == "bir oy"
assert self.locale._format_timeframe("months", 11) == "11 oy"
assert self.locale._format_timeframe("year", 1) == "bir yil"
assert self.locale._format_timeframe("years", 12) == "12 yil"
@pytest.mark.usefixtures("lang_locale")
| TestUzbekLocale |
python | weaviate__weaviate-python-client | weaviate/collections/classes/config_vectorizers.py | {
"start": 17358,
"end": 17617
} | class ____(_Multi2VecBase):
vectorizer: Union[Vectorizers, _EnumLikeStr] = Field(
default=Vectorizers.MULTI2VEC_AWS, frozen=True, exclude=True
)
region: Optional[str]
model: Optional[str]
dimensions: Optional[int]
| _Multi2VecAWSConfig |
python | eventlet__eventlet | tests/isolated/patcher_existing_locks_exception.py | {
"start": 19,
"end": 306
} | class ____(dict):
def items(self):
raise Exception()
if __name__ == '__main__':
import threading
test_lock = threading.RLock()
test_lock.acquire()
baddict = BadDict(testkey='testvalue')
import eventlet
eventlet.monkey_patch()
print('pass')
| BadDict |
python | realpython__materials | solid-principles-python/app_dip.py | {
"start": 716,
"end": 810
} | class ____(DataSource):
def get_data(self):
return "Data from the database"
| Database |
python | tensorflow__tensorflow | tensorflow/python/kernel_tests/array_ops/array_ops_test.py | {
"start": 22389,
"end": 24802
} | class ____(object):
"""Check a given tensor against the numpy result."""
REF_TENSOR = np.arange(1, 19, dtype=np.float32).reshape(3, 2, 3)
REF_TENSOR_ALIGNED = np.arange(1, 97, dtype=np.float32).reshape(3, 4, 8)
def __init__(self, test, x, tensor_type=dtypes.int32, check_type_infer=True):
self.x_np = np.array(x).astype(tensor_type.as_numpy_dtype)
if tensor_type.is_bool:
self.x_np = np.array(x % 3).astype(np.bool_)
# Give the value a non-zero imaginary component for complex types.
if tensor_type.is_complex:
self.x_np -= 1j * self.x_np
self.test = test
self.x = constant_op.constant(self.x_np, dtype=tensor_type)
self.check_type_infer = check_type_infer
def __getitem__(self, spec):
op = self.x.__getitem__(spec)
def eval_if_tensor(x):
try:
return self.test.evaluate(x)
except (AttributeError, TypeError, ValueError):
return x
def casts_to_bool_nparray(x):
try:
return np.asarray(x).dtype == bool
except NotImplementedError:
return False
if (
isinstance(spec, bool)
or (isinstance(spec, tensor_lib.Tensor) and spec.dtype == dtypes.bool)
or (isinstance(spec, np.ndarray) and spec.dtype == bool)
or (isinstance(spec, (list, tuple)) and casts_to_bool_nparray(spec))
):
tensor = self.test.evaluate(op)
np_spec = eval_if_tensor(spec)
self.test.assertAllEqual(self.x_np[np_spec], tensor)
return tensor
if not isinstance(spec, (list, tuple)):
spec = [spec]
tensor = self.test.evaluate(op)
# Make a numpy spec that pre-evals the tensors
np_specs = []
for s in spec:
if isinstance(s, slice):
start = eval_if_tensor(s.start)
stop = eval_if_tensor(s.stop)
step = eval_if_tensor(s.step)
np_specs.append(slice(start, stop, step))
else:
np_specs.append(eval_if_tensor(s))
self.test.assertAllEqual(self.x_np[tuple(np_specs)], tensor)
if self.check_type_infer:
self.test.assertAllEqual(tensor.shape, op.get_shape())
return tensor
STRIDED_SLICE_TYPES = [
dtypes.int32,
dtypes.int64,
dtypes.int16,
dtypes.int8,
dtypes.uint8,
dtypes.float32,
dtypes.float64,
dtypes.complex64,
dtypes.complex128,
dtypes.bool,
dtypes.bfloat16,
dtypes.float8_e5m2,
dtypes.float8_e4m3fn,
]
| StridedSliceChecker |
python | nryoung__algorithms | tests/test_factorization.py | {
"start": 212,
"end": 444
} | class ____(unittest.TestCase):
def test_fermat(self):
x = random.randint(1, 100000000)
factors = fermat(x)
res = 1
for i in factors:
res *= i
self.assertEqual(x, res)
| TestFermat |
python | google__python-fire | fire/test_components.py | {
"start": 10526,
"end": 11723
} | class ____:
def double(self, number):
return 2 * number
@property
def prop(self):
raise ValueError('test')
def simple_decorator(f):
@functools.wraps(f)
def wrapper(*args, **kwargs):
return f(*args, **kwargs)
return wrapper
@simple_decorator
def decorated_method(name='World'):
return 'Hello %s' % name
# pylint: disable=g-doc-args,g-doc-return-or-yield
def fn_with_kwarg(arg1, arg2, **kwargs):
"""Function with kwarg.
:param arg1: Description of arg1.
:param arg2: Description of arg2.
:key arg3: Description of arg3.
"""
del arg1, arg2
return kwargs.get('arg3')
def fn_with_kwarg_and_defaults(arg1, arg2, opt=True, **kwargs):
"""Function with kwarg and defaults.
:param arg1: Description of arg1.
:param arg2: Description of arg2.
:key arg3: Description of arg3.
"""
del arg1, arg2, opt
return kwargs.get('arg3')
def fn_with_multiple_defaults(first='first', last='last', late='late'):
"""Function with kwarg and defaults.
:key first: Description of first.
:key last: Description of last.
:key late: Description of late.
"""
del last, late
return first
# pylint: enable=g-doc-args,g-doc-return-or-yield
| InvalidProperty |
python | kamyu104__LeetCode-Solutions | Python/maximal-range-that-each-element-is-maximum-in-it.py | {
"start": 42,
"end": 485
} | class ____(object):
def maximumLengthOfRanges(self, nums):
"""
:type nums: List[int]
:rtype: List[int]
"""
result = [0]*len(nums)
stk = [-1]
nums.append(float("inf"))
for i, x in enumerate(nums):
while stk[-1] != -1 and nums[stk[-1]] < x:
j = stk.pop()
result[j] = (i-1)-stk[-1]
stk.append(i)
return result
| Solution |
python | ansible__ansible | lib/ansible/executor/play_iterator.py | {
"start": 5093,
"end": 33268
} | class ____:
def __init__(self, inventory, play, play_context, variable_manager, all_vars, start_at_done=False):
self._play = play
self._blocks = []
self._variable_manager = variable_manager
setup_block = Block(play=self._play)
# Gathering facts with run_once would copy the facts from one host to
# the others.
setup_block.run_once = False
setup_task = Task(block=setup_block)
setup_task.action = 'gather_facts'
setup_task.name = 'Gathering Facts'
setup_task.args = {}
# Unless play is specifically tagged, gathering should 'always' run
if not self._play.tags:
setup_task.tags = ['always']
# Default options to gather
for option in ('gather_subset', 'gather_timeout', 'fact_path'):
value = getattr(self._play, option, None)
if value is not None:
setup_task.args[option] = value
setup_task.set_loader(self._play._loader)
# short circuit fact gathering if the entire playbook is conditional
if self._play._included_conditional is not None:
setup_task.when = self._play._included_conditional[:]
setup_block.block = [setup_task]
validation_task = Task.load({
'name': f'Validating arguments against arg spec {self._play.validate_argspec}',
'action': 'ansible.builtin.validate_argument_spec',
'args': {
# 'provided_arguments': {}, # allow configuration via module_defaults
'argument_spec': self._play.argument_spec,
'validate_args_context': {
'type': 'play',
'name': self._play.validate_argspec,
'argument_spec_name': self._play.validate_argspec,
'path': self._play._metadata_path,
},
},
'tags': ['always'],
}, block=setup_block)
validation_task.set_loader(self._play._loader)
if self._play._included_conditional is not None:
validation_task.when = self._play._included_conditional[:]
setup_block.block.append(validation_task)
setup_block = setup_block.filter_tagged_tasks(all_vars)
self._blocks.append(setup_block)
# keep flatten (no blocks) list of all tasks from the play
# used for the lockstep mechanism in the linear strategy
self.all_tasks = setup_block.get_tasks()
for block in self._play.compile():
new_block = block.filter_tagged_tasks(all_vars)
if new_block.has_tasks():
self._blocks.append(new_block)
self.all_tasks.extend(new_block.get_tasks())
# keep list of all handlers, it is copied into each HostState
# at the beginning of IteratingStates.HANDLERS
# the copy happens at each flush in order to restore the original
# list and remove any included handlers that might not be notified
# at the particular flush
self.handlers = [h for b in self._play.handlers for h in b.block]
self._host_states = {}
start_at_matched = False
batch = inventory.get_hosts(self._play.hosts, order=self._play.order)
self.batch_size = len(batch)
for host in batch:
self.set_state_for_host(host.name, HostState(blocks=self._blocks))
# if we're looking to start at a specific task, iterate through
# the tasks for this host until we find the specified task
if play_context.start_at_task is not None and not start_at_done:
while True:
(s, task) = self.get_next_task_for_host(host, peek=True)
if s.run_state == IteratingStates.COMPLETE:
break
if task.name == play_context.start_at_task or (task.name and fnmatch.fnmatch(task.name, play_context.start_at_task)) or \
task.get_name() == play_context.start_at_task or fnmatch.fnmatch(task.get_name(), play_context.start_at_task):
start_at_matched = True
break
self.set_state_for_host(host.name, s)
# finally, reset the host's state to IteratingStates.SETUP
if start_at_matched:
self._host_states[host.name].did_start_at_task = True
self._host_states[host.name].run_state = IteratingStates.SETUP
if start_at_matched:
# we have our match, so clear the start_at_task field on the
# play context to flag that we've started at a task (and future
# plays won't try to advance)
play_context.start_at_task = None
self.end_play = False
self.cur_task = 0
def get_host_state(self, host):
# Since we're using the PlayIterator to carry forward failed hosts,
# in the event that a previous host was not in the current inventory
# we create a stub state for it now
if host.name not in self._host_states:
self.set_state_for_host(host.name, HostState(blocks=[]))
return self._host_states[host.name].copy()
def get_next_task_for_host(self, host, peek=False):
display.debug("getting the next task for host %s" % host.name)
s = self.get_host_state(host)
task = None
if s.run_state == IteratingStates.COMPLETE:
display.debug("host %s is done iterating, returning" % host.name)
return (s, None)
(s, task) = self._get_next_task_from_state(s, host=host)
if not peek:
self.set_state_for_host(host.name, s)
display.debug("done getting next task for host %s" % host.name)
display.debug(" ^ state is: %s" % s)
return (s, task)
def _get_next_task_from_state(self, state, host):
task = None
# try and find the next task, given the current state.
while True:
# try to get the current block from the list of blocks, and
# if we run past the end of the list we know we're done with
# this block
try:
block = state._blocks[state.cur_block]
except IndexError:
state.run_state = IteratingStates.COMPLETE
return (state, None)
if state.run_state == IteratingStates.SETUP:
# First, we check to see if we completed both setup tasks injected
# during play compilation in __init__ above.
# If not, below we will determine if we do in fact want to gather
# facts or validate arguments for the specified host.
state.pending_setup = state.cur_regular_task < len(block.block)
if state.pending_setup:
task = block.block[state.cur_regular_task]
# Gather facts if the default is 'smart' and we have not yet
# done it for this host; or if 'explicit' and the play sets
# gather_facts to True; or if 'implicit' and the play does
# NOT explicitly set gather_facts to False.
gather_facts = bool(state.cur_regular_task == 0)
gathering = C.DEFAULT_GATHERING
implied = self._play.gather_facts is None or boolean(self._play.gather_facts, strict=False)
if gather_facts and not (
(gathering == 'implicit' and implied) or
(gathering == 'explicit' and boolean(self._play.gather_facts, strict=False)) or
(gathering == 'smart' and implied and not self._variable_manager._facts_gathered_for_host(host.name))
):
task = None
elif not gather_facts and not self._play.validate_argspec:
task = None
state.cur_regular_task += 1
else:
# This is the last trip through IteratingStates.SETUP, so we
# move onto the next block in the list while setting the run
# state to IteratingStates.TASKS
state.run_state = IteratingStates.TASKS
if not state.did_start_at_task:
state.cur_block += 1
state.cur_regular_task = 0
state.cur_rescue_task = 0
state.cur_always_task = 0
state.tasks_child_state = None
state.rescue_child_state = None
state.always_child_state = None
elif state.run_state == IteratingStates.TASKS:
# clear the pending setup flag, since we're past that and it didn't fail
if state.pending_setup:
state.pending_setup = False
# First, we check for a child task state that is not failed, and if we
# have one recurse into it for the next task. If we're done with the child
# state, we clear it and drop back to getting the next task from the list.
if state.tasks_child_state:
(state.tasks_child_state, task) = self._get_next_task_from_state(state.tasks_child_state, host=host)
if self._check_failed_state(state.tasks_child_state):
# failed child state, so clear it and move into the rescue portion
state.tasks_child_state = None
self._set_failed_state(state)
else:
# get the next task recursively
if task is None or state.tasks_child_state.run_state == IteratingStates.COMPLETE:
# we're done with the child state, so clear it and continue
# back to the top of the loop to get the next task
state.tasks_child_state = None
continue
else:
# First here, we check to see if we've failed anywhere down the chain
# of states we have, and if so we move onto the rescue portion. Otherwise,
# we check to see if we've moved past the end of the list of tasks. If so,
# we move into the always portion of the block, otherwise we get the next
# task from the list.
if self._check_failed_state(state):
state.run_state = IteratingStates.RESCUE
elif state.cur_regular_task >= len(block.block):
state.run_state = IteratingStates.ALWAYS
else:
task = block.block[state.cur_regular_task]
# if the current task is actually a child block, create a child
# state for us to recurse into on the next pass
if isinstance(task, Block):
state.tasks_child_state = HostState(blocks=[task])
state.tasks_child_state.run_state = IteratingStates.TASKS
# since we've created the child state, clear the task
# so we can pick up the child state on the next pass
task = None
state.cur_regular_task += 1
elif state.run_state == IteratingStates.RESCUE:
# The process here is identical to IteratingStates.TASKS, except instead
# we move into the always portion of the block.
if state.rescue_child_state:
(state.rescue_child_state, task) = self._get_next_task_from_state(state.rescue_child_state, host=host)
if self._check_failed_state(state.rescue_child_state):
state.rescue_child_state = None
self._set_failed_state(state)
else:
if task is None or state.rescue_child_state.run_state == IteratingStates.COMPLETE:
state.rescue_child_state = None
continue
else:
if state.fail_state & FailedStates.RESCUE == FailedStates.RESCUE:
state.run_state = IteratingStates.ALWAYS
elif state.cur_rescue_task >= len(block.rescue):
if len(block.rescue) > 0:
state.fail_state = FailedStates.NONE
state.run_state = IteratingStates.ALWAYS
state.did_rescue = True
else:
task = block.rescue[state.cur_rescue_task]
if isinstance(task, Block):
state.rescue_child_state = HostState(blocks=[task])
state.rescue_child_state.run_state = IteratingStates.TASKS
task = None
state.cur_rescue_task += 1
elif state.run_state == IteratingStates.ALWAYS:
# And again, the process here is identical to IteratingStates.TASKS, except
# instead we either move onto the next block in the list, or we set the
# run state to IteratingStates.COMPLETE in the event of any errors, or when we
# have hit the end of the list of blocks.
if state.always_child_state:
(state.always_child_state, task) = self._get_next_task_from_state(state.always_child_state, host=host)
if self._check_failed_state(state.always_child_state):
state.always_child_state = None
self._set_failed_state(state)
else:
if task is None or state.always_child_state.run_state == IteratingStates.COMPLETE:
state.always_child_state = None
continue
else:
if state.cur_always_task >= len(block.always):
if state.fail_state != FailedStates.NONE:
state.run_state = IteratingStates.COMPLETE
else:
state.cur_block += 1
state.cur_regular_task = 0
state.cur_rescue_task = 0
state.cur_always_task = 0
state.run_state = IteratingStates.TASKS
state.tasks_child_state = None
state.rescue_child_state = None
state.always_child_state = None
state.did_rescue = False
else:
task = block.always[state.cur_always_task]
if isinstance(task, Block):
state.always_child_state = HostState(blocks=[task])
state.always_child_state.run_state = IteratingStates.TASKS
task = None
state.cur_always_task += 1
elif state.run_state == IteratingStates.HANDLERS:
if state.update_handlers:
# reset handlers for HostState since handlers from include_tasks
# might be there from previous flush
state.handlers = self.handlers[:]
state.update_handlers = False
while True:
try:
task = state.handlers[state.cur_handlers_task]
except IndexError:
task = None
state.cur_handlers_task = 0
state.run_state = state.pre_flushing_run_state
state.update_handlers = True
break
else:
state.cur_handlers_task += 1
if task.is_host_notified(host):
return state, task
elif state.run_state == IteratingStates.COMPLETE:
return (state, None)
# if something above set the task, break out of the loop now
if task:
# skip implicit flush_handlers if there are no handlers notified
if (
task.implicit
and task._get_meta() == 'flush_handlers'
and (
# the state store in the `state` variable could be a nested state,
# notifications are always stored in the top level state, get it here
not self.get_state_for_host(host.name).handler_notifications
# in case handlers notifying other handlers, the notifications are not
# saved in `handler_notifications` and handlers are notified directly
# to prevent duplicate handler runs, so check whether any handler
# is notified
and all(not h.notified_hosts for h in self.handlers)
)
):
display.debug("No handler notifications for %s, skipping." % host.name)
elif (
(role := task._role)
and role._metadata.allow_duplicates is False
and host.name in self._play._get_cached_role(role)._completed
):
display.debug("'%s' skipped because role has already run" % task)
else:
break
return (state, task)
def _set_failed_state(self, state):
if state.run_state == IteratingStates.SETUP:
state.fail_state |= FailedStates.SETUP
state.run_state = IteratingStates.COMPLETE
elif state.run_state == IteratingStates.TASKS:
if state.tasks_child_state is not None:
state.tasks_child_state = self._set_failed_state(state.tasks_child_state)
else:
state.fail_state |= FailedStates.TASKS
if state._blocks[state.cur_block].rescue:
state.run_state = IteratingStates.RESCUE
elif state._blocks[state.cur_block].always:
state.run_state = IteratingStates.ALWAYS
else:
state.run_state = IteratingStates.COMPLETE
elif state.run_state == IteratingStates.RESCUE:
if state.rescue_child_state is not None:
state.rescue_child_state = self._set_failed_state(state.rescue_child_state)
else:
state.fail_state |= FailedStates.RESCUE
if state._blocks[state.cur_block].always:
state.run_state = IteratingStates.ALWAYS
else:
state.run_state = IteratingStates.COMPLETE
elif state.run_state == IteratingStates.ALWAYS:
if state.always_child_state is not None:
state.always_child_state = self._set_failed_state(state.always_child_state)
else:
state.fail_state |= FailedStates.ALWAYS
state.run_state = IteratingStates.COMPLETE
return state
def mark_host_failed(self, host):
s = self.get_host_state(host)
display.debug("marking host %s failed, current state: %s" % (host, s))
if s.run_state == IteratingStates.HANDLERS:
# we are failing `meta: flush_handlers`, so just reset the state to whatever
# it was before and let `_set_failed_state` figure out the next state
s.run_state = s.pre_flushing_run_state
s.update_handlers = True
s = self._set_failed_state(s)
display.debug("^ failed state is now: %s" % s)
self.set_state_for_host(host.name, s)
self._play._removed_hosts.append(host.name)
def get_failed_hosts(self):
return dict((host, True) for (host, state) in self._host_states.items() if self._check_failed_state(state))
def _check_failed_state(self, state):
if state is None:
return False
elif state.run_state == IteratingStates.RESCUE and self._check_failed_state(state.rescue_child_state):
return True
elif state.run_state == IteratingStates.ALWAYS and self._check_failed_state(state.always_child_state):
return True
elif state.fail_state != FailedStates.NONE:
if state.run_state == IteratingStates.RESCUE and state.fail_state & FailedStates.RESCUE == 0:
return False
elif state.run_state == IteratingStates.ALWAYS and state.fail_state & FailedStates.ALWAYS == 0:
return False
else:
return not (state.did_rescue and state.fail_state & FailedStates.ALWAYS == 0)
elif state.run_state == IteratingStates.TASKS and self._check_failed_state(state.tasks_child_state):
cur_block = state._blocks[state.cur_block]
if len(cur_block.rescue) > 0 and state.fail_state & FailedStates.RESCUE == 0:
return False
else:
return True
return False
def is_failed(self, host):
s = self.get_host_state(host)
return self._check_failed_state(s)
def clear_host_errors(self, host):
self._clear_state_errors(self.get_state_for_host(host.name))
def _clear_state_errors(self, state: HostState) -> None:
state.fail_state = FailedStates.NONE
if state.tasks_child_state is not None:
self._clear_state_errors(state.tasks_child_state)
elif state.rescue_child_state is not None:
self._clear_state_errors(state.rescue_child_state)
elif state.always_child_state is not None:
self._clear_state_errors(state.always_child_state)
def get_active_state(self, state):
"""
Finds the active state, recursively if necessary when there are child states.
"""
if state.run_state == IteratingStates.TASKS and state.tasks_child_state is not None:
return self.get_active_state(state.tasks_child_state)
elif state.run_state == IteratingStates.RESCUE and state.rescue_child_state is not None:
return self.get_active_state(state.rescue_child_state)
elif state.run_state == IteratingStates.ALWAYS and state.always_child_state is not None:
return self.get_active_state(state.always_child_state)
return state
def is_any_block_rescuing(self, state):
"""
Given the current HostState state, determines if the current block, or any child blocks,
are in rescue mode.
"""
if state.run_state in (IteratingStates.TASKS, IteratingStates.HANDLERS) and state.get_current_block().rescue:
return True
if state.tasks_child_state is not None:
return self.is_any_block_rescuing(state.tasks_child_state)
if state.rescue_child_state is not None:
return self.is_any_block_rescuing(state.rescue_child_state)
if state.always_child_state is not None:
return self.is_any_block_rescuing(state.always_child_state)
return False
def _insert_tasks_into_state(self, state, task_list):
# if we've failed at all, or if the task list is empty, just return the current state
if (state.fail_state != FailedStates.NONE and state.run_state == IteratingStates.TASKS) or not task_list:
return state
if state.run_state == IteratingStates.TASKS:
if state.tasks_child_state:
state.tasks_child_state = self._insert_tasks_into_state(state.tasks_child_state, task_list)
else:
target_block = state._blocks[state.cur_block].copy(exclude_tasks=True)
target_block.block[state.cur_regular_task:state.cur_regular_task] = task_list
state._blocks[state.cur_block] = target_block
elif state.run_state == IteratingStates.RESCUE:
if state.rescue_child_state:
state.rescue_child_state = self._insert_tasks_into_state(state.rescue_child_state, task_list)
else:
target_block = state._blocks[state.cur_block].copy(exclude_tasks=True)
target_block.rescue[state.cur_rescue_task:state.cur_rescue_task] = task_list
state._blocks[state.cur_block] = target_block
elif state.run_state == IteratingStates.ALWAYS:
if state.always_child_state:
state.always_child_state = self._insert_tasks_into_state(state.always_child_state, task_list)
else:
target_block = state._blocks[state.cur_block].copy(exclude_tasks=True)
target_block.always[state.cur_always_task:state.cur_always_task] = task_list
state._blocks[state.cur_block] = target_block
elif state.run_state == IteratingStates.HANDLERS:
state.handlers[state.cur_handlers_task:state.cur_handlers_task] = [h for b in task_list for h in b.block]
return state
def add_tasks(self, host, task_list):
self.set_state_for_host(host.name, self._insert_tasks_into_state(self.get_host_state(host), task_list))
@property
def host_states(self):
return self._host_states
def get_state_for_host(self, hostname: str) -> HostState:
return self._host_states[hostname]
def set_state_for_host(self, hostname: str, state: HostState) -> None:
if not isinstance(state, HostState):
raise AnsibleAssertionError('Expected state to be a HostState but was a %s' % type(state))
self._host_states[hostname] = state
def set_run_state_for_host(self, hostname: str, run_state: IteratingStates) -> None:
if not isinstance(run_state, IteratingStates):
raise AnsibleAssertionError('Expected run_state to be a IteratingStates but was %s' % (type(run_state)))
self._host_states[hostname].run_state = run_state
def set_fail_state_for_host(self, hostname: str, fail_state: FailedStates) -> None:
if not isinstance(fail_state, FailedStates):
raise AnsibleAssertionError('Expected fail_state to be a FailedStates but was %s' % (type(fail_state)))
self._host_states[hostname].fail_state = fail_state
def add_notification(self, hostname: str, notification: str) -> None:
# preserve order
host_state = self._host_states[hostname]
if notification not in host_state.handler_notifications:
host_state.handler_notifications.append(notification)
def clear_notification(self, hostname: str, notification: str) -> None:
self._host_states[hostname].handler_notifications.remove(notification)
def end_host(self, hostname: str) -> None:
"""Used by ``end_host``, ``end_batch`` and ``end_play`` meta tasks to end executing given host."""
state = self.get_active_state(self.get_state_for_host(hostname))
if state.run_state == IteratingStates.RESCUE:
# This is a special case for when ending a host occurs in rescue.
# By definition the meta task responsible for ending the host
# is the last task, so we need to clear the fail state to mark
# the host as rescued.
# The reason we need to do that is because this operation is
# normally done when PlayIterator transitions from rescue to
# always when only then we can say that rescue didn't fail
# but with ending a host via meta task, we don't get to that transition.
self.set_fail_state_for_host(hostname, FailedStates.NONE)
self.set_run_state_for_host(hostname, IteratingStates.COMPLETE)
self._play._removed_hosts.append(hostname)
| PlayIterator |
python | Textualize__rich | rich/markdown.py | {
"start": 15712,
"end": 25839
} | class ____(JupyterMixin):
"""A Markdown renderable.
Args:
markup (str): A string containing markdown.
code_theme (str, optional): Pygments theme for code blocks. Defaults to "monokai". See https://pygments.org/styles/ for code themes.
justify (JustifyMethod, optional): Justify value for paragraphs. Defaults to None.
style (Union[str, Style], optional): Optional style to apply to markdown.
hyperlinks (bool, optional): Enable hyperlinks. Defaults to ``True``.
inline_code_lexer: (str, optional): Lexer to use if inline code highlighting is
enabled. Defaults to None.
inline_code_theme: (Optional[str], optional): Pygments theme for inline code
highlighting, or None for no highlighting. Defaults to None.
"""
elements: ClassVar[dict[str, type[MarkdownElement]]] = {
"paragraph_open": Paragraph,
"heading_open": Heading,
"fence": CodeBlock,
"code_block": CodeBlock,
"blockquote_open": BlockQuote,
"hr": HorizontalRule,
"bullet_list_open": ListElement,
"ordered_list_open": ListElement,
"list_item_open": ListItem,
"image": ImageItem,
"table_open": TableElement,
"tbody_open": TableBodyElement,
"thead_open": TableHeaderElement,
"tr_open": TableRowElement,
"td_open": TableDataElement,
"th_open": TableDataElement,
}
inlines = {"em", "strong", "code", "s"}
def __init__(
self,
markup: str,
code_theme: str = "monokai",
justify: JustifyMethod | None = None,
style: str | Style = "none",
hyperlinks: bool = True,
inline_code_lexer: str | None = None,
inline_code_theme: str | None = None,
) -> None:
parser = MarkdownIt().enable("strikethrough").enable("table")
self.markup = markup
self.parsed = parser.parse(markup)
self.code_theme = code_theme
self.justify: JustifyMethod | None = justify
self.style = style
self.hyperlinks = hyperlinks
self.inline_code_lexer = inline_code_lexer
self.inline_code_theme = inline_code_theme or code_theme
def _flatten_tokens(self, tokens: Iterable[Token]) -> Iterable[Token]:
"""Flattens the token stream."""
for token in tokens:
is_fence = token.type == "fence"
is_image = token.tag == "img"
if token.children and not (is_image or is_fence):
yield from self._flatten_tokens(token.children)
else:
yield token
def __rich_console__(
self, console: Console, options: ConsoleOptions
) -> RenderResult:
"""Render markdown to the console."""
style = console.get_style(self.style, default="none")
options = options.update(height=None)
context = MarkdownContext(
console,
options,
style,
inline_code_lexer=self.inline_code_lexer,
inline_code_theme=self.inline_code_theme,
)
tokens = self.parsed
inline_style_tags = self.inlines
new_line = False
_new_line_segment = Segment.line()
for token in self._flatten_tokens(tokens):
node_type = token.type
tag = token.tag
entering = token.nesting == 1
exiting = token.nesting == -1
self_closing = token.nesting == 0
if node_type == "text":
context.on_text(token.content, node_type)
elif node_type == "hardbreak":
context.on_text("\n", node_type)
elif node_type == "softbreak":
context.on_text(" ", node_type)
elif node_type == "link_open":
href = str(token.attrs.get("href", ""))
if self.hyperlinks:
link_style = console.get_style("markdown.link_url", default="none")
link_style += Style(link=href)
context.enter_style(link_style)
else:
context.stack.push(Link.create(self, token))
elif node_type == "link_close":
if self.hyperlinks:
context.leave_style()
else:
element = context.stack.pop()
assert isinstance(element, Link)
link_style = console.get_style("markdown.link", default="none")
context.enter_style(link_style)
context.on_text(element.text.plain, node_type)
context.leave_style()
context.on_text(" (", node_type)
link_url_style = console.get_style(
"markdown.link_url", default="none"
)
context.enter_style(link_url_style)
context.on_text(element.href, node_type)
context.leave_style()
context.on_text(")", node_type)
elif (
tag in inline_style_tags
and node_type != "fence"
and node_type != "code_block"
):
if entering:
# If it's an opening inline token e.g. strong, em, etc.
# Then we move into a style context i.e. push to stack.
context.enter_style(f"markdown.{tag}")
elif exiting:
# If it's a closing inline style, then we pop the style
# off of the stack, to move out of the context of it...
context.leave_style()
else:
# If it's a self-closing inline style e.g. `code_inline`
context.enter_style(f"markdown.{tag}")
if token.content:
context.on_text(token.content, node_type)
context.leave_style()
else:
# Map the markdown tag -> MarkdownElement renderable
element_class = self.elements.get(token.type) or UnknownElement
element = element_class.create(self, token)
if entering or self_closing:
context.stack.push(element)
element.on_enter(context)
if exiting: # CLOSING tag
element = context.stack.pop()
should_render = not context.stack or (
context.stack
and context.stack.top.on_child_close(context, element)
)
if should_render:
if new_line:
yield _new_line_segment
yield from console.render(element, context.options)
elif self_closing: # SELF-CLOSING tags (e.g. text, code, image)
context.stack.pop()
text = token.content
if text is not None:
element.on_text(context, text)
should_render = (
not context.stack
or context.stack
and context.stack.top.on_child_close(context, element)
)
if should_render:
if new_line and node_type != "inline":
yield _new_line_segment
yield from console.render(element, context.options)
if exiting or self_closing:
element.on_leave(context)
new_line = element.new_line
if __name__ == "__main__": # pragma: no cover
import argparse
import sys
parser = argparse.ArgumentParser(
description="Render Markdown to the console with Rich"
)
parser.add_argument(
"path",
metavar="PATH",
help="path to markdown file, or - for stdin",
)
parser.add_argument(
"-c",
"--force-color",
dest="force_color",
action="store_true",
default=None,
help="force color for non-terminals",
)
parser.add_argument(
"-t",
"--code-theme",
dest="code_theme",
default="monokai",
help="pygments code theme",
)
parser.add_argument(
"-i",
"--inline-code-lexer",
dest="inline_code_lexer",
default=None,
help="inline_code_lexer",
)
parser.add_argument(
"-y",
"--hyperlinks",
dest="hyperlinks",
action="store_true",
help="enable hyperlinks",
)
parser.add_argument(
"-w",
"--width",
type=int,
dest="width",
default=None,
help="width of output (default will auto-detect)",
)
parser.add_argument(
"-j",
"--justify",
dest="justify",
action="store_true",
help="enable full text justify",
)
parser.add_argument(
"-p",
"--page",
dest="page",
action="store_true",
help="use pager to scroll output",
)
args = parser.parse_args()
from rich.console import Console
if args.path == "-":
markdown_body = sys.stdin.read()
else:
with open(args.path, encoding="utf-8") as markdown_file:
markdown_body = markdown_file.read()
markdown = Markdown(
markdown_body,
justify="full" if args.justify else "left",
code_theme=args.code_theme,
hyperlinks=args.hyperlinks,
inline_code_lexer=args.inline_code_lexer,
)
if args.page:
import io
import pydoc
fileio = io.StringIO()
console = Console(
file=fileio, force_terminal=args.force_color, width=args.width
)
console.print(markdown)
pydoc.pager(fileio.getvalue())
else:
console = Console(
force_terminal=args.force_color, width=args.width, record=True
)
console.print(markdown)
| Markdown |
python | apache__airflow | providers/google/tests/unit/google/cloud/operators/test_dataproc.py | {
"start": 30503,
"end": 46416
} | class ____(DataprocClusterTestBase):
def test_deprecation_warning(self):
with pytest.warns(AirflowProviderDeprecationWarning) as warnings:
op = DataprocCreateClusterOperator(
task_id=TASK_ID,
region=GCP_REGION,
project_id=GCP_PROJECT,
cluster_name="cluster_name",
num_workers=2,
zone="zone",
)
assert_warning("Passing cluster parameters by keywords", warnings)
assert op.project_id == GCP_PROJECT
assert op.cluster_name == "cluster_name"
assert op.cluster_config["worker_config"]["num_instances"] == 2
assert "zones/zone" in op.cluster_config["master_config"]["machine_type_uri"]
@mock.patch(DATAPROC_PATH.format("Cluster.to_dict"))
@mock.patch(DATAPROC_PATH.format("DataprocHook"))
def test_execute(self, mock_hook, to_dict_mock):
self.extra_links_manager_mock.attach_mock(mock_hook, "hook")
mock_hook.return_value.create_cluster.result.return_value = None
create_cluster_args = {
"region": GCP_REGION,
"project_id": GCP_PROJECT,
"cluster_name": CLUSTER_NAME,
"request_id": REQUEST_ID,
"retry": RETRY,
"timeout": TIMEOUT,
"metadata": METADATA,
"cluster_config": CONFIG,
"labels": LABELS,
"virtual_cluster_config": None,
}
expected_calls = [
*self.extra_links_expected_calls_base,
call.hook().create_cluster(**create_cluster_args),
]
op = DataprocCreateClusterOperator(
task_id=TASK_ID,
region=GCP_REGION,
labels=LABELS,
cluster_name=CLUSTER_NAME,
project_id=GCP_PROJECT,
cluster_config=CONFIG,
request_id=REQUEST_ID,
gcp_conn_id=GCP_CONN_ID,
retry=RETRY,
timeout=TIMEOUT,
metadata=METADATA,
impersonation_chain=IMPERSONATION_CHAIN,
)
op.execute(context=self.mock_context)
mock_hook.assert_called_once_with(gcp_conn_id=GCP_CONN_ID, impersonation_chain=IMPERSONATION_CHAIN)
mock_hook.return_value.create_cluster.assert_called_once_with(**create_cluster_args)
# Test whether xcom push occurs before create cluster is called
self.extra_links_manager_mock.assert_has_calls(expected_calls, any_order=False)
to_dict_mock.assert_called_once_with(mock_hook().wait_for_operation())
if AIRFLOW_V_3_0_PLUS:
self.mock_ti.xcom_push.assert_called_once_with(
key="dataproc_cluster",
value=DATAPROC_CLUSTER_EXPECTED,
)
else:
self.mock_ti.xcom_push.assert_called_once_with(
key="dataproc_cluster",
value=DATAPROC_CLUSTER_EXPECTED,
)
@mock.patch(DATAPROC_PATH.format("Cluster.to_dict"))
@mock.patch(DATAPROC_PATH.format("DataprocHook"))
def test_execute_in_gke(self, mock_hook, to_dict_mock):
self.extra_links_manager_mock.attach_mock(mock_hook, "hook")
mock_hook.return_value.create_cluster.return_value = None
create_cluster_args = {
"region": GCP_REGION,
"project_id": GCP_PROJECT,
"cluster_name": CLUSTER_NAME,
"request_id": REQUEST_ID,
"retry": RETRY,
"timeout": TIMEOUT,
"metadata": METADATA,
"cluster_config": None,
"labels": LABELS,
"virtual_cluster_config": VIRTUAL_CLUSTER_CONFIG,
}
expected_calls = [
*self.extra_links_expected_calls_base,
call.hook().create_cluster(**create_cluster_args),
]
op = DataprocCreateClusterOperator(
task_id=TASK_ID,
region=GCP_REGION,
labels=LABELS,
cluster_name=CLUSTER_NAME,
project_id=GCP_PROJECT,
virtual_cluster_config=VIRTUAL_CLUSTER_CONFIG,
request_id=REQUEST_ID,
gcp_conn_id=GCP_CONN_ID,
retry=RETRY,
timeout=TIMEOUT,
metadata=METADATA,
impersonation_chain=IMPERSONATION_CHAIN,
)
op.execute(context=self.mock_context)
mock_hook.assert_called_once_with(gcp_conn_id=GCP_CONN_ID, impersonation_chain=IMPERSONATION_CHAIN)
mock_hook.return_value.create_cluster.assert_called_once_with(**create_cluster_args)
# Test whether xcom push occurs before create cluster is called
self.extra_links_manager_mock.assert_has_calls(expected_calls, any_order=False)
to_dict_mock.assert_called_once_with(mock_hook().wait_for_operation())
if AIRFLOW_V_3_0_PLUS:
self.mock_ti.xcom_push.assert_called_once_with(
key="dataproc_cluster",
value=DATAPROC_CLUSTER_EXPECTED,
)
else:
self.mock_ti.xcom_push.assert_called_once_with(
key="dataproc_cluster",
value=DATAPROC_CLUSTER_EXPECTED,
)
@mock.patch(DATAPROC_PATH.format("Cluster.to_dict"))
@mock.patch(DATAPROC_PATH.format("DataprocHook"))
def test_execute_if_cluster_exists(self, mock_hook, to_dict_mock):
mock_hook.return_value.create_cluster.side_effect = [AlreadyExists("test")]
mock_hook.return_value.get_cluster.return_value.status.state = 0
op = DataprocCreateClusterOperator(
task_id=TASK_ID,
region=GCP_REGION,
project_id=GCP_PROJECT,
cluster_config=CONFIG,
labels=LABELS,
cluster_name=CLUSTER_NAME,
gcp_conn_id=GCP_CONN_ID,
retry=RETRY,
timeout=TIMEOUT,
metadata=METADATA,
request_id=REQUEST_ID,
impersonation_chain=IMPERSONATION_CHAIN,
)
op.execute(context=self.mock_context)
mock_hook.assert_called_once_with(gcp_conn_id=GCP_CONN_ID, impersonation_chain=IMPERSONATION_CHAIN)
mock_hook.return_value.create_cluster.assert_called_once_with(
region=GCP_REGION,
project_id=GCP_PROJECT,
cluster_config=CONFIG,
labels=LABELS,
cluster_name=CLUSTER_NAME,
request_id=REQUEST_ID,
retry=RETRY,
timeout=TIMEOUT,
metadata=METADATA,
virtual_cluster_config=None,
)
mock_hook.return_value.get_cluster.assert_called_once_with(
region=GCP_REGION,
project_id=GCP_PROJECT,
cluster_name=CLUSTER_NAME,
retry=RETRY,
timeout=TIMEOUT,
metadata=METADATA,
)
to_dict_mock.assert_called_once_with(mock_hook.return_value.get_cluster.return_value)
@mock.patch(DATAPROC_PATH.format("DataprocHook"))
def test_execute_if_cluster_exists_do_not_use(self, mock_hook):
mock_hook.return_value.create_cluster.side_effect = [AlreadyExists("test")]
mock_hook.return_value.get_cluster.return_value.status.state = 0
op = DataprocCreateClusterOperator(
task_id=TASK_ID,
region=GCP_REGION,
project_id=GCP_PROJECT,
cluster_config=CONFIG,
labels=LABELS,
cluster_name=CLUSTER_NAME,
gcp_conn_id=GCP_CONN_ID,
retry=RETRY,
timeout=TIMEOUT,
metadata=METADATA,
request_id=REQUEST_ID,
use_if_exists=False,
)
with pytest.raises(AlreadyExists):
op.execute(context=self.mock_context)
@mock.patch(DATAPROC_PATH.format("DataprocCreateClusterOperator._wait_for_cluster_in_deleting_state"))
@mock.patch(DATAPROC_PATH.format("DataprocHook"))
def test_execute_if_cluster_exists_in_error_state(self, mock_hook, mock_wait_for_deleting):
mock_hook.return_value.create_cluster.side_effect = [AlreadyExists("test")]
cluster_status = mock_hook.return_value.get_cluster.return_value.status
cluster_status.state = 0
cluster_status.State.ERROR = 0
mock_wait_for_deleting.return_value.get_cluster.side_effect = [NotFound]
op = DataprocCreateClusterOperator(
task_id=TASK_ID,
region=GCP_REGION,
project_id=GCP_PROJECT,
cluster_config=CONFIG,
labels=LABELS,
cluster_name=CLUSTER_NAME,
delete_on_error=True,
gcp_conn_id=GCP_CONN_ID,
retry=RETRY,
timeout=TIMEOUT,
metadata=METADATA,
request_id=REQUEST_ID,
)
with pytest.raises(AirflowException):
op.execute(context=self.mock_context)
mock_hook.return_value.diagnose_cluster.assert_called_once_with(
region=GCP_REGION, project_id=GCP_PROJECT, cluster_name=CLUSTER_NAME
)
mock_hook.return_value.diagnose_cluster.return_value.result.assert_called_once_with()
mock_hook.return_value.delete_cluster.assert_called_once_with(
region=GCP_REGION, project_id=GCP_PROJECT, cluster_name=CLUSTER_NAME
)
@mock.patch(DATAPROC_PATH.format("Cluster.to_dict"))
@mock.patch(DATAPROC_PATH.format("exponential_sleep_generator"))
@mock.patch(DATAPROC_PATH.format("DataprocCreateClusterOperator._create_cluster"))
@mock.patch(DATAPROC_PATH.format("DataprocCreateClusterOperator._get_cluster"))
@mock.patch(DATAPROC_PATH.format("DataprocHook"))
def test_execute_if_cluster_exists_in_deleting_state(
self,
mock_hook,
mock_get_cluster,
mock_create_cluster,
mock_generator,
to_dict_mock,
):
cluster_deleting = mock.MagicMock()
cluster_deleting.status.state = 0
cluster_deleting.status.State.DELETING = 0
cluster_running = mock.MagicMock()
cluster_running.status.state = 0
cluster_running.status.State.RUNNING = 0
mock_create_cluster.side_effect = [AlreadyExists("test"), cluster_running]
mock_generator.return_value = [0]
mock_get_cluster.side_effect = [cluster_deleting, NotFound("test")]
op = DataprocCreateClusterOperator(
task_id=TASK_ID,
region=GCP_REGION,
project_id=GCP_PROJECT,
cluster_config=CONFIG,
labels=LABELS,
cluster_name=CLUSTER_NAME,
delete_on_error=True,
gcp_conn_id=GCP_CONN_ID,
)
op.execute(context=self.mock_context)
calls = [mock.call(mock_hook.return_value), mock.call(mock_hook.return_value)]
mock_get_cluster.assert_has_calls(calls)
mock_create_cluster.assert_has_calls(calls)
to_dict_mock.assert_called_once_with(cluster_running)
@mock.patch(DATAPROC_PATH.format("DataprocHook"))
@mock.patch(DATAPROC_TRIGGERS_PATH.format("DataprocAsyncHook"))
def test_create_execute_call_defer_method(self, mock_trigger_hook, mock_hook):
mock_hook.return_value.create_cluster.return_value = None
operator = DataprocCreateClusterOperator(
task_id=TASK_ID,
region=GCP_REGION,
project_id=GCP_PROJECT,
cluster_config=CONFIG,
labels=LABELS,
cluster_name=CLUSTER_NAME,
delete_on_error=True,
metadata=METADATA,
gcp_conn_id=GCP_CONN_ID,
impersonation_chain=IMPERSONATION_CHAIN,
retry=RETRY,
timeout=TIMEOUT,
deferrable=True,
)
with pytest.raises(TaskDeferred) as exc:
operator.execute(mock.MagicMock())
mock_hook.assert_called_once_with(
gcp_conn_id=GCP_CONN_ID,
impersonation_chain=IMPERSONATION_CHAIN,
)
mock_hook.return_value.create_cluster.assert_called_once_with(
region=GCP_REGION,
project_id=GCP_PROJECT,
cluster_config=CONFIG,
request_id=None,
labels=LABELS,
cluster_name=CLUSTER_NAME,
virtual_cluster_config=None,
retry=RETRY,
timeout=TIMEOUT,
metadata=METADATA,
)
mock_hook.return_value.wait_for_operation.assert_not_called()
assert isinstance(exc.value.trigger, DataprocClusterTrigger)
assert exc.value.method_name == GOOGLE_DEFAULT_DEFERRABLE_METHOD_NAME
@mock.patch(DATAPROC_PATH.format("DataprocCreateClusterOperator.defer"))
@mock.patch(DATAPROC_PATH.format("DataprocHook"))
@mock.patch(DATAPROC_TRIGGERS_PATH.format("DataprocAsyncHook"))
def test_create_execute_call_finished_before_defer(self, mock_trigger_hook, mock_hook, mock_defer):
cluster = Cluster(
cluster_name="test_cluster",
status=dataproc.ClusterStatus(state=dataproc.ClusterStatus.State.RUNNING),
)
mock_hook.return_value.create_cluster.return_value = cluster
mock_hook.return_value.get_cluster.return_value = cluster
operator = DataprocCreateClusterOperator(
task_id=TASK_ID,
region=GCP_REGION,
project_id=GCP_PROJECT,
cluster_config=CONFIG,
labels=LABELS,
cluster_name=CLUSTER_NAME,
delete_on_error=True,
metadata=METADATA,
gcp_conn_id=GCP_CONN_ID,
impersonation_chain=IMPERSONATION_CHAIN,
retry=RETRY,
timeout=TIMEOUT,
deferrable=True,
)
operator.execute(mock.MagicMock())
assert not mock_defer.called
mock_hook.assert_called_once_with(
gcp_conn_id=GCP_CONN_ID,
impersonation_chain=IMPERSONATION_CHAIN,
)
mock_hook.return_value.create_cluster.assert_called_once_with(
region=GCP_REGION,
project_id=GCP_PROJECT,
cluster_config=CONFIG,
request_id=None,
labels=LABELS,
cluster_name=CLUSTER_NAME,
virtual_cluster_config=None,
retry=RETRY,
timeout=TIMEOUT,
metadata=METADATA,
)
mock_hook.return_value.wait_for_operation.assert_not_called()
@pytest.mark.db_test
@pytest.mark.need_serialized_dag
def test_create_cluster_operator_extra_links(
dag_maker, create_task_instance_of_operator, mock_supervisor_comms
):
ti = create_task_instance_of_operator(
DataprocCreateClusterOperator,
dag_id=TEST_DAG_ID,
task_id=TASK_ID,
region=GCP_REGION,
project_id=GCP_PROJECT,
cluster_name=CLUSTER_NAME,
delete_on_error=True,
gcp_conn_id=GCP_CONN_ID,
)
serialized_dag = dag_maker.get_serialized_data()
# Assert operator links for serialized DAG
deserialized_dag = SerializedDAG.deserialize_dag(serialized_dag["dag"])
operator_extra_link = deserialized_dag.tasks[0].operator_extra_links[0]
assert operator_extra_link.name == "Dataproc Cluster"
if AIRFLOW_V_3_0_PLUS:
mock_supervisor_comms.send.return_value = XComResult(
key="key",
value="",
)
# Assert operator link is empty when no XCom push occurred
assert ti.task.operator_extra_links[0].get_link(operator=ti.task, ti_key=ti.key) == ""
ti.xcom_push(key="dataproc_cluster", value=DATAPROC_CLUSTER_EXPECTED)
if AIRFLOW_V_3_0_PLUS:
mock_supervisor_comms.send.return_value = XComResult(
key="key",
value={"cluster_id": "cluster_name", "project_id": "test-project", "region": "test-location"},
)
# Assert operator links after execution
assert (
ti.task.operator_extra_links[0].get_link(operator=ti.task, ti_key=ti.key)
== DATAPROC_CLUSTER_LINK_EXPECTED
)
| TestDataprocCreateClusterOperator |
python | ray-project__ray | python/ray/tune/tests/test_tune_restore.py | {
"start": 21762,
"end": 22711
} | class ____(unittest.TestCase):
def test_resource_exhausted_info(self):
"""This is to test if helpful information is displayed when
the objects captured in trainable/training function are too
large and RESOURCES_EXHAUSTED error of gRPC is triggered."""
# generate some random data to be captured implicitly in training func.
from sklearn.datasets import fetch_olivetti_faces
a_large_array = []
for i in range(50):
a_large_array.append(fetch_olivetti_faces())
def training_func(config):
for item in a_large_array:
assert item
with self.assertRaisesRegex(
TuneError,
"The Trainable/training function is too large for grpc resource limit.",
):
tune.run(training_func)
if __name__ == "__main__":
import sys
sys.exit(pytest.main(["-v", __file__] + sys.argv[1:]))
| ResourceExhaustedTest |
python | sqlalchemy__sqlalchemy | lib/sqlalchemy/orm/identity.py | {
"start": 3432,
"end": 9250
} | class ____(IdentityMap):
_dict: Dict[_IdentityKeyType[Any], InstanceState[Any]]
def __getitem__(self, key: _IdentityKeyType[_O]) -> _O:
state = cast("InstanceState[_O]", self._dict[key])
o = state.obj()
if o is None:
raise KeyError(key)
return o
def __contains__(self, key: _IdentityKeyType[Any]) -> bool:
try:
if key in self._dict:
state = self._dict[key]
o = state.obj()
else:
return False
except KeyError:
return False
else:
return o is not None
def contains_state(self, state: InstanceState[Any]) -> bool:
if state.key in self._dict:
if TYPE_CHECKING:
assert state.key is not None
try:
return self._dict[state.key] is state
except KeyError:
return False
else:
return False
def replace(
self, state: InstanceState[Any]
) -> Optional[InstanceState[Any]]:
assert state.key is not None
if state.key in self._dict:
try:
existing = existing_non_none = self._dict[state.key]
except KeyError:
# catch gc removed the key after we just checked for it
existing = None
else:
if existing_non_none is not state:
self._manage_removed_state(existing_non_none)
else:
return None
else:
existing = None
self._dict[state.key] = state
self._manage_incoming_state(state)
return existing
def add(self, state: InstanceState[Any]) -> bool:
key = state.key
assert key is not None
# inline of self.__contains__
if key in self._dict:
try:
existing_state = self._dict[key]
except KeyError:
# catch gc removed the key after we just checked for it
pass
else:
if existing_state is not state:
o = existing_state.obj()
if o is not None:
raise sa_exc.InvalidRequestError(
"Can't attach instance "
"%s; another instance with key %s is already "
"present in this session."
% (orm_util.state_str(state), state.key)
)
else:
return False
self._dict[key] = state
self._manage_incoming_state(state)
return True
def _add_unpresent(
self, state: InstanceState[Any], key: _IdentityKeyType[Any]
) -> None:
# inlined form of add() called by loading.py
self._dict[key] = state
state._instance_dict = self._wr
def fast_get_state(
self, key: _IdentityKeyType[_O]
) -> Optional[InstanceState[_O]]:
return self._dict.get(key)
def get(
self, key: _IdentityKeyType[_O], default: Optional[_O] = None
) -> Optional[_O]:
if key not in self._dict:
return default
try:
state = cast("InstanceState[_O]", self._dict[key])
except KeyError:
# catch gc removed the key after we just checked for it
return default
else:
o = state.obj()
if o is None:
return default
return o
def items(self) -> List[Tuple[_IdentityKeyType[Any], InstanceState[Any]]]:
values = self.all_states()
result = []
for state in values:
value = state.obj()
key = state.key
assert key is not None
if value is not None:
result.append((key, value))
return result
def values(self) -> List[object]:
values = self.all_states()
result = []
for state in values:
value = state.obj()
if value is not None:
result.append(value)
return result
def __iter__(self) -> Iterator[_IdentityKeyType[Any]]:
return iter(self.keys())
def all_states(self) -> List[InstanceState[Any]]:
return list(self._dict.values())
def _fast_discard(self, state: InstanceState[Any]) -> None:
# used by InstanceState for state being
# GC'ed, inlines _managed_removed_state
key = state.key
assert key is not None
try:
st = self._dict[key]
except KeyError:
# catch gc removed the key after we just checked for it
pass
else:
if st is state:
self._dict.pop(key, None)
def discard(self, state: InstanceState[Any]) -> None:
self.safe_discard(state)
def safe_discard(self, state: InstanceState[Any]) -> None:
key = state.key
if key in self._dict:
assert key is not None
try:
st = self._dict[key]
except KeyError:
# catch gc removed the key after we just checked for it
pass
else:
if st is state:
self._dict.pop(key, None)
self._manage_removed_state(state)
def _killed(state: InstanceState[Any], key: _IdentityKeyType[Any]) -> NoReturn:
# external function to avoid creating cycles when assigned to
# the IdentityMap
raise sa_exc.InvalidRequestError(
"Object %s cannot be converted to 'persistent' state, as this "
"identity map is no longer valid. Has the owning Session "
"been closed?" % orm_util.state_str(state),
code="lkrp",
)
| _WeakInstanceDict |
python | numba__numba | numba/tests/test_dyn_array.py | {
"start": 49348,
"end": 55791
} | class ____(MemoryLeakMixin, TestCase):
"""
Tests for np.stack().
"""
def _3d_arrays(self):
a = np.arange(24).reshape((4, 3, 2))
b = a + 10
c = (b + 10).copy(order='F')
d = (c + 10)[::-1]
e = (d + 10)[...,::-1]
return a, b, c, d, e
@contextlib.contextmanager
def assert_invalid_sizes(self):
with self.assertRaises(ValueError) as raises:
yield
self.assertIn("all input arrays must have the same shape",
str(raises.exception))
def check_stack(self, pyfunc, cfunc, args):
expected = pyfunc(*args)
got = cfunc(*args)
# Numba doesn't choose the same layout as Numpy.
# We would like to check the result is contiguous, but we can't
# rely on the "flags" attribute when there are 1-sized
# dimensions.
self.assertEqual(got.shape, expected.shape)
self.assertPreciseEqual(got.flatten(), expected.flatten())
def check_3d(self, pyfunc, cfunc, generate_starargs):
def check(a, b, c, args):
self.check_stack(pyfunc, cfunc, (a, b, c) + args)
def check_all_axes(a, b, c):
for args in generate_starargs():
check(a, b, c, args)
a, b, c, d, e = self._3d_arrays()
# C, C, C
check_all_axes(a, b, b)
# C, C, F
check_all_axes(a, b, c)
# F, F, F
check_all_axes(a.T, b.T, a.T)
# F, F, C
check_all_axes(a.T, b.T, c.T)
# F, F, A
check_all_axes(a.T, b.T, d.T)
# A, A, A
check_all_axes(d.T, e.T, d.T)
# Different but compatible dtypes
check_all_axes(a, b.astype(np.float64), b)
def check_runtime_errors(self, cfunc, generate_starargs):
# Exceptions leak references
self.assert_no_memory_leak()
self.disable_leak_check()
# Inputs have different shapes
a, b, c, d, e = self._3d_arrays()
with self.assert_invalid_sizes():
args = next(generate_starargs())
cfunc(a[:-1], b, c, *args)
def test_3d(self):
"""
stack(3d arrays, axis)
"""
pyfunc = np_stack2
cfunc = nrtjit(pyfunc)
def generate_starargs():
for axis in range(3):
yield (axis,)
yield (-3 + axis,)
self.check_3d(pyfunc, cfunc, generate_starargs)
self.check_runtime_errors(cfunc, generate_starargs)
def test_3d_no_axis(self):
"""
stack(3d arrays)
"""
pyfunc = np_stack1
cfunc = nrtjit(pyfunc)
def generate_starargs():
yield()
self.check_3d(pyfunc, cfunc, generate_starargs)
self.check_runtime_errors(cfunc, generate_starargs)
def test_0d(self):
"""
stack(0d arrays)
"""
pyfunc = np_stack1
cfunc = nrtjit(pyfunc)
a = np.array(42)
b = np.array(-5j)
c = np.array(True)
self.check_stack(pyfunc, cfunc, (a, b, c))
def check_xxstack(self, pyfunc, cfunc):
"""
3d and 0d tests for hstack(), vstack(), dstack().
"""
def generate_starargs():
yield()
self.check_3d(pyfunc, cfunc, generate_starargs)
# 0d
a = np.array(42)
b = np.array(-5j)
c = np.array(True)
self.check_stack(pyfunc, cfunc, (a, b, a))
def test_hstack(self):
pyfunc = np_hstack
cfunc = nrtjit(pyfunc)
self.check_xxstack(pyfunc, cfunc)
# 1d
a = np.arange(5)
b = np.arange(6) + 10
self.check_stack(pyfunc, cfunc, (a, b, b))
# 2d
a = np.arange(6).reshape((2, 3))
b = np.arange(8).reshape((2, 4)) + 100
self.check_stack(pyfunc, cfunc, (a, b, a))
def test_vstack(self):
# Since np.row_stack is an alias for np.vstack, it does not need a
# separate Numba implementation. For every test for np.vstack, the same
# test for np.row_stack has been added.
functions = [np_vstack, np_row_stack]
for pyfunc in functions:
cfunc = nrtjit(pyfunc)
self.check_xxstack(pyfunc, cfunc)
# 1d
a = np.arange(5)
b = a + 10
self.check_stack(pyfunc, cfunc, (a, b, b))
# 2d
a = np.arange(6).reshape((3, 2))
b = np.arange(8).reshape((4, 2)) + 100
self.check_stack(pyfunc, cfunc, (a, b, b))
def test_dstack(self):
pyfunc = np_dstack
cfunc = nrtjit(pyfunc)
self.check_xxstack(pyfunc, cfunc)
# 1d
a = np.arange(5)
b = a + 10
self.check_stack(pyfunc, cfunc, (a, b, b))
# 2d
a = np.arange(12).reshape((3, 4))
b = a + 100
self.check_stack(pyfunc, cfunc, (a, b, b))
def test_column_stack(self):
pyfunc = np_column_stack
cfunc = nrtjit(pyfunc)
a = np.arange(4)
b = a + 10
c = np.arange(12).reshape((4, 3))
self.check_stack(pyfunc, cfunc, (a, b, c))
# Exceptions leak references
self.assert_no_memory_leak()
self.disable_leak_check()
# Invalid dims
a = np.array(42)
with self.assertTypingError():
cfunc((a, a, a))
a = a.reshape((1, 1, 1))
with self.assertTypingError():
cfunc((a, a, a))
def test_bad_arrays(self):
for pyfunc in (np_stack1, np_hstack, np_vstack, np_dstack, np_column_stack):
cfunc = nrtjit(pyfunc)
c = np.arange(12).reshape((4, 3))
# non-tuple input
with self.assertTypingError() as raises:
cfunc(c, 1, c)
self.assertIn('expecting a non-empty tuple of arrays', str(raises.exception))
def benchmark_refct_speed():
def pyfunc(x, y, t):
"""Swap array x and y for t number of times
"""
for i in range(t):
x, y = y, x
return x, y
cfunc = nrtjit(pyfunc)
x = np.random.random(100)
y = np.random.random(100)
t = 10000
def bench_pyfunc():
pyfunc(x, y, t)
def bench_cfunc():
cfunc(x, y, t)
python_time = utils.benchmark(bench_pyfunc)
numba_time = utils.benchmark(bench_cfunc)
print(python_time)
print(numba_time)
if __name__ == "__main__":
unittest.main()
| TestNpStack |
python | joerick__pyinstrument | pyinstrument/renderers/speedscope.py | {
"start": 1978,
"end": 3075
} | class ____(json.JSONEncoder):
"""
Encoder class used by json.dumps to serialize the various
speedscope data classes.
"""
def default(self, o: Any) -> Any:
if isinstance(o, SpeedscopeFile):
return {
"$schema": o.schema,
"name": o.name,
"activeProfileIndex": o.active_profile_index,
"exporter": o.exporter,
"profiles": o.profiles,
"shared": o.shared,
}
if isinstance(o, SpeedscopeProfile):
return {
"type": o.type,
"name": o.name,
"unit": o.unit,
"startValue": o.start_value,
"endValue": o.end_value,
"events": o.events,
}
if isinstance(o, (SpeedscopeFrame, SpeedscopeEvent)):
d: SpeedscopeFrameDictType | SpeedscopeEventDictType = o.__dict__
return d
if isinstance(o, SpeedscopeEventType):
return o.value
return json.JSONEncoder.default(self, o)
| SpeedscopeEncoder |
python | pandas-dev__pandas | pandas/tests/frame/methods/test_describe.py | {
"start": 183,
"end": 16064
} | class ____:
def test_describe_bool_in_mixed_frame(self):
df = DataFrame(
{
"string_data": ["a", "b", "c", "d", "e"],
"bool_data": [True, True, False, False, False],
"int_data": [10, 20, 30, 40, 50],
}
)
# Integer data are included in .describe() output,
# Boolean and string data are not.
result = df.describe()
expected = DataFrame(
{"int_data": [5, 30, df.int_data.std(), 10, 20, 30, 40, 50]},
index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
)
tm.assert_frame_equal(result, expected)
# Top value is a boolean value that is False
result = df.describe(include=["bool"])
expected = DataFrame(
{"bool_data": [5, 2, False, 3]}, index=["count", "unique", "top", "freq"]
)
tm.assert_frame_equal(result, expected)
def test_describe_empty_object(self):
# GH#27183
df = DataFrame({"A": [None, None]}, dtype=object)
result = df.describe()
expected = DataFrame(
{"A": [0, 0, np.nan, np.nan]},
dtype=object,
index=["count", "unique", "top", "freq"],
)
tm.assert_frame_equal(result, expected)
result = df.iloc[:0].describe()
tm.assert_frame_equal(result, expected)
def test_describe_bool_frame(self):
# GH#13891
df = DataFrame(
{
"bool_data_1": [False, False, True, True],
"bool_data_2": [False, True, True, True],
}
)
result = df.describe()
expected = DataFrame(
{"bool_data_1": [4, 2, False, 2], "bool_data_2": [4, 2, True, 3]},
index=["count", "unique", "top", "freq"],
)
tm.assert_frame_equal(result, expected)
df = DataFrame(
{
"bool_data": [False, False, True, True, False],
"int_data": [0, 1, 2, 3, 4],
}
)
result = df.describe()
expected = DataFrame(
{"int_data": [5, 2, df.int_data.std(), 0, 1, 2, 3, 4]},
index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
)
tm.assert_frame_equal(result, expected)
df = DataFrame(
{"bool_data": [False, False, True, True], "str_data": ["a", "b", "c", "a"]}
)
result = df.describe()
expected = DataFrame(
{"bool_data": [4, 2, False, 2], "str_data": [4, 3, "a", 2]},
index=["count", "unique", "top", "freq"],
)
tm.assert_frame_equal(result, expected)
def test_describe_categorical(self):
df = DataFrame({"value": np.random.default_rng(2).integers(0, 10000, 100)})
labels = [f"{i} - {i + 499}" for i in range(0, 10000, 500)]
cat_labels = Categorical(labels, labels)
df = df.sort_values(by=["value"], ascending=True)
df["value_group"] = pd.cut(
df.value, range(0, 10500, 500), right=False, labels=cat_labels
)
cat = df
# Categoricals should not show up together with numerical columns
result = cat.describe()
assert len(result.columns) == 1
# In a frame, describe() for the cat should be the same as for string
# arrays (count, unique, top, freq)
cat = Categorical(
["a", "b", "b", "b"], categories=["a", "b", "c"], ordered=True
)
s = Series(cat)
result = s.describe()
expected = Series([4, 2, "b", 3], index=["count", "unique", "top", "freq"])
tm.assert_series_equal(result, expected)
cat = Series(Categorical(["a", "b", "c", "c"]))
df3 = DataFrame({"cat": cat, "s": ["a", "b", "c", "c"]})
result = df3.describe()
tm.assert_numpy_array_equal(result["cat"].values, result["s"].values)
def test_describe_empty_categorical_column(self):
# GH#26397
# Ensure the index of an empty categorical DataFrame column
# also contains (count, unique, top, freq)
df = DataFrame({"empty_col": Categorical([])})
result = df.describe()
expected = DataFrame(
{"empty_col": [0, 0, np.nan, np.nan]},
index=["count", "unique", "top", "freq"],
dtype="object",
)
tm.assert_frame_equal(result, expected)
# ensure NaN, not None
assert np.isnan(result.iloc[2, 0])
assert np.isnan(result.iloc[3, 0])
def test_describe_categorical_columns(self):
# GH#11558
columns = pd.CategoricalIndex(["int1", "int2", "obj"], ordered=True, name="XXX")
df = DataFrame(
{
"int1": [10, 20, 30, 40, 50],
"int2": [10, 20, 30, 40, 50],
"obj": ["A", 0, None, "X", 1],
},
columns=columns,
)
result = df.describe()
exp_columns = pd.CategoricalIndex(
["int1", "int2"],
categories=["int1", "int2", "obj"],
ordered=True,
name="XXX",
)
expected = DataFrame(
{
"int1": [5, 30, df.int1.std(), 10, 20, 30, 40, 50],
"int2": [5, 30, df.int2.std(), 10, 20, 30, 40, 50],
},
index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
columns=exp_columns,
)
tm.assert_frame_equal(result, expected)
tm.assert_categorical_equal(result.columns.values, expected.columns.values)
def test_describe_datetime_columns(self):
columns = pd.DatetimeIndex(
["2011-01-01", "2011-02-01", "2011-03-01"],
freq="MS",
tz="US/Eastern",
name="XXX",
)
df = DataFrame(
{
0: [10, 20, 30, 40, 50],
1: [10, 20, 30, 40, 50],
2: ["A", 0, None, "X", 1],
}
)
df.columns = columns
result = df.describe()
exp_columns = pd.DatetimeIndex(
["2011-01-01", "2011-02-01"], freq="MS", tz="US/Eastern", name="XXX"
)
expected = DataFrame(
{
0: [5, 30, df.iloc[:, 0].std(), 10, 20, 30, 40, 50],
1: [5, 30, df.iloc[:, 1].std(), 10, 20, 30, 40, 50],
},
index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
)
expected.columns = exp_columns
tm.assert_frame_equal(result, expected)
assert result.columns.freq == "MS"
assert result.columns.tz == expected.columns.tz
def test_describe_timedelta_values(self):
# GH#6145
t1 = pd.timedelta_range("1 days", freq="D", periods=5)
t2 = pd.timedelta_range("1 hours", freq="h", periods=5)
df = DataFrame({"t1": t1, "t2": t2})
expected = DataFrame(
{
"t1": [
5,
pd.Timedelta("3 days"),
df.iloc[:, 0].std(),
pd.Timedelta("1 days"),
pd.Timedelta("2 days"),
pd.Timedelta("3 days"),
pd.Timedelta("4 days"),
pd.Timedelta("5 days"),
],
"t2": [
5,
pd.Timedelta("3 hours"),
df.iloc[:, 1].std(),
pd.Timedelta("1 hours"),
pd.Timedelta("2 hours"),
pd.Timedelta("3 hours"),
pd.Timedelta("4 hours"),
pd.Timedelta("5 hours"),
],
},
index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
)
result = df.describe()
tm.assert_frame_equal(result, expected)
exp_repr = (
" t1 t2\n"
"count 5 5\n"
"mean 3 days 00:00:00 0 days 03:00:00\n"
"std 1 days 13:56:50.394919273 0 days 01:34:52.099788303\n"
"min 1 days 00:00:00 0 days 01:00:00\n"
"25% 2 days 00:00:00 0 days 02:00:00\n"
"50% 3 days 00:00:00 0 days 03:00:00\n"
"75% 4 days 00:00:00 0 days 04:00:00\n"
"max 5 days 00:00:00 0 days 05:00:00"
)
assert repr(result) == exp_repr
def test_describe_tz_values(self, tz_naive_fixture):
# GH#21332
tz = tz_naive_fixture
s1 = Series(range(5))
start = Timestamp(2018, 1, 1)
end = Timestamp(2018, 1, 5)
s2 = Series(date_range(start, end, tz=tz))
df = DataFrame({"s1": s1, "s2": s2})
expected = DataFrame(
{
"s1": [5, 2, 0, 1, 2, 3, 4, 1.581139],
"s2": [
5,
Timestamp(2018, 1, 3).tz_localize(tz),
start.tz_localize(tz),
s2[1],
s2[2],
s2[3],
end.tz_localize(tz),
np.nan,
],
},
index=["count", "mean", "min", "25%", "50%", "75%", "max", "std"],
)
result = df.describe(include="all")
tm.assert_frame_equal(result, expected)
def test_datetime_is_numeric_includes_datetime(self):
df = DataFrame({"a": date_range("2012", periods=3), "b": [1, 2, 3]})
result = df.describe()
expected = DataFrame(
{
"a": [
3,
Timestamp("2012-01-02"),
Timestamp("2012-01-01"),
Timestamp("2012-01-01T12:00:00"),
Timestamp("2012-01-02"),
Timestamp("2012-01-02T12:00:00"),
Timestamp("2012-01-03"),
np.nan,
],
"b": [3, 2, 1, 1.5, 2, 2.5, 3, 1],
},
index=["count", "mean", "min", "25%", "50%", "75%", "max", "std"],
)
tm.assert_frame_equal(result, expected)
def test_describe_tz_values2(self):
tz = "CET"
s1 = Series(range(5))
start = Timestamp(2018, 1, 1)
end = Timestamp(2018, 1, 5)
s2 = Series(date_range(start, end, tz=tz))
df = DataFrame({"s1": s1, "s2": s2})
s1_ = s1.describe()
s2_ = s2.describe()
idx = [
"count",
"mean",
"min",
"25%",
"50%",
"75%",
"max",
"std",
]
expected = pd.concat([s1_, s2_], axis=1, keys=["s1", "s2"]).reindex(idx)
result = df.describe(include="all")
tm.assert_frame_equal(result, expected)
def test_describe_percentiles_integer_idx(self):
# GH#26660
df = DataFrame({"x": [1]})
pct = np.linspace(0, 1, 10 + 1)
result = df.describe(percentiles=pct)
expected = DataFrame(
{"x": [1.0, 1.0, np.nan, 1.0, *(1.0 for _ in pct), 1.0]},
index=[
"count",
"mean",
"std",
"min",
"0%",
"10%",
"20%",
"30%",
"40%",
"50%",
"60%",
"70%",
"80%",
"90%",
"100%",
"max",
],
)
tm.assert_frame_equal(result, expected)
def test_describe_does_not_raise_error_for_dictlike_elements(self):
# GH#32409
df = DataFrame([{"test": {"a": "1"}}, {"test": {"a": "2"}}])
expected = DataFrame(
{"test": [2, 2, {"a": "1"}, 1]}, index=["count", "unique", "top", "freq"]
)
result = df.describe()
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize("exclude", ["x", "y", ["x", "y"], ["x", "z"]])
def test_describe_when_include_all_exclude_not_allowed(self, exclude):
"""
When include is 'all', then setting exclude != None is not allowed.
"""
df = DataFrame({"x": [1], "y": [2], "z": [3]})
msg = "exclude must be None when include is 'all'"
with pytest.raises(ValueError, match=msg):
df.describe(include="all", exclude=exclude)
def test_describe_when_included_dtypes_not_present(self):
# GH#61863
df = DataFrame({"a": [1, 2, 3]})
msg = "No columns match the specified include or exclude data types"
with pytest.raises(ValueError, match=msg):
df.describe(include=["datetime"])
def test_describe_with_duplicate_columns(self):
df = DataFrame(
[[1, 1, 1], [2, 2, 2], [3, 3, 3]],
columns=["bar", "a", "a"],
dtype="float64",
)
result = df.describe()
ser = df.iloc[:, 0].describe()
expected = pd.concat([ser, ser, ser], keys=df.columns, axis=1)
tm.assert_frame_equal(result, expected)
def test_ea_with_na(self, any_numeric_ea_dtype):
# GH#48778
df = DataFrame({"a": [1, pd.NA, pd.NA], "b": pd.NA}, dtype=any_numeric_ea_dtype)
result = df.describe()
expected = DataFrame(
{"a": [1.0, 1.0, pd.NA] + [1.0] * 5, "b": [0.0] + [pd.NA] * 7},
index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
dtype="Float64",
)
tm.assert_frame_equal(result, expected)
def test_describe_exclude_pa_dtype(self):
# GH#52570
pa = pytest.importorskip("pyarrow")
df = DataFrame(
{
"a": Series([1, 2, 3], dtype=pd.ArrowDtype(pa.int8())),
"b": Series([1, 2, 3], dtype=pd.ArrowDtype(pa.int16())),
"c": Series([1, 2, 3], dtype=pd.ArrowDtype(pa.int32())),
}
)
result = df.describe(
include=pd.ArrowDtype(pa.int8()), exclude=pd.ArrowDtype(pa.int32())
)
expected = DataFrame(
{"a": [3, 2, 1, 1, 1.5, 2, 2.5, 3]},
index=["count", "mean", "std", "min", "25%", "50%", "75%", "max"],
dtype=pd.ArrowDtype(pa.float64()),
)
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize("percentiles", [None, [], [0.2]])
def test_refine_percentiles(self, percentiles):
"""
Test that the percentiles are returned correctly depending on the `percentiles`
argument.
- The default behavior is to return the 25th, 50th, and 75 percentiles
- If `percentiles` is an empty list, no percentiles are returned
- If `percentiles` is a non-empty list, only those percentiles are returned
"""
# GH#60550
df = DataFrame({"a": np.arange(0, 10, 1)})
result = df.describe(percentiles=percentiles)
if percentiles is None:
percentiles = [0.25, 0.5, 0.75]
expected = DataFrame(
[
len(df.a),
df.a.mean(),
df.a.std(),
df.a.min(),
*[df.a.quantile(p) for p in percentiles],
df.a.max(),
],
index=pd.Index(
[
"count",
"mean",
"std",
"min",
*[f"{p:.0%}" for p in percentiles],
"max",
]
),
columns=["a"],
)
tm.assert_frame_equal(result, expected)
| TestDataFrameDescribe |
python | cherrypy__cherrypy | cherrypy/lib/locking.py | {
"start": 51,
"end": 239
} | class ____(object):
"""A representation of a never expiring object."""
def expired(self):
"""Communicate that the object hasn't expired."""
return False
| NeverExpires |
python | jazzband__django-oauth-toolkit | tests/test_client_credential.py | {
"start": 4064,
"end": 5912
} | class ____(BaseTest):
@classmethod
def setUpClass(cls):
cls.request_factory = RequestFactory()
super().setUpClass()
def test_extended_request(self):
token_request_data = {
"grant_type": "client_credentials",
}
auth_headers = get_basic_auth_header(self.application.client_id, CLEARTEXT_SECRET)
response = self.client.post(reverse("oauth2_provider:token"), data=token_request_data, **auth_headers)
self.assertEqual(response.status_code, 200)
content = json.loads(response.content.decode("utf-8"))
access_token = content["access_token"]
# use token to access the resource
auth_headers = {
"HTTP_AUTHORIZATION": "Bearer " + access_token,
}
request = self.request_factory.get("/fake-req", **auth_headers)
request.user = "fake"
test_view = ExampleView()
self.assertIsInstance(test_view.get_server(), BackendApplicationServer)
valid, r = test_view.verify_request(request)
self.assertTrue(valid)
self.assertIsNone(r.user)
self.assertEqual(r.client, self.application)
self.assertEqual(r.scopes, ["read", "write"])
def test_raises_error_with_invalid_hex_in_query_params(self):
request = self.request_factory.get("/fake-req?auth_token=%%7A")
with pytest.raises(SuspiciousOperation):
ExampleView().verify_request(request)
@patch("oauth2_provider.views.mixins.OAuthLibMixin.get_oauthlib_core")
def test_reraises_value_errors_as_is(self, patched_core):
patched_core.return_value.verify_request.side_effect = ValueError("Generic error")
request = self.request_factory.get("/fake-req")
with pytest.raises(ValueError):
ExampleView().verify_request(request)
| TestExtendedRequest |
python | django__django | django/core/paginator.py | {
"start": 552,
"end": 5160
} | class ____:
# Translators: String used to replace omitted page numbers in elided page
# range generated by paginators, e.g. [1, 2, '…', 5, 6, 7, '…', 9, 10].
ELLIPSIS = _("…")
default_error_messages = {
"invalid_page": _("That page number is not an integer"),
"min_page": _("That page number is less than 1"),
"no_results": _("That page contains no results"),
}
def __init__(
self,
object_list,
per_page,
orphans=0,
allow_empty_first_page=True,
error_messages=None,
):
self.object_list = object_list
self._check_object_list_is_ordered()
self.per_page = int(per_page)
self.orphans = int(orphans)
self.allow_empty_first_page = allow_empty_first_page
self.error_messages = (
self.default_error_messages
if error_messages is None
else self.default_error_messages | error_messages
)
if self.per_page <= self.orphans:
# RemovedInDjango70Warning: When the deprecation ends, replace
# with:
# raise ValueError(
# "The orphans argument cannot be larger than or equal to the "
# "per_page argument."
# )
msg = (
"Support for the orphans argument being larger than or equal to the "
"per_page argument is deprecated. This will raise a ValueError in "
"Django 7.0."
)
warnings.warn(msg, category=RemovedInDjango70Warning, stacklevel=2)
def _check_object_list_is_ordered(self):
"""
Warn if self.object_list is unordered (typically a QuerySet).
"""
ordered = getattr(self.object_list, "ordered", None)
if ordered is not None and not ordered:
obj_list_repr = (
"{} {}".format(
self.object_list.model, self.object_list.__class__.__name__
)
if hasattr(self.object_list, "model")
else "{!r}".format(self.object_list)
)
warnings.warn(
"Pagination may yield inconsistent results with an unordered "
"object_list: {}.".format(obj_list_repr),
UnorderedObjectListWarning,
stacklevel=3,
)
def _get_elided_page_range(
self, number, num_pages, page_range, on_each_side=3, on_ends=2
):
"""
Return a 1-based range of pages with some values elided.
If the page range is larger than a given size, the whole range is not
provided and a compact form is returned instead, e.g. for a paginator
with 50 pages, if page 43 were the current page, the output, with the
default arguments, would be:
1, 2, …, 40, 41, 42, 43, 44, 45, 46, …, 49, 50.
"""
if num_pages <= (on_each_side + on_ends) * 2:
for page in page_range:
yield page
return
if number > (1 + on_each_side + on_ends) + 1:
for page in range(1, on_ends + 1):
yield page
yield self.ELLIPSIS
for page in range(number - on_each_side, number + 1):
yield page
else:
for page in range(1, number + 1):
yield page
if number < (num_pages - on_each_side - on_ends) - 1:
for page in range(number + 1, number + on_each_side + 1):
yield page
yield self.ELLIPSIS
for page in range(num_pages - on_ends + 1, num_pages + 1):
yield page
else:
for page in range(number + 1, num_pages + 1):
yield page
def _get_page(self, *args, **kwargs):
"""
Return an instance of a single page.
This hook can be used by subclasses to use an alternative to the
standard :cls:`Page` object.
"""
return Page(*args, **kwargs)
def _validate_number(self, number, num_pages):
"""Validate the given 1-based page number."""
try:
if isinstance(number, float) and not number.is_integer():
raise ValueError
number = int(number)
except (TypeError, ValueError):
raise PageNotAnInteger(self.error_messages["invalid_page"])
if number < 1:
raise EmptyPage(self.error_messages["min_page"])
if number > num_pages:
raise EmptyPage(self.error_messages["no_results"])
return number
| BasePaginator |
python | django__django | tests/prefetch_related/tests.py | {
"start": 1065,
"end": 2139
} | class ____:
@classmethod
def setUpTestData(cls):
cls.book1 = Book.objects.create(title="Poems")
cls.book2 = Book.objects.create(title="Jane Eyre")
cls.book3 = Book.objects.create(title="Wuthering Heights")
cls.book4 = Book.objects.create(title="Sense and Sensibility")
cls.author1 = Author.objects.create(name="Charlotte", first_book=cls.book1)
cls.author2 = Author.objects.create(name="Anne", first_book=cls.book1)
cls.author3 = Author.objects.create(name="Emily", first_book=cls.book1)
cls.author4 = Author.objects.create(name="Jane", first_book=cls.book4)
cls.book1.authors.add(cls.author1, cls.author2, cls.author3)
cls.book2.authors.add(cls.author1)
cls.book3.authors.add(cls.author3)
cls.book4.authors.add(cls.author4)
cls.reader1 = Reader.objects.create(name="Amy")
cls.reader2 = Reader.objects.create(name="Belinda")
cls.reader1.books_read.add(cls.book1, cls.book4)
cls.reader2.books_read.add(cls.book2, cls.book4)
| TestDataMixin |
python | pytorch__pytorch | torch/export/_safeguard.py | {
"start": 158,
"end": 1956
} | class ____(TorchFunctionMode):
"""
Detect grad state ops during exporting the graph and fail the process by
raising an error, to avoid unexpected behavior. Those grad mode ops could be:
`torch.no_grad`
`torch.enable_grad`
`torch.set_grad_enabled`
Export with predispatch mode is exempted.
"""
def __torch_function__(self, func, types, args=(), kwargs=None):
kwargs = kwargs or {}
unsupported_grad_mode_ops = [
torch._C._set_grad_enabled,
]
# It's only enabled while tracing, by confirming the torch dispatch mode is
# any active PROXY. This is to allow the autograd ops out of tracing.
current_state = torch._C.is_grad_enabled()
if func in unsupported_grad_mode_ops:
assert len(args) == 1
changed_state = args[0]
mode = torch._C._get_dispatch_mode(torch._C._TorchDispatchModeKey.PROXY)
# Intend to check if it's not the pre_dispatch mode. It's allowed to use
# autograd ops in pre_dispatch mode, e.g. `torch.no_grad`
if (
mode
and isinstance(mode, ProxyTorchDispatchMode)
and not mode.pre_dispatch
and changed_state != current_state
):
raise RuntimeError(
f"Encountered autograd state manager op {func} trying to change global autograd state "
"while exporting. This is unsafe because we don't capture this op in torch.export "
"today, hence we can't reflect the user intention soundly. You can fix this by "
"adding a torch.no_grad() context around the export call."
)
return func(*args, **kwargs)
| AutogradStateOpsFailSafeguard |
python | kamyu104__LeetCode-Solutions | Python/cat-and-mouse-ii.py | {
"start": 3035,
"end": 6470
} | class ____(object):
def canMouseWin(self, grid, catJump, mouseJump):
"""
:type grid: List[str]
:type catJump: int
:type mouseJump: int
:rtype: bool
"""
directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
DRAW, MOUSE, CAT = range(3)
def parents(m, c, t):
if t == CAT:
for nm in graph[m, MOUSE^CAT^t]:
yield nm, c, MOUSE^CAT^t
else:
for nc in graph[c, MOUSE^CAT^t]:
yield m, nc, MOUSE^CAT^t
R, C = len(grid), len(grid[0])
N = R*C
WALLS = set()
FOOD, MOUSE_START, CAT_START = [-1]*3
for r in xrange(R):
for c in xrange(C):
if grid[r][c] == 'M':
MOUSE_START = r*C + c
elif grid[r][c] == 'C':
CAT_START = r*C + c
elif grid[r][c] == 'F':
FOOD = r*C + c
elif grid[r][c] == '#':
WALLS.add(r*C + c)
graph = collections.defaultdict(set)
jump = {MOUSE:mouseJump, CAT:catJump}
for r in xrange(R):
for c in xrange(C):
if grid[r][c] == '#':
continue
pos = r*C + c
for t in [MOUSE, CAT]:
for dr, dc in directions:
for d in xrange(jump[t]+1):
nr, nc = r+dr*d, c+dc*d
if not (0 <= nr < R and 0 <= nc < C and grid[nr][nc] != '#'):
break
graph[pos, t].add(nr*C + nc)
degree = {}
for m in xrange(N):
for c in xrange(N):
# degree[m, c, MOUSE] = len(graph[m, MOUSE])
degree[m, c, CAT] = len(graph[c, CAT])
color = collections.defaultdict(int)
q1 = collections.deque()
# q2 = collections.deque()
for i in xrange(N):
if i in WALLS or i == FOOD:
continue
color[FOOD, i, CAT] = MOUSE
q1.append((FOOD, i, CAT))
color[i, FOOD, MOUSE] = CAT
# q2.append((i, FOOD, MOUSE))
for t in [MOUSE, CAT]:
color[i, i, t] = CAT
# q2.append((i, i, t))
while q1:
i, j, t = q1.popleft()
for ni, nj, nt in parents(i, j, t):
if color[ni, nj, nt] != DRAW:
continue
if t == CAT:
color[ni, nj, nt] = MOUSE
q1.append((ni, nj, nt))
continue
degree[ni, nj, nt] -= 1
if not degree[ni, nj, nt]:
color[ni, nj, nt] = MOUSE
q1.append((ni, nj, nt))
# while q2:
# i, j, t = q2.popleft()
# for ni, nj, nt in parents(i, j, t):
# if color[ni, nj, nt] != DRAW:
# continue
# if t == MOUSE:
# color[ni, nj, nt] = CAT
# q2.append((ni, nj, nt))
# continue
# degree[ni, nj, nt] -= 1
# if not degree[ni, nj, nt]:
# color[ni, nj, nt] = CAT
# q2.append((ni, nj, nt))
return color[MOUSE_START, CAT_START, MOUSE] == MOUSE
| Solution2 |
python | astropy__astropy | astropy/io/ascii/fastbasic.py | {
"start": 12634,
"end": 16272
} | class ____(FastBasic):
"""
A faster version of the :class:`Rdb` reader. This format is similar to
tab-delimited, but it also contains a header line after the column
name line denoting the type of each column (N for numeric, S for string).
"""
_format_name = "fast_rdb"
_description = "Tab-separated with a type definition header line"
_fast = True
def __init__(self, **kwargs):
super().__init__({"delimiter": "\t", "data_start": 2}, **kwargs)
self.strip_whitespace_lines = False
self.strip_whitespace_fields = False
def _read_header(self):
tmp = self.engine.source
line1 = ""
line2 = ""
for line in tmp.splitlines():
# valid non-comment line
if not line1 and line.strip() and line.lstrip()[0] != self.comment:
line1 = line
elif not line2 and line.strip() and line.lstrip()[0] != self.comment:
line2 = line
break
else: # less than 2 lines in table
raise ValueError("RDB header requires 2 lines")
# Tokenize the two header lines separately.
# Each call to self.engine.read_header by default
# - calls _deduplicate_names to ensure unique header_names
# - sets self.names from self.header_names if not provided as kwarg
# - applies self.include_names/exclude_names to self.names.
# For parsing the types disable 1+3, but self.names needs to be set.
self.engine.setup_tokenizer([line2])
self.engine.header_start = 0
self.engine.read_header(deduplicate=False, filter_names=False)
types = self.engine.get_header_names()
# If no kwarg names have been passed, reset to have column names read from header line 1.
if types == self.engine.get_names():
self.engine.set_names([])
self.engine.setup_tokenizer([line1])
# Get full list of column names prior to applying include/exclude_names,
# which have to be applied to the unique name set after deduplicate.
self.engine.read_header(deduplicate=True, filter_names=False)
col_names = self.engine.get_names()
self.engine.read_header(deduplicate=False)
if len(col_names) != len(types):
raise core.InconsistentTableError(
"RDB header mismatch between number of column names and column types"
)
# If columns have been removed via include/exclude_names, extract matching types.
if len(self.engine.get_names()) != len(types):
types = [types[col_names.index(n)] for n in self.engine.get_names()]
if any(not re.match(r"\d*(N|S)$", x, re.IGNORECASE) for x in types):
raise core.InconsistentTableError(
f"RDB type definitions do not all match [num](N|S): {types}"
)
try_int = {}
try_float = {}
try_string = {}
for name, col_type in zip(self.engine.get_names(), types):
if col_type[-1].lower() == "s":
try_int[name] = 0
try_float[name] = 0
try_string[name] = 1
else:
try_int[name] = 1
try_float[name] = 1
try_string[name] = 0
self.engine.setup_tokenizer(tmp)
return (try_int, try_float, try_string)
def write(self, table, output):
"""
Override the default writing behavior in `FastBasic` to
output a line with column types after the column name line.
"""
self._write(table, output, {}, output_types=True)
| FastRdb |
python | sympy__sympy | sympy/integrals/transforms.py | {
"start": 39589,
"end": 41166
} | class ____(SineCosineTypeTransform):
"""
Class representing unevaluated sine transforms.
For usage of this class, see the :class:`IntegralTransform` docstring.
For how to compute sine transforms, see the :func:`sine_transform`
docstring.
"""
_name = 'Sine'
_kern = sin
def a(self):
return sqrt(2)/sqrt(pi)
def b(self):
return S.One
def sine_transform(f, x, k, **hints):
r"""
Compute the unitary, ordinary-frequency sine transform of `f`, defined
as
.. math:: F(k) = \sqrt{\frac{2}{\pi}} \int_{0}^\infty f(x) \sin(2\pi x k) \mathrm{d} x.
Explanation
===========
If the transform cannot be computed in closed form, this
function returns an unevaluated :class:`SineTransform` object.
For a description of possible hints, refer to the docstring of
:func:`sympy.integrals.transforms.IntegralTransform.doit`.
Note that for this transform, by default ``noconds=True``.
Examples
========
>>> from sympy import sine_transform, exp
>>> from sympy.abc import x, k, a
>>> sine_transform(x*exp(-a*x**2), x, k)
sqrt(2)*k*exp(-k**2/(4*a))/(4*a**(3/2))
>>> sine_transform(x**(-a), x, k)
2**(1/2 - a)*k**(a - 1)*gamma(1 - a/2)/gamma(a/2 + 1/2)
See Also
========
fourier_transform, inverse_fourier_transform
inverse_sine_transform
cosine_transform, inverse_cosine_transform
hankel_transform, inverse_hankel_transform
mellin_transform, laplace_transform
"""
return SineTransform(f, x, k).doit(**hints)
| SineTransform |
python | allegroai__clearml | clearml/backend_api/services/v2_20/tasks.py | {
"start": 85206,
"end": 87880
} | class ____(Request):
"""
Archive tasks.
If a task is queued it will first be dequeued and then archived.
:param tasks: List of task ids
:type tasks: Sequence[str]
:param status_reason: Reason for status change
:type status_reason: str
:param status_message: Extra information regarding status change
:type status_message: str
"""
_service = "tasks"
_action = "archive"
_version = "2.20"
_schema = {
"definitions": {},
"properties": {
"status_message": {
"description": "Extra information regarding status change",
"type": "string",
},
"status_reason": {
"description": "Reason for status change",
"type": "string",
},
"tasks": {
"description": "List of task ids",
"items": {"type": "string"},
"type": "array",
},
},
"required": ["tasks"],
"type": "object",
}
def __init__(
self, tasks: List[str], status_reason: Optional[str] = None, status_message: Optional[str] = None, **kwargs: Any
) -> None:
super(ArchiveRequest, self).__init__(**kwargs)
self.tasks = tasks
self.status_reason = status_reason
self.status_message = status_message
@schema_property("tasks")
def tasks(self) -> List[str]:
return self._property_tasks
@tasks.setter
def tasks(self, value: List[str]) -> None:
if value is None:
self._property_tasks = None
return
self.assert_isinstance(value, "tasks", (list, tuple))
self.assert_isinstance(value, "tasks", six.string_types, is_array=True)
self._property_tasks = value
@schema_property("status_reason")
def status_reason(self) -> Optional[str]:
return self._property_status_reason
@status_reason.setter
def status_reason(self, value: Optional[str]) -> None:
if value is None:
self._property_status_reason = None
return
self.assert_isinstance(value, "status_reason", six.string_types)
self._property_status_reason = value
@schema_property("status_message")
def status_message(self) -> Optional[str]:
return self._property_status_message
@status_message.setter
def status_message(self, value: Optional[str]) -> None:
if value is None:
self._property_status_message = None
return
self.assert_isinstance(value, "status_message", six.string_types)
self._property_status_message = value
| ArchiveRequest |
python | django__django | tests/string_lookup/models.py | {
"start": 31,
"end": 158
} | class ____(models.Model):
name = models.CharField(max_length=50)
friend = models.CharField(max_length=50, blank=True)
| Foo |
python | joke2k__faker | tests/providers/test_ssn.py | {
"start": 34820,
"end": 35061
} | class ____(unittest.TestCase):
def setUp(self):
self.fake = Faker("nl_NL")
Faker.seed(0)
def test_vat_id(self):
for _ in range(100):
assert re.search(r"^NL\d{9}B\d{2}$", self.fake.vat_id())
| TestNlNL |
python | walkccc__LeetCode | solutions/2008. Maximum Earnings From Taxi/2008-2.py | {
"start": 0,
"end": 505
} | class ____:
def maxTaxiEarnings(self, n: int, rides: list[list[int]]) -> int:
endToStartAndEarns = [[] for _ in range(n + 1)]
# dp[i] := the maximum dollars you can earn starting at i
dp = [0] * (n + 1)
for start, end, tip in rides:
earn = end - start + tip
endToStartAndEarns[end].append((start, earn))
for i in range(1, n + 1):
dp[i] = dp[i - 1]
for start, earn in endToStartAndEarns[i]:
dp[i] = max(dp[i], dp[start] + earn)
return dp[n]
| Solution |
python | falconry__falcon | falcon/util/deprecation.py | {
"start": 927,
"end": 1218
} | class ____(AttributeError):
"""A deprecated attribute, class, or function has been subsequently removed."""
# NOTE(kgriffs): We don't want our deprecations to be ignored by default,
# so create our own type.
#
# TODO(kgriffs): Revisit this decision if users complain.
| AttributeRemovedError |
python | google__pytype | pytype/overlays/typing_overlay.py | {
"start": 15130,
"end": 17462
} | class ____(abstract.PyTDFunction):
"""Implementation of typing.NewType as a function."""
def __init__(self, name, signatures, kind, decorators, ctx):
super().__init__(name, signatures, kind, decorators, ctx)
assert len(self.signatures) == 1, "NewType has more than one signature."
signature = self.signatures[0].signature
self._name_arg_name = signature.param_names[0]
self._type_arg_name = signature.param_names[1]
self._internal_name_counter = 0
@property
def internal_name_counter(self):
val = self._internal_name_counter
self._internal_name_counter += 1
return val
def call(self, node, func, args, alias_map=None):
args = args.simplify(node, self.ctx)
self.match_args(node, args, match_all_views=True)
# As long as the types match we do not really care about the actual
# class name. But, if we have a string literal value as the name arg,
# we will use it.
name_arg = args.namedargs.get(self._name_arg_name) or args.posargs[0]
try:
_ = abstract_utils.get_atomic_python_constant(name_arg, str)
except abstract_utils.ConversionError:
name_arg = self.ctx.convert.constant_to_var(
f"_NewType_Internal_Class_Name_{self.internal_name_counter}_"
)
type_arg = args.namedargs.get(self._type_arg_name) or args.posargs[1]
try:
type_value = abstract_utils.get_atomic_value(type_arg)
except abstract_utils.ConversionError:
# We need the type arg to be an atomic value. If not, we just
# silently return unsolvable.
return node, self.ctx.new_unsolvable(node)
if isinstance(type_value, abstract.AnnotationContainer):
type_value = type_value.base_cls
constructor = overlay_utils.make_method(
self.ctx, node, name="__init__", params=[Param("val", type_value)]
)
members = abstract.Dict(self.ctx)
members.set_str_item(node, "__init__", constructor)
props = class_mixin.ClassBuilderProperties(
name_var=name_arg,
bases=[type_arg],
class_dict_var=members.to_variable(node),
)
node, clsvar = self.ctx.make_class(node, props)
# At runtime, the 'class' created by NewType is simply an identity function,
# so it ignores abstract-ness.
for cls in clsvar.data:
cls.abstract_methods.clear()
return node, clsvar
| NewType |
python | doocs__leetcode | solution/0900-0999/0994.Rotting Oranges/Solution.py | {
"start": 0,
"end": 893
} | class ____:
def orangesRotting(self, grid: List[List[int]]) -> int:
m, n = len(grid), len(grid[0])
cnt = 0
q = deque()
for i, row in enumerate(grid):
for j, x in enumerate(row):
if x == 2:
q.append((i, j))
elif x == 1:
cnt += 1
ans = 0
dirs = (-1, 0, 1, 0, -1)
while q and cnt:
ans += 1
for _ in range(len(q)):
i, j = q.popleft()
for a, b in pairwise(dirs):
x, y = i + a, j + b
if 0 <= x < m and 0 <= y < n and grid[x][y] == 1:
grid[x][y] = 2
q.append((x, y))
cnt -= 1
if cnt == 0:
return ans
return -1 if cnt else 0
| Solution |
python | davidhalter__parso | parso/python/tree.py | {
"start": 8414,
"end": 8621
} | class ____(PythonLeaf):
"""
f-strings contain f-string expressions and normal python strings. These are
the string parts of f-strings.
"""
type = 'fstring_end'
__slots__ = ()
| FStringEnd |
python | pytorch__pytorch | torch/_inductor/runtime/caching/exceptions.py | {
"start": 957,
"end": 1581
} | class ____(SystemError):
"""Error raised when a lock operation times out.
This exception is raised when a lock operation exceeds the specified timeout
limit, indicating that the lock could not be acquired within the allotted time.
"""
def __init__(self, lock: Lock, timeout: float) -> None:
"""Initialize the lock timeout error with detailed lock information.
Args:
lock: The lock object that timed out.
timeout: The timeout limit that was exceeded.
"""
super().__init__(f"Failed to acquire lock {lock} within {timeout} seconds.")
| LockTimeoutError |
python | allegroai__clearml | clearml/backend_api/services/v2_9/queues.py | {
"start": 57854,
"end": 59154
} | class ____(Response):
"""
Response of queues.move_task_to_back endpoint.
:param position: The new position of the task entry in the queue (index, -1
represents bottom of queue)
:type position: int
"""
_service = "queues"
_action = "move_task_to_back"
_version = "2.9"
_schema = {
"definitions": {},
"properties": {
"position": {
"description": "The new position of the task entry in the queue (index, -1 represents bottom of queue)",
"type": ["integer", "null"],
}
},
"type": "object",
}
def __init__(self, position: Optional[int] = None, **kwargs: Any) -> None:
super(MoveTaskToBackResponse, self).__init__(**kwargs)
self.position = position
@schema_property("position")
def position(self) -> Optional[int]:
return self._property_position
@position.setter
def position(self, value: Optional[int]) -> None:
if value is None:
self._property_position = None
return
if isinstance(value, float) and value.is_integer():
value = int(value)
self.assert_isinstance(value, "position", six.integer_types)
self._property_position = value
| MoveTaskToBackResponse |
python | django__django | tests/decorators/test_common.py | {
"start": 196,
"end": 1311
} | class ____(SimpleTestCase):
def test_wrapped_sync_function_is_not_coroutine_function(self):
def sync_view(request):
return HttpResponse()
wrapped_view = no_append_slash(sync_view)
self.assertIs(iscoroutinefunction(wrapped_view), False)
def test_wrapped_async_function_is_coroutine_function(self):
async def async_view(request):
return HttpResponse()
wrapped_view = no_append_slash(async_view)
self.assertIs(iscoroutinefunction(wrapped_view), True)
def test_no_append_slash_decorator(self):
@no_append_slash
def sync_view(request):
return HttpResponse()
self.assertIs(sync_view.should_append_slash, False)
self.assertIsInstance(sync_view(HttpRequest()), HttpResponse)
async def test_no_append_slash_decorator_async_view(self):
@no_append_slash
async def async_view(request):
return HttpResponse()
self.assertIs(async_view.should_append_slash, False)
self.assertIsInstance(await async_view(HttpRequest()), HttpResponse)
| NoAppendSlashTests |
python | Unity-Technologies__ml-agents | ml-agents/mlagents/trainers/torch_entities/agent_action.py | {
"start": 293,
"end": 7189
} | class ____(NamedTuple):
"""
A NamedTuple containing the tensor for continuous actions and list of tensors for
discrete actions. Utility functions provide numpy <=> tensor conversions to be
sent as actions to the environment manager as well as used by the optimizers.
:param continuous_tensor: Torch tensor corresponding to continuous actions
:param discrete_list: List of Torch tensors each corresponding to discrete actions
"""
continuous_tensor: torch.Tensor
discrete_list: Optional[List[torch.Tensor]]
@property
def discrete_tensor(self) -> torch.Tensor:
"""
Returns the discrete action list as a stacked tensor
"""
if self.discrete_list is not None and len(self.discrete_list) > 0:
return torch.stack(self.discrete_list, dim=-1)
else:
return torch.empty(0)
def slice(self, start: int, end: int) -> "AgentAction":
"""
Returns an AgentAction with the continuous and discrete tensors slices
from index start to index end.
"""
_cont = None
_disc_list = []
if self.continuous_tensor is not None:
_cont = self.continuous_tensor[start:end]
if self.discrete_list is not None and len(self.discrete_list) > 0:
for _disc in self.discrete_list:
_disc_list.append(_disc[start:end])
return AgentAction(_cont, _disc_list)
def to_action_tuple(self, clip: bool = False) -> ActionTuple:
"""
Returns an ActionTuple
"""
action_tuple = ActionTuple()
if self.continuous_tensor is not None:
_continuous_tensor = self.continuous_tensor
if clip:
_continuous_tensor = torch.clamp(_continuous_tensor, -3, 3) / 3
continuous = ModelUtils.to_numpy(_continuous_tensor)
action_tuple.add_continuous(continuous)
if self.discrete_list is not None:
discrete = ModelUtils.to_numpy(self.discrete_tensor[:, 0, :])
action_tuple.add_discrete(discrete)
return action_tuple
@staticmethod
def from_buffer(buff: AgentBuffer) -> "AgentAction":
"""
A static method that accesses continuous and discrete action fields in an AgentBuffer
and constructs the corresponding AgentAction from the retrieved np arrays.
"""
continuous: torch.Tensor = None
discrete: List[torch.Tensor] = None # type: ignore
if BufferKey.CONTINUOUS_ACTION in buff:
continuous = ModelUtils.list_to_tensor(buff[BufferKey.CONTINUOUS_ACTION])
if BufferKey.DISCRETE_ACTION in buff:
discrete_tensor = ModelUtils.list_to_tensor(
buff[BufferKey.DISCRETE_ACTION], dtype=torch.long
)
discrete = [
discrete_tensor[..., i] for i in range(discrete_tensor.shape[-1])
]
return AgentAction(continuous, discrete)
@staticmethod
def _group_agent_action_from_buffer(
buff: AgentBuffer, cont_action_key: BufferKey, disc_action_key: BufferKey
) -> List["AgentAction"]:
"""
Extracts continuous and discrete groupmate actions, as specified by BufferKey, and
returns a List of AgentActions that correspond to the groupmate's actions. List will
be of length equal to the maximum number of groupmates in the buffer. Any spots where
there are less agents than maximum, the actions will be padded with 0's.
"""
continuous_tensors: List[torch.Tensor] = []
discrete_tensors: List[torch.Tensor] = []
if cont_action_key in buff:
padded_batch = buff[cont_action_key].padded_to_batch()
continuous_tensors = [
ModelUtils.list_to_tensor(arr) for arr in padded_batch
]
if disc_action_key in buff:
padded_batch = buff[disc_action_key].padded_to_batch(dtype=np.long)
discrete_tensors = [
ModelUtils.list_to_tensor(arr, dtype=torch.long) for arr in padded_batch
]
actions_list = []
for _cont, _disc in itertools.zip_longest(
continuous_tensors, discrete_tensors, fillvalue=None
):
if _disc is not None:
_disc = [_disc[..., i] for i in range(_disc.shape[-1])]
actions_list.append(AgentAction(_cont, _disc))
return actions_list
@staticmethod
def group_from_buffer(buff: AgentBuffer) -> List["AgentAction"]:
"""
A static method that accesses next group continuous and discrete action fields in an AgentBuffer
and constructs a padded List of AgentActions that represent the group agent actions.
The List is of length equal to max number of groupmate agents in the buffer, and the AgentBuffer iss
of the same length as the buffer. Empty spots (e.g. when agents die) are padded with 0.
:param buff: AgentBuffer of a batch or trajectory
:return: List of groupmate's AgentActions
"""
return AgentAction._group_agent_action_from_buffer(
buff, BufferKey.GROUP_CONTINUOUS_ACTION, BufferKey.GROUP_DISCRETE_ACTION
)
@staticmethod
def group_from_buffer_next(buff: AgentBuffer) -> List["AgentAction"]:
"""
A static method that accesses next group continuous and discrete action fields in an AgentBuffer
and constructs a padded List of AgentActions that represent the next group agent actions.
The List is of length equal to max number of groupmate agents in the buffer, and the AgentBuffer iss
of the same length as the buffer. Empty spots (e.g. when agents die) are padded with 0.
:param buff: AgentBuffer of a batch or trajectory
:return: List of groupmate's AgentActions
"""
return AgentAction._group_agent_action_from_buffer(
buff, BufferKey.GROUP_NEXT_CONT_ACTION, BufferKey.GROUP_NEXT_DISC_ACTION
)
def to_flat(self, discrete_branches: List[int]) -> torch.Tensor:
"""
Flatten this AgentAction into a single torch Tensor of dimension (batch, num_continuous + num_one_hot_discrete).
Discrete actions are converted into one-hot and concatenated with continuous actions.
:param discrete_branches: List of sizes for discrete actions.
:return: Tensor of flattened actions.
"""
# if there are any discrete actions, create one-hot
if self.discrete_list is not None and len(self.discrete_list) > 0:
discrete_oh = ModelUtils.actions_to_onehot(
self.discrete_tensor, discrete_branches
)
discrete_oh = torch.cat(discrete_oh, dim=1)
else:
discrete_oh = torch.empty(0)
return torch.cat([self.continuous_tensor, discrete_oh], dim=-1)
| AgentAction |
python | GoogleCloudPlatform__python-docs-samples | speech/microphone/transcribe_streaming_mic_test.py | {
"start": 834,
"end": 2683
} | class ____:
def __init__(self: object, audio_filename: str) -> None:
self.audio_filename = audio_filename
def __call__(self: object, *args: object) -> object:
return self
def open(
self: object,
stream_callback: object,
rate: int,
*args: object,
**kwargs: object
) -> object:
self.rate = rate
self.closed = threading.Event()
self.stream_thread = threading.Thread(
target=self.stream_audio,
args=(self.audio_filename, stream_callback, self.closed),
)
self.stream_thread.start()
return self
def close(self: object) -> None:
self.closed.set()
def stop_stream(self: object) -> None:
pass
def terminate(self: object) -> None:
pass
def stream_audio(
self: object,
audio_filename: str,
callback: object,
closed: object,
num_frames: int = 512,
) -> None:
with open(audio_filename, "rb") as audio_file:
while not closed.is_set():
# Approximate realtime by sleeping for the appropriate time for
# the requested number of frames
time.sleep(num_frames / float(self.rate))
# audio is 16-bit samples, whereas python byte is 8-bit
num_bytes = 2 * num_frames
chunk = audio_file.read(num_bytes) or b"\0" * num_bytes
callback(chunk, None, None, None)
@mock.patch.dict(
"sys.modules",
pyaudio=mock.MagicMock(PyAudio=MockPyAudio(os.path.join(RESOURCES, "quit.raw"))),
)
def test_main(capsys: pytest.CaptureFixture) -> None:
import transcribe_streaming_mic
transcribe_streaming_mic.main()
out, err = capsys.readouterr()
assert re.search(r"quit", out, re.DOTALL | re.I)
| MockPyAudio |
python | joke2k__faker | faker/providers/job/bs_BA/__init__.py | {
"start": 204,
"end": 175211
} | class ____(BaseProvider):
jobs = [
"Аdministrаtivni pоmоćnik u mеdicinskој оrdinаciјi",
"Administrativni službenik",
"Administrator",
"Administrator baza podataka",
"Administrator obrade podataka",
"Administrator područne računarske mreže",
"Advokat",
"Aerodromski transportni radnik",
"Agent za kulturne priredbe",
"Agent za literaturu",
"Agent za muzičke priredbe",
"Agent za pozorišne priredbe",
"Agent za propagandu",
"Agent za sport",
"Agroekonomista",
"Agronom kunićarstva",
"Agronom pčelarstva",
"Agronom peradarstva",
"Agronom ribarstva",
"Agronom savjetodavne službe",
"Agronom stočarstva",
"Agronom za hortikulturu",
"Agronom za melioracije",
"Agronom za proizvodnju duhana",
"Agronom za ratarstvo",
"Agronom za vinogradarstvo",
"Agronom za voćarstvo",
"Agronom za vrtlarstvo",
"Agronom za zaštitu bilja",
"Ahrimandit",
"Akademski grafički dizajner",
"Aktuar",
"Аkupunktоrоlоg",
"Akustički izolater",
"Akviziter",
"Alatničar",
"Alatničar za metalne kalupe,specijalizirani",
"Alatničar za mjerne pribore,specijalizirani",
"Alatničar za rezane alate,specijalizirani",
"Alatničar za stezne pribore,specijalizirani",
"Alatničar,majstor",
"Alatničarski poslovođa",
"Alpinistički vodič",
"Ambasador",
"Analitičar istraživanja tržišta",
"Аnаlitičаr pоlitika organizacije",
"Analitičar sistema",
"Analitičar sistema inženjersko-naučnih procesa",
"Analitičar sistema poslovnih procesa",
"Analitičar sistema sa računarske mreže",
"Analitičar studija rada i vremena",
"Analitičar zanimanja",
"Anatom",
"Andragog",
"Animator",
"Аnkеtаr u istrаživаnju tržištа",
"Аnkеtаr u istrаživаnju јаvnоg mnjеnjа",
"Antikvar",
"Antropolog",
"Aranžer",
"Aranžer muzike",
"Arheolog",
"Arhitekt dizajner",
"Arhitekt istraživač",
"Arhitekt konzervator",
"Arhitekt samostalni istraživač",
"Arhivar",
"Arhivist",
"Arhivski službenik",
"Arhivski službenik filmoteke",
"Armirač",
"Armirač i betonirac",
"Armirač i betonirac,majstor",
"Armirač, specijalizirani",
"Armirački radnik",
"Artist",
"Artist dreser",
"Asfalter",
"Asfalter,specijalizirani",
"Asistent folklornog koreografa",
"Asistent u osiguranju",
"Asistent visoke škole biotehničkih nauka",
"Asistent visoke škole društveno-humanističkih nauka",
"Asistent visoke škole medicinskih nauka",
"Asistent visoke škole prirodnih nauka",
"Asistent visoke škole tehničkih nauka",
"Asistent visoke škole u teologiji",
"Astrolog",
"Astronom",
"Astronomski tehničar",
"Ataše",
"Aukcionar",
"Autoelektričar",
"Autoelektričar, majstor",
"Autolakirer",
"Autolakirerski poslovođa",
"Autolimar",
"Autolimar,majstor",
"Automehaničar",
"Automehaničar, majstor",
"Aviolimar",
"Aviolimar,specijalizirani",
"Aviomehaničar",
"Babica",
"Bačvar",
"Bačvar,majstor",
"Bakroštamper",
"Bakteriolog",
"Bakteriološki tehničar",
"Balanser letilica",
"Baletni pedagog",
"Baletni plesač",
"Baletni solista",
"Balzamer",
"Bankovni službenik",
"Bankovni službenik na šalteru",
"Barmen",
"Batler",
"Berač ljekovitog bilja",
"Berač poljoprivrednih proizvoda",
"Berač šumskih plodova",
"Betonirac",
"Betonirac, specijalizirani",
"Bibliotečki istraživač",
"Bibliotekar",
"Bibliotekar specijalist",
"Bibliotekarski službenik",
"Bibliоtеčki tеhničаr",
"Biletar",
"Bioenergetičar",
"Biofizičar",
"Biograf",
"Biohemičar",
"Biohemijski tehničar",
"Biolog",
"Biološki tehničar",
"Biskup",
"Bižuterist",
"Blagajnik",
"Blagajnik na pošti",
"Blagajnik u banci",
"Blagajnik u trgovini",
"Blanjač metala",
"Bojadiser drvenih proizvoda",
"Bolničar",
"Botaničar",
"Botanički tehničar",
"Bravar",
"Bravar,majstor",
"Brigadir",
"Brigadni general",
"Brijač",
"Brodarski brokerski službenik",
"Brodobravar",
"Brodobravar,specijalizirani",
"Brodocjevar",
"Brodograđevinski inženjer",
"Brodograđevni tehničar",
"Brodolimar",
"Brodolimar,specijalizirani",
"Brodomonter",
"Brodomonter ,specijalizirani",
"Brodoskelar",
"Brodostolar",
"Brodostrojar",
"Brodostrojarski inženjer pomorskog prometa",
"Brodotraser",
"Brodotraser,specijalizirani",
"Brodovođa unutarnje plovidbe",
"Brodski elektromehaničar",
"Brodski elektromehaničar,specijalizirani",
"Brodski mazač",
"Brodski motorist",
"Brojač novca",
"Brusač i moler konstrukcija",
"Brusač kristalnog stakla",
"Brusač kristalnog stakla,specijalizirani",
"Brusač metala",
"Bula",
"Buregdžija",
"Bušač i dubinski bušač",
"Bušač na površinskom kopu",
"Bаkаlin",
"Carinik",
"Carinski inspektor",
"Carinski službenik",
"Cerader",
"Cestarski radnik",
"Citolog",
"Cjevar",
"Crkveni muzičar",
"Crkveni vratar",
"Crkvenjak",
"Crtač dezena na staklu,keramici i sl.",
"Crtač, netehnički",
"Cvjećar",
"Cvjećar - aranžer",
"Cvjećarski poslovođa",
"Časna sestra",
"Četkar",
"Čipkar",
"Čipkar ručni",
"Čistač fasade",
"Čistač obuće",
"Čistač stroja",
"Čistač ulica",
"Čistačica prostorija",
"Čistačica u domaćinstvu",
"Čistačica vozila",
"Čistаč tеpihа",
"Član /delegat - poslanik doma parlamenta / skupštine entiteta",
"Član nadzornog savjeta preduzeća",
"Član predsjedništva BiH",
"Član Predstavničkog doma Parlamentarne skupštine BiH",
"Član uprave preduzeća",
"Član Upravnog odbora Centralne banke BiH",
"Član upravnog odbora preduzeća",
"Čuvar",
"Čuvar cestovnog prelaza",
"Čuvar mosta",
"Čuvar ophodar",
"Čuvar plaže",
"Čuvar prtljaga",
"Čuvar pruge",
"Čuvar ribnjaka",
"Čuvar skretnica",
"Čuvar staja",
"Čuvar šume, lugar",
"Čuvar tunela",
"Čuvar usporene vožnje",
"Čuvar životinja (u ZOO-vrtu,štenarama, rezervatima)",
"Ćevabdžija",
"Ćilimar",
"Dadilja",
"Daktilograf",
"Daktilograf - administrativni tehničar",
"Defektolog",
"Defektolog logoped",
"Defektolog surdoaudiolog",
"Dekan",
"Dekorater",
"Dekorater emajlom",
"Dekorater keramike",
"Dekorater stakla",
"Dekorativni slikar",
"Delegat Doma naroda Parlamentarne skupštine BiH",
"Deminer",
"Demograf",
"Demonstrator za prodaju",
"Deratizer",
"Detektiv",
"Devizni inspektor",
"Dezinfektor",
"Dezinsektor",
"Dijagnostičar kvarova na vozilima, specijalizirani",
"Dijetni kuhar",
"Dimnjačar",
"Dimnjačarski poslovođa",
"Direktor Agencije za bankarstvo",
"Direktor Agencije za privatizaciju",
"Direktor arhiva",
"Direktor banke",
"Direktor biblioteke",
"Direktor bolnice",
"Direktor botaničkog vrta",
"Direktor dijela preduzeća za proizvodnju termoelektrične energije",
"Direktor direkcije",
"Direktor distribucije",
"Direktor doma penzionera",
"Direktor doma zdravlja",
"Direktor finansija i računovodstva",
"Direktor gerijatrijskog centra",
"Direktor hotelskoga poslovanja",
"Direktor inspektorata",
"Direktor internog glasila",
"Direktor izvanteritorijalne organizacije",
"Direktor kampa",
"Direktor kazneno - popravnog zavoda",
"Direktor kliničkog centra",
"Direktor klinike",
"Direktor komercijalne službe",
"Direktor konferencijskog centra",
"Direktor kontrole",
"Direktor male izvanteritorijalne organizacije",
"Direktor male kafane",
"Direktor male mjenjačnice",
"Direktor male modne agencije",
"Direktor male obrazovne ustanove",
"Direktor male trgovine na malo",
"Direktor male trgovine na veliko",
"Direktor male ustanove socijalnog rada",
"Direktor male ustanove za kulturu",
"Direktor male ustanove za sport i rekreaciju",
"Direktor male zdravstvene ustanove",
"Direktor malog disko-bara",
"Direktor malog građevinskog preduzeća",
"Direktor malog hotela",
"Direktor malog kampa",
"Direktor malog lovišta",
"Direktor malog lovno-uzgojnog preduzeća",
"Direktor malog noćnog bara",
"Direktor malog odmarališta",
"Direktor malog poljoprivrednog preduzeća",
"Direktor malog povrtlarskog preduzeća",
"Direktor malog preduzeća za poslovne usluge",
"Direktor malog preduzeća i ustanove na drugom mjestu nespomenut",
"Direktor malog preduzeća za dizajniranje",
"Direktor malog preduzeća za finansijske poslove",
"Direktor malog preduzeća za ispitivanje javnog mijenja",
"Direktor malog preduzeća za iznajmljivanje soba i kuća",
"Direktor malog preduzeća za lične usluge",
"Direktor malog preduzeća za poljoprivredne radove",
"Direktor malog preduzeća za posredovanje nekretninama",
"Direktor malog preduzeća za pranje i čišćenje",
"Direktor malog preduzeća za prevoz opasnih materija",
"Direktor malog preduzeća za računarske usluge",
"Direktor malog preduzeća za računovodstvene poslove",
"Direktor malog preduzeća za računovodstveno-finansijske poslove",
"Direktor malog preduzeća za tehničko ispitivanje i analize",
"Direktor malog preduzeća za usluge putničkih agencija",
"Direktor malog preduzeća za usluge turističkih agencija",
"Direktor malog prevoznog preduzeća",
"Direktor malog proizvodnog preduzeća",
"Direktor malog projektnog ureda",
"Direktor malog rasadnika",
"Direktor malog restorana",
"Direktor malog ribarskog preduzeća",
"Direktor malog skladišta",
"Direktor malog špediterskog preduzeća",
"Direktor malog šumarskog preduzeća",
"Direktor malog šumarskog rasadnika",
"Direktor malog telekomunikacionog preduzeća",
"Direktor malog veterinarskog društva",
"Direktor marketinga",
"Direktor međunarodnog putničkog saobaraćaja u preduzećima",
"Direktor međunarodnog teretnoga saobraćaja u preduzećima",
"Direktor muzeja",
"Direktor nabave",
"Direktor nacionalnog parka",
"Direktor naučno-istraživačkog instituta",
"Direktor odjela za računarske usluge",
"Direktor organizacije u oblasti kulture",
"Direktor osnovne škole",
"Direktor područne službe",
"Direktor područne službe za socijalni rad",
"Direktor policijske uprave",
"Direktor popravne ustanove",
"Direktor poslova uspostave informacionog sistema",
"Direktor poslovanja za područje hrane i pića u hotelima i restoranima",
"Direktor poslovanja izdavačkog preduzeća",
"Direktor poslovanja osiguravajućega društva",
"Direktor poslovanja pogrebnoga preduzeća",
"Direktor poslovanja preduzeća komunalne čistoće",
"Direktor poslovanja preduzeća lične usluge",
"Direktor poslovanja preduzeća za cjevovodni transport",
"Direktor poslovanja preduzeća za drumski saobraćaj",
"Direktor poslovanja preduzeća za filmsku i video djelatnost",
"Direktor poslovanja preduzeća za finansijsko posredovanje",
"Direktor poslovanja preduzeća za intelektualne usluge",
"Direktor poslovanja preduzeća za istraživanje i razvoj",
"Direktor poslovanja preduzeća za iznajmljivanje",
"Direktor poslovanja preduzeća za nespomenute poslovne usluge",
"Direktor poslovanja preduzeća za ostale usluge u saobraćaju",
"Direktor poslovanja preduzeća za poslovanje nekretninama",
"Direktor poslovanja preduzeća za posredničke poslove",
"Direktor poslovanja preduzeća za promet nekretninama",
"Direktor poslovanja preduzeća za smještaj gostiju",
"Direktor poslovanja preduzeća za uklanjanje otpadnih voda",
"Direktor poslovanja preduzeća za vazdušni saobraćaj",
"Direktor poslovanja privatnih agencija i fondova",
"Direktor poslovanja putničke i turističke agencije",
"Direktor poslovanja skladišta",
"Direktor poslovanja špediterskog preduzeća",
"Direktor poslovanja ugostiteljskoga preduzeća",
"Direktor poslovanja ustanove za kulturu",
"Direktor poslovanja veterinarske ustanove",
"Direktor poslovanja zdravstvene ustanove",
"Direktor poslovanja željezničkog saobraćaja",
"Direktor poslovne jedinice trgovine na malo",
"Direktor poslovne jedinice trgovine na veliko",
"Direktor poslovne jedinice za održavanje i popravku motornih vozila",
"Direktor poslovne jedinice za popravku proizvoda široke potrošnje",
"Direktor pošta",
"Direktor pravne, kadrovske i opće službe",
"Direktor predškolske ustanove",
"Direktor pretovarne operative",
"Direktor prihvata i otpreme na aerodromu",
"Direktor prijevoza opasnih materija u preduzeću",
"Direktor prijevoza u brodarskom preduzeću",
"Direktor prodaje",
"Direktor prodajne promocije",
"Direktor proizvodne i operativne jedinice građevinskog preduzeća",
"Direktor proizvodne i operativne jedinice preduzeća u prerađivačkoj djelatnosti",
"Direktor proizvodne i operativne jedinice preduzeća u proizvodnji termoelektrične energije",
"Direktor proizvodne i operativne jedinice preduzeća u rudarstvu",
"Direktor proizvodne i operativne jedinice preduzeća za snabdjevanje el. energijom, gasom i vodom ",
"Direktor proizvodnje i poslovanja lovno-uzgojnog preduzeća",
"Direktor proizvodnje i poslovanja šumarskog preduzeća",
"Direktor proizvodnje poljoprivrednog preduzeća",
"Direktor proizvodnje ribarskog preduzeća",
"Direktor putničke agencije",
"Direktor razvojno-istraživačke službe",
"Direktor rekreacionog centra",
"Direktor restoranskog poslovanja",
"Direktor revizije za poslovanje banaka i finansijskih organizacija",
"Direktor revizije za poslovanje poduzetnika",
"Direktor saobraćaja autobuske stanice",
"Direktor sektora banke",
"Direktor skladišne službe",
"Direktor službe drugdje nerazvrstan",
"Direktor službe obezbjeđenja",
"Direktor službe za odnose s javnošću",
"Direktor službe za oglašavanje",
"Direktor službe za pomoć porodicama",
"Direktor službe za računarske usluge",
"Direktor sportskog objekta",
"Direktor srednje škole",
"Direktor staračkog doma",
"Direktor telekomunikacija",
"Direktor tržnog centra",
"Direktor umjetničke galerije",
"Direktor unutrašnje finansijske kontrole",
"Direktor uprave",
"Direktor upravne organizacije",
"Direktor upravnog organa u sastavu ministarstva",
"Direktor ustanove socijalnog rada",
"Direktor ustanove za brigu o djeci",
"Direktor ustanove za pružanje pravne pomoći",
"Direktor ustanove za smještaj iz okvira socijalne zaštite",
"Direktor visoke škole",
"Direktor za ekološke poslove",
"Direktor za organizaciju rada",
"Direktor za socijalno osiguranje",
"Direktor zaštite okoline i sigurnosti na radu",
"Direktor Zavoda za računovodstvo i reviziju",
"Direktor Zavoda za reviziju",
"Direktor Zavoda/Agencija za zapošljavanje",
"Direktor zoološkog vrta",
"Dirigent hora",
"Dirigent orkestra",
"Disko džokej",
"Dispečer transportnog gasnog sistema, specijalizirani",
"Dizajner",
"Dizajner ambalaže",
"Dizajner interijera",
"Dizajner keramike",
"Dizajner kože",
"Dizajner obuće i kožne galanterije",
"Dizajner stakla",
"Dizajner tekstila i odjeće",
"Doktor dječije i preventivne stomatologije",
"Doktor farmacije",
"Doktor farmacije specijalizant",
"Doktor farmacije stažist",
"Doktor fizikalne medicine i rehabilitacije",
"Doktor javnog zdravstva",
"Doktor medicine",
"Doktor medicine anesteziolog i reanimatolog",
"Doktor medicine citolog",
"Doktor medicine dermatolog",
"Doktor medicine dermatolog i venerolog",
"Doktor medicine dječji hirurg",
"Doktor medicine epidemiolog",
"Doktor medicine ginekolog i opstetričar",
"Doktor medicine infektolog",
"Doktor medicine internista",
"Doktor medicine klinički farmakolog",
"Doktor medicine klinički farmakolog i toksikolog",
"Doktor medicine maksilofacijalni hirurg",
"Doktor medicine neurohirurg",
"Doktor medicine neurolog",
"Doktor medicine neuropsihijatar",
"Doktor medicine oftalmolog",
"Doktor medicine opšti hirurg",
"Doktor medicine ortoped",
"Doktor medicine otorinolaringolog",
"Doktor medicine patološki anatom",
"Doktor medicine pedijatar",
"Doktor medicine plastični i rekonstruktivni hirurg",
"Doktor medicine pneumoftizeolog",
"Doktor medicine psihijatar",
"Doktor medicine rada",
"Doktor medicine radiolog",
"Doktor medicine radioterapeut",
"Doktor medicine radioterapeut i onkolog",
"Doktor medicine rentgenolog",
"Doktor medicine specijalizant",
"Doktor medicine stažista",
"Doktor medicine transfuziolog",
"Doktor medicine urolog",
"Doktor medicine zdravstveni ekolog",
"Doktor medicine-specijalista higijene",
"Doktor medicinske mikrobiologije s parazitologijom",
"Doktor nuklearne medicine",
"Doktor opće medicine",
"Doktor porodične medicine",
"Doktor porodične stomatologije",
"Doktor socijalne medicine",
"Doktor stomatologije",
"Doktor stomatologije dentalni i oralni patolog i parodontolog",
"Doktor stomatologije dentalni patolog i endodont",
"Doktor stomatologije oralni hirurg",
"Doktor stomatologije oralni patolog",
"Doktor stomatologije ortodont",
"Doktor stomatologije parodontolog",
"Doktor stomatologije protetičar",
"Doktor stomatologije specijalizant",
"Doktor stomatologije stažist",
"Doktor sudske medicine",
"Doktor školske medicine",
"Dokumentalist",
"Domaćin kluba",
"Domar kampa",
"Domar planinarskog doma",
"Dostavljač",
"Draguljar",
"Dramaturg",
"Dreser pasa",
"Druga zanimanja - mehaničari i mašinisti",
"Drugi oficir palube",
"Drugi oficir stroja",
"Drvodjelja",
"Drvogalanterist",
"Drvomodelar",
"Drvorezbar",
"Drvorezbar,specijalizirani",
"Drvotokar",
"Drvotokar,majstor",
"Državni odvjetnik",
"Đakon",
"Edukator-rehabilitolog",
"Eko higijeničar",
"Ekolog",
"Ekološki tehničar",
"Ekološko-sanitarni inženjer",
"Ekonom",
"Ekonom uredski",
"Ekonometrik",
"Ekonomista",
"Ekonomista bankarstva",
"Ekonomista hoteljerstva",
"Ekonomista investicijski savjetnik",
"Ekonomista kontrolor poslovanja",
"Ekonomista kreditno-garantnih poslova",
"Ekonomista menadžmenta",
"Ekonomista osiguranja",
"Ekonomista platnog prometa",
"Ekonomista savjetnik",
"Ekonomista turizmolog",
"Ekonomista vanjsko - trgovinskog smjera",
"Ekonomista za analize i planiranje",
"Ekonomista za carinske poslove",
"Ekonomista za devizno poslovanje",
"Ekonomista za finansije",
"Ekonomista za marketing",
"Ekonomista za međunarodnu razmjenu",
"Ekonomista za politiku cijena",
"Ekonomista za poreski sistem",
"Ekonomista za poslovanje s vrijednosnim papirima",
"Ekonomista za turizam i ugostiteljstvo",
"Ekonomski službenik",
"Ekonomski tehničar",
"Električar održavanja",
"Električar pozornice i studija",
"Električar pozornice i studija,specijalizirani",
"Elektroenergetičar, majstor",
"Elektroenergetski inspektor",
"Elektroenergetski tehničar",
"Elektroinstalater",
"Elektroinstalater telekomunikacijskih vodova i instalacija",
"Elektroinstalater za priključke i instalacije",
"Elektroinstalater,specijalizirani",
"Elektroinženjer za automatiku",
"Elektroinženjer za automatizaciju u elektroenergetici",
"Elektroinženjer za automatizaciju u industriji",
"Elektroinženjer za automatizaciju u transportu",
"Elektroinženjer za automatsko upravljanje tehničkim sistemima",
"Elektroinženjer za elektrane",
"Elektroinženjer za električnu vuču",
"Elektroinženjer za mjerenja i instrumentaciju",
"Elektroinženjer za plovna sredstva",
"Elektroinženjer za procesna mjerenja",
"Elektroinženjer za vađenje pokretnih objekata",
"Elektrolizer aluminijuma",
"Elektromašinski tehničar",
"Elektromehaničar",
"Elektromehaničar aparata za domaćinstvo",
"Elektromehaničar aparata za domaćinstvo,majstor",
"Elektromehaničar proizvodnih mašina",
"Elektromehaničar proizvodnih mašina,specijalizirani",
"Elektromehaničar za elektroenergetiku",
"Elektromehaničar za elektroenergetiku,specijalizirani",
"Elektromehaničar za elektroenergetska postrojenja",
"Elektromehaničar za mjerne instrumente i sklopove",
"Elektromehaničar za mjerne instrumente i sklopove,specijalizirani",
"Elektromehaničar za željezničku elektroenergetiku,specijalizirani",
"Elektromehaničar za željezničku elektroenergitiku",
"Elektromehaničar željezničke vuče i vozila",
"Elektromehaničar željezničke vuče i vozila,specijalizirani",
"Elektromonter",
"Elektromonter dizala",
"Elektromonter energetskih mašina i uređaja",
"Elektromonter energetskih mašina i uređaja,specijalizirani",
"Elektromonter za visoki napon",
"Elektronamotač",
"Elektronamotač,specijalizirani",
"Elektroničar telekomunikacionih uređaja, majstor",
"Elektroničar za AOP",
"Elektroničar za telekomunikacije",
"Elektrorudarski inspektor",
"Elektrotehničar",
"Elektrotehničar proizvoda za domaćinstvo",
"Elektrotehničar šinskih vozila i postrojenja",
"Elektrotehničar za distribuciju električne energije",
"Elektrotehničar za dizala i transportna sredstva",
"Elektrotehničar za električne mašine, aparate i uređaje",
"Elektrotehničar za elektromotore",
"Elektrotehničar za instalacije i opremu",
"Elektrotehničar za mjerne instrumente i sklopove",
"Elektrotehničar za opremu proizvodnih mašina",
"Elektrotehničar za plovna sredstva",
"Elektrotehničar za prijenos električne energije",
"Elektrotehničar za procesnu tehniku",
"Elektrotehničar za proizvodnju električne energije",
"Elektrotehničar za slabu i jaku struju",
"Elektrotehničar za željeznicu",
"Elektrotiper",
"Elektrozavarivač",
"Elektrozavarivač, specijalizirani",
"Embriolog",
"Endokrinolog",
"Epidemiolog",
"Episkop",
"Esejist",
"Etnogeograf",
"Etnolog",
"Evangelista",
"Evidentičar normativa",
"Evidentičar radnih lista",
"Evidentičari u proizvodnji",
"Fakturista",
"Farmaceut",
"Farmaceut farmakoinformatičar",
"Farmaceut na ispitivanju i kontroli lijekova",
"Farmaceut u industriji",
"Farmaceut u veleprodaji",
"Farmaceut za ljekovito bilje",
"Farmaceutski laborant",
"Farmaceutski tehničar",
"Farmakolog",
"Farmakološki tehničar",
"Fasader",
"Fasader,majstor",
"Figurant",
"Filigranist",
"Filmski i elektronski montažer",
"Filmski laborant",
"Filolog",
"Filolog istraživač",
"Filolog samostalni istraživač",
"Filosanitarni inspektor",
"Filozof",
"Finansijski administrator",
"Finansijski analitičar",
"Finansijski inspektor",
"Finansijski knjigovođa",
"Finansijski savjetnik",
"Finomehaničar",
"Finomehaničar,majstor",
"Fitosanitarni inspektor",
"Fizičar",
"Fizičar istraživač",
"Fizičar samostalni istraživač",
"Fiziolog",
"Fizioterapeut",
"Fizioterapeutski tehničar",
"Fleksografski štampar",
"Folklorni igrač",
"Folklorni muzičar",
"Fonetičar",
"Fonotekar",
"Fotograf",
"Fotograf za komercijalne ilustracije",
"Fotograf,majstor",
"Fotografski tehničar",
"Fotogrametar",
"Fotograver",
"Fotolaborant",
"Fotomodel",
"Fotoreporter",
"Fratar",
"Frizer - Vlasuljar",
"Frizer - Vlasuljar, majstor",
"Frizer za muškarce",
"Frizer za muškarce, majstor",
"Frizer za žene",
"Frizer za muškarce i žene",
"Frizer za žene, majstor",
"Galerijski vodič",
"Galvanizer",
"Galvanizer,specijalizirani",
"Garderober",
"Gatara",
"Generalmajor",
"Generalni direktor",
"Generalni revizor Ureda za reviziju institucija u FBIH",
"Generalni sekretar Narodne skupštine",
"Generalni sekretar Vlade",
"Generalpukovnik",
"Genetičar",
"Geodet hidrograf",
"Geodet topograf",
"Geodeta fotogrametar",
"Geodeta kartograf",
"Geodeta projektant fotogrametrijskih radova",
"Geodeta projektant osnovnih geodetskih radova",
"Geodeta projektant u oblasti kartografije",
"Geodeta projektant za inženjersku geodeziju",
"Geodeta projektant za zemljišno informacione sisteme",
"Geodeta za inženjersku geodeziju",
"Geodeta za osnovne radove",
"Geodeta za rudnike",
"Geodeta za zemljišno informacione sisteme",
"Geodetski projektant",
"Geodetski tehničar",
"Geodetski tehničar geometar",
"Geodetski tehničar hidrografije",
"Geodetski tehničar restitutor",
"Geodetski tehničar za elaborate",
"Geodetski tehničar za evidenciju državnog vlasništva",
"Geodetski tehničar za evidenciju prostornih jedinica",
"Geodetski tehničar za fotogrametriju",
"Geodetski tehničar za katastar",
"Geodetski tehničar za katastar vodova",
"Geofizički tehničar",
"Geograf",
"Geolog istraživač",
"Geolog samostalni istraživač",
"Geolog za geomehaniku",
"Geolog za geotermiku",
"Geolog za hidrologiju",
"Geolog za inženjerisku geologiju",
"Geolog za istraživanje metalnih i nemetalnih sirovina",
"Geolog za obradu podataka",
"Geolog za paleontologiju",
"Geolog za petrografiju",
"Geolog za sedimentologiju",
"Geolog za stratigrafiju",
"Geolog za tektoniku",
"Geološki tehničar",
"Gipsar",
"Gipsmodelar",
"Gipsmodelar,specijalizirani",
"Glavni entitetski inspektor",
"Glavni imam",
"Glavni inspektor policije",
"Glavni inspektor u inspektoratu RS",
"Glavni konobar",
"Glavni kuhar",
"Glavni okružni tužilac",
"Glavni planer izgradnje",
"Glavni planer održavanja",
"Glavni planer pripreme rada",
"Glavni planer proizvodnje",
"Glavni republički tužilac",
"Glavni revizor RS",
"Glavni tužilac BiH",
"Glazer keramike",
"Glumac",
"Gorski spasilac",
"Graditelj drvenih brodova",
"Graditelj drvenih brodova,majstor",
"Graditelj lakih letjelica",
"Graditelj metalnih brodova",
"Graditelj metalnih brodova, majstor",
"Graditelji tradicionalnim materijalima",
"Gradonačelnik",
"Građevinar za održavanje pruga",
"Građevinar za održavanje puteva",
"Građevinar za održavanje zgrada",
"Građevinski dekorater",
"Građevinski inspektor",
"Građevinski inženjer",
"Građevinski inženjer za geotehniku",
"Građevinski laborant",
"Građevinski poslovođa",
"Građevinski staklar",
"Građevinski stolar",
"Građevinski stolar,majstor",
"Građevinski tehničar",
"Građevinski tehničar izrade štamparskih formata",
"Građevinski tehničar niskogradnje",
"Građevinski tehničar razrađivač projekta",
"Građevinski tehničar saobraćajni",
"Građevinski tehničar visokogradnje",
"Građevinski tehničar za hidrogradnju",
"Grafičar pripremne proizvodnje,specijalizirani",
"Grafičar slagač/monter",
"Grafičar štamparske proizvodnje,specijalizirani",
"Grafičar za doradu",
"Grafičar za fotoslog i računarski slog,specijalizirani",
"Grafičar završne proizvodnje,specijalizirani",
"Grafički dizajner",
"Grafički jetkač",
"Grafički predradnik",
"Grafički tehničar",
"Grafički urednik",
"Grafolog",
"Granični policajac",
"Graver pečatorezac",
"Graver plemenitih metala",
"Gravimetrijski i magnetometrijski tehničar",
"Grobar",
"Grupovođa elektromontera i elektromehaničara energetskih mašina",
"Grupovođa industrijskih talioca,livaca i valjaoničara",
"Grupovođa mehaničara i montera motornih vozila",
"Grupovođa montera električnih i telekomunikacijskih mreža",
"Grupovođa montera,mehaničara i servisera elektronike",
"Grupovođa montera,mehaničara i servisera mašina",
"Grupovođa montera,mehaničara i servisera telekomunikacijskih uređaja",
"Grupovođa preciznih mehaničara",
"Grupovođa rukovalaca alatnih mašina",
"Grupovođa rukovalaca mašinama za izradu drvenih proizvoda",
"Grupovođa rukovalaca procesnih mašina i uređaja za dobijanje metala",
"Grupovođa staklarskih,keramičkih i sličnih procesnih mašina i uređaja",
"Grupovođa stolara",
"Gumar",
"Guverner Centralne banke BiH",
"Gvardijan",
"Gаlеriјski tеhničаr",
"Hafiz",
"Hemičar",
"Hemičar analitičar",
"Hemičar istraživač",
"Hemičar operator",
"Hemičar samostalni istraživač",
"Hemičar u farmaciji",
"Hemičar za anorgansku hemiju",
"Hemičar za fizikalnu hemiju",
"Hemičar za organsku hemiju",
"Hemijski čistač",
"Hemijski čistač,majstor",
"Hemijski laborant",
"Hemijski predradnik",
"Hemijski tehničar",
"Hemijski tehničar analitičkih sistema",
"Hemijski tehničar anorganskih sistema",
"Hemijski tehničar elektrotehničkih materijala",
"Hemijski tehničar organskih sistema",
"Hemijski tehnolog za elektrotehničke materijale i sisteme",
"Hemijskotehnološki tehničar",
"Hidrobiolog",
"Hidroizolater",
"Hidrolog",
"Hidrološki tehničar",
"Hidrometeorolog",
"Higijeničarka",
"Hipnotizer",
"Histolog",
"Historičar",
"Historičar umjetnosti",
"Hodža",
"Horizontalni metalobušač",
"Horizontalni metalobušač,specijalizirani",
"Hortikulturni tehničar",
"Hostesa",
"Hotelska domaćica / domaćin",
"Hotelski nosač",
"Hotelski poslovođa",
"Hotelski recepcionar",
"Hroničar",
"Hоmеоpаtа",
"Iguman",
"Ilustrator",
"Imam",
"Imitator",
"Impregnator drveta",
"Impregnirač elektromehaničkih komponenti i sklopova",
"Imunolog",
"Industrijski kalilac",
"Industrijski livac",
"Industrijski obrađivač mlijeka,specijalizirani",
"Industrijski psiholog",
"Industrijski talilac",
"Industrijski talilac livar",
"Industrijski valjaoničar",
"Industrijski žarilac",
"Industrijski žičar",
"Informacijski istraživač",
"Informacijski stručnjak",
"Informatičar",
"Inkasant",
"Inspektor državne uprave bliže neodređen",
"Inspektor igara na stolovima za igru na sreću",
"Inspektor parnih kotlova",
"Inspektor za civilnu zaštitu",
"Inspektor za odbranu",
"Inspektor za požarnu sigurnost",
"Inspektor za promet",
"Inspektor za rad",
"Inspektor za sigurnost ličnih podataka",
"Inspektor za sigurnost na radu",
"Inspicijent opere",
"Instalater grijanja i klimatizacije",
"Instalater vodovoda i kanalizacije",
"Instruktor za jedrenje i plovidbu",
"Instruktor za letenje",
"Instruktor za zanimanje i stručno obrazovanje",
"Instruktori za upravljanje mašinama",
"Instrumentalist",
"Instrumentalist (violinist)",
"Instrumentalist solist",
"Instrumentalni optičar",
"Instrumentalni optičar,majstor",
"Instrumentalni solist (klavijaturist)",
"Intarzijski stolar",
"Intarzijski stolar,specijalizirani",
"Inženjer za karotažu i perforiranje naftnih bušotina",
"Inženjer aeronautike",
"Inženjer agronom",
"Inženjer arhitekture",
"Inženjer biotehnologije",
"Inženjer brodske elektronike",
"Inženjer drumskog saobraćaja",
"Inženjer drvne tehnologije",
"Inženjer elektroenergetike",
"Inženjer elektromašinskog održavanja",
"Inženjer elektromašinstva",
"Inženjer elektronike",
"Inženjer elektronike za normalizaciju i mjerenje",
"Inženjer elektrotehnike",
"Inženjer geodezije",
"Inženjer geofizike",
"Inženjer geologije",
"Inženjer grafičke tehnologije",
"Inženjer hemijske tehnologije",
"Inženjer hortikulture",
"Inženjer informacijskih tehnologija",
"Inženjer kontrole leta",
"Inženjer kožarstva",
"Inženjer medicinske elektronike",
"Inženjer medicinske radiologije",
"Inženjer medicinsko-laboratorijske dijagnostike",
"Inženjer metalnih materijala",
"Inženjer metalurgije",
"Inženjer nautike unutrašnje plovidbe",
"Inženjer nemetalnih materijala",
"Inženjer obućarstva",
"Inženjer pomorske nautike",
"Inženjer pomorskog saobraćaja",
"Inženjer poštanskog saobraćaja",
"Inženjer prehrambene tehnologije",
"Inženjer prerade drveta",
"Inženjer računarske elektronike",
"Inženjer računarstva",
"Inženjer radiokomunikacija",
"Inženjer rudarstva za bušotinsku eksploataciju mineralnih sirovina",
"Inženjer signalnosigurnosnih uređaja",
"Inženjer sigurnosti i pomoći",
"Inženjer sistema za opremu",
"Inženjer sistema za personalne računare",
"Inženjer sistema za programe",
"Inženjer smjenski u termoelektranama",
"Inženjer šumarstva",
"Inženjer tekstilne tehnologije",
"Inženjer telekomunikacija",
"Inženjer unutrašnje plovidbe",
"Inženjer vazduhoplovne elektronike",
"Inženjer za električne mašine i uređaje",
"Inženjer za elektroenergetska postrojenja",
"Inženjer za elektroničke komponente",
"Inženjer za elektroničke proizvode",
"Inženjer za elektrotehničke proizvode",
"Inženjer za geofizička mjerenja",
"Inženjer za geofizičko istraživanje ležišta",
"Inženjer za geološka istraživanja ležišta",
"Inženjer za izgradnju računarskih sistema",
"Inženjer za izradu i održavanje naftnih bušotina",
"Inženjer za laboratorijsko ispitivanje stjena",
"Inženjer za logistiku",
"Inženjer za normizaciju u elektroenergetici i elektromašinstvu",
"Inženjer za obradu geofizičkih podataka",
"Inženjer za obradu podataka",
"Inženjer za obradu tona i slike",
"Inženjer za optoelektroniku",
"Inženjer za organizaciju rada",
"Inženjer za proizvodnju nafte i gasa",
"Inženjer za računarsku grafiku",
"Inženjer za radiokomunikacijske uređaje",
"Inženjer za razradu ležišta nafte i gasa",
"Inženjer za razvoj tehnologije transporta gasa",
"Inženjer za telekomunikacijske uređaje i mreže",
"Inženjer za transport nafte i gasa",
"Inženjer za višemedijske komunikacije",
"Inženjer za zaštitu analize",
"Inženjer za zaštitu od električnog napona",
"Inženjer zaštite okoliša",
"Inženjer zračnog saobraćaja",
"Inženjer željezničkog saobraćaja",
"Ipođakon",
"Ispitivač kvaliteta industrijskih procesa",
"Ispitivač kvaliteta proizvoda",
"Ispitivač kvaliteta usluga",
"Istražitelj kriminalist",
"Istražitelj kriminolog",
"Istraživač antropolog",
"Istraživač arheolog",
"Istraživač arhivistike",
"Istraživač biologije",
"Istraživač biotehnologije",
"Istraživač brodograđevinarstva",
"Istraživač ekonomskih nauka",
"Istraživač elektronike, telekomunikacija i automatike",
"Istraživač etnolog",
"Istraživač filozofije",
"Istraživač geodezije",
"Istraživač geograf",
"Istraživač građevinarstva",
"Istraživač grafičke tehnologije",
"Istraživač hemijske tehnologije",
"Istraživač historije",
"Istraživač komunikolog",
"Istraživač mašinstva",
"Istraživač metalurgije",
"Istraživač meteorologije",
"Istraživač politologije",
"Istraživač pravnih nauka",
"Istraživač računarstva",
"Istraživač rudarstva",
"Istraživač saobraćaja",
"Istraživač sociolog",
"Istraživač tekstilne tehnologije",
"Istraživač u agronomiji",
"Istraživač u oblasti životne sredine",
"Istraživač u šumarstvu",
"Istraživač umjetnosti",
"Istraživač urbanizma",
"Istraživač vaspitnih nauka",
"Istraživač veterine",
"Istraživač za elektroenergetiku i elektromašinstvo",
"Istražni sudija",
"Iznajmljivač odjeće",
"Iznajmljivač opreme",
"Iznajmljivač soba",
"Izolater",
"Izradivac hemijskih proivoda",
"Izradivac kožne galanterije",
"Izrađivač alata za grafičku ambalažu",
"Izrađivač donjih dijelova obuće",
"Izrađivač drvene obuće",
"Izrađivač drvene sportske opreme",
"Izrađivač držala,štapova i sličnih predmeta",
"Izrađivač duvačkih muzičkih instrumenata",
"Izrađivač gornjih dijelova obuće",
"Izrađivač gornjih dijelova ortopedske obuće",
"Izrađivač gudačkih instrumenata",
"Izrađivač harmonika",
"Izrađivač hirurških instrumenata",
"Izrađivač hirurških instrumenata,specijalizirani",
"Izrađivač klavira",
"Izrađivač ključeva",
"Izrađivač kožnih proizvoda domaće radinosti",
"Izrađivač krzna",
"Izrađivač leća",
"Izrađivač ljekovitih proizvoda od meda,specijalizirani",
"Izrađivač muzičkih instrumenata",
"Izrađivač narodnih nošnji",
"Izrađivač okvira za slike",
"Izrađivač orgulja",
"Izrađivač ortopedskih pomagala",
"Izrađivač ortopedskih pomagala,majstor",
"Izrađivač ploče za Braillovo pismo",
"Izrađivač posebnih koža",
"Izrađivač posteljnih ulošaka",
"Izrađivač predmeta domaće radinosti iz kamena",
"Izrađivač predmeta od školjki",
"Izrađivač sredstava za poliranje i brušenje",
"Izrađivač svijeća",
"Izrađivač šablona za odjeću, specijalizirani",
"Izrađivač tambura",
"Izrađivač tapiserija",
"Izrađivač tekstilnih proizvoda domaće radinosti",
"Izrađivač tradicijskih predmeta",
"Izrađivač udaračkih mašinskih instrumenata",
"Izrađivač ukrasa i nakita",
"Izrezivač drvenih igračaka",
"Izvršni direktor",
"Izvršni sekretar u konzularnom uredu",
"Jamski spasilac",
"Javni notar",
"Jerej",
"Jeromonah",
"Jetkač stakla",
"Jezgrar ljevačkih kalupa",
"Jorgandžija",
"Juvelir",
"Kadrovski referent",
"Kalajdžija",
"Kalkulant",
"Kaluđer/kaluđerica",
"Kamenorezac",
"Kapetan",
"Kapetan aviona",
"Kaplar",
"Kardinal",
"Karikaturist",
"Kartograf",
"Kartografski crtač",
"Kaskader",
"Kazandžija",
"Kemigraf",
"Keramičar",
"Keramičar - teracer - podopolagač",
"Keramičar - teracer - podopolagač,majstor",
"Kineziolog",
"Kinooperater",
"Kipar",
"Kipar naivac",
"Kišobrandžija",
"Klesar",
"Klesar, majstor",
"Klesarski poslovođa",
"Klinaš",
"Klinički farmaceut",
"Klinički psiholog",
"Klovn",
"Ključar",
"Knjigoštampar",
"Knjigovezac",
"Knjigovezac mekog uveza",
"Knjigovezac tvrdog uveza",
"Knjigovezac za ručni uvez",
"Knjigovezac,majstor",
"Knjigovezački poslovođa",
"Knjigovodstveni operator na računaru",
"Knjigovođa",
"Knjigovođa zaliha",
"Književni komparatist",
"Književnik",
"Kobasičar",
"Kočijaš",
"Kočničar",
"Kolar",
"Kolar,majstor",
"Komandant bataljona/bojne",
"Komandir čete/satnije",
"Komandir odjeljenja/desetine",
"Komandir voda",
"Komentator",
"Komercijalist",
"Komercijalist unutrašnje trgovine",
"Komercijalist vanjske trgovine",
"Komercijalist za domaću trgovinu",
"Komercijalist za vanjsku trgovinu",
"Komercijalni službenik",
"Komesar policije",
"Komičar",
"Kompozitor",
"Komunalni redar",
"Komunikolog",
"Koncertni majstor",
"Konditor",
"Kondukter",
"Kondukter na žičari",
"Kondukter u autobusu",
"Kondukter u spavaćim kolima",
"Kondukter u vozu",
"Konfekcionar",
"Konfekcionar tekstila - krojač",
"Konferencijski tumač",
"Konobar",
"Konstruktor odjeće",
"Konter",
"Kontrolor mineralurških procesa i proizvoda",
"Kontrolor drvenih proizvoda",
"Kontrolor električnih proizvoda",
"Kontrolor gumenih proizvoda",
"Kontrolor igara na stolovima za igru na sreću",
"Kontrolor kamere",
"Kontrolor leta",
"Kontrolor metalnih proizvoda",
"Kontrolor metalurških procesa i proizvoda",
"Kontrolor mlijeka",
"Kontrolor pošte",
"Kontrolor preciznih instrumenata",
"Kontrolor pripreme i obrade podataka",
"Kontrolor proizvoda od drveta",
"Kontrolor robota",
"Kontrolor staklenih proizvoda",
"Kontrolor šivanih i sličnih proizvoda",
"Kontrolor štamparskih proizvoda",
"Kontrolor telefonskog saobraćaja",
"Kontrolor telegrafskog prometa",
"Kontrolor za kvalitet poslovanja",
"Kontrolor za slijetanje aviona",
"Konzervator umjetničkih djela",
"Konzervator za kulturno nasljeđe",
"Konzervator za prirodno nasljeđe",
"Konzul",
"Koordinator računarske mreže",
"Koordinator za pružanje njege starijim osobama u zajednici",
"Koordinator zračnog saobraćaja",
"Kopač rova",
"Korektor",
"Korektor u izdavaštvu",
"Koreograf",
"Korepetitor",
"Korespodent",
"Kormilar",
"Kormilar tegljača",
"Kormilar unutarnje plovidbe",
"Kostimograf",
"Kotlar",
"Kotlar,majstor",
"Kovač",
"Kovač,majstor",
"Kozmetičar",
"Kožar",
"Kožar bojadiser, specijalizirani",
"Kožni galanterist",
"Kreditni službenik",
"Kriminalist",
"Kriminalistički inspektor",
"Kriminalistički tehničar",
"Kriminalističko tehnički vještak",
"Kriminolog",
"Kritičar",
"Krojač",
"Krojač gornjih dijelova obuće",
"Krojač krzna i kože",
"Krojač lake odjeće",
"Krojač materijala za tapaciranje",
"Krojač muške odjeće,majstor",
"Krojač rublja, majstor",
"Krojač tekstila",
"Krojač teške odjeće",
"Krojač trikotažne odjeće",
"Krojač u scenografiji,specijalizirani",
"Krojač ženske odjeće,majstor",
"Krojač,majstor",
"Krovopokrivač",
"Krovopokrivač,majstor",
"Krovopokrivač,specijalizirani",
"Krupije",
"Krznar",
"Krznar, majstor",
"Kućna pomoćnica",
"Kuhar",
"Kuhar specijaliteta",
"Kuhar šibe",
"Kuhinjski pomoćnik",
"Kuhаr brzе hrаnе",
"Kujundžija",
"Kulinar",
"Kulinarski tehničar",
"Kulturolog",
"Kupališni radnik",
"Kurir",
"Kustos muzeja",
"Kustos umjetničke galerije",
"Kušaoc hrane",
"Kušaoc pića",
"Kаlupеr оptičkih sоčivа",
"Lađar",
"Lakej, dodavač",
"Lakirer proizvedene robe",
"Leksikograf",
"Lektor",
"Lektor stranog jezika",
"Lemitelj",
"Licitar",
"Likovni tehničar",
"Likovni tehničar primjenjenog slikarstva",
"Likovni tehničar primjenjenog vajarstva",
"Likovni tehničar tekstilnog dizajna",
"Likovni tehničar za oblikovanje u metalu",
"Likovni tehničar za opremu knjige",
"Likovni tehničar za reklamnu grafiku",
"Likvidator",
"Limar",
"Limar,majstor",
"Litografski crtač",
"Logoped i surdoaudiolog",
"Lončar",
"Lovac",
"Lovački vodič",
"Lovni inspektor",
"Lovni tehničar",
"Lovočuvar",
"Ložač centralnog grijanja",
"Ložač parne lokomotive",
"Ložač parnog kotla",
"Lučki radnik",
"Lugar",
"Lutkar",
"Ljevač keramičkih proizvoda",
"Ljevač metala",
"Ljevač metala,majstor",
"Ljevač olovnih slova",
"Ljevač plemenitih metala",
"Ljevač stereotipskih ploča",
"Ljevački drvomodelar",
"Ljevački drvomodelar,specijalizirani",
"Ljevački kalupar",
"Ljuštilac kore",
"Ljuštilac povrća i voća",
"Ljuštilac žita",
"Mađioničar",
"Magacioner",
"Magistar farmacije specijalizant",
"Magistar farmacije stažist",
"Major",
"Majstor drvene sportske opreme",
"Majstor rasvjete",
"Majstor stilskog namještaja",
"Majstor za zanimanje i stručno obrazovanje",
"Maketar",
"Maneken",
"Manevrist",
"Manikir",
"Manipulant tekućeg naftnog gasa",
"Manipulant u konfekcioniranju tekstila",
"Manipulant u preradi plastičnih masa",
"Maser",
"Masker",
"Maslar",
"Mašinist generatora i gasnih stanica",
"Mašinist motora SUS",
"Mašinista",
"Mašinobravar",
"Mašinobravar za termo i hidro postrojenja",
"Mašinobravar,majstor",
"Mašinovođa",
"Mašinovođa dizelvučnog vozila",
"Mašinovođa elektrovučnog vozila",
"Mašinovođa parne lokomotive",
"Mašinovođa za manevar dizelvučnog vozila",
"Mašinovođa za manevar elektrovučnog vozila",
"Mašinski inženjer",
"Mašinski inženjer za normizaciju",
"Mašinski konstruktor aparata za domaćinstvo",
"Mašinski konstruktor procesne opreme",
"Mašinski kovač",
"Mašinski ljevački kalupar",
"Mašinski pletač",
"Mašinski projektant konstruktor",
"Mašinski projektant male automatizacije",
"Mašinski projektant postrojenja",
"Mašinski projektant postrojenja procesne industrije",
"Mašinski projektant postrojenja za mikroklimu u postrojenjima",
"Mašinski projektant tehnologije montaže",
"Mašinski projektant tehnologije obrade plastičnih masa",
"Mašinski slovoslagač",
"Mašinski tehničar",
"Mašinski tehničar - energetičar",
"Mašinski tehničar održavanja brodske opreme",
"Mašinski tehničar održavanja cjevovodne mreže",
"Mašinski tehničar održavanja drumskih vozila",
"Mašinski tehničar održavanja energetskog postrojenja",
"Mašinski tehničar održavanja građevinskih mašina",
"Mašinski tehničar održavanja metalurške opreme",
"Mašinski tehničar održavanja opreme",
"Mašinski tehničar održavanja plinske mreže",
"Mašinski tehničar održavanja poljoprivredne mehanizacije",
"Mašinski tehničar održavanja procesne opreme",
"Mašinski tehničar održavanja proizvodne opreme",
"Mašinski tehničar održavanja šinskih vozila",
"Mašinski tehničar održavanja vazduhoplova",
"Mašinski tehničar vazduhoplovnog smjera",
"Mašinski tehničar za montažne postupke",
"Mašinski tehničar za kompjutersko konstruisanje",
"Mašinski tehničar za motore i motorna vozila",
"Mašinski tehničar za preciznu mehaniku i optiku",
"Mašinski tehničar za preradu plastičnih masa",
"Mašinski tehnolog za održavanje energetskih postrojenja",
"Mašinski tehnolog za održavanje metalurške opreme",
"Mašinski tehnolog za održavanje procesne opreme",
"Matematičar",
"Matematičar - informatičar",
"Matematičar aplikativni",
"Matematičar istraživač",
"Matičar",
"Maturant gimnazije",
"Maturant vazduhoplovne gimnazije",
"Medicinska sestra",
"Medicinska sestra babica",
"Medicinska sestra za intenzivnu zdravstvenu njegu",
"Medicinska sestra za oftalmološku zdravstvenu njegu",
"Medicinska sestra za patronažnu zdravstvenu njegu",
"Medicinska sestra za porodiljsko - ginekološku zdravstvenu njegu",
"Medicinska sestra za psihijatrijsku zdravstvenu njegu",
"Medicinska sestra-tehničar",
"Medicinski asistent",
"Medicinski fizičar",
"Medicinski laboratorijski tehničar",
"Medicinski patronažni asistenti",
"Medicinski terapeut",
"Mehanaičar uredskih mašina, majstor",
"Mehaničar alatnih mašina",
"Mehaničar alatnih mašina,majstor",
"Mehaničar audio i video tehnike",
"Mehaničar audio i video tehnike,majstor",
"Mehaničar bicikla",
"Mehaničar brodskih mašina",
"Mehaničar brodskih mašina,specijalizirani",
"Mehaničar elektroničar",
"Mehaničar elektroničar,specijalizirani",
"Mehaničar elektronike proizvodnih mašina",
"Mehaničar elektronike proizvodnih mašina,specijalizirani",
"Mehaničar elektronike uredski mašina",
"Mehaničar elektronike uredskih mašina,specijalizirani",
"Mehaničar elektronskih signalnih uređaja",
"Mehaničar elektronskih signalnih uređaja,majstor",
"Mehaničar energetske opreme",
"Mehaničar energetske opreme,specijalizirani",
"Mehaničar građevinski mašina",
"Mehaničar građevinski mašina,specijalizirani",
"Mehaničar grafičkih mašina",
"Mehaničar grafičkih mašina,specijalizirani",
"Mehaničar grejne i rashladne tehnike",
"Mehaničar industrijske opreme",
"Mehaničar industrijske opreme,specijalizirani",
"Mehaničar konfekcijskih mašina",
"Mehaničar konfekcijskih mašina,specijalizirani",
"Mehaničar mašina za kožarstvo i obućarstvo",
"Mehaničar mašina za kožarstvo i obućarstvo,specijalizirani",
"Mehaničar mašina za preradu nemetala",
"Mehaničar mašina za preradu nemetala,specijalizirani",
"Mehaničar medicinske elektronike",
"Mehaničar metalurške opreme",
"Mehaničar metalurške opreme,specijalizirani",
"Mehaničar motocikla",
"Mehaničar motocikla,majstor",
"Mehaničar opreme za grijanje",
"Mehaničar opreme za grijanje,specijalizirani",
"Mehaničar opreme za kompresore",
"Mehaničar opreme za kompresore, specijalizirani",
"Mehaničar pletaćih mašina",
"Mehaničar poljoprivredne mehanizacije",
"Mehaničar poljoprivredne mehanizacije,majstor",
"Mehaničar postrojenja za punjenje i pakovanje",
"Mehaničar postrojenja za punjenje i pakovanje, specijalizirani",
"Mehaničar pretovarne mehanizacije",
"Mehaničar pretovarne mehanizacije,specijalizirani",
"Mehaničar procesne opreme",
"Mehaničar procesne opreme,specijalizirani",
"Mehaničar proizvodnog postrojenja",
"Mehaničar proizvodnog postrojenja,specijalizirani",
"Mehaničar pružnih vozila unutrašnjeg transporta",
"Mehaničar pružnih vozila, specijalizirani",
"Mehaničar računarske elektronike",
"Mehaničar računarske elektronike,specijalizirani",
"Mehaničar rudarskih mašina",
"Mehaničar rudarskih mašina,specijalizirani",
"Mehaničar studijskih tonskih i videouređaja",
"Mehaničar studijskih tonskih i videouređaja,specijalizirani",
"Mehaničar šumske mehanizacije",
"Mehaničar šumske mehnizacije,specijalizirani",
"Mehaničar tekstilnih mašina",
"Mehaničar tekstilnih mašina,specijalizirani",
"Mehaničar telekomunikacijske opreme",
"Mehaničar telekomunikacijske opreme,specijalizirani",
"Mehaničar telekomunikacijskih uređaja",
"Mehaničar telekomunikacijskih uređaja,specijalizirani",
"Mehaničar uredskih mašina",
"Mehaničar uređaja za mjerenje i regulaciju",
"Mehaničar uređaja za mjerenje i regulaciju,majstor",
"Mehaničar vazduhoplova i motora",
"Mehaničar vazduhoplova i motora,specijalizirani",
"Mehaničar vazduhoplovne elektornike,specijalizirani",
"Mehaničar vazduhoplovne elektronike",
"Mehaničar vozila unutrašnjeg transporta",
"Mehaničar za baždarenje mjernih instrumenata",
"Mehaničar za baždarenje mjernih instrumenata,specijalizirani",
"Mehaničar za energetskoelektronske uređaje,specijalizirani",
"Mehaničar za hidrauliku,specijalizirani",
"Mehaničar za medicinsku i laboratorijsku opremu",
"Mehaničar za medicinsku i laboratorijsku opremu,majstor",
"Mehaničar za pumpe,specijalizirani",
"Mehaničar za rashladne i klimatizacijske uređaje",
"Mehaničar za rashladne i klimatizacijske uređaje,majstor",
"Mehaničar za vage",
"Mehaničar za vage,majstor",
"Mehaničar ze elektronske mjerne i upravljačke uređaje,specijalzirani",
"Mehatroničar operater",
"Mehatroničar procesnih tehnologija",
"Menadžer kvaliteta",
"Menadžer samostalnih stvaralaca",
"Menadžer sportista",
"Mesar",
"Mesar, majstor",
"Mesarski poslovođa",
"Metalobrusač",
"Metalobrusač,specijalizirani",
"Metaloglodač",
"Metaloglodač,specijalizirani",
"Metalomodelar",
"Metalomodelar,specijalizirani",
"Metalopojaser",
"Metalostrugar",
"Metalotokar",
"Metalotokar,majstor",
"Metalurg obojenih metala",
"Metalurg u proizvodnji",
"Metalurški tehničar za preradu i toplinsku obradu",
"Metalurški tehnolog prerade i toplinske obrade",
"Meteorolog",
"Meteorološki tehničar",
"Metlar",
"Mikrobiolog",
"Mikrobiološki tehničar - kontrolor namirnica",
"Mikrofotograf",
"Mikser slike",
"Mikser zvuka",
"Miner",
"Ministar u Vijeću ministara BiH",
"Ministar u Vladi entiteta",
"Ministar u vladi kantona",
"Mitropolit",
"Mjenjač novca",
"Mješalac pića",
"Mlinar",
"Mlinar sirovina za cement, kreč i gips",
"Mlinar žita",
"Mljekar",
"Mljekar,majstor",
"Mljekarski tehničar",
"Modelar i konstruktor kožne galanterije",
"Modelar i konstruktor obuće",
"Modelar kalupa i peta",
"Modelar odjeće",
"Moderator",
"Modist",
"Modular, elektrotip",
"Modular, stereotip",
"Molekularni botaničar",
"Moler",
"Moler - farbar",
"Moler - farbar, majstor",
"Monah/monahinja",
"Montažer slike i zvuka",
"Montažer u štamparstvu",
"Monter alatnih mašina",
"Monter alatnih mašina,specijalizirani",
"Monter audiovizuelne elektronike,specijalizirani",
"Monter bicikla",
"Monter brodske opreme",
"Monter brodske opreme,specijalizirani",
"Monter brodskih instalacija",
"Monter centralnog grijanja",
"Monter cjevovoda",
"Monter dizala",
"Monter dizala,specijalizirani",
"Monter električnih aparata za domaćinstvo",
"Monter električnih mašina i opreme",
"Monter električnih mjernih instrumenata i sklopova",
"Monter električnih mreža",
"Monter električnih mreža,specijalizirani",
"Monter elektronike instrumenata,specijalizirani",
"Monter elektronske opreme",
"Monter energetske opreme",
"Monter energetske opreme,specijalizirani",
"Monter građevinskih elemenata",
"Monter građevinskih skela",
"Monter industrijskih transportnih sredstava",
"Monter industrijskih transportnih sredstava,specijalizirani",
"Monter mašina",
"Monter mašina,specijalizrani",
"Monter medicinske elektronike,specijalizirani",
"Monter metalnih konstrukcija",
"Monter metalnih konstrukcija,specijalizirani",
"Monter mjernih instrumenata",
"Monter motornih vozila",
"Monter namještaja",
"Monter niskonaponskih instalacija",
"Monter opreme za grijanje i hlađenje",
"Monter opreme za grijanje i hlađenje,specijalizirani",
"Monter poljoprivrednih mašina",
"Monter poljoprivrednih mašina,specijalizirani",
"Monter procesne opreme",
"Monter procesne opreme,specijalizrani",
"Monter računarske elektronike,specijalizirani",
"Monter radio-televizijske elektronike,specijalizirani",
"Monter signalne elektronike,specijalizirani",
"Monter suhe gradnje",
"Monter tekstilnih mašina",
"Monter tekstilnih mašina,specijalizirani",
"Monter telekomunikacijske elektronike,specijalizirani",
"Monter telekomunikacijskih mreža",
"Monter telekomunikacijskih mreža,specijalizirani",
"Monter telekomunikacijskih uređaja",
"Monter telekomunikacijskih uređaja,specijalizirani",
"Monter televizijskih antena",
"Monter vazduhoplova",
"Monteri čeličnih užadi i žica",
"Mornar",
"Mornar marine",
"Mornar motorist",
"Mrijestilišni uzgajivač",
"Mrtvozornik",
"Mualim",
"Muftija",
"Mujezin",
"Muzejski službenik",
"Мuzејski tеhničаr",
"Muzejski vodič",
"Muzeolog",
"Muzičar",
"Muzičar - klavirist",
"Muzičar na ulici",
"Muzičar opceg smjera",
"Muzičar solista",
"Muzičar u noćnom klubu",
"Muzički redaktor",
"Muzički urednik",
"Muzikolog",
"Nabavni referent",
"Nabavno – prodajni referent",
"Načelnik policije",
"Nadbiskup",
"Nadzornik lovišta",
"Nadzornik novčanog tržišta",
"Nadzornik prirodnih parkova",
"Nadzornik tržišta kapitala",
"Nadzornik uzgajališta divljači",
"Naftni procesni tehnolog",
"Naftno rudarski tehničar",
"Naftno rudarski tehničar za bušotinske fluide",
"Naftno rudarski tehničar za hidrodinamička mjerenja",
"Naftno rudarski tehničar za karotažne radove",
"Naftno rudarski tehničar za opskrbu bušaće platforme",
"Naftno rudarski tehničar za posebne radove u bušotinama",
"Naftno rudarski tehničar za pripremne radove",
"Naftno rudarski tehničar za sanacijske radove u bušotinama",
"Naftno rudarski tehničar za usmjereno bušenje",
"Naftno-rudarski inženjer",
"Naftno-rudarski inženjer za razvoj tehnologije izrade i održavanja bušotina",
"Najavljivač programa",
"Nanositelj kita na drvo",
"Naočalni majstor optike",
"Naočalni optičar",
"Naočalni tehničar-optičar",
"Naplaćivač na parkingu",
"Naplaćivač pijačarine",
"Naplaćivač putarine",
"Nastavnik biologije",
"Nastavnik biologije i hemije",
"Nastavnik domaćinstva",
"Nastavnik ekonomike domaćinstva i hemije",
"Nastavnik engleskog jezika",
"Nastavnik fizičke i zdravstvene kulture",
"Nastavnik fizike",
"Nastavnik geografije",
"Nastavnik hemije",
"Nastavnik historije",
"Nastavnik informatike",
"Nastavnik islamske vjeronauke",
"Nastavnik likovne kulture",
"Nastavnik matematike",
"Nastavnik maternjeg jezika",
"Nastavnik muzičke kulture",
"Nastavnik muzičke teorijsko - pedagoškog smjera",
"Nastavnik praktične nastave",
"Nastavnik predškolskog vaspitanja",
"Nastavnik razredne nastave",
"Nastavnik ruskog jezika",
"Nastavnik stranog jezika",
"Nastavnik tehničke kulture",
"Nastavnik tehničkog obrazovanja i hemije",
"Nastavnik tehničkog obrazovanja i informatike",
"Nastavnik vjeronauke",
"Nautičar unutrašnje plovidbe",
"Navigator leta",
"Neposredni izvršilac društvene samozaštite",
"Nijanser premaznih sredstava",
"Noćni stražar",
"Nomodski stočar",
"Nosač",
"Notar - Javni bilježnik",
"Notni arhivar",
"Novinar",
"Novinski fotograf",
"Nuklearni fizičar",
"Numerolog",
"Nutricionista",
"Nаdzоrnik u transportu",
"Nаdzоrnik visоkоgrаdnjе",
"Njegovatelj bolesnika u kući",
"Njegovatelj djece",
"Njegovatelj lica s razvojnim teškoćama",
"Njegovatelj starijih i nemoćnih lica",
"Njegovatelji životinja",
"Oblikovalac metala",
"Obrađivač drveta,specijalizirani",
"Obrađivač kamenih blokova",
"Obrađivač konstrukcijskog željeza",
"Obrađivač lima",
"Obrađivač materijala u kartonaži",
"Obrađivač materijala u knjigoveznici",
"Obrađivač materijala u preradi papira",
"Obrađivač metala odvajanjem čestica",
"Obrađivač metala toplinskim postupkom",
"Obućar",
"Obućar,majstor",
"Obućarski radnik",
"Ocjenjivač duvana",
"Ocjenjivač hrane",
"Ocjenjivač pića",
"Ocrtavač limova",
"Ocrtavač limova,specijalizirani",
"Ocrtavač odljevaka",
"Ocrtavač odljevaka,specijalizirani",
"Očitač brojila gasa / vode / struje",
"Odbornik skupštine grada",
"Odbornik skupštine opštine",
"Odgajitelj",
"Odgojitelj u zavodu za djecu sa posebnim potrebama",
"Odjavničar",
"Oficir",
"Oficir artiljerije",
"Oficir informatike",
"Oficir inženjerstva",
"Oficir kontrole vazdušnog prostora",
"Oficir lučke kapetanije",
"Oficir oklopnih jedinica",
"Oficir palube na platformi",
"Oficir palube unutrašnje plovidbe",
"Oficir pomorstva",
"Oficir protivzračne odbrane",
"Oficir stabilnosti platforme",
"Oficir stroja unutrašnje plovidbe",
"Oficir veze",
"Oficir za administrativne poslove",
"Oficir za bezbjednosne i kontraobavještajne poslove",
"Oficir za finansijske poslove",
"Oficir za logostiku",
"Oficir za obavještajne poslove",
"Oficir za održavanje materijalnotehničkih sredstava",
"Oficir za opće i kadrovske poslove",
"Oficir za pokret i transport",
"Oficir za sanitet",
"Oficir za zdravstvenu zaštitu",
"Oficir zaštite na radu",
"Oficir zrakoplovstva",
"Ofset mašinist",
"Ofset štamper",
"Oftalmološki optičar",
"Oglašivač",
"Okružni tužilac",
"Oligofrenopedagog",
"Ombudsmen",
"Opančar",
"Općinski načelnik",
"Operacijski istraživač",
"Оpеrаtеr pоstrојеnjа zа prеrаdu vоdе",
"Operator dojavnog sistema",
"Operator na audiometrijskoj opremi",
"Operator na elektroencefalografskoj opremi",
"Operator na elektrokardiografskoj opremi",
"Operator na medicinskoj opremi",
"Operator na medicinskoj skenirajućoj opremi",
"Operator na opremi medicinske radiografije",
"Operator na opremi medicinske radiologije",
"Operator na opremi u očnoj dijagnostici",
"Operator na opremi za dijalizu",
"Operator na optoelektronskim uređajima i sistemima",
"Operator na provođenju mjera gazdovanja šumom",
"Operator na radioodašiljaču",
"Operator na scenskoj rasvjeti",
"Operator na telekomunikacijskoj opremi",
"Operator na televizijskom odašiljaču",
"Operator na vanjskoj računarskoj opremi",
"Operator opreme za zračnu kontrolu",
"Operator optičkog čitača",
"Operator računara za tekst",
"Operator radioprijenosa",
"Operator sistema na računarskom sistemu",
"Operator telegrafskih uređaja",
"Operator televizijskog prijenosa",
"Operator za pripremu obrade podataka",
"Operator za unos podataka",
"Oplemenjivač tekstila",
"Optičar",
"Optometričar",
"Optometrist",
"Opunomoćeni ministar ambasade",
"Оrganizаtоr kоnfеrеnciја/skupоvа",
"Organizator kongresne djelatnosti",
"Organizator kulturno-zabavne djelatnosti",
"Organizator lova",
"Organizator muzičke i muzičkoscenske produkcije",
"Organizator obrade podataka",
"Organizator obrazovanja odraslih u obrazovnim zavodima",
"Organizator obrazovanja zaposlenih u preduzeću",
"Organizator posla",
"Organizator poslovnih priredbi",
"Organizator praktične nastave",
"Organizator prodaje",
"Organizator putovanja",
"Organizator rada",
"Organizator sajamske djelatnosti",
"Organizator sportsko-rekreacijske djelatnosti",
"Organizator televizijske i filmske produkcije",
"Organizator zdravstvene njege",
"Organizator zdravstvenog odgoja",
"Ornitolog",
"Ortopedski obućar",
"Ortopedski obućar,majstor",
"Osmatrač šumskih požara",
"Osoba zadužena za kontrolu vode",
"Oštrač alata",
"Oštrač alata,specijalizirani",
"Oštrač noževa",
"Otpravnik poslova u ambasadi",
"Otpravnik u drumskom saobraćaju",
"Ovlašteni posrednik vrijednosnim papirima",
"Ovlašteni revizor",
"Ovlaživač drveta",
"Palitelj mina površinskog kopa",
"Palitelj mina u jami",
"Parazitolog",
"Paritelj drveta",
"Parketar",
"Parkirališni radnik",
"Paroh",
"Pastir",
"Pastor",
"Patofiziolog",
"Patolog",
"Patološki tehničar",
"Patrijarh",
"Pazikuća",
"Pčelar",
"Pčelarski radnik",
"Pečenjar",
"Pećar",
"Pećar, specijalizirani",
"Pedagog",
"Pedagog-psiholog",
"Pedijatrijska sestra - tehničar",
"Pediker",
"Peglač",
"Pekar",
"Pekar bureka i pizze",
"Pekar,majstor",
"Pekarski poslovođa",
"Peljar",
"Perač ",
"Perač fabričkih prostorija",
"Perač prozora",
"Perač ulica",
"Peradar",
"Peradarski poslovođa",
"Peradarski radnik",
"Peradarski tehničar",
"Petrohemijski laborant",
"Petrohemijski tehničar",
"Petrohemijski tehničar analitičar",
"Petrohemijski tehnolog",
"Pilar drva za ogrijev",
"Pilot aviona",
"Pilot helikoptera",
"Pirotehničar",
"Pisac reklamnih poruka",
"Pisar",
"Pismoslikar",
"Pismoslikar,majstor",
"Pismoslikarski poslovođa",
"Pivar",
"Pjeskar zgrada i konstrukcija",
"Pjevač hora",
"Pjevač na ulici",
"Pjevač u noćnom klubu",
"Plakatar",
"Planer visokogradnje",
"Planinarski vodič",
"Plesač",
"Plesač na ulici",
"Plesač slobodnog plesa",
"Plesač u noćnom klubu",
"Pletač",
"Pletač korpi",
"Pletač likom",
"Pletač metalne užadi",
"Pletač namještaja",
"Pletač rogozom i trskom",
"Pletač slamom",
"Pletač uzoraka za korpe",
"Pletač,majstor",
"Plinoinstalater",
"Podešavač drvoobrađivački mašina,specijalizirani",
"Podešavač drvoobrađivačkih mašina",
"Podešavač metaloobrađivačkih numeričkih upravljanih mašina,specijalizirani",
"Podešavač metaloobrađivačkog automatskog postrojenja,specijalizirani",
"Podešavač muzičkih instrumenata",
"Podešavač poluautomatskih i automatskih alatnih mašina,specijalizirani",
"Podešavač sastavljenih reznih alata,specijalizirani",
"Podešavač specijalnih alatnih mašina,specijalizirani",
"Podgrađivač okna,specijalizirani",
"Podmazivač mašina",
"Podmazivač vozila",
"Podoficir",
"Podoficir artiljerije",
"Podoficir informatike",
"Podoficir inženjerstva",
"Podoficir kontrole vazdušnog prostora",
"Podoficir oklopnih jedinica",
"Podoficir pomorstva",
"Podoficir protivzračne odbrane",
"Podoficir veze",
"Podoficir za administrativne poslove",
"Podoficir za bezbjednosne i kontraobavještajne poslove",
"Podoficir za finansijske poslove",
"Podoficir za kadrovske poslove",
"Podoficir za logistiku",
"Podoficir za obavještajne poslove",
"Podoficir za održavanje materijalnotehničkih sredstava",
"Podoficir za pokret i transport",
"Podoficir za sanitet",
"Podoficir za zdravstvenu zaštitu",
"Podoficir zaštite na radu",
"Podoficir zrakoplovstva",
"Podopolagač",
"Podopolagač,specijalizirani",
"Podrumar",
"Podrumar,vinogradar",
"Podrumarski radnik",
"Podvodni monter",
"Pođakon",
"Pogonski električar",
"Pogrebnik",
"Polagač čeličnih užadi žica",
"Polagač keramičkih pločica",
"Polagač zidnih tapeta",
"Policajac",
"Policajac- pozornik",
"Policajac specijalac",
"Policajac za posebne zadatke",
"Policijski detektiv",
"Policijski inspektor",
"Policijski službenik",
"Polirac metala",
"Politolog",
"Poljoprivredni inspektor",
"Poljoprivredni radnik",
"Poljoprivredni tehničar",
"Poljoprivredni tehničar savjetodavac, asistent",
"Poljoprivredni tehničar za melioraciju",
"Poljoprivredni traktorist",
"Pomočni skladištar",
"Pomoćni analitičar u stručnim obrazovnim školama",
"Pomoćni analitičar u stručnom osposobljavanju u službama",
"Pomoćni automehaničar",
"Pomoćni bravar",
"Pomoćni električar",
"Pomoćni frizer (muški i ženski)",
"Pomoćni gumari i plastičari",
"Pomoćni instalater vodovoda i kanalizacije",
"Pomoćni istraživač u biologiji",
"Pomoćni istraživač u fizici",
"Pomoćni istraživač u geografiji",
"Pomoćni istraživač u hemiji",
"Pomoćni izolater",
"Pomoćni jamski kopač i rudar",
"Pomoćni kalupar",
"Pomoćni keramičar",
"Pomoćni konobar",
"Pomoćni kontrolor leta",
"Pomoćni krojač podstave obuće",
"Pomoćni krojač tekstila",
"Pomoćni kuhar",
"Pomoćni metalobušač",
"Pomoćni moler",
"Pomoćni monter mašina",
"Pomoćni proizvođač celuloze",
"Pomoćni radnik u arhivi",
"Pomoćni rukovalac rudarskim postrojenjem",
"Pomoćni rukovalac sjekaćicom kamena",
"Pomoćni rukovalac šivaćim mašinama za tapetariju",
"Pomoćni trgovac",
"Pomoćni ugostiteljski radnik",
"Pomoćni uzgajivač životinja",
"Pomoćni vatrogasac",
"Pomoćni zdravstveni radnik",
"Pomoćnik pravobranioca",
"Pomoćnik direktora republičke uprave",
"Pomoćnik direktora republičke upravne organizacije",
"Pomoćnik direktora upravne organizacije i uprave",
"Pomoćnik generalnog sekretara Vlade",
"Pomoćnik konfekcijskog tekstila",
"Pomoćnik mesara",
"Pomoćnik ministra",
"Pomoćnik ministra u Vladi entiteta",
"Pomoćnik ministra u Vladi kantona",
"Pomoćnik u podzemsnoj eksploataciji",
"Pomorski nautičar",
"Pomorski radiotelegrafist",
"Pop",
"Poreski inspektor",
"Poreski kontrolor",
"Poreski savjetnik",
"Poreski službenik",
"Poreznik",
"Portir",
"Poručnik",
"Poslanik kantonalne skupštine",
"Poslanik općinskog vijeća/ skupštine",
"Poslovni sekretar",
"Poslovođa armiračnice",
"Poslovođa asfaltirnice",
"Poslovođa betonare",
"Poslovođa bušotinskih servisa",
"Poslovođa dopreme i pripreme uglja u TE",
"Poslovođa gradnje saobraćajnica",
"Poslovođa građevinskoinstalaterskih radova",
"Poslovođa građevinskozanatskih radova",
"Poslovođa hidrotehničkih radova",
"Poslovođa mehaničara i montera motornih vozila",
"Poslovođa miniranja",
"Poslovođa naftno-gasnog polja",
"Poslovođa pripreme karotažnih radova",
"Poslovođa pripreme, izrade i održavanja bušotina",
"Poslovođa proizvodnje soli",
"Poslovođa pružnih radova",
"Poslovođa radova niskogradnje",
"Poslovođa radova visokogradnje",
"Poslovođa servisa za sanacijske radove u bušotina",
"Poslovođa soboslikara i molera",
"Poslovođa stanice za tehnički pregled vozila",
"Poslovođa transporta gasa",
"Poslovođa u ribogojstvu",
"Poslovođa u šumarstvu",
"Poslovođa uzgajivača ostalih životinja",
"Poslovođa uzgoja riba i školjaka",
"Poslovođa za parkove i nasade",
"Poslovođa završnih radova",
"Poslovođa žičare",
"Poslužitelj",
"Poslužitelj alatnih mašina",
"Poslužitelj jela i pića",
"Poslužitelj lifta",
"Poslužitelj linije u preradi duhana",
"Poslužitelj linije u proizvodnji pića",
"Poslužitelj linije za preradu voća i povrća",
"Poslužitelj mašina u preradi mesa i ribe",
"Poslužitelj mašina za pekarske proizvode i slatkiše",
"Poslužitelj mašina za sastavljanje četaka",
"Poslužitelj mašine za gradiranje obućarskih šablona",
"Poslužitelj mašine za isijecanje i rezanje kožne galanterije",
"Poslužitelj mašine za mljevenje prehrambenih proizvoda",
"Poslužitelj mašine za proizvodnju sijalica",
"Poslužitelj mašine za proizvodnju šećera",
"Poslužitelj mašine za ukrašavanje obuće",
"Poslužitelj na žičari",
"Poslužitelj postrojenja za izradu parketa",
"Poslužitelj specijalne alatne mašine",
"Poslužitelj u golfu",
"Poslužitelj u kasinu",
"Poslužitelj u saunama,bazenima i kupatilima",
"Poslužitelj uređaja u preradi mlijeka",
"Poslužitelj zabavnog parka",
"Posrebrivač ogledala",
"Posrednik prodaje na lizing",
"Posrednik za nekretnine",
"Posrednik za poslovne djelatnosti",
"Posrednik za prevoz",
"Posrednik za putovanja",
"Posrednik za trgovinu",
"Posrednik za uslužne djelatnosti",
"Posrednik za zapošljavanje",
"Postavničar",
"Poštanski službenik na šalteru",
"Poštar-pismonoša",
"Potkivač",
"Potporučnik",
"Potpredsjednik /dopredsjednik Komore",
"Potpredsjednik entiteta",
"Potpredsjednik Narodne skupštine RS",
"Potpredsjednik skupštine grada",
"Potpredsjednik skupštine opštine",
"Povrtlarski tehničar",
"Pratilac",
"Pratilac vrijednosne pošiljke",
"Pratitelj lokomotiva",
"Pravni savjetnik",
"Pravni zastupnik",
"Pravnik",
"Pravobranilac",
"Pravobranilac BiH",
"Praznitelj automata za igru",
"Praznitelj prodajnih automata",
"Precrtavač furnira i masivnog drveta",
"Predavač agronomije",
"Predavač arheologije",
"Predavač arhitekture i urbanizma",
"Predavač astronomije",
"Predavač biologije",
"Predavač biotehničkih nauka",
"Predavač biotehnologije i prehrambene tehnologije",
"Predavač defektologije",
"Predavač dizajna",
"Predavač društveno-humanističkih nauka",
"Predavač ekonomije",
"Predavač elektrotehnike",
"Predavač etnologije",
"Predavač farmacije",
"Predavač filologije",
"Predavač filozofije",
"Predavač fizike",
"Predavač geodezije",
"Predavač geofizike",
"Predavač geografije",
"Predavač geologije",
"Predavač građevinarstva",
"Predavač grafičke tehnologije",
"Predavač hemije",
"Predavač hemijskog inženjerstva i tehnologije",
"Predavač historije",
"Predavač informacijskih nauka",
"Predavač kineziologije",
"Predavač kriminalistike",
"Predavač likovnih umjetnosti",
"Predavač mašinstva",
"Predavač matematike",
"Predavač medicine",
"Predavač medicinske biohemije",
"Predavač mehanike",
"Predavač metalurgije",
"Predavač muzičkih umjetnosti",
"Predavač organizacijskih nauka",
"Predavač pedagogije",
"Predavač politologije",
"Predavač prava",
"Predavač primjenjenih umjetnosti",
"Predavač prirodnih nauka",
"Predavač psihologije",
"Predavač računarstva",
"Predavač rudarstva",
"Predavač saobraćaja",
"Predavač scenskih umjetnosti",
"Predavač socijalnog rada",
"Predavač sociologije",
"Predavač stomatologije",
"Predavač šumarstva",
"Predavač tehničko-tehnoloških nauka",
"Predavač tehnologije drva",
"Predavač tekstilne tehnologije",
"Predavač teologije",
"Predavač ugostiteljstva i turizma",
"Predavač veterine",
"Predavač zaštite na radu",
"Predkazivač sreće i budućnosti",
"Predmetni učitelj",
"Predradnik brodogradilišta",
"Predradnik cjevovodnotransportnim uređajima",
"Predradnik elektroničar",
"Predradnik elektroničar u montaži",
"Predradnik kožarstva",
"Predradnik kožne galanterije",
"Predradnik mašinski",
"Predradnik montaže mašina i metalnih proizvoda",
"Predradnik obrade kamena",
"Predradnik obrade metala",
"Predradnik obućarstva",
"Predradnik pripreme, izrade i održavanja bušotina",
"Predradnik proizvodnje soli",
"Predradnik tapetarstva",
"Predradnik u crnoj metalurgiji",
"Predradnik u elektroenergetici",
"Predradnik u elektromašinstvu",
"Predradnik u elektromontaži i instalacijama",
"Predradnik u obojenoj metalurgiji",
"Predradnik u preradi drveta",
"Predradnik u staklarstvu",
"Predradnik za bitumensko katranske materijale",
"Predradnik za emajle i glazure",
"Predradnik za građevinske materijale",
"Predradnik za keramiku",
"Predradnik za odjeću",
"Predradnik za proizvodnju leća",
"Predsjedavajući / predsjednik doma parlamenta / skupštine entiteta",
"Predsjedavajući Doma naroda Parlamentarne skupštine BiH",
"Predsjedavajući gradskog vijeća/skupštine",
"Predsjedavajući kantonalne skupštine",
"Predsjedavajući općinskog vijeća/skupštine",
"Predsjedavajući Predsjedništva BiH",
"Predsjedavajući predstavničkog doma Parlamentarne skupštine BiH",
"Predsjedavajući Vijeća ministara BiH",
"Predsjednik entiteta",
"Predsjednik humanitarne organizacije",
"Predsjednik izborne komisije",
"Predsjednik kantonalnog - oblasnog suda",
"Predsjednik komisije za ljudska prava",
"Predsjednik komisije za zaštitu okoline",
"Predsjednik komore",
"Predsjednik Narodne skupštine RS",
"Predsjednik općinskog suda",
"Predsjednik političke stranke",
"Predsjednik posebne interesne organizacije",
"Predsjednik poslovnog udruženja",
"Predsjednik saveza",
"Predsjednik Saveza sindikata",
"Predsjednik sindikata",
"Predsjednik skupštine grada",
"Predsjednik skupštine opštine",
"Predsjednik strukovnog udruženja",
"Predsjednik upravnog odbora preduzeća",
"Predsjednik Ustavnog suda BiH",
"Predsjednik Ustavnog suda entiteta",
"Predsjednik Vlade entiteta",
"Predsjednik Vrhovnog suda entiteta",
"Predsjednik zadružnog saveza",
"Predstavnik stranke za odnose na javnošću",
"Pregledač vagona",
"Prehrambeni predradnik",
"Prehrambeni tehničar",
"Prehrambenohemijski laborant",
"Premijer/Predsjednik vlade kantona",
"Preparator",
"Prerađivač mesa i mlijeka",
"Prerađivač žita, brašna i šećera",
"Prerađivač glinice",
"Prerađivač mlijeka,specijalizirani",
"Prerađivač voća i povrća",
"Prešač metala",
"Prešač plemenitih metala",
"Prevodilac",
"Primatelj uloga za klađenje",
"Primatelj uplata u igrama na sreću",
"Pripremač duvana",
"Pripremač tekstilnih vlakana",
"Probni padobranac",
"Probni pilot",
"Procjenitelj",
"Procjenitelj boniteta",
"Procjenitelj nakita",
"Procjenitelj osiguranja",
"Procjenitelj umjetnina",
"Prodajni referent",
"Prodavac prehrambene robe",
"Prodavac tehničke robe",
"Prodavac nafte i naftnih derivata",
"Prodavac tekstilne robe",
"Prodavač",
"Prodavač autobusnih karata",
"Prodavač na pijaci",
"Prodavač na priredbama",
"Prodavač na uličnoj tezgi",
"Prodavač nа pumpi",
"Prodavač putem telefona",
"Prodavač putničkih karata",
"Prodavač u kiosku",
"Prodavač u kаfеtеriјi",
"Prodavač ulaznica",
"Prodavači zakupci",
"Prodekan",
"Producent",
"Profesor albanskog jezika",
"Profesor arapskog jezika",
"Profesor arhitekture",
"Profesor astronomije",
"Profesor baleta i plesa",
"Profesor biologije",
"Profesor birotehničkih predmeta",
"Profesor bosanskog jezika",
"Profesor drumskog saobraćaja",
"Profesor ekonomskih predmeta",
"Profesor elektronike",
"Profesor elektrotehnike",
"Profesor engleskog jezika",
"Profesor farmaceutskih predmeta",
"Profesor filozofije",
"Profesor fizičke i zdravstvene kulture",
"Profesor fizike",
"Profesor fizioterapije",
"Profesor flaute",
"Profesor francuskog jezika",
"Profesor geodezije",
"Profesor geofizike",
"Profesor geografije",
"Profesor geologije",
"Profesor građevinarstva",
"Profesor grčkog jezika",
"Profesor gumarske tehnologije",
"Profesor hemije",
"Profesor hemijske tehnologije",
"Profesor historije",
"Profesor hrvatskog jezika",
"Profesor informatike",
"Profesor instrumentalista-privatni časovi",
"Profesor keramičarske tehnologije",
"Profesor kliničkih medicinskih nauka",
"Profesor konditorstva",
"Profesor konfekcijske tehnologije",
"Profesor kožarsko-krznarske tehnologije",
"Profesor kulinarstva",
"Profesor kulturoloških predmeta",
"Profesor latinskog jezika",
"Profesor likovnih predmeta",
"Profesor logike",
"Profesor ljekovitog i aromatskog bilja",
"Profesor marksizma",
"Profesor mašinske energetike",
"Profesor mašinstva",
"Profesor matematike",
"Profesor medicinskobiohemijskih predmeta",
"Profesor mehanike",
"Profesor melioracije",
"Profesor metalurgije",
"Profesor mlinarstva i pekarstva",
"Profesor muzičkih predmeta",
"Profesor njemačkog jezika",
"Profesor obućarske i kožno-galanterijske tehnologije",
"Profesor odbrane i sigurnosti",
"Profesor orjentalistike",
"Profesor osnovnih i socijalnih medicinskih nauka",
"Profesor pedagogije",
"Profesor plastičarske tehnologije",
"Profesor poljoprivredne mehanizacije",
"Profesor praktične nastave",
"Profesor pravnih predmeta",
"Profesor prerade duhana",
"Profesor prerade mesa",
"Profesor prerade mlijeka",
"Profesor prerade voća",
"Profesor proizvodnje alkohola i alkoholnih pića",
"Profesor proizvodnje šećera i skroba",
"Profesor proizvodnje ulja i biljnih masti",
"Profesor protupožarne zaštite",
"Profesor psihologije",
"Profesor PTT saobraćaja",
"Profesor računarstva",
"Profesor ratarstva i povrtlarstva",
"Profesor religijske kulture",
"Profesor restauracije i gradnje muzičkih predmeta",
"Profesor riječnog saobraćaja",
"Profesor romskog jezika",
"Profesor rudarstva",
"Profesor ruskog jezika",
"Profesor scenskih predmeta",
"Profesor sociologije",
"Profesor srpskog jezika",
"Profesor srpskohrvatskog jezika i jugoslovenske književnosti",
"Profesor staklarske tehnologije",
"Profesor stočarstva",
"Profesor stomatoloških predmeta",
"Profesor stranog jezika",
"Profesor šumarstva",
"Profesor talijanskog jezika",
"Profesor tehnologije drveta",
"Profesor tehnologije papira",
"Profesor tekstilne tehnologije",
"Profesor trgovinskih predmeta",
"Profesor turskog jezika",
"Profesor ugostiteljstva i turizma",
"Profesor unutrašnjeg saobraćaja",
"Profesor vazduhoplovnog saobraćaja",
"Profesor veterinarskih predmeta",
"Profesor visoke škole biotehničkih nauka",
"Profesor visoke škole društveno-humanističkih nauka",
"Profesor visoke škole medicinskih nauka",
"Profesor visoke škole prirodnih nauka",
"Profesor visoke škole tehničkih nauka",
"Profesor visoke škole u teologiji",
"Profesor vjeronauke",
"Profesor voćarstva i vinogradarstva",
"Profesor za osobe sa poremećajima u ponašanju",
"Profesor zaštite na radu",
"Profesor željezničkog saobraćaja",
"Programer",
"Programer inženjersko-naučnih primjena",
"Programer mašina upravljanih brojčano",
"Programer poslovnih primjena",
"Programer računarskih primjena",
"Programer za računarske mreže",
"Proizvodni inženjer",
"Proizvođač akumulatorskih kutija",
"Proizvođač alkoholnih pića",
"Proizvođač bezalkoholnih pića",
"Proizvođač duvanskih proizvoda",
"Proizvođač furnira i drvenih pločica",
"Proizvođač gume i plastike",
"Proizvođač industrijskog bilja",
"Proizvođač jestivih ulja",
"Proizvođač sirćeta",
"Proizvođač šećera",
"Proizvođač vatrostalnog materijala",
"Projektant arhitekture",
"Projektant bušotina za naftu i gas",
"Projektant elektroenergetskih postrojenja",
"Projektant enterijera",
"Projektant građevinskih konstrukcija",
"Projektant hemijske tehnologije",
"Projektant hidrotehničkih građevina",
"Projektant informacionih sistema",
"Projektant konstruktor alatnih mašina",
"Projektant konstruktor brodskih motora",
"Projektant konstruktor brodskih pomoćnih mašina",
"Projektant konstruktor dizalica",
"Projektant konstruktor drumskih vozila",
"Projektant konstruktor elektroničkih sistema i proizvoda",
"Projektant konstruktor elektrotehničkih proizvoda",
"Projektant konstruktor energetskoelektroničkih uređaja",
"Projektant konstruktor klasičnog naoružanja",
"Projektant konstruktor mašina za građevinarstvo i industrijski transport",
"Projektant konstruktor mašina za zavarivanje",
"Projektant konstruktor metalnih konstrukcija",
"Projektant konstruktor plovnih sredstava",
"Projektant konstruktor poljoprivrednih mašina",
"Projektant konstruktor preciznih instrumenata",
"Projektant konstruktor pumpi i kompresora",
"Projektant konstruktor pumpi pod pritiskom",
"Projektant konstruktor složenih alata i uređaja",
"Projektant konstruktor šinskih vozila",
"Projektant konstruktor šivaćih mašina",
"Projektant konstruktor tekstilnih mašina",
"Projektant konstruktor turbina",
"Projektant mašinske tehnologije",
"Projektant mašinske tehnologije osiguranja kvaliteta",
"Projektant mašinskog dijela energetskog postrojenja",
"Projektant mreže za distribuciju gasovitih medija",
"Projektant naftne tehnologije",
"Projektant organizacije gradnje",
"Projektant postrojenja za snabdjevanje vodom",
"Projektant sabirnih sistema za naftu i plin",
"Projektant saobraćajnih građevina",
"Projektant tehnologije gradnje plovnih sredstava",
"Projektant tehnologije obrade deformacijom",
"Projektant tehnologije obrade odvajanjem čestica",
"Projektant tehnologije održavanja brodske opreme",
"Projektant tehnologije održavanja vazduhoplova",
"Projektant tehnologije za održavanje drumskih vozila",
"Projektant tehnologije za održavanje građevinskih mašina",
"Projektant tehnologije za održavanje poljoprivredne mehanizacije",
"Projektant tehnologije za održavanje proizvodne opreme",
"Projektant tehnologije za održavanje šinskih vozila",
"Projektant tehnologije zavarivanja",
"Projektant vrtne i pejsažne arhitekture",
"Propovjednik",
"Prorektor",
"Prostorni planer",
"Prostorni projektant",
"Prota",
"Protođakon",
"Protupožarni inspektor",
"Pružni radnik",
"Prvi oficir palube",
"Prvi oficir stroja",
"Prеdаvаč iz оblаsti rаčunаrа",
"Prеdаvаč iz оblаsti sоftvеrа",
"Prоfеsоr gitаrе - privаtni čаsоvi",
"Prоfеsоr klаvirа - privаtni čаsоvi",
"Prоfеsоr pjevanja - privаtni čаsоvi",
"Prоfеsоr plеsа - privаtni čаsоvi",
"Prоfеsоr slikаnjа - privаtni čаsоvi",
"Prоfеsоr viоlinе - privаtni čаsоvi",
"Prоfеsоr zа intеnzivnо učеnjе јеzikа",
"Prоfеsоr zа prаktičnu primjenu јеzikа",
"Psihogerijatrijska sestra - tehničar",
"Psiholog",
"Psiholog forenzičar",
"Psiholog istraživač",
"Psiholog rada",
"Psiholog samostalni istraživač",
"Psiholog savjetnik u savjetovalištu",
"Psihoterapeut",
"PTT tehničar poštanskog saobraćaja",
"Pukovnik",
"Puškar",
"Puškar,majstor",
"Putar",
"Pоmоćnik u kuhinji",
"Pоmоćnik učitеljа",
"Pоzоrišni gаrdеrоbеr",
"Pоzоrišni tеhničаr",
"Rabin",
"Računarski operator",
"Računarski tehničar",
"Računovođa",
"Radiotelegrafist",
"Radni terapeut",
"Radnik betonirac",
"Radnik na baliranju otpadaka",
"Radnik na elektronamotavanju",
"Radnik na istovaru i utovaru",
"Radnik na izvozu i iznosu drvnih sortimenata",
"Radnik na jednostavnim drvoprerađivačkim poslovima",
"Radnik na jednostavnim grafičkim poslovima",
"Radnik na jednostavnim keramičkim poslovima",
"Radnik na jednostavnim laboratorijskim poslovima",
"Radnik na jednostavnim poslovima na energetskom postrojenju",
"Radnik na jednostavnim poslovima na pakovanju tehničkih gasova",
"Radnik na jednostavnim poslovima na postrojenju za preradu i obradu vode",
"Radnik na jednostavnim poslovima u ciglarstvu",
"Radnik na jednostavnim poslovima u hemijskoj proizvodnji",
"Radnik na jednostavnim poslovima u izradi građevinskih materijala",
"Radnik na jednostavnim poslovima u kožarstvu",
"Radnik na jednostavnim poslovima u kožnoj galanteriji",
"Radnik na jednostavnim poslovima u naftno hemijskoj proizvodnji",
"Radnik na jednostavnim poslovima u proizvodnji obuće",
"Radnik na jednostavnim poslovima u tekstilnoj proizvodnji",
"Radnik na jednostavnim poslovima utovarača,pretovarača i prenosa tereta",
"Radnik na jednostavnim transportnim poslovima",
"Radnik na kontinuiranom kuhalu drveta",
"Radnik na palubi platforme",
"Radnik na sabiranju sjemena",
"Radnik na tržnici",
"Radnik na utovaru drvnih sortimenata",
"Radnik na uzgoju i zaštiti divljači",
"Radnik niskogradnje",
"Radnik u asfaltirnici",
"Radnik u ekonomskom dvorištu",
"Radnik u glinokopu",
"Radnik u kamenolomu",
"Radnik u lovištu",
"Radnik u održavanju",
"Radnik u šljunkari",
"Radnik uzgajanja različitih životinja",
"Radnik visokogradnje",
"Radnik za dostavu robe iz trgovina",
"Radnik za jednostavne poslove drugdje nerazvrstan",
"Radnik za jednostavne poslove na montaži",
"Radnik za jednostavne poslove na proizvodnoj liniji",
"Radnik za jednostavne poslove u preradi duhana",
"Radnik za mehaničku lopatu",
"Radnik za pomoć u kući",
"Radnik za sortiranje prtljaga",
"Radnik za uređenje kaptaža",
"Rafinerijski punitelj",
"Rasadničar",
"Raspoređivač u drumskom saobraćaju",
"Ratar",
"Ratar i stočar",
"Ratar za navodnjavanje",
"Ratarski mehanizator",
"Ratarski poslovođa",
"Ratarski radnik",
"Ratarski tehničar",
"Raznosilac",
"Razredni učitelj",
"Razvrstavač i slagač lemelnih i mozaičnih parketa",
"Razvrstavač keramičkih proizvoda",
"Razvrstavač koža,specijalizirani",
"Recenzent",
"Recepcionar",
"Redaktor",
"Redovnik",
"Referent kancelarijskog poslovanja",
"Referent za bolničko liječenje",
"Referent za građevinske dozvole",
"Referent za izdavanje koncesija",
"Referent za izdavanje putnih isprava",
"Referent za iznajmljivanje vozila",
"Referent za izvoz i uvoz",
"Referent za javno upravne poslove",
"Referent za naknade za nezaposlenost",
"Referent za penziono i invalidsko osiguranje",
"Referent za porodična primanja",
"Referent za poštu",
"Referent za pravne poslove",
"Referent za reklamaciju",
"Referent za socijalne pomoći",
"Referent za vozne redove",
"Referent za zdravstveno osiguranje",
"Reis ullema",
"Rektor univerziteta",
"Rekviziter alata",
"Remenar-sedlar",
"Rentgenski pregledač osoba, prtljaga i poštanskih pošiljki",
"Reporter",
"Reprofotograf",
"Reprograf skenarist",
"Republički tužilac",
"Restaurator drvenih predmeta,specijalizirani",
"Restaurator umjetničkih djela",
"Retušer",
"Revizor",
"Revizor za ekonomsko-finansijske poslove",
"Revizori za pravne poslove",
"Rezač drvenih figura",
"Rezač drveta",
"Rezač i brusač naočalnih zaštitnih stakala",
"Rezač plinom",
"Rezbar predmeta od roga",
"Režiser",
"Režiser operne predstave",
"Ribar na moru",
"Ribar otvorenog mora",
"Ribar riječni i jezerski",
"Ribarski inspektor",
"Ribarski poslovođa na otvorenom moru",
"Ribarski poslovođa riječni i jezerski",
"Ribarski tehničar",
"Ribarski vodič",
"Ribarskonautički tehničar",
"Ribnjačarski radnik",
"Roletar",
"Roletar,majstor",
"Ronilac spužvi i koralja",
"Ronilac za spasavanje",
"Ručni čistač",
"Ručni graver štamparskih uzoraka u metalu",
"Ručni graver štamparskih uzoraka u nemetalu",
"Ručni izrađivač ambalažnih grafičkih proizvoda",
"Ručni izrađivač fotoosjetljivih slojeva za sitoštampu",
"Ručni izrađivač proizvoda od papira",
"Ručni izrađivač štamparskih formi i klišeja",
"Ručni pakirer",
"Ručni perač ambalaže",
"Ručni perač automobila",
"Ručni perač dijelova",
"Ručni perač stakla na kolima -ulični",
"Ručni razvrstavač dijelova",
"Ručni razvrstavač proizvoda",
"Ručni savijač metala",
"Ručni slovoslagač",
"Ručni štampar",
"Rudar",
"Rudar podzemnog kopa",
"Rudar površinskog kopa",
"Rudar,specijalizirani",
"Rudarski inspektor",
"Rudarski inženjer",
"Rudarski Inženjer podzemne eksploatacije",
"Rudarski Inženjer površinske eksploatacije",
"Rudarski jamski nadzornik",
"Rudarski jamski poslovođa",
"Rudarski jamski predradnik",
"Rudarski mjernik",
"Rudarski nadzornik površinskog kopa",
"Rudarski nadzornik separacije",
"Rudarski poslovođa",
"Rudarski poslovođa površinskog kopa",
"Rudarski predradnik površinskog kopa",
"Rudarski radnik",
"Rudarski tehničar",
"Rudarski tehničar podzemne eksploatacije",
"Rudarski tehničar površinske eksploatacije",
"Rudarski tehničar za pripremu proizvodnje",
"Rudarski tesar",
"Rukavičar",
"Rukovalac bušilicom za drvo",
"Rukovalac mašinom za brušenje i poliranje drveta",
"Rukovalac oštrilicom alata",
"Rukovalac uređajem za sljepljivanje rubova drveta",
"Rukovalac alatnom mašinom",
"Rukovalac asfaltne baze",
"Rukovalac autoklavom za sječku",
"Rukovalac automatiziranom montažnom linijom,specijalizirani",
"Rukovalac betonskim topom",
"Rukovalac betonskom pumpom",
"Rukovalac blanjalicom metala",
"Rukovalac blanjalicom za drvo",
"Rukovalac brodskim dizalicama",
"Rukovalac brojčano upravljanim mašinama za primarnu preradu drveta",
"Rukovalac brojčano upravljanom drvoobrađivačkom mašinom",
"Rukovalac brojčano upravljanom mašinom za obradu metala",
"Rukovalac brojčano upravljanom mašinom za obradu metala ,specijalizirani",
"Rukovalac cirkularom ,gaterom i poralicom",
"Rukovalac cjevovodnotransportnim uređajima",
"Rukovalac dehidratorom hemikalija",
"Rukovalac destilatorom",
"Rukovalac destilatorom aroma i parfema",
"Rukovalac digestorom za pulpu",
"Rukovalac dijamantnom pilom",
"Rukovalac dispergatorom hemikalija",
"Rukovalac dizalicom",
"Rukovalac dizalom",
"Rukovalac drobilicom za hemikalije",
"Rukovalac drvotokarskim mašinama",
"Rukovalac ekstraktorom hemikalija",
"Rukovalac ekstruderom za hemikalije",
"Rukovalac ekstruderom za polimere",
"Rukovalac elektroenergetskim postrojenjem,specijalizirani",
"Rukovalac elektrolizne stanice",
"Rukovalac filterima za hemikalije",
"Rukovalac fleksoštamparskom mašinom",
"Rukovalac glodalicom metala",
"Rukovalac glodalicom za drvo",
"Rukovalac građevinskih strojeva visokogradnje",
"Rukovalac građevinskim i pretovarnim mašinama",
"Rukovalac građevinskim mašinama",
"Rukovalac industrijskim robotom,specijalizirani",
"Rukovalac isparivačem",
"Rukovalac jamskom utovarnom mehanizacijom",
"Rukovalac kalandrom za tekstil",
"Rukovalac knjigovezačkim mašinama",
"Rukovalac kompresorom",
"Rukovalac kompresorskih stanica,specijalizirani",
"Rukovalac kotlova",
"Rukovalac kožarsko-krznarskim mašinama",
"Rukovalac kranom",
"Rukovalac krematorija",
"Rukovalac kružnom pilom",
"Rukovalac lakih građevinskih mašina",
"Rukovalac laktofrizom",
"Rukovalac linijom za sastavljanje tapaciranih proizvoda",
"Rukovalac lučkom mehanizacijom",
"Rukovalac mašinama za izradu plastičnih proizvoda,specijalizirani",
"Rukovalac mašinama i uređajima za istiskivanje metala",
"Rukovalac mašinama i uređajima za izvlačenje metala",
"Rukovalac mašinama i uređajima za obradu rude i kamena",
"Rukovalac mašinama i uređajima za proizvodnju keramike",
"Rukovalac mašinama i uređajima za proizvodnju stakla",
"Rukovalac mašinama i uređajima za proizvodnju staklenih proizvoda",
"Rukovalac mašinama u pekarstvu",
"Rukovalac mašinama za asfaltiranje",
"Rukovalac mašinama za bojenje tekstila",
"Rukovalac mašinama za brušenje i četkanje kože",
"Rukovalac mašinama za bušenje i razbijanje",
"Rukovalac mašinama za češljanje i šišanje krzna",
"Rukovalac mašinama za doradu potplatnih koža",
"Rukovalac mašinama za glačanje i ravnanje koža",
"Rukovalac mašinama za iglanje i prošivanje",
"Rukovalac mašinama za injektiranje tla",
"Rukovalac mašinama za iskop",
"Rukovalac mašinama za iskop tunela",
"Rukovalac mašinama za iskuhavanje tekstila",
"Rukovalac mašinama za izdvajanje radioaktivnih materija",
"Rukovalac mašinama za izradu dijafragme",
"Rukovalac mašinama za izradu plastičnih proizvoda",
"Rukovalac mašinama za izradu šešira",
"Rukovalac mašinama za izradu traka s uzorkom",
"Rukovalac mašinama za kesonsko temeljenje",
"Rukovalac mašinama za konzerviranje mesa i ribe",
"Rukovalac mašinama za ljuštenje žita",
"Rukovalac mašinama za mliječne proizvode",
"Rukovalac mašinama za mljevenje uljarične ljuske",
"Rukovalac mašinama za mljevenje uljnog sjemena",
"Rukovalac mašinama za mljevenje žita",
"Rukovalac mašinama za nabijanje",
"Rukovalac mašinama za napinjanje kože",
"Rukovalac mašinama za netkani tekstil",
"Rukovalac mašinama za obradu kamena",
"Rukovalac mašinama za obradu voća",
"Rukovalac mašinama za planiranje tla",
"Rukovalac mašinama za pletenje",
"Rukovalac mašinama za pletenje mreža",
"Rukovalac mašinama za pokrivne slojeve kože",
"Rukovalac mašinama za poslastice i peciva",
"Rukovalac mašinama za pranje tekstila",
"Rukovalac mašinama za pranje voća i povrća",
"Rukovalac mašinama za predenje",
"Rukovalac mašinama za preradu mesa",
"Rukovalac mašinama za preradu ribe",
"Rukovalac mašinama za preradu voća i povrća",
"Rukovalac mašinama za pripremu voća i povrća",
"Rukovalac mašinama za proizvodnju čokolade",
"Rukovalac mašinama za proizvodnju dijetne hrane",
"Rukovalac mašinama za proizvodnju dječije hrane iz voća",
"Rukovalac mašinama za proizvodnju industrijskih dijamanata",
"Rukovalac mašinama za proizvodnju jestivog ulja",
"Rukovalac mašinama za proizvodnju keksa",
"Rukovalac mašinama za proizvodnju koksa",
"Rukovalac mašinama za proizvodnju kolača",
"Rukovalac mašinama za proizvodnju margarina i biljnog masla",
"Rukovalac mašinama za proizvodnju sintetičkih vlakana",
"Rukovalac mašinama za proizvodnju slatkiša",
"Rukovalac mašinama za proizvodnju sokova",
"Rukovalac mašinama za proizvodnju soli",
"Rukovalac mašinama za proizvodnju stočne hrane",
"Rukovalac mašinama za proizvodnju tijesta",
"Rukovalac mašinama za proizvodnju tjestenine",
"Rukovalac mašinama za proizvodnju vještačke kože",
"Rukovalac mašinama za proizvodnju vještačkih đubriva",
"Rukovalac mašinama za proizvodnju žvakaćih guma",
"Rukovalac mašinama za pružne radove",
"Rukovalac mašinama za rafiniranje ulja i masti",
"Rukovalac mašinama za stabilizaciju tla",
"Rukovalac mašinama za sušenje kože",
"Rukovalac mašinama za sušenje mesa",
"Rukovalac mašinama za tkanje",
"Rukovalac mašinama za toplinsko oblikovanje tekstila",
"Rukovalac mašinama za toplinsku obradu hemikalija",
"Rukovalac mašinama za toplinsku obradu tekstila",
"Rukovalac mašinama za topljenje masti",
"Rukovalac mašinama za ugradnju betonskih ivičnjaka",
"Rukovalac mašinama za ukrasni tekstil",
"Rukovalac mašinama za užad",
"Rukovalac mašinama za vezenje",
"Rukovalac mašinama za zabijanje pilote",
"Rukovalac mašinama za zemljane radove",
"Rukovalac mašinama za žitne proizvode",
"Rukovalac mašinom za torkretiranje",
"Rukovalac mašinom u kartonaži",
"Rukovalac mašinom za bakroštampu",
"Rukovalac mašinom za bijeljenje tekstila",
"Rukovalac mašinom za blanjenje",
"Rukovalac mašinom za bojenje pređe",
"Rukovalac mašinom za bojenje tekstilnih vlakana",
"Rukovalac mašinom za boranje (plisiranje) tekstila",
"Rukovalac mašinom za brizganje polimera",
"Rukovalac mašinom za brizganje potplata na obuću",
"Rukovalac mašinom za brušenje metala",
"Rukovalac mašinom za brušenje obuće",
"Rukovalac mašinom za brušenje žljebova",
"Rukovalac mašinom za bušenje metala",
"Rukovalac mašinom za cijeđenje rublja",
"Rukovalac mašinom za cijepanje kože",
"Rukovalac mašinom za čupavljenje tekstila",
"Rukovalac mašinom za dijeljenje drveta bez iverja",
"Rukovalac mašinom za dubljenje rupa u drvetu",
"Rukovalac mašinom za elektroerodiranje",
"Rukovalac mašinom za farmaceutske proizvode",
"Rukovalac mašinom za glačanje odjeće",
"Rukovalac mašinom za glačanje tekstila",
"Rukovalac mašinom za glodanje žljebova",
"Rukovalac mašinom za graviranje metala",
"Rukovalac mašinom za hermetičko zatvaranje",
"Rukovalac mašinom za injekcijsko presanje polimera",
"Rukovalac mašinom za isijecanje donjih dijelova obuće",
"Rukovalac mašinom za iveranje drveta",
"Rukovalac mašinom za izradu dugmadi",
"Rukovalac mašinom za izradu gornjih gumenih dijelova obuće",
"Rukovalac mašinom za izradu gume",
"Rukovalac mašinom za izradu koverata",
"Rukovalac mašinom za izradu pragova",
"Rukovalac mašinom za izradu reznog alata",
"Rukovalac mašinom za izradu sintetičkih đonova",
"Rukovalac mašinom za izradu vrećica",
"Rukovalac mašinom za jetkanje metala",
"Rukovalac mašinom za karboniziranje tekstila",
"Rukovalac mašinom za knjižnu štampu",
"Rukovalac mašinom za konzerviranje mlijeka",
"Rukovalac mašinom za kovanje alata",
"Rukovalac mašinom za kovanje novca",
"Rukovalac mašinom za kozmetičke proizvode",
"Rukovalac mašinom za krojenje gornjih dijelova obuće",
"Rukovalac mašinom za laminiranje polimera",
"Rukovalac mašinom za lijevanje betona",
"Rukovalac mašinom za lomljenje lica kože",
"Rukovalac mašinom za mekšanje kože",
"Rukovalac mašinom za mjerenje kože",
"Rukovalac mašinom za naknadnu obradu tekstila",
"Rukovalac mašinom za namotavanje tekstila",
"Rukovalac mašinom za navlačenje gornjih dijelova obuće",
"Rukovalac mašinom za oblikovanje drveta savijanjem i utiskivanjem",
"Rukovalac mašinom za oblikovanje gumenih proizvoda",
"Rukovalac mašinom za obradu papira",
"Rukovalac mašinom za obradu pluta",
"Rukovalac mašinom za obradu ruba potplata",
"Rukovalac mašinom za obrađivanje i obljepljivanje drveta",
"Rukovalac mašinom za održavanje skijališta",
"Rukovalac mašinom za odškrobljavanje tekstila",
"Rukovalac mašinom za otkoravanje",
"Rukovalac mašinom za označavanje ceste",
"Rukovalac mašinom za pakovanje",
"Rukovalac mašinom za pakovanje pod pritiskom",
"Rukovalac mašinom za pakovanje tableta",
"Rukovalac mašinom za peraća sredstva",
"Rukovalac mašinom za piljenje metala",
"Rukovalac mašinom za plastificiranje tekstila",
"Rukovalac mašinom za postavljanje cijevne instalacije",
"Rukovalac mašinom za postavljanje drenaže",
"Rukovalac mašinom za postavljanje izolacije",
"Rukovalac mašinom za pranje automobila",
"Rukovalac mašinom za pranje rublja",
"Rukovalac mašinom za pranje vagona",
"Rukovalac mašinom za preradu duhana",
"Rukovalac mašinom za preradu papira",
"Rukovalac mašinom za presanje dijelova obuće",
"Rukovalac mašinom za prevlačenje električnih vodova",
"Rukovalac mašinom za pripremu oblovine",
"Rukovalac mašinom za pripremu polimera",
"Rukovalac mašinom za proizvodnju baterija",
"Rukovalac mašinom za proizvodnju duhanskih proizvoda",
"Rukovalac mašinom za proizvodnju električnih vodova",
"Rukovalac mašinom za proizvodnju kotlova",
"Rukovalac mašinom za proizvodnju metalne užadi",
"Rukovalac mašinom za proizvodnju nakita",
"Rukovalac mašinom za proizvodnju papira",
"Rukovalac mašinom za proizvodnju papira,specijalizirani",
"Rukovalac mašinom za proizvodnju toaletnih proizvoda",
"Rukovalac mašinom za prošivanje đonova",
"Rukovalac mašinom za puhanje polimera",
"Rukovalac mašinom za ravno šivenje odjeće",
"Rukovalac mašinom za riblje proizvode",
"Rukovalac mašinom za rotolijev polimera",
"Rukovalac mašinom za rupičanje kožnih dijelova",
"Rukovalac mašinom za sastavljanje kablova i užadi",
"Rukovalac mašinom za sastavljanje madraca",
"Rukovalac mašinom za skidanje mesine",
"Rukovalac mašinom za sljepljiivanje kutnih spojeva drveta",
"Rukovalac mašinom za sljepljivanje uskih strana drveta",
"Rukovalac mašinom za struganje kože",
"Rukovalac mašinom za šišanje tekstila",
"Rukovalac mašinom za štampanje tekstila",
"Rukovalac mašinom za valjanje tekstila",
"Rukovalac mašinom za vezenje",
"Rukovalac mašinom za zakivanje eksera",
"Rukovalac mašinskim makazama za rezanje metala",
"Rukovalac mehanizacijom na površinskoj eksploataciji",
"Rukovalac mehanizacijom u šumarstvu",
"Rukovalac mješalicom za granulat plastike",
"Rukovalac mlinom za gumu",
"Rukovalac mlinom za hemikalije",
"Rukovalac mlinom za papirnu smjesu",
"Rukovalac mlinom za plastiku",
"Rukovalac mlinom za začine",
"Rukovalac mlinskim sitima",
"Rukovalac mlinskim valjcima",
"Rukovalac motorom s unutrašnjim sagorjevanjem",
"Rukovalac motorom s unutrašnjim sagorjevanjem,specijalizirani",
"Rukovalac obalnim dizalicama",
"Rukovalac obućarskim mašinama",
"Rukovalac ofsetnom štamparskom mašinom",
"Rukovalac opremom u zabavnom parku",
"Rukovalac opremom za doradu gumenih proizvoda",
"Rukovalac parnim kotlovima sa automatskom komandom,specijalizirani",
"Rukovalac parnim kotlovima sa mehaniziranim loženjem,specijalizirani",
"Rukovalac parnim kotlovima sa ručnim loženjem",
"Rukovalac parnim mašinama",
"Rukovalac parnim turbinama",
"Rukovalac parnim turbinama,specijalizirani",
"Rukovalac peći za cement",
"Rukovalac peći za fritu",
"Rukovalac peći za gips",
"Rukovalac peći za kreč",
"Rukovalac pećima za prerađivanje metala",
"Rukovalac pilom za kamen",
"Rukovalac plinskim turbinama",
"Rukovalac plinskim turbinama,specijalizirani",
"Rukovalac pokretnim parnim kotlovima",
"Rukovalac pokretnim parnim kotlovima,specijalizirani",
"Rukovalac pokretnom dizalicom",
"Rukovalac pomičnim mostom",
"Rukovalac pomoćne jamske mehanizacije",
"Rukovalac pomoćnim knjigovezačkim mašinama",
"Rukovalac pomoćnom mašinom u kartonaži",
"Rukovalac pomoćnom štamparskom mašinom",
"Rukovalac posebnim mašinama za šivanje odjeće",
"Rukovalac postrojenja kondenzacije",
"Rukovalac postrojenja kondenzacije, specijalizirani",
"Rukovalac postrojenjem pri instrumentacijama u bušotini,specijalizirani",
"Rukovalac postrojenjem pri kosom usmjerenom bušenju,specijalizirani",
"Rukovalac postrojenjem za cementacije i stimulacije bušotina,specijalizirani",
"Rukovalac postrojenjem za dobivanje glutena",
"Rukovalac postrojenjem za dobivanje škrobnog sirupa",
"Rukovalac postrojenjem za drobljenje rude i kamena",
"Rukovalac postrojenjem za ekstrakciju šećera",
"Rukovalac postrojenjem za farmaceutske proizvode,specijalizirani",
"Rukovalac postrojenjem za filtriranje šećernog sirupa",
"Rukovalac postrojenjem za hidratizaciju kreča",
"Rukovalac postrojenjem za hidrološka bušenja",
"Rukovalac postrojenjem za istraživanje bušotina,specijalizirani",
"Rukovalac postrojenjem za izbjeljivanje, dimljenje i patiniranje drveta",
"Rukovalac postrojenjem za izradu staklenih vlakana",
"Rukovalac postrojenjem za karotažne radove,specijalizirani",
"Rukovalac postrojenjem za kozmetičke proizvode,specijalizirani",
"Rukovalac postrojenjem za kristalizaciju",
"Rukovalac postrojenjem za mljevenje rude i kamena",
"Rukovalac postrojenjem za nanošenje veznih slojeva na drvo",
"Rukovalac postrojenjem za oplemenjivanje gasa,specijalizirani",
"Rukovalac postrojenjem za oplemenjivanje mineralnih sirovina",
"Rukovalac postrojenjem za peraća sredstva,specijalizirani",
"Rukovalac postrojenjem za pranje cisterni",
"Rukovalac postrojenjem za preradu meda",
"Rukovalac postrojenjem za preradu mlijeka",
"Rukovalac postrojenjem za pripremu bušotinskih fluida",
"Rukovalac postrojenjem za pripremu kafe,kafovine,instanta i čajeva",
"Rukovalac postrojenjem za pripremu keramičke mase",
"Rukovalac postrojenjem za pripremu vode",
"Rukovalac postrojenjem za pročišćavanje vode",
"Rukovalac postrojenjem za proizvodnju duhanskih proizvoda",
"Rukovalac postrojenjem za proizvodnju mliječne dječije hrane",
"Rukovalac postrojenjem za proizvodnju piva",
"Rukovalac postrojenjem za proizvodnju sirćeta",
"Rukovalac postrojenjem za proizvodnju škrobnih derivata",
"Rukovalac postrojenjem za protočna mjerenja u bušotini,specijalizirani",
"Rukovalac postrojenjem za punjenje boca",
"Rukovalac postrojenjem za punjenje boca tehničkim plinom",
"Rukovalac postrojenjem za radove sa savitljivim tubingom u bušotini,specijalizirani",
"Rukovalac postrojenjem za radove sa tekućim azotom u bušotini,specijalizirani",
"Rukovalac postrojenjem za radove žicom i kablom u bušotini,specijalizirani",
"Rukovalac postrojenjem za rafiniranje škroba",
"Rukovalac postrojenjem za razvlaknjivanje drveta",
"Rukovalac postrojenjem za rezanje šećerne repe",
"Rukovalac postrojenjem za separaciju",
"Rukovalac postrojenjem za separaciju škroba",
"Rukovalac postrojenjem za spaljivanje otpadaka",
"Rukovalac postrojenjem za steriliziranje uređaja i transportnih sredstava",
"Rukovalac postrojenjem za sušenje šećera i rezanaca",
"Rukovalac postrojenjem za tekući šećer",
"Rukovalac postrojenjem za transport gasa",
"Rukovalac postrojenjem za usitnjavanje hemikalija",
"Rukovalac postrojenjem za ventilaciju i klimatizaciju",
"Rukovalac postrojenjima u preradi nafte",
"Rukovalac postrojenjima za preradu kafe,kakaoa,dodataka jelima i čajeva",
"Rukovalac prehrambenim mašinama",
"Rukovalac presom za metale",
"Rukovalac presom za obljepljivanje rubova",
"Rukovalac presom za polimere",
"Rukovalac presom za sljepljivanje drvenih ploha",
"Rukovalac presom za sljepljivanje drvenih vlakana",
"Rukovalac presom za sljepljivanje iverja i ploča",
"Rukovalac presom za sljepljivanje rubova drveta",
"Rukovalac presom za utiskivanje ornamenata u drvo",
"Rukovalac pretovarnim mašinama za beton",
"Rukovalac procesnih linija za prerađivanje metala",
"Rukovalac procesnih mašina i uređaja za dobijanje metala",
"Rukovalac procesnih mašina za toplotnu obradu metala",
"Rukovalac proizvodnim postrojenjem za naftu i gas,specijalizirani",
"Rukovalac proizvodno-otpremnim postrojenjem za naftu i gas",
"Rukovalac proizvodno-otpremnim sistemom za naftu i gas,specijalizirani",
"Rukovalac pumpama",
"Rukovalac pumpnih stanica,specijalizirani (osim nafte i prirodnog gasa)",
"Rukovalac rashladnim postrojenjem",
"Rukovalac rashladnim postrojenjem, specijalizirani",
"Rukovalac reaktorskim postrojenjem za proizvodnju hemikalija",
"Rukovalac rudarskim izvoznim postrojenjem",
"Rukovalac rudarskim postrojenjem",
"Rukovalac samopokretnom bušilicom",
"Rukovalac separatorom za hemikalije",
"Rukovalac silosnim uređajima",
"Rukovalac sitima za hemikalije",
"Rukovalac sitoštamparskom mašinom",
"Rukovalac sjekaćicom kamena",
"Rukovalac sterilizatorom",
"Rukovalac sušarom za hemikalije",
"Rukovalac šivaćim mašinama za tapetariju",
"Rukovalac šivaćim poluautomatom i automatom",
"Rukovalac šivaćom mašinom za kožnu galanteriju",
"Rukovalac šivaćom mašinom za kožu",
"Rukovalac šivaćom mašinom za obuću",
"Rukovalac šivaćom mašinom za tekstil",
"Rukovalac štamparskom mašinom",
"Rukovalac tekstilnom presom",
"Rukovalac tokarilicom metala",
"Rukovalac topioničkim pećima",
"Rukovalac tračnom pilom",
"Rukovalac transportnim gasnim sistemom,specijalizirani",
"Rukovalac transportnom trakom",
"Rukovalac uklopnim postrojenjem",
"Rukovalac uklopnim postrojenjem,specijalizirani",
"Rukovalac urađejem za mješanje hemikalija",
"Rukovalac uređajem za bojanje i lakiranje drveta",
"Rukovalac uređajem za azbestnocementne proizvode",
"Rukovalac uređajem za bitumensko-katranske proizvode",
"Rukovalac uređajem za bruniranje",
"Rukovalac uređajem za ekspandiranje polimera",
"Rukovalac uređajem za elektrolizu",
"Rukovalac uređajem za elektrozavarivanje",
"Rukovalac uređajem za eloksiranje",
"Rukovalac uređajem za fosfatiziranje metala",
"Rukovalac uređajem za frakcijsku destilaciju drveta",
"Rukovalac uređajem za gipsane ploče",
"Rukovalac uređajem za granuliranje hemikalija",
"Rukovalac uređajem za gumiranje",
"Rukovalac uređajem za hidriranje pulpe",
"Rukovalac uređajem za hlađenje mliječnih proizvoda",
"Rukovalac uređajem za iskuhavanje drveta",
"Rukovalac uređajem za izbjeljivanje celuloze",
"Rukovalac uređajem za izradu betonskih građevinskih elemenata",
"Rukovalac uređajem za izradu betonskih proizvoda",
"Rukovalac uređajem za izradu fotografija",
"Rukovalac uređajem za izradu metalne galanterije",
"Rukovalac uređajem za izradu proizvoda od porobetona",
"Rukovalac uređajem za izradu šibica",
"Rukovalac uređajem za izradu žičanih mreža i tkanina",
"Rukovalac uređajem za kalciniranje",
"Rukovalac uređajem za karotažne radove",
"Rukovalac uređajem za klimatiziranje i otvrdnjavanje površine drveta",
"Rukovalac uređajem za kondicioniranje drveta",
"Rukovalac uređajem za kuhanje hemikalija",
"Rukovalac uređajem za lijevanje polimera",
"Rukovalac uređajem za mješanje betona",
"Rukovalac uređajem za obradu mlijeka",
"Rukovalac uređajem za odmašćivanje metala",
"Rukovalac uređajem za otapanje hemikalija",
"Rukovalac uređajem za pasterizaciju mliječnih proizvoda",
"Rukovalac uređajem za pasterizaciju mlijeka",
"Rukovalac uređajem za pirotehničke proizvode",
"Rukovalac uređajem za pjeskarenje metala",
"Rukovalac uređajem za plastificiranje metala",
"Rukovalac uređajem za poliranje metala",
"Rukovalac uređajem za pranje vozila",
"Rukovalac uređajem za premazivanje metala",
"Rukovalac uređajem za preradu duhana",
"Rukovalac uređajem za preradu gumenih proizvoda",
"Rukovalac uređajem za preradu otpadnog luga",
"Rukovalac uređajem za preradu plastike",
"Rukovalac uređajem za pripremu glazure",
"Rukovalac uređajem za pripremu ljepila za papir",
"Rukovalac uređajem za pripremu papirne mase",
"Rukovalac uređajem za pripremu smjese za šibice",
"Rukovalac uređajem za proizvode iz polimernog betona",
"Rukovalac uređajem za proizvodnju eksploziva",
"Rukovalac uređajem za proizvodnju fotografskih filmova",
"Rukovalac uređajem za proizvodnju fotografskih ploča",
"Rukovalac uređajem za proizvodnju fotografskih proizvoda",
"Rukovalac uređajem za proizvodnju fotohemikalija",
"Rukovalac uređajem za proizvodnju linoleuma",
"Rukovalac uređajem za proizvodnju olovaka",
"Rukovalac uređajem za proizvodnju silicijskih ploča",
"Rukovalac uređajem za proizvodnju streljiva",
"Rukovalac uređajem za proizvodnju streljiva,specijalizirani",
"Rukovalac uređajem za proizvodnju svijeća",
"Rukovalac uređajem za proizvodnju školskog pribora",
"Rukovalac uređajem za prosijavanje,razvrstavanje i natresanje drveta",
"Rukovalac uređajem za razvijanje filmova",
"Rukovalac uređajem za rezanje plamenom",
"Rukovalac uređajem za sačmarenje metala",
"Rukovalac uređajem za sastavljanje kliznih zatvarača",
"Rukovalac uređajem za savijanje drveta",
"Rukovalac uređajem za sintezu hemikalija",
"Rukovalac uređajem za suhu destilaciju drveta",
"Rukovalac uređajem za uranjanje metala",
"Rukovalac uređajem za vulkaniziranje",
"Rukovalac uređajem za zavarivanje plamenom",
"Rukovalac uređajima brane",
"Rukovalac uređajima na palubi platforme",
"Rukovalac uređajima u hemigrafiji",
"Rukovalac uređajima u reprofotografiji",
"Rukovalac uređajima u slovoljevaonici",
"Rukovalac uređajima za cementacije i stimulacije u bušotini",
"Rukovalac uređajima za izradu kobasica",
"Rukovalac uređajima za izvlačenje žice",
"Rukovalac uređajima za obradu ječma i slada",
"Rukovalac uređajima za obradu mesa",
"Rukovalac uređajima za obradu ribe",
"Rukovalac uređajima za oplemenjivanje gasa",
"Rukovalac uređajima za pripremu stakla",
"Rukovalac uređajima za proizvodnju alkohola",
"Rukovalac uređajima za proizvodnju bezalkoholnih pića",
"Rukovalac uređajima za proizvodnju elektroda",
"Rukovalac uređajima za proizvodnju gasa",
"Rukovalac uređajima za proizvodnju jakih alkoholnih pića",
"Rukovalac uređajima za proizvodnju kvasca",
"Rukovalac uređajima za proizvodnju nafte i gasa",
"Rukovalac uređajima za proizvodnju pića",
"Rukovalac uređajima za proizvodnju vina",
"Rukovalac uređajima za sterilizaciju mesnih i ribljih konzervi",
"Rukovalac uređajima za steriliziranje konzervi voća i povrća",
"Rukovalac uređajima za sušenje voća i povrća",
"Rukovalac uređajima za utovar tekućeg gasa",
"Rukovalac uređajima za zamrzavanje mesa i ribe",
"Rukovalac uređajima za zamrzavanje voća i povrća",
"Rukovalac uspinjačom",
"Rukovalac vagom",
"Rukovalac viljuškarom",
"Rukovalac višefaznim mašinama za drvo",
"Rukovalac višefaznom mašinom za guljenje,pilenje,iveranje",
"Rukovalac višefazom mašinom za obradu drveta i spajanje rubova",
"Rukovalac vitlom",
"Rukovalac vodnim turbinama",
"Rukovalac vodnim turbinama,specijalizirani",
"Rukovalac za dodavanje financijskih markica",
"Rukovalac za izradu pozamenterije",
"Rukovalac za obilježavanje robe",
"Rukovalac za toplo oblikovanje polimera",
"Rukovalac žičarom",
"Rukovodilac vladinog ureda",
"Rukovodilac finansijskih poslova",
"Rukovodilac gradnje",
"Rukovodilac kadrovskih poslova",
"Rukovodilac knjigovodstvenih poslova",
"Rukovodilac općih i pravnih poslova",
"Rukovodilac poslova pretovara",
"Rukovodilac poslovnice nabave i prodaje",
"Rukovodilac protokola",
"Rukovodilac računovodstva i finansija",
"Rukovodilac službe za zaštitu",
"Rukovodilac špeditersko-agencijskih poslova",
"Rukоvоdilаc grаdilištа",
"Sakristan",
"Sakupljač i naplaćivač dugova",
"Saldakontist",
"Samaraš",
"Samostalni bibliotečki istraživač",
"Samostalni informacijski istraživač",
"Samostalni istražitelj kriminalist",
"Samostalni istražitelj kriminolog",
"Samostalni istraživač antropolog",
"Samostalni istraživač arheolog",
"Samostalni istraživač arhivistike",
"Samostalni istraživač biologije",
"Samostalni istraživač biotehnologije",
"Samostalni istraživač brodograđevinarstva",
"Samostalni istraživač ekonomskih nauka",
"Samostalni istraživač elektronike, telekomunikacija i automatike",
"Samostalni istraživač etnolog",
"Samostalni istraživač filozofije",
"Samostalni istraživač geodezije",
"Samostalni istraživač geograf",
"Samostalni istraživač građevinarstva",
"Samostalni istraživač grafičke tehnologije",
"Samostalni istraživač hemijske tehnologije",
"Samostalni istraživač historije",
"Samostalni istraživač komunikolog",
"Samostalni istraživač mašinstva",
"Samostalni istraživač metalurgije",
"Samostalni istraživač meteorologije",
"Samostalni istraživač politologije",
"Samostalni istraživač pravnih nauka",
"Samostalni istraživač računarstva",
"Samostalni istraživač rudarstva",
"Samostalni istraživač sociolog",
"Samostalni istraživač tekstilne tehnologije",
"Samostalni istraživač u agronomiji",
"Samostalni istraživač u šumarstvu",
"Samostalni istraživač umjetnosti",
"Samostalni istraživač urbanizma",
"Samostalni istraživač vaspitnih nauka",
"Samostalni istraživač veterine",
"Samostalni istraživač za elektroenergetiku i elektromašinstvo",
"Samostalni prognostičar vremena",
"Samostalni računovođa",
"Samostalni stručni saradnik u poslovnim i srodnim djelatnostima",
"Sanitarni inspektor",
"Sanitarni inženjer",
"Sanitarni tehničar",
"Saobraćajni disponent",
"Saobraćajni policajac",
"Saobraćajni tehničar",
"Saradnik prevodioca za francuski jezik",
"Saradnik prevodioca za francuski jezik sa poznavanjem arapskog jezika",
"Saradnik prevodioca za francuski jezik sa poznavanjem latinskog jezika",
"Saradnik prevodioca za njemački jezik",
"Saradnik prevodioca za njemački jezik sa poznavanjem arapskog jezika",
"Saradnik prevodioca za njemački jezik sa poznavanjem latinskog jezika",
"Saradnik prevodioca za ruski jezik",
"Saradnik prevodioca za ruski jezik sa poznavanjem arapskog jezika",
"Saradnik prevodioca za ruski jezik sa poznavanjem latinskog jezika",
"Saradnik (pomoćnik) stručnjaka za specijalno vaspitanje i obrazovanje",
"Saradnik (pomoćnik) u nastavi u osnovnoj školi",
"Saradnik (pomoćnik) vaspitača predškolske djece",
"Saradnik prevodioca za engleski jezik",
"Saradnik prevodioca za engleski jezik sa poznavanjem arapskog jezika",
"Saradnik prevodioca za engleski jezik sa poznavanjem latinskog jezika",
"Saradnik za analiziranje i planiranje proizvodnih procesa",
"Saradnik za logistiku",
"Saradnik za organizaciju posla",
"Sastavljač akumulatora",
"Sastavljač aparata za domaćinstvo",
"Sastavljač baterija",
"Sastavljač dizalica",
"Sastavljač drvenih proizvoda",
"Sastavljač električnih mjernih instrumenata i sklopova",
"Sastavljač elektroinstalacijskog materijala",
"Sastavljač elektromehaničkih komponenti i sklopova",
"Sastavljač elektromotora",
"Sastavljač elektronske opreme",
"Sastavljač elektronskih sklopova",
"Sastavljač elektrožičanih snopova",
"Sastavljač građevinske stolarije",
"Sastavljač gumenih proizvoda",
"Sastavljač kartonskih proizvoda",
"Sastavljač kožnih proizvoda",
"Sastavljač malih transformatora",
"Sastavljač mašina",
"Sastavljač mašinskih pribora",
"Sastavljač metalnih proizvoda",
"Sastavljač metalnog namještaja",
"Sastavljač motora",
"Sastavljač naočala",
"Sastavljač papirnatih proizvoda",
"Sastavljač parnih kotlova",
"Sastavljač parnih turbina",
"Sastavljač plastičnih proizvoda",
"Sastavljač plinskih turbina",
"Sastavljač proizvoda od različitih materijala",
"Sastavljač računarske opreme",
"Sastavljač rasvjetnih tijela",
"Sastavljač sijalica",
"Sastavljač streljiva, specijalizirani",
"Sastavljač štampanih ploča",
"Sastavljač tekstilnih proizvoda",
"Sastavljač telefonskog aparata",
"Sastavljač telekomunikacijske opreme",
"Sastavljač vozila",
"Satiričar",
"Savijač drveta u kalupu",
"Savjetnik direktora",
"Savjetnik kantonalnog suda",
"Savjetnik komore",
"Savjetnik ministra",
"Savjetnik općinskog suda",
"Savjetnik predsjednika političke stranke",
"Savjetnik socijalne pomoći",
"Savjetnik u vaspitno obrazovnom zavodu",
"Savjetnik vrhovnog suda",
"Savjetnik za ekonomiku domaćinstva",
"Savjetnik za istraživanje tržišta",
"Savjetnik za kulturno-umjetničke programe",
"Savjetnik za nekretnine",
"Savjetnik za obrazovanje osoba sa posebnim potrebama",
"Savjetnik za odbranu",
"Savjetnik za odbranu i sigurnost",
"Savjetnik za odnose sa javnosti",
"Savjetnik za osobnu i poslovnu uspješnost",
"Savjetnik za patente",
"Savjetnik za poduzetništvo",
"Savjetnik za poslovanje",
"Savjetnik za predmetno područje",
"Savjetnik za predškolsko vaspitanje",
"Savjetnik za prodajne metode",
"Savjetnik za prodaju",
"Savjetnik za profesionalno informiranje",
"Savjetnik za promotivne metode",
"Savjetnik za proračune",
"Savjetnik za razrednu nastavu",
"Savjetnik za studentska pitanja",
"Savjetnik za veterinarstvo",
"Savjetnik za zapošljavanje",
"Savjetnik za zaštitu životne sredine",
"Savjetnik za zdravstveno osiguranje",
"Savjetnik za zdravstvo",
"Savjetnik zemljišno-informacijskog sistema",
"Scenarist",
"Scenograf",
"Scenski dizajner",
"Scenski tehničar",
"Seizmolog",
"Sekretar diplomatsko konzularnog predstavništva",
"Sekretar društva",
"Sekretar gradskog vijeća",
"Sekretar humanitarne organizacije",
"Sekretar kabineta funkcionera",
"Sekretar komore",
"Sekretar ministarstva",
"Sekretar mjesnog ureda",
"Sekretar okružnog tužilaštva",
"Sekretar općinskog vijeća",
"Sekretar organizacije",
"Sekretar parlamenta / skupštine",
"Sekretar političke stranke",
"Sekretar poslovne interesne organizacije",
"Sekretar pravobranilaštva",
"Sekretar preduzeća",
"Sekretar radnog tijela parlamenta / skupštine",
"Sekretar radnog tijela vlade",
"Sekretar republičkog tužilaštva",
"Sekretar sindikata",
"Sekretar Skupštine grada",
"Sekretar Skupštine kantona",
"Sekretar Skupštine opštine",
"Sekretar ustanove",
"Sekretar Vlade entiteta",
"Sekretarica",
"Servis ortopedskih i drugih zdravstvenih pomagala",
"Serviser dijamantnih pila",
"Serviser električnih aparata i opreme",
"Serviser elektronskih uređaja i opreme",
"Serviser muzičkih instrumenata",
"Serviser optičke opreme",
"Serviser plinskih uređaja",
"Serviser plinskih uređaja,specijalizirani",
"Serviser preciznih naprava i opreme",
"Serviser ručnog alata",
"Serviser ručnog alata,specijalizirani",
"Serviser sportske opreme",
"Serviser šivaćih mašina",
"Serviser šivaćih mašina,majstor",
"Serviser terminalskih aparata kod pretplatnika",
"Serviser uređaja za točenje goriva",
"Serviser uređaja za točenje goriva,specijalizirani",
"Serviser vatrogasnih aparata",
"Sinđel",
"Sirar",
"Sirar, industrijski",
"Sistem inženjer",
"Sistem programer",
"Sitoštampar",
"Sjekač šiba i trske",
"Sjemenar",
"Skelar",
"Skiper",
"Skladišni dispečer",
"Skladišni manipulant",
"Skladišni radnik",
"Skladišni službenik",
"Skladištar",
"Skladištar alata",
"Skretničar",
"Skupljač priloga za dobrotvorne svrhe",
"Sladoledar",
"Slagač na računskom terminalu",
"Slastičar",
"Slastičar,majstor",
"Slavista",
"Slikar",
"Slikar crtanog filma",
"Slikar grafičar",
"Slikar naivac",
"Slikar proizvedene robe",
"Slikar vozila",
"Slovoslagač",
"Službenik deviznog poslovanja",
"Službenik kadrovskih poslova",
"Službenik lučke kapetanije",
"Službenik nabave",
"Službenik obračuna plaća",
"Službenik općih poslova",
"Službenik platnog prometa",
"Službenik prodaje",
"Službenik protokola",
"Službenik u agenciji za platni promet na šalteru",
"Službenik u distribuciji",
"Službenik u knjigovodstvu",
"Službenik za administrativno-tehničke poslove",
"Službenik za bankomatsku mrežu",
"Službenik za informacije",
"Službenik za izračunavanje",
"Službenik za kopiranje dokumenata",
"Službenik za likvidaciju naknada",
"Službenik za organizaciju putovanja",
"Službenik za osiguranje",
"Službenik za posredništvo sa nekretninama",
"Službenik za vrijednosne papire",
"Službenik zbirnog prometa",
"Službеnik infоrmisаnjа u zdrаvstvu",
"Službеnik mеdicinskоg оsigurаnjа",
"Službеnik оbаvеštајno-sigurnosne službе",
"Smećar",
"Smjenovođa u TE",
"Snimatelj slike",
"Snimatelj slike i zvuka",
"Snimatelj trika",
"Snimatelj vremena i pokreta",
"Snimatelj zvuka",
"Sobarica",
"Soboslikar i moler",
"Soboslikar i moler,majstor",
"Socijalni pedagog",
"Socijalni radnik",
"Socijalni radnik u centru",
"Socijalni radnik u domu",
"Socijalni radnik u obrazovanju",
"Socijalni radnik u pravosuđu",
"Socijalni radnik u zdravstvu",
"Socijalni radnik za ostvarivanje prava",
"Socijalni radnik za rad sa hendikepiranim osobama",
"Socijalni radnik za rad sa materijalno ugroženim osobama",
"Socijalni stručnjak",
"Socijalni stručnjak u centru",
"Socijalni stručnjak u domu",
"Socijalni stručnjak u obrazovanju",
"Socijalni stručnjak u pravosuđu",
"Socijalni stručnjak u zdravstvu",
"Socijalni stručnjak za rad sa hendikepiranim osobama",
"Socijalni stručnjak za rad sa materijalno ugroženim osobama",
"Sociolog",
"Softwer inženjer",
"Sokolar",
"Solanski radnik",
"Solo pjevač",
"SOS majka",
"SOS teta",
"Spajač elektrotehničkih elemenata",
"Spasilac iz požara",
"Spasilac iz vode",
"Speleološki vodič",
"Spiker",
"Splavar",
"Sportista",
"Sportski direktor",
"Sportski psiholog",
"Sportski sudac",
"Sportski trener",
"Sportski vodič",
"Srmar",
"Staklar",
"Staklarski poslovođa",
"Staklobrusač",
"Stakloduvač",
"Stakloduvač,specijalizirani",
"Staklorezac",
"Staratelj",
"Stariji vodnik",
"Stariji vodnik I. klase",
"Statista",
"Statističar",
"Statističar demograf",
"Statističar istraživač",
"Statističar matematičar",
"Statističar metodolog",
"Statističar samostalni istraživač",
"Statistički službenik",
"Stečajni upravnik",
"Stenodaktilograf",
"Stenograf",
"Stilar,dekorni i umjetnički majstor",
"Stjuard / stjuardesa na aerodromu",
"Stjuard / stjuardesa na brodu",
"Stjuard / stjuardesa u avionu",
"Stočar",
"Stočarski poslovođa",
"Stočarski radnik",
"Stočarski tehničar",
"Stolar",
"Stolar stilskog namještaja",
"Stolar za scensku opremu",
"Stolar za scensku opremu,specijalizirani",
"Stolar za šablone",
"Stolar,dekorni i umjetnički",
"Stolar,majstor",
"Stolar,ortopedski",
"Stolar,ortopedski specijalizirani",
"Stolar,specijalizirani za izradu šablona i prototipova",
"Stomatološka sestra",
"Stražar",
"Stražar u zatvoru",
"Stručna bаbica",
"Stručni saradnik (asistent) za finansijske planove i analize",
"Stručni saradnik (asistent) za proračune i prikaze u osiguranju",
"Stručni saradnik (asistent) za računovodstvene proračune i prikaze",
"Stručni saradnik (asistent) za statističke proračune i prikaze",
"Stručni saradnik kontonalnog suda",
"Stručni saradnik općinskog suda",
"Stručni saradnik u pravosudnim organima",
"Stručni saradnik vrhovnog suda",
"Stručni saradnik za analitičko-planske poslove",
"Stručni saradnik za imovinsko-pravne poslove",
"Stručni saradnik za kadrovske poslove",
"Stručni saradnik za normativne poslove",
"Stručni saradnik za poslove javnih nabavki",
"Stručni saradnik za rad sa mladima",
"Stručnjak za metodiku u obrazovnim područjima",
"Stručnjak za obrazovne tehnologije",
"Stručnjak za razvoj vaspitno-obrazovnog programa",
"Stručnjak za strateško planiranje",
"Stručnjak za upravljanje energijom i vodom",
"Stručnjak za upravljanje otpadom",
"Stručnjak za zdravstvenu njegu",
"Stučni saradnik za likvidaciju računa i naknada",
"Stučni saradnik-instruktor za kontrolu obračuna i naplate",
"Stučni saradnik-instruktor za računovodstvene poslove",
"Sudija kantonalnog - oblasnog suda",
"Sudija okružnog suda",
"Sudija općinskog suda",
"Sudija prekršajnog suda",
"Sudija Ustavnog suda na nivou države",
"Sudija Ustavnog suda na nivou entiteta",
"Sudija Vrhovnog suda",
"Sudski tumač",
"Sudski zapisničar",
"Sufler",
"Sušilac duvana",
"Sušitelj drveta",
"Svećenik",
"Svjetioničar",
"Šalterski službenik putničke agencije",
"Šalterski službenik zalagaonice",
"Šef kuhinje",
"Šef željezničkoga saobraćaja",
"Šeširdžija",
"Šeširdžija, majstor",
"Šifrant",
"Šinter",
"Šivač",
"Šivač gornjih dijelova obuće",
"Šivač kože",
"Šivač krzna",
"Šivač krzna i kože",
"Šivač lake konfekcije",
"Šivač podstave obuće",
"Šivač tekstila",
"Šivač teške konfekcije",
"Školski inspektor",
"Školski laborant",
"Školski psiholog",
"Špediter",
"Špediterski carinski deklarant",
"Špeditersko-agencijski službenik",
"Štampar",
"Štampar na metalu",
"Štampar na plastici",
"Štampar na tekstilu",
"Štampar višebojnih otisaka u štampi",
"Štamparski graver,specijalizirani",
"Štamper nijanser štamparskih boja",
"Štamper probnih otisaka",
"Štamper višebojnih otisaka",
"Štamper višebojnih otisaka u bakroštampi",
"Štamper višebojnih otisaka u fleksoštampi",
"Štamper višebojnih otisaka u knjigoštampi",
"Štamper višebojnih otisaka u ofsetu",
"Štimer harmonike",
"Štimer klavira",
"Štukater",
"Šumarski inspektor",
"Šumarski radnik",
"Šumarski tehničar",
"Šumski mjerač drveta",
"Šumski poslovođa",
"Šumski putar",
"Šumski radnik na destilaciji drveta tradicionalnom tehnikom",
"Šumski rasadničar",
"Šumski sjekač",
"Šumski traktorist",
"Šumski uzgajivač",
"Šаltеrski službеnik zа priјеm zahtjevа",
"Tapetar",
"Tapetar dekorater",
"Tapetar namještaja",
"Tapetar vozila",
"Tapetar, majstor",
"Tapetarski tehničar",
"Tarifer",
"Tehničar agrohemikalija",
"Tehničar analize namirnica",
"Tehničar bitumensko katranskih proizvoda",
"Tehničar boja i lakova",
"Tehničar celuloze",
"Tehničar dijetetske proizvodnje",
"Tehničar drumskog saobraćaja",
"Tehničar elektrohemijskih sistema",
"Tehničar elektroničar za računare",
"Tehničar elektronike",
"Tehničar elektronike za mjerne i upravljačke uređaje",
"Tehničar elektronike za signalno-zaštitne uređaje",
"Tehničar farmaceutskih proizvoda",
"Tehničar farmaceutskih sistema",
"Tehničar finalne prerade drveta",
"Tehničar fizikalni",
"Tehničar fotografskih proizvoda",
"Tehničar geoelektričnih mjerenja",
"Tehničar geofizičkog istraživanja ležišta",
"Tehničar geološkog istraživanja ležišta",
"Tehničar grafičke dorade",
"Tehničar grafički urednik",
"Tehničar gumarstva",
"Tehničar hemigrafije i reprofotografije",
"Tehničar hidraulike i pneumatike",
"Теhničаr hitnе mеdicinske pоmоći",
"Tehničar interpretacije geofizičkih podataka",
"Tehničar keramike",
"Tehničar konditorske proizvodnje",
"Tehničar konstruktor alatnih mašina",
"Tehničar konstruktor aparata za domaćinstvo",
"Tehničar konstruktor brodskih mašina",
"Tehničar konstruktor cjevovoda",
"Tehničar konstruktor cjevovoda i armature",
"Tehničar konstruktor dijelova metalnih konstrukcija",
"Tehničar konstruktor dijelova plovnih sredstava",
"Tehničar konstruktor dijelova proizvoda precizne mehanike",
"Tehničar konstruktor dijelova pružnih vozila",
"Tehničar konstruktor dijelova uređaja i kalupa",
"Tehničar konstruktor dizalica",
"Tehničar konstruktor drumskih vozila",
"Tehničar konstruktor električnih proizvoda",
"Tehničar konstruktor elektronskih proizvoda",
"Tehničar konstruktor energetskoelektronskih uređaja",
"Tehničar konstruktor gasne mreže",
"Tehničar konstruktor klasičnog naoružanja",
"Tehničar konstruktor limenih dijelova",
"Tehničar konstruktor mašina za građevinarstvo i industrijski transport",
"Tehničar konstruktor mašinskih dijelova",
"Tehničar konstruktor plovnih sredstava",
"Tehničar konstruktor poljoprivrednih mašina",
"Tehničar konstruktor posuda pod pritiskom",
"Tehničar konstruktor procesne opreme",
"Tehničar konstruktor proizvoda precizne mehanike",
"Tehničar konstruktor pumpi i kompresora",
"Tehničar konstruktor rashladnih uređaja",
"Tehničar konstruktor složenih alata i uređaja",
"Tehničar konstruktor šinskih vozila",
"Tehničar konstruktor šivaćih mašina",
"Tehničar konstruktor tekstilnih mašina",
"Tehničar konstruktor telekomunikacijskih uređaja",
"Tehničar konstruktor turbina",
"Tehničar konstruktor uređaja za zavarivanje",
"Tehničar kozmetičkih proizvoda",
"Tehničar laboratorijske kontrole",
"Tehničar laboratorijskog ispitivanja stijena",
"Tehničar lijevanja crne metalurgije",
"Tehničar lijevanja obojenih metala",
"Tehničar logistike i špedicije",
"Tehničar mašinski konstruktor",
"Tehničar mašinski konstruktor detaljist",
"Tehničar matematički",
"Теhničаr mеdicinskih dоsiјеа",
"Tehničar mehatronike",
"Tehničar metalurgije",
"Tehničar mlinarstva i prerade brašna",
"Tehničar obrade geofizičkih podataka",
"Tehničar obrade kamena",
"Tehničar okeanografije",
"Tehničar papirske tehnologije",
"Tehničar pigmenata",
"Tehničar pletenja",
"Tehničar polimera",
"Tehničar poštanskog saobraćaja",
"Tehničar predenja",
"Tehničar preparator životinja i biljaka",
"Tehničar prerade duhana",
"Tehničar prerade kave, kavovina i čajeva",
"Tehničar prerade mesa i ribe",
"Tehničar prerade polimera",
"Tehničar prerade voća, povrća i sokova",
"Tehničar pripreme i obrade vode",
"Теhničаr prоcеsа rаfinisаnjа",
"Tehničar proizvodnje biljnih ulja",
"Tehničar proizvodnje crne metalurgije",
"Tehničar proizvodnje enzima",
"Tehničar proizvodnje jakih alkoholnih pića",
"Tehničar proizvodnje obojenih metala",
"Tehničar proizvodnje piva",
"Tehničar proizvodnje stočne hrane",
"Tehničar proizvodnje šećera",
"Tehničar proizvodnje škroba",
"Tehničar proizvodnje vina",
"Tehničar proizvodnje voda i gaziranih napitaka",
"Tehničar prostornog planiranja",
"Tehničar radioloških sistema",
"Tehničar robota",
"Tehničar rudarski mjernik",
"Tehničar savjetodavac za dijetnu ishranu",
"Tehničar savjetodavac za zdravu ishranu",
"Tehničar seizmičkih mjerenja",
"Tehničar sredstava za pranje",
"Tehničar staklarstva",
"Tehničar tiska",
"Tehničar tkanja",
"Tehničar unutrašnjeg transporta",
"Tehničar vojno hemijskih sistema",
"Tehničar vojnohemijskih proizvoda",
"Tehničar vuče",
"Tehničar za brodske telekomunikacije",
"Tehničar za drvo",
"Tehničar za eksploataciju kamena",
"Tehničar za elektronske proizvode",
"Tehničar za elektrotehniku",
"Tehničar za emajle i glazure",
"Tehničar za energetskoelektronske uređaje",
"Tehničar za gradnju plovnih sredstava",
"Tehničar za građevinske materijale",
"Tehničar za izgradnju sabirnih sistema za naftu i plin",
"Tehničar za izvođenje programa",
"Tehničar za kožarstvo",
"Tehničar za kožnu galanteriju",
"Tehničar za medicinske elektronske uređaje",
"Tehničar za mehatroniku",
"Tehničar za mjerenja nafte i plina",
"Tehničar za obradu deformacijom",
"Tehničar za obradu odvajanjem čestica",
"Tehničar za obuću",
"Tehničar za odjeću",
"Tehničar za održavanje elektrotehničkih proizvoda",
"Tehničar za održavanje programa",
"Tehničar za održavanje pruga",
"Tehničar za organske sinteze",
"Tehničar za ortopednu tehniku",
"Tehničar za podvodnu opremu na bušaćoj platformi",
"Tehničar za pomoć korisniku",
"Tehničar za pretovar",
"Tehničar za procesnu automatiku",
"Tehničar za programiranje",
"Tehničar za proizvodnju elektrotehničkih proizvoda",
"Tehničar za proizvodnju leća",
"Tehničar za proizvodnju nafte i plina",
"Tehničar za proizvodnju soli",
"Tehničar za računsku tehniku i automatiku",
"Tehničar za radio i televizijske uređaje",
"Tehničar za razradu naftnih i plinskih ležišta",
"Tehničar za razvijanje",
"Tehničar za sigurnost na radu",
"Tehničar za sigurnost saobraćaja",
"Tehničar za sigurnost vazduhoplovnog saobraćaja",
"Tehničar za sistemsku programsku opremu",
"Tehničar za tehnologiju saobraćaja",
"Tehničar za telekomunikacije",
"Tehničar za telekomunikacijske uređaje i mreže",
"Tehničar za transport plina",
"Tehničar za uređaje vazduhoplovne elektronike",
"Tehničar za vazduhoplovne telekomunikacije",
"Tehničar za zavarivanje",
"Tehničar za zubnu protetiku",
"Tehničar za zvučne efekte",
"Tehničar za željezničke telekomunikacije",
"Tehničar zaštite bilja",
"Tehničar zaštite od korozije",
"Tehnički crtač",
"Tehnički crtač za arheologiju",
"Tehnički crtač za arhitekturu",
"Tehnički crtač za brodogradnju",
"Tehnički crtač za elektrotehniku",
"Tehnički crtač za geodeziju",
"Tehnički crtač za građevinarstvo",
"Tehnički crtač za mašinstvo",
"Tehnički direktor u termoelektrani",
"Tehnički ilustrator",
"Tehnički kalkulant",
"Tehnički kontrolor drumskih vozila",
"Tehnički kontrolor tramvaja",
"Tehnički kontrolor vozila",
"Tehnički pisac",
"Tehnički saradnik za zaštitu okoline",
"Tehnički zastupnik prodaje",
"Tehnički zastupnik za prodaju informacione opreme",
"Tehnički zastupnik za prodaju komunikacijske opreme",
"Tehnolog - tehničar",
"Tehnolog agrohemikalija",
"Tehnolog automatike i elektrotehnike",
"Tehnolog boja i lakova",
"Tehnolog celuloze",
"Tehnolog elektrotehnike",
"Tehnolog famaceutskih proizvoda",
"Tehnolog građevinskog održavanja",
"Tehnolog gumarstva",
"Tehnolog konditorske proizvodnje",
"Tehnolog kotlovskih postrojenja u TE",
"Tehnolog kozmetičkih proizvoda",
"Tehnolog lijevanja i valjanja obojenih metala",
"Tehnolog mašinskog održavanja energetskih postrojenja u TE",
"Tehnolog mlinarstva i prerade brašna",
"Tehnolog obrade otpadnih voda",
"Tehnolog održavanja cjevovodne mreže",
"Tehnolog održavanja gasne mreže",
"Tehnolog održavanja rudarske opreme",
"Tehnolog pakovanja",
"Tehnolog papirnih proizvoda",
"Tehnolog peradarstva",
"Tehnolog pigmenata",
"Tehnolog prerade duhana",
"Tehnolog prerade mesa i ribe",
"Tehnolog prerade mlijeka i mliječnih proizvoda",
"Tehnolog prerade polimera",
"Tehnolog prerade voća, povrća i bezalkoholnih pića",
"Tehnolog presovanja obojenih metala",
"Tehnolog pripreme i obrade vode",
"Tehnolog proizvodnje biljnih ulja i masti",
"Tehnolog proizvodnje crne metalurgije",
"Tehnolog proizvodnje enzima",
"Tehnolog proizvodnje gotove hrane",
"Tehnolog proizvodnje obojenih metala",
"Tehnolog proizvodnje piva",
"Tehnolog proizvodnje soli",
"Tehnolog proizvodnje stočne hrane",
"Tehnolog proizvodnje šećera, skroba i derivata",
"Tehnolog proizvodnje vina, alkohola i sirćeta",
"Tehnolog proizvodnje vitamina i hormona",
"Tehnolog ribarstva",
"Tehnolog sredstava za pranje i čišćenje",
"Tehnolog stočarstva",
"Tehnolog školskog pribora",
"Tehnolog tekstila",
"Tehnolog telekomunikacija",
"Tehnolog vojnohemijskih sistema",
"Tehnolog za fotografske proizvode",
"Tehnolog za građevinske materijale",
"Tehnolog za keramiku",
"Tehnolog za organske sinteze",
"Tehnolog za preciznu optiku",
"Tehnolog za proizvodni proces u TE",
"Tehnolog za promet",
"Tehnolog za staklarstvo",
"Tehnolog zaštite od korozije",
"Tekstilni inženjer",
"Tekstilni inženjer - tehnolog konfekcije",
"Tekstilni predradnik",
"Tekstilni tehničar",
"Tekstilni tehničar - konfekcionar",
"Tekstilni tehničar hemijsko - oplemenjivačkog smjera",
"Tekstilni tehničar mašinskog smjera tkač, predioničar, pletač",
"Tekstilni tehničar modelar - konstruktor",
"Tekstilnohemijski tehničar",
"Telefaksist",
"Telefonist",
"Telefonist za međunarodne veze",
"Telegrafist",
"Teleprinterist",
"Teolog",
"Teracer",
"Terapeut za govor i gluhoću",
"Terapeut za poremećaje vida",
"Termoizolater",
"Termotehničar",
"Tesar",
"Tesar - parketar",
"Tesar - parketar,majstor",
"Tesar krovopokrivač",
"Tesar,majstor",
"Tesarski radnik",
"Tetovirač",
"Timaritelj u zoološkom vrtu",
"Tipomašinist",
"Tipomašinist, specijalizirani",
"Tjelohranitelj",
"Tjesteninar",
"Tkač",
"Tkač ćilima",
"Tkač, predioničar, pletač",
"Točilac pića",
"Toksikolog",
"Torbar",
"Torbar, prodavač",
"Torbar,specijalizirani",
"Tornjaš",
"Transportni agent",
"Тrаvаr",
"Treći oficir palube",
"Treći oficir stroja",
"Trener konja",
"Trezorist",
"Trgovački poslovođa",
"Trgovački putnik",
"Tržni inspektor",
"Tumač za jezike",
"Turistički animator",
"Turistički pratioci",
"Turistički vodič",
"Turističko hotelijerski tehničar",
"Turizmolog",
"Tužilac",
"TV mehaničar",
"Učitelj djece sa razvojnim teškoćama",
"Učitelj mentalno retardiranih osoba",
"Učitelj muzike",
"Učitelj osoba s oštećenjem sluha",
"Učitelj osoba s oštećenjem vida",
"Učitelj osoba s poremećajima u ponašanju",
"Učitelj predškolske djece",
"Učitelj predškolske djece sa posebnim potrebama",
"Učitelj tjelesno invalidnih osoba",
"Ugljar",
"Ugostiteljska domaćica / domaćin",
"Ugostiteljski poslastičar",
"Ugostiteljski poslovođa",
"Ugostiteljski tehničar",
"Ulični piljаr",
"Ulični prodavač drugih proizvoda",
"Ulični prodavač hrane i pića",
"Umjetnički model",
"Umjetnički stvaralac",
"Univerzitetski asistent agronomije",
"Univerzitetski asistent arheologije",
"Univerzitetski asistent arhitekture i urbanizma",
"Univerzitetski asistent astronomije",
"Univerzitetski asistent biologije",
"Univerzitetski asistent biotehničkih nauka",
"Univerzitetski asistent biotehnologije i prehrambene tehnologije",
"Univerzitetski asistent defektologije",
"Univerzitetski asistent dizajna",
"Univerzitetski asistent društveno-humanističkih nauka",
"Univerzitetski asistent ekonomije",
"Univerzitetski asistent elektrotehnike",
"Univerzitetski asistent etnologije",
"Univerzitetski asistent farmacije",
"Univerzitetski asistent filologije",
"Univerzitetski asistent filozofije",
"Univerzitetski asistent fizike",
"Univerzitetski asistent geodezije",
"Univerzitetski asistent geofizike",
"Univerzitetski asistent geografije",
"Univerzitetski asistent geologije",
"Univerzitetski asistent građevinarstva",
"Univerzitetski asistent grafičke tehnologije",
"Univerzitetski asistent hemije",
"Univerzitetski asistent hemijskog inženjerstva i tehnologije",
"Univerzitetski asistent historije",
"Univerzitetski asistent informacijskih nauka",
"Univerzitetski asistent kineziologije",
"Univerzitetski asistent kriminalistike",
"Univerzitetski asistent likovnih umjetnosti",
"Univerzitetski asistent mašinstva",
"Univerzitetski asistent matematike",
"Univerzitetski asistent medicine",
"Univerzitetski asistent medicinske biohemije",
"Univerzitetski asistent mehanike",
"Univerzitetski asistent metalurgije",
"Univerzitetski asistent muzičkih umjetnosti",
"Univerzitetski asistent organizacijskih nauka",
"Univerzitetski asistent pedagogije",
"Univerzitetski asistent politologije",
"Univerzitetski asistent prava",
"Univerzitetski asistent primjenjenih umjetnosti",
"Univerzitetski asistent prirodnih nauka",
"Univerzitetski asistent psihologije",
"Univerzitetski asistent računarstva",
"Univerzitetski asistent rudarstva",
"Univerzitetski asistent saobraćaja",
"Univerzitetski asistent scenskih umjetnosti",
"Univerzitetski asistent socijalnog rada",
"Univerzitetski asistent sociologije",
"Univerzitetski asistent stomatologije",
"Univerzitetski asistent šumarstva",
"Univerzitetski asistent tehničko -tehnoloških nauka",
"Univerzitetski asistent tehnologije drva",
"Univerzitetski asistent tekstilne tehnologije",
"Univerzitetski asistent teologije",
"Univerzitetski asistent ugostiteljstva i turizma",
"Univerzitetski asistent veterine",
"Univerzitetski asistent zaštite na radu",
"Univerzitetski profesor agronomije",
"Univerzitetski profesor arheologije",
"Univerzitetski profesor arhitekture i urbanizma",
"Univerzitetski profesor astronomije",
"Univerzitetski profesor biologije",
"Univerzitetski profesor biotehničkih nauka",
"Univerzitetski profesor biotehnologije i prehrambene tehnologije",
"Univerzitetski profesor defektologije",
"Univerzitetski profesor dizajna",
"Univerzitetski profesor društveno-humanističkih nauka",
"Univerzitetski profesor ekonomije",
"Univerzitetski profesor elektrotehnike",
"Univerzitetski profesor etnologije",
"Univerzitetski profesor farmacije",
"Univerzitetski profesor filologije",
"Univerzitetski profesor filozofije",
"Univerzitetski profesor fizike",
"Univerzitetski profesor geodezije",
"Univerzitetski profesor geofizike",
"Univerzitetski profesor geografije",
"Univerzitetski profesor geologije",
"Univerzitetski profesor građevinarstva",
"Univerzitetski profesor grafičke tehnologije",
"Univerzitetski profesor hemije",
"Univerzitetski profesor hemijskog inženjerstva i tehnologije",
"Univerzitetski profesor historije",
"Univerzitetski profesor informacijskih nauka",
"Univerzitetski profesor kineziologije",
"Univerzitetski profesor kriminalistike",
"Univerzitetski profesor likovnih umjetnosti",
"Univerzitetski profesor mašinstva",
"Univerzitetski profesor matematike",
"Univerzitetski profesor medicine",
"Univerzitetski profesor medicinske biohemije",
"Univerzitetski profesor mehanike",
"Univerzitetski profesor metalurgije",
"Univerzitetski profesor muzičkih umjetnosti",
"Univerzitetski profesor organizacijskih nauka",
"Univerzitetski profesor pedagogije",
"Univerzitetski profesor politologije",
"Univerzitetski profesor prava",
"Univerzitetski profesor primjenjenih umjetnosti",
"Univerzitetski profesor prirodnih nauka",
"Univerzitetski profesor psihologije",
"Univerzitetski profesor računarstva",
"Univerzitetski profesor rudarstva",
"Univerzitetski profesor saobraćaja",
"Univerzitetski profesor scenskih umjetnosti",
"Univerzitetski profesor socijalnog rada",
"Univerzitetski profesor sociologije",
"Univerzitetski profesor stomatologije",
"Univerzitetski profesor šumarstva",
"Univerzitetski profesor tehničko-tehnoloških nauka",
"Univerzitetski profesor tehnologije drva",
"Univerzitetski profesor tekstilne tehnologije",
"Univerzitetski profesor teologije",
"Univerzitetski profesor ugostiteljstva i turizma",
"Univerzitetski profesor veterine",
"Univerzitetski profesor zaštite na radu",
"Upravitelj stroja",
"Upravitelj stroja unutrašnje plovidbe",
"Upravni inspektor",
"Upravni organizator",
"Upravni pravnik",
"Upravni savjetnik",
"Upravni službenik",
"Upravni službenik za dozvole i isprave",
"Upravnik / upravnica domaćinstva",
"Upravnik zatvora",
"Urar za popravak i održavanja satova",
"Urar, u proizvodnji satova",
"Urbanistički inspektor",
"Urednik novinar",
"Uređivač polica",
"Utovarivač otpada",
"Uzgajivač divljači",
"Uzgajivač glista",
"Uzgajivač gljiva",
"Uzgajivač goveda",
"Uzgajivač konja",
"Uzgajivač koza",
"Uzgajivač kunića za meso",
"Uzgajivač laboratorijskih životinja",
"Uzgajivač ljekovitog bilja",
"Uzgajivač mačaka",
"Uzgajivač ostalih životinja",
"Uzgajivač ovaca",
"Uzgajivač pasa",
"Uzgajivač pernate šumske divljači",
"Uzgajivač ptica",
"Uzgajivač puževa",
"Uzgajivač ribe",
"Uzgajivač ribe i školjki",
"Uzgajivač ribljih larvi i žive hrane",
"Uzgajivač svilene bube",
"Uzgajivač svinja",
"Uzgajivač šumske dlakave divljači",
"Uzgajivač ukrasnih riba",
"Uzgajivač žaba",
"Uzgajivač životinja za krzno",
"Uzgajivači nojeva",
"Užar i izrađivač vrpci",
"Valjač plemenitih metala",
"Vaspitač",
"Vaspitač u učeničkom domu",
"Vatrogasac",
"Vatrogasni tehničar",
"Vatrogasni tehničar,specijalista",
"Vazduhoplovni otpravnik",
"Veterinar",
"Veterinar na poslovima kvaliteta i higijene namjernica životinjskog porijekla",
"Veterinar epizootiolog",
"Veterinar hirurg",
"Veterinar internist",
"Veterinar kućnih ljubimaca",
"Veterinar mikrobiolog",
"Veterinar na poslovima deratizacije, dezinsekcije i dezinfekcije",
"Veterinar opšte prakse",
"Veterinar parazitolog",
"Veterinar specijalizant",
"Veterinar tehnolog u animalnoj proizvodnji",
"Veterinar za reprodukciju životinja",
"Veterinar za zdravstvenu zaštitu životinja",
"Veterinarski bolničar",
"Veterinarski inspektor",
"Veterinarski laboratorijski tehničar",
"Veterinarski tehničar",
"Veterinarski tehničar za pelcovanje životinja",
"Veterinarski tehničar za poslove deratizacije, dezinsekcije i dezinfekcije",
"Veterinarski tehničar za trihinoskopiju",
"Veterinarski tehničar za vještačko osjemenjavanje",
"Vezilac",
"Vicekonzul",
"Videotehničar",
"Videotekar",
"Vijećnik gradskog vijeća",
"Vijećnik općinskog vijeća",
"Vinogradar",
"Vinogradarski poslovođa",
"Vinogradarski tehničar",
"Vinogradski radnik",
"Vinski savjetodavac",
"Visoki čelnik institucije drugdje nerazvrstan",
"Visoki funkcioner institucije drugdje nerazvrstan",
"Viša medicinska sestra i zdravstveni tehničar",
"Viši fizioterapeut",
"Viši radiološki tehničar",
"Viši sanitarni tehničar",
"Viši upravni savjetnik",
"Vjeroučitelj u osnovnoj školi",
"Vladika",
"Voćar",
"Voćar - vinogradar",
"Voćarski poslovođa",
"Voćarski radnik",
"Voćarski tehničar",
"Vodič",
"Voditelj distributivnih poslova",
"Voditelj matičnog ureda",
"Voditelj plovnog sistema jahti",
"Voditelj poslova obezbjeđenja",
"Voditelj poslovnice nabave",
"Voditelj poslovnice prodaje",
"Voditelj rudarskog katastra",
"Voditelj skladišnog poslovanja",
"Voditelj sportske rekreacije",
"Voditelj sportskih aktivnosti djece i omladine",
"Voditelj u programu",
"Vodnik",
"Vodograditelj",
"Vodoinstalater",
"Vodoinstalater i plinoinstalater",
"Vođa benda",
"Vođa hidroloških radova",
"Vođa knjigovodstva",
"Vođa krojačnice",
"Vođa malog plovećeg radnog stroja",
"Vođa palube",
"Vođa palube na platformi",
"Vođa palube unutarnje plovidbe",
"Vođa plovećeg radnog stroja",
"Vođa posade marine",
"Vođa poslovnog voza",
"Vođa recepcije",
"Vođa skladišta",
"Vođa smjene na bušaćem postrojenju",
"Vođa smjene na postrojenju za remont bušotina",
"Vođa smjene vatrogasne jedinice",
"Vođa straže",
"Vođa stroja",
"Vođa stroja unutarnje plovidbe",
"Vojni psiholog",
"Vojnik",
"Vojnik I. klase",
"Vozač autobusa",
"Vozač automješalice",
"Vozač cisterne",
"Vozač električnih paletnih kolica",
"Vozač furgona",
"Vozač hitne pomoći",
"Vozač hladnjače",
"Vozač kamiona",
"Vozač kamiona s dizalicom",
"Vozač kombibusa",
"Vozač kontejnerskog prijenosnika",
"Vozač kontejnerskog trajlera",
"Vozač lakih motornih vozila",
"Vozač lakog dostavnog vozila",
"Vozač mašina za asfaltiranje",
"Vozač mašina za bušenje i razbijanje",
"Vozač mašina za čišćenje kanalizacije",
"Vozač mašina za čišćenje saobraćajnica",
"Vozač mašina za injektiranje tla",
"Vozač mašina za iskop",
"Vozač mašina za nabijanje tla",
"Vozač mašina za stabilizaciju tla",
"Vozač mašina za ugradnju betonskih ivičnjaka",
"Vozač mašina za zabijanje pilota",
"Vozač mašine za zemljane radove",
"Vozač motocikla",
"Vozač motornih pružnih vozila",
"Vozač motornih vozila",
"Vozač opasnih materija",
"Vozač pokretne dizalice",
"Vozač poljoprivrednih mašina",
"Vozač posebnih teretnih vozila",
"Vozač putničkog automobila",
"Vozač ručnih kolica",
"Vozač skele",
"Vozač šlepera",
"Vozač šlepera sa poluprikolicom",
"Vozač taksija",
"Vozač taksija na vodi",
"Vozač teretnog viljuškara",
"Vozač teretnog vozila",
"Vozač teretnog vozila sa prikolicom",
"Vozač teške šumske mehanizacije",
"Vozač teških notornih vozila,majstor",
"Vozač teškog traktora",
"Vozač tramvaja",
"Vozač tricikla",
"Vozač trolejbusa",
"Vozački instruktor",
"Vozni manipulant",
"Vratar,razvodnik",
"Vrtlar",
"Vrtlar za nasade",
"Vrtlar za parkove",
"Vrtlar,specijalizirani",
"Vrtlarski poslovođa",
"Vrtlarski radnik",
"Vrtlarski tehničar",
"Vulkanizer",
"Vunovlačar",
"Web site tеhničаr",
"Zajmodavac",
"Zamjenik direktora inspektorata",
"Zamjenik direktora kazneno - popravnog zavoda",
"Zamjenik direktora uprave",
"Zamjenik direktora upravne organizacije",
"Zamjenik glavnog republičkog tužioca",
"Zamjenik glavnog revizora",
"Zamjenik glavnog revizora Ureda za reviziju FBIH",
"Zamjenik gradonačelnika",
"Zamjenik ministra u Vijeću ministara BiH",
"Zamjenik ministra u Vladi FBiH",
"Zamjenik načelnika",
"Zamjenik pravobranioca BiH",
"Zamjenik predsjedavajućeg /potpredsjednik doma parlamenta /skupštine entiteta",
"Zamjenik predsjedavajućeg Doma naroda Parlamentarne skupštine BiH",
"Zamjenik predsjedavajućeg gradskog vijeća",
"Zamjenik predsjedavajućeg kantonalne skupštine",
"Zamjenik predsjedavajućeg općinskog vijeća",
"Zamjenik predsjedavajućeg Predstavničkog doma Parlamentarne skupštine BiH",
"Zamjenik predsjedavajućeg Vijeća ministara BiH",
"Zapovijednik broda",
"Zapovijednik broda unutrašnje plovidbe",
"Zapovijednik bušaće platforme",
"Zastakljivač",
"Zastakljivač vozila",
"Zastavnik",
"Zastavnik I. klase",
"Zastupnik osiguranja",
"Zastupnik za trgovinu",
"Zastupnik za zapošljavanje",
"Zavarivač",
"Zavarivač plinom",
"Zavarivač za zavarivanje u zaštićenim atmosferama",
"Zavarivač,specijalizirani",
"Zdravstveni inspektor",
"Zemljoradnik",
"Zidar",
"Zidar - fasader - izolater",
"Zidar - fasader - izolater, majstor",
"Zidar dimnjaka",
"Zidar dimnjaka,specijalizirani",
"Zidar i betonirac",
"Zidar i tesar",
"Zidar kamenom",
"Zidar kamenom,specijalizirani",
"Zidar šamoter",
"Zidar šamoter,specijalizirani",
"Zidar za popločavanje trotoara i ulica",
"Zidar za spomenike od kamena",
"Zidar, majstor",
"Zidarski poslovođa",
"Zidarski radnik",
"Zlatar",
"Zlatar - draguljar",
"Zlatarski poslovođa",
"Zoolog",
"Zoološki tehničar",
"Zubotehničar",
"Zubozdravstveni asistent",
"Zvonar",
"Željeznički otpravnik",
"Željeznički robno-putnički blagajnik",
"Željeznički transportni radnik",
"Željezničko - saobraćajni tehničar",
"Živoder",
"Žongler",
"Župni asistent",
"Župnik",
]
| Provider |
python | spack__spack | lib/spack/spack/vendor/macholib/MachOStandalone.py | {
"start": 328,
"end": 374
} | class ____(MissingMachO):
pass
| ExcludedMachO |
python | sympy__sympy | sympy/functions/special/error_functions.py | {
"start": 19347,
"end": 23295
} | class ____(DefinedFunction):
r"""
Two-argument error function.
Explanation
===========
This function is defined as:
.. math ::
\mathrm{erf2}(x, y) = \frac{2}{\sqrt{\pi}} \int_x^y e^{-t^2} \mathrm{d}t
Examples
========
>>> from sympy import oo, erf2
>>> from sympy.abc import x, y
Several special values are known:
>>> erf2(0, 0)
0
>>> erf2(x, x)
0
>>> erf2(x, oo)
1 - erf(x)
>>> erf2(x, -oo)
-erf(x) - 1
>>> erf2(oo, y)
erf(y) - 1
>>> erf2(-oo, y)
erf(y) + 1
In general one can pull out factors of -1:
>>> erf2(-x, -y)
-erf2(x, y)
The error function obeys the mirror symmetry:
>>> from sympy import conjugate
>>> conjugate(erf2(x, y))
erf2(conjugate(x), conjugate(y))
Differentiation with respect to $x$, $y$ is supported:
>>> from sympy import diff
>>> diff(erf2(x, y), x)
-2*exp(-x**2)/sqrt(pi)
>>> diff(erf2(x, y), y)
2*exp(-y**2)/sqrt(pi)
See Also
========
erf: Gaussian error function.
erfc: Complementary error function.
erfi: Imaginary error function.
erfinv: Inverse error function.
erfcinv: Inverse Complementary error function.
erf2inv: Inverse two-argument error function.
References
==========
.. [1] https://functions.wolfram.com/GammaBetaErf/Erf2/
"""
def fdiff(self, argindex):
x, y = self.args
if argindex == 1:
return -2*exp(-x**2)/sqrt(pi)
elif argindex == 2:
return 2*exp(-y**2)/sqrt(pi)
else:
raise ArgumentIndexError(self, argindex)
@classmethod
def eval(cls, x, y):
chk = (S.Infinity, S.NegativeInfinity, S.Zero)
if x is S.NaN or y is S.NaN:
return S.NaN
elif x == y:
return S.Zero
elif x in chk or y in chk:
return erf(y) - erf(x)
if isinstance(y, erf2inv) and y.args[0] == x:
return y.args[1]
if x.is_zero or y.is_zero or x.is_extended_real and x.is_infinite or \
y.is_extended_real and y.is_infinite:
return erf(y) - erf(x)
#Try to pull out -1 factor
sign_x = x.could_extract_minus_sign()
sign_y = y.could_extract_minus_sign()
if (sign_x and sign_y):
return -cls(-x, -y)
elif (sign_x or sign_y):
return erf(y)-erf(x)
def _eval_conjugate(self):
return self.func(self.args[0].conjugate(), self.args[1].conjugate())
def _eval_is_extended_real(self):
return self.args[0].is_extended_real and self.args[1].is_extended_real
def _eval_rewrite_as_erf(self, x, y, **kwargs):
return erf(y) - erf(x)
def _eval_rewrite_as_erfc(self, x, y, **kwargs):
return erfc(x) - erfc(y)
def _eval_rewrite_as_erfi(self, x, y, **kwargs):
return I*(erfi(I*x)-erfi(I*y))
def _eval_rewrite_as_fresnels(self, x, y, **kwargs):
return erf(y).rewrite(fresnels) - erf(x).rewrite(fresnels)
def _eval_rewrite_as_fresnelc(self, x, y, **kwargs):
return erf(y).rewrite(fresnelc) - erf(x).rewrite(fresnelc)
def _eval_rewrite_as_meijerg(self, x, y, **kwargs):
return erf(y).rewrite(meijerg) - erf(x).rewrite(meijerg)
def _eval_rewrite_as_hyper(self, x, y, **kwargs):
return erf(y).rewrite(hyper) - erf(x).rewrite(hyper)
def _eval_rewrite_as_uppergamma(self, x, y, **kwargs):
from sympy.functions.special.gamma_functions import uppergamma
return (sqrt(y**2)/y*(S.One - uppergamma(S.Half, y**2)/sqrt(pi)) -
sqrt(x**2)/x*(S.One - uppergamma(S.Half, x**2)/sqrt(pi)))
def _eval_rewrite_as_expint(self, x, y, **kwargs):
return erf(y).rewrite(expint) - erf(x).rewrite(expint)
def _eval_expand_func(self, **hints):
return self.rewrite(erf)
def _eval_is_zero(self):
return is_eq(*self.args)
| erf2 |
python | celery__celery | t/unit/tasks/test_tasks.py | {
"start": 30263,
"end": 53923
} | class ____(TasksCase):
def now(self):
return self.app.now()
def test_typing(self):
@self.app.task()
def add(x, y, kw=1):
pass
with pytest.raises(TypeError):
add.delay(1)
with pytest.raises(TypeError):
add.delay(1, kw=2)
with pytest.raises(TypeError):
add.delay(1, 2, foobar=3)
add.delay(2, 2)
def test_shadow_name(self):
def shadow_name(task, args, kwargs, options):
return 'fooxyz'
@self.app.task(shadow_name=shadow_name)
def shadowed():
pass
old_send_task = self.app.send_task
self.app.send_task = Mock()
shadowed.delay()
self.app.send_task.assert_called_once_with(ANY, ANY, ANY,
compression=ANY,
delivery_mode=ANY,
exchange=ANY,
expires=ANY,
immediate=ANY,
link=ANY,
link_error=ANY,
mandatory=ANY,
priority=ANY,
producer=ANY,
queue=ANY,
result_cls=ANY,
routing_key=ANY,
serializer=ANY,
soft_time_limit=ANY,
task_id=ANY,
task_type=ANY,
time_limit=ANY,
shadow='fooxyz',
ignore_result=False)
self.app.send_task = old_send_task
def test_inherit_parent_priority_child_task(self):
self.app.conf.task_inherit_parent_priority = True
self.app.producer_or_acquire = Mock()
self.app.producer_or_acquire.attach_mock(
ContextMock(serializer='json'), 'return_value')
self.app.amqp.send_task_message = Mock(name="send_task_message")
self.task_which_calls_other_task.apply(args=[])
self.app.amqp.send_task_message.assert_called_with(
ANY, 't.unit.tasks.test_tasks.task_called_by_other_task',
ANY, priority=5, queue=ANY, serializer=ANY)
def test_typing__disabled(self):
@self.app.task(typing=False)
def add(x, y, kw=1):
pass
add.delay(1)
add.delay(1, kw=2)
add.delay(1, 2, foobar=3)
def test_typing__disabled_by_app(self):
with self.Celery(set_as_current=False, strict_typing=False) as app:
@app.task()
def add(x, y, kw=1):
pass
assert not add.typing
add.delay(1)
add.delay(1, kw=2)
add.delay(1, 2, foobar=3)
@pytest.mark.usefixtures('depends_on_current_app')
def test_unpickle_task(self):
import pickle
@self.app.task(shared=True)
def xxx():
pass
assert pickle.loads(pickle.dumps(xxx)) is xxx.app.tasks[xxx.name]
@patch('celery.app.task.current_app')
@pytest.mark.usefixtures('depends_on_current_app')
def test_bind__no_app(self, current_app):
class XTask(Task):
_app = None
XTask._app = None
XTask.__bound__ = False
XTask.bind = Mock(name='bind')
assert XTask.app is current_app
XTask.bind.assert_called_with(current_app)
def test_reprtask__no_fmt(self):
assert _reprtask(self.mytask)
def test_AsyncResult(self):
task_id = uuid()
result = self.retry_task.AsyncResult(task_id)
assert result.backend == self.retry_task.backend
assert result.id == task_id
def assert_next_task_data_equal(self, consumer, presult, task_name,
test_eta=False, test_expires=False,
properties=None, headers=None, **kwargs):
next_task = consumer.queues[0].get(accept=['pickle', 'json'])
task_properties = next_task.properties
task_headers = next_task.headers
task_body = next_task.decode()
task_args, task_kwargs, embed = task_body
assert task_headers['id'] == presult.id
assert task_headers['task'] == task_name
if test_eta:
assert isinstance(task_headers.get('eta'), str)
to_datetime = datetime.fromisoformat(task_headers.get('eta'))
assert isinstance(to_datetime, datetime)
if test_expires:
assert isinstance(task_headers.get('expires'), str)
to_datetime = datetime.fromisoformat(task_headers.get('expires'))
assert isinstance(to_datetime, datetime)
properties = properties or {}
for arg_name, arg_value in properties.items():
assert task_properties.get(arg_name) == arg_value
headers = headers or {}
for arg_name, arg_value in headers.items():
assert task_headers.get(arg_name) == arg_value
for arg_name, arg_value in kwargs.items():
assert task_kwargs.get(arg_name) == arg_value
def test_incomplete_task_cls(self):
class IncompleteTask(Task):
app = self.app
name = 'c.unittest.t.itask'
with pytest.raises(NotImplementedError):
IncompleteTask().run()
def test_task_kwargs_must_be_dictionary(self):
with pytest.raises(TypeError):
self.increment_counter.apply_async([], 'str')
def test_task_args_must_be_list(self):
with pytest.raises(TypeError):
self.increment_counter.apply_async('s', {})
def test_regular_task(self):
assert isinstance(self.mytask, Task)
assert self.mytask.run()
assert callable(self.mytask)
assert self.mytask(), 'Task class runs run() when called'
with self.app.connection_or_acquire() as conn:
consumer = self.app.amqp.TaskConsumer(conn)
with pytest.raises(NotImplementedError):
consumer.receive('foo', 'foo')
consumer.purge()
assert consumer.queues[0].get() is None
self.app.amqp.TaskConsumer(conn, queues=[Queue('foo')])
# Without arguments.
presult = self.mytask.delay()
self.assert_next_task_data_equal(
consumer, presult, self.mytask.name)
# With arguments.
presult2 = self.mytask.apply_async(
kwargs={'name': 'George Costanza'},
)
self.assert_next_task_data_equal(
consumer, presult2, self.mytask.name, name='George Costanza',
)
# send_task
sresult = self.app.send_task(self.mytask.name,
kwargs={'name': 'Elaine M. Benes'})
self.assert_next_task_data_equal(
consumer, sresult, self.mytask.name, name='Elaine M. Benes',
)
# With ETA, absolute expires.
presult2 = self.mytask.apply_async(
kwargs={'name': 'George Costanza'},
eta=self.now() + timedelta(days=1),
expires=self.now() + timedelta(days=2),
)
self.assert_next_task_data_equal(
consumer, presult2, self.mytask.name,
name='George Costanza', test_eta=True, test_expires=True,
)
# With ETA, absolute expires without timezone.
presult2 = self.mytask.apply_async(
kwargs={'name': 'George Constanza'},
eta=self.now() + timedelta(days=1),
expires=(self.now() + timedelta(hours=2)).replace(tzinfo=None),
)
self.assert_next_task_data_equal(
consumer, presult2, self.mytask.name,
name='George Constanza', test_eta=True, test_expires=True,
)
# With ETA, absolute expires in the past.
presult2 = self.mytask.apply_async(
kwargs={'name': 'George Costanza'},
eta=self.now() + timedelta(days=1),
expires=self.now() - timedelta(days=2),
)
self.assert_next_task_data_equal(
consumer, presult2, self.mytask.name,
name='George Costanza', test_eta=True, test_expires=True,
)
# With ETA, relative expires.
presult2 = self.mytask.apply_async(
kwargs={'name': 'George Costanza'},
eta=self.now() + timedelta(days=1),
expires=2 * 24 * 60 * 60,
)
self.assert_next_task_data_equal(
consumer, presult2, self.mytask.name,
name='George Costanza', test_eta=True, test_expires=True,
)
# With countdown.
presult2 = self.mytask.apply_async(
kwargs={'name': 'George Costanza'}, countdown=10, expires=12,
)
self.assert_next_task_data_equal(
consumer, presult2, self.mytask.name,
name='George Costanza', test_eta=True, test_expires=True,
)
# With ETA, absolute expires in the past in ISO format.
presult2 = self.mytask.apply_async(
kwargs={'name': 'George Costanza'},
eta=self.now() + timedelta(days=1),
expires=self.now() - timedelta(days=2),
)
self.assert_next_task_data_equal(
consumer, presult2, self.mytask.name,
name='George Costanza', test_eta=True, test_expires=True,
)
# Default argsrepr/kwargsrepr behavior
presult2 = self.mytask.apply_async(
args=('spam',), kwargs={'name': 'Jerry Seinfeld'}
)
self.assert_next_task_data_equal(
consumer, presult2, self.mytask.name,
headers={'argsrepr': "('spam',)",
'kwargsrepr': "{'name': 'Jerry Seinfeld'}"},
)
# With argsrepr/kwargsrepr
presult2 = self.mytask.apply_async(
args=('secret',), argsrepr="'***'",
kwargs={'password': 'foo'}, kwargsrepr="{'password': '***'}",
)
self.assert_next_task_data_equal(
consumer, presult2, self.mytask.name,
headers={'argsrepr': "'***'",
'kwargsrepr': "{'password': '***'}"},
)
# Discarding all tasks.
consumer.purge()
self.mytask.apply_async()
assert consumer.purge() == 1
assert consumer.queues[0].get() is None
assert not presult.successful()
self.mytask.backend.mark_as_done(presult.id, result=None)
assert presult.successful()
def test_send_event(self):
mytask = self.mytask._get_current_object()
mytask.app.events = Mock(name='events')
mytask.app.events.attach_mock(ContextMock(), 'default_dispatcher')
mytask.request.id = 'fb'
mytask.send_event('task-foo', id=3122)
mytask.app.events.default_dispatcher().send.assert_called_with(
'task-foo', uuid='fb', id=3122,
retry=True, retry_policy=self.app.conf.task_publish_retry_policy)
@pytest.mark.usefixtures('depends_on_current_app')
def test_on_replace(self):
class CustomStampingVisitor(StampingVisitor):
def on_signature(self, sig, **headers) -> dict:
return {'header': 'value'}
class MyTask(Task):
def on_replace(self, sig):
sig.stamp(CustomStampingVisitor())
return super().on_replace(sig)
mytask = self.app.task(shared=False, base=MyTask)(return_True)
sig1 = signature('sig1')
with pytest.raises(Ignore):
mytask.replace(sig1)
assert sig1.options['header'] == 'value'
def test_replace(self):
sig1 = MagicMock(name='sig1')
sig1.options = {}
self.mytask.request.id = sentinel.request_id
with pytest.raises(Ignore):
self.mytask.replace(sig1)
sig1.freeze.assert_called_once_with(self.mytask.request.id)
sig1.set.assert_called_once_with(replaced_task_nesting=1,
chord=ANY,
group_id=ANY,
group_index=ANY,
root_id=ANY)
def test_replace_with_chord(self):
sig1 = Mock(name='sig1')
sig1.options = {'chord': None}
with pytest.raises(ImproperlyConfigured):
self.mytask.replace(sig1)
def test_replace_callback(self):
c = group([self.mytask.s()], app=self.app)
c.freeze = Mock(name='freeze')
c.delay = Mock(name='delay')
self.mytask.request.id = 'id'
self.mytask.request.group = 'group'
self.mytask.request.root_id = 'root_id'
self.mytask.request.callbacks = callbacks = 'callbacks'
self.mytask.request.errbacks = errbacks = 'errbacks'
# Replacement groups get uplifted to chords so that we can accumulate
# the results and link call/errbacks - patch the appropriate `chord`
# methods so we can validate this behaviour
with patch(
"celery.canvas.chord.link"
) as mock_chord_link, patch(
"celery.canvas.chord.link_error"
) as mock_chord_link_error:
with pytest.raises(Ignore):
self.mytask.replace(c)
# Confirm that the call/errbacks on the original signature are linked
# to the replacement signature as expected
mock_chord_link.assert_called_once_with(callbacks)
mock_chord_link_error.assert_called_once_with(errbacks)
def test_replace_group(self):
c = group([self.mytask.s()], app=self.app)
c.freeze = Mock(name='freeze')
c.delay = Mock(name='delay')
self.mytask.request.id = 'id'
self.mytask.request.group = 'group'
self.mytask.request.root_id = 'root_id',
with pytest.raises(Ignore):
self.mytask.replace(c)
def test_replace_chain(self):
c = chain([self.mytask.si(), self.mytask.si()], app=self.app)
c.freeze = Mock(name='freeze')
c.delay = Mock(name='delay')
self.mytask.request.id = 'id'
self.mytask.request.chain = c
with pytest.raises(Ignore):
self.mytask.replace(c)
def test_replace_run(self):
with pytest.raises(Ignore):
self.task_replaced_by_other_task.run()
def test_replace_run_with_autoretry(self):
with pytest.raises(Ignore):
self.task_replaced_by_other_task_with_autoretry.run()
def test_replace_delay(self):
res = self.task_replaced_by_other_task.delay()
assert isinstance(res, AsyncResult)
def test_replace_apply(self):
res = self.task_replaced_by_other_task.apply()
assert isinstance(res, EagerResult)
assert res.get() == "replaced"
def test_add_trail__no_trail(self):
mytask = self.increment_counter._get_current_object()
mytask.trail = False
mytask.add_trail('foo')
def test_repr_v2_compat(self):
self.mytask.__v2_compat__ = True
assert 'v2 compatible' in repr(self.mytask)
def test_context_get(self):
self.mytask.push_request()
try:
request = self.mytask.request
request.foo = 32
assert request.get('foo') == 32
assert request.get('bar', 36) == 36
request.clear()
finally:
self.mytask.pop_request()
def test_annotate(self):
with patch('celery.app.task.resolve_all_annotations') as anno:
anno.return_value = [{'FOO': 'BAR'}]
@self.app.task(shared=False)
def task():
pass
task.annotate()
assert task.FOO == 'BAR'
def test_after_return(self):
self.mytask.push_request()
try:
self.mytask.request.chord = self.mytask.s()
self.mytask.after_return('SUCCESS', 1.0, 'foobar', (), {}, None)
self.mytask.request.clear()
finally:
self.mytask.pop_request()
def test_update_state(self):
@self.app.task(shared=False)
def yyy():
pass
yyy.push_request()
try:
tid = uuid()
# update_state should accept arbitrary kwargs, which are passed to
# the backend store_result method
yyy.update_state(tid, 'FROBULATING', {'fooz': 'baaz'},
arbitrary_kwarg=None)
assert yyy.AsyncResult(tid).status == 'FROBULATING'
assert yyy.AsyncResult(tid).result == {'fooz': 'baaz'}
yyy.request.id = tid
yyy.update_state(state='FROBUZATING', meta={'fooz': 'baaz'})
assert yyy.AsyncResult(tid).status == 'FROBUZATING'
assert yyy.AsyncResult(tid).result == {'fooz': 'baaz'}
finally:
yyy.pop_request()
def test_update_state_passes_request_to_backend(self):
backend = Mock()
@self.app.task(shared=False, backend=backend)
def ttt():
pass
ttt.push_request()
tid = uuid()
ttt.update_state(tid, 'SHRIMMING', {'foo': 'bar'})
backend.store_result.assert_called_once_with(
tid, {'foo': 'bar'}, 'SHRIMMING', request=ttt.request
)
def test_repr(self):
@self.app.task(shared=False)
def task_test_repr():
pass
assert 'task_test_repr' in repr(task_test_repr)
def test_has___name__(self):
@self.app.task(shared=False)
def yyy2():
pass
assert yyy2.__name__
def test_default_priority(self):
@self.app.task(shared=False)
def yyy3():
pass
@self.app.task(shared=False, priority=66)
def yyy4():
pass
@self.app.task(shared=False, bind=True, base=TaskWithPriority)
def yyy5(self):
pass
self.app.conf.task_default_priority = 42
old_send_task = self.app.send_task
self.app.send_task = Mock()
yyy3.delay()
self.app.send_task.assert_called_once_with(ANY, ANY, ANY,
compression=ANY,
delivery_mode=ANY,
exchange=ANY,
expires=ANY,
immediate=ANY,
link=ANY,
link_error=ANY,
mandatory=ANY,
priority=42,
producer=ANY,
queue=ANY,
result_cls=ANY,
routing_key=ANY,
serializer=ANY,
soft_time_limit=ANY,
task_id=ANY,
task_type=ANY,
time_limit=ANY,
shadow=None,
ignore_result=False)
self.app.send_task = Mock()
yyy4.delay()
self.app.send_task.assert_called_once_with(ANY, ANY, ANY,
compression=ANY,
delivery_mode=ANY,
exchange=ANY,
expires=ANY,
immediate=ANY,
link=ANY,
link_error=ANY,
mandatory=ANY,
priority=66,
producer=ANY,
queue=ANY,
result_cls=ANY,
routing_key=ANY,
serializer=ANY,
soft_time_limit=ANY,
task_id=ANY,
task_type=ANY,
time_limit=ANY,
shadow=None,
ignore_result=False)
self.app.send_task = Mock()
yyy5.delay()
self.app.send_task.assert_called_once_with(ANY, ANY, ANY,
compression=ANY,
delivery_mode=ANY,
exchange=ANY,
expires=ANY,
immediate=ANY,
link=ANY,
link_error=ANY,
mandatory=ANY,
priority=10,
producer=ANY,
queue=ANY,
result_cls=ANY,
routing_key=ANY,
serializer=ANY,
soft_time_limit=ANY,
task_id=ANY,
task_type=ANY,
time_limit=ANY,
shadow=None,
ignore_result=False)
self.app.send_task = old_send_task
def test_soft_time_limit_failure(self):
@self.app.task(soft_time_limit=5, time_limit=3)
def yyy():
pass
try:
yyy_result = yyy.apply_async()
yyy_result.get(timeout=5)
assert yyy_result.state == 'FAILURE'
except ValueError as e:
assert str(e) == 'soft_time_limit must be less than or equal to time_limit'
| test_tasks |
python | openai__openai-python | src/openai/types/evals/run_create_params.py | {
"start": 12557,
"end": 13579
} | class ____(TypedDict, total=False):
source: Required[DataSourceCreateEvalResponsesRunDataSourceSource]
"""Determines what populates the `item` namespace in this run's data source."""
type: Required[Literal["responses"]]
"""The type of run data source. Always `responses`."""
input_messages: DataSourceCreateEvalResponsesRunDataSourceInputMessages
"""Used when sampling from a model.
Dictates the structure of the messages passed into the model. Can either be a
reference to a prebuilt trajectory (ie, `item.input_trajectory`), or a template
with variable references to the `item` namespace.
"""
model: str
"""The name of the model to use for generating completions (e.g. "o3-mini")."""
sampling_params: DataSourceCreateEvalResponsesRunDataSourceSamplingParams
DataSource: TypeAlias = Union[
CreateEvalJSONLRunDataSourceParam,
CreateEvalCompletionsRunDataSourceParam,
DataSourceCreateEvalResponsesRunDataSource,
]
| DataSourceCreateEvalResponsesRunDataSource |
python | pypa__setuptools | setuptools/_vendor/jaraco/context.py | {
"start": 5735,
"end": 8312
} | class ____:
"""
A context manager that will catch certain exceptions and provide an
indication they occurred.
>>> with ExceptionTrap() as trap:
... raise Exception()
>>> bool(trap)
True
>>> with ExceptionTrap() as trap:
... pass
>>> bool(trap)
False
>>> with ExceptionTrap(ValueError) as trap:
... raise ValueError("1 + 1 is not 3")
>>> bool(trap)
True
>>> trap.value
ValueError('1 + 1 is not 3')
>>> trap.tb
<traceback object at ...>
>>> with ExceptionTrap(ValueError) as trap:
... raise Exception()
Traceback (most recent call last):
...
Exception
>>> bool(trap)
False
"""
exc_info = None, None, None
def __init__(self, exceptions=(Exception,)):
self.exceptions = exceptions
def __enter__(self):
return self
@property
def type(self):
return self.exc_info[0]
@property
def value(self):
return self.exc_info[1]
@property
def tb(self):
return self.exc_info[2]
def __exit__(self, *exc_info):
type = exc_info[0]
matches = type and issubclass(type, self.exceptions)
if matches:
self.exc_info = exc_info
return matches
def __bool__(self):
return bool(self.type)
def raises(self, func, *, _test=bool):
"""
Wrap func and replace the result with the truth
value of the trap (True if an exception occurred).
First, give the decorator an alias to support Python 3.8
Syntax.
>>> raises = ExceptionTrap(ValueError).raises
Now decorate a function that always fails.
>>> @raises
... def fail():
... raise ValueError('failed')
>>> fail()
True
"""
@functools.wraps(func)
def wrapper(*args, **kwargs):
with ExceptionTrap(self.exceptions) as trap:
func(*args, **kwargs)
return _test(trap)
return wrapper
def passes(self, func):
"""
Wrap func and replace the result with the truth
value of the trap (True if no exception).
First, give the decorator an alias to support Python 3.8
Syntax.
>>> passes = ExceptionTrap(ValueError).passes
Now decorate a function that always fails.
>>> @passes
... def fail():
... raise ValueError('failed')
>>> fail()
False
"""
return self.raises(func, _test=operator.not_)
| ExceptionTrap |
python | huggingface__transformers | src/transformers/integrations/integration_utils.py | {
"start": 25646,
"end": 26419
} | class ____(str, Enum):
"""Enum of possible log model values in W&B."""
CHECKPOINT = "checkpoint"
END = "end"
FALSE = "false"
@property
def is_enabled(self) -> bool:
"""Check if the value corresponds to a state where the `WANDB_LOG_MODEL` setting is enabled."""
return self in (WandbLogModel.CHECKPOINT, WandbLogModel.END)
@classmethod
def _missing_(cls, value: Any) -> "WandbLogModel":
if not isinstance(value, str):
raise TypeError(f"Expecting to have a string `WANDB_LOG_MODEL` setting, but got {type(value)}")
logger.warning(
f"Received unrecognized `WANDB_LOG_MODEL` setting value={value}; so disabling `WANDB_LOG_MODEL`"
)
return WandbLogModel.FALSE
| WandbLogModel |
python | ray-project__ray | python/ray/train/lightgbm/v2.py | {
"start": 354,
"end": 5714
} | class ____(DataParallelTrainer):
"""A Trainer for distributed data-parallel LightGBM training.
Example
-------
.. testcode::
:skipif: True
import lightgbm as lgb
import ray.data
import ray.train
from ray.train.lightgbm import RayTrainReportCallback, LightGBMTrainer
def train_fn_per_worker(config: dict):
# (Optional) Add logic to resume training state from a checkpoint.
# ray.train.get_checkpoint()
# 1. Get the dataset shard for the worker and convert to a `lgb.Dataset`
train_ds_iter, eval_ds_iter = (
ray.train.get_dataset_shard("train"),
ray.train.get_dataset_shard("validation"),
)
train_ds, eval_ds = train_ds_iter.materialize(), eval_ds_iter.materialize()
train_df, eval_df = train_ds.to_pandas(), eval_ds.to_pandas()
train_X, train_y = train_df.drop("y", axis=1), train_df["y"]
eval_X, eval_y = eval_df.drop("y", axis=1), eval_df["y"]
train_set = lgb.Dataset(train_X, label=train_y)
eval_set = lgb.Dataset(eval_X, label=eval_y)
# 2. Run distributed data-parallel training.
# `get_network_params` sets up the necessary configurations for LightGBM
# to set up the data parallel training worker group on your Ray cluster.
params = {
"objective": "regression",
# Adding the line below is the only change needed
# for your `lgb.train` call!
**ray.train.lightgbm.get_network_params(),
}
lgb.train(
params,
train_set,
valid_sets=[eval_set],
valid_names=["eval"],
callbacks=[RayTrainReportCallback()],
)
train_ds = ray.data.from_items([{"x": x, "y": x + 1} for x in range(32)])
eval_ds = ray.data.from_items(
[{"x": x, "y": x + 1} for x in range(32, 32 + 16)]
)
trainer = LightGBMTrainer(
train_fn_per_worker,
datasets={"train": train_ds, "validation": eval_ds},
scaling_config=ray.train.ScalingConfig(num_workers=4),
)
result = trainer.fit()
booster = RayTrainReportCallback.get_model(result.checkpoint)
Args:
train_loop_per_worker: The training function to execute on each worker.
This function can either take in zero arguments or a single ``Dict``
argument which is set by defining ``train_loop_config``.
Within this function you can use any of the
:ref:`Ray Train Loop utilities <train-loop-api>`.
train_loop_config: A configuration ``Dict`` to pass in as an argument to
``train_loop_per_worker``.
This is typically used for specifying hyperparameters.
lightgbm_config: The configuration for setting up the distributed lightgbm
backend. See :class:`~ray.train.lightgbm.LightGBMConfig` for more info.
datasets: The Ray Datasets to use for training and validation.
dataset_config: The configuration for ingesting the input ``datasets``.
By default, all the Ray Dataset are split equally across workers.
See :class:`~ray.train.DataConfig` for more details.
scaling_config: The configuration for how to scale data parallel training.
``num_workers`` determines how many Python processes are used for training,
and ``use_gpu`` determines whether or not each process should use GPUs.
See :class:`~ray.train.ScalingConfig` for more info.
run_config: The configuration for the execution of the training run.
See :class:`~ray.train.RunConfig` for more info.
resume_from_checkpoint: A checkpoint to resume training from.
This checkpoint can be accessed from within ``train_loop_per_worker``
by calling ``ray.train.get_checkpoint()``.
metadata: Dict that should be made available via
`ray.train.get_context().get_metadata()` and in `checkpoint.get_metadata()`
for checkpoints saved from this Trainer. Must be JSON-serializable.
"""
def __init__(
self,
train_loop_per_worker: Union[Callable[[], None], Callable[[Dict], None]],
*,
train_loop_config: Optional[Dict] = None,
lightgbm_config: Optional[LightGBMConfig] = None,
scaling_config: Optional[ray.train.ScalingConfig] = None,
run_config: Optional[ray.train.RunConfig] = None,
datasets: Optional[Dict[str, GenDataset]] = None,
dataset_config: Optional[ray.train.DataConfig] = None,
metadata: Optional[Dict[str, Any]] = None,
resume_from_checkpoint: Optional[Checkpoint] = None,
):
super(LightGBMTrainer, self).__init__(
train_loop_per_worker=train_loop_per_worker,
train_loop_config=train_loop_config,
backend_config=lightgbm_config or LightGBMConfig(),
scaling_config=scaling_config,
dataset_config=dataset_config,
run_config=run_config,
datasets=datasets,
resume_from_checkpoint=resume_from_checkpoint,
metadata=metadata,
)
| LightGBMTrainer |
python | huggingface__transformers | tests/models/aya_vision/test_modeling_aya_vision.py | {
"start": 1450,
"end": 5197
} | class ____:
def __init__(
self,
parent,
batch_size=3,
seq_length=7,
vision_feature_layer=-1,
downsample_factor=2,
ignore_index=-100,
bos_token_id=0,
eos_token_id=0,
pad_token_id=0,
image_token_index=2,
num_channels=3,
image_size=64,
model_type="aya_vision",
is_training=True,
text_config={
"model_type": "cohere2",
"vocab_size": 99,
"hidden_size": 128,
"intermediate_size": 37,
"num_hidden_layers": 2,
"num_attention_heads": 4,
"output_channels": 64,
"hidden_act": "silu",
"max_position_embeddings": 512,
"tie_word_embeddings": True,
"bos_token_id": 0,
"eos_token_id": 0,
"pad_token_id": 0,
},
vision_config={
"model_type": "siglip_vision_model",
"hidden_size": 32,
"num_hidden_layers": 2,
"num_attention_heads": 4,
"intermediate_size": 128,
"image_size": 64,
"patch_size": 8,
"vision_use_head": False,
},
):
self.parent = parent
self.ignore_index = ignore_index
self.bos_token_id = bos_token_id
self.eos_token_id = eos_token_id
self.pad_token_id = pad_token_id
self.image_token_index = image_token_index
self.model_type = model_type
self.text_config = text_config
self.vision_config = vision_config
self.batch_size = batch_size
self.vision_feature_layer = vision_feature_layer
self.downsample_factor = downsample_factor
self.is_training = is_training
self.num_channels = num_channels
self.image_size = image_size
self.image_seq_length = (image_size // (vision_config["patch_size"] * downsample_factor)) ** 2
self.seq_length = seq_length + self.image_seq_length
self.num_hidden_layers = text_config["num_hidden_layers"]
self.vocab_size = text_config["vocab_size"]
self.hidden_size = text_config["hidden_size"]
self.num_attention_heads = text_config["num_attention_heads"]
def get_config(self):
return AyaVisionConfig(
text_config=self.text_config,
vision_config=self.vision_config,
model_type=self.model_type,
bos_token_id=self.bos_token_id,
eos_token_id=self.eos_token_id,
pad_token_id=self.pad_token_id,
image_token_index=self.image_token_index,
vision_feature_layer=self.vision_feature_layer,
downsample_factor=self.downsample_factor,
)
def prepare_config_and_inputs(self):
config = self.get_config()
pixel_values = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])
return config, pixel_values
def prepare_config_and_inputs_for_common(self):
config_and_inputs = self.prepare_config_and_inputs()
config, pixel_values = config_and_inputs
input_ids = ids_tensor([self.batch_size, self.seq_length], self.vocab_size)
attention_mask = torch.ones(input_ids.shape, dtype=torch.long, device=torch_device)
# input_ids[:, -1] = self.pad_token_id
input_ids[input_ids == self.image_token_index] = self.pad_token_id
input_ids[:, : self.image_seq_length] = self.image_token_index
inputs_dict = {
"pixel_values": pixel_values,
"input_ids": input_ids,
"attention_mask": attention_mask,
}
return config, inputs_dict
@require_torch
| AyaVisionVisionText2TextModelTester |
python | TheAlgorithms__Python | data_structures/arrays/prefix_sum.py | {
"start": 139,
"end": 2571
} | class ____:
def __init__(self, array: list[int]) -> None:
len_array = len(array)
self.prefix_sum = [0] * len_array
if len_array > 0:
self.prefix_sum[0] = array[0]
for i in range(1, len_array):
self.prefix_sum[i] = self.prefix_sum[i - 1] + array[i]
def get_sum(self, start: int, end: int) -> int:
"""
The function returns the sum of array from the start to the end indexes.
Runtime : O(1)
Space: O(1)
>>> PrefixSum([1,2,3]).get_sum(0, 2)
6
>>> PrefixSum([1,2,3]).get_sum(1, 2)
5
>>> PrefixSum([1,2,3]).get_sum(2, 2)
3
>>> PrefixSum([]).get_sum(0, 0)
Traceback (most recent call last):
...
ValueError: The array is empty.
>>> PrefixSum([1,2,3]).get_sum(-1, 2)
Traceback (most recent call last):
...
ValueError: Invalid range specified.
>>> PrefixSum([1,2,3]).get_sum(2, 3)
Traceback (most recent call last):
...
ValueError: Invalid range specified.
>>> PrefixSum([1,2,3]).get_sum(2, 1)
Traceback (most recent call last):
...
ValueError: Invalid range specified.
"""
if not self.prefix_sum:
raise ValueError("The array is empty.")
if start < 0 or end >= len(self.prefix_sum) or start > end:
raise ValueError("Invalid range specified.")
if start == 0:
return self.prefix_sum[end]
return self.prefix_sum[end] - self.prefix_sum[start - 1]
def contains_sum(self, target_sum: int) -> bool:
"""
The function returns True if array contains the target_sum,
False otherwise.
Runtime : O(n)
Space: O(n)
>>> PrefixSum([1,2,3]).contains_sum(6)
True
>>> PrefixSum([1,2,3]).contains_sum(5)
True
>>> PrefixSum([1,2,3]).contains_sum(3)
True
>>> PrefixSum([1,2,3]).contains_sum(4)
False
>>> PrefixSum([1,2,3]).contains_sum(7)
False
>>> PrefixSum([1,-2,3]).contains_sum(2)
True
"""
sums = {0}
for sum_item in self.prefix_sum:
if sum_item - target_sum in sums:
return True
sums.add(sum_item)
return False
if __name__ == "__main__":
import doctest
doctest.testmod()
| PrefixSum |
python | encode__httpx | tests/models/test_responses.py | {
"start": 86,
"end": 30023
} | class ____:
def __iter__(self):
yield b"Hello, "
yield b"world!"
def streaming_body() -> typing.Iterator[bytes]:
yield b"Hello, "
yield b"world!"
async def async_streaming_body() -> typing.AsyncIterator[bytes]:
yield b"Hello, "
yield b"world!"
def autodetect(content):
return chardet.detect(content).get("encoding")
def test_response():
response = httpx.Response(
200,
content=b"Hello, world!",
request=httpx.Request("GET", "https://example.org"),
)
assert response.status_code == 200
assert response.reason_phrase == "OK"
assert response.text == "Hello, world!"
assert response.request.method == "GET"
assert response.request.url == "https://example.org"
assert not response.is_error
def test_response_content():
response = httpx.Response(200, content="Hello, world!")
assert response.status_code == 200
assert response.reason_phrase == "OK"
assert response.text == "Hello, world!"
assert response.headers == {"Content-Length": "13"}
def test_response_text():
response = httpx.Response(200, text="Hello, world!")
assert response.status_code == 200
assert response.reason_phrase == "OK"
assert response.text == "Hello, world!"
assert response.headers == {
"Content-Length": "13",
"Content-Type": "text/plain; charset=utf-8",
}
def test_response_html():
response = httpx.Response(200, html="<html><body>Hello, world!</html></body>")
assert response.status_code == 200
assert response.reason_phrase == "OK"
assert response.text == "<html><body>Hello, world!</html></body>"
assert response.headers == {
"Content-Length": "39",
"Content-Type": "text/html; charset=utf-8",
}
def test_response_json():
response = httpx.Response(200, json={"hello": "world"})
assert response.status_code == 200
assert response.reason_phrase == "OK"
assert str(response.json()) == "{'hello': 'world'}"
assert response.headers == {
"Content-Length": "17",
"Content-Type": "application/json",
}
def test_raise_for_status():
request = httpx.Request("GET", "https://example.org")
# 2xx status codes are not an error.
response = httpx.Response(200, request=request)
response.raise_for_status()
# 1xx status codes are informational responses.
response = httpx.Response(101, request=request)
assert response.is_informational
with pytest.raises(httpx.HTTPStatusError) as exc_info:
response.raise_for_status()
assert str(exc_info.value) == (
"Informational response '101 Switching Protocols' for url 'https://example.org'\n"
"For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/101"
)
# 3xx status codes are redirections.
headers = {"location": "https://other.org"}
response = httpx.Response(303, headers=headers, request=request)
assert response.is_redirect
with pytest.raises(httpx.HTTPStatusError) as exc_info:
response.raise_for_status()
assert str(exc_info.value) == (
"Redirect response '303 See Other' for url 'https://example.org'\n"
"Redirect location: 'https://other.org'\n"
"For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/303"
)
# 4xx status codes are a client error.
response = httpx.Response(403, request=request)
assert response.is_client_error
assert response.is_error
with pytest.raises(httpx.HTTPStatusError) as exc_info:
response.raise_for_status()
assert str(exc_info.value) == (
"Client error '403 Forbidden' for url 'https://example.org'\n"
"For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/403"
)
# 5xx status codes are a server error.
response = httpx.Response(500, request=request)
assert response.is_server_error
assert response.is_error
with pytest.raises(httpx.HTTPStatusError) as exc_info:
response.raise_for_status()
assert str(exc_info.value) == (
"Server error '500 Internal Server Error' for url 'https://example.org'\n"
"For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500"
)
# Calling .raise_for_status without setting a request instance is
# not valid. Should raise a runtime error.
response = httpx.Response(200)
with pytest.raises(RuntimeError):
response.raise_for_status()
def test_response_repr():
response = httpx.Response(
200,
content=b"Hello, world!",
)
assert repr(response) == "<Response [200 OK]>"
def test_response_content_type_encoding():
"""
Use the charset encoding in the Content-Type header if possible.
"""
headers = {"Content-Type": "text-plain; charset=latin-1"}
content = "Latin 1: ÿ".encode("latin-1")
response = httpx.Response(
200,
content=content,
headers=headers,
)
assert response.text == "Latin 1: ÿ"
assert response.encoding == "latin-1"
def test_response_default_to_utf8_encoding():
"""
Default to utf-8 encoding if there is no Content-Type header.
"""
content = "おはようございます。".encode("utf-8")
response = httpx.Response(
200,
content=content,
)
assert response.text == "おはようございます。"
assert response.encoding == "utf-8"
def test_response_fallback_to_utf8_encoding():
"""
Fallback to utf-8 if we get an invalid charset in the Content-Type header.
"""
headers = {"Content-Type": "text-plain; charset=invalid-codec-name"}
content = "おはようございます。".encode("utf-8")
response = httpx.Response(
200,
content=content,
headers=headers,
)
assert response.text == "おはようございます。"
assert response.encoding == "utf-8"
def test_response_no_charset_with_ascii_content():
"""
A response with ascii encoded content should decode correctly,
even with no charset specified.
"""
content = b"Hello, world!"
headers = {"Content-Type": "text/plain"}
response = httpx.Response(
200,
content=content,
headers=headers,
)
assert response.status_code == 200
assert response.encoding == "utf-8"
assert response.text == "Hello, world!"
def test_response_no_charset_with_utf8_content():
"""
A response with UTF-8 encoded content should decode correctly,
even with no charset specified.
"""
content = "Unicode Snowman: ☃".encode("utf-8")
headers = {"Content-Type": "text/plain"}
response = httpx.Response(
200,
content=content,
headers=headers,
)
assert response.text == "Unicode Snowman: ☃"
assert response.encoding == "utf-8"
def test_response_no_charset_with_iso_8859_1_content():
"""
A response with ISO 8859-1 encoded content should decode correctly,
even with no charset specified, if autodetect is enabled.
"""
content = "Accented: Österreich abcdefghijklmnopqrstuzwxyz".encode("iso-8859-1")
headers = {"Content-Type": "text/plain"}
response = httpx.Response(
200, content=content, headers=headers, default_encoding=autodetect
)
assert response.text == "Accented: Österreich abcdefghijklmnopqrstuzwxyz"
assert response.charset_encoding is None
def test_response_no_charset_with_cp_1252_content():
"""
A response with Windows 1252 encoded content should decode correctly,
even with no charset specified, if autodetect is enabled.
"""
content = "Euro Currency: € abcdefghijklmnopqrstuzwxyz".encode("cp1252")
headers = {"Content-Type": "text/plain"}
response = httpx.Response(
200, content=content, headers=headers, default_encoding=autodetect
)
assert response.text == "Euro Currency: € abcdefghijklmnopqrstuzwxyz"
assert response.charset_encoding is None
def test_response_non_text_encoding():
"""
Default to attempting utf-8 encoding for non-text content-type headers.
"""
headers = {"Content-Type": "image/png"}
response = httpx.Response(
200,
content=b"xyz",
headers=headers,
)
assert response.text == "xyz"
assert response.encoding == "utf-8"
def test_response_set_explicit_encoding():
headers = {
"Content-Type": "text-plain; charset=utf-8"
} # Deliberately incorrect charset
response = httpx.Response(
200,
content="Latin 1: ÿ".encode("latin-1"),
headers=headers,
)
response.encoding = "latin-1"
assert response.text == "Latin 1: ÿ"
assert response.encoding == "latin-1"
def test_response_force_encoding():
response = httpx.Response(
200,
content="Snowman: ☃".encode("utf-8"),
)
response.encoding = "iso-8859-1"
assert response.status_code == 200
assert response.reason_phrase == "OK"
assert response.text == "Snowman: â\x98\x83"
assert response.encoding == "iso-8859-1"
def test_response_force_encoding_after_text_accessed():
response = httpx.Response(
200,
content=b"Hello, world!",
)
assert response.status_code == 200
assert response.reason_phrase == "OK"
assert response.text == "Hello, world!"
assert response.encoding == "utf-8"
with pytest.raises(ValueError):
response.encoding = "UTF8"
with pytest.raises(ValueError):
response.encoding = "iso-8859-1"
def test_read():
response = httpx.Response(
200,
content=b"Hello, world!",
)
assert response.status_code == 200
assert response.text == "Hello, world!"
assert response.encoding == "utf-8"
assert response.is_closed
content = response.read()
assert content == b"Hello, world!"
assert response.content == b"Hello, world!"
assert response.is_closed
def test_empty_read():
response = httpx.Response(200)
assert response.status_code == 200
assert response.text == ""
assert response.encoding == "utf-8"
assert response.is_closed
content = response.read()
assert content == b""
assert response.content == b""
assert response.is_closed
@pytest.mark.anyio
async def test_aread():
response = httpx.Response(
200,
content=b"Hello, world!",
)
assert response.status_code == 200
assert response.text == "Hello, world!"
assert response.encoding == "utf-8"
assert response.is_closed
content = await response.aread()
assert content == b"Hello, world!"
assert response.content == b"Hello, world!"
assert response.is_closed
@pytest.mark.anyio
async def test_empty_aread():
response = httpx.Response(200)
assert response.status_code == 200
assert response.text == ""
assert response.encoding == "utf-8"
assert response.is_closed
content = await response.aread()
assert content == b""
assert response.content == b""
assert response.is_closed
def test_iter_raw():
response = httpx.Response(
200,
content=streaming_body(),
)
raw = b""
for part in response.iter_raw():
raw += part
assert raw == b"Hello, world!"
def test_iter_raw_with_chunksize():
response = httpx.Response(200, content=streaming_body())
parts = list(response.iter_raw(chunk_size=5))
assert parts == [b"Hello", b", wor", b"ld!"]
response = httpx.Response(200, content=streaming_body())
parts = list(response.iter_raw(chunk_size=7))
assert parts == [b"Hello, ", b"world!"]
response = httpx.Response(200, content=streaming_body())
parts = list(response.iter_raw(chunk_size=13))
assert parts == [b"Hello, world!"]
response = httpx.Response(200, content=streaming_body())
parts = list(response.iter_raw(chunk_size=20))
assert parts == [b"Hello, world!"]
def test_iter_raw_doesnt_return_empty_chunks():
def streaming_body_with_empty_chunks() -> typing.Iterator[bytes]:
yield b"Hello, "
yield b""
yield b"world!"
yield b""
response = httpx.Response(200, content=streaming_body_with_empty_chunks())
parts = list(response.iter_raw())
assert parts == [b"Hello, ", b"world!"]
def test_iter_raw_on_iterable():
response = httpx.Response(
200,
content=StreamingBody(),
)
raw = b""
for part in response.iter_raw():
raw += part
assert raw == b"Hello, world!"
def test_iter_raw_on_async():
response = httpx.Response(
200,
content=async_streaming_body(),
)
with pytest.raises(RuntimeError):
list(response.iter_raw())
def test_close_on_async():
response = httpx.Response(
200,
content=async_streaming_body(),
)
with pytest.raises(RuntimeError):
response.close()
def test_iter_raw_increments_updates_counter():
response = httpx.Response(200, content=streaming_body())
num_downloaded = response.num_bytes_downloaded
for part in response.iter_raw():
assert len(part) == (response.num_bytes_downloaded - num_downloaded)
num_downloaded = response.num_bytes_downloaded
@pytest.mark.anyio
async def test_aiter_raw():
response = httpx.Response(200, content=async_streaming_body())
raw = b""
async for part in response.aiter_raw():
raw += part
assert raw == b"Hello, world!"
@pytest.mark.anyio
async def test_aiter_raw_with_chunksize():
response = httpx.Response(200, content=async_streaming_body())
parts = [part async for part in response.aiter_raw(chunk_size=5)]
assert parts == [b"Hello", b", wor", b"ld!"]
response = httpx.Response(200, content=async_streaming_body())
parts = [part async for part in response.aiter_raw(chunk_size=13)]
assert parts == [b"Hello, world!"]
response = httpx.Response(200, content=async_streaming_body())
parts = [part async for part in response.aiter_raw(chunk_size=20)]
assert parts == [b"Hello, world!"]
@pytest.mark.anyio
async def test_aiter_raw_on_sync():
response = httpx.Response(
200,
content=streaming_body(),
)
with pytest.raises(RuntimeError):
[part async for part in response.aiter_raw()]
@pytest.mark.anyio
async def test_aclose_on_sync():
response = httpx.Response(
200,
content=streaming_body(),
)
with pytest.raises(RuntimeError):
await response.aclose()
@pytest.mark.anyio
async def test_aiter_raw_increments_updates_counter():
response = httpx.Response(200, content=async_streaming_body())
num_downloaded = response.num_bytes_downloaded
async for part in response.aiter_raw():
assert len(part) == (response.num_bytes_downloaded - num_downloaded)
num_downloaded = response.num_bytes_downloaded
def test_iter_bytes():
response = httpx.Response(200, content=b"Hello, world!")
content = b""
for part in response.iter_bytes():
content += part
assert content == b"Hello, world!"
def test_iter_bytes_with_chunk_size():
response = httpx.Response(200, content=streaming_body())
parts = list(response.iter_bytes(chunk_size=5))
assert parts == [b"Hello", b", wor", b"ld!"]
response = httpx.Response(200, content=streaming_body())
parts = list(response.iter_bytes(chunk_size=13))
assert parts == [b"Hello, world!"]
response = httpx.Response(200, content=streaming_body())
parts = list(response.iter_bytes(chunk_size=20))
assert parts == [b"Hello, world!"]
def test_iter_bytes_with_empty_response():
response = httpx.Response(200, content=b"")
parts = list(response.iter_bytes())
assert parts == []
def test_iter_bytes_doesnt_return_empty_chunks():
def streaming_body_with_empty_chunks() -> typing.Iterator[bytes]:
yield b"Hello, "
yield b""
yield b"world!"
yield b""
response = httpx.Response(200, content=streaming_body_with_empty_chunks())
parts = list(response.iter_bytes())
assert parts == [b"Hello, ", b"world!"]
@pytest.mark.anyio
async def test_aiter_bytes():
response = httpx.Response(
200,
content=b"Hello, world!",
)
content = b""
async for part in response.aiter_bytes():
content += part
assert content == b"Hello, world!"
@pytest.mark.anyio
async def test_aiter_bytes_with_chunk_size():
response = httpx.Response(200, content=async_streaming_body())
parts = [part async for part in response.aiter_bytes(chunk_size=5)]
assert parts == [b"Hello", b", wor", b"ld!"]
response = httpx.Response(200, content=async_streaming_body())
parts = [part async for part in response.aiter_bytes(chunk_size=13)]
assert parts == [b"Hello, world!"]
response = httpx.Response(200, content=async_streaming_body())
parts = [part async for part in response.aiter_bytes(chunk_size=20)]
assert parts == [b"Hello, world!"]
def test_iter_text():
response = httpx.Response(
200,
content=b"Hello, world!",
)
content = ""
for part in response.iter_text():
content += part
assert content == "Hello, world!"
def test_iter_text_with_chunk_size():
response = httpx.Response(200, content=b"Hello, world!")
parts = list(response.iter_text(chunk_size=5))
assert parts == ["Hello", ", wor", "ld!"]
response = httpx.Response(200, content=b"Hello, world!!")
parts = list(response.iter_text(chunk_size=7))
assert parts == ["Hello, ", "world!!"]
response = httpx.Response(200, content=b"Hello, world!")
parts = list(response.iter_text(chunk_size=7))
assert parts == ["Hello, ", "world!"]
response = httpx.Response(200, content=b"Hello, world!")
parts = list(response.iter_text(chunk_size=13))
assert parts == ["Hello, world!"]
response = httpx.Response(200, content=b"Hello, world!")
parts = list(response.iter_text(chunk_size=20))
assert parts == ["Hello, world!"]
@pytest.mark.anyio
async def test_aiter_text():
response = httpx.Response(
200,
content=b"Hello, world!",
)
content = ""
async for part in response.aiter_text():
content += part
assert content == "Hello, world!"
@pytest.mark.anyio
async def test_aiter_text_with_chunk_size():
response = httpx.Response(200, content=b"Hello, world!")
parts = [part async for part in response.aiter_text(chunk_size=5)]
assert parts == ["Hello", ", wor", "ld!"]
response = httpx.Response(200, content=b"Hello, world!")
parts = [part async for part in response.aiter_text(chunk_size=13)]
assert parts == ["Hello, world!"]
response = httpx.Response(200, content=b"Hello, world!")
parts = [part async for part in response.aiter_text(chunk_size=20)]
assert parts == ["Hello, world!"]
def test_iter_lines():
response = httpx.Response(
200,
content=b"Hello,\nworld!",
)
content = list(response.iter_lines())
assert content == ["Hello,", "world!"]
@pytest.mark.anyio
async def test_aiter_lines():
response = httpx.Response(
200,
content=b"Hello,\nworld!",
)
content = []
async for line in response.aiter_lines():
content.append(line)
assert content == ["Hello,", "world!"]
def test_sync_streaming_response():
response = httpx.Response(
200,
content=streaming_body(),
)
assert response.status_code == 200
assert not response.is_closed
content = response.read()
assert content == b"Hello, world!"
assert response.content == b"Hello, world!"
assert response.is_closed
@pytest.mark.anyio
async def test_async_streaming_response():
response = httpx.Response(
200,
content=async_streaming_body(),
)
assert response.status_code == 200
assert not response.is_closed
content = await response.aread()
assert content == b"Hello, world!"
assert response.content == b"Hello, world!"
assert response.is_closed
def test_cannot_read_after_stream_consumed():
response = httpx.Response(
200,
content=streaming_body(),
)
content = b""
for part in response.iter_bytes():
content += part
with pytest.raises(httpx.StreamConsumed):
response.read()
@pytest.mark.anyio
async def test_cannot_aread_after_stream_consumed():
response = httpx.Response(
200,
content=async_streaming_body(),
)
content = b""
async for part in response.aiter_bytes():
content += part
with pytest.raises(httpx.StreamConsumed):
await response.aread()
def test_cannot_read_after_response_closed():
response = httpx.Response(
200,
content=streaming_body(),
)
response.close()
with pytest.raises(httpx.StreamClosed):
response.read()
@pytest.mark.anyio
async def test_cannot_aread_after_response_closed():
response = httpx.Response(
200,
content=async_streaming_body(),
)
await response.aclose()
with pytest.raises(httpx.StreamClosed):
await response.aread()
@pytest.mark.anyio
async def test_elapsed_not_available_until_closed():
response = httpx.Response(
200,
content=async_streaming_body(),
)
with pytest.raises(RuntimeError):
response.elapsed # noqa: B018
def test_unknown_status_code():
response = httpx.Response(
600,
)
assert response.status_code == 600
assert response.reason_phrase == ""
assert response.text == ""
def test_json_with_specified_encoding():
data = {"greeting": "hello", "recipient": "world"}
content = json.dumps(data).encode("utf-16")
headers = {"Content-Type": "application/json, charset=utf-16"}
response = httpx.Response(
200,
content=content,
headers=headers,
)
assert response.json() == data
def test_json_with_options():
data = {"greeting": "hello", "recipient": "world", "amount": 1}
content = json.dumps(data).encode("utf-16")
headers = {"Content-Type": "application/json, charset=utf-16"}
response = httpx.Response(
200,
content=content,
headers=headers,
)
assert response.json(parse_int=str)["amount"] == "1"
@pytest.mark.parametrize(
"encoding",
[
"utf-8",
"utf-8-sig",
"utf-16",
"utf-16-be",
"utf-16-le",
"utf-32",
"utf-32-be",
"utf-32-le",
],
)
def test_json_without_specified_charset(encoding):
data = {"greeting": "hello", "recipient": "world"}
content = json.dumps(data).encode(encoding)
headers = {"Content-Type": "application/json"}
response = httpx.Response(
200,
content=content,
headers=headers,
)
assert response.json() == data
@pytest.mark.parametrize(
"encoding",
[
"utf-8",
"utf-8-sig",
"utf-16",
"utf-16-be",
"utf-16-le",
"utf-32",
"utf-32-be",
"utf-32-le",
],
)
def test_json_with_specified_charset(encoding):
data = {"greeting": "hello", "recipient": "world"}
content = json.dumps(data).encode(encoding)
headers = {"Content-Type": f"application/json; charset={encoding}"}
response = httpx.Response(
200,
content=content,
headers=headers,
)
assert response.json() == data
@pytest.mark.parametrize(
"headers, expected",
[
(
{"Link": "<https://example.com>; rel='preload'"},
{"preload": {"rel": "preload", "url": "https://example.com"}},
),
(
{"Link": '</hub>; rel="hub", </resource>; rel="self"'},
{
"hub": {"url": "/hub", "rel": "hub"},
"self": {"url": "/resource", "rel": "self"},
},
),
],
)
def test_link_headers(headers, expected):
response = httpx.Response(
200,
content=None,
headers=headers,
)
assert response.links == expected
@pytest.mark.parametrize("header_value", (b"deflate", b"gzip", b"br"))
def test_decode_error_with_request(header_value):
headers = [(b"Content-Encoding", header_value)]
broken_compressed_body = b"xxxxxxxxxxxxxx"
with pytest.raises(httpx.DecodingError):
httpx.Response(
200,
headers=headers,
content=broken_compressed_body,
)
with pytest.raises(httpx.DecodingError):
httpx.Response(
200,
headers=headers,
content=broken_compressed_body,
request=httpx.Request("GET", "https://www.example.org/"),
)
@pytest.mark.parametrize("header_value", (b"deflate", b"gzip", b"br"))
def test_value_error_without_request(header_value):
headers = [(b"Content-Encoding", header_value)]
broken_compressed_body = b"xxxxxxxxxxxxxx"
with pytest.raises(httpx.DecodingError):
httpx.Response(200, headers=headers, content=broken_compressed_body)
def test_response_with_unset_request():
response = httpx.Response(200, content=b"Hello, world!")
assert response.status_code == 200
assert response.reason_phrase == "OK"
assert response.text == "Hello, world!"
assert not response.is_error
def test_set_request_after_init():
response = httpx.Response(200, content=b"Hello, world!")
response.request = httpx.Request("GET", "https://www.example.org")
assert response.request.method == "GET"
assert response.request.url == "https://www.example.org"
def test_cannot_access_unset_request():
response = httpx.Response(200, content=b"Hello, world!")
with pytest.raises(RuntimeError):
response.request # noqa: B018
def test_generator_with_transfer_encoding_header():
def content() -> typing.Iterator[bytes]:
yield b"test 123" # pragma: no cover
response = httpx.Response(200, content=content())
assert response.headers == {"Transfer-Encoding": "chunked"}
def test_generator_with_content_length_header():
def content() -> typing.Iterator[bytes]:
yield b"test 123" # pragma: no cover
headers = {"Content-Length": "8"}
response = httpx.Response(200, content=content(), headers=headers)
assert response.headers == {"Content-Length": "8"}
def test_response_picklable():
response = httpx.Response(
200,
content=b"Hello, world!",
request=httpx.Request("GET", "https://example.org"),
)
pickle_response = pickle.loads(pickle.dumps(response))
assert pickle_response.is_closed is True
assert pickle_response.is_stream_consumed is True
assert pickle_response.next_request is None
assert pickle_response.stream is not None
assert pickle_response.content == b"Hello, world!"
assert pickle_response.status_code == 200
assert pickle_response.request.url == response.request.url
assert pickle_response.extensions == {}
assert pickle_response.history == []
@pytest.mark.anyio
async def test_response_async_streaming_picklable():
response = httpx.Response(200, content=async_streaming_body())
pickle_response = pickle.loads(pickle.dumps(response))
with pytest.raises(httpx.ResponseNotRead):
pickle_response.content # noqa: B018
with pytest.raises(httpx.StreamClosed):
await pickle_response.aread()
assert pickle_response.is_stream_consumed is False
assert pickle_response.num_bytes_downloaded == 0
assert pickle_response.headers == {"Transfer-Encoding": "chunked"}
response = httpx.Response(200, content=async_streaming_body())
await response.aread()
pickle_response = pickle.loads(pickle.dumps(response))
assert pickle_response.is_stream_consumed is True
assert pickle_response.content == b"Hello, world!"
assert pickle_response.num_bytes_downloaded == 13
def test_response_decode_text_using_autodetect():
# Ensure that a 'default_encoding="autodetect"' on the response allows for
# encoding autodetection to be used when no "Content-Type: text/plain; charset=..."
# info is present.
#
# Here we have some french text encoded with ISO-8859-1, rather than UTF-8.
text = (
"Non-seulement Despréaux ne se trompait pas, mais de tous les écrivains "
"que la France a produits, sans excepter Voltaire lui-même, imprégné de "
"l'esprit anglais par son séjour à Londres, c'est incontestablement "
"Molière ou Poquelin qui reproduit avec l'exactitude la plus vive et la "
"plus complète le fond du génie français."
)
content = text.encode("ISO-8859-1")
response = httpx.Response(200, content=content, default_encoding=autodetect)
assert response.status_code == 200
assert response.reason_phrase == "OK"
assert response.encoding == "ISO-8859-1"
assert response.text == text
def test_response_decode_text_using_explicit_encoding():
# Ensure that a 'default_encoding="..."' on the response is used for text decoding
# when no "Content-Type: text/plain; charset=..."" info is present.
#
# Here we have some french text encoded with Windows-1252, rather than UTF-8.
# https://en.wikipedia.org/wiki/Windows-1252
text = (
"Non-seulement Despréaux ne se trompait pas, mais de tous les écrivains "
"que la France a produits, sans excepter Voltaire lui-même, imprégné de "
"l'esprit anglais par son séjour à Londres, c'est incontestablement "
"Molière ou Poquelin qui reproduit avec l'exactitude la plus vive et la "
"plus complète le fond du génie français."
)
content = text.encode("cp1252")
response = httpx.Response(200, content=content, default_encoding="cp1252")
assert response.status_code == 200
assert response.reason_phrase == "OK"
assert response.encoding == "cp1252"
assert response.text == text
| StreamingBody |
python | Textualize__textual | tests/test_app.py | {
"start": 794,
"end": 10677
} | class ____(App):
def compose(self) -> ComposeResult:
yield Input()
yield Button("Click me!")
async def test_hover_update_styles():
app = MyApp(ansi_color=False)
async with app.run_test() as pilot:
button = app.query_one(Button)
assert button.pseudo_classes == {
"blur",
"can-focus",
"dark",
"enabled",
"first-of-type",
"last-of-type",
"last-child",
"even",
"empty",
}
# Take note of the initial background colour
initial_background = button.styles.background
await pilot.hover(Button)
# We've hovered, so ensure the pseudoclass is present and background changed
assert button.pseudo_classes == {
"blur",
"can-focus",
"dark",
"enabled",
"hover",
"first-of-type",
"last-of-type",
"last-child",
"even",
"empty",
}
assert button.styles.background != initial_background
def test_setting_title():
app = MyApp()
app.title = None
assert app.title == "None"
app.title = ""
assert app.title == ""
app.title = 0.125
assert app.title == "0.125"
app.title = [True, False, 2]
assert app.title == "[True, False, 2]"
def test_setting_sub_title():
app = MyApp()
app.sub_title = None
assert app.sub_title == "None"
app.sub_title = ""
assert app.sub_title == ""
app.sub_title = 0.125
assert app.sub_title == "0.125"
app.sub_title = [True, False, 2]
assert app.sub_title == "[True, False, 2]"
async def test_default_return_code_is_zero():
app = App()
async with app.run_test():
app.exit()
assert app.return_code == 0
async def test_return_code_is_one_after_crash():
class MyApp(App):
def key_p(self):
1 / 0
app = MyApp()
with contextlib.suppress(ZeroDivisionError):
async with app.run_test() as pilot:
await pilot.press("p")
assert app.return_code == 1
async def test_set_return_code():
app = App()
async with app.run_test():
app.exit(return_code=42)
assert app.return_code == 42
def test_no_return_code_before_running():
app = App()
assert app.return_code is None
async def test_no_return_code_while_running():
app = App()
async with app.run_test():
assert app.return_code is None
async def test_ansi_theme():
app = App()
async with app.run_test():
app.ansi_theme_dark = NIGHT_OWLISH
assert app.ansi_theme == NIGHT_OWLISH
app.theme = "textual-light"
assert app.ansi_theme != NIGHT_OWLISH
app.ansi_theme_light = MONOKAI
assert app.ansi_theme == MONOKAI
# Ensure if we change the dark theme while on light mode,
# then change back to dark mode, the dark theme is updated.
app.ansi_theme_dark = DIMMED_MONOKAI
assert app.ansi_theme == MONOKAI
app.theme = "textual-dark"
assert app.ansi_theme == DIMMED_MONOKAI
async def test_early_exit():
"""Test exiting early doesn't cause issues."""
from textual.app import App
class AppExit(App):
def compose(self):
yield Static("Hello")
def on_mount(self) -> None:
# Exit after creating app
self.exit()
app = AppExit()
async with app.run_test():
pass
def test_early_exit_inline():
"""Test exiting early in inline mode doesn't break."""
class AppExit(App[None]):
def compose(self):
yield Static("Hello")
def on_mount(self) -> None:
# Exit after creating app
self.exit()
app = AppExit()
app.run(inline=True, inline_no_clear=True)
async def test_search_with_simple_commands():
"""Test search with a list of SimpleCommands and ensure callbacks are invoked."""
called = False
def callback():
nonlocal called
called = True
app = App[None]()
commands = [
SimpleCommand("Test Command", callback, "A test command"),
SimpleCommand("Another Command", callback, "Another test command"),
]
async with app.run_test() as pilot:
await app.search_commands(commands)
await pilot.press("enter", "enter")
assert called
async def test_search_with_tuples():
"""Test search with a list of tuples and ensure callbacks are invoked.
In this case we also have no help text in the tuples.
"""
called = False
def callback():
nonlocal called
called = True
app = App[None]()
commands = [
("Test Command", callback),
("Another Command", callback),
]
async with app.run_test() as pilot:
await app.search_commands(commands)
await pilot.press("enter", "enter")
assert called
async def test_search_with_empty_list():
"""Test search with an empty command list doesn't crash."""
app = App[None]()
async with app.run_test():
await app.search_commands([])
async def raw_click(pilot: Pilot, selector: str, times: int = 1):
"""A lower level click function that doesn't use the Pilot,
and so doesn't bypass the click chain logic in App.on_event."""
app = pilot.app
kwargs = _get_mouse_message_arguments(app.query_one(selector))
for _ in range(times):
app.post_message(events.MouseDown(**kwargs))
app.post_message(events.MouseUp(**kwargs))
await pilot.pause()
@pytest.mark.parametrize("number_of_clicks,final_count", [(1, 1), (2, 3), (3, 6)])
async def test_click_chain_initial_repeated_clicks(
number_of_clicks: int, final_count: int
):
click_count = 0
class MyApp(App[None]):
# Ensure clicks are always within the time threshold
CLICK_CHAIN_TIME_THRESHOLD = 1000.0
def compose(self) -> ComposeResult:
yield Label("Click me!", id="one")
def on_click(self, event: events.Click) -> None:
nonlocal click_count
print(f"event: {event}")
click_count += event.chain
async with MyApp().run_test() as pilot:
# Clicking the same Label at the same offset creates a double and triple click.
for _ in range(number_of_clicks):
await raw_click(pilot, "#one")
assert click_count == final_count
async def test_click_chain_different_offset():
click_count = 0
class MyApp(App[None]):
# Ensure clicks are always within the time threshold
CLICK_CHAIN_TIME_THRESHOLD = 1000.0
def compose(self) -> ComposeResult:
yield Label("One!", id="one")
yield Label("Two!", id="two")
yield Label("Three!", id="three")
def on_click(self, event: events.Click) -> None:
nonlocal click_count
click_count += event.chain
async with MyApp().run_test() as pilot:
# Clicking on different offsets in quick-succession doesn't qualify as a double or triple click.
await raw_click(pilot, "#one")
assert click_count == 1
await raw_click(pilot, "#two")
assert click_count == 2
await raw_click(pilot, "#three")
assert click_count == 3
async def test_click_chain_offset_changes_mid_chain():
"""If we're in the middle of a click chain (e.g. we've double clicked), and the third click
comes in at a different offset, that third click should be considered a single click.
"""
click_count = 0
class MyApp(App[None]):
# Ensure clicks are always within the time threshold
CLICK_CHAIN_TIME_THRESHOLD = 1000.0
def compose(self) -> ComposeResult:
yield Label("Click me!", id="one")
yield Label("Another button!", id="two")
def on_click(self, event: events.Click) -> None:
nonlocal click_count
click_count = event.chain
async with MyApp().run_test() as pilot:
await raw_click(pilot, "#one", times=2) # Double click
assert click_count == 2
await raw_click(pilot, "#two") # Single click (because different widget)
assert click_count == 1
async def test_click_chain_time_outwith_threshold():
click_count = 0
class MyApp(App[None]):
# Intentionally set the threshold to 0.0 to ensure we always exceed it
# and can confirm that a click chain is never created
CLICK_CHAIN_TIME_THRESHOLD = 0.0
def compose(self) -> ComposeResult:
yield Label("Click me!", id="one")
def on_click(self, event: events.Click) -> None:
nonlocal click_count
click_count += event.chain
async with MyApp().run_test() as pilot:
for i in range(1, 4):
# Each click is outwith the time threshold, so a click chain is never created.
await raw_click(pilot, "#one")
assert click_count == i
def test_app_loop() -> None:
"""Test that App.run accepts a loop argument."""
class MyApp(App[int]):
def on_mount(self) -> None:
self.exit(42)
app = MyApp()
result = app.run(loop=asyncio.new_event_loop())
assert result == 42
async def test_app_run_async() -> None:
"""Check run_async runs without issues."""
class MyApp(App[int]):
def on_mount(self) -> None:
self.exit(42)
app = MyApp()
result = await app.run_async()
assert result == 42
def test_app_loop_run_after_asyncio_run() -> None:
"""Test that App.run runs after asyncio.run has run."""
class MyApp(App[int]):
def on_mount(self) -> None:
self.exit(42)
async def amain():
pass
asyncio.run(amain())
app = MyApp()
result = app.run()
assert result == 42
| MyApp |
python | ray-project__ray | python/ray/exceptions.py | {
"start": 27449,
"end": 27590
} | class ____(RayError):
"""Called when an object was not available within the given timeout."""
pass
@PublicAPI
| PlasmaObjectNotAvailable |
python | sqlalchemy__sqlalchemy | test/ext/test_associationproxy.py | {
"start": 77256,
"end": 79632
} | class ____(fixtures.MappedTest):
run_create_tables = None
@classmethod
def define_tables(cls, metadata):
Table("a", metadata, Column("id", Integer, primary_key=True))
Table(
"b",
metadata,
Column("id", Integer, primary_key=True),
Column("aid", Integer, ForeignKey("a.id")),
Column("elem", String),
)
@classmethod
def setup_mappers(cls):
a, b = cls.tables("a", "b")
class B(cls.Basic):
def __init__(self, key, elem):
self.key = key
self.elem = elem
class A(cls.Basic):
elements = association_proxy("orig", "elem", creator=B)
cls.mapper_registry.map_imperatively(
A,
a,
properties={
"orig": relationship(
B, collection_class=attribute_keyed_dict("key")
)
},
)
cls.mapper_registry.map_imperatively(B, b)
def test_update_one_elem_dict(self):
a1 = self.classes.A()
a1.elements.update({("B", 3): "elem2"})
eq_(a1.elements, {("B", 3): "elem2"})
def test_update_multi_elem_dict(self):
a1 = self.classes.A()
a1.elements.update({("B", 3): "elem2", ("C", 4): "elem3"})
eq_(a1.elements, {("B", 3): "elem2", ("C", 4): "elem3"})
def test_update_one_elem_list(self):
a1 = self.classes.A()
a1.elements.update([(("B", 3), "elem2")])
eq_(a1.elements, {("B", 3): "elem2"})
def test_update_multi_elem_list(self):
a1 = self.classes.A()
a1.elements.update([(("B", 3), "elem2"), (("C", 4), "elem3")])
eq_(a1.elements, {("B", 3): "elem2", ("C", 4): "elem3"})
def test_update_one_elem_varg(self):
a1 = self.classes.A()
assert_raises_message(
ValueError,
"dictionary update sequence element #1 has length 5; "
"2 is required",
a1.elements.update,
(("B", 3), "elem2"),
)
def test_update_multi_elem_varg(self):
a1 = self.classes.A()
assert_raises_message(
TypeError,
"update expected at most 1 arguments?, got 2",
a1.elements.update,
(("B", 3), "elem2"),
(("C", 4), "elem3"),
)
| DictOfTupleUpdateTest |
python | numba__numba | numba/core/typing/mathdecl.py | {
"start": 2834,
"end": 3118
} | class ____(ConcreteTemplate):
cases = [
signature(types.boolean, types.int64),
signature(types.boolean, types.uint64),
signature(types.boolean, types.float32),
signature(types.boolean, types.float64),
]
@infer_global(math.isfinite)
| Math_predicate |
python | spack__spack | lib/spack/spack/util/environment.py | {
"start": 13723,
"end": 14248
} | class ____(NamePathModifier):
def execute(self, env: MutableMapping[str, str]):
tty.debug(f"RemovePath: {self.name}-{self.value}", level=3)
environment_value = env.get(self.name, "")
directories = environment_value.split(self.separator)
directories = [
path_to_os_path(os.path.normpath(x)).pop()
for x in directories
if x != path_to_os_path(os.path.normpath(self.value)).pop()
]
env[self.name] = self.separator.join(directories)
| RemovePath |
python | tensorflow__tensorflow | tensorflow/python/distribute/mirrored_strategy_test.py | {
"start": 50206,
"end": 54336
} | class ____(
multi_worker_test_base.MultiWorkerTestBase,
strategy_test_lib.DistributionTestBase):
def _configure_distribution_strategy(self, distribution):
cluster_spec = server_lib.ClusterSpec({
"worker": ["/job:worker/task:0", "/job:worker/task:1"]
})
distribution.configure(cluster_spec=cluster_spec)
def test_num_replicas_in_sync(self, distribution):
self._configure_distribution_strategy(distribution)
# We calculate the total number of gpus across the workers(2) specified in
# the cluster spec.
self.assertEqual(context.num_gpus() * 2, distribution.num_replicas_in_sync)
def testMinimizeLossGraph(self, distribution):
self._configure_distribution_strategy(distribution)
self._test_minimize_loss_graph(distribution, learning_rate=0.05)
def testDeviceScope(self, distribution):
"""Test the device scope of multi-worker MirroredStrategy."""
self._configure_distribution_strategy(distribution)
with distribution.scope():
a = constant_op.constant(1.)
with ops.device("/cpu:0"):
b = constant_op.constant(1.)
self.assertEqual(a.device, "/job:worker/task:0")
self.assertEqual(b.device, "/job:worker/task:0/device:CPU:0")
def testMakeInputFnIteratorWithDataset(self, distribution):
self._configure_distribution_strategy(distribution)
dataset_fn = lambda: dataset_ops.Dataset.range(100)
num_gpus = context.num_gpus()
num_workers = 2
expected_values = [[i+j for j in range(num_gpus)] * num_workers
for i in range(0, 100, num_gpus)]
with context.graph_mode(), self.cached_session() as sess:
# `expected_input_pipeline_id` is None because the input_fn will be called
# multiple times, each with a different input_pipeline_id.
input_fn = self._input_fn_to_test_input_context(
dataset_fn,
expected_num_replicas_in_sync=num_workers*num_gpus,
expected_num_input_pipelines=num_workers,
expected_input_pipeline_id=None)
iterator = distribution.make_input_fn_iterator(input_fn)
self._test_input_fn_iterator(
iterator, distribution.extended.worker_devices, expected_values, sess)
def testMakeInputFnIteratorWithCallable(self, distribution):
self._configure_distribution_strategy(distribution)
def fn():
dataset = dataset_ops.Dataset.range(100)
it = dataset_ops.make_one_shot_iterator(dataset)
return it.get_next
num_gpus = context.num_gpus()
num_workers = 2
expected_values = []
for i in range(0, 100, num_gpus):
expected_values.append([i+j for j in range(num_gpus)] * num_workers)
with context.graph_mode(), self.cached_session() as sess:
# `expected_input_pipeline_id` is None because the input_fn will be called
# multiple times, each with a different input_pipeline_id.
input_fn = self._input_fn_to_test_input_context(
fn,
expected_num_replicas_in_sync=num_workers*num_gpus,
expected_num_input_pipelines=num_workers,
expected_input_pipeline_id=None)
iterator = distribution.make_input_fn_iterator(input_fn)
self._test_input_fn_iterator(
iterator, distribution.extended.worker_devices, expected_values, sess,
test_reinitialize=False, ignore_order=True)
def testUpdateConfigProto(self, distribution):
distribution.configure(cluster_spec={"worker": ["fake1", "fake2"]})
config_proto = config_pb2.ConfigProto()
new_config = distribution.update_config_proto(config_proto)
# Verify isolate_session_state
self.assertTrue(new_config.isolate_session_state)
@combinations.generate(
combinations.combine(
distribution=[
combinations.NamedDistribution(
"Mirrored",
# pylint: disable=g-long-lambda
lambda: mirrored_strategy.MirroredStrategy(
devices=["/job:worker/task:0/gpu:{}".format(
i) for i in range(context.num_gpus())]),
required_gpus=1)
],
mode=["graph"]))
| MultiWorkerMirroredStrategyTest |
python | mlflow__mlflow | dev/clint/tests/rules/test_redundant_test_docstring.py | {
"start": 1859,
"end": 2262
} | class ____:
"""This is a longer docstring than the class name TestShort."""
pass
'''
config = Config(select={RedundantTestDocstring.name})
violations = lint_file(Path("test_classes.py"), code, config, index_path)
assert len(violations) == 1
def test_non_test_files_are_ignored(index_path: Path) -> None:
code = '''
def test_something():
"""Short."""
assert True
| TestShort |
python | django__django | tests/db_functions/models.py | {
"start": 1542,
"end": 1723
} | class ____(models.Model):
n1 = models.DecimalField(decimal_places=2, max_digits=6)
n2 = models.DecimalField(decimal_places=7, max_digits=9, null=True, blank=True)
| DecimalModel |
python | huggingface__transformers | src/transformers/models/t5gemma/modular_t5gemma.py | {
"start": 54824,
"end": 60085
} | class ____(T5GemmaPreTrainedModel):
def __init__(self, config: T5GemmaConfig, is_encoder_decoder: Optional[bool] = None):
r"""
is_encoder_decoder (`Optional`, *optional*):
Whether use encoder_decoder for token classification. When set to False, only encoder is used.
"""
if is_encoder_decoder is not None:
config.is_encoder_decoder = is_encoder_decoder
super().__init__(config)
self.num_labels = config.num_labels
if config.is_encoder_decoder:
self.model = T5GemmaModel(config)
else:
self.model = T5GemmaEncoderModel(config)
hidden_size = config.encoder.hidden_size
if config.is_encoder_decoder:
hidden_size = config.decoder.hidden_size
classifier_dropout = getattr(config, "classifier_dropout_rate", 0.1)
self.score = T5GemmaClassificationHead(hidden_size, self.num_labels, classifier_dropout)
self.post_init()
def get_input_embeddings(self):
return self.model.get_input_embeddings()
def set_input_embeddings(self, value):
self.model.set_input_embeddings(value)
@can_return_tuple
@auto_docstring
def forward(
self,
input_ids: Optional[torch.LongTensor] = None,
attention_mask: Optional[torch.Tensor] = None,
position_ids: Optional[torch.LongTensor] = None,
decoder_input_ids: Optional[torch.LongTensor] = None,
decoder_attention_mask: Optional[torch.Tensor] = None,
decoder_position_ids: Optional[torch.LongTensor] = None,
encoder_outputs: Optional[BaseModelOutput] = None,
inputs_embeds: Optional[torch.FloatTensor] = None,
decoder_inputs_embeds: Optional[torch.FloatTensor] = None,
labels: Optional[torch.LongTensor] = None,
**kwargs: Unpack[TransformersKwargs],
) -> TokenClassifierOutput:
r"""
decoder_position_ids (`torch.LongTensor` of shape `(batch_size, decoder_sequence_length)`, *optional*):
Indices of positions of each decoder input sequence tokens in the position embeddings. Selected in the range `[0,
config.decoder.n_positions - 1]`. [What are position IDs?](../glossary#position-ids)
labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
`config.num_labels > 1` a classification loss is computed (Cross-Entropy).
"""
if self.config.is_encoder_decoder and (input_ids is None and inputs_embeds is not None):
raise NotImplementedError(
f"Passing input embeddings is currently not supported for {self.__class__.__name__} in encoder-decoder mode."
)
if self.config.is_encoder_decoder and (decoder_input_ids is None and decoder_inputs_embeds is None):
if input_ids is None:
raise ValueError(
"If no `decoder_input_ids` or `decoder_inputs_embeds` are "
"passed, `input_ids` cannot be `None`. Please pass either "
"`input_ids` or `decoder_input_ids` or `decoder_inputs_embeds`."
)
decoder_input_ids = self._shift_right(input_ids)
if self.config.is_encoder_decoder:
outputs: Seq2SeqModelOutput = self.model(
input_ids,
attention_mask=attention_mask,
position_ids=position_ids,
decoder_input_ids=decoder_input_ids,
decoder_attention_mask=decoder_attention_mask,
decoder_position_ids=decoder_position_ids,
encoder_outputs=encoder_outputs,
inputs_embeds=inputs_embeds,
decoder_inputs_embeds=decoder_inputs_embeds,
use_cache=False,
**kwargs,
)
last_hidden_state = outputs.last_hidden_state
hidden_states = outputs.decoder_hidden_states
attentions = outputs.decoder_attentions
else:
outputs: BaseModelOutput = self.model(
input_ids,
attention_mask=attention_mask,
position_ids=position_ids,
inputs_embeds=inputs_embeds,
**kwargs,
)
last_hidden_state = outputs.last_hidden_state
hidden_states = outputs.hidden_states
attentions = outputs.attentions
logits = self.score(last_hidden_state)
loss = None
if labels is not None:
loss = self.loss_function(logits, labels, self.config)
return TokenClassifierOutput(
loss=loss,
logits=logits,
hidden_states=hidden_states,
attentions=attentions,
)
__all__ = [
"T5GemmaConfig",
"T5GemmaModuleConfig",
"T5GemmaForConditionalGeneration",
"T5GemmaModel",
"T5GemmaEncoderModel",
"T5GemmaPreTrainedModel",
"T5GemmaForSequenceClassification",
"T5GemmaForTokenClassification",
]
| T5GemmaForTokenClassification |
python | graphql-python__graphene | graphene/utils/subclass_with_meta.py | {
"start": 299,
"end": 1616
} | class ____(metaclass=SubclassWithMeta_Meta):
"""This class improves __init_subclass__ to receive automatically the options from meta"""
def __init_subclass__(cls, **meta_options):
"""This method just terminates the super() chain"""
_Meta = getattr(cls, "Meta", None)
_meta_props = {}
if _Meta:
if isinstance(_Meta, dict):
_meta_props = _Meta
elif isclass(_Meta):
_meta_props = props(_Meta)
else:
raise Exception(
f"Meta have to be either a class or a dict. Received {_Meta}"
)
delattr(cls, "Meta")
options = dict(meta_options, **_meta_props)
abstract = options.pop("abstract", False)
if abstract:
assert not options, (
"Abstract types can only contain the abstract attribute. "
f"Received: abstract, {', '.join(options)}"
)
else:
super_class = super(cls, cls)
if hasattr(super_class, "__init_subclass_with_meta__"):
super_class.__init_subclass_with_meta__(**options)
@classmethod
def __init_subclass_with_meta__(cls, **meta_options):
"""This method just terminates the super() chain"""
| SubclassWithMeta |
python | airbytehq__airbyte | airbyte-integrations/connectors/source-github/source_github/github_schema.py | {
"start": 285243,
"end": 286195
} | class ____(sgqlc.types.Input):
"""Autogenerated input type of RequestReviews"""
__schema__ = github_schema
__field_names__ = ("pull_request_id", "user_ids", "team_ids", "union", "client_mutation_id")
pull_request_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestId")
"""The Node ID of the pull request to modify."""
user_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="userIds")
"""The Node IDs of the user to request."""
team_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="teamIds")
"""The Node IDs of the team to request."""
union = sgqlc.types.Field(Boolean, graphql_name="union")
"""Add users to the set rather than replace."""
client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId")
"""A unique identifier for the client performing the mutation."""
| RequestReviewsInput |
python | airbytehq__airbyte | airbyte-integrations/connectors/source-stripe/unit_tests/integration/test_transactions.py | {
"start": 9331,
"end": 14953
} | class ____(TestCase):
@HttpMocker()
def test_given_no_state_when_read_then_use_transactions_endpoint(self, http_mocker: HttpMocker) -> None:
cursor_value = int(_A_START_DATE.timestamp()) + 1
http_mocker.get(
_transactions_request().with_created_gte(_A_START_DATE).with_created_lte(_NOW).with_limit(100).build(),
_transactions_response().with_record(_a_transaction().with_cursor(cursor_value)).build(),
)
output = self._read(_config().with_start_date(_A_START_DATE), _NO_STATE)
most_recent_state = output.most_recent_state
assert most_recent_state.stream_descriptor == StreamDescriptor(name=_STREAM_NAME)
assert most_recent_state.stream_state.updated == str(cursor_value)
@HttpMocker()
def test_given_state_when_read_then_query_events_using_types_and_state_value_plus_1(self, http_mocker: HttpMocker) -> None:
start_date = _NOW - timedelta(days=40)
state_datetime = _NOW - timedelta(days=5)
cursor_value = int(state_datetime.timestamp()) + 1
http_mocker.get(
_events_request().with_created_gte(state_datetime).with_created_lte(_NOW).with_limit(100).with_types(_EVENT_TYPES).build(),
_events_response().with_record(_an_event().with_cursor(cursor_value).with_field(_DATA_FIELD, _a_transaction().build())).build(),
)
output = self._read(
_config().with_start_date(start_date),
StateBuilder().with_stream_state(_STREAM_NAME, {"updated": int(state_datetime.timestamp())}).build(),
)
most_recent_state = output.most_recent_state
assert most_recent_state.stream_descriptor == StreamDescriptor(name=_STREAM_NAME)
assert most_recent_state.stream_state.updated == str(cursor_value)
@HttpMocker()
def test_given_state_and_pagination_when_read_then_return_records(self, http_mocker: HttpMocker) -> None:
state_datetime = _NOW - timedelta(days=5)
http_mocker.get(
_events_request().with_created_gte(state_datetime).with_created_lte(_NOW).with_limit(100).with_types(_EVENT_TYPES).build(),
_events_response()
.with_pagination()
.with_record(_an_event().with_id("last_record_id_from_first_page").with_field(_DATA_FIELD, _a_transaction().build()))
.build(),
)
http_mocker.get(
_events_request()
.with_starting_after("last_record_id_from_first_page")
.with_created_gte(state_datetime)
.with_created_lte(_NOW)
.with_limit(100)
.with_types(_EVENT_TYPES)
.build(),
_events_response().with_record(self._a_transaction_event()).build(),
)
output = self._read(
_config(),
StateBuilder().with_stream_state(_STREAM_NAME, {"updated": int(state_datetime.timestamp())}).build(),
)
assert len(output.records) == 2
@HttpMocker()
def test_given_state_and_small_slice_range_when_read_then_perform_multiple_queries(self, http_mocker: HttpMocker) -> None:
state_datetime = _NOW - timedelta(days=5)
slice_range = timedelta(days=3)
slice_datetime = state_datetime + slice_range
http_mocker.get(
_events_request()
.with_created_gte(state_datetime)
.with_created_lte(slice_datetime - _AVOIDING_INCLUSIVE_BOUNDARIES)
.with_limit(100)
.with_types(_EVENT_TYPES)
.build(),
_events_response().with_record(self._a_transaction_event()).build(),
)
http_mocker.get(
_events_request().with_created_gte(slice_datetime).with_created_lte(_NOW).with_limit(100).with_types(_EVENT_TYPES).build(),
_events_response().with_record(self._a_transaction_event()).with_record(self._a_transaction_event()).build(),
)
output = self._read(
_config().with_start_date(_NOW - timedelta(days=30)).with_slice_range_in_days(slice_range.days),
StateBuilder().with_stream_state(_STREAM_NAME, {"updated": int(state_datetime.timestamp())}).build(),
)
assert len(output.records) == 3
@HttpMocker()
def test_given_state_earlier_than_30_days_when_read_then_query_events_using_types_and_event_lower_boundary(
self, http_mocker: HttpMocker
) -> None:
# this seems odd as we would miss some data between start_date and events_lower_boundary. In that case, we should hit the
# transactions endpoint
start_date = _NOW - timedelta(days=40)
state_value = _NOW - timedelta(days=39)
events_lower_boundary = _NOW - timedelta(days=30)
http_mocker.get(
_events_request()
.with_created_gte(events_lower_boundary)
.with_created_lte(_NOW)
.with_limit(100)
.with_types(_EVENT_TYPES)
.build(),
_events_response().with_record(self._a_transaction_event()).build(),
)
self._read(
_config().with_start_date(start_date),
StateBuilder().with_stream_state(_STREAM_NAME, {"updated": int(state_value.timestamp())}).build(),
)
# request matched http_mocker
def _a_transaction_event(self) -> RecordBuilder:
return _an_event().with_field(_DATA_FIELD, _a_transaction().build())
def _read(self, config: ConfigBuilder, state: Optional[Dict[str, Any]], expecting_exception: bool = False) -> EntrypointOutput:
return _read(config, SyncMode.incremental, state, expecting_exception)
| IncrementalTest |
python | huggingface__transformers | src/transformers/models/donut/modeling_donut_swin.py | {
"start": 21970,
"end": 22600
} | class ____(nn.Module):
def __init__(self, config, dim):
super().__init__()
self.dense = nn.Linear(dim, int(config.mlp_ratio * dim))
if isinstance(config.hidden_act, str):
self.intermediate_act_fn = ACT2FN[config.hidden_act]
else:
self.intermediate_act_fn = config.hidden_act
def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
hidden_states = self.dense(hidden_states)
hidden_states = self.intermediate_act_fn(hidden_states)
return hidden_states
# Copied from transformers.models.swin.modeling_swin.SwinOutput
| DonutSwinIntermediate |
python | qdrant__qdrant-client | qdrant_client/http/models/models.py | {
"start": 21962,
"end": 25091
} | class ____(BaseModel, extra="forbid"):
"""
Operation for creating new collection and (optionally) specify index params
"""
vectors: Optional["VectorsConfig"] = Field(
default=None, description="Operation for creating new collection and (optionally) specify index params"
)
shard_number: Optional[int] = Field(
default=None,
description="For auto sharding: Number of shards in collection. - Default is 1 for standalone, otherwise equal to the number of nodes - Minimum is 1 For custom sharding: Number of shards in collection per shard group. - Default is 1, meaning that each shard key will be mapped to a single shard - Minimum is 1",
)
sharding_method: Optional["ShardingMethod"] = Field(
default=None,
description="Sharding method Default is Auto - points are distributed across all available shards Custom - points are distributed across shards according to shard key",
)
replication_factor: Optional[int] = Field(
default=None, description="Number of shards replicas. Default is 1 Minimum is 1"
)
write_consistency_factor: Optional[int] = Field(
default=None,
description="Defines how many replicas should apply the operation for us to consider it successful. Increasing this number will make the collection more resilient to inconsistencies, but will also make it fail if not enough replicas are available. Does not have any performance impact.",
)
on_disk_payload: Optional[bool] = Field(
default=None,
description="If true - point's payload will not be stored in memory. It will be read from the disk every time it is requested. This setting saves RAM by (slightly) increasing the response time. Note: those payload values that are involved in filtering and are indexed - remain in RAM. Default: true",
)
hnsw_config: Optional["HnswConfigDiff"] = Field(
default=None,
description="Custom params for HNSW index. If none - values from service configuration file are used.",
)
wal_config: Optional["WalConfigDiff"] = Field(
default=None, description="Custom params for WAL. If none - values from service configuration file are used."
)
optimizers_config: Optional["OptimizersConfigDiff"] = Field(
default=None,
description="Custom params for Optimizers. If none - values from service configuration file are used.",
)
quantization_config: Optional["QuantizationConfig"] = Field(
default=None, description="Quantization parameters. If none - quantization is disabled."
)
sparse_vectors: Optional[Dict[str, "SparseVectorParams"]] = Field(
default=None, description="Sparse vector data config."
)
strict_mode_config: Optional["StrictModeConfig"] = Field(default=None, description="Strict-mode config.")
metadata: Optional["Payload"] = Field(
default=None,
description="Arbitrary JSON metadata for the collection This can be used to store application-specific information such as creation time, migration data, inference model info, etc.",
)
| CreateCollection |
python | getsentry__sentry | tests/sentry/deletions/tasks/test_overwatch.py | {
"start": 313,
"end": 11274
} | class ____(TestCase):
def setUp(self) -> None:
super().setUp()
self.organization_id = 12345
self.organization_slug = "test-org"
# Mock region
self.mock_region = MagicMock()
self.mock_region.name = "us"
@override_settings(
OVERWATCH_WEBHOOK_SECRET="test-secret",
OVERWATCH_REGION_URL="https://overwatch-us.example.com",
)
@patch("sentry.deletions.tasks.overwatch.get_local_region")
@patch("sentry.deletions.tasks.overwatch.logger")
@patch("sentry.deletions.tasks.overwatch.metrics")
def test_region_not_enabled(
self, mock_metrics: Any, mock_logger: Any, mock_get_local_region: Any
) -> None:
mock_get_local_region.return_value = self.mock_region
with self.options({"overwatch.enabled-regions": []}):
notify_overwatch_organization_deleted(self.organization_id, self.organization_slug)
mock_logger.debug.assert_called_once_with(
"overwatch.organization_deleted.region_not_enabled",
extra={
"organization_id": self.organization_id,
"organization_slug": self.organization_slug,
"region_name": "us",
},
)
mock_metrics.incr.assert_not_called()
@override_settings(OVERWATCH_WEBHOOK_SECRET=None)
@patch("sentry.deletions.tasks.overwatch.get_local_region")
@patch("sentry.deletions.tasks.overwatch.logger")
@patch("sentry.deletions.tasks.overwatch.metrics")
def test_no_webhook_secret(
self, mock_metrics: Any, mock_logger: Any, mock_get_local_region: Any
) -> None:
mock_get_local_region.return_value = self.mock_region
with self.options({"overwatch.enabled-regions": ["us"]}):
notify_overwatch_organization_deleted(self.organization_id, self.organization_slug)
mock_logger.warning.assert_called_once_with(
"overwatch.organization_deleted.no_secret",
extra={
"organization_id": self.organization_id,
"organization_slug": self.organization_slug,
},
)
mock_metrics.incr.assert_not_called()
@override_settings(
OVERWATCH_WEBHOOK_SECRET="test-secret",
OVERWATCH_REGION_URL="https://overwatch-us.example.com",
)
@responses.activate
@patch("sentry.deletions.tasks.overwatch.get_local_region")
@patch("sentry.deletions.tasks.overwatch.logger")
@patch("sentry.deletions.tasks.overwatch.metrics")
def test_successful_notification(
self, mock_metrics: Any, mock_logger: Any, mock_get_local_region: Any
) -> None:
mock_get_local_region.return_value = self.mock_region
responses.add(
responses.POST,
"https://overwatch-us.example.com/webhooks/sentry",
status=200,
)
with self.options({"overwatch.enabled-regions": ["us"]}):
notify_overwatch_organization_deleted(self.organization_id, self.organization_slug)
assert len(responses.calls) == 1
request = responses.calls[0].request
payload = json.loads(request.body)
assert payload == {
"event_type": "organization_delete",
"organization_id": self.organization_id,
"organization_slug": self.organization_slug,
"region": "us",
}
expected_signature = hmac.new(
b"test-secret",
request.body,
hashlib.sha256,
).hexdigest()
assert request.headers["x-sentry-overwatch-signature"] == expected_signature
assert request.headers["content-type"] == "application/json;charset=utf-8"
mock_logger.info.assert_called_once_with(
"overwatch.organization_deleted.success",
extra={
"organization_id": self.organization_id,
"organization_slug": self.organization_slug,
"region_name": "us",
"status_code": 200,
},
)
mock_metrics.incr.assert_called_once_with(
"overwatch.organization_deleted.sent",
amount=1,
tags={"status": "success", "region": "us"},
)
@override_settings(
OVERWATCH_WEBHOOK_SECRET="test-secret",
OVERWATCH_REGION_URL=None, # No URL configured
)
@patch("sentry.deletions.tasks.overwatch.get_local_region")
@patch("sentry.deletions.tasks.overwatch.logger")
@patch("sentry.deletions.tasks.overwatch.metrics")
def test_missing_region_url(
self, mock_metrics: Any, mock_logger: Any, mock_get_local_region: Any
) -> None:
mock_get_local_region.return_value = self.mock_region
with self.options({"overwatch.enabled-regions": ["us"]}):
notify_overwatch_organization_deleted(self.organization_id, self.organization_slug)
mock_logger.warning.assert_called_once_with(
"overwatch.organization_deleted.missing_region_url",
extra={
"organization_id": self.organization_id,
"organization_slug": self.organization_slug,
"region_name": "us",
},
)
mock_metrics.incr.assert_called_once_with(
"overwatch.organization_deleted.sent",
amount=1,
tags={"status": "failure", "region": "us"},
)
@override_settings(
OVERWATCH_WEBHOOK_SECRET="test-secret",
OVERWATCH_REGION_URL="https://overwatch-us.example.com",
)
@responses.activate
@patch("sentry.deletions.tasks.overwatch.get_local_region")
@patch("sentry.deletions.tasks.overwatch.logger")
@patch("sentry.deletions.tasks.overwatch.metrics")
def test_request_failure(
self, mock_metrics: Any, mock_logger: Any, mock_get_local_region: Any
) -> None:
mock_get_local_region.return_value = self.mock_region
responses.add(
responses.POST,
"https://overwatch-us.example.com/webhooks/sentry",
status=500,
)
with self.options({"overwatch.enabled-regions": ["us"]}):
notify_overwatch_organization_deleted(self.organization_id, self.organization_slug)
mock_logger.exception.assert_called_once()
call_args = mock_logger.exception.call_args
assert call_args[0][0] == "overwatch.organization_deleted.failed"
assert call_args[1]["extra"]["organization_id"] == self.organization_id
assert call_args[1]["extra"]["region_name"] == "us"
mock_metrics.incr.assert_called_once_with(
"overwatch.organization_deleted.sent",
amount=1,
tags={"status": "failure", "region": "us"},
)
@override_settings(
OVERWATCH_WEBHOOK_SECRET="test-secret",
OVERWATCH_REGION_URL="https://overwatch-us.example.com",
)
@responses.activate
@patch("sentry.deletions.tasks.overwatch.get_local_region")
def test_request_timeout(self, mock_get_local_region: Any) -> None:
import requests
mock_get_local_region.return_value = self.mock_region
responses.add(
responses.POST,
"https://overwatch-us.example.com/webhooks/sentry",
body=requests.exceptions.Timeout(),
)
with self.options({"overwatch.enabled-regions": ["us"]}):
notify_overwatch_organization_deleted(self.organization_id, self.organization_slug)
assert len(responses.calls) == 1
@override_settings(
OVERWATCH_WEBHOOK_SECRET="secret-with-special-chars-!@#$%",
OVERWATCH_REGION_URL="https://overwatch-us.example.com",
)
@responses.activate
@patch("sentry.deletions.tasks.overwatch.get_local_region")
def test_signature_with_special_characters(self, mock_get_local_region: Any) -> None:
mock_get_local_region.return_value = self.mock_region
responses.add(
responses.POST,
"https://overwatch-us.example.com/webhooks/sentry",
status=200,
)
with self.options({"overwatch.enabled-regions": ["us"]}):
notify_overwatch_organization_deleted(self.organization_id, self.organization_slug)
request = responses.calls[0].request
payload = request.body
expected_signature = hmac.new(
b"secret-with-special-chars-!@#$%",
payload,
hashlib.sha256,
).hexdigest()
assert request.headers["x-sentry-overwatch-signature"] == expected_signature
@override_settings(
OVERWATCH_WEBHOOK_SECRET="test-secret",
OVERWATCH_REGION_URL="https://overwatch-us.example.com",
)
@patch("sentry.deletions.tasks.overwatch.get_local_region")
@patch("sentry.deletions.tasks.overwatch.logger")
@patch("sentry.deletions.tasks.overwatch.metrics")
def test_get_local_region_error(
self, mock_metrics: Any, mock_logger: Any, mock_get_local_region: Any
) -> None:
mock_get_local_region.side_effect = Exception("Region not configured")
with self.options({"overwatch.enabled-regions": ["us"]}):
notify_overwatch_organization_deleted(self.organization_id, self.organization_slug)
mock_logger.exception.assert_called_once()
call_args = mock_logger.exception.call_args
assert call_args[0][0] == "overwatch.organization_deleted.region_error"
assert call_args[1]["extra"]["organization_id"] == self.organization_id
assert call_args[1]["extra"]["error"] == "Region not configured"
mock_metrics.incr.assert_not_called()
@override_settings(
OVERWATCH_WEBHOOK_SECRET="test-secret",
OVERWATCH_REGION_URL="https://overwatch-us.example.com",
)
@responses.activate
@patch("sentry.deletions.tasks.overwatch.get_local_region")
@patch("sentry.deletions.tasks.overwatch.logger")
@patch("sentry.deletions.tasks.overwatch.metrics")
def test_different_region_name(
self, mock_metrics: Any, mock_logger: Any, mock_get_local_region: Any
) -> None:
"""Test that the correct region name from get_local_region is used"""
eu_region = MagicMock()
eu_region.name = "eu"
mock_get_local_region.return_value = eu_region
# us is enabled but we're in eu region (not enabled)
with self.options({"overwatch.enabled-regions": ["us"]}):
notify_overwatch_organization_deleted(self.organization_id, self.organization_slug)
# Should log that eu region is not enabled
mock_logger.debug.assert_called_once_with(
"overwatch.organization_deleted.region_not_enabled",
extra={
"organization_id": self.organization_id,
"organization_slug": self.organization_slug,
"region_name": "eu",
},
)
mock_metrics.incr.assert_not_called()
| NotifyOverwatchOrganizationDeletedTest |
python | ray-project__ray | python/ray/llm/_internal/batch/stages/sglang_engine_stage.py | {
"start": 2687,
"end": 7774
} | class ____:
"""Wrapper around the SGLang engine to handle async requests.
Args:
*args: The positional arguments for the engine.
max_pending_requests: The maximum number of pending requests in the queue.
**kwargs: The keyword arguments for the engine.
"""
def __init__(
self,
idx_in_batch_column: str,
max_pending_requests: int = -1,
**kwargs,
):
self.request_id = 0
self.idx_in_batch_column = idx_in_batch_column
self.task_type = kwargs.pop("task", SGLangTaskType.GENERATE)
self.model = kwargs.pop("model", None)
assert self.model is not None
# We need to rename the `model` to `model_path` for SGLang.
kwargs["model_path"] = self.model
# Set the skip_tokenizer_init to True by default for SGLang engine
# because we will not use the tokenizer/detokenizer in SGLang engine
# by default.
self.skip_tokenizer_init = kwargs.pop("skip_tokenizer_init", True)
kwargs["skip_tokenizer_init"] = self.skip_tokenizer_init
try:
import sglang
except ImportError as e:
raise ImportError(
"SGLang is not installed or failed to import. Please run "
"`pip install sglang[all]` to install required dependencies."
) from e
# Initialize the SGLang engine
self.engine = sglang.Engine(**kwargs)
# The performance gets really bad if there are too many requests in the pending queue.
# We work around it with semaphore to limit the number of concurrent requests in the engine.
self.max_pending_requests = max_pending_requests
if self.max_pending_requests > 0:
self.semaphore = asyncio.Semaphore(self.max_pending_requests)
else:
# Use contextlib.nullcontext which works for both sync and async contexts.
self.semaphore = nullcontext()
async def _prepare_llm_request(self, row: Dict[str, Any]) -> SGLangEngineRequest:
"""Prepare the inputs for LLM inference.
Args:
row: The row.
Returns:
A single SGLangEngineRequest.
"""
prompt = row.pop("prompt")
if "tokenized_prompt" in row:
tokenized_prompt = row.pop("tokenized_prompt").tolist()
else:
tokenized_prompt = None
# Prepare sampling parameters.
if self.task_type == SGLangTaskType.GENERATE:
params = maybe_convert_ndarray_to_list(row.pop("sampling_params"))
else:
raise ValueError(f"Unsupported task type: {self.task_type}")
if tokenized_prompt is not None and not self.skip_tokenizer_init:
raise ValueError(
"To use a token-in-token-out mode of SGLang Engine, please set engine_kwargs['skip_tokenizer_init'] to True."
)
request = SGLangEngineRequest(
request_id=self.request_id,
idx_in_batch=row[self.idx_in_batch_column],
prompt=prompt,
prompt_token_ids=tokenized_prompt,
params=params,
)
self.request_id += 1
return request
async def generate_async(
self, row: Dict[str, Any]
) -> Tuple[SGLangEngineRequest, Dict[str, Any], float]:
"""Process a single request.
Args:
request: The request.
Returns:
A tuple of index in batch, request output and bypassed custom fields, and time taken.
"""
request = await self._prepare_llm_request(row)
t = time.perf_counter()
async with self.semaphore:
output = await self._generate_async(request)
time_taken = time.perf_counter() - t
output_data = SGLangOutputData.from_sglang_engine_output(output)
return request, output_data.model_dump(), time_taken
async def _generate_async(self, request: SGLangEngineRequest) -> Any:
"""Process a single request.
Args:
request: The request.
Returns:
The output of the request.
"""
# Send the request to the LLM engine.
stream = await self.engine.async_generate(
prompt=request.prompt,
input_ids=request.prompt_token_ids,
sampling_params=request.params,
stream=True,
)
# Consume the stream until the request is finished.
async for output in stream:
if output["meta_info"]["finish_reason"] is not None:
output["prompt"] = request.prompt
output["prompt_token_ids"] = request.prompt_token_ids
return output
raise RuntimeError(
"[SGLang] The request is not finished. This should not happen. Please report this issue to the Ray team."
)
def shutdown(self):
"""Shutdown the SGLang engine."""
if hasattr(self.engine, "shutdown"):
logger.info("Shutting down SGLang engine")
self.engine.shutdown()
| SGLangEngineWrapper |
python | django-haystack__django-haystack | test_haystack/test_app_loading.py | {
"start": 2074,
"end": 2356
} | class ____(TestCase):
# Confirm that everything works if an app is enabled
def test_simple_view(self):
url = reverse("app-without-models:simple-view")
resp = self.client.get(url)
self.assertEqual(resp.content.decode("utf-8"), "OK")
| AppWithoutModelsTests |
python | huggingface__transformers | src/transformers/models/electra/modeling_electra.py | {
"start": 13676,
"end": 15144
} | class ____(nn.Module):
def __init__(self, config, is_causal=False, layer_idx=None, is_cross_attention=False):
super().__init__()
self.is_cross_attention = is_cross_attention
attention_class = ElectraCrossAttention if is_cross_attention else ElectraSelfAttention
self.self = attention_class(config, is_causal=is_causal, layer_idx=layer_idx)
self.output = ElectraSelfOutput(config)
def forward(
self,
hidden_states: torch.Tensor,
attention_mask: Optional[torch.FloatTensor] = None,
encoder_hidden_states: Optional[torch.FloatTensor] = None,
encoder_attention_mask: Optional[torch.FloatTensor] = None,
past_key_values: Optional[Cache] = None,
cache_position: Optional[torch.Tensor] = None,
**kwargs: Unpack[TransformersKwargs],
) -> tuple[torch.Tensor]:
attention_mask = attention_mask if not self.is_cross_attention else encoder_attention_mask
attention_output, attn_weights = self.self(
hidden_states,
encoder_hidden_states=encoder_hidden_states,
attention_mask=attention_mask,
past_key_values=past_key_values,
cache_position=cache_position,
**kwargs,
)
attention_output = self.output(attention_output, hidden_states)
return attention_output, attn_weights
# Copied from transformers.models.bert.modeling_bert.BertIntermediate
| ElectraAttention |
python | charliermarsh__ruff | crates/ruff_linter/resources/test/fixtures/pyupgrade/UP050.py | {
"start": 291,
"end": 329
} | class ____(A, metaclass=type):
...
| B |
python | huggingface__transformers | src/transformers/models/bros/modeling_bros.py | {
"start": 19805,
"end": 21306
} | class ____(nn.Module):
def __init__(self, config):
super().__init__()
self.n_relations = config.n_relations
self.backbone_hidden_size = config.hidden_size
self.head_hidden_size = config.hidden_size
self.classifier_dropout_prob = config.classifier_dropout_prob
self.drop = nn.Dropout(self.classifier_dropout_prob)
self.query = nn.Linear(self.backbone_hidden_size, self.n_relations * self.head_hidden_size)
self.key = nn.Linear(self.backbone_hidden_size, self.n_relations * self.head_hidden_size)
self.dummy_node = nn.Parameter(torch.zeros(1, self.backbone_hidden_size))
def forward(self, query_layer: torch.Tensor, key_layer: torch.Tensor):
query_layer = self.query(self.drop(query_layer))
dummy_vec = self.dummy_node.unsqueeze(0).repeat(1, key_layer.size(1), 1)
key_layer = torch.cat([key_layer, dummy_vec], axis=0)
key_layer = self.key(self.drop(key_layer))
query_layer = query_layer.view(
query_layer.size(0), query_layer.size(1), self.n_relations, self.head_hidden_size
)
key_layer = key_layer.view(key_layer.size(0), key_layer.size(1), self.n_relations, self.head_hidden_size)
relation_score = torch.matmul(
query_layer.permute(2, 1, 0, 3), key_layer.permute(2, 1, 3, 0)
) # equivalent to torch.einsum("ibnd,jbnd->nbij", (query_layer, key_layer))
return relation_score
@auto_docstring
| BrosRelationExtractor |
python | PrefectHQ__prefect | src/integrations/prefect-github/prefect_github/schemas/graphql_schema.py | {
"start": 544761,
"end": 545398
} | class ____(sgqlc.types.relay.Connection):
"""
See source code for more info.
"""
__schema__ = graphql_schema
__field_names__ = ("edges", "nodes", "page_info", "total_count")
edges = sgqlc.types.Field(
sgqlc.types.list_of("PushAllowanceEdge"), graphql_name="edges"
)
nodes = sgqlc.types.Field(
sgqlc.types.list_of("PushAllowance"), graphql_name="nodes"
)
page_info = sgqlc.types.Field(
sgqlc.types.non_null(PageInfo), graphql_name="pageInfo"
)
total_count = sgqlc.types.Field(
sgqlc.types.non_null(Int), graphql_name="totalCount"
)
| PushAllowanceConnection |
python | django__django | tests/staticfiles_tests/test_management.py | {
"start": 5073,
"end": 7478
} | class ____(StaticFilesTestCase):
def test_location_empty(self):
msg = "without having set the STATIC_ROOT setting to a filesystem path"
err = StringIO()
for root in ["", None]:
with override_settings(STATIC_ROOT=root):
with self.assertRaisesMessage(ImproperlyConfigured, msg):
call_command(
"collectstatic", interactive=False, verbosity=0, stderr=err
)
def test_local_storage_detection_helper(self):
staticfiles_storage = storage.staticfiles_storage
try:
storage.staticfiles_storage._wrapped = empty
with self.settings(
STORAGES={
**settings.STORAGES,
STATICFILES_STORAGE_ALIAS: {
"BACKEND": (
"django.contrib.staticfiles.storage.StaticFilesStorage"
)
},
}
):
command = collectstatic.Command()
self.assertTrue(command.is_local_storage())
storage.staticfiles_storage._wrapped = empty
with self.settings(
STORAGES={
**settings.STORAGES,
STATICFILES_STORAGE_ALIAS: {
"BACKEND": "staticfiles_tests.storage.DummyStorage"
},
}
):
command = collectstatic.Command()
self.assertFalse(command.is_local_storage())
collectstatic.staticfiles_storage = storage.FileSystemStorage()
command = collectstatic.Command()
self.assertTrue(command.is_local_storage())
collectstatic.staticfiles_storage = DummyStorage()
command = collectstatic.Command()
self.assertFalse(command.is_local_storage())
finally:
staticfiles_storage._wrapped = empty
collectstatic.staticfiles_storage = staticfiles_storage
storage.staticfiles_storage = staticfiles_storage
@override_settings(STATICFILES_DIRS=("test"))
def test_collectstatis_check(self):
msg = "The STATICFILES_DIRS setting is not a tuple or list."
with self.assertRaisesMessage(SystemCheckError, msg):
call_command("collectstatic", skip_checks=False)
| TestConfiguration |
python | bokeh__bokeh | src/bokeh/plotting/contour.py | {
"start": 3431,
"end": 10495
} | class ____:
''' Complete geometry data for filled polygons and/or contour lines over a
whole sequence of contour levels.
:func:`~bokeh.plotting.contour.contour_data` returns an object of
this class that can then be passed to :func:`bokeh.models.ContourRenderer.set_data`.
'''
fill_data: FillData | None
line_data: LineData | None
def contour_data(
x: ArrayLike | None = None,
y: ArrayLike | None = None,
z: ArrayLike | np.ma.MaskedArray | None = None,
levels: ArrayLike | None = None,
*,
want_fill: bool = True,
want_line: bool = True,
) -> ContourData:
''' Return the contour data of filled and/or line contours that can be
passed to :func:`bokeh.models.ContourRenderer.set_data`
'''
levels = _validate_levels(levels)
if len(levels) < 2:
want_fill = False
if not want_fill and not want_line:
raise ValueError("Neither fill nor line requested in contour_data")
coords = _contour_coords(x, y, z, levels, want_fill, want_line)
fill_data = None
if coords.fill_coords:
fill_coords = coords.fill_coords
fill_data = FillData(xs=fill_coords.xs, ys=fill_coords.ys, lower_levels=levels[:-1], upper_levels=levels[1:])
line_data = None
if coords.line_coords:
line_coords = coords.line_coords
line_data = LineData(xs=line_coords.xs, ys=line_coords.ys, levels=levels)
return ContourData(fill_data, line_data)
def from_contour(
x: ArrayLike | None = None,
y: ArrayLike | None = None,
z: ArrayLike | np.ma.MaskedArray | None = None,
levels: ArrayLike | None = None,
**visuals, # This is union of LineProps, FillProps and HatchProps
) -> ContourRenderer:
''' Creates a :class:`bokeh.models.ContourRenderer` containing filled
polygons and/or contour lines.
Usually it is preferable to call :func:`~bokeh.plotting.figure.contour`
instead of this function.
Filled contour polygons are calculated if ``fill_color`` is set,
contour lines if ``line_color`` is set.
Args:
x (array-like[float] of shape (ny, nx) or (nx,), optional) :
The x-coordinates of the ``z`` values. May be 2D with the same
shape as ``z.shape``, or 1D with length ``nx = z.shape[1]``.
If not specified are assumed to be ``np.arange(nx)``. Must be
ordered monotonically.
y (array-like[float] of shape (ny, nx) or (ny,), optional) :
The y-coordinates of the ``z`` values. May be 2D with the same
shape as ``z.shape``, or 1D with length ``ny = z.shape[0]``.
If not specified are assumed to be ``np.arange(ny)``. Must be
ordered monotonically.
z (array-like[float] of shape (ny, nx)) :
A 2D NumPy array of gridded values to calculate the contours
of. May be a masked array, and any invalid values (``np.inf``
or ``np.nan``) will also be masked out.
levels (array-like[float]) :
The z-levels to calculate the contours at, must be increasing.
Contour lines are calculated at each level and filled contours
are calculated between each adjacent pair of levels so the
number of sets of contour lines is ``len(levels)`` and the
number of sets of filled contour polygons is ``len(levels)-1``.
**visuals: |fill properties|, |hatch properties| and |line properties|
Fill and hatch properties are used for filled contours, line
properties for line contours. If using vectorized properties
then the correct number must be used, ``len(levels)`` for line
properties and ``len(levels)-1`` for fill and hatch properties.
``fill_color`` and ``line_color`` are more flexible in that
they will accept longer sequences and interpolate them to the
required number using :func:`~bokeh.palettes.linear_palette`,
and also accept palette collections (dictionaries mapping from
integer length to color sequence) such as
`bokeh.palettes.Cividis`.
'''
levels = _validate_levels(levels)
if len(levels) < 2:
want_fill = False
nlevels = len(levels)
want_line = visuals.get("line_color", None) is not None
if want_line:
# Handle possible callback or interpolation for line_color.
visuals["line_color"] = _color(visuals["line_color"], nlevels)
line_cds = ColumnDataSource()
_process_sequence_literals(MultiLine, visuals, line_cds, False)
# Remove line visuals identified from visuals dict.
line_visuals = {}
for name in LineProps.properties():
prop = visuals.pop(name, None)
if prop is not None:
line_visuals[name] = prop
else:
visuals.pop("line_color", None)
want_fill = visuals.get("fill_color", None) is not None
if want_fill:
# Handle possible callback or interpolation for fill_color and hatch_color.
visuals["fill_color"] = _color(visuals["fill_color"], nlevels-1)
if "hatch_color" in visuals:
visuals["hatch_color"] = _color(visuals["hatch_color"], nlevels-1)
fill_cds = ColumnDataSource()
_process_sequence_literals(MultiPolygons, visuals, fill_cds, False)
else:
visuals.pop("fill_color", None)
# Check for extra unknown kwargs.
unknown = visuals.keys() - FillProps.properties() - HatchProps.properties()
if unknown:
raise ValueError(f"Unknown keyword arguments in 'from_contour': {', '.join(unknown)}")
new_contour_data = contour_data(x=x, y=y, z=z, levels=levels, want_fill=want_fill, want_line=want_line)
# Will be other possibilities here like logarithmic....
contour_renderer = ContourRenderer(
fill_renderer=GlyphRenderer(glyph=MultiPolygons(), data_source=ColumnDataSource()),
line_renderer=GlyphRenderer(glyph=MultiLine(), data_source=ColumnDataSource()),
levels=list(levels))
contour_renderer.set_data(new_contour_data)
if new_contour_data.fill_data:
glyph = contour_renderer.fill_renderer.glyph
for name, value in visuals.items():
setattr(glyph, name, value)
cds = contour_renderer.fill_renderer.data_source
for name, value in fill_cds.data.items():
cds.add(value, name)
glyph.line_alpha = 0 # Don't display lines around fill.
glyph.line_width = 0
if new_contour_data.line_data:
glyph = contour_renderer.line_renderer.glyph
for name, value in line_visuals.items():
setattr(glyph, name, value)
cds = contour_renderer.line_renderer.data_source
for name, value in line_cds.data.items():
cds.add(value, name)
return contour_renderer
#-----------------------------------------------------------------------------
# Private API
#-----------------------------------------------------------------------------
@dataclass(frozen=True)
| ContourData |
python | jmcnamara__XlsxWriter | xlsxwriter/test/comparison/test_image21.py | {
"start": 315,
"end": 886
} | class ____(ExcelComparisonTest):
"""
Test file created by XlsxWriter against a file created by Excel.
"""
def setUp(self):
self.set_filename("image21.xlsx")
def test_create_file(self):
"""Test the creation of a simple XlsxWriter file with image(s)."""
workbook = Workbook(self.got_filename)
worksheet = workbook.add_worksheet()
worksheet.write(2000, 0, "Here")
worksheet.insert_image(2000, 1, self.image_dir + "logo.png")
workbook.close()
self.assertExcelEqual()
| TestCompareXLSXFiles |
python | huggingface__transformers | src/transformers/models/regnet/modeling_regnet.py | {
"start": 6945,
"end": 7781
} | class ____(nn.Module):
"""
A RegNet stage composed by stacked layers.
"""
def __init__(
self,
config: RegNetConfig,
in_channels: int,
out_channels: int,
stride: int = 2,
depth: int = 2,
):
super().__init__()
layer = RegNetXLayer if config.layer_type == "x" else RegNetYLayer
self.layers = nn.Sequential(
# downsampling is done in the first layer with stride of 2
layer(
config,
in_channels,
out_channels,
stride=stride,
),
*[layer(config, out_channels, out_channels) for _ in range(depth - 1)],
)
def forward(self, hidden_state):
hidden_state = self.layers(hidden_state)
return hidden_state
| RegNetStage |
python | airbytehq__airbyte | airbyte-integrations/connectors/source-github/source_github/github_schema.py | {
"start": 156030,
"end": 156467
} | class ____(sgqlc.types.Input):
"""The filters that are available when fetching check suites."""
__schema__ = github_schema
__field_names__ = ("app_id", "check_name")
app_id = sgqlc.types.Field(Int, graphql_name="appId")
"""Filters the check suites created by this application ID."""
check_name = sgqlc.types.Field(String, graphql_name="checkName")
"""Filters the check suites by this name."""
| CheckSuiteFilter |
python | fastapi__sqlmodel | docs_src/tutorial/relationship_attributes/read_relationships/tutorial001_py310.py | {
"start": 300,
"end": 3802
} | class ____(SQLModel, table=True):
id: int | None = Field(default=None, primary_key=True)
name: str = Field(index=True)
secret_name: str
age: int | None = Field(default=None, index=True)
team_id: int | None = Field(default=None, foreign_key="team.id")
team: Team | None = Relationship(back_populates="heroes")
sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"
engine = create_engine(sqlite_url, echo=True)
def create_db_and_tables():
SQLModel.metadata.create_all(engine)
def create_heroes():
with Session(engine) as session:
team_preventers = Team(name="Preventers", headquarters="Sharp Tower")
team_z_force = Team(name="Z-Force", headquarters="Sister Margaret's Bar")
hero_deadpond = Hero(
name="Deadpond", secret_name="Dive Wilson", team=team_z_force
)
hero_rusty_man = Hero(
name="Rusty-Man", secret_name="Tommy Sharp", age=48, team=team_preventers
)
hero_spider_boy = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")
session.add(hero_deadpond)
session.add(hero_rusty_man)
session.add(hero_spider_boy)
session.commit()
session.refresh(hero_deadpond)
session.refresh(hero_rusty_man)
session.refresh(hero_spider_boy)
print("Created hero:", hero_deadpond)
print("Created hero:", hero_rusty_man)
print("Created hero:", hero_spider_boy)
hero_spider_boy.team = team_preventers
session.add(hero_spider_boy)
session.commit()
session.refresh(hero_spider_boy)
print("Updated hero:", hero_spider_boy)
hero_black_lion = Hero(name="Black Lion", secret_name="Trevor Challa", age=35)
hero_sure_e = Hero(name="Princess Sure-E", secret_name="Sure-E")
team_wakaland = Team(
name="Wakaland",
headquarters="Wakaland Capital City",
heroes=[hero_black_lion, hero_sure_e],
)
session.add(team_wakaland)
session.commit()
session.refresh(team_wakaland)
print("Team Wakaland:", team_wakaland)
hero_tarantula = Hero(name="Tarantula", secret_name="Natalia Roman-on", age=32)
hero_dr_weird = Hero(name="Dr. Weird", secret_name="Steve Weird", age=36)
hero_cap = Hero(
name="Captain North America", secret_name="Esteban Rogelios", age=93
)
team_preventers.heroes.append(hero_tarantula)
team_preventers.heroes.append(hero_dr_weird)
team_preventers.heroes.append(hero_cap)
session.add(team_preventers)
session.commit()
session.refresh(hero_tarantula)
session.refresh(hero_dr_weird)
session.refresh(hero_cap)
print("Preventers new hero:", hero_tarantula)
print("Preventers new hero:", hero_dr_weird)
print("Preventers new hero:", hero_cap)
def select_heroes():
with Session(engine) as session:
statement = select(Hero).where(Hero.name == "Spider-Boy")
result = session.exec(statement)
hero_spider_boy = result.one()
statement = select(Team).where(Team.id == hero_spider_boy.team_id)
result = session.exec(statement)
team = result.first()
print("Spider-Boy's team:", team)
print("Spider-Boy's team again:", hero_spider_boy.team)
def main():
create_db_and_tables()
create_heroes()
select_heroes()
if __name__ == "__main__":
main()
| Hero |
python | psf__requests | tests/test_utils.py | {
"start": 8295,
"end": 8688
} | class ____:
def test_valid(self):
assert is_valid_cidr("192.168.1.0/24")
@pytest.mark.parametrize(
"value",
(
"8.8.8.8",
"192.168.1.0/a",
"192.168.1.0/128",
"192.168.1.0/-1",
"192.168.1.999/24",
),
)
def test_invalid(self, value):
assert not is_valid_cidr(value)
| TestIsValidCIDR |
python | jazzband__django-pipeline | pipeline/compilers/livescript.py | {
"start": 87,
"end": 625
} | class ____(SubProcessCompiler):
output_extension = "js"
def match_file(self, path):
return path.endswith(".ls")
def compile_file(self, infile, outfile, outdated=False, force=False):
if not outdated and not force:
return # File doesn't need to be recompiled
command = (
settings.LIVE_SCRIPT_BINARY,
"-cp",
settings.LIVE_SCRIPT_ARGUMENTS,
infile,
)
return self.execute_command(command, stdout_captured=outfile)
| LiveScriptCompiler |
python | microsoft__pyright | packages/pyright-internal/src/tests/samples/classes11.py | {
"start": 564,
"end": 648
} | class ____(Sequence[float], Mapping[int, int]): ...
# This should generate an error.
| E |
python | aio-libs__aiohttp | examples/combined_middleware.py | {
"start": 2836,
"end": 4627
} | class ____:
"""Middleware that retries failed requests with exponential backoff."""
def __init__(
self,
max_retries: int = 3,
retry_statuses: set[HTTPStatus] | None = None,
initial_delay: float = 1.0,
backoff_factor: float = 2.0,
) -> None:
self.max_retries = max_retries
self.retry_statuses = retry_statuses or DEFAULT_RETRY_STATUSES
self.initial_delay = initial_delay
self.backoff_factor = backoff_factor
async def __call__(
self,
request: ClientRequest,
handler: ClientHandlerType,
) -> ClientResponse:
"""Execute request with retry logic."""
last_response: ClientResponse | None = None
delay = self.initial_delay
for attempt in range(self.max_retries + 1):
if attempt > 0:
_LOGGER.info(
"Retrying request (attempt %s/%s)",
attempt + 1,
self.max_retries + 1,
)
# Execute the request
response = await handler(request)
last_response = response
# Check if we should retry
if response.status not in self.retry_statuses:
return response
# Don't retry if we've exhausted attempts
if attempt >= self.max_retries:
_LOGGER.warning("Max retries exceeded")
return response
# Wait before retrying
_LOGGER.debug("Waiting %ss before retry...", delay)
await asyncio.sleep(delay)
delay *= self.backoff_factor
if TYPE_CHECKING:
assert last_response is not None # Always set since we loop at least once
return last_response
| RetryMiddleware |
python | jmcnamara__XlsxWriter | xlsxwriter/test/comparison/test_background07.py | {
"start": 315,
"end": 1210
} | class ____(ExcelComparisonTest):
"""
Test file created by XlsxWriter against a file created by Excel.
"""
def setUp(self):
self.set_filename("background07.xlsx")
self.ignore_elements = {"xl/worksheets/sheet1.xml": ["<pageSetup"]}
def test_create_file(self):
"""Test the creation of an XlsxWriter file with a background image."""
workbook = Workbook(self.got_filename)
worksheet = workbook.add_worksheet()
worksheet.insert_image("E9", self.image_dir + "logo.jpg")
worksheet.set_background(self.image_dir + "logo.jpg")
worksheet.set_header("&C&G", {"image_center": self.image_dir + "blue.jpg"})
worksheet.write("A1", "Foo")
worksheet.write_comment("B2", "Some text")
worksheet.set_comments_author("John")
workbook.close()
self.assertExcelEqual()
| TestCompareXLSXFiles |
python | altair-viz__altair | altair/vegalite/v6/schema/core.py | {
"start": 1409198,
"end": 1420913
} | class ____(VegaLiteSchema):
"""
TitleConfig schema wrapper.
Parameters
----------
align : :class:`Align`, Literal['left', 'center', 'right']
Horizontal text alignment for title text. One of ``"left"``, ``"center"``, or
``"right"``.
anchor : dict, :class:`ExprRef`, :class:`TitleAnchor`, Literal[None, 'start', 'middle', 'end']
The anchor position for placing the title and subtitle text. One of ``"start"``,
``"middle"``, or ``"end"``. For example, with an orientation of top these anchor
positions map to a left-, center-, or right-aligned title.
angle : dict, float, :class:`ExprRef`
Angle in degrees of title and subtitle text.
aria : bool, dict, :class:`ExprRef`
A boolean flag indicating if `ARIA attributes
<https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA>`__ should be
included (SVG output only). If ``false``, the "aria-hidden" attribute will be set on
the output SVG group, removing the title from the ARIA accessibility tree.
**Default value:** ``true``
baseline : :class:`Baseline`, :class:`TextBaseline`, Literal['alphabetic', 'line-bottom', 'line-top', 'top', 'middle', 'bottom']
Vertical text baseline for title and subtitle text. One of ``"alphabetic"``
(default), ``"top"``, ``"middle"``, ``"bottom"``, ``"line-top"``, or
``"line-bottom"``. The ``"line-top"`` and ``"line-bottom"`` values operate similarly
to ``"top"`` and ``"bottom"``, but are calculated relative to the *lineHeight*
rather than *fontSize* alone.
color : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None
Text color for title text.
dx : dict, float, :class:`ExprRef`
Delta offset for title and subtitle text x-coordinate.
dy : dict, float, :class:`ExprRef`
Delta offset for title and subtitle text y-coordinate.
font : str, dict, :class:`ExprRef`
Font name for title text.
fontSize : dict, float, :class:`ExprRef`
Font size in pixels for title text.
fontStyle : str, dict, :class:`ExprRef`, :class:`FontStyle`
Font style for title text.
fontWeight : dict, :class:`ExprRef`, :class:`FontWeight`, Literal['normal', 'bold', 'lighter', 'bolder', 100, 200, 300, 400, 500, 600, 700, 800, 900]
Font weight for title text. This can be either a string (e.g ``"bold"``,
``"normal"``) or a number (``100``, ``200``, ``300``, ..., ``900`` where
``"normal"`` = ``400`` and ``"bold"`` = ``700``).
frame : str, dict, :class:`ExprRef`, :class:`TitleFrame`, Literal['bounds', 'group']
The reference frame for the anchor position, one of ``"bounds"`` (to anchor relative
to the full bounding box) or ``"group"`` (to anchor relative to the group width or
height).
limit : dict, float, :class:`ExprRef`
The maximum allowed length in pixels of title and subtitle text.
lineHeight : dict, float, :class:`ExprRef`
Line height in pixels for multi-line title text or title text with ``"line-top"`` or
``"line-bottom"`` baseline.
offset : dict, float, :class:`ExprRef`
The orthogonal offset in pixels by which to displace the title group from its
position along the edge of the chart.
orient : dict, :class:`ExprRef`, :class:`TitleOrient`, Literal['none', 'left', 'right', 'top', 'bottom']
Default title orientation (``"top"``, ``"bottom"``, ``"left"``, or ``"right"``)
subtitleColor : str, dict, :class:`Color`, :class:`ExprRef`, :class:`HexColor`, :class:`ColorName`, Literal['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'], None
Text color for subtitle text.
subtitleFont : str, dict, :class:`ExprRef`
Font name for subtitle text.
subtitleFontSize : dict, float, :class:`ExprRef`
Font size in pixels for subtitle text.
subtitleFontStyle : str, dict, :class:`ExprRef`, :class:`FontStyle`
Font style for subtitle text.
subtitleFontWeight : dict, :class:`ExprRef`, :class:`FontWeight`, Literal['normal', 'bold', 'lighter', 'bolder', 100, 200, 300, 400, 500, 600, 700, 800, 900]
Font weight for subtitle text. This can be either a string (e.g ``"bold"``,
``"normal"``) or a number (``100``, ``200``, ``300``, ..., ``900`` where
``"normal"`` = ``400`` and ``"bold"`` = ``700``).
subtitleLineHeight : dict, float, :class:`ExprRef`
Line height in pixels for multi-line subtitle text.
subtitlePadding : dict, float, :class:`ExprRef`
The padding in pixels between title and subtitle text.
zindex : dict, float, :class:`ExprRef`
The integer z-index indicating the layering of the title group relative to other
axis, mark, and legend groups.
**Default value:** ``0``.
"""
_schema = {"$ref": "#/definitions/TitleConfig"}
def __init__(
self,
align: Optional[SchemaBase | Align_T] = Undefined,
anchor: Optional[Parameter | SchemaBase | Map | TitleAnchor_T] = Undefined,
angle: Optional[float | Parameter | SchemaBase | Map] = Undefined,
aria: Optional[bool | Parameter | SchemaBase | Map] = Undefined,
baseline: Optional[SchemaBase | TextBaseline_T] = Undefined,
color: Optional[
str | Parameter | SchemaBase | Map | ColorName_T | None
] = Undefined,
dx: Optional[float | Parameter | SchemaBase | Map] = Undefined,
dy: Optional[float | Parameter | SchemaBase | Map] = Undefined,
font: Optional[str | Parameter | SchemaBase | Map] = Undefined,
fontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined,
fontStyle: Optional[str | Parameter | SchemaBase | Map] = Undefined,
fontWeight: Optional[Parameter | SchemaBase | Map | FontWeight_T] = Undefined,
frame: Optional[str | Parameter | SchemaBase | Map | TitleFrame_T] = Undefined,
limit: Optional[float | Parameter | SchemaBase | Map] = Undefined,
lineHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined,
offset: Optional[float | Parameter | SchemaBase | Map] = Undefined,
orient: Optional[Parameter | SchemaBase | Map | TitleOrient_T] = Undefined,
subtitleColor: Optional[
str | Parameter | SchemaBase | Map | ColorName_T | None
] = Undefined,
subtitleFont: Optional[str | Parameter | SchemaBase | Map] = Undefined,
subtitleFontSize: Optional[float | Parameter | SchemaBase | Map] = Undefined,
subtitleFontStyle: Optional[str | Parameter | SchemaBase | Map] = Undefined,
subtitleFontWeight: Optional[
Parameter | SchemaBase | Map | FontWeight_T
] = Undefined,
subtitleLineHeight: Optional[float | Parameter | SchemaBase | Map] = Undefined,
subtitlePadding: Optional[float | Parameter | SchemaBase | Map] = Undefined,
zindex: Optional[float | Parameter | SchemaBase | Map] = Undefined,
**kwds,
):
super().__init__(
align=align,
anchor=anchor,
angle=angle,
aria=aria,
baseline=baseline,
color=color,
dx=dx,
dy=dy,
font=font,
fontSize=fontSize,
fontStyle=fontStyle,
fontWeight=fontWeight,
frame=frame,
limit=limit,
lineHeight=lineHeight,
offset=offset,
orient=orient,
subtitleColor=subtitleColor,
subtitleFont=subtitleFont,
subtitleFontSize=subtitleFontSize,
subtitleFontStyle=subtitleFontStyle,
subtitleFontWeight=subtitleFontWeight,
subtitleLineHeight=subtitleLineHeight,
subtitlePadding=subtitlePadding,
zindex=zindex,
**kwds,
)
| TitleConfig |
python | ray-project__ray | python/ray/tests/test_autoscaler_fake_scaledown.py | {
"start": 254,
"end": 6340
} | class ____:
def __init__(self):
self.data = []
def f(self):
pass
def recv(self, obj):
pass
def create(self, size):
return np.zeros(size)
# Tests that we scale down even if secondary copies of objects are present on
# idle nodes: https://github.com/ray-project/ray/issues/21870
@pytest.mark.skipif(platform.system() == "Windows", reason="Failing on Windows.")
@pytest.mark.parametrize("autoscaler_v2", [False, True], ids=["v1", "v2"])
def test_scaledown_shared_objects(autoscaler_v2, shutdown_only):
cluster = AutoscalingCluster(
head_resources={"CPU": 0},
worker_node_types={
"cpu_node": {
"resources": {
"CPU": 1,
"object_store_memory": 100 * 1024 * 1024,
},
"node_config": {},
"min_workers": 0,
"max_workers": 5,
},
},
idle_timeout_minutes=0.05,
autoscaler_v2=autoscaler_v2,
)
try:
cluster.start(_system_config={"scheduler_report_pinned_bytes_only": True})
ray.init("auto")
actors = [Actor.remote() for _ in range(5)]
ray.get([a.f.remote() for a in actors])
print("All five nodes launched")
# Verify scale-up.
wait_for_condition(lambda: ray.cluster_resources().get("CPU", 0) == 5)
data = actors[0].create.remote(1024 * 1024 * 5)
ray.get([a.recv.remote(data) for a in actors])
print("Data broadcast successfully, deleting actors.")
del actors
# Verify scale-down.
wait_for_condition(
lambda: ray.cluster_resources().get("CPU", 0) == 1, timeout=30
)
finally:
cluster.shutdown()
def check_memory(local_objs, num_spilled_objects=None, num_plasma_objects=None):
def ok():
s = ray._private.internal_api.memory_summary()
print(f"\n\nMemory Summary:\n{s}\n")
actual_objs = re.findall(r"LOCAL_REFERENCE[\s|\|]+([0-9a-f]+)", s)
if sorted(actual_objs) != sorted(local_objs):
raise RuntimeError(
f"Expect local objects={local_objs}, actual={actual_objs}"
)
if num_spilled_objects is not None:
m = re.search(r"Spilled (\d+) MiB, (\d+) objects", s)
if m is not None:
actual_spilled_objects = int(m.group(2))
if actual_spilled_objects < num_spilled_objects:
raise RuntimeError(
f"Expected spilled objects={num_spilled_objects} "
f"greater than actual={actual_spilled_objects}"
)
if num_plasma_objects is not None:
m = re.search(r"Plasma memory usage (\d+) MiB, (\d+) objects", s)
if m is None:
raise RuntimeError(
"Memory summary does not contain Plasma memory objects count"
)
actual_plasma_objects = int(m.group(2))
if actual_plasma_objects != num_plasma_objects:
raise RuntimeError(
f"Expected plasma objects={num_plasma_objects} not equal "
f"to actual={actual_plasma_objects}"
)
return True
wait_for_condition(ok, timeout=30, retry_interval_ms=5000)
# Tests that node with live spilled object does not get scaled down.
@pytest.mark.skipif(platform.system() == "Windows", reason="Failing on Windows.")
@pytest.mark.parametrize("autoscaler_v2", [False, True], ids=["v1", "v2"])
def test_no_scaledown_with_spilled_objects(autoscaler_v2, shutdown_only):
cluster = AutoscalingCluster(
head_resources={"CPU": 0},
worker_node_types={
"cpu_node": {
"resources": {
"CPU": 1,
"object_store_memory": 75 * 1024 * 1024,
},
"node_config": {},
"min_workers": 0,
"max_workers": 2,
},
},
idle_timeout_minutes=0.05,
autoscaler_v2=autoscaler_v2,
)
try:
cluster.start(
_system_config={
"scheduler_report_pinned_bytes_only": True,
"min_spilling_size": 0,
}
)
ray.init("auto")
actors = [Actor.remote() for _ in range(2)]
ray.get([a.f.remote() for a in actors])
# Verify scale-up.
wait_for_condition(lambda: ray.cluster_resources().get("CPU", 0) == 2)
print("All nodes launched")
# Put 10 x 80MiB objects into the object store with 75MiB memory limit.
obj_size = 10 * 1024 * 1024
objs = []
for i in range(10):
obj = actors[0].create.remote(obj_size)
ray.get(actors[1].recv.remote(obj))
objs.append(obj)
print(f"obj {i}={obj.hex()}")
del obj
# At least 9 out of the 10 objects should have spilled.
check_memory([obj.hex() for obj in objs], num_spilled_objects=9)
print("Objects spilled, deleting actors and object references.")
# Assume the 1st object always gets spilled.
spilled_obj = objs[0]
del objs
del actors
# Verify scale-down to 1 node.
def scaledown_to_one():
cpu = ray.cluster_resources().get("CPU", 0)
assert cpu > 0, "Scale-down should keep at least 1 node"
return cpu == 1
wait_for_condition(scaledown_to_one, timeout=30)
# Verify the spilled object still exists, and there is no object in the
# plasma store.
check_memory([spilled_obj.hex()], num_plasma_objects=0)
# Delete the spilled object, the remaining worker node should be scaled
# down.
del spilled_obj
wait_for_condition(lambda: ray.cluster_resources().get("CPU", 0) == 0)
check_memory([], num_plasma_objects=0)
finally:
cluster.shutdown()
if __name__ == "__main__":
sys.exit(pytest.main(["-sv", __file__]))
| Actor |
python | numba__llvmlite | llvmlite/ir/_utils.py | {
"start": 1196,
"end": 1433
} | class ____(object):
def get_reference(self):
try:
return self.__cached_refstr
except AttributeError:
s = self.__cached_refstr = self._get_reference()
return s
| _StringReferenceCaching |
python | ray-project__ray | python/ray/serve/tests/test_config_files/broken_app.py | {
"start": 57,
"end": 554
} | class ____(Exception):
"""This exception cannot be serialized."""
def __reduce__(self):
raise RuntimeError("This exception cannot be serialized!")
# Confirm that NonserializableException cannot be serialized.
try:
pickle.dumps(NonserializableException())
except RuntimeError as e:
assert "This exception cannot be serialized!" in repr(e)
raise NonserializableException("custom exception info")
@serve.deployment
def f():
pass
app = f.bind()
| NonserializableException |
python | microsoft__pyright | packages/pyright-internal/src/tests/samples/metaclass9.py | {
"start": 557,
"end": 689
} | class ____(metaclass=Meta1, param1="", param2=""): ...
# This should generate an error because param1 and param2 are missing.
| Class1_3 |
python | airbytehq__airbyte | airbyte-integrations/connectors/source-gnews/components.py | {
"start": 369,
"end": 1006
} | class ____(BackoffStrategy):
"""
Backoff strategy that waits until next midnight
"""
parameters: InitVar[Mapping[str, Any]]
config: Config
def backoff_time(
self, response_or_exception: Optional[Union[requests.Response, requests.RequestException]], attempt_count: int
) -> Optional[float]:
now_utc = datetime.now(datetime.timezone.utc)
midnight_utc = (now_utc + timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
delta = midnight_utc - now_utc
return delta.total_seconds() if type(delta) is timedelta else delta.seconds
| WaitUntilMidnightBackoffStrategy |
python | scikit-learn__scikit-learn | sklearn/frozen/_frozen.py | {
"start": 623,
"end": 5015
} | class ____(BaseEstimator):
"""Estimator that wraps a fitted estimator to prevent re-fitting.
This meta-estimator takes an estimator and freezes it, in the sense that calling
`fit` on it has no effect. `fit_predict` and `fit_transform` are also disabled.
All other methods are delegated to the original estimator and original estimator's
attributes are accessible as well.
This is particularly useful when you have a fitted or a pre-trained model as a
transformer in a pipeline, and you'd like `pipeline.fit` to have no effect on this
step.
Parameters
----------
estimator : estimator
The estimator which is to be kept frozen.
See Also
--------
None: No similar entry in the scikit-learn documentation.
Examples
--------
>>> from sklearn.datasets import make_classification
>>> from sklearn.frozen import FrozenEstimator
>>> from sklearn.linear_model import LogisticRegression
>>> X, y = make_classification(random_state=0)
>>> clf = LogisticRegression(random_state=0).fit(X, y)
>>> frozen_clf = FrozenEstimator(clf)
>>> frozen_clf.fit(X, y) # No-op
FrozenEstimator(estimator=LogisticRegression(random_state=0))
>>> frozen_clf.predict(X) # Predictions from `clf.predict`
array(...)
"""
def __init__(self, estimator):
self.estimator = estimator
@available_if(_estimator_has("__getitem__"))
def __getitem__(self, *args, **kwargs):
"""__getitem__ is defined in :class:`~sklearn.pipeline.Pipeline` and \
:class:`~sklearn.compose.ColumnTransformer`.
"""
return self.estimator.__getitem__(*args, **kwargs)
def __getattr__(self, name):
# `estimator`'s attributes are now accessible except `fit_predict` and
# `fit_transform`
if name in ["fit_predict", "fit_transform"]:
raise AttributeError(f"{name} is not available for frozen estimators.")
return getattr(self.estimator, name)
def __sklearn_clone__(self):
return self
def __sklearn_is_fitted__(self):
try:
check_is_fitted(self.estimator)
return True
except NotFittedError:
return False
def fit(self, X, y, *args, **kwargs):
"""No-op.
As a frozen estimator, calling `fit` has no effect.
Parameters
----------
X : object
Ignored.
y : object
Ignored.
*args : tuple
Additional positional arguments. Ignored, but present for API compatibility
with `self.estimator`.
**kwargs : dict
Additional keyword arguments. Ignored, but present for API compatibility
with `self.estimator`.
Returns
-------
self : object
Returns the instance itself.
"""
check_is_fitted(self.estimator)
return self
def set_params(self, **kwargs):
"""Set the parameters of this estimator.
The only valid key here is `estimator`. You cannot set the parameters of the
inner estimator.
Parameters
----------
**kwargs : dict
Estimator parameters.
Returns
-------
self : FrozenEstimator
This estimator.
"""
estimator = kwargs.pop("estimator", None)
if estimator is not None:
self.estimator = estimator
if kwargs:
raise ValueError(
"You cannot set parameters of the inner estimator in a frozen "
"estimator since calling `fit` has no effect. You can use "
"`frozenestimator.estimator.set_params` to set parameters of the inner "
"estimator."
)
def get_params(self, deep=True):
"""Get parameters for this estimator.
Returns a `{"estimator": estimator}` dict. The parameters of the inner
estimator are not included.
Parameters
----------
deep : bool, default=True
Ignored.
Returns
-------
params : dict
Parameter names mapped to their values.
"""
return {"estimator": self.estimator}
def __sklearn_tags__(self):
tags = deepcopy(get_tags(self.estimator))
tags._skip_test = True
return tags
| FrozenEstimator |
python | airbytehq__airbyte | airbyte-integrations/connectors/source-github/source_github/github_schema.py | {
"start": 3954,
"end": 4216
} | class ____(sgqlc.types.Enum):
"""The possible types of check runs.
Enumeration Choices:
* `ALL`: Every check run available.
* `LATEST`: The latest check run.
"""
__schema__ = github_schema
__choices__ = ("ALL", "LATEST")
| CheckRunType |
python | realpython__materials | python-enum/roles.py | {
"start": 187,
"end": 482
} | class ____(Flag):
OWNER = 8
POWER_USER = 4
USER = 2
SUPERVISOR = 1
ADMIN = OWNER | POWER_USER | USER | SUPERVISOR
john = Role.USER | Role.SUPERVISOR
if Role.USER in john:
print("John, you're a user")
if Role.SUPERVISOR in john:
print("John, you're a supervisor")
| Role |
python | django__django | django/db/migrations/state.py | {
"start": 24921,
"end": 25490
} | class ____(AppConfig):
"""Stub of an AppConfig. Only provides a label and a dict of models."""
def __init__(self, label):
self.apps = None
self.models = {}
# App-label and app-name are not the same thing, so technically passing
# in the label here is wrong. In practice, migrations don't care about
# the app name, but we need something unique, and the label works fine.
self.label = label
self.name = label
def import_models(self):
self.models = self.apps.all_models[self.label]
| AppConfigStub |
python | doocs__leetcode | solution/2400-2499/2432.The Employee That Worked on the Longest Task/Solution.py | {
"start": 0,
"end": 285
} | class ____:
def hardestWorker(self, n: int, logs: List[List[int]]) -> int:
last = mx = ans = 0
for uid, t in logs:
t -= last
if mx < t or (mx == t and ans > uid):
ans, mx = uid, t
last += t
return ans
| Solution |
python | pytorch__pytorch | test/torch_np/numpy_tests/lib/test_function_base.py | {
"start": 76054,
"end": 77545
} | class ____(TestCase):
def test_simple(self):
assert_almost_equal(i0(0.5), np.array(1.0634833707413234))
# need at least one test above 8, as the implementation is piecewise
A = np.array([0.49842636, 0.6969809, 0.22011976, 0.0155549, 10.0])
expected = np.array(
[1.06307822, 1.12518299, 1.01214991, 1.00006049, 2815.71662847]
)
assert_almost_equal(i0(A), expected)
assert_almost_equal(i0(-A), expected)
B = np.array(
[
[0.827002, 0.99959078],
[0.89694769, 0.39298162],
[0.37954418, 0.05206293],
[0.36465447, 0.72446427],
[0.48164949, 0.50324519],
]
)
assert_almost_equal(
i0(B),
np.array(
[
[1.17843223, 1.26583466],
[1.21147086, 1.03898290],
[1.03633899, 1.00067775],
[1.03352052, 1.13557954],
[1.05884290, 1.06432317],
]
),
)
# Regression test for gh-11205
i0_0 = np.i0([0.0])
assert_equal(i0_0.shape, (1,))
assert_array_equal(np.i0([0.0]), np.array([1.0]))
def test_complex(self):
a = np.array([0, 1 + 2j])
with pytest.raises(
(TypeError, RuntimeError),
# match="i0 not supported for complex values"
):
i0(a)
| Test_I0 |
python | wandb__wandb | wandb/vendor/pygments/lexers/ecl.py | {
"start": 440,
"end": 5875
} | class ____(RegexLexer):
"""
Lexer for the declarative big-data `ECL
<http://hpccsystems.com/community/docs/ecl-language-reference/html>`_
language.
.. versionadded:: 1.5
"""
name = 'ECL'
aliases = ['ecl']
filenames = ['*.ecl']
mimetypes = ['application/x-ecl']
flags = re.IGNORECASE | re.MULTILINE
tokens = {
'root': [
include('whitespace'),
include('statements'),
],
'whitespace': [
(r'\s+', Text),
(r'\/\/.*', Comment.Single),
(r'/(\\\n)?\*(.|\n)*?\*(\\\n)?/', Comment.Multiline),
],
'statements': [
include('types'),
include('keywords'),
include('functions'),
include('hash'),
(r'"', String, 'string'),
(r'\'', String, 'string'),
(r'(\d+\.\d*|\.\d+|\d+)e[+-]?\d+[lu]*', Number.Float),
(r'(\d+\.\d*|\.\d+|\d+f)f?', Number.Float),
(r'0x[0-9a-f]+[lu]*', Number.Hex),
(r'0[0-7]+[lu]*', Number.Oct),
(r'\d+[lu]*', Number.Integer),
(r'\*/', Error),
(r'[~!%^&*+=|?:<>/-]+', Operator),
(r'[{}()\[\],.;]', Punctuation),
(r'[a-z_]\w*', Name),
],
'hash': [
(r'^#.*$', Comment.Preproc),
],
'types': [
(r'(RECORD|END)\D', Keyword.Declaration),
(r'((?:ASCII|BIG_ENDIAN|BOOLEAN|DATA|DECIMAL|EBCDIC|INTEGER|PATTERN|'
r'QSTRING|REAL|RECORD|RULE|SET OF|STRING|TOKEN|UDECIMAL|UNICODE|'
r'UNSIGNED|VARSTRING|VARUNICODE)\d*)(\s+)',
bygroups(Keyword.Type, Text)),
],
'keywords': [
(words((
'APPLY', 'ASSERT', 'BUILD', 'BUILDINDEX', 'EVALUATE', 'FAIL',
'KEYDIFF', 'KEYPATCH', 'LOADXML', 'NOTHOR', 'NOTIFY', 'OUTPUT',
'PARALLEL', 'SEQUENTIAL', 'SOAPCALL', 'CHECKPOINT', 'DEPRECATED',
'FAILCODE', 'FAILMESSAGE', 'FAILURE', 'GLOBAL', 'INDEPENDENT',
'ONWARNING', 'PERSIST', 'PRIORITY', 'RECOVERY', 'STORED', 'SUCCESS',
'WAIT', 'WHEN'), suffix=r'\b'),
Keyword.Reserved),
# These are classed differently, check later
(words((
'ALL', 'AND', 'ANY', 'AS', 'ATMOST', 'BEFORE', 'BEGINC++', 'BEST', 'BETWEEN', 'CASE',
'CONST', 'COUNTER', 'CSV', 'DESCEND', 'ENCRYPT', 'ENDC++', 'ENDMACRO', 'EXCEPT',
'EXCLUSIVE', 'EXPIRE', 'EXPORT', 'EXTEND', 'FALSE', 'FEW', 'FIRST', 'FLAT', 'FULL',
'FUNCTION', 'GROUP', 'HEADER', 'HEADING', 'HOLE', 'IFBLOCK', 'IMPORT', 'IN', 'JOINED',
'KEEP', 'KEYED', 'LAST', 'LEFT', 'LIMIT', 'LOAD', 'LOCAL', 'LOCALE', 'LOOKUP', 'MACRO',
'MANY', 'MAXCOUNT', 'MAXLENGTH', 'MIN SKEW', 'MODULE', 'INTERFACE', 'NAMED', 'NOCASE',
'NOROOT', 'NOSCAN', 'NOSORT', 'NOT', 'OF', 'ONLY', 'OPT', 'OR', 'OUTER', 'OVERWRITE',
'PACKED', 'PARTITION', 'PENALTY', 'PHYSICALLENGTH', 'PIPE', 'QUOTE', 'RELATIONSHIP',
'REPEAT', 'RETURN', 'RIGHT', 'SCAN', 'SELF', 'SEPARATOR', 'SERVICE', 'SHARED', 'SKEW',
'SKIP', 'SQL', 'STORE', 'TERMINATOR', 'THOR', 'THRESHOLD', 'TOKEN', 'TRANSFORM', 'TRIM',
'TRUE', 'TYPE', 'UNICODEORDER', 'UNSORTED', 'VALIDATE', 'VIRTUAL', 'WHOLE', 'WILD',
'WITHIN', 'XML', 'XPATH', '__COMPRESSED__'), suffix=r'\b'),
Keyword.Reserved),
],
'functions': [
(words((
'ABS', 'ACOS', 'ALLNODES', 'ASCII', 'ASIN', 'ASSTRING', 'ATAN', 'ATAN2', 'AVE', 'CASE',
'CHOOSE', 'CHOOSEN', 'CHOOSESETS', 'CLUSTERSIZE', 'COMBINE', 'CORRELATION', 'COS',
'COSH', 'COUNT', 'COVARIANCE', 'CRON', 'DATASET', 'DEDUP', 'DEFINE', 'DENORMALIZE',
'DISTRIBUTE', 'DISTRIBUTED', 'DISTRIBUTION', 'EBCDIC', 'ENTH', 'ERROR', 'EVALUATE',
'EVENT', 'EVENTEXTRA', 'EVENTNAME', 'EXISTS', 'EXP', 'FAILCODE', 'FAILMESSAGE',
'FETCH', 'FROMUNICODE', 'GETISVALID', 'GLOBAL', 'GRAPH', 'GROUP', 'HASH', 'HASH32',
'HASH64', 'HASHCRC', 'HASHMD5', 'HAVING', 'IF', 'INDEX', 'INTFORMAT', 'ISVALID',
'ITERATE', 'JOIN', 'KEYUNICODE', 'LENGTH', 'LIBRARY', 'LIMIT', 'LN', 'LOCAL', 'LOG', 'LOOP',
'MAP', 'MATCHED', 'MATCHLENGTH', 'MATCHPOSITION', 'MATCHTEXT', 'MATCHUNICODE',
'MAX', 'MERGE', 'MERGEJOIN', 'MIN', 'NOLOCAL', 'NONEMPTY', 'NORMALIZE', 'PARSE', 'PIPE',
'POWER', 'PRELOAD', 'PROCESS', 'PROJECT', 'PULL', 'RANDOM', 'RANGE', 'RANK', 'RANKED',
'REALFORMAT', 'RECORDOF', 'REGEXFIND', 'REGEXREPLACE', 'REGROUP', 'REJECTED',
'ROLLUP', 'ROUND', 'ROUNDUP', 'ROW', 'ROWDIFF', 'SAMPLE', 'SET', 'SIN', 'SINH', 'SIZEOF',
'SOAPCALL', 'SORT', 'SORTED', 'SQRT', 'STEPPED', 'STORED', 'SUM', 'TABLE', 'TAN', 'TANH',
'THISNODE', 'TOPN', 'TOUNICODE', 'TRANSFER', 'TRIM', 'TRUNCATE', 'TYPEOF', 'UNGROUP',
'UNICODEORDER', 'VARIANCE', 'WHICH', 'WORKUNIT', 'XMLDECODE', 'XMLENCODE',
'XMLTEXT', 'XMLUNICODE'), suffix=r'\b'),
Name.Function),
],
'string': [
(r'"', String, '#pop'),
(r'\'', String, '#pop'),
(r'[^"\']+', String),
],
}
| ECLLexer |
python | gevent__gevent | src/greentest/3.11/test_signal.py | {
"start": 442,
"end": 2647
} | class ____(unittest.TestCase):
def test_enums(self):
for name in dir(signal):
sig = getattr(signal, name)
if name in {'SIG_DFL', 'SIG_IGN'}:
self.assertIsInstance(sig, signal.Handlers)
elif name in {'SIG_BLOCK', 'SIG_UNBLOCK', 'SIG_SETMASK'}:
self.assertIsInstance(sig, signal.Sigmasks)
elif name.startswith('SIG') and not name.startswith('SIG_'):
self.assertIsInstance(sig, signal.Signals)
elif name.startswith('CTRL_'):
self.assertIsInstance(sig, signal.Signals)
self.assertEqual(sys.platform, "win32")
CheckedSignals = enum._old_convert_(
enum.IntEnum, 'Signals', 'signal',
lambda name:
name.isupper()
and (name.startswith('SIG') and not name.startswith('SIG_'))
or name.startswith('CTRL_'),
source=signal,
)
enum._test_simple_enum(CheckedSignals, signal.Signals)
CheckedHandlers = enum._old_convert_(
enum.IntEnum, 'Handlers', 'signal',
lambda name: name in ('SIG_DFL', 'SIG_IGN'),
source=signal,
)
enum._test_simple_enum(CheckedHandlers, signal.Handlers)
Sigmasks = getattr(signal, 'Sigmasks', None)
if Sigmasks is not None:
CheckedSigmasks = enum._old_convert_(
enum.IntEnum, 'Sigmasks', 'signal',
lambda name: name in ('SIG_BLOCK', 'SIG_UNBLOCK', 'SIG_SETMASK'),
source=signal,
)
enum._test_simple_enum(CheckedSigmasks, Sigmasks)
def test_functions_module_attr(self):
# Issue #27718: If __all__ is not defined all non-builtin functions
# should have correct __module__ to be displayed by pydoc.
for name in dir(signal):
value = getattr(signal, name)
if inspect.isroutine(value) and not inspect.isbuiltin(value):
self.assertEqual(value.__module__, 'signal')
@unittest.skipIf(sys.platform == "win32", "Not valid on Windows")
| GenericTests |
python | apache__airflow | providers/google/src/airflow/providers/google/cloud/operators/vertex_ai/feature_store.py | {
"start": 12539,
"end": 16842
} | class ____(GoogleCloudBaseOperator, OperationHelper):
"""
Create request for Feature View creation.
This method initiates VertexAI Feature View request for the existing Feature Online Store.
Feature View represents features and data according to the source provided.
:param feature_view_id: The ID to use for the FeatureView, which will become the final component
of the FeatureView's resource name. This value may be up to 60 characters, and valid characters
are ``[a-z0-9_]``. The first character cannot be a number.
The value must be unique within a FeatureOnlineStore.
:param feature_view: The configuration of the FeatureView to create.
:param feature_online_store_id: The ID of the online feature store.
:param run_sync_immediately: If set to true, one on demand sync will be run
immediately, regardless the FeatureView.sync_config.
:param project_id: Required. The ID of the Google Cloud project that contains the feature store.
This is used to identify which project's resources to interact with.
:param location: Required. The location of the feature store (e.g., 'us-central1', 'us-east1').
This specifies the Google Cloud region where the feature store resources are located.
:param gcp_conn_id: The connection ID to use for connecting to Google Cloud Platform.
Defaults to 'google_cloud_default'.
:param impersonation_chain: Optional service account to impersonate using short-term
credentials. Can be either a single account or a chain of accounts required to
get the access_token of the last account in the list, which will be impersonated
in the request. If set as a string, the account must grant the originating account
the Service Account Token Creator IAM role. If set as a sequence, the identities
from the list must grant Service Account Token Creator IAM role to the directly
preceding identity, with first account from the list granting this role to the
originating account.
"""
template_fields: Sequence[str] = (
"project_id",
"location",
"feature_online_store_id",
)
def __init__(
self,
*,
feature_view_id: str,
feature_view: FeatureView,
feature_online_store_id: str,
run_sync_immediately: bool = False,
project_id: str,
location: str,
timeout: float | _MethodDefault = DEFAULT,
retry: Retry | _MethodDefault | None = DEFAULT,
metadata: Sequence[tuple[str, str]] = (),
gcp_conn_id: str = "google_cloud_default",
impersonation_chain: str | Sequence[str] | None = None,
**kwargs,
) -> None:
super().__init__(**kwargs)
self.project_id = project_id
self.location = location
self.feature_view_id = feature_view_id
self.feature_view = feature_view
self.run_sync_immediately = run_sync_immediately
self.feature_online_store_id = feature_online_store_id
self.timeout = timeout
self.retry = retry
self.metadata = metadata
self.gcp_conn_id = gcp_conn_id
self.impersonation_chain = impersonation_chain
def execute(self, context: Context) -> dict[str, Any]:
"""Execute the get feature view sync operation."""
hook = FeatureStoreHook(
gcp_conn_id=self.gcp_conn_id,
impersonation_chain=self.impersonation_chain,
)
self.log.info("Creating the Online Store Feature View...")
result_operation = hook.create_feature_view(
project_id=self.project_id,
location=self.location,
feature_view_id=self.feature_view_id,
feature_view=self.feature_view,
feature_online_store_id=self.feature_online_store_id,
run_sync_immediately=self.run_sync_immediately,
timeout=self.timeout,
retry=self.retry,
metadata=self.metadata,
)
op_result = self.wait_for_operation_result(operation=result_operation)
self.log.info("The Online Store Feature View has been created: %s", self.feature_online_store_id)
result = type(op_result).to_dict(op_result)
return result
| CreateFeatureViewOperator |
python | run-llama__llama_index | llama-index-core/llama_index/core/base/base_selector.py | {
"start": 421,
"end": 531
} | class ____(BaseModel):
"""A single selection of a choice."""
index: int
reason: str
| SingleSelection |
python | ethereum__web3.py | web3/_utils/events.py | {
"start": 15557,
"end": 15820
} | class ____(BaseArgumentFilter):
# type ignore b/c conflict with BaseArgumentFilter.match_values type
@property
def match_values(self) -> tuple[TypeStr, tuple[Any, ...]]: # type: ignore
return self.arg_type, self._match_values
| DataArgumentFilter |
python | django__django | tests/serializers/models/data.py | {
"start": 999,
"end": 1108
} | class ____(models.Model):
data = models.DecimalField(null=True, decimal_places=3, max_digits=5)
| DecimalData |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.