TheBloke/dolphin-2.7-mixtral-8x7b-GPTQ
Text Generation
•
Updated
•
61.7k
•
18
Datasets:
lang
stringclasses 9
values | raw_index
int64 4
150k
| index
int64 0
40k
| seed
stringlengths 1
3.85k
| openai_fingerprint
stringclasses 1
value | problem
stringlengths 139
6.98k
| solution
stringlengths 52
7.08k
|
|---|---|---|---|---|---|---|
cpp | 101,533 | 4,626 | int n;
cin >> n;
vector<int> a(n + 1), b(n + 1);
for (int i = 1; i <= n; ++i) cin >> a[i] >> b[i];
auto c = convolution(a, b);
for (int i = 1; i <= 2 * n; ++i) cout << c[i] << endl;
}
| fp_eeff13170a | You are given two arrays, A and B, each of length n. You need to perform a convolution operation on these arrays and output the resulting array.
The convolution of two arrays A and B is defined as follows:
- Let C be the resulting array of length 2n-1, where C[i] = Σ(A[j] * B[i-j]) for j = max(0, i-n+1) to min(i, n-1).
Write a function or method to perform the convolution operation and return the resulting array C.
Function Signature:
```cpp
vector<int> convolution(vector<int> a, vector<int> b)
```
Input:
- Two arrays a and b of length n (1 <= n <= 10^5), where each element of the array is an integer (-10^9 <= a[i], b[i] <= 10^9).
Output:
- Return the resulting array C after performing the convolution operation.
Example:
Input:
a = [1, 2, 3]
b = [4, 5, 6]
Output:
convolution(a, b) -> [4, 13, 28, 27, 18] | ```cpp
#include <iostream>
#include <vector>
using namespace std;
vector<int> convolution(vector<int> a, vector<int> b) {
int n = a.size();
vector<int> c(2 * n - 1, 0);
for (int i = 0; i < 2 * n - 1; ++i) {
for (int j = max(0, i - n + 1); j <= min(i, n - 1); ++j) {
c[i] += a[j] * b[i - j];
}
}
return c;
}
int main() {
vector<int> a = {1, 2, 3};
vector<int> b = {4, 5, 6};
vector<int> result = convolution(a, b);
for (int i = 0; i < result.size(); ++i) {
cout << result[i] << " ";
}
return 0;
}
``` |
python | 131,094 | 37,716 | return jinja
| fp_eeff13170a | You are tasked with implementing a simple Python function that takes a list of strings as input and returns a new list containing only the strings that are palindromes. A palindrome is a word, phrase, number, or other sequence of characters that reads the same forward and backward (ignoring spaces, punctuation, and capitalization).
You are provided with the following code snippet as a starting point:
```python
def find_palindromes(words):
# Your code here
return palindromes
```
Your task is to complete the `find_palindromes` function to filter out the palindromes from the input list of strings and return a new list containing only the palindromes.
For example, if the input list is `["radar", "hello", "level", "world", "Anna"]`, the function should return `["radar", "level", "Anna"]`. | ```python
def find_palindromes(words):
palindromes = [word for word in words if word.lower().replace(" ", "") == word[::-1].lower().replace(" ", "")]
return palindromes
```
The `find_palindromes` function uses list comprehension to iterate through the input list of strings. For each word, it checks if the lowercase version of the word with spaces removed is equal to its reverse in lowercase with spaces removed. If the condition is met, the word is considered a palindrome and added to the `palindromes` list. Finally, the list of palindromes is returned. |
cpp | 145,091 | 3,213 |
return sum == num;
}
};
// WTF
class Solution {
public:
bool checkPerfectNumber(int num) {
static unordered_set<int> n = {6, 28, 496, 8128, 33550336};
return n.find(num) != n.end();
}
}; | fp_eeff13170a | You are given a class `Solution` with a method `checkPerfectNumber` which takes an integer `num` as input. The method should return `true` if the given number is a perfect number, and `false` otherwise. A perfect number is a positive integer that is equal to the sum of its proper divisors, excluding itself.
For example, 6 is a perfect number since its proper divisors are 1, 2, and 3, and 1 + 2 + 3 = 6.
You need to implement the `checkPerfectNumber` method to determine if the given number is a perfect number. | ```cpp
#include <unordered_set>
#include <cmath>
class Solution {
public:
bool checkPerfectNumber(int num) {
if (num <= 1) {
return false;
}
int sum = 1; // 1 is always a proper divisor
int sqrtNum = sqrt(num);
for (int i = 2; i <= sqrtNum; i++) {
if (num % i == 0) {
sum += i;
if (i != num / i) {
sum += num / i;
}
}
}
return sum == num;
}
};
```
In the `checkPerfectNumber` method, we first handle the base case where `num` is less than or equal to 1, in which case it cannot be a perfect number. Then, we iterate through all numbers from 2 to the square root of `num` to find its proper divisors. For each divisor found, we add it to the `sum` and also add its complement divisor if it's not the same. Finally, we compare the `sum` with the original `num` and return `true` if they are equal, indicating that `num` is a perfect number, and `false` otherwise. |
python | 21,428 | 32,012 | return ("daddress", t[0])
def dcommand(self, t):
return ("dcommand", str(t[0]))
def doaddress(self, t):
return ("doaddress", t[0])
def dosymbol(self, t):
return ('dosymbol', str(t[0]))
| fp_eeff13170a | You are tasked with implementing a parser for a simple programming language. The language has four types of tokens: "daddress", "dcommand", "doaddress", and "dosymbol". The parser should take a list of tokens as input and return a parsed representation of the input.
You are provided with a code snippet that contains the definitions of four functions: `daddress`, `dcommand`, `doaddress`, and `dosymbol`. Each function takes a single argument `t` representing a token and returns a tuple containing the type of the token and its value.
Your task is to implement the parser function that takes a list of tokens and uses the provided functions to parse and return the parsed representation of the input.
Implement the following function:
```python
def parse_tokens(tokens):
parsed_tokens = []
for token in tokens:
if token[0] == 'daddress':
parsed_tokens.append(daddress(token))
elif token[0] == 'dcommand':
parsed_tokens.append(dcommand(token))
elif token[0] == 'doaddress':
parsed_tokens.append(doaddress(token))
elif token[0] == 'dosymbol':
parsed_tokens.append(dosymbol(token))
return parsed_tokens
```
For example, if the input list of tokens is `[('daddress', '123'), ('dcommand', 'print'), ('dosymbol', 'x')]`, the output of `parse_tokens` should be `[('daddress', '123'), ('dcommand', 'print'), ('dosymbol', 'x')]`. | ```python
def parse_tokens(tokens):
parsed_tokens = []
for token in tokens:
if token[0] == 'daddress':
parsed_tokens.append(daddress(token))
elif token[0] == 'dcommand':
parsed_tokens.append(dcommand(token))
elif token[0] == 'doaddress':
parsed_tokens.append(doaddress(token))
elif token[0] == 'dosymbol':
parsed_tokens.append(dosymbol(token))
return parsed_tokens
```
The `parse_tokens` function iterates through the input list of tokens and uses the provided functions `daddress`, `dcommand`, `doaddress`, and `dosymbol` to parse each token. The parsed representation of the input is then returned as a list of tuples containing the type and value of each token. |
python | 40,698 | 3,894 | value = value.replace('\r', '')
value = value.replace('\n', '')
return value
class QueryTestCase(unittest.TestCase):
def test_parse_names(self):
self.assertEqual(None, parse_names(u''))
self.assertEqual(None, parse_names(u' '))
self.assertEqual(None, parse_names(u'\t'))
self.assertEqual(None, parse_names(u'\r'))
self.assertEqual(None, parse_names(u'\n'))
self.assertEqual(None, parse_names(u'a'))
self.assertEqual(None, parse_names(u' a'))
| fp_eeff13170a | You are tasked with implementing a function to parse a string containing names separated by whitespace. The function should handle various edge cases and return a list of parsed names. The function should also remove any leading or trailing whitespace, as well as any occurrences of carriage return ('\r') and newline ('\n') characters.
You are provided with a code snippet that includes a partial implementation of the function `parse_names` and a set of unit tests using the `unittest` framework.
Your task is to complete the implementation of the `parse_names` function and ensure that it passes all the provided unit tests.
The `parse_names` function should have the following signature:
```python
def parse_names(value: str) -> List[str]:
# Your implementation here
``` | ```python
from typing import List
import unittest
def parse_names(value: str) -> List[str]:
value = value.replace('\r', '').replace('\n', '') # Remove carriage return and newline characters
names = value.split() # Split the string into a list of names using whitespace as the delimiter
names = [name.strip() for name in names] # Remove leading and trailing whitespace from each name
return names
class QueryTestCase(unittest.TestCase):
def test_parse_names(self):
self.assertEqual([], parse_names(u'')) # Empty string should return an empty list
self.assertEqual([], parse_names(u' ')) # String with only whitespace should return an empty list
self.assertEqual([], parse_names(u'\t')) # String with only tab should return an empty list
self.assertEqual([], parse_names(u'\r')) # String with only carriage return should return an empty list
self.assertEqual([], parse_names(u'\n')) # String with only newline should return an empty list
self.assertEqual(['a'], parse_names(u'a')) # Single name without whitespace should return a list with that name
self.assertEqual(['a'], parse_names(u' a')) # Single name with leading whitespace should return a list with that name
self.assertEqual(['John', 'Doe'], parse_names(u'John Doe')) # String with two names separated by whitespace should return a list with both names
self.assertEqual(['Alice', 'Bob', 'Charlie'], parse_names(u'Alice Bob Charlie')) # String with multiple names separated by multiple whitespace should return a list with all names
self.assertEqual(['Alice', 'Bob', 'Charlie'], parse_names(u'\nAlice\r \tBob\nCharlie\n')) # String with names separated by various whitespace and newline characters should return a list with all names
```
The `parse_names` function first removes any carriage return and newline characters from the input string using the `replace` method. Then, it splits the string into a list of names using whitespace as the delimiter. After that, it removes any leading or trailing whitespace from each name using list comprehension. Finally, it returns the list of parsed names.
The provided unit tests ensure that the `parse_names` function handles various edge cases and input scenarios correctly. |
swift | 59,131 | 3,537 | commandLine.appendPath(backDeployLibPath)
}
| fp_eeff13170a | You are tasked with implementing a file path manipulation function in a programming language of your choice. The function should take a base path and a relative path as input and return the combined absolute path. The base path represents the starting directory, and the relative path represents the path to be appended to the base path.
For example, given the base path "/usr/local/" and the relative path "bin/", the function should return "/usr/local/bin/".
Your task is to implement the function that performs this file path manipulation. | ```python
def append_path(base_path, relative_path):
if base_path.endswith('/'):
return base_path + relative_path
else:
return base_path + '/' + relative_path
# Example usage
base_path = "/usr/local/"
relative_path = "bin/"
absolute_path = append_path(base_path, relative_path)
print(absolute_path) # Output: "/usr/local/bin/"
``` |
python | 5,772 | 12,081 |
def authrization_heder_token(
api_key: str = Depends(APIKeyHeader(name="Authorization")),
) -> str:
try:
token_prefix, token = api_key.split(" ")
except ValueError:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="unsupported authorization type",
)
if token_prefix != JWT_TOKEN_PREFIX:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
| fp_eeff13170a | You are tasked with implementing a Python function that validates an authorization header token for a web API. The function should extract the token from the provided header, check its format, and return the token if it is valid. If the token is not in the expected format or the authorization type is unsupported, the function should raise an HTTPException with the appropriate status code and error message.
You are given the following code snippet as a starting point:
```python
from fastapi import Depends, HTTPException, status
from fastapi.security import APIKeyHeader
JWT_TOKEN_PREFIX = "Bearer"
def authrization_heder_token(
api_key: str = Depends(APIKeyHeader(name="Authorization")),
) -> str:
try:
token_prefix, token = api_key.split(" ")
except ValueError:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="unsupported authorization type",
)
if token_prefix != JWT_TOKEN_PREFIX:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="unsupported authorization type",
)
# Your implementation here
```
Your task is to complete the `authrization_heder_token` function by adding the necessary logic to validate the token and return it if valid, or raise an HTTPException if not. The function should adhere to the following requirements:
- If the authorization header is missing or in an invalid format (e.g., missing token or incorrect prefix), raise an HTTPException with status code 403 and the detail "invalid authorization header".
- If the token is in the correct format and authorization type, return the token.
Write the implementation for the `authrization_heder_token` function to fulfill the specified requirements. | ```python
def authrization_heder_token(
api_key: str = Depends(APIKeyHeader(name="Authorization")),
) -> str:
try:
token_prefix, token = api_key.split(" ")
except ValueError:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="invalid authorization header",
)
if token_prefix != JWT_TOKEN_PREFIX:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="unsupported authorization type",
)
return token
```
In the solution, the `authrization_heder_token` function first attempts to split the provided `api_key` into the token prefix and the token itself. If this operation fails due to an incorrect format, it raises an HTTPException with the status code 403 and the detail "invalid authorization header". If the token prefix does not match the expected JWT token prefix, it raises an HTTPException with the status code 403 and the detail "unsupported authorization type". If both checks pass, the function returns the extracted token. |
python | 6,265 | 1,121 | # software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
| fp_eeff13170a | You are tasked with creating a program that analyzes a software license file to extract specific information. The license file contains comments and the actual license text. Your program needs to extract the license type, the permissions, and the limitations from the file.
You are given a string `license_text` representing the content of the license file. The license text may contain comments, indicated by lines starting with a `#` symbol. The license type is specified in the first non-comment line, the permissions are listed after the line containing "WITHOUT WARRANTIES OR CONDITIONS OF ANY", and the limitations are listed after the line containing "limitations".
Write a function `extract_license_info(license_text: str) -> dict` that takes the `license_text` as input and returns a dictionary containing the extracted information. The dictionary should have the following keys:
- "license_type": a string representing the type of the license.
- "permissions": a list of strings representing the permissions granted by the license.
- "limitations": a list of strings representing the limitations imposed by the license.
Assume that the license text will always contain the required sections in the specified order.
Example:
```python
license_text = '''
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
MIT License
The permission is granted to any person obtaining a copy of this software
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
limitations:
- The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
'''
print(extract_license_info(license_text))
```
Output:
```
{
"license_type": "MIT License",
"permissions": [
"to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software",
"to permit persons to whom the Software is furnished to do so"
],
"limitations": [
"The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software",
"THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."
]
}
``` | ```python
def extract_license_info(license_text: str) -> dict:
info = {"license_type": "", "permissions": [], "limitations": []}
lines = license_text.split('\n')
for line in lines:
if line.strip() and not line.strip().startswith('#'):
info["license_type"] = line.strip()
break
start_permissions = False
start_limitations = False
for line in lines:
if "WITHOUT WARRANTIES OR CONDITIONS OF ANY" in line:
start_permissions = True
continue
if "limitations" in line:
start_permissions = False
start_limitations = True
continue
if start_permissions and line.strip() and not line.strip().startswith('#'):
info["permissions"].append(line.strip())
if start_limitations and line.strip() and not line.strip().startswith('#'):
info["limitations"].append(line.strip())
return info
``` |
python | 30,486 | 11,648 |
#Coded by <NAME>, Founder Teknohouse.ID, Co-founder and former CTO of Indisbuilding
#pin 15 = relay 4 = dispenser_cewek
| fp_eeff13170a | You are tasked with creating a program to control a dispenser for a women's restroom. The dispenser is connected to a microcontroller, and the code snippet provided contains a comment indicating the pin number and the corresponding relay number for the dispenser. Your task is to write a Python program that toggles the relay to control the dispenser.
Your program should include the following functionalities:
1. Initialize the pin and relay mapping based on the provided comment in the code snippet.
2. Implement a function to toggle the relay, simulating the action of dispensing a product.
3. Provide a user interface to prompt the user for input to trigger the dispenser.
Write a Python program that fulfills the requirements outlined above. | ```python
import RPi.GPIO as GPIO # Import the GPIO library for Raspberry Pi
# Initialize the pin and relay mapping based on the provided comment
pin_relay_mapping = {
15: 4 # pin 15 = relay 4 = dispenser_cewek
}
# Set up the GPIO mode and pin
GPIO.setmode(GPIO.BCM)
GPIO.setup(list(pin_relay_mapping.keys()), GPIO.OUT)
# Function to toggle the relay
def toggle_relay(pin):
GPIO.output(pin, GPIO.HIGH) # Turn on the relay
# Simulate dispensing action
print(f"Dispenser activated for pin {pin_relay_mapping[pin]}")
GPIO.output(pin, GPIO.LOW) # Turn off the relay
# User interface to trigger the dispenser
def main():
while True:
user_input = input("Press Enter to dispense or 'q' to quit: ")
if user_input.lower() == 'q':
break
for pin in pin_relay_mapping:
toggle_relay(pin)
if __name__ == "__main__":
main()
```
In this solution, we use the RPi.GPIO library to control the GPIO pins of a Raspberry Pi. We initialize the pin and relay mapping based on the provided comment and set up the GPIO mode and pin. The `toggle_relay` function is implemented to simulate the dispensing action by toggling the relay. The `main` function provides a user interface to trigger the dispenser by prompting the user for input. When the user presses Enter, the dispenser is activated, and the program continues to prompt for input until the user enters 'q' to quit. |
rust | 32,928 | 1,601 | pub mod animation;
pub mod control_state;
pub mod controllable;
pub mod local_player;
pub mod physics;
pub use animated_sprite::*;
pub use animation::*;
pub use control_state::*;
pub use controllable::*;
pub use local_player::*;
pub use physics::*;
| fp_eeff13170a | You are tasked with creating a Rust module system for a 2D game engine. The game engine consists of several modules, each serving a specific purpose. The provided code snippet includes the module declarations and re-exports for the game engine.
Your task is to design and implement a new module called `input` that will handle user input for the game. The `input` module should encapsulate functionality for capturing and processing user input events such as keyboard presses, mouse movements, and gamepad inputs.
Your implementation should include the following components:
1. A `input_handler` module that contains the logic for capturing and processing user input events.
2. A `keyboard` module that handles keyboard input events.
3. A `mouse` module that handles mouse input events.
4. A `gamepad` module that handles gamepad input events.
Your `input` module should re-export all the public items from the `input_handler`, `keyboard`, `mouse`, and `gamepad` modules.
Design the module structure and provide a basic implementation for each module, including the necessary data structures, traits, and functions to handle user input events. | ```rust
// input_handler.rs
pub mod input_handler {
pub struct InputHandler {
// Implementation for capturing and processing user input events
}
}
// keyboard.rs
pub mod keyboard {
pub struct Keyboard {
// Implementation for handling keyboard input events
}
}
// mouse.rs
pub mod mouse {
pub struct Mouse {
// Implementation for handling mouse input events
}
}
// gamepad.rs
pub mod gamepad {
pub struct Gamepad {
// Implementation for handling gamepad input events
}
}
// input.rs
pub mod input {
pub use input_handler::InputHandler;
pub use keyboard::Keyboard;
pub use mouse::Mouse;
pub use gamepad::Gamepad;
}
```
In this solution, we have created the `input_handler`, `keyboard`, `mouse`, and `gamepad` modules to handle user input events. Each module contains a struct representing the input device and its associated implementation. The `input` module re-exports all the public items from the individual input-related modules. This design allows for a clean and organized structure for handling user input in the game engine. |
csharp | 3,355 | 3,244 | </a>
</div>
</div>
}
}
| fp_eeff13170a | You are given a snippet of HTML code representing a portion of a web page. The code contains a nested structure of HTML elements. Your task is to write a function that takes this HTML snippet as input and returns the number of nested levels in the HTML structure.
For the purpose of this problem, consider only the opening tags of HTML elements (e.g., `<div>`, `<a>`, etc.) and ignore any closing tags or self-closing tags. The nesting level is determined by the depth of the HTML elements in the structure.
Write a function `countNestedLevels` that takes a string `htmlSnippet` as input and returns an integer representing the number of nested levels in the HTML structure.
Example:
For the given HTML snippet:
```
</a>
</div>
</div>
}
}
```
The function should return 2, as there are two levels of nesting in the HTML structure. | ```python
def countNestedLevels(htmlSnippet):
max_depth = 0
current_depth = 0
for char in htmlSnippet:
if char == '<':
current_depth += 1
max_depth = max(max_depth, current_depth)
elif char == '>':
current_depth -= 1
return max_depth - 1 # Subtract 1 to account for the top-level HTML tag
```
The `countNestedLevels` function iterates through the characters of the HTML snippet and maintains a count of the current nesting depth. It increments the depth count when encountering an opening tag (`<`) and decrements it when encountering a closing tag (`>`). The function returns the maximum depth encountered minus 1 to account for the top-level HTML tag. |
python | 26,436 | 7,464 | and modify ranges of data contained by a buffer object even though OpenGL
might still be using other parts of it.
This extension also provides a method for explicitly flushing ranges of a
mapped buffer object so OpenGL does not have to assume that the entire
range may have been modified. Further, it allows the application to more
precisely specify its intent with respect to reading, writing, and whether
the previous contents of a mapped range of interest need be preserved
prior to modification.
| fp_eeff13170a | You are tasked with implementing a buffer management system for a graphics application using OpenGL. The system should allow for efficient modification and flushing of ranges of data within a buffer object, while ensuring that OpenGL can still use other parts of the buffer.
Your task is to create a class `BufferManager` with the following functionalities:
1. `map_buffer(range_start, range_end, access_mode)`: A method to map a range of the buffer object for modification. The `range_start` and `range_end` parameters specify the start and end indices of the range to be mapped, and `access_mode` specifies whether the range will be read from, written to, or both.
2. `flush_range(range_start, range_end)`: A method to explicitly flush a mapped range of the buffer object, indicating that the modifications have been made and OpenGL should not assume the entire range has been modified.
3. `unmap_buffer()`: A method to unmap the buffer, indicating that the modifications are complete and the buffer can be used by OpenGL.
You should also handle the precise specification of intent with respect to reading, writing, and preservation of previous contents of a mapped range.
Implement the `BufferManager` class with the specified functionalities and ensure that it provides efficient and precise management of buffer ranges for the graphics application. | ```python
class BufferManager:
def __init__(self, buffer_data):
self.buffer_data = buffer_data
self.mapped_range = None
def map_buffer(self, range_start, range_end, access_mode):
if self.mapped_range is not None:
raise Exception("Buffer range already mapped")
# Perform mapping operations, e.g., obtaining a pointer to the range
# based on range_start and range_end
# Set access mode and preserve previous contents based on access_mode
self.mapped_range = (range_start, range_end, access_mode)
def flush_range(self, range_start, range_end):
if self.mapped_range is None:
raise Exception("No buffer range mapped")
if range_start < self.mapped_range[0] or range_end > self.mapped_range[1]:
raise Exception("Flush range outside mapped range")
# Perform flushing operations for the specified range
def unmap_buffer(self):
if self.mapped_range is None:
raise Exception("No buffer range mapped")
# Perform unmapping operations, e.g., releasing the mapped range
self.mapped_range = None
```
In this solution, the `BufferManager` class is implemented to manage buffer ranges efficiently. The `map_buffer` method maps a range of the buffer object for modification, specifying the access mode and preservation of previous contents. The `flush_range` method explicitly flushes a mapped range, and the `unmap_buffer` method unmaps the buffer after modifications are complete. The class ensures precise management of buffer ranges for the graphics application using OpenGL. |
python | 114,631 | 33,462 |
def has_object_permission(self, request, view, obj):
return True
class AnyGroupJWTBasePermission(JWTBasePermission):
'''
give access for all authenticated users that belong to any group
'''
def has_permission(self, request, view):
# TODO Temp. Remove as deprecated when all mt_jwt_auth use jwt authentication
| fp_eeff13170a | You are tasked with implementing a custom permission class for a Django REST Framework (DRF) API. The custom permission class should allow access to all authenticated users who belong to any group. You are provided with a code snippet that includes a base permission class and a method that needs to be implemented.
Your task is to complete the implementation of the `has_permission` method in the `AnyGroupJWTBasePermission` class. The method should check if the authenticated user belongs to any group and grant access if they do. If the user is not authenticated, access should be denied.
You are to write the implementation for the `has_permission` method based on the given requirements. | ```python
class AnyGroupJWTBasePermission(JWTBasePermission):
'''
give access for all authenticated users that belong to any group
'''
def has_permission(self, request, view):
if request.user and request.user.is_authenticated:
# Assuming the user model has a "groups" attribute representing the groups the user belongs to
if request.user.groups.exists():
return True # Grant access if the user belongs to any group
return False # Deny access if the user is not authenticated or does not belong to any group
```
In the solution, the `has_permission` method checks if the request user is authenticated and belongs to any group. If both conditions are met, the method returns `True`, granting access. Otherwise, it returns `False`, denying access. This implementation ensures that only authenticated users belonging to any group are granted access. |
java | 89,335 | 2,484 | private MqttClient client;
private MqttConnectOptions options = new MqttConnectOptions();
@Override
protected void startUp() throws Exception {
MemoryPersistence persistence = new MemoryPersistence();
String broker = config.getProperty("mqtt.broker", "tcp://localhost:1883");
String clientId = config.getProperty("mqtt.clientId", "WifiDetector");
| fp_eeff13170a | You are tasked with implementing a class that connects to an MQTT broker and subscribes to a specific topic. The provided code snippet is a part of a larger MQTT client implementation. Your task is to complete the implementation by adding the necessary code to subscribe to a given topic and handle incoming messages.
Your task is to implement the `MqttSubscriber` class, which should have the following requirements:
- The class should have a method `connectAndSubscribe` that takes the MQTT broker URL, client ID, topic, and quality of service (QoS) as parameters and establishes a connection to the broker and subscribes to the specified topic with the given QoS.
- The class should have a method `disconnect` to disconnect from the MQTT broker.
You should use the Eclipse Paho MQTT client library to achieve this. The library can be included in the project using Maven or Gradle.
You can assume that the necessary dependencies and configurations are already set up, and you only need to focus on implementing the `MqttSubscriber` class. | ```java
import org.eclipse.paho.client.mqttv3.*;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
public class MqttSubscriber {
private MqttClient client;
private MqttConnectOptions options = new MqttConnectOptions();
public void connectAndSubscribe(String brokerUrl, String clientId, String topic, int qos) throws MqttException {
String serverURI = "tcp://" + brokerUrl;
client = new MqttClient(serverURI, clientId, new MemoryPersistence());
client.connect(options);
client.subscribe(topic, qos, this::messageArrived);
}
public void disconnect() throws MqttException {
if (client != null && client.isConnected()) {
client.disconnect();
}
}
private void messageArrived(String topic, MqttMessage message) {
System.out.println("Received message: " + new String(message.getPayload()) + " on topic: " + topic);
}
}
```
In the solution, the `MqttSubscriber` class uses the Eclipse Paho MQTT client library to connect to the MQTT broker, subscribe to the specified topic, and handle incoming messages. The `connectAndSubscribe` method establishes a connection to the broker and subscribes to the specified topic with the given QoS. The `disconnect` method disconnects from the MQTT broker. The `messageArrived` method is a callback that gets invoked when a message is received on the subscribed topic. |
python | 63,301 | 9,042 | reactor.stop()
| fp_eeff13170a | You are tasked with implementing a simple event-driven system for a reactor simulation. The reactor is represented by a class `Reactor` with a method `stop()` that shuts down the reactor. Your goal is to create a program that simulates the behavior of the reactor and its shutdown process.
You need to implement a class `Reactor` with the following specifications:
- The `Reactor` class should have a method `stop()` that prints "Reactor shutting down..." when called.
- You should then create an instance of the `Reactor` class and call the `stop()` method to simulate the reactor shutting down.
Your task is to write the code to create the `Reactor` class and call its `stop()` method to simulate the reactor shutting down. | ```python
class Reactor:
def stop(self):
print("Reactor shutting down...")
# Create an instance of the Reactor class
reactor = Reactor()
# Call the stop method to simulate the reactor shutting down
reactor.stop()
```
In this solution, we define a class `Reactor` with a method `stop()` that prints "Reactor shutting down...". Then, we create an instance of the `Reactor` class and call its `stop()` method to simulate the reactor shutting down. |
swift | 81,055 | 3,667 | var detected = false
// MARK: - Public Variables
// We do not declare as `weak` reference type because the implementing ViewController
// which declares / holds the EvrythngScanner instance will hold EvrthngScanner's instance.
// Hence, this delegate should be manually set to nil to avoid memory leak
var evrythngScannerDelegate: EvrythngScannerDelegate?
// MARK: - IBOutlets
@IBOutlet weak var imageView: UIImageView!
| fp_eeff13170a | You are tasked with implementing a delegate pattern in Swift for a custom scanner class. The `EvrythngScanner` class is responsible for scanning and processing images, and it requires a delegate to handle the scanned results. Your goal is to create a protocol for the delegate and set up the necessary delegate property in the `EvrythngScanner` class.
Your task is to define the protocol `EvrythngScannerDelegate` with a method `didScanImage(_: UIImage)` that will be called when an image is scanned. Then, you need to modify the `EvrythngScanner` class to include a property `evrythngScannerDelegate` of type `EvrythngScannerDelegate?` to hold the delegate instance.
Ensure that the delegate property is not declared as a `weak` reference type, as the implementing ViewController will hold the `EvrythngScanner` instance. Additionally, provide an explanation for this decision and highlight the potential memory management concerns. | ```swift
// MARK: - Protocol Definition
protocol EvrythngScannerDelegate: AnyObject {
func didScanImage(_ image: UIImage)
}
// MARK: - EvrythngScanner Class
class EvrythngScanner {
var evrythngScannerDelegate: EvrythngScannerDelegate?
// Other scanner methods and properties
// Method to trigger image scanning and notify the delegate
func scanImage(_ image: UIImage) {
// Perform image scanning logic
// Notify the delegate about the scanned image
evrythngScannerDelegate?.didScanImage(scannedImage)
}
}
```
Explanation:
- The `EvrythngScannerDelegate` protocol is defined with the method `didScanImage(_:)` to handle scanned images.
- The `EvrythngScanner` class includes a property `evrythngScannerDelegate` of type `EvrythngScannerDelegate?` to hold the delegate instance.
- The decision not to declare the delegate property as a `weak` reference type is justified by the fact that the implementing ViewController, which holds the `EvrythngScanner` instance, will also hold the delegate instance. Therefore, there is no risk of creating a strong reference cycle, and using a `weak` reference would require manually setting the delegate to `nil` to avoid potential memory leaks. |
python | 109,821 | 8,202 | import os
import hashlib
from datetime import datetime
import configparser
from random import randint
import collections
import time
def getDigest(input):
| fp_eeff13170a | You are tasked with implementing a function to calculate the digest of a given input string using various hashing algorithms. The function should support multiple hashing algorithms and return the digest along with the algorithm used for hashing.
You are provided with a partial code snippet that imports necessary modules and defines a function `getDigest(input)`. Your task is to complete the `getDigest` function to support multiple hashing algorithms and return the digest along with the algorithm used.
Your function should take the following inputs:
- `input`: A string for which the digest needs to be calculated.
Your function should return a dictionary with the following keys:
- `algorithm`: The name of the hashing algorithm used.
- `digest`: The hexadecimal digest of the input string using the specified algorithm.
You need to support at least three hashing algorithms: MD5, SHA-256, and SHA-512. The function should be able to calculate the digest using any of these algorithms based on user input.
Complete the `getDigest` function to achieve the desired functionality. | ```python
import hashlib
def getDigest(input, algorithm):
algorithms = {
'md5': hashlib.md5,
'sha256': hashlib.sha256,
'sha512': hashlib.sha512
}
if algorithm.lower() not in algorithms:
return "Invalid algorithm"
hash_algorithm = algorithms[algorithm.lower()]()
hash_algorithm.update(input.encode('utf-8'))
digest = hash_algorithm.hexdigest()
return {'algorithm': algorithm, 'digest': digest}
```
The `getDigest` function takes the input string and the algorithm name as parameters. It then checks if the specified algorithm is supported and calculates the digest using the selected algorithm. The result is returned as a dictionary containing the algorithm name and the corresponding digest. If an invalid algorithm is provided, the function returns an error message. |
php | 38,647 | 2,333 | <div class="heading">
<h1>Placement <span>Form</span></h1>
</div>
<?php echo $this->Form->create('Placement');?>
<fieldset>
<?php
echo $this->Form->input('form_for');
echo $this->Form->input('branch');
echo $this->Form->input('category');
echo $this->Form->input('stu_name');
echo $this->Form->input('father_name');
echo $this->Form->input('resi_address');
echo $this->Form->input('present_address');
| fp_eeff13170a | You are tasked with creating a web form for a placement application system. The form should include fields for the applicant's information such as the form type, branch, category, student name, father's name, residential address, and present address. Each field should be validated to ensure that the data entered is accurate and complete. Your task is to write a function that validates the input data for each field according to the specified criteria.
Write a function `validatePlacementForm` that takes an associative array representing the form data as input and returns a boolean value indicating whether the data is valid or not. The keys of the associative array correspond to the form field names, and the values represent the data entered by the applicant.
The validation criteria for each field are as follows:
- `form_for`: Should be a non-empty string.
- `branch`: Should be a non-empty string.
- `category`: Should be a non-empty string.
- `stu_name`: Should be a non-empty string.
- `father_name`: Should be a non-empty string.
- `resi_address`: Should be a non-empty string.
- `present_address`: Should be a non-empty string.
If any of the fields fail to meet the validation criteria, the function should return `false`. Otherwise, it should return `true`.
Example:
Input:
```php
$formData = array(
'form_for' => 'Internship',
'branch' => 'Computer Science',
'category' => 'General',
'stu_name' => 'John Doe',
'father_name' => 'Michael Doe',
'resi_address' => '123 Main Street',
'present_address' => '456 Elm Street'
);
```
Output:
```php
validatePlacementForm($formData); // true
``` | ```php
function validatePlacementForm($formData) {
foreach ($formData as $field => $value) {
if (empty($value) || !is_string($value)) {
return false;
}
}
return true;
}
```
The `validatePlacementForm` function iterates through the form data and checks each field's value against the validation criteria. If any field's value is empty or not a string, the function immediately returns `false`. If all fields pass the validation, the function returns `true`. This ensures that the form data is valid according to the specified criteria. |
swift | 9,045 | 1,638 | init?(map: Map) { }
| fp_eeff13170a | You are tasked with implementing a Swift initializer for a custom data type called `Location` that represents geographical coordinates. The `Location` type should have two properties: `latitude` and `longitude`, both of type `Double`. Your task is to implement the initializer `init?(map: Map)` that takes a `Map` object as input and initializes a `Location` object based on the data in the `Map`. The `Map` object contains information about latitude and longitude.
The `Map` type is defined as follows:
```swift
struct Map {
let latitude: Double
let longitude: Double
}
```
Your `init?(map: Map)` initializer should perform the following tasks:
1. Check if the latitude and longitude values in the `Map` object are valid geographical coordinates. Latitude ranges from -90 to 90, and longitude ranges from -180 to 180. If the values are invalid, the initializer should return `nil`.
2. If the latitude and longitude values are valid, create a new `Location` object with the provided latitude and longitude values and return it.
Your task is to implement the `init?(map: Map)` initializer for the `Location` type according to the specified requirements. | ```swift
struct Location {
let latitude: Double
let longitude: Double
init?(map: Map) {
guard (-90...90).contains(map.latitude) && (-180...180).contains(map.longitude) else {
return nil // Invalid latitude or longitude
}
self.latitude = map.latitude
self.longitude = map.longitude
}
}
```
In the solution, the `Location` struct is defined with properties `latitude` and `longitude`. The `init?(map: Map)` initializer checks if the latitude and longitude values in the `Map` object are within the valid geographical coordinate ranges. If they are valid, a new `Location` object is created with the provided latitude and longitude values. If the values are invalid, the initializer returns `nil`. |
java | 114,900 | 3,100 | @Permissions({ @Permission(value = RolePermission.MANAGEMENT_USERS, acls = READ) })
public Response getUsers(@BeanParam PaginationParam paginationParam) {
UserCriteria criteria = new UserCriteria.Builder().build();
List<User> users = userService
| fp_eeff13170a | You are tasked with implementing a custom permission system for a user management application. The application has a method `getUsers` that retrieves a list of users based on certain criteria. The method is annotated with `@Permissions` and `@Permission` to define the required permissions for accessing this endpoint. The `@Permission` annotation specifies the value of the permission and the access control level (ACL).
Your task is to create a custom permission checker that validates whether a user has the required permission to access the `getUsers` method based on the defined permissions and ACLs.
You are provided with the following information:
- The `@Permissions` annotation is used to group multiple `@Permission` annotations.
- The `@Permission` annotation contains the value of the permission and the ACL required for access.
- The ACL can have values such as READ, WRITE, DELETE, etc.
- The `getUsers` method takes a `PaginationParam` object as a parameter for pagination.
Your custom permission checker should validate whether the user has the required permission to access the `getUsers` method based on the defined permissions and ACLs.
Create a method `checkPermission` that takes the user's role and the required permission as input and returns a boolean indicating whether the user has the required permission.
Write the `checkPermission` method using Java and assume the existence of necessary classes and methods for retrieving user roles and permissions. | ```java
import java.util.Arrays;
import java.util.List;
public class PermissionChecker {
// Method to check if the user has the required permission
public boolean checkPermission(String userRole, String requiredPermission) {
// Assume a method to retrieve user's permissions based on role
List<String> userPermissions = getUserPermissionsByRole(userRole);
// Check if the user has the required permission
return userPermissions.contains(requiredPermission);
}
// Dummy method to retrieve user's permissions based on role
private List<String> getUserPermissionsByRole(String userRole) {
// Replace with actual logic to retrieve user's permissions based on role
if (userRole.equals("admin")) {
return Arrays.asList("MANAGEMENT_USERS_READ", "MANAGEMENT_USERS_WRITE", "MANAGEMENT_USERS_DELETE");
} else if (userRole.equals("manager")) {
return Arrays.asList("MANAGEMENT_USERS_READ", "MANAGEMENT_USERS_WRITE");
} else {
return Arrays.asList("MANAGEMENT_USERS_READ");
}
}
}
```
In the solution, the `PermissionChecker` class contains a method `checkPermission` that takes the user's role and the required permission as input. It retrieves the user's permissions based on the role and checks if the user has the required permission by comparing it with the required permission. The `getUserPermissionsByRole` method is a dummy method to simulate the retrieval of user permissions based on the role. In a real-world scenario, this method would be replaced with actual logic to retrieve user permissions from a data source. |
php | 139,197 | 2,146 |
public function create()
{
$data = RelatedNews::all();
return view('admin.judicial.relatednews_info.create', compact('data'));
}
public function edit($id)
{
$data = RelatedNews::where('rn_id', $id)->get()[0];
return view('admin.judicial.relatednews_info.edit', compact('data'));
}
public function update(Request $request, $id)
| fp_eeff13170a | You are tasked with creating a web application for managing related news articles. The application has a backend built with Laravel, and the code snippet provided is from the related news controller. The `create` method retrieves all related news articles and passes them to the `create` view, while the `edit` method retrieves a specific related news article based on its ID and passes it to the `edit` view for modification. Your task is to implement the `update` method in the controller to handle the update of a related news article based on the provided request and ID.
You are given the following information:
- The `RelatedNews` model represents the related news articles.
- The `create` method retrieves all related news articles and passes them to the `create` view.
- The `edit` method retrieves a specific related news article based on its ID and passes it to the `edit` view for modification.
- The `update` method should handle the update of a related news article based on the provided request and ID.
Your task is to complete the `update` method in the related news controller to ensure that it updates the related news article based on the provided request and ID.
Complete the `update` method in the related news controller with the necessary code to update the related news article based on the provided request and ID. | ```php
public function update(Request $request, $id)
{
$relatedNews = RelatedNews::find($id);
if ($relatedNews) {
$relatedNews->title = $request->input('title');
$relatedNews->content = $request->input('content');
// Update other fields as needed
$relatedNews->save();
return redirect()->route('relatednews.index')->with('success', 'Related news article updated successfully');
} else {
return redirect()->back()->with('error', 'Related news article not found');
}
}
```
In the `update` method, we first retrieve the related news article based on the provided ID using the `find` method. If the related news article is found, we update its fields based on the provided request data and then save the changes. Finally, we redirect the user to the index page with a success message if the update is successful, or back to the previous page with an error message if the related news article is not found. |
python | 72,841 | 26,141 | out_path = "data/out"
if not os.path.isdir(out_path):
os.mkdir(out_path)
os.mkdir(os.path.join(out_path, 'anomaly_detection'))
| fp_eeff13170a | You are working on a data processing pipeline for anomaly detection and need to organize the output data into specific directories. The code snippet provided is a part of the setup process for creating the necessary directory structure. Your task is to complete the directory creation process based on certain conditions.
You are given a list of anomaly types and a base output path. For each anomaly type, you need to create a directory within the output path. However, if the directory already exists, you should append a numerical suffix to the directory name to make it unique. The numerical suffix should start from 1 and increment until an available directory name is found.
Write a function `create_anomaly_directories(output_path, anomaly_types)` that takes in the base output path as a string and a list of anomaly types as strings. The function should create directories for each anomaly type within the output path, following the rules described above. The function should return a list of the full paths of the created directories in the order of the anomaly types provided.
For example, given `output_path = "data/out"` and `anomaly_types = ["spike", "drift", "shift", "noise", "outlier", "missing"]`, the function should create directories named "spike", "drift", "shift", "noise", "outlier", and "missing" within the "data/out" directory. If any of these directories already exist, the function should append a numerical suffix to make the directory names unique. | ```python
import os
def create_anomaly_directories(output_path, anomaly_types):
created_directories = []
for anomaly_type in anomaly_types:
dir_name = anomaly_type
suffix = 1
while os.path.exists(os.path.join(output_path, dir_name)):
dir_name = f"{anomaly_type}_{suffix}"
suffix += 1
full_path = os.path.join(output_path, dir_name)
os.mkdir(full_path)
created_directories.append(full_path)
return created_directories
```
The `create_anomaly_directories` function iterates through the anomaly types and creates directories within the output path, ensuring unique names by appending numerical suffixes if necessary. It returns a list of the full paths of the created directories in the order of the anomaly types provided. |
python | 13,472 | 24,423 |
def __init__(self, lang: str):
super().__init__()
self.lang = lang
self.moses = sacremoses.MosesTokenizer(lang)
self.rm_accent = lang in self.LANG_WITHOUT_ACCENT
self.ready = True
def do(self, text: str):
text = text_normalizer.normalize(
text, accent=self.rm_accent, case=False, numbers=False, punct=True
)
| fp_eeff13170a | You are tasked with implementing a text processing class that normalizes input text based on certain language-specific rules. The class has an `__init__` method that initializes the language and sets up some language-specific tools, and a `do` method that normalizes the input text. Your task is to complete the implementation of the `do` method to perform the required text normalization.
You are provided with the following code snippet as a starting point:
```python
import sacremoses
import text_normalizer
class TextProcessor:
LANG_WITHOUT_ACCENT = ["en", "es", "fr"] # List of languages without accents
def __init__(self, lang: str):
self.lang = lang
self.moses = sacremoses.MosesTokenizer(lang)
self.rm_accent = lang in self.LANG_WITHOUT_ACCENT
self.ready = True
def do(self, text: str):
text = text_normalizer.normalize(
text, accent=self.rm_accent, case=False, numbers=False, punct=True
)
# Your implementation here
```
Your task is to complete the `do` method to perform the following text normalization steps:
1. Tokenize the input text using the `moses` tokenizer.
2. Normalize the tokenized text using the `text_normalizer.normalize` function with the following parameters:
- `accent`: Set to the value of `self.rm_accent`.
- `case`: Set to `False`.
- `numbers`: Set to `False`.
- `punct`: Set to `True`.
Your implementation should modify the `text` variable in the `do` method to store the normalized text and return the modified text. | ```python
import sacremoses
import text_normalizer
class TextProcessor:
LANG_WITHOUT_ACCENT = ["en", "es", "fr"] # List of languages without accents
def __init__(self, lang: str):
self.lang = lang
self.moses = sacremoses.MosesTokenizer(lang)
self.rm_accent = lang in self.LANG_WITHOUT_ACCENT
self.ready = True
def do(self, text: str):
tokenized_text = self.moses.tokenize(text, return_str=True)
normalized_text = text_normalizer.normalize(
tokenized_text, accent=self.rm_accent, case=False, numbers=False, punct=True
)
return normalized_text
```
In the solution, the `do` method first tokenizes the input text using the `moses` tokenizer and then normalizes the tokenized text using the `text_normalizer.normalize` function with the specified parameters. The normalized text is then returned as the result of the `do` method. |
python | 32,133 | 17,352 | [1] 1 16.8973559126 2.6933495054 1.0
[2] 1 5.5548729596 2.7777687995 1.0
[3] 0 46.1810010826 3.1611961917 0.0
[4] 0 44.3117586448 3.3458963222 0.0
[5] 0 34.6334526911 3.6429838715 0.0
| fp_eeff13170a | You are given a dataset containing several records, each consisting of four numerical values. The first value represents the class label (0 or 1), and the remaining three values represent features. Your task is to implement a Python function that calculates the Euclidean distance between each record and a given query point. The Euclidean distance between two points (x1, y1, z1) and (x2, y2, z2) is given by the formula: sqrt((x2-x1)^2 + (y2-y1)^2 + (z2-z1)^2).
Write a function `calculate_distances(dataset, query_point)` that takes in two parameters:
- `dataset` (list of lists): A list of records, where each record is represented as a list of four numerical values [class_label, feature1, feature2, feature3].
- `query_point` (list): A list representing the query point with three numerical values [query_feature1, query_feature2, query_feature3].
The function should return a list of tuples, where each tuple contains the index of the record in the dataset and its corresponding Euclidean distance from the query point. The list should be sorted in ascending order based on the Euclidean distances.
For example, given the following dataset:
```
dataset = [
[1, 16.8973559126, 2.6933495054, 1.0],
[1, 5.5548729596, 2.7777687995, 1.0],
[0, 46.1810010826, 3.1611961917, 0.0],
[0, 44.3117586448, 3.3458963222, 0.0],
[0, 34.6334526911, 3.6429838715, 0.0]
]
```
and a query point:
```
query_point = [10.0, 3.0, 1.5]
```
the function call `calculate_distances(dataset, query_point)` should return:
```
[(1, 5.684354368), (0, 36.1980010826), (2, 36.1980010826), (4, 36.1980010826), (3, 38.1282435204)]
```
where each tuple contains the index of the record in the dataset and its corresponding Euclidean distance from the query point. | ```python
import math
def calculate_distances(dataset, query_point):
distances = []
for i, record in enumerate(dataset):
class_label, feature1, feature2, feature3 = record
euclidean_distance = math.sqrt((query_point[0] - feature1) ** 2 + (query_point[1] - feature2) ** 2 + (query_point[2] - feature3) ** 2)
distances.append((i, euclidean_distance))
distances.sort(key=lambda x: x[1])
return distances
```
The `calculate_distances` function iterates through each record in the dataset, calculates the Euclidean distance between the record's features and the query point, and appends the index and distance as a tuple to the `distances` list. Finally, it sorts the list based on the Euclidean distances and returns the sorted list of tuples. |
python | 85,883 | 6,415 |
marks = {'James': 90, 'Jules': 55, 'Arthur': 77}
| fp_eeff13170a | You are tasked with creating a Python function that processes a dictionary containing student names as keys and their respective marks as values. The function should return the name of the student with the highest mark. If there are multiple students with the same highest mark, the function should return a list of their names.
The function signature should be:
```python
def highest_mark_students(marks: dict) -> Union[str, List[str]]:
pass
```
For example, given the input `marks = {'James': 90, 'Jules': 55, 'Arthur': 77}`, the function should return `'James'` since James has the highest mark. If the input is `marks = {'Alice': 85, 'Bob': 92, 'Charlie': 92}`, the function should return `['Bob', 'Charlie']` as both Bob and Charlie have the highest mark. | ```python
from typing import Union, List
def highest_mark_students(marks: dict) -> Union[str, List[str]]:
max_mark = max(marks.values())
top_students = [name for name, mark in marks.items() if mark == max_mark]
if len(top_students) == 1:
return top_students[0]
else:
return top_students
``` |
python | 13,520 | 19,173 |
cmds_map = [new_tmux_cmd(session, "ps", base_cmd + ["--job-name", "ps"])]
for i in range(num_workers):
cmds_map += [new_tmux_cmd(session,
"w-%d" % i, base_cmd + ["--job-name", "worker", "--task", str(i), "--remotes", remotes[i]])]
cmds_map += [new_tmux_cmd(session, "tb", ["tensorboard --logdir {} --port 12345".format(logdir)])]
cmds_map += [new_tmux_cmd(session, "htop", ["htop"])]
| fp_eeff13170a | You are tasked with creating a Python function that generates a set of tmux commands for managing a distributed machine learning job. Tmux is a terminal multiplexer that allows multiple terminal sessions to be accessed and controlled from a single window. The provided code snippet demonstrates the creation of tmux commands for running processes related to a distributed machine learning job.
Your task is to implement a Python function `generate_tmux_commands` that takes in the following parameters:
- `session`: The name of the tmux session to be created.
- `base_cmd`: The base command to be executed by each worker.
- `num_workers`: The number of worker processes to be created.
- `remotes`: A list of remote addresses for the workers.
- `logdir`: The directory for storing the log files.
The function should generate a list of tmux commands based on the input parameters. Each command should be in the format of `new_tmux_cmd(session, name, command)`, where `session` is the tmux session name, `name` is the name of the command, and `command` is the actual command to be executed.
The generated commands should include the following:
1. A command for the parameter server process with the name "ps".
2. Commands for each worker process, named "w-0", "w-1", ..., "w-(num_workers-1)".
3. A command for starting TensorBoard with the name "tb".
4. A command for launching the htop system monitoring tool with the name "htop".
Your task is to complete the implementation of the `generate_tmux_commands` function to produce the required list of tmux commands based on the given input parameters.
```python
def generate_tmux_commands(session, base_cmd, num_workers, remotes, logdir):
cmds_map = [new_tmux_cmd(session, "ps", base_cmd + ["--job-name", "ps"])]
for i in range(num_workers):
cmds_map += [new_tmux_cmd(session,
"w-%d" % i, base_cmd + ["--job-name", "worker", "--task", str(i), "--remotes", remotes[i]])]
cmds_map += [new_tmux_cmd(session, "tb", ["tensorboard --logdir {} --port 12345".format(logdir)])]
cmds_map += [new_tmux_cmd(session, "htop", ["htop"])]
return cmds_map
``` | ```python
def new_tmux_cmd(session, name, command):
return (session, name, command)
# Example usage
session_name = "distributed_ml"
base_command = ["python", "train.py"]
num_workers = 3
remote_addresses = ["192.168.1.10", "192.168.1.11", "192.168.1.12"]
log_directory = "/path/to/logs"
tmux_commands = generate_tmux_commands(session_name, base_command, num_workers, remote_addresses, log_directory)
print(tmux_commands)
```
The `generate_tmux_commands` function takes the input parameters and constructs a list of tmux commands based on the provided code snippet. The function then returns the list of commands, which can be used to manage the distributed machine learning job within a tmux session. |
python | 15,137 | 5,848 | self.ReDraw()
# Register event handlers
self.Bind(wx.EVT_SIZE, self.onSize)
self.Bind(wx.EVT_PAINT, self.onPaint)
def MakeNewBuffer(self):
size = self.GetClientSize()
self.buffer = BitmapBuffer(size[0], size[1],
| fp_eeff13170a | You are tasked with implementing a simple drawing application using the wxPython library. The provided code snippet is a part of a larger program that handles the drawing canvas and event handling. Your task is to complete the implementation by adding the necessary methods to handle drawing on the canvas and resizing the drawing area.
Your goal is to implement the following functionalities:
1. Implement the `ReDraw` method to handle redrawing the canvas.
2. Implement the `onSize` method to handle resizing of the canvas.
3. Implement the `onPaint` method to handle the painting of the canvas.
4. Implement the `MakeNewBuffer` method to create a new buffer for the canvas.
Your implementation should ensure that the canvas is redrawn when necessary, and the drawing area is responsive to resizing and painting events.
Your task is to complete the implementation of the missing methods based on the provided code snippet and the given requirements. | ```python
class DrawingApplication(wx.Frame):
def __init__(self, parent, title):
super(DrawingApplication, self).__init__(parent, title=title, size=(800, 600))
self.InitUI()
def InitUI(self):
self.Bind(wx.EVT_SIZE, self.onSize)
self.Bind(wx.EVT_PAINT, self.onPaint)
self.buffer = None
self.Centre()
self.Show(True)
def ReDraw(self):
if self.buffer:
dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
self.Draw(dc)
def onSize(self, event):
self.MakeNewBuffer()
event.Skip()
def onPaint(self, event):
if self.buffer:
dc = wx.BufferedPaintDC(self, self.buffer)
def MakeNewBuffer(self):
size = self.GetClientSize()
self.buffer = wx.Bitmap(size.width, size.height)
dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
self.Draw(dc)
def Draw(self, dc):
dc.SetBackground(wx.Brush(wx.Colour(255, 255, 255)))
dc.Clear()
# Add drawing logic here
```
In the solution, the `DrawingApplication` class is extended to include the missing methods for handling drawing, resizing, and painting events. The `ReDraw` method is implemented to redraw the canvas, the `onSize` method is implemented to handle resizing, the `onPaint` method is implemented to handle painting, and the `MakeNewBuffer` method is implemented to create a new buffer for the canvas. Additionally, a `Draw` method is included to handle the actual drawing logic. |
python | 22,277 | 6,503 | dtype="float32", )
# first_layer 与 first_layer_mask 对应着infer起始层的节点
| fp_eeff13170a | You are tasked with implementing a Python function that processes a given input to extract specific information and perform a series of operations. The input will consist of a multi-line string containing code snippets in Python. Your function should identify and extract all the comments from the input, then count the occurrences of each unique word in these comments. Finally, the function should return a dictionary where the keys are the unique words found in the comments, and the values are the respective counts of each word.
The function signature is:
```python
def count_comment_words(input_str: str) -> dict:
pass
```
For example, given the following input:
```python
input_str = '''
# This is a comment
# with multiple lines
# and some repeated words
dtype="float32", )
# first_layer 与 first_layer_mask 对应着infer起始层的节点
'''
The function should return the following dictionary:
```python
{
'This': 1,
'is': 1,
'a': 1,
'comment': 1,
'with': 1,
'multiple': 1,
'lines': 1,
'and': 1,
'some': 1,
'repeated': 1,
'words': 1,
'first_layer': 1,
'与': 1,
'first_layer_mask': 1,
'对应着infer起始层的节点': 1
}
``` | ```python
def count_comment_words(input_str: str) -> dict:
import re
# Extract comments from the input using regular expression
comments = re.findall(r'#.*', input_str)
# Split comments into words and count occurrences
word_count = {}
for comment in comments:
words = re.findall(r'\w+', comment)
for word in words:
word_count[word] = word_count.get(word, 0) + 1
return word_count
``` |
python | 92,795 | 5,779 | with open(test_directory / f'{filename}.txt', 'w') as f:
f.write(s)
assert 15 == count_words_threading(str(test_directory / '*.txt'))
| fp_eeff13170a | You are tasked with implementing a function to count the total number of words across multiple text files in a given directory using threading. The code snippet provided demonstrates the usage of the function `count_words_threading` to count the words in all text files within a specified directory. The function takes a directory path as input and returns the total count of words in all the text files within that directory. The function utilizes threading to concurrently process multiple files for improved performance.
Your task is to implement the `count_words_threading` function using Python's threading module to achieve parallel processing of text files and accurately count the total number of words across all files in the specified directory.
Example:
Suppose we have a directory named `test_directory` containing multiple text files. The function call `count_words_threading(str(test_directory / '*.txt'))` should return the total count of words in all the text files within the `test_directory`. | ```python
import os
import threading
def count_words(file_path, result):
with open(file_path, 'r') as file:
content = file.read()
words = content.split()
result.append(len(words))
def count_words_threading(directory):
total_words = 0
result = []
def process_file(file_path):
nonlocal total_words
count_words(file_path, result)
threads = []
for file_name in os.listdir(directory):
file_path = os.path.join(directory, file_name)
if os.path.isfile(file_path) and file_name.endswith('.txt'):
thread = threading.Thread(target=process_file, args=(file_path,))
threads.append(thread)
thread.start()
for thread in threads:
thread.join()
total_words = sum(result)
return total_words
# Example usage
test_directory = '/path/to/test_directory'
assert 15 == count_words_threading(test_directory)
```
In the solution, the `count_words` function is responsible for counting the words in a single file and appending the count to the `result` list. The `count_words_threading` function utilizes threading to concurrently process each text file within the specified directory. Each file is processed by a separate thread, and the word counts are accumulated in the `result` list. After all threads have completed, the total word count is calculated by summing the counts in the `result` list and returned as the final result. |
typescript | 89,484 | 4,910 | @autobind
private async fetchData(filter: TFilter): Promise<TData> {
return jsonMutationDataFetcher<TRaw, TData>(
this.props.mutationName,
this.props.filterFormatter ? this.props.filterFormatter(filter) : filter,
this.props.formatter
);
}
| fp_eeff13170a | You are tasked with creating a TypeScript class method that fetches and processes data from a server using the provided code snippet as a reference. Your task is to implement the `jsonMutationDataFetcher` function and ensure that the `fetchData` method correctly handles the asynchronous data retrieval and processing.
The `fetchData` method is a private method of a TypeScript class and is decorated with `@autobind`. It takes a `filter` parameter of type `TFilter` and returns a `Promise` of type `TData`. The `jsonMutationDataFetcher` function is used to fetch and process the data. It takes three parameters: `mutationName` of type `string`, `filter` of type `TFilter` or its formatted version, and `formatter` function.
Your task is to implement the `jsonMutationDataFetcher` function and ensure that the `fetchData` method correctly calls it with the appropriate parameters. Additionally, you need to handle the asynchronous nature of data fetching and processing.
Implement the `jsonMutationDataFetcher` function and the `fetchData` method to ensure that the data is fetched, formatted, and processed correctly. | ```typescript
// Solution for jsonMutationDataFetcher function
async function jsonMutationDataFetcher<TRaw, TData>(
mutationName: string,
filter: TFilter,
formatter: (data: TRaw) => TData
): Promise<TData> {
// Implement data fetching logic, for example using fetch API or Axios
const rawData = await fetchDataFromServer(mutationName, filter);
// Process the raw data using the provided formatter function
const processedData = formatter(rawData);
return processedData;
}
// Solution for fetchData method
@autobind
private async fetchData(filter: TFilter): Promise<TData> {
return jsonMutationDataFetcher<TRaw, TData>(
this.props.mutationName,
this.props.filterFormatter ? this.props.filterFormatter(filter) : filter,
this.props.formatter
);
}
```
In the solution, the `jsonMutationDataFetcher` function is implemented to handle the data fetching and processing. It takes the `mutationName`, `filter`, and `formatter` as parameters and returns a `Promise` of type `TData`. Inside the `fetchData` method, the `jsonMutationDataFetcher` function is called with the appropriate parameters to fetch and process the data. The `@autobind` decorator ensures the correct binding of `this` within the method. |
python | 52,597 | 12,220 |
#==============================================================================
# Generic Django project settings
#==============================================================================
ALLOWED_HOSTS = ['*']
| fp_eeff13170a | You are tasked with creating a Python function that validates a given domain against a list of allowed hosts. The function should take the domain as input and return a boolean value indicating whether the domain is allowed or not.
You are provided with a snippet of generic Django project settings, where the `ALLOWED_HOSTS` variable contains a list of allowed hosts. The `ALLOWED_HOSTS` list may contain specific domain names or the wildcard character `'*'` to allow all domains.
Your task is to implement the `validate_domain` function that checks if a given domain is allowed based on the `ALLOWED_HOSTS` list.
Function Signature:
```python
def validate_domain(domain: str, allowed_hosts: list) -> bool:
pass
```
Input:
- `domain` (string) - A domain name to be validated.
- `allowed_hosts` (list) - A list of allowed hosts as defined in the Django project settings.
Output:
- A boolean value indicating whether the domain is allowed (`True`) or not allowed (`False`).
Constraints:
- The input domain will be a non-empty string.
- The input allowed_hosts list will contain at least one element.
Example:
```python
allowed_hosts = ['example.com', '*.example.org', 'subdomain.example.net', '*']
print(validate_domain('example.com', allowed_hosts)) # Output: True
print(validate_domain('test.example.org', allowed_hosts)) # Output: True
print(validate_domain('invalid.com', allowed_hosts)) # Output: False
print(validate_domain('sub.subdomain.example.net', allowed_hosts)) # Output: True
print(validate_domain('random.org', allowed_hosts)) # Output: True
``` | ```python
def validate_domain(domain: str, allowed_hosts: list) -> bool:
for allowed_host in allowed_hosts:
if allowed_host == '*':
return True # Wildcard allows all domains
if allowed_host.startswith('*.') and domain.endswith(allowed_host[2:]):
return True # Wildcard subdomain match
if domain == allowed_host:
return True # Exact domain match
return False # Domain not found in allowed hosts
```
The `validate_domain` function iterates through the `allowed_hosts` list and checks each entry against the given `domain`. It returns `True` if the domain matches any of the allowed hosts based on the following conditions:
1. If the allowed host is a wildcard (`'*'`), it allows all domains.
2. If the allowed host starts with `'*.'` and the domain ends with the specified subdomain, it allows the domain.
3. If the domain exactly matches an entry in the allowed hosts list, it allows the domain.
If none of the conditions are met, the function returns `False`, indicating that the domain is not allowed. |
python | 142,714 | 21,057 | ('gender', models.CharField(blank=True, choices=[('None', '未定義'), ('Male', 'オス'), ('Female', 'メス')], max_length=10, null=True, verbose_name='オス・メス')),
('count', models.IntegerField(default=1, verbose_name='個数')),
('connector', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='supply_relations', to='supply.connector', verbose_name='コネクタ')),
('supply', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='connector_relations', to='supply.supply', verbose_name='製品')),
],
),
migrations.AddField(
model_name='supply',
name='connectors',
field=models.ManyToManyField(blank=True, related_name='supplies', through='supply.SupplyConnectorRelation', to='supply.Connector', verbose_name='コネクタ'),
),
| fp_eeff13170a | You are working on a supply management system for a manufacturing company. The system uses Django as the backend framework. The provided code snippet is a part of the Django model definitions for managing the supply and connector relations.
The code snippet defines two models: `SupplyConnectorRelation` and `Supply`. The `SupplyConnectorRelation` model represents the relation between a supply and a connector, and the `Supply` model represents the supply of products. The `Supply` model has a many-to-many relationship with the `Connector` model through the `SupplyConnectorRelation` model.
Your task is to implement a Django model method that calculates the total count of connectors associated with a supply. The method should be added to the `Supply` model and should return the total count of connectors for that supply.
Write a method named `calculate_total_connector_count` in the `Supply` model that calculates the total count of connectors associated with the supply.
```python
class Supply(models.Model):
# Other fields and model definitions
def calculate_total_connector_count(self):
total_count = self.connectors.aggregate(total_count=Sum('supplyconnectorrelation__count'))['total_count']
return total_count if total_count is not None else 0
``` | The `calculate_total_connector_count` method is added to the `Supply` model to calculate the total count of connectors associated with the supply. The method uses the `aggregate` function to calculate the sum of the `count` field from the related `SupplyConnectorRelation` model for the given supply. If there are no connectors associated with the supply, the method returns 0. |
typescript | 149,803 | 2,330 | */
export declare function addClass(elm: Element, classes: string | string[]): void;
//# sourceMappingURL=../../../../../../../../../splide/src/js/utils/dom/addClass/addClass.d.ts.map | fp_eeff13170a | You are tasked with implementing a TypeScript function that adds one or more CSS classes to an HTML element.
You are given the following TypeScript declaration for the `addClass` function:
```typescript
export declare function addClass(elm: Element, classes: string | string[]): void;
```
Your task is to implement the `addClass` function in TypeScript. The function should take an HTML element `elm` and one or more CSS classes `classes` as input. If `classes` is a string, the function should add that single class to the element. If `classes` is an array of strings, the function should add all the classes in the array to the element.
The function should modify the `elm` element by adding the specified classes to its `classList`.
Your implementation should adhere to the TypeScript declaration provided. | ```typescript
export function addClass(elm: Element, classes: string | string[]): void {
if (typeof classes === 'string') {
elm.classList.add(classes);
} else if (Array.isArray(classes)) {
classes.forEach((cls) => elm.classList.add(cls));
}
}
```
The `addClass` function takes an HTML element `elm` and one or more CSS classes `classes` as input. If `classes` is a string, the function adds that single class to the element using `elm.classList.add()`. If `classes` is an array of strings, the function iterates through the array and adds each class to the element using `elm.classList.add()`.
This solution adheres to the TypeScript declaration provided and effectively adds the specified classes to the element's class list. |
typescript | 20,784 | 3,121 | }
| fp_eeff13170a | You are given a code snippet that represents a function in a programming language. Your task is to complete the function by implementing the missing logic. The function takes in an array of integers and an integer target. The goal is to find two distinct elements in the array that sum up to the target. If such a pair exists, the function should return their indices as an array. If no such pair exists, the function should return an empty array.
The given code snippet is as follows:
```python
def find_two_sum(nums, target):
# Your implementation here
```
Your task is to complete the `find_two_sum` function to achieve the desired functionality. | ```python
def find_two_sum(nums, target):
num_indices = {}
for i, num in enumerate(nums):
complement = target - num
if complement in num_indices:
return [num_indices[complement], i]
num_indices[num] = i
return []
```
In the solution, we use a dictionary `num_indices` to store the indices of the elements we have seen so far. We iterate through the array `nums` and for each element, we calculate its complement with respect to the `target`. If the complement is found in `num_indices`, we return the indices of the current element and its complement. If no such pair is found, we return an empty array. This solution has a time complexity of O(n) and a space complexity of O(n), where n is the number of elements in the input array. |
python | 15,492 | 4,683 | self.centralWidget = QtWidgets.QWidget(MainWindow)
self.centralWidget.setObjectName("centralWidget")
#%% QFrames
| fp_eeff13170a | You are tasked with creating a Python class that simulates a simple banking system. The class should have methods for depositing funds, withdrawing funds, and checking the current balance. Additionally, the class should be able to handle multiple accounts, each identified by a unique account number.
Your task is to implement the `BankAccount` class with the following specifications:
- The class should be initialized with an account number and an initial balance.
- It should have methods `deposit` and `withdraw` to add or subtract funds from the account balance.
- The `get_balance` method should return the current balance of the account.
Your implementation should also include a method to keep track of the total number of accounts created.
Implement the `BankAccount` class and ensure that it meets the specified requirements. | ```python
class BankAccount:
total_accounts = 0 # Class variable to keep track of the total number of accounts
def __init__(self, account_number, initial_balance):
self.account_number = account_number
self.balance = initial_balance
BankAccount.total_accounts += 1 # Increment the total number of accounts
def deposit(self, amount):
if amount > 0:
self.balance += amount
return True
else:
return False
def withdraw(self, amount):
if amount > 0 and self.balance >= amount:
self.balance -= amount
return True
else:
return False
def get_balance(self):
return self.balance
# Example usage
acc1 = BankAccount("12345", 1000)
acc2 = BankAccount("67890", 500)
print(BankAccount.total_accounts) # Output: 2
acc1.deposit(500)
print(acc1.get_balance()) # Output: 1500
acc2.withdraw(200)
print(acc2.get_balance()) # Output: 300
``` |
rust | 31,009 | 2,725 | KBDR = 0xFE02 // Keyboard data
}
// Returns a bool based on whether the number given
// represents a negative number or not
pub const fn is_negative(x: u16, bit_count: u16) -> bool {
x >> (bit_count - 1) == 1
| fp_eeff13170a | You are tasked with implementing a function to determine whether a given unsigned 16-bit number represents a negative number or not. The function should take two parameters: the number to be checked and the number of bits in the representation. The function should return `true` if the number is negative and `false` if it is not.
You are provided with the following code snippet for inspiration:
```rust
pub const fn is_negative(x: u16, bit_count: u16) -> bool {
x >> (bit_count - 1) == 1
}
```
Your task is to implement the `is_negative` function in Rust, ensuring that it correctly determines whether the given number represents a negative number based on the specified bit count. | ```rust
pub const fn is_negative(x: u16, bit_count: u16) -> bool {
// Calculate the mask for the sign bit based on the bit count
let sign_bit_mask = 1 << (bit_count - 1);
// Perform a bitwise AND operation to check the sign bit
x & sign_bit_mask != 0
}
```
The solution involves calculating the mask for the sign bit based on the bit count provided and then performing a bitwise AND operation to check the sign bit of the given number. If the result is non-zero, the number is considered negative, and the function returns `true`; otherwise, it returns `false`. |
java | 102,953 | 4,584 | return true;
}
}
return false;
}
}
| fp_eeff13170a | You are given a Java method that takes an array of integers as input and is intended to return true if the array contains any duplicate elements, and false otherwise. However, the given code snippet is incomplete and contains a logical error. Your task is to complete the method and fix the logical error to ensure that it correctly identifies duplicate elements in the array.
Complete the given Java method to correctly identify duplicate elements in the array and return true if any duplicates are found, and false otherwise. You should also ensure that the method has an efficient time complexity.
```java
public class DuplicateChecker {
public static boolean containsDuplicate(int[] nums) {
Set<Integer> set = new HashSet<>();
for (int num : nums) {
if (set.contains(num)) {
return true; // Found a duplicate
}
set.add(num);
}
return false; // No duplicates found
}
}
``` | The given Java method `containsDuplicate` is completed to correctly identify duplicate elements in the array using a HashSet to efficiently track unique elements. The method iterates through the input array and checks if the current element is already present in the set. If it is, the method returns true, indicating the presence of a duplicate. If no duplicates are found after iterating through the entire array, the method returns false.
The time complexity of this solution is O(n), where n is the number of elements in the input array. This is because the HashSet provides constant time complexity for add and contains operations, resulting in an efficient solution for identifying duplicate elements in the array. |
java | 54,757 | 3,895 | * @author <NAME> (hohwille at users.sourceforge.net)
* @since 1.0.0
*/
public interface SignatureVerifier<S extends SignatureBinary> extends SignatureVerifierSimple {
/**
* @param signature the {@code byte} array with the signature as raw data.
* @return {@code true} if the given signature is valid, {@code false} otherwise.
*/
default boolean verifyAfterUpdate(S signature) {
| fp_eeff13170a | You are tasked with implementing a Java interface for verifying digital signatures. The interface, `SignatureVerifier`, extends another interface `SignatureVerifierSimple` and takes a generic type `S` that extends `SignatureBinary`. The interface includes a default method `verifyAfterUpdate` that takes an object of type `S` representing a signature and returns a boolean value indicating whether the given signature is valid.
Your task is to create a concrete class that implements the `SignatureVerifier` interface and provides the necessary logic to verify the signature based on the raw signature data.
Write a Java class `ConcreteSignatureVerifier` that implements the `SignatureVerifier` interface and provides the implementation for the `verifyAfterUpdate` method. Assume that the `SignatureBinary` interface is already defined and includes the necessary methods and properties for handling digital signatures.
Your implementation should include the following:
- Proper validation of the signature based on the raw signature data.
- Handling any necessary exceptions or error conditions related to signature verification. | ```java
public class ConcreteSignatureVerifier implements SignatureVerifier<ConcreteSignatureBinary> {
@Override
public boolean verifyAfterUpdate(ConcreteSignatureBinary signature) {
// Implement signature verification logic here
try {
// Perform signature verification based on the raw signature data
// Example:
// boolean isValid = someVerificationMethod.verifySignature(signature.getRawData());
// return isValid;
// For demonstration purposes, assuming a simple validation logic
return signature.getRawData().length > 0; // Just checking if the raw data is non-empty
} catch (Exception e) {
// Handle any exceptions related to signature verification
// Example: log the error, return false, or rethrow as a custom exception
return false;
}
}
}
```
In the solution, `ConcreteSignatureVerifier` is a concrete class that implements the `SignatureVerifier` interface for a specific type of signature, `ConcreteSignatureBinary`. The `verifyAfterUpdate` method contains the logic for verifying the signature based on the raw signature data. The implementation includes error handling to manage any exceptions that may occur during the verification process. |
cpp | 71,143 | 321 | glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mRendererID);
}
uint32_t OpenGLIndexBuffer::getCount() const
{
return mBuffer.mSize;
}
}
| fp_eeff13170a | You are tasked with implementing a class for managing index buffers in an OpenGL-based graphics application. The provided code snippet is a part of the implementation for an OpenGLIndexBuffer class. The class is responsible for binding the index buffer and returning the count of indices in the buffer.
Your task is to complete the implementation of the OpenGLIndexBuffer class by adding the necessary member variables and methods to manage the index buffer and retrieve the count of indices.
You are provided with the following incomplete class definition:
```cpp
#include <cstdint>
class OpenGLIndexBuffer {
public:
// Constructor and Destructor
// Method to bind the index buffer
void bind() const;
// Method to get the count of indices in the buffer
uint32_t getCount() const;
private:
// Member variables needed for managing the index buffer
// You need to define the appropriate member variable(s) here
};
```
Your task is to complete the class definition by adding the necessary member variables and implementing the constructor, destructor, bind() method, and getCount() method. The bind() method should bind the index buffer using the OpenGL function glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mRendererID), where mRendererID is the ID of the index buffer. The getCount() method should return the count of indices in the buffer.
Complete the class definition for OpenGLIndexBuffer and ensure that it can be used to manage index buffers in an OpenGL-based graphics application. | ```cpp
#include <GL/glew.h>
#include <cstdint>
class OpenGLIndexBuffer {
public:
// Constructor
OpenGLIndexBuffer(uint32_t* indices, uint32_t count) {
glGenBuffers(1, &mRendererID);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mRendererID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, count * sizeof(uint32_t), indices, GL_STATIC_DRAW);
mCount = count;
}
// Destructor
~OpenGLIndexBuffer() {
glDeleteBuffers(1, &mRendererID);
}
// Method to bind the index buffer
void bind() const {
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mRendererID);
}
// Method to get the count of indices in the buffer
uint32_t getCount() const {
return mCount;
}
private:
uint32_t mRendererID;
uint32_t mCount;
};
```
In the solution, the class constructor initializes the index buffer by generating a buffer ID, binding the buffer, and allocating memory for the indices. The destructor is responsible for deleting the buffer when the object is destroyed. The bind() method binds the index buffer, and the getCount() method returns the count of indices in the buffer. The member variables mRendererID and mCount are used to store the buffer ID and the count of indices, respectively. |
python | 124,528 | 10,704 | for i in range(6):
q.append(((qpast[i]+deltaT*qdot[i]) + np.pi) % (2 * np.pi) - np.pi)
qpast = q
#send control
for i in range(6):
set_joint_orientation(joints_id[i], q[i], mode=opmode)
ic(Rf)
#close.
| fp_eeff13170a | You are tasked with simulating a robotic arm movement using a simplified kinematic model. The given code snippet is a part of a larger program that controls the movement of a robotic arm with 6 joints. The code snippet includes a loop that updates the joint angles based on the previous joint angles, time step, and joint velocities. Additionally, it sets the joint orientations using a function `set_joint_orientation`. Your task is to implement a function that simulates the movement of the robotic arm for a given duration and time step.
You are provided with the following information:
- The robotic arm has 6 joints, and the joint angles are represented by the list `q` of length 6.
- The joint velocities are represented by the list `qdot` of length 6.
- The time step is represented by `deltaT`.
- The function `set_joint_orientation(joint_id, angle, mode)` sets the orientation of a joint with the given `joint_id` to the specified `angle` using the specified `mode`.
Your task is to implement the function `simulate_arm_movement(duration, time_step, initial_joint_angles, joint_velocities)` that simulates the movement of the robotic arm for the given `duration` using the provided `time_step`, `initial_joint_angles`, and `joint_velocities`. The function should update the joint angles at each time step and set the joint orientations using the `set_joint_orientation` function.
Function Signature: `def simulate_arm_movement(duration, time_step, initial_joint_angles, joint_velocities) -> None`
Example:
```python
# Initial joint angles
initial_joint_angles = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6]
# Joint velocities
joint_velocities = [0.01, 0.02, 0.03, 0.04, 0.05, 0.06]
# Simulate arm movement for 5 seconds with a time step of 0.1
simulate_arm_movement(5, 0.1, initial_joint_angles, joint_velocities)
``` | ```python
import numpy as np
def simulate_arm_movement(duration, time_step, initial_joint_angles, joint_velocities):
qpast = initial_joint_angles # Initialize qpast with initial joint angles
for t in np.arange(0, duration, time_step):
q = [] # Initialize the updated joint angles
for i in range(6):
q.append(((qpast[i] + time_step * joint_velocities[i]) + np.pi) % (2 * np.pi) - np.pi)
qpast = q # Update qpast with the new joint angles
# Set joint orientations using the set_joint_orientation function
for i in range(6):
set_joint_orientation(joints_id[i], q[i], mode=opmode)
```
In the solution, we use the provided initial joint angles and joint velocities to simulate the movement of the robotic arm for the given duration and time step. We update the joint angles at each time step and set the joint orientations using the `set_joint_orientation` function. |
php | 4,910 | 2,070 |
foreach ($users as $key => $user) {
$auth = ApiAuth::where('uid', $user->id)->first();
$return[] = [
'id' => $user->id,
'Username' => $user->email,
'ClientKey' => ($auth) ? $auth->client_key : '',
'ClientSecret' => ($auth) ? $auth->client_secret : '',
'ApiKey' => ($auth) ? $auth->api_key : '',
| fp_eeff13170a | You are tasked with creating a function that processes user data and generates a report containing user information and associated API authentication details. The function should take an array of user objects as input and return an array of user information with corresponding API authentication details.
Each user object has the following properties:
- `id`: The unique identifier for the user.
- `email`: The email address associated with the user.
The API authentication details are stored in the `ApiAuth` model and are associated with the user's `id`. The `ApiAuth` model has the following properties:
- `uid`: The user's unique identifier.
- `client_key`: The client key associated with the user's API authentication.
- `client_secret`: The client secret associated with the user's API authentication.
- `api_key`: The API key associated with the user's API authentication.
Your task is to create a function `generateUserReport` that takes an array of user objects and returns an array of user information with associated API authentication details. If a user does not have API authentication details, the corresponding fields in the report should be empty strings.
The function signature is:
```php
function generateUserReport(array $users): array {
// Your implementation here
}
```
For example, given the following input:
```php
$users = [
(object) ['id' => 1, 'email' => 'user1@example.com'],
(object) ['id' => 2, 'email' => 'user2@example.com'],
(object) ['id' => 3, 'email' => 'user3@example.com'],
];
```
The function `generateUserReport($users)` should return the following output:
```php
[
[
'id' => 1,
'Username' => 'user1@example.com',
'ClientKey' => 'client_key_1',
'ClientSecret' => 'client_secret_1',
'ApiKey' => 'api_key_1',
],
[
'id' => 2,
'Username' => 'user2@example.com',
'ClientKey' => '',
'ClientSecret' => '',
'ApiKey' => '',
],
[
'id' => 3,
'Username' => 'user3@example.com',
'ClientKey' => 'client_key_3',
'ClientSecret' => 'client_secret_3',
'ApiKey' => 'api_key_3',
],
]
``` | ```php
function generateUserReport(array $users): array {
$return = [];
foreach ($users as $user) {
$auth = ApiAuth::where('uid', $user->id)->first();
$return[] = [
'id' => $user->id,
'Username' => $user->email,
'ClientKey' => ($auth) ? $auth->client_key : '',
'ClientSecret' => ($auth) ? $auth->client_secret : '',
'ApiKey' => ($auth) ? $auth->api_key : '',
];
}
return $return;
}
```
The `generateUserReport` function iterates through the array of user objects, retrieves the corresponding API authentication details using the `ApiAuth` model, and constructs the report array with the required user information and associated API authentication details. If a user does not have API authentication details, the corresponding fields in the report are populated with empty strings. |
python | 98,438 | 25,911 | import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
| fp_eeff13170a | You are tasked with creating a Python function that simulates a simplified version of a database migration system. In this system, each migration is represented by a class that contains a list of its dependencies. Your task is to implement a function that takes a list of migration classes and returns the order in which the migrations should be applied, considering their dependencies.
You are given the following code snippet as a starting point:
```python
import django.db.models.deletion
class Migration:
dependencies = []
```
You need to implement the following function:
```python
def get_migration_order(migrations):
"""
Returns the order in which the migrations should be applied, considering their dependencies.
Args:
migrations: A list of Migration classes, each containing a list of its dependencies.
Returns:
A list of Migration classes in the order they should be applied.
"""
# Your implementation here
```
For example, given the following migration classes:
```python
class Migration1(Migration):
dependencies = []
class Migration2(Migration):
dependencies = [Migration1]
class Migration3(Migration):
dependencies = [Migration1]
class Migration4(Migration):
dependencies = [Migration2, Migration3]
```
The function `get_migration_order` should return `[Migration1, Migration2, Migration3, Migration4]`, as this is the order in which the migrations should be applied to satisfy their dependencies.
Write a function that efficiently solves this problem and handles cases where there might be circular dependencies or missing dependencies. | ```python
def get_migration_order(migrations):
# Create a dictionary to store the dependencies for each migration
dependency_map = {m.__name__: m.dependencies for m in migrations}
# Create a dictionary to store the visited status of each migration
visited = {m.__name__: False for m in migrations}
# Create a list to store the final order of migrations
order = []
def dfs(migration):
if not visited[migration.__name__]:
visited[migration.__name__] = True
for dependency in dependency_map[migration.__name__]:
if not visited[dependency.__name__]:
dfs(dependency)
order.append(migration)
for migration in migrations:
dfs(migration)
return order[::-1]
```
This solution uses a depth-first search (DFS) algorithm to traverse the dependencies of each migration class and determine the order in which they should be applied. The `dependency_map` dictionary is used to store the dependencies for each migration, and the `visited` dictionary keeps track of the visited status of each migration to handle circular dependencies. The DFS function recursively visits the dependencies of each migration, and the final order of migrations is stored in the `order` list, which is then returned in reverse order to represent the correct application order. |
python | 147,313 | 36,777 | fp_eeff13170a | You are given a list of integers representing the daily stock prices of a company. Your task is to write a function to calculate the maximum profit that can be obtained by buying and selling the stock at most once. If it is not possible to make any profit, the function should return 0.
Write a function `maxProfit` that takes in a list of integers `prices` representing the stock prices on different days. The function should return the maximum profit that can be obtained by buying and selling the stock at most once.
Example:
Input:
prices = [7, 1, 5, 3, 6, 4]
Output:
5
Explanation:
In this case, the maximum profit can be obtained by buying the stock on day 2 (price = 1) and selling it on day 5 (price = 6), resulting in a profit of 5.
Input:
prices = [7, 6, 4, 3, 1]
Output:
0
Explanation:
In this case, it is not possible to make any profit as the stock prices are continuously decreasing. | ```python
def maxProfit(prices):
if not prices:
return 0
min_price = prices[0]
max_profit = 0
for price in prices:
if price < min_price:
min_price = price
else:
max_profit = max(max_profit, price - min_price)
return max_profit
``` |
|
python | 140,173 | 18,895 | use_softmax=False)
if resume:
gesture_classifier.load_state_dict(checkpoint_classifier)
if num_layers_to_finetune > 0:
# remove internal padding for training
| fp_eeff13170a | You are tasked with implementing a Python function that performs fine-tuning on a gesture classifier model. The function takes several parameters, including the model, a flag to indicate whether to use softmax, a flag to indicate whether to resume training from a checkpoint, and the number of layers to fine-tune. The function should handle the fine-tuning process based on the provided parameters.
The function signature is as follows:
```python
def fine_tune_gesture_classifier(gesture_classifier, use_softmax=False, resume=False, num_layers_to_finetune=0):
# Your implementation here
```
The `gesture_classifier` parameter is an instance of the gesture classifier model. The `use_softmax` parameter is a boolean flag indicating whether to use softmax during training. The `resume` parameter is a boolean flag indicating whether to resume training from a checkpoint. The `num_layers_to_finetune` parameter is an integer representing the number of layers to fine-tune.
Your task is to complete the `fine_tune_gesture_classifier` function to handle the fine-tuning process based on the provided parameters. If `use_softmax` is True, the function should use softmax during training. If `resume` is True, the function should resume training from a checkpoint by loading the state dictionary into the gesture classifier. If `num_layers_to_finetune` is greater than 0, the function should remove internal padding for training. | ```python
def fine_tune_gesture_classifier(gesture_classifier, use_softmax=False, resume=False, num_layers_to_finetune=0):
if use_softmax:
# Use softmax during training
# Your implementation here
if resume:
# Resume training from a checkpoint by loading the state dictionary into the gesture classifier
# Your implementation here
if num_layers_to_finetune > 0:
# Remove internal padding for training
# Your implementation here
```
This solution provides a basic structure for the `fine_tune_gesture_classifier` function, outlining the conditional handling of the parameters to perform the fine-tuning process. The specific implementation details within each conditional block would depend on the actual gesture classifier model and the training process. |
typescript | 60,736 | 3,350 | await fixture.tearDown()
})
describe('bonding curve', function () {
const tokensToDeposit = curatorTokens
it('reject convert signal to tokens if subgraph deployment not initted', async function () {
const tx = curation.signalToTokens(subgraphDeploymentID, toGRT('100'))
await expect(tx).revertedWith('Subgraph deployment must be curated to perform calculations')
})
| fp_eeff13170a | You are tasked with implementing a function to manage a bonding curve for a decentralized application. A bonding curve is a mathematical curve that defines the relationship between the price of a token and the token's supply. In this scenario, you are required to implement a function that converts a signal to tokens, but only if a subgraph deployment has been initialized.
You are provided with the following code snippet as a reference:
```javascript
await fixture.tearDown()
})
describe('bonding curve', function () {
const tokensToDeposit = curatorTokens
it('reject convert signal to tokens if subgraph deployment not initted', async function () {
const tx = curation.signalToTokens(subgraphDeploymentID, toGRT('100'))
await expect(tx).revertedWith('Subgraph deployment must be curated to perform calculations')
})
```
Your task is to implement the `signalToTokens` function, ensuring that it checks whether the subgraph deployment has been initialized before converting the signal to tokens. If the subgraph deployment has not been initialized, the function should revert with the message 'Subgraph deployment must be curated to perform calculations'.
Implement the `signalToTokens` function according to the following specifications:
- Function Name: `signalToTokens`
- Parameters: `subgraphDeploymentID` (string), `signalAmount` (numeric)
- Return Type: `Promise<void>`
- Behavior: If the subgraph deployment has not been initialized, the function should revert with the message 'Subgraph deployment must be curated to perform calculations'. Otherwise, it should perform the conversion of the signal to tokens.
You are not required to implement the entire bonding curve logic, only the `signalToTokens` function with the specified behavior. | ```javascript
async function signalToTokens(subgraphDeploymentID, signalAmount) {
// Check if the subgraph deployment has been initialized
const isInitialized = await checkSubgraphInitialization(subgraphDeploymentID);
if (!isInitialized) {
throw new Error('Subgraph deployment must be curated to perform calculations');
}
// Perform the conversion of signal to tokens
// Your implementation for signal to tokens conversion goes here
// If the conversion is successful, return the result
// return result;
}
async function checkSubgraphInitialization(subgraphDeploymentID) {
// Implement logic to check if the subgraph deployment has been initialized
// Your implementation for checking subgraph initialization goes here
// Return true if initialized, false otherwise
}
```
In the solution, the `signalToTokens` function checks whether the subgraph deployment has been initialized using the `checkSubgraphInitialization` function. If the deployment has not been initialized, the function reverts with the specified message. Otherwise, the function proceeds with the conversion of the signal to tokens. The `checkSubgraphInitialization` function is responsible for checking the initialization status of the subgraph deployment. |
python | 36,648 | 7,986 | new_name='product',
),
]
| fp_eeff13170a | You are tasked with implementing a Python function that processes a list of tuples representing product information and returns a dictionary containing the products grouped by their category. Each tuple in the input list contains the product name as the first element and the category as the second element.
You need to write a function `group_products_by_category(products)` that takes in a list of tuples `products` and returns a dictionary where the keys are the unique categories and the values are lists of product names belonging to that category.
For example, given the input:
```python
products = [
('laptop', 'electronics'),
('phone', 'electronics'),
('banana', 'fruits'),
('apple', 'fruits'),
('desk', 'furniture'),
('chair', 'furniture'),
('keyboard', 'electronics'),
('orange', 'fruits'),
]
```
The function should return:
```python
{
'electronics': ['laptop', 'phone', 'keyboard'],
'fruits': ['banana', 'apple', 'orange'],
'furniture': ['desk', 'chair']
}
``` | ```python
def group_products_by_category(products):
product_dict = {}
for product, category in products:
if category in product_dict:
product_dict[category].append(product)
else:
product_dict[category] = [product]
return product_dict
``` |
python | 102,253 | 17,599 | print(main())
| fp_eeff13170a | You are given a Python function `main()` that returns a list of integers. Your task is to write a Python program to find the maximum and minimum values in the list returned by `main()` and then calculate the difference between the maximum and minimum values.
Your program should output the maximum value, the minimum value, and the difference between the maximum and minimum values, each on a new line.
Code snippet for inspiration:
```
print(main())
``` | ```python
def main():
# Assume main() returns a list of integers
return [5, 8, 3, 12, 7]
# Get the list of integers returned by main()
int_list = main()
# Find the maximum and minimum values in the list
max_value = max(int_list)
min_value = min(int_list)
# Calculate the difference between the maximum and minimum values
difference = max_value - min_value
# Output the maximum value, minimum value, and the difference
print(f"Maximum value: {max_value}")
print(f"Minimum value: {min_value}")
print(f"Difference between maximum and minimum values: {difference}")
```
When executed, the solution program will output:
```
Maximum value: 12
Minimum value: 3
Difference between maximum and minimum values: 9
``` |
shell | 9,796 | 832 | apps=(
google-chorme
firefox
slack-desktop
spotify
vlc
whatsapp-web-desktop
| fp_eeff13170a | You are given a list of software applications installed on a user's computer. The list contains the names of the applications, but there are some errors in the names. The errors include misspellings, incorrect capitalization, and missing characters. Your task is to create a Python function that takes the list of applications as input and returns a corrected list with the errors fixed.
The function signature is:
```python
def fix_application_names(apps: list) -> list:
pass
```
For example, given the input list:
```python
apps = [
"google-chorme",
"firefox",
"slack-desktop",
"spotfiy",
"vlc",
"whatsapp-web-desktop"
]
```
The function should return the corrected list:
```python
[
"google-chrome",
"firefox",
"slack-desktop",
"spotify",
"vlc",
"whatsapp-web-desktop"
]
```
Assumptions:
- The corrected names should match the most common and widely accepted spellings and capitalization for each application.
- The corrected names should be in the same order as the input list. | ```python
def fix_application_names(apps: list) -> list:
corrected_apps = []
for app in apps:
if app == "google-chorme":
corrected_apps.append("google-chrome")
elif app == "spotfiy":
corrected_apps.append("spotify")
else:
corrected_apps.append(app)
return corrected_apps
```
The `fix_application_names` function iterates through the input list of applications and corrects the errors by replacing the incorrect names with the correct ones. In this specific solution, it handles the corrections for "google-chorme" and "spotfiy" and appends the corrected names to a new list, which is then returned as the output. |
python | 77,428 | 21,332 | filename = 'image.jpg'
img = cv2.imread(filename)
img = cv2.resize(img, (640, 480), interpolation = cv2.INTER_AREA )
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
gray = np.float32(gray)
| fp_eeff13170a | You are tasked with implementing a program to perform corner detection on a grayscale image using the Harris corner detection algorithm. The Harris corner detection algorithm is a popular method for identifying corners in images by analyzing variations in intensity. Your task is to write a function that takes a grayscale image as input and returns the coordinates of detected corners.
You are provided with the following code snippet as a starting point:
```python
filename = 'image.jpg'
img = cv2.imread(filename)
img = cv2.resize(img, (640, 480), interpolation = cv2.INTER_AREA )
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
gray = np.float32(gray)
```
You have access to the OpenCV library for image processing, and the `cv2` and `np` modules are already imported. Your task is to complete the implementation by writing a function to detect corners using the Harris corner detection algorithm.
Your function signature should be:
```python
def detect_corners(image):
# Your implementation here
pass
``` | ```python
import cv2
import numpy as np
def detect_corners(image):
# Calculate gradients
Ix = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=3)
Iy = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=3)
# Harris corner detection parameters
k = 0.04 # Empirical constant
threshold = 0.01 # Threshold for corner response
# Calculate M matrix for each pixel
Ix2 = Ix ** 2
Iy2 = Iy ** 2
Ixy = Ix * Iy
# Apply Gaussian filter to the M matrix
w = 3 # Window size for Gaussian filter
Ix2 = cv2.GaussianBlur(Ix2, (w, w), 0)
Iy2 = cv2.GaussianBlur(Iy2, (w, w), 0)
Ixy = cv2.GaussianBlur(Ixy, (w, w), 0)
# Calculate corner response R
det_M = Ix2 * Iy2 - Ixy ** 2
trace_M = Ix2 + Iy2
R = det_M - k * (trace_M ** 2)
# Apply thresholding to select corners
corners = np.zeros_like(image)
corners[R > threshold * R.max()] = 255
# Get coordinates of detected corners
corner_coords = np.argwhere(corners == 255)
return corner_coords
```
This solution defines the `detect_corners` function, which takes a grayscale image as input and performs Harris corner detection to identify corners in the image. It calculates gradients using Sobel operators, constructs the M matrix, applies Gaussian filtering, computes the corner response R, applies thresholding, and finally returns the coordinates of detected corners. |
python | 70,086 | 26,949 | mask = np.abs(pxdiff) >= pxThreshold
if pxCount is not None:
assert mask.sum() <= pxCount
maskedDiff = diff[mask]
if maxPxDiff is not None and maskedDiff.size > 0:
assert maskedDiff.max() <= maxPxDiff
if avgPxDiff is not None and maskedDiff.size > 0:
assert maskedDiff.mean() <= avgPxDiff
if minCorr is not None:
with np.errstate(invalid='ignore'):
corr = np.corrcoef(im1.ravel(), im2.ravel())[0, 1]
| fp_eeff13170a | You are given a Python function that processes differences between two images. The function takes in several parameters and performs various checks on the differences between the images. Your task is to understand the function's behavior and implement a similar function in a different programming language.
The function takes the following parameters:
- `pxdiff`: A NumPy array representing the pixel differences between two images.
- `pxThreshold`: An integer representing the threshold for pixel differences.
- `pxCount`: An integer representing the maximum number of pixels allowed to exceed the threshold.
- `maxPxDiff`: An integer representing the maximum allowed pixel difference.
- `avgPxDiff`: A float representing the maximum allowed average pixel difference.
- `minCorr`: A float representing the minimum correlation coefficient allowed between the two images.
- `im1`: A NumPy array representing the first image.
- `im2`: A NumPy array representing the second image.
The function performs the following checks:
1. It creates a mask based on the absolute pixel differences exceeding the threshold.
2. If `pxCount` is provided, it asserts that the number of pixels exceeding the threshold does not exceed `pxCount`.
3. It extracts the differences based on the mask and performs additional checks:
- If `maxPxDiff` is provided and there are differences, it asserts that the maximum difference does not exceed `maxPxDiff`.
- If `avgPxDiff` is provided and there are differences, it asserts that the average difference does not exceed `avgPxDiff`.
4. If `minCorr` is provided, it calculates the correlation coefficient between the two images and ignores invalid values.
Your task is to implement a similar function in a different programming language, such as Java, C++, or JavaScript, that performs the same checks and operations as the given Python function. | ```java
import java.util.Arrays;
public class ImageDifferenceProcessor {
public static void processImageDifferences(int[] pxdiff, int pxThreshold, Integer pxCount, Integer maxPxDiff, Double avgPxDiff, Double minCorr, int[] im1, int[] im2) {
boolean[] mask = new boolean[pxdiff.length];
for (int i = 0; i < pxdiff.length; i++) {
mask[i] = Math.abs(pxdiff[i]) >= pxThreshold;
}
if (pxCount != null) {
int count = (int) Arrays.stream(mask).filter(b -> b).count();
assert count <= pxCount : "Number of pixels exceeding the threshold exceeds pxCount";
}
int[] maskedDiff = new int[pxdiff.length];
int index = 0;
for (int i = 0; i < pxdiff.length; i++) {
if (mask[i]) {
maskedDiff[index] = pxdiff[i];
index++;
}
}
maskedDiff = Arrays.copyOf(maskedDiff, index);
if (maxPxDiff != null && maskedDiff.length > 0) {
int maxDiff = Arrays.stream(maskedDiff).max().getAsInt();
assert maxDiff <= maxPxDiff : "Maximum difference exceeds maxPxDiff";
}
if (avgPxDiff != null && maskedDiff.length > 0) {
double avgDiff = Arrays.stream(maskedDiff).average().getAsDouble();
assert avgDiff <= avgPxDiff : "Average difference exceeds avgPxDiff";
}
if (minCorr != null) {
// Calculate correlation coefficient between im1 and im2
// Code for calculating correlation coefficient
double corr = calculateCorrelation(im1, im2);
if (Double.isNaN(corr)) {
System.out.println("Invalid correlation coefficient");
} else {
assert corr >= minCorr : "Correlation coefficient is less than minCorr";
}
}
}
private static double calculateCorrelation(int[] im1, int[] im2) {
// Code for calculating correlation coefficient
return 0.0; // Placeholder for correlation coefficient calculation
}
}
```
In the provided Java solution, the `processImageDifferences` method takes in the same parameters as the Python function and performs similar checks and operations. It creates a mask based on the absolute pixel differences exceeding the threshold, checks the number of pixels exceeding the threshold, extracts the differences based on the mask, and performs additional checks for maximum and average differences. Additionally, it calculates the correlation coefficient between the two images and handles invalid correlation coefficients. |
csharp | 14,986 | 3,352 |
public static string UploadDirectory { get; set; }
| fp_eeff13170a | You are tasked with creating a file management system that allows users to upload files to a specific directory. You need to implement a class that manages the upload directory and provides a method to upload files to that directory.
You are given a code snippet that defines a property `UploadDirectory` in a C# class. Your task is to complete the class by implementing a method to upload files to the specified directory.
Complete the following class:
```csharp
using System;
using System.IO;
public class FileManager
{
public static string UploadDirectory { get; set; }
// Implement a method to upload a file to the specified directory
public static void UploadFile(string fileName, byte[] fileContent)
{
// Your code here
}
}
```
Your implementation should allow users to set the `UploadDirectory` property and upload files to that directory using the `UploadFile` method. | ```csharp
using System;
using System.IO;
public class FileManager
{
public static string UploadDirectory { get; set; }
// Implement a method to upload a file to the specified directory
public static void UploadFile(string fileName, byte[] fileContent)
{
if (string.IsNullOrEmpty(UploadDirectory))
{
throw new InvalidOperationException("Upload directory is not specified.");
}
string filePath = Path.Combine(UploadDirectory, fileName);
File.WriteAllBytes(filePath, fileContent);
}
}
```
In the solution, the `UploadFile` method first checks if the `UploadDirectory` is specified. If not, it throws an `InvalidOperationException`. If the directory is specified, it combines the directory path with the file name and uses `File.WriteAllBytes` to write the file content to the specified path. |
python | 53,587 | 17,164 | local_url = "/home/garrison/Code/blogengine/output"
remote_url = "http://www.example.com"
site_title = "My Vanilla Blog"
site_description = "The really cool blog in which I write about stuff"
copy_rst = False
disqus_shortname = "mydisqusshortname"
| fp_eeff13170a | You are tasked with creating a Python script to generate a configuration file for a blog engine. The configuration file should contain settings for both local and remote URLs, site title, site description, a boolean flag for copying RST files, and a Disqus shortname.
You are given the following variables:
```python
local_url = "/home/garrison/Code/blogengine/output"
remote_url = "http://www.example.com"
site_title = "My Vanilla Blog"
site_description = "The really cool blog in which I write about stuff"
copy_rst = False
disqus_shortname = "mydisqusshortname"
```
Write a Python function `generate_config_file` that takes these variables as input and returns a string representing the configuration file in the following format:
```
# Blog Engine Configuration
local_url = "/home/garrison/Code/blogengine/output"
remote_url = "http://www.example.com"
site_title = "My Vanilla Blog"
site_description = "The really cool blog in which I write about stuff"
copy_rst = False
disqus_shortname = "mydisqusshortname"
```
The function should handle the conversion of the boolean `copy_rst` to a string representation in the configuration file. | ```python
def generate_config_file(local_url, remote_url, site_title, site_description, copy_rst, disqus_shortname):
config_file = f"# Blog Engine Configuration\n"
config_file += f"local_url = \"{local_url}\"\n"
config_file += f"remote_url = \"{remote_url}\"\n"
config_file += f"site_title = \"{site_title}\"\n"
config_file += f"site_description = \"{site_description}\"\n"
config_file += f"copy_rst = {str(copy_rst)}\n"
config_file += f"disqus_shortname = \"{disqus_shortname}\"\n"
return config_file
# Test the function
local_url = "/home/garrison/Code/blogengine/output"
remote_url = "http://www.example.com"
site_title = "My Vanilla Blog"
site_description = "The really cool blog in which I write about stuff"
copy_rst = False
disqus_shortname = "mydisqusshortname"
print(generate_config_file(local_url, remote_url, site_title, site_description, copy_rst, disqus_shortname))
```
The `generate_config_file` function takes the input variables and constructs a string representing the configuration file in the specified format. It handles the conversion of the boolean `copy_rst` to a string representation in the configuration file. |
python | 125,788 | 28,336 | from ..models.unique_identifier import UniqueIdentifier
from .base_heap_object_factory import HeapObjectFactory
class KvpHeapObjectFactory(HeapObjectFactory):
def __init__(self, obj: Dict, options: Options = None) -> None:
super().__init__(obj, options)
self._items = obj.items()
self._object_id = self.get_object_id(obj)
self._max_len = (self.options.max_size or len(self._items)) if self.options is not None else len(obj)
self._render_options: Optional[RenderOptions] = None
| fp_eeff13170a | You are tasked with implementing a Python class that extends a base class and handles the creation of heap objects. The base class, `HeapObjectFactory`, provides a framework for creating heap objects, and your task is to create a subclass called `KvpHeapObjectFactory` that specifically handles key-value pair objects.
The `KvpHeapObjectFactory` class should have the following features:
- It should inherit from the `HeapObjectFactory` class.
- The constructor should take two parameters: `obj`, which is a dictionary representing the key-value pair object, and `options`, which is an optional parameter of type `Options`.
- The `obj` parameter represents the key-value pair object that the factory will work with.
- The `options` parameter represents additional options that can be passed to the factory. If no `options` are provided, it should default to `None`.
- The class should have the following attributes:
- `_items`: This should store the key-value pairs of the input dictionary.
- `_object_id`: This should store the unique identifier of the object, obtained using the `get_object_id` method from the base class.
- `_max_len`: This should store the maximum size of the object, which is determined based on the provided `options` or the length of the input dictionary if no `options` are provided.
- `_render_options`: This should store the rendering options for the object, and it should default to `None`.
Your task is to complete the implementation of the `KvpHeapObjectFactory` class based on the provided code snippet and the outlined features. | ```python
from typing import Dict, Optional
from .base_heap_object_factory import HeapObjectFactory
from ..models.unique_identifier import UniqueIdentifier
from ..models.render_options import RenderOptions
from ..models.options import Options
class KvpHeapObjectFactory(HeapObjectFactory):
def __init__(self, obj: Dict, options: Optional[Options] = None) -> None:
super().__init__(obj, options)
self._items = obj.items()
self._object_id = self.get_object_id(obj)
self._max_len = (self.options.max_size or len(self._items)) if self.options is not None else len(obj)
self._render_options: Optional[RenderOptions] = None
```
In the solution, we complete the implementation of the `KvpHeapObjectFactory` class by inheriting from the `HeapObjectFactory` class and implementing the constructor with the required parameters and attributes. The `obj` parameter is used to store the key-value pairs of the input dictionary, and the `options` parameter is used to determine the maximum size of the object. The `get_object_id` method from the base class is used to obtain the unique identifier for the object, and the `_render_options` attribute is initialized to `None`. |
python | 122,139 | 15,312 | # glove.save(_GV_MODEL_FILE, binary=False)
glove2word2vec(glove_input_file=_GV_MODEL_FILE, word2vec_output_file=_GV_W2V_MODEL_FILE)
# with open(_GV_MODEL_FILE, 'rb') as f:
# buf = f.read()
# print(buf)
model = KeyedVectors.load_word2vec_format(_GV_W2V_MODEL_FILE, binary=False)
print(model.word_vec('apple'))
# model = loadGloveModel(_GV_W2V_MODEL_FILE)
if __name__ == '__main__':
create_glove_model()
| fp_eeff13170a | You are tasked with implementing a Python function that processes a given text file to create a GloVe word embedding model. GloVe (Global Vectors for Word Representation) is an unsupervised learning algorithm for obtaining vector representations for words. The provided code snippet serves as a starting point for creating the GloVe model. Your task is to complete the implementation of the `create_glove_model` function, which should read a text file, process its content, and generate a GloVe word embedding model.
The `create_glove_model` function should perform the following steps:
1. Read the content of a text file named `_GV_TEXT_FILE` and preprocess it to extract words and their co-occurrence statistics.
2. Use the extracted data to train a GloVe model and save it to a file named `_GV_MODEL_FILE`.
3. Convert the trained GloVe model to the word2vec format and save it to a file named `_GV_W2V_MODEL_FILE`.
4. Load the word2vec model and print the vector representation of the word 'apple'.
You are required to complete the implementation of the `create_glove_model` function to achieve the specified functionality.
```python
import os
from gensim.scripts.glove2word2vec import glove2word2vec
from gensim.models import KeyedVectors
from glove import Corpus, Glove
_GV_TEXT_FILE = 'input_text.txt'
_GV_MODEL_FILE = 'glove_model.txt'
_GV_W2V_MODEL_FILE = 'word2vec_model.txt'
def create_glove_model():
# Read the content of the text file and preprocess it
corpus = Corpus()
with open(_GV_TEXT_FILE, 'r', encoding='utf-8') as file:
text = file.read()
corpus.fit(text, window=10)
# Train the GloVe model and save it
glove = Glove(no_components=100, learning_rate=0.05)
glove.fit(corpus.matrix, epochs=30, no_threads=4, verbose=True)
glove.add_dictionary(corpus.dictionary)
glove.save(_GV_MODEL_FILE, binary=False)
# Convert the GloVe model to word2vec format and save it
glove2word2vec(glove_input_file=_GV_MODEL_FILE, word2vec_output_file=_GV_W2V_MODEL_FILE)
# Load the word2vec model and print the vector representation of the word 'apple'
model = KeyedVectors.load_word2vec_format(_GV_W2V_MODEL_FILE, binary=False)
print(model.word_vec('apple'))
if __name__ == '__main__':
create_glove_model()
``` | ```python
import os
from gensim.scripts.glove2word2vec import glove2word2vec
from gensim.models import KeyedVectors
from glove import Corpus, Glove
_GV_TEXT_FILE = 'input_text.txt'
_GV_MODEL_FILE = 'glove_model.txt'
_GV_W2V_MODEL_FILE = 'word2vec_model.txt'
def create_glove_model():
# Read the content of the text file and preprocess it
corpus = Corpus()
with open(_GV_TEXT_FILE, 'r', encoding='utf-8') as file:
text = file.read()
corpus.fit(text, window=10)
# Train the GloVe model and save it
glove = Glove(no_components=100, learning_rate=0.05)
glove.fit(corpus.matrix, epochs=30, no_threads=4, verbose=True)
glove.add_dictionary(corpus.dictionary)
glove.save(_GV_MODEL_FILE, binary=False)
# Convert the GloVe model to word2vec format and save it
glove2word2vec(glove_input_file=_GV_MODEL_FILE, word2vec_output_file=_GV_W2V_MODEL_FILE)
# Load the word2vec model and print the vector representation of the word 'apple'
model = KeyedVectors.load_word2vec_format(_GV_W2V_MODEL_FILE, binary=False)
print(model.word_vec('apple'))
if __name__ == '__main__':
create_glove_model()
```
The provided solution completes the implementation of the `create_glove_model` function. It reads the content of the specified text file, processes it to extract words and their co-occurrence statistics, trains a GloVe model, saves it to a file, converts the trained model to the word2vec format, and finally loads the word2vec model to print the vector representation of the word 'apple'. |
swift | 58,006 | 2,302 | self.Milliseconds = Milliseconds
self.Items = Items
}
}
struct TimedMessage {
let Milliseconds: UInt
let bytes: [UInt8]
}
| fp_eeff13170a | You are tasked with implementing a message queue system that can handle timed messages. Each timed message consists of a set of bytes and a delay in milliseconds before the message should be processed. Your goal is to design a class that manages the timed messages and processes them after the specified delay has elapsed.
You are provided with the following Swift code snippet as a starting point:
```swift
struct TimedMessage {
let Milliseconds: UInt
let bytes: [UInt8]
}
```
Your task is to implement a Swift class called `TimedMessageQueue` with the following specifications:
1. The class should have a property `messages` to store the timed messages in the queue.
2. Implement a method `addMessage` that takes a `TimedMessage` object and adds it to the queue.
3. Implement a method `processMessages` that simulates the passage of time and processes the messages in the queue after the specified delay has elapsed. When processing a message, print the message bytes to the console.
Your implementation should ensure that messages are processed in the order of their scheduled time.
Example:
```swift
let message1 = TimedMessage(Milliseconds: 2000, bytes: [0x48, 0x65, 0x6C, 0x6C, 0x6F]) // Delay: 2000ms
let message2 = TimedMessage(Milliseconds: 1000, bytes: [0x57, 0x6F, 0x72, 0x6C, 0x64]) // Delay: 1000ms
let queue = TimedMessageQueue()
queue.addMessage(message1)
queue.addMessage(message2)
queue.processMessages()
// Output after 1000ms: "World" (from message2)
// Output after 2000ms: "Hello" (from message1)
``` | ```swift
struct TimedMessage {
let Milliseconds: UInt
let bytes: [UInt8]
}
class TimedMessageQueue {
private var messages: [TimedMessage] = []
func addMessage(_ message: TimedMessage) {
messages.append(message)
}
func processMessages() {
messages.sort { $0.Milliseconds < $1.Milliseconds }
var currentTime: UInt = 0
for message in messages {
let delay = message.Milliseconds - currentTime
if delay > 0 {
usleep(useconds_t(delay * 1000)) // Simulate delay in milliseconds
currentTime += delay
}
print(String(bytes: message.bytes, encoding: .utf8) ?? "") // Print message bytes
}
}
}
``` |
python | 42,745 | 89 | self.head = head
def encode(self, content):
return super().encode('<!DOCTYPE html><html><head>' + self.head + '</head><body>' + str(content) + '</body></html>')
def run_server(info, port, encoder = JsonEncoder(), response_cache = {}):
class MyHandler(http.server.SimpleHTTPRequestHandler):
def respond(self, content, code=200):
self.send_response(code)
self.send_header("Content-type", encoder.get_type())
self.end_headers()
self.wfile.write(encoder.encode(content))
| fp_eeff13170a | You are tasked with implementing a simple web server in Python. Your goal is to extend the provided code snippet to create a web server that can handle HTTP requests and respond with encoded content. The server should support different encodings and response caching.
Your task is to complete the implementation of the `run_server` function and the `MyHandler` class. The `run_server` function should create an HTTP server that listens on the specified port and uses the provided encoder and response cache. The `MyHandler` class should handle incoming HTTP requests and respond with the appropriate content and encoding.
The `run_server` function takes the following parameters:
- `info`: A string representing server information.
- `port`: An integer representing the port number on which the server should listen.
- `encoder`: An instance of an encoder class that provides encoding and content type information. It defaults to `JsonEncoder()` if not provided.
- `response_cache`: A dictionary representing a cache for storing responses. It defaults to an empty dictionary if not provided.
The `MyHandler` class should extend `http.server.SimpleHTTPRequestHandler` and implement the following method:
- `respond(self, content, code=200)`: A method to send an HTTP response with the specified content and status code. It should use the provided encoder to encode the content and set the appropriate content type in the response headers.
Your implementation should support the following requirements:
1. The server should respond to HTTP requests with the appropriate content type and encoding based on the provided encoder.
2. The server should utilize response caching to store and retrieve responses based on the requested URL.
Complete the implementation of the `run_server` function and the `MyHandler` class to fulfill the requirements. | ```python
import http.server
import json
class JsonEncoder:
def get_type(self):
return 'application/json'
def encode(self, content):
return json.dumps(content).encode('utf-8')
class MyHandler(http.server.SimpleHTTPRequestHandler):
def do_GET(self):
url = self.path
if url in response_cache:
content, code = response_cache[url]
self.respond(content, code)
else:
self.respond("Not Found", 404)
def respond(self, content, code=200):
self.send_response(code)
self.send_header("Content-type", encoder.get_type())
self.end_headers()
self.wfile.write(encoder.encode(content))
def run_server(info, port, encoder=JsonEncoder(), response_cache={}):
server_address = ('', port)
MyHandler.encoder = encoder
MyHandler.response_cache = response_cache
httpd = http.server.HTTPServer(server_address, MyHandler)
print(f"Server running on port {port}...")
httpd.serve_forever()
```
In the solution, the `JsonEncoder` class provides encoding and content type information for JSON content. The `MyHandler` class extends `http.server.SimpleHTTPRequestHandler` and implements the `do_GET` method to handle incoming HTTP GET requests. It checks the response cache for the requested URL and responds accordingly. The `respond` method sends an HTTP response with the specified content and status code, utilizing the provided encoder and response cache.
The `run_server` function creates an HTTP server that listens on the specified port, using the provided encoder and response cache. It sets the encoder and response cache attributes for the `MyHandler` class and starts the server to handle incoming requests. |
python | 124,878 | 17,313 |
agent_func = """
@flamegpu_device_function
def helper(x: numpy.int16) -> int :
return x**2
@flamegpu_agent_function
def pred_output_location(message_in: MessageBruteForce, message_out: MessageBruteForce):
id = FLAMEGPU.getID()
offset = 10
| fp_eeff13170a | You are working on a project that involves simulating agent-based models using the FLAMEGPU framework, which allows for the parallel execution of agent-based models on GPUs. As part of this project, you need to implement a custom agent function that performs a specific computation on the agents' data.
The provided code snippet includes a partial implementation of the agent function in FLAMEGPU. Your task is to complete the implementation of the agent function based on the given code snippet and requirements.
The agent function `pred_output_location` takes two parameters: `message_in` and `message_out`, which are instances of the `MessageBruteForce` class. Inside the function, the agent's ID is obtained using `FLAMEGPU.getID()`, and an offset value of 10 is assigned to the variable `offset`.
Your task is to complete the implementation of the `pred_output_location` agent function by incorporating the following requirements:
1. Use the `helper` device function to calculate the square of the agent's ID.
2. Update the `message_out` with the result of the computation from the `helper` function and the `offset` value.
Complete the implementation of the `pred_output_location` agent function to meet the specified requirements. | ```python
agent_func = """
@flamegpu_device_function
def helper(x: numpy.int16) -> int :
return x**2
@flamegpu_agent_function
def pred_output_location(message_in: MessageBruteForce, message_out: MessageBruteForce):
id = FLAMEGPU.getID()
offset = 10
result = helper(id) + offset
message_out.setVariableInt("result", result)
"""
```
In the solution, the `helper` device function is used to calculate the square of the agent's ID. The result of this computation, along with the `offset` value, is stored in the `message_out` using the `setVariableInt` method. |
php | 127,357 | 2,164 | </div>
<!-- END of PAGE CONTENT | fp_eeff13170a | You are tasked with creating a program that can analyze and manipulate HTML code. Your program needs to identify the position of the closing tag for a specific HTML element within the given code snippet. The HTML code may contain multiple nested elements, and you need to locate the closing tag for a particular element.
Write a function `findClosingTagPosition(html, element)` that takes in two parameters:
- `html` (string): The HTML code snippet to be analyzed.
- `element` (string): The HTML element for which the closing tag position needs to be found.
The function should return the position (index) of the closing tag for the specified element within the HTML code. If the element is not found or has no closing tag, the function should return -1.
For example, given the following HTML code snippet:
```html
<div>
<p>This is a paragraph</p>
<div>
<span>Nested element</span>
</div>
</div>
<!-- END of PAGE CONTENT -->
```
If the function `findClosingTagPosition(html, 'div')` is called, it should return the position of the closing tag for the 'div' element, which is 63. | ```python
def findClosingTagPosition(html, element):
stack = []
start_tag = '<' + element
end_tag = '</' + element + '>'
for i in range(len(html)):
if html[i:i+len(start_tag)] == start_tag:
stack.append(i)
elif html[i:i+len(end_tag)] == end_tag:
if stack:
stack.pop()
else:
return -1
if not stack:
return i + len(end_tag) - 1
return -1
```
The `findClosingTagPosition` function uses a stack to keep track of the positions of opening tags encountered while iterating through the HTML code. When an opening tag is found, its position is added to the stack. If a closing tag is encountered, it checks if the stack is empty. If the stack is not empty, it means there is a corresponding opening tag, so it pops the position from the stack. If the stack is empty after processing the current tag, it means the closing tag for the specified element has been found, and the function returns the position. If the stack is not empty at the end of the iteration, it means the closing tag is missing, and the function returns -1. |
php | 53,997 | 4,405 | $exception->setSeverity(12346664321);
$this->expectException(LogicException::class);
new Exception($exception);
}
}
| fp_eeff13170a | You are tasked with implementing a custom exception class in PHP that can handle different severity levels. The severity levels are represented by integers, and the exception class should be able to throw exceptions with the specified severity level. Additionally, you need to create a test case to ensure that the exception is thrown with the correct severity level.
Your task is to complete the implementation of the custom exception class and write a test case to verify that the exception is thrown with the expected severity level.
Custom Exception Class:
```php
class CustomException extends Exception {
protected $severity;
public function setSeverity($severity) {
$this->severity = $severity;
}
public function getSeverity() {
return $this->severity;
}
}
```
Test Case:
```php
class CustomExceptionTest extends TestCase {
public function testExceptionSeverity() {
$exception = new CustomException();
$exception->setSeverity(12346664321);
$this->expectException(LogicException::class);
new Exception($exception);
}
}
```
Your task is to complete the `CustomException` class by adding the necessary code to throw an exception with the specified severity level. Additionally, you need to modify the test case to ensure that the exception is thrown with the correct severity level. | Custom Exception Class:
```php
class CustomException extends Exception {
protected $severity;
public function setSeverity($severity) {
$this->severity = $severity;
}
public function getSeverity() {
return $this->severity;
}
public function throwWithSeverity() {
throw new LogicException("Custom exception with severity: " . $this->severity, $this->severity);
}
}
```
Test Case:
```php
class CustomExceptionTest extends TestCase {
public function testExceptionSeverity() {
$exception = new CustomException();
$exception->setSeverity(12346664321);
$this->expectException(LogicException::class);
$this->expectExceptionMessage("Custom exception with severity: 12346664321");
$this->expectExceptionCode(12346664321);
$exception->throwWithSeverity();
}
}
```
In the solution, the `CustomException` class is extended to include a method `throwWithSeverity()` that throws a `LogicException` with the specified severity level. The test case is modified to assert that the exception is thrown with the correct severity level, message, and code. |
cpp | 45,805 | 4,733 | ConfigVariableList exclude_texture_scale
("exclude-texture-scale",
PRC_DESC("This is a list of glob patterns for texture filenames "
"(excluding the directory part of the filename, but including "
"the extension); for instance, 'digits_*.png'. Any texture "
"filenames that match one of these patterns will not be affected "
"by max-texture-dimension or texture-scale."));
ConfigVariableBool keep_texture_ram
| fp_eeff13170a | You are tasked with implementing a configuration variable system for a game engine. The system should allow for the definition and management of configuration variables with specific data types and descriptions.
Your task is to create a class or data structure to represent a configuration variable, and then implement a method to retrieve the description of a given configuration variable.
The configuration variable should have the following properties:
- Name: A string representing the name of the configuration variable.
- Type: The data type of the configuration variable (e.g., string, boolean, integer).
- Description: A string providing a description of the configuration variable.
You should also implement a method to retrieve the description of a given configuration variable by its name.
Use the following code snippet as a reference for the structure of a configuration variable:
```cpp
class ConfigVariable {
public:
std::string name;
std::string type;
std::string description;
ConfigVariable(std::string name, std::string type, std::string description)
: name(name), type(type), description(description) {}
};
// Example usage
ConfigVariable exclude_texture_scale("exclude-texture-scale", "string",
"This is a list of glob patterns for texture filenames "
"(excluding the directory part of the filename, but including "
"the extension); for instance, 'digits_*.png'. Any texture "
"filenames that match one of these patterns will not be affected "
"by max-texture-dimension or texture-scale.");
ConfigVariable keep_texture_ram("keep-texture-ram", "boolean",
"Specifies whether to keep the texture data in RAM after loading.");
```
Implement a method `getDescription` that takes the name of a configuration variable as a parameter and returns its description. If the configuration variable with the given name does not exist, the method should return "Variable not found". | ```cpp
#include <iostream>
#include <unordered_map>
class ConfigVariable {
public:
std::string name;
std::string type;
std::string description;
ConfigVariable(std::string name, std::string type, std::string description)
: name(name), type(type), description(description) {}
};
class ConfigManager {
private:
std::unordered_map<std::string, ConfigVariable> variables;
public:
void addVariable(const ConfigVariable& variable) {
variables[variable.name] = variable;
}
std::string getDescription(const std::string& name) {
if (variables.find(name) != variables.end()) {
return variables[name].description;
}
return "Variable not found";
}
};
int main() {
ConfigManager manager;
ConfigVariable exclude_texture_scale("exclude-texture-scale", "string",
"This is a list of glob patterns for texture filenames "
"(excluding the directory part of the filename, but including "
"the extension); for instance, 'digits_*.png'. Any texture "
"filenames that match one of these patterns will not be affected "
"by max-texture-dimension or texture-scale.");
ConfigVariable keep_texture_ram("keep-texture-ram", "boolean",
"Specifies whether to keep the texture data in RAM after loading.");
manager.addVariable(exclude_texture_scale);
manager.addVariable(keep_texture_ram);
std::cout << manager.getDescription("exclude-texture-scale") << std::endl; // Output: Description of exclude-texture-scale
std::cout << manager.getDescription("keep-texture-ram") << std::endl; // Output: Description of keep-texture-ram
std::cout << manager.getDescription("non-existent-variable") << std::endl; // Output: Variable not found
return 0;
}
``` |
python | 98,554 | 31,593 |
"""End-to-end tests for traffic control library."""
import os
import re
import sys
import unittest
import traffic_control
| fp_eeff13170a | You are tasked with creating a Python function that analyzes a given Python file to extract and count the number of imported modules. The function should take a file path as input and return a dictionary where the keys are the imported module names and the values are the number of times each module is imported.
For example, given the following Python file `example.py`:
```python
"""End-to-end tests for traffic control library."""
import os
import re
import sys
import unittest
import traffic_control
import traffic_control
import os
import re
import sys
import unittest
```
The function should return the following dictionary:
```python
{
'os': 2,
're': 2,
'sys': 2,
'unittest': 2,
'traffic_control': 2
}
```
Write a Python function called `count_imports` that takes a file path as input and returns a dictionary containing the count of imported modules as described above.
Function signature: `def count_imports(file_path: str) -> dict:`
Note:
- The imported modules can appear in the file with or without aliases.
- The file may contain comments and docstrings, but the function should only consider the actual import statements. | ```python
import ast
import collections
def count_imports(file_path: str) -> dict:
with open(file_path, 'r') as file:
tree = ast.parse(file.read())
import_counts = collections.defaultdict(int)
for node in ast.walk(tree):
if isinstance(node, ast.Import):
for alias in node.names:
import_counts[alias.name] += 1
elif isinstance(node, ast.ImportFrom):
module_name = node.module if node.module else ''
for alias in node.names:
import_counts[module_name + '.' + alias.name] += 1
return dict(import_counts)
```
This solution uses the `ast` module to parse the Python file and extract the import statements. It then iterates through the parsed tree to count the occurrences of each imported module, considering both regular imports and imports from specific modules. The result is returned as a dictionary with the module names as keys and their import counts as values. |
python | 35,306 | 27,194 | ('tf_auth', '0008_auto_20170417_0012'),
]
operations = [
migrations.RunPython(forwards, migrations.RunPython.noop)
]
| fp_eeff13170a | You are tasked with creating a Python function that processes a list of database migration operations and generates SQL statements based on the provided operations. Each migration operation is represented as a tuple containing the operation type and a version number. The function should handle two types of migration operations: "migrate" and "rollback". For "migrate" operations, the function should generate an SQL statement to apply the migration, while for "rollback" operations, it should generate an SQL statement to revert the migration.
The function signature should be:
```python
def generate_sql_statements(operations: List[Tuple[str, str]]) -> List[str]:
pass
```
For example, given the following list of operations:
```python
operations = [
('migrate', '0001_initial'),
('rollback', '0002_auto_20170417_0012'),
('migrate', '0003_auto_20170417_0012'),
('migrate', '0004_auto_20170417_0012'),
('rollback', '0005_auto_20170417_0012'),
]
```
The function should generate the corresponding SQL statements:
```
[
"APPLY MIGRATION '0001_initial'",
"REVERT MIGRATION '0002_auto_20170417_0012'",
"APPLY MIGRATION '0003_auto_20170417_0012'",
"APPLY MIGRATION '0004_auto_20170417_0012'",
"REVERT MIGRATION '0005_auto_20170417_0012'"
]
```
Note: The SQL statements should follow the format "APPLY MIGRATION '<version_number>'" for "migrate" operations and "REVERT MIGRATION '<version_number>'" for "rollback" operations. | ```python
from typing import List, Tuple
def generate_sql_statements(operations: List[Tuple[str, str]]) -> List[str]:
sql_statements = []
for operation, version in operations:
if operation == 'migrate':
sql_statements.append(f"APPLY MIGRATION '{version}'")
elif operation == 'rollback':
sql_statements.append(f"REVERT MIGRATION '{version}'")
return sql_statements
```
The `generate_sql_statements` function iterates through the list of operations and generates the corresponding SQL statements based on the operation type. For "migrate" operations, it appends "APPLY MIGRATION '<version_number>'" to the `sql_statements` list, and for "rollback" operations, it appends "REVERT MIGRATION '<version_number>'". Finally, it returns the list of generated SQL statements. |
python | 102,561 | 12,525 | scan_array = scan_nii.get_fdata()
scan_array[scan_array <= min_] = min_
scan_array[scan_array >= max_] = max_
tmp = nib.Nifti1Image(scan_array, affine = scan_nii.affine)
os.system(f"rm {scan_id}")
nib.save(tmp, scan_id)
if __name__ == "__main__":
| fp_eeff13170a | You are working on a medical imaging application that processes NIfTI (Neuroimaging Informatics Technology Initiative) files. The given code snippet is a part of a Python script that performs certain operations on a NIfTI image and saves the modified image back to the file system. Your task is to complete the script by implementing a function that will perform a specific image processing task.
The script processes a NIfTI image represented as a 3D array. The `scan_nii` variable holds the NIfTI image data, and `scan_id` is the file path where the NIfTI image is stored. The `min_` and `max_` variables represent the minimum and maximum intensity values for the image, respectively.
Your task is to implement the `process_nifti_image` function that takes the NIfTI image data, minimum and maximum intensity values, and returns the processed NIfTI image data. The processing involves clipping the intensity values of the image array such that any value less than `min_` is set to `min_` and any value greater than `max_` is set to `max_`.
Complete the script by implementing the `process_nifti_image` function and calling it within the `if __name__ == "__main__":` block to process the NIfTI image and save the modified image back to the file system. | ```python
import os
import nibabel as nib
def process_nifti_image(scan_array, min_, max_):
# Clip the intensity values of the image array
scan_array[scan_array <= min_] = min_
scan_array[scan_array >= max_] = max_
return scan_array
if __name__ == "__main__":
# Assuming scan_nii and scan_id are defined before this block
scan_array = scan_nii.get_fdata()
min_ = 50 # Example minimum intensity value
max_ = 200 # Example maximum intensity value
processed_array = process_nifti_image(scan_array, min_, max_)
processed_nifti = nib.Nifti1Image(processed_array, affine=scan_nii.affine)
os.system(f"rm {scan_id}") # Remove the original NIfTI file
nib.save(processed_nifti, scan_id) # Save the modified NIfTI image
```
In the solution, the `process_nifti_image` function takes the NIfTI image data `scan_array`, minimum intensity value `min_`, and maximum intensity value `max_` as input. It clips the intensity values of the image array and returns the processed array. Within the `if __name__ == "__main__":` block, the `process_nifti_image` function is called to process the NIfTI image and save the modified image back to the file system. |
python | 141,762 | 25,210 | for key in rooms[roomIdx]:
if not seen[key]:
seen[key] = True
stack.append(key)
| fp_eeff13170a | You are given a graph representing a network of rooms in a building. Each room is labeled with a unique integer identifier. The graph is represented as an adjacency list, where each key-value pair in the dictionary `rooms` represents a room and the rooms it is connected to. For example, `rooms[roomIdx]` returns a list of room identifiers that are directly connected to room `roomIdx`.
Your task is to implement a function `find_connected_rooms(rooms, start_room)` that takes in the adjacency list `rooms` and the identifier of a starting room `start_room`, and returns a list of all the rooms that are connected to the starting room, including the starting room itself. The function should use depth-first search (DFS) to traverse the graph.
The function should follow these guidelines:
- Use a stack to keep track of the rooms to visit.
- Use a dictionary `seen` to keep track of the rooms that have been visited.
- Initialize the `seen` dictionary with all rooms set to `False`.
- When visiting a room, mark it as seen and add it to the stack.
- Continue the DFS until the stack is empty.
Function signature: `def find_connected_rooms(rooms: dict, start_room: int) -> list`
For example, given the following `rooms` dictionary:
```
rooms = {
1: [2, 3],
2: [4],
3: [5],
4: [],
5: [6],
6: []
}
```
If `start_room = 1`, the function should return `[1, 2, 4, 3, 5, 6]` as these are all the rooms connected to room 1. | ```python
def find_connected_rooms(rooms: dict, start_room: int) -> list:
stack = [start_room]
seen = {room: False for room in rooms}
connected_rooms = []
while stack:
room_idx = stack.pop()
if not seen[room_idx]:
seen[room_idx] = True
connected_rooms.append(room_idx)
for key in rooms[room_idx]:
if not seen[key]:
stack.append(key)
return connected_rooms
``` |
cpp | 142,842 | 4,299 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include "callback.h"
int main()
{
int i = 0;
omp_set_num_threads(2);
#pragma omp parallel for
for (i = 0; i < 10; i++)
{
printf("Hello World #%d\n", i);
}
| fp_eeff13170a | You are tasked with implementing a callback mechanism in C++ to handle events in a multi-threaded environment. The callback mechanism should allow registering callback functions and invoking them when specific events occur. Additionally, you need to ensure thread safety and proper synchronization when invoking the callbacks.
You are provided with a basic code snippet that uses OpenMP for parallel processing. Your task is to implement the `Callback` class and its associated methods to achieve the desired functionality.
Your `Callback` class should have the following public methods:
1. `registerCallback`: This method should take a function pointer or a lambda function and register it as a callback.
2. `invokeCallbacks`: This method should be thread-safe and should invoke all the registered callbacks.
Your implementation should ensure that the `invokeCallbacks` method can be safely called from multiple threads without causing data races or other synchronization issues.
Your task is to complete the implementation of the `Callback` class and its methods to achieve the desired functionality.
```cpp
#include <iostream>
#include <vector>
#include <functional>
#include <omp.h>
class Callback {
public:
void registerCallback(std::function<void()> callback) {
// TODO: Implement callback registration
}
void invokeCallbacks() {
// TODO: Implement thread-safe invocation of registered callbacks
}
};
int main() {
Callback callback;
// Registering callbacks
callback.registerCallback([]() { std::cout << "Callback 1 invoked" << std::endl; });
callback.registerCallback([]() { std::cout << "Callback 2 invoked" << std::endl; });
// Simulating parallel processing
int i = 0;
omp_set_num_threads(2);
#pragma omp parallel for
for (i = 0; i < 10; i++) {
// Invoke callbacks within the parallel loop
callback.invokeCallbacks();
}
return 0;
}
``` | ```cpp
#include <iostream>
#include <vector>
#include <functional>
#include <omp.h>
#include <mutex>
class Callback {
private:
std::vector<std::function<void()>> callbacks;
std::mutex mutex;
public:
void registerCallback(std::function<void()> callback) {
std::lock_guard<std::mutex> lock(mutex);
callbacks.push_back(callback);
}
void invokeCallbacks() {
std::lock_guard<std::mutex> lock(mutex);
for (const auto& callback : callbacks) {
callback();
}
}
};
int main() {
Callback callback;
// Registering callbacks
callback.registerCallback([]() { std::cout << "Callback 1 invoked" << std::endl; });
callback.registerCallback([]() { std::cout << "Callback 2 invoked" << std::endl; });
// Simulating parallel processing
int i = 0;
omp_set_num_threads(2);
#pragma omp parallel for
for (i = 0; i < 10; i++) {
// Invoke callbacks within the parallel loop
callback.invokeCallbacks();
}
return 0;
}
```
In the solution, the `Callback` class is implemented with a vector to store the registered callbacks and a mutex for thread safety. The `registerCallback` method uses a lock guard to safely add the callback to the vector, and the `invokeCallbacks` method also uses a lock guard to safely iterate and invoke the registered callbacks. This ensures that the callback mechanism is thread-safe and can be used in a multi-threaded environment without synchronization issues. |
python | 13,908 | 28,491 | """
A DynamoDB table has an ItemCount value, but it is only updated every six hours.
To verify this DAG worked, we will scan the table and count the items manually.
"""
| fp_eeff13170a | You are tasked with creating a Python function to verify the accuracy of the ItemCount value in a DynamoDB table. The ItemCount value is only updated every six hours, so the function should scan the table and count the items manually to ensure the accuracy of the ItemCount value.
You are given the following information:
- The DynamoDB table has an ItemCount value that is updated every six hours.
- The function should scan the table and count the items manually to verify the accuracy of the ItemCount value.
Write a Python function `verify_item_count` that takes in the following parameters:
- `table_name`: a string representing the name of the DynamoDB table to be scanned.
The function should connect to the DynamoDB table, scan the table, and count the items to verify the accuracy of the ItemCount value. It should return a boolean value:
- `True` if the manually counted items match the ItemCount value in the table.
- `False` if the manually counted items do not match the ItemCount value in the table.
Assume that the necessary AWS credentials and permissions are already set up for accessing the DynamoDB table.
Example:
```python
# Assume the necessary AWS credentials and permissions are set up
result = verify_item_count('my_dynamodb_table')
print(result) # Output: True
``` | ```python
import boto3
def verify_item_count(table_name):
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table(table_name)
# Get the ItemCount value from the table
response = table.describe_table()
item_count = response['Table']['ItemCount']
# Scan the table and count the items manually
scan_response = table.scan()
manual_item_count = scan_response['Count']
# Verify the accuracy of the ItemCount value
return item_count == manual_item_count
```
The `verify_item_count` function connects to the specified DynamoDB table, retrieves the ItemCount value from the table, scans the table to count the items manually, and then compares the manually counted items with the ItemCount value. It returns `True` if the counts match and `False` if they do not. |
python | 19,646 | 26,689 | title=random.choice(NEGATIVE_REPLIES),
description=(
"Your display name is too long to be catified! "
"Please change it to be under 26 characters."
),
| fp_eeff13170a | You are tasked with creating a program that generates cat names from user input. However, there are certain rules that must be followed for a name to be considered valid. The program should prompt the user to input their desired cat name and then check if it meets the following criteria:
1. The name must be under 26 characters in length.
2. The name must not contain any special characters or numbers.
3. The name must not be empty.
If the user's input does not meet these criteria, the program should display a random negative reply and a corresponding description, as shown in the code snippet provided.
Your task is to implement the program to generate cat names and handle the validation of user input according to the specified criteria. | ```python
import random
import string
NEGATIVE_REPLIES = ["Sorry, that name won't work.", "Hmm, try again with a different name.", "Your cat name needs to be shorter."]
def generate_cat_name():
while True:
name = input("Enter your desired cat name: ")
if len(name) == 0 or len(name) > 25 or not name.isalpha():
print(f"title={random.choice(NEGATIVE_REPLIES)}, description=("Your display name is too long to be catified! Please change it to be under 26 characters.")")
else:
return name
valid_cat_name = generate_cat_name()
print(f"Your cat's name is: {valid_cat_name}")
```
In this solution, the program prompts the user to input a cat name and then checks if it meets the specified criteria. If the input is invalid, a random negative reply and a corresponding description are displayed. If the input is valid, the program outputs the cat's name. |
python | 123,256 | 31,183 | isEnabled=False
)
),
mlbRuntime=ElastigroupThirdPartiesIntegrationMlbRuntime(
| fp_eeff13170a | You are tasked with implementing a Python class that simulates a simple light switch. The class should have methods to turn the light on, turn the light off, and check the current state of the light. Additionally, the class should keep track of the number of times the light has been turned on and off. The class should also have a method to reset the count of on and off operations.
Your task is to complete the implementation of the `LightSwitch` class by filling in the missing methods. The class should be able to handle multiple instances of the light switch, each with its own count of on and off operations.
You are provided with a partial implementation of the `LightSwitch` class as a starting point:
```python
class LightSwitch:
def __init__(self):
self.is_enabled = False
self.on_count = 0
self.off_count = 0
def turn_on(self):
# TODO: Implement this method to turn the light on
pass
def turn_off(self):
# TODO: Implement this method to turn the light off
pass
def get_state(self):
# TODO: Implement this method to return the current state of the light
pass
def reset_count(self):
# TODO: Implement this method to reset the count of on and off operations
pass
```
Your task is to complete the implementation of the `LightSwitch` class by filling in the missing methods to meet the specified requirements. | ```python
class LightSwitch:
def __init__(self):
self.is_enabled = False
self.on_count = 0
self.off_count = 0
def turn_on(self):
self.is_enabled = True
self.on_count += 1
def turn_off(self):
self.is_enabled = False
self.off_count += 1
def get_state(self):
return "on" if self.is_enabled else "off"
def reset_count(self):
self.on_count = 0
self.off_count = 0
```
The completed `LightSwitch` class provides the functionality to turn the light on, turn the light off, check the current state of the light, and reset the count of on and off operations. The `turn_on` method sets the `is_enabled` attribute to `True` and increments the `on_count` attribute. The `turn_off` method sets the `is_enabled` attribute to `False` and increments the `off_count` attribute. The `get_state` method returns the current state of the light as a string ("on" or "off"). The `reset_count` method resets the count of on and off operations to zero. |
csharp | 55,666 | 983 | }
}
}
| fp_eeff13170a | You are given a class `Graph` representing a directed graph with nodes and edges. The class has a method `findShortestPath` that takes two node names as input and returns the shortest path between the two nodes. The graph is represented using an adjacency list.
The `Graph` class has the following structure:
```java
import java.util.*;
class Graph {
private Map<String, List<String>> adjacencyList;
public Graph() {
this.adjacencyList = new HashMap<>();
}
public void addNode(String nodeName) {
adjacencyList.put(nodeName, new ArrayList<>());
}
public void addEdge(String sourceNode, String destinationNode) {
if (adjacencyList.containsKey(sourceNode) && adjacencyList.containsKey(destinationNode)) {
adjacencyList.get(sourceNode).add(destinationNode);
} else {
throw new IllegalArgumentException("Node does not exist in the graph");
}
}
public List<String> findShortestPath(String startNode, String endNode) {
// Your implementation here
}
}
```
You need to implement the `findShortestPath` method to find the shortest path between the `startNode` and `endNode` using Breadth-First Search (BFS) algorithm. | ```java
import java.util.*;
class Graph {
private Map<String, List<String>> adjacencyList;
public Graph() {
this.adjacencyList = new HashMap<>();
}
public void addNode(String nodeName) {
adjacencyList.put(nodeName, new ArrayList<>());
}
public void addEdge(String sourceNode, String destinationNode) {
if (adjacencyList.containsKey(sourceNode) && adjacencyList.containsKey(destinationNode)) {
adjacencyList.get(sourceNode).add(destinationNode);
} else {
throw new IllegalArgumentException("Node does not exist in the graph");
}
}
public List<String> findShortestPath(String startNode, String endNode) {
if (!adjacencyList.containsKey(startNode) || !adjacencyList.containsKey(endNode)) {
throw new IllegalArgumentException("Start or end node does not exist in the graph");
}
Queue<String> queue = new LinkedList<>();
Map<String, String> parentMap = new HashMap<>();
Set<String> visited = new HashSet<>();
queue.add(startNode);
visited.add(startNode);
parentMap.put(startNode, null);
while (!queue.isEmpty()) {
String currentNode = queue.poll();
if (currentNode.equals(endNode)) {
return reconstructPath(parentMap, startNode, endNode);
}
for (String neighbor : adjacencyList.get(currentNode)) {
if (!visited.contains(neighbor)) {
queue.add(neighbor);
visited.add(neighbor);
parentMap.put(neighbor, currentNode);
}
}
}
return new ArrayList<>(); // No path found
}
private List<String> reconstructPath(Map<String, String> parentMap, String startNode, String endNode) {
List<String> path = new ArrayList<>();
String currentNode = endNode;
while (currentNode != null) {
path.add(0, currentNode);
currentNode = parentMap.get(currentNode);
}
return path;
}
}
``` |
python | 22,734 | 5,470 | @pytest.mark.parametrize("value", (("",), (1, 2)))
def test_get_netcdf_metadata_number_with_warning(value):
"""Tests computing the unpacked data type for a NetCDF variable."""
key = "name"
| fp_eeff13170a | You are tasked with creating a function that computes the unpacked data type for a NetCDF variable. NetCDF (Network Common Data Form) is a file format for storing multidimensional scientific data. The unpacked data type refers to the native data type of the variable, which may differ from the packed data type used for storage efficiency.
You are given a Python code snippet that uses the `pytest` library to define parameterized tests for the function. The `@pytest.mark.parametrize` decorator is used to specify different input values for the test cases. The `test_get_netcdf_metadata_number_with_warning` function is intended to test the computation of the unpacked data type for a NetCDF variable.
Your task is to implement the function `get_netcdf_metadata_number_with_warning` that takes a NetCDF variable as input and returns the unpacked data type. The function should handle cases where the input variable is empty or contains numerical data. | ```python
import netCDF4
def get_netcdf_metadata_number_with_warning(variable):
"""
Computes the unpacked data type for a NetCDF variable.
Args:
variable: netCDF4.Variable - The NetCDF variable for which the unpacked data type needs to be computed.
Returns:
str - The unpacked data type of the variable.
"""
if not variable:
return "Empty variable"
if variable.dtype.kind in 'SU':
return "String"
elif variable.dtype.kind in 'fiu':
return "Numeric"
else:
return "Unknown data type"
```
In the solution, the `netCDF4` library is used to work with NetCDF files. The `get_netcdf_metadata_number_with_warning` function takes a `netCDF4.Variable` object as input and determines the unpacked data type based on the data type of the variable. It checks if the variable is empty and returns an appropriate message. If the variable contains string data, it returns "String"; if it contains numerical data, it returns "Numeric"; otherwise, it returns "Unknown data type". |
cpp | 10,205 | 1,949 | * limitations under the License.
*/
#include "WriteChecker.h"
#include <activemq/transport/inactivity/InactivityMonitor.h>
#include <decaf/lang/System.h>
#include <decaf/lang/exceptions/NullPointerException.h>
using namespace activemq;
using namespace activemq::transport;
using namespace activemq::transport::inactivity;
using namespace decaf;
using namespace decaf::util;
| fp_eeff13170a | You are tasked with implementing a C++ class that performs write checking for a messaging system. The class should monitor the activity of a messaging transport and detect inactivity. To achieve this, you need to create a `WriteChecker` class that utilizes the `InactivityMonitor` from the `activemq::transport::inactivity` namespace.
Your task is to implement the `WriteChecker` class with the following requirements:
1. The class should have a method `checkWrite` that takes no parameters and returns void.
2. Inside the `checkWrite` method, it should use the `InactivityMonitor` to check for inactivity and perform appropriate actions if inactivity is detected.
3. The class should handle any potential exceptions that may occur during the write checking process.
You are provided with the following code snippet as a starting point:
```cpp
#include "WriteChecker.h"
#include <activemq/transport/inactivity/InactivityMonitor.h>
#include <decaf/lang/System.h>
#include <decaf/lang/exceptions/NullPointerException.h>
using namespace activemq;
using namespace activemq::transport;
using namespace activemq::transport::inactivity;
using namespace decaf;
using namespace decaf::util;
// Your implementation of the WriteChecker class goes here
```
Your task is to complete the `WriteChecker` class by implementing the `checkWrite` method and handling any necessary imports and namespace usage. | ```cpp
#include "WriteChecker.h"
#include <activemq/transport/inactivity/InactivityMonitor.h>
#include <decaf/lang/System.h>
#include <decaf/lang/exceptions/NullPointerException.h>
using namespace activemq;
using namespace activemq::transport;
using namespace activemq::transport::inactivity;
using namespace decaf;
using namespace decaf::util;
class WriteChecker {
public:
void checkWrite() {
try {
// Create an InactivityMonitor instance
InactivityMonitor monitor;
// Perform write checking using the InactivityMonitor
monitor.checkWrite();
} catch (const decaf::lang::exceptions::NullPointerException& e) {
// Handle NullPointerException
std::cerr << "NullPointerException occurred: " << e.what() << std::endl;
} catch (const std::exception& e) {
// Handle other exceptions
std::cerr << "Exception occurred: " << e.what() << std::endl;
}
}
};
```
In the solution, the `WriteChecker` class is implemented with the `checkWrite` method that utilizes the `InactivityMonitor` to perform write checking. The method also handles potential exceptions that may occur during the write checking process. |
python | 68,614 | 31,300 | name="openne",
url="https://github.com/thunlp/OpenNE",
license="MIT",
author="THUNLP",
description="Open Source Network Embedding toolkit",
packages=find_packages(),
long_description=open("README.md").read(),
zip_safe=False,
| fp_eeff13170a | You are tasked with creating a Python package management system that can parse and extract information from a package configuration file. The configuration file is in the format of a Python dictionary, containing details about the package such as name, URL, license, author, description, packages, and long description. Your goal is to implement a function that can extract specific information from this configuration file.
Write a function `extract_package_info(config: dict, info: str) -> str` that takes in a dictionary `config` representing the package configuration and a string `info` representing the specific information to be extracted. The function should return the value associated with the given `info` key in the `config` dictionary. If the `info` key is not present in the `config` dictionary, the function should return "Information not found".
For example, given the following `config` dictionary:
```python
config = {
"name": "openne",
"url": "https://github.com/thunlp/OpenNE",
"license": "MIT",
"author": "THUNLP",
"description": "Open Source Network Embedding toolkit",
"packages": ["package1", "package2"],
"long_description": "This is a long description of the package."
}
```
If the `info` is "author", the function should return "THUNLP". If the `info` is "version", the function should return "Information not found". | ```python
def extract_package_info(config: dict, info: str) -> str:
if info in config:
return config[info]
else:
return "Information not found"
```
The `extract_package_info` function checks if the given `info` key exists in the `config` dictionary. If it does, the function returns the corresponding value; otherwise, it returns "Information not found". This solution provides a straightforward approach to extracting specific information from the package configuration. |
End of preview. Expand
in Dataset Viewer.
YAML Metadata
Warning:
The task_categories "conversational" is not in the official list: text-classification, token-classification, table-question-answering, question-answering, zero-shot-classification, translation, summarization, feature-extraction, text-generation, text2text-generation, fill-mask, sentence-similarity, text-to-speech, text-to-audio, automatic-speech-recognition, audio-to-audio, audio-classification, voice-activity-detection, depth-estimation, image-classification, object-detection, image-segmentation, text-to-image, image-to-text, image-to-image, image-to-video, unconditional-image-generation, video-classification, reinforcement-learning, robotics, tabular-classification, tabular-regression, tabular-to-text, table-to-text, multiple-choice, text-retrieval, time-series-forecasting, text-to-video, image-text-to-text, visual-question-answering, document-question-answering, zero-shot-image-classification, graph-ml, mask-generation, zero-shot-object-detection, text-to-3d, image-to-3d, image-feature-extraction, other
This is the OSS-Instruct dataset generated by gpt-3.5-turbo-1106 developed by OpenAI. Please pay attention to OpenAI's usage policy when adopting this dataset: https://openai.com/policies/usage-policies.
- Downloads last month
- 935
Size of downloaded dataset files:
203 MB
Size of the auto-converted Parquet files:
88.3 MB
Number of rows:
75,197
