Datasets:

---

sourcegraph

/

test-dataset-context-aware-fim-autocomplete-oracle-openai_cosine_sim

like 0

Follow

Sourcegraph 19

[ { "filename": "platform/mkrules/src/sonic-vppcfgd/vppcfgd/config.py", "retrieved_chunk": " def update(self, sonic_vpp_cfg):\n \"\"\" Read current config from VPP \"\"\"\n self.vpp_json_cfg = self.vpp.get_config()\n self.deep_update(sonic_vpp_cfg, self.vpp_json_cfg)\n print_dict(self.vpp_json_cfg)\n def render_vpp_config(self):\n indoff=''\n self.vpp_startup_conf=''\n self.gen_vpp_conf(self.vpp_json_cfg, indoff)\n def gen_vpp_conf(self, cfg, indoff):", "score": 0.8240028619766235 }, { "filename": "platform/mkrules/src/sonic-vppcfgd/vppcfgd/config.py", "retrieved_chunk": "# See the License for the specific language governing permissions and\n# limitations under the License.\nimport json\nfrom .vars import g_dev_debug, VPP_CONFIG_JSON_PATH, VPP_CFG_STARTUP_PATH, VPP_BOOTUP_CFG_PATH, INDENT\nfrom .log import dev_debug, log_notice\nfrom .utils import print_dict\nimport os\nclass ConfigMgr(object):\n \"\"\" The class represents vpp configuration \"\"\"\n def __init__(self, vpp):", "score": 0.8204391598701477 }, { "filename": "platform/mkrules/src/sonic-vppcfgd/vppcfgd/config.py", "retrieved_chunk": " self.vpp = vpp\n self.vpp_json_cfg = None\n self.vpp_startup_conf = ''\n self.vpp_vports_conf = ''\n def reset(self):\n \"\"\" Reset stored config \"\"\"\n self.vpp_json_cfg = None\n self.vpp_startup_conf = ''\n self.vpp_vports_conf = ''\n def deep_update(self, input, output):", "score": 0.8191080689430237 }, { "filename": "platform/mkrules/src/sonic-vppcfgd/vppcfgd/config.py", "retrieved_chunk": " with open(VPP_CONFIG_JSON_PATH, \"w\") as fp:\n json.dump(self.vpp_json_cfg, fp, indent=4)\n dev_debug(\"bootup ports config {}\".format(self.vpp_vports_conf))\n with open(VPP_BOOTUP_CFG_PATH, \"w\") as fp:\n fp.write(self.vpp_vports_conf)\n dev_debug(\"startup {}\".format(self.vpp_startup_conf))\n with open(VPP_CFG_STARTUP_PATH, \"w\") as fp:\n fp.write(self.vpp_startup_conf)\n self.reset()\n log_notice(\"Config changes committed.\");", "score": 0.8173758387565613 }, { "filename": "platform/mkrules/src/sonic-vppcfgd/vppcfgd/vpp.py", "retrieved_chunk": "# See the License for the specific language governing permissions and\n# limitations under the License.\nimport json\nclass VppMgr(object):\n \"\"\" The class represents vpp configuration template in json\"\"\"\n def __init__(self, template):\n self.vpp_config = {}\n with open(template, \"r\") as flp:\n self.vpp_config = json.load(flp)\n print(\"Template {}\".format(self.vpp_config))", "score": 0.8168800473213196 } ]

[ { "filename": "tests/conformance/runner.py", "retrieved_chunk": " oneofs_pb2, # noqa: F401\n repeated_pb2, # noqa: F401\n strings_pb2, # noqa: F401\n wkt_any_pb2, # noqa: F401\n wkt_duration_pb2, # noqa: F401\n wkt_nested_pb2, # noqa: F401\n wkt_timestamp_pb2, # noqa: F401\n wkt_wrappers_pb2, # noqa: F401\n)\nfrom buf.validate.conformance.cases.custom_constraints import custom_constraints_pb2 # noqa: F401", "score": 0.8114248514175415 }, { "filename": "gen/buf/validate/conformance/cases/wkt_any_pb2.py", "retrieved_chunk": "from google.protobuf.internal import builder as _builder\n# @@protoc_insertion_point(imports)\n_sym_db = _symbol_database.Default()\nfrom buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2\nfrom google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2\nDESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\\n,buf/validate/conformance/cases/wkt_any.proto\\x12\\x1e\\x62uf.validate.conformance.cases\\x1a\\x1b\\x62uf/validate/validate.proto\\x1a\\x19google/protobuf/any.proto\\\"1\\n\\x07\\x41nyNone\\x12&\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x14.google.protobuf.AnyR\\x03val\\\"=\\n\\x0b\\x41nyRequired\\x12.\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x14.google.protobuf.AnyB\\x06\\xbaH\\x03\\xc8\\x01\\x01R\\x03val\\\"e\\n\\x05\\x41nyIn\\x12\\\\\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x14.google.protobuf.AnyB4\\xbaH1\\xa2\\x01.\\x12,type.googleapis.com/google.protobuf.DurationR\\x03val\\\"i\\n\\x08\\x41nyNotIn\\x12]\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x14.google.protobuf.AnyB5\\xbaH2\\xa2\\x01/\\x1a-type.googleapis.com/google.protobuf.TimestampR\\x03valb\\x06proto3')\n_globals = globals()\n_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)\n_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'buf.validate.conformance.cases.wkt_any_pb2', _globals)\nif _descriptor._USE_C_DESCRIPTORS == False:", "score": 0.8034172058105469 }, { "filename": "gen/buf/validate/conformance/cases/wkt_timestamp_pb2.py", "retrieved_chunk": "from google.protobuf.internal import builder as _builder\n# @@protoc_insertion_point(imports)\n_sym_db = _symbol_database.Default()\nfrom buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2\nfrom google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2\nDESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\\n2buf/validate/conformance/cases/wkt_timestamp.proto\\x12\\x1e\\x62uf.validate.conformance.cases\\x1a\\x1b\\x62uf/validate/validate.proto\\x1a\\x1fgoogle/protobuf/timestamp.proto\\\"=\\n\\rTimestampNone\\x12,\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampR\\x03val\\\"I\\n\\x11TimestampRequired\\x12\\x34\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x06\\xbaH\\x03\\xc8\\x01\\x01R\\x03val\\\"J\\n\\x0eTimestampConst\\x12\\x38\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\n\\xbaH\\x07\\xb2\\x01\\x04\\x12\\x02\\x08\\x03R\\x03val\\\"E\\n\\x0bTimestampLT\\x12\\x36\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x08\\xbaH\\x05\\xb2\\x01\\x02\\x1a\\x00R\\x03val\\\"H\\n\\x0cTimestampLTE\\x12\\x38\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\n\\xbaH\\x07\\xb2\\x01\\x04\\\"\\x02\\x08\\x01R\\x03val\\\"H\\n\\x0bTimestampGT\\x12\\x39\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x0b\\xbaH\\x08\\xb2\\x01\\x05*\\x03\\x10\\xe8\\x07R\\x03val\\\"J\\n\\x0cTimestampGTE\\x12:\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x0c\\xbaH\\t\\xb2\\x01\\x06\\x32\\x04\\x10\\xc0\\x84=R\\x03val\\\"K\\n\\rTimestampGTLT\\x12:\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x0c\\xbaH\\t\\xb2\\x01\\x06\\x1a\\x02\\x08\\x01*\\x00R\\x03val\\\"M\\n\\x0fTimestampExLTGT\\x12:\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x0c\\xbaH\\t\\xb2\\x01\\x06\\x1a\\x00*\\x02\\x08\\x01R\\x03val\\\"P\\n\\x0fTimestampGTELTE\\x12=\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x0f\\xbaH\\x0c\\xb2\\x01\\t\\\"\\x03\\x08\\x90\\x1c\\x32\\x02\\x08<R\\x03val\\\"R\\n\\x11TimestampExGTELTE\\x12=\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x0f\\xbaH\\x0c\\xb2\\x01\\t\\\"\\x02\\x08<2\\x03\\x08\\x90\\x1cR\\x03val\\\"H\\n\\x0eTimestampLTNow\\x12\\x36\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x08\\xbaH\\x05\\xb2\\x01\\x02\\x38\\x01R\\x03val\\\"H\\n\\x0eTimestampGTNow\\x12\\x36\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x08\\xbaH\\x05\\xb2\\x01\\x02@\\x01R\\x03val\\\"L\\n\\x0fTimestampWithin\\x12\\x39\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x0b\\xbaH\\x08\\xb2\\x01\\x05J\\x03\\x08\\x90\\x1cR\\x03val\\\"S\\n\\x14TimestampLTNowWithin\\x12;\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\r\\xbaH\\n\\xb2\\x01\\x07\\x38\\x01J\\x03\\x08\\x90\\x1cR\\x03val\\\"S\\n\\x14TimestampGTNowWithin\\x12;\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\r\\xbaH\\n\\xb2\\x01\\x07@\\x01J\\x03\\x08\\x90\\x1cR\\x03valb\\x06proto3')\n_globals = globals()\n_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)\n_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'buf.validate.conformance.cases.wkt_timestamp_pb2', _globals)\nif _descriptor._USE_C_DESCRIPTORS == False:", "score": 0.8025689721107483 }, { "filename": "tests/conformance/runner.py", "retrieved_chunk": "# segfaults when using a dynamic descriptor pool.\nfrom buf.validate.conformance.cases import (\n bool_pb2, # noqa: F401\n bytes_pb2, # noqa: F401\n enums_pb2, # noqa: F401\n filename_with_dash_pb2, # noqa: F401\n kitchen_sink_pb2, # noqa: F401\n maps_pb2, # noqa: F401\n messages_pb2, # noqa: F401\n numbers_pb2, # noqa: F401", "score": 0.8009651899337769 }, { "filename": "gen/buf/validate/conformance/cases/wkt_nested_pb2.py", "retrieved_chunk": "from google.protobuf.internal import builder as _builder\n# @@protoc_insertion_point(imports)\n_sym_db = _symbol_database.Default()\nfrom buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2\nDESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\\n/buf/validate/conformance/cases/wkt_nested.proto\\x12\\x1e\\x62uf.validate.conformance.cases\\x1a\\x1b\\x62uf/validate/validate.proto\\\"\\x84\\x02\\n\\x0bWktLevelOne\\x12Q\\n\\x03two\\x18\\x01 \\x01(\\x0b\\x32\\x37.buf.validate.conformance.cases.WktLevelOne.WktLevelTwoB\\x06\\xbaH\\x03\\xc8\\x01\\x01R\\x03two\\x1a\\xa1\\x01\\n\\x0bWktLevelTwo\\x12\\x63\\n\\x05three\\x18\\x01 \\x01(\\x0b\\x32\\x45.buf.validate.conformance.cases.WktLevelOne.WktLevelTwo.WktLevelThreeB\\x06\\xbaH\\x03\\xc8\\x01\\x01R\\x05three\\x1a-\\n\\rWktLevelThree\\x12\\x1c\\n\\x04uuid\\x18\\x01 \\x01(\\tB\\x08\\xbaH\\x05r\\x03\\xb0\\x01\\x01R\\x04uuidb\\x06proto3')\n_globals = globals()\n_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)\n_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'buf.validate.conformance.cases.wkt_nested_pb2', _globals)\nif _descriptor._USE_C_DESCRIPTORS == False:\n DESCRIPTOR._options = None", "score": 0.8004965782165527 } ]

[ { "filename": "gen/buf/validate/conformance/cases/numbers_pb2.py", "retrieved_chunk": " _SINT64LTE.fields_by_name['val']._options = None\n _SINT64LTE.fields_by_name['val']._serialized_options = b'\\272H\\005B\\003\\030\\200\\001'\n _SINT64GT.fields_by_name['val']._options = None\n _SINT64GT.fields_by_name['val']._serialized_options = b'\\272H\\004B\\002 '\n _SINT64GTE.fields_by_name['val']._options = None\n _SINT64GTE.fields_by_name['val']._serialized_options = b'\\272H\\004B\\002(\\020'\n _SINT64GTLT.fields_by_name['val']._options = None\n _SINT64GTLT.fields_by_name['val']._serialized_options = b'\\272H\\006B\\004\\020\\024 \\000'\n _SINT64EXLTGT.fields_by_name['val']._options = None\n _SINT64EXLTGT.fields_by_name['val']._serialized_options = b'\\272H\\006B\\004\\020\\000 \\024'", "score": 0.8057215213775635 }, { "filename": "gen/buf/validate/conformance/cases/numbers_pb2.py", "retrieved_chunk": " _INT64GTE.fields_by_name['val']._options = None\n _INT64GTE.fields_by_name['val']._serialized_options = b'\\272H\\004\\\"\\002(\\010'\n _INT64GTLT.fields_by_name['val']._options = None\n _INT64GTLT.fields_by_name['val']._serialized_options = b'\\272H\\006\\\"\\004\\020\\n \\000'\n _INT64EXLTGT.fields_by_name['val']._options = None\n _INT64EXLTGT.fields_by_name['val']._serialized_options = b'\\272H\\006\\\"\\004\\020\\000 \\n'\n _INT64GTELTE.fields_by_name['val']._options = None\n _INT64GTELTE.fields_by_name['val']._serialized_options = b'\\272H\\010\\\"\\006\\030\\200\\002(\\200\\001'\n _INT64EXGTELTE.fields_by_name['val']._options = None\n _INT64EXGTELTE.fields_by_name['val']._serialized_options = b'\\272H\\010\\\"\\006\\030\\200\\001(\\200\\002'", "score": 0.8021782040596008 }, { "filename": "gen/buf/validate/conformance/cases/numbers_pb2.py", "retrieved_chunk": " _FIXED64LT.fields_by_name['val']._options = None\n _FIXED64LT.fields_by_name['val']._serialized_options = b'\\272H\\013R\\t\\021\\005\\000\\000\\000\\000\\000\\000\\000'\n _FIXED64LTE.fields_by_name['val']._options = None\n _FIXED64LTE.fields_by_name['val']._serialized_options = b'\\272H\\013R\\t\\031@\\000\\000\\000\\000\\000\\000\\000'\n _FIXED64GT.fields_by_name['val']._options = None\n _FIXED64GT.fields_by_name['val']._serialized_options = b'\\272H\\013R\\t!\\020\\000\\000\\000\\000\\000\\000\\000'\n _FIXED64GTE.fields_by_name['val']._options = None\n _FIXED64GTE.fields_by_name['val']._serialized_options = b'\\272H\\013R\\t)\\010\\000\\000\\000\\000\\000\\000\\000'\n _FIXED64GTLT.fields_by_name['val']._options = None\n _FIXED64GTLT.fields_by_name['val']._serialized_options = b'\\272H\\024R\\022\\021\\n\\000\\000\\000\\000\\000\\000\\000!\\005\\000\\000\\000\\000\\000\\000\\000'", "score": 0.8021023273468018 }, { "filename": "gen/buf/validate/conformance/cases/numbers_pb2.py", "retrieved_chunk": " _SFIXED64NOTIN.fields_by_name['val']._options = None\n _SFIXED64NOTIN.fields_by_name['val']._serialized_options = b'\\272H\\014b\\n:\\010\\000\\000\\000\\000\\000\\000\\000\\000'\n _SFIXED64LT.fields_by_name['val']._options = None\n _SFIXED64LT.fields_by_name['val']._serialized_options = b'\\272H\\013b\\t\\021\\000\\000\\000\\000\\000\\000\\000\\000'\n _SFIXED64LTE.fields_by_name['val']._options = None\n _SFIXED64LTE.fields_by_name['val']._serialized_options = b'\\272H\\013b\\t\\031@\\000\\000\\000\\000\\000\\000\\000'\n _SFIXED64GT.fields_by_name['val']._options = None\n _SFIXED64GT.fields_by_name['val']._serialized_options = b'\\272H\\013b\\t!\\020\\000\\000\\000\\000\\000\\000\\000'\n _SFIXED64GTE.fields_by_name['val']._options = None\n _SFIXED64GTE.fields_by_name['val']._serialized_options = b'\\272H\\013b\\t)\\010\\000\\000\\000\\000\\000\\000\\000'", "score": 0.8017646074295044 }, { "filename": "gen/buf/validate/conformance/cases/numbers_pb2.py", "retrieved_chunk": " _SINT64GTELTE.fields_by_name['val']._options = None\n _SINT64GTELTE.fields_by_name['val']._serialized_options = b'\\272H\\010B\\006\\030\\200\\004(\\200\\002'\n _SINT64EXGTELTE.fields_by_name['val']._options = None\n _SINT64EXGTELTE.fields_by_name['val']._serialized_options = b'\\272H\\010B\\006\\030\\200\\002(\\200\\004'\n _SINT64IGNORE.fields_by_name['val']._options = None\n _SINT64IGNORE.fields_by_name['val']._serialized_options = b'\\272H\\013B\\006\\030\\200\\004(\\200\\002\\320\\001\\001'\n _SINT64INCORRECTTYPE.fields_by_name['val']._options = None\n _SINT64INCORRECTTYPE.fields_by_name['val']._serialized_options = b'\\272H\\007\\n\\005%\\000\\000\\000\\000'\n _FIXED32CONST.fields_by_name['val']._options = None\n _FIXED32CONST.fields_by_name['val']._serialized_options = b'\\272H\\007J\\005\\r\\001\\000\\000\\000'", "score": 0.7956457138061523 } ]

[ { "filename": "protovalidate/internal/constraints.py", "retrieved_chunk": " violations = expression_pb2.Violations()\n self._violations = violations\n @property\n def fail_fast(self) -> bool:\n return self._fail_fast\n @property\n def violations(self) -> expression_pb2.Violations:\n return self._violations\n def add(self, field_name: str, constraint_id: str, message: str):\n self._violations.violations.append(", "score": 0.8188672065734863 }, { "filename": "protovalidate/internal/constraints.py", "retrieved_chunk": " return _repeated_field_to_cel(msg, field)\n elif field.message_type is not None and not msg.HasField(field.name):\n return None\n else:\n return _scalar_field_value_to_cel(getattr(msg, field.name), field)\nclass ConstraintContext:\n \"\"\"The state associated with a single constraint evaluation.\"\"\"\n def __init__(self, fail_fast: bool = False, violations: expression_pb2.Violations = None): # noqa: FBT001, FBT002\n self._fail_fast = fail_fast\n if violations is None:", "score": 0.8089085817337036 }, { "filename": "protovalidate/internal/constraints.py", "retrieved_chunk": " expression_pb2.Violation(\n field_path=field_name,\n constraint_id=constraint_id,\n message=message,\n )\n )\n def add_errors(self, other_ctx):\n self._violations.violations.extend(other_ctx.violations.violations)\n def add_path_prefix(self, prefix: str, delim=\".\"):\n for violation in self._violations.violations:", "score": 0.8076056241989136 }, { "filename": "protovalidate/__init__.py", "retrieved_chunk": "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nfrom protovalidate import validator\nValidator = validator.Validator\nCompilationError = validator.CompilationError\nValidationError = validator.ValidationError\nViolations = validator.Violations\n_validator = Validator()\nvalidate = _validator.validate", "score": 0.7955551743507385 }, { "filename": "protovalidate/__init__.py", "retrieved_chunk": "collect_violations = _validator.collect_violations\n__all__ = [\"Validator\", \"CompilationError\", \"ValidationError\", \"Violations\", \"validate\", \"collect_violations\"]", "score": 0.7793749570846558 } ]

[ { "filename": "gen/buf/validate/conformance/cases/wkt_timestamp_pb2.py", "retrieved_chunk": "from google.protobuf.internal import builder as _builder\n# @@protoc_insertion_point(imports)\n_sym_db = _symbol_database.Default()\nfrom buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2\nfrom google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2\nDESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\\n2buf/validate/conformance/cases/wkt_timestamp.proto\\x12\\x1e\\x62uf.validate.conformance.cases\\x1a\\x1b\\x62uf/validate/validate.proto\\x1a\\x1fgoogle/protobuf/timestamp.proto\\\"=\\n\\rTimestampNone\\x12,\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampR\\x03val\\\"I\\n\\x11TimestampRequired\\x12\\x34\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x06\\xbaH\\x03\\xc8\\x01\\x01R\\x03val\\\"J\\n\\x0eTimestampConst\\x12\\x38\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\n\\xbaH\\x07\\xb2\\x01\\x04\\x12\\x02\\x08\\x03R\\x03val\\\"E\\n\\x0bTimestampLT\\x12\\x36\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x08\\xbaH\\x05\\xb2\\x01\\x02\\x1a\\x00R\\x03val\\\"H\\n\\x0cTimestampLTE\\x12\\x38\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\n\\xbaH\\x07\\xb2\\x01\\x04\\\"\\x02\\x08\\x01R\\x03val\\\"H\\n\\x0bTimestampGT\\x12\\x39\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x0b\\xbaH\\x08\\xb2\\x01\\x05*\\x03\\x10\\xe8\\x07R\\x03val\\\"J\\n\\x0cTimestampGTE\\x12:\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x0c\\xbaH\\t\\xb2\\x01\\x06\\x32\\x04\\x10\\xc0\\x84=R\\x03val\\\"K\\n\\rTimestampGTLT\\x12:\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x0c\\xbaH\\t\\xb2\\x01\\x06\\x1a\\x02\\x08\\x01*\\x00R\\x03val\\\"M\\n\\x0fTimestampExLTGT\\x12:\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x0c\\xbaH\\t\\xb2\\x01\\x06\\x1a\\x00*\\x02\\x08\\x01R\\x03val\\\"P\\n\\x0fTimestampGTELTE\\x12=\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x0f\\xbaH\\x0c\\xb2\\x01\\t\\\"\\x03\\x08\\x90\\x1c\\x32\\x02\\x08<R\\x03val\\\"R\\n\\x11TimestampExGTELTE\\x12=\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x0f\\xbaH\\x0c\\xb2\\x01\\t\\\"\\x02\\x08<2\\x03\\x08\\x90\\x1cR\\x03val\\\"H\\n\\x0eTimestampLTNow\\x12\\x36\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x08\\xbaH\\x05\\xb2\\x01\\x02\\x38\\x01R\\x03val\\\"H\\n\\x0eTimestampGTNow\\x12\\x36\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x08\\xbaH\\x05\\xb2\\x01\\x02@\\x01R\\x03val\\\"L\\n\\x0fTimestampWithin\\x12\\x39\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\x0b\\xbaH\\x08\\xb2\\x01\\x05J\\x03\\x08\\x90\\x1cR\\x03val\\\"S\\n\\x14TimestampLTNowWithin\\x12;\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\r\\xbaH\\n\\xb2\\x01\\x07\\x38\\x01J\\x03\\x08\\x90\\x1cR\\x03val\\\"S\\n\\x14TimestampGTNowWithin\\x12;\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x1a.google.protobuf.TimestampB\\r\\xbaH\\n\\xb2\\x01\\x07@\\x01J\\x03\\x08\\x90\\x1cR\\x03valb\\x06proto3')\n_globals = globals()\n_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)\n_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'buf.validate.conformance.cases.wkt_timestamp_pb2', _globals)\nif _descriptor._USE_C_DESCRIPTORS == False:", "score": 0.7876836657524109 }, { "filename": "gen/buf/validate/conformance/cases/wkt_any_pb2.py", "retrieved_chunk": "from google.protobuf.internal import builder as _builder\n# @@protoc_insertion_point(imports)\n_sym_db = _symbol_database.Default()\nfrom buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2\nfrom google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2\nDESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\\n,buf/validate/conformance/cases/wkt_any.proto\\x12\\x1e\\x62uf.validate.conformance.cases\\x1a\\x1b\\x62uf/validate/validate.proto\\x1a\\x19google/protobuf/any.proto\\\"1\\n\\x07\\x41nyNone\\x12&\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x14.google.protobuf.AnyR\\x03val\\\"=\\n\\x0b\\x41nyRequired\\x12.\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x14.google.protobuf.AnyB\\x06\\xbaH\\x03\\xc8\\x01\\x01R\\x03val\\\"e\\n\\x05\\x41nyIn\\x12\\\\\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x14.google.protobuf.AnyB4\\xbaH1\\xa2\\x01.\\x12,type.googleapis.com/google.protobuf.DurationR\\x03val\\\"i\\n\\x08\\x41nyNotIn\\x12]\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x14.google.protobuf.AnyB5\\xbaH2\\xa2\\x01/\\x1a-type.googleapis.com/google.protobuf.TimestampR\\x03valb\\x06proto3')\n_globals = globals()\n_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)\n_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'buf.validate.conformance.cases.wkt_any_pb2', _globals)\nif _descriptor._USE_C_DESCRIPTORS == False:", "score": 0.7734032869338989 }, { "filename": "gen/buf/validate/conformance/cases/wkt_nested_pb2.py", "retrieved_chunk": "from google.protobuf.internal import builder as _builder\n# @@protoc_insertion_point(imports)\n_sym_db = _symbol_database.Default()\nfrom buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2\nDESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\\n/buf/validate/conformance/cases/wkt_nested.proto\\x12\\x1e\\x62uf.validate.conformance.cases\\x1a\\x1b\\x62uf/validate/validate.proto\\\"\\x84\\x02\\n\\x0bWktLevelOne\\x12Q\\n\\x03two\\x18\\x01 \\x01(\\x0b\\x32\\x37.buf.validate.conformance.cases.WktLevelOne.WktLevelTwoB\\x06\\xbaH\\x03\\xc8\\x01\\x01R\\x03two\\x1a\\xa1\\x01\\n\\x0bWktLevelTwo\\x12\\x63\\n\\x05three\\x18\\x01 \\x01(\\x0b\\x32\\x45.buf.validate.conformance.cases.WktLevelOne.WktLevelTwo.WktLevelThreeB\\x06\\xbaH\\x03\\xc8\\x01\\x01R\\x05three\\x1a-\\n\\rWktLevelThree\\x12\\x1c\\n\\x04uuid\\x18\\x01 \\x01(\\tB\\x08\\xbaH\\x05r\\x03\\xb0\\x01\\x01R\\x04uuidb\\x06proto3')\n_globals = globals()\n_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)\n_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'buf.validate.conformance.cases.wkt_nested_pb2', _globals)\nif _descriptor._USE_C_DESCRIPTORS == False:\n DESCRIPTOR._options = None", "score": 0.7704271674156189 }, { "filename": "protovalidate/internal/constraints.py", "retrieved_chunk": "from protovalidate.internal import string_format\nclass CompilationError(Exception):\n pass\ndef make_key_path(field_name: str, key: celtypes.Value) -> str:\n return f\"{field_name}[{string_format.format_value(key)}]\"\ndef make_duration(msg: message.Message) -> celtypes.DurationType:\n return celtypes.DurationType(\n seconds=msg.seconds, # type: ignore\n nanos=msg.nanos, # type: ignore\n )", "score": 0.7670688629150391 }, { "filename": "gen/buf/validate/conformance/cases/wkt_duration_pb2.py", "retrieved_chunk": "from google.protobuf.internal import builder as _builder\n# @@protoc_insertion_point(imports)\n_sym_db = _symbol_database.Default()\nfrom buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2\nfrom google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2\nDESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\\n1buf/validate/conformance/cases/wkt_duration.proto\\x12\\x1e\\x62uf.validate.conformance.cases\\x1a\\x1b\\x62uf/validate/validate.proto\\x1a\\x1egoogle/protobuf/duration.proto\\\";\\n\\x0c\\x44urationNone\\x12+\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x19.google.protobuf.DurationR\\x03val\\\"G\\n\\x10\\x44urationRequired\\x12\\x33\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x19.google.protobuf.DurationB\\x06\\xbaH\\x03\\xc8\\x01\\x01R\\x03val\\\"H\\n\\rDurationConst\\x12\\x37\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x19.google.protobuf.DurationB\\n\\xbaH\\x07\\xaa\\x01\\x04\\x12\\x02\\x08\\x03R\\x03val\\\"J\\n\\nDurationIn\\x12<\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x19.google.protobuf.DurationB\\x0f\\xbaH\\x0c\\xaa\\x01\\t:\\x02\\x08\\x01:\\x03\\x10\\xe8\\x07R\\x03val\\\"F\\n\\rDurationNotIn\\x12\\x35\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x19.google.protobuf.DurationB\\x08\\xbaH\\x05\\xaa\\x01\\x02\\x42\\x00R\\x03val\\\"C\\n\\nDurationLT\\x12\\x35\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x19.google.protobuf.DurationB\\x08\\xbaH\\x05\\xaa\\x01\\x02\\x1a\\x00R\\x03val\\\"F\\n\\x0b\\x44urationLTE\\x12\\x37\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x19.google.protobuf.DurationB\\n\\xbaH\\x07\\xaa\\x01\\x04\\\"\\x02\\x08\\x01R\\x03val\\\"F\\n\\nDurationGT\\x12\\x38\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x19.google.protobuf.DurationB\\x0b\\xbaH\\x08\\xaa\\x01\\x05*\\x03\\x10\\xe8\\x07R\\x03val\\\"H\\n\\x0b\\x44urationGTE\\x12\\x39\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x19.google.protobuf.DurationB\\x0c\\xbaH\\t\\xaa\\x01\\x06\\x32\\x04\\x10\\xc0\\x84=R\\x03val\\\"I\\n\\x0c\\x44urationGTLT\\x12\\x39\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x19.google.protobuf.DurationB\\x0c\\xbaH\\t\\xaa\\x01\\x06\\x1a\\x02\\x08\\x01*\\x00R\\x03val\\\"K\\n\\x0e\\x44urationExLTGT\\x12\\x39\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x19.google.protobuf.DurationB\\x0c\\xbaH\\t\\xaa\\x01\\x06\\x1a\\x00*\\x02\\x08\\x01R\\x03val\\\"N\\n\\x0e\\x44urationGTELTE\\x12<\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x19.google.protobuf.DurationB\\x0f\\xbaH\\x0c\\xaa\\x01\\t\\\"\\x03\\x08\\x90\\x1c\\x32\\x02\\x08<R\\x03val\\\"P\\n\\x10\\x44urationExGTELTE\\x12<\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x19.google.protobuf.DurationB\\x0f\\xbaH\\x0c\\xaa\\x01\\t\\\"\\x02\\x08<2\\x03\\x08\\x90\\x1cR\\x03val\\\"\\x8a\\x01\\n\\x1c\\x44urationFieldWithOtherFields\\x12H\\n\\x0c\\x64uration_val\\x18\\x01 \\x01(\\x0b\\x32\\x19.google.protobuf.DurationB\\n\\xbaH\\x07\\xaa\\x01\\x04\\\"\\x02\\x08\\x01R\\x0b\\x64urationVal\\x12 \\n\\x07int_val\\x18\\x02 \\x01(\\x05\\x42\\x07\\xbaH\\x04\\x1a\\x02 \\x10R\\x06intValb\\x06proto3')\n_globals = globals()\n_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)\n_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'buf.validate.conformance.cases.wkt_duration_pb2', _globals)\nif _descriptor._USE_C_DESCRIPTORS == False:", "score": 0.7662765979766846 } ]

[ { "filename": "gen/buf/validate/conformance/cases/repeated_pb2.py", "retrieved_chunk": "_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'buf.validate.conformance.cases.repeated_pb2', _globals)\nif _descriptor._USE_C_DESCRIPTORS == False:\n DESCRIPTOR._options = None\n _EMBED.fields_by_name['val']._options = None\n _EMBED.fields_by_name['val']._serialized_options = b'\\272H\\004\\\"\\002 \\000'\n _REPEATEDMIN.fields_by_name['val']._options = None\n _REPEATEDMIN.fields_by_name['val']._serialized_options = b'\\272H\\005\\222\\001\\002\\010\\002'\n _REPEATEDMAX.fields_by_name['val']._options = None\n _REPEATEDMAX.fields_by_name['val']._serialized_options = b'\\272H\\005\\222\\001\\002\\020\\003'\n _REPEATEDMINMAX.fields_by_name['val']._options = None", "score": 0.7953979969024658 }, { "filename": "gen/buf/validate/conformance/cases/messages_pb2.py", "retrieved_chunk": "from google.protobuf.internal import builder as _builder\n# @@protoc_insertion_point(imports)\n_sym_db = _symbol_database.Default()\nfrom buf.validate.conformance.cases.other_package import embed_pb2 as buf_dot_validate_dot_conformance_dot_cases_dot_other__package_dot_embed__pb2\nfrom buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2\nDESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\\n-buf/validate/conformance/cases/messages.proto\\x12\\x1e\\x62uf.validate.conformance.cases\\x1a\\x38\\x62uf/validate/conformance/cases/other_package/embed.proto\\x1a\\x1b\\x62uf/validate/validate.proto\\\"l\\n\\x07TestMsg\\x12 \\n\\x05\\x63onst\\x18\\x01 \\x01(\\tB\\n\\xbaH\\x07r\\x05\\n\\x03\\x66ooR\\x05\\x63onst\\x12?\\n\\x06nested\\x18\\x02 \\x01(\\x0b\\x32\\'.buf.validate.conformance.cases.TestMsgR\\x06nested\\\"_\\n\\x0bMessageNone\\x12\\x45\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x33.buf.validate.conformance.cases.MessageNone.NoneMsgR\\x03val\\x1a\\t\\n\\x07NoneMsg\\\"3\\n\\x0fMessageDisabled\\x12\\x19\\n\\x03val\\x18\\x01 \\x01(\\x04\\x42\\x07\\xbaH\\x04\\x32\\x02 {R\\x03val:\\x05\\xbaH\\x02\\x08\\x01\\\"D\\n\\x07Message\\x12\\x39\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\'.buf.validate.conformance.cases.TestMsgR\\x03val\\\"\\\\\\n\\x13MessageCrossPackage\\x12\\x45\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x33.buf.validate.conformance.cases.other_package.EmbedR\\x03val\\\"P\\n\\x0bMessageSkip\\x12\\x41\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\'.buf.validate.conformance.cases.TestMsgB\\x06\\xbaH\\x03\\xc0\\x01\\x01R\\x03val\\\"T\\n\\x0fMessageRequired\\x12\\x41\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\'.buf.validate.conformance.cases.TestMsgB\\x06\\xbaH\\x03\\xc8\\x01\\x01R\\x03val\\\"l\\n\\x1aMessageRequiredButOptional\\x12\\x46\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\'.buf.validate.conformance.cases.TestMsgB\\x06\\xbaH\\x03\\xc8\\x01\\x01H\\x00R\\x03val\\x88\\x01\\x01\\x42\\x06\\n\\x04_val\\\"i\\n\\x14MessageRequiredOneof\\x12\\x43\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\'.buf.validate.conformance.cases.TestMsgB\\x06\\xbaH\\x03\\xc8\\x01\\x01H\\x00R\\x03valB\\x0c\\n\\x03one\\x12\\x05\\xbaH\\x02\\x08\\x01\\\"\\x15\\n\\x13MessageWith3dInsideb\\x06proto3')\n_globals = globals()\n_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)\n_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'buf.validate.conformance.cases.messages_pb2', _globals)\nif _descriptor._USE_C_DESCRIPTORS == False:", "score": 0.7933809757232666 }, { "filename": "gen/buf/validate/conformance/cases/repeated_pb2.py", "retrieved_chunk": "from google.protobuf.internal import builder as _builder\n# @@protoc_insertion_point(imports)\n_sym_db = _symbol_database.Default()\nfrom buf.validate.conformance.cases.other_package import embed_pb2 as buf_dot_validate_dot_conformance_dot_cases_dot_other__package_dot_embed__pb2\nfrom buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2\nfrom google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2\nfrom google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2\nDESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\\n-buf/validate/conformance/cases/repeated.proto\\x12\\x1e\\x62uf.validate.conformance.cases\\x1a\\x38\\x62uf/validate/conformance/cases/other_package/embed.proto\\x1a\\x1b\\x62uf/validate/validate.proto\\x1a\\x19google/protobuf/any.proto\\x1a\\x1egoogle/protobuf/duration.proto\\\"\\\"\\n\\x05\\x45mbed\\x12\\x19\\n\\x03val\\x18\\x01 \\x01(\\x03\\x42\\x07\\xbaH\\x04\\\"\\x02 \\x00R\\x03val\\\" \\n\\x0cRepeatedNone\\x12\\x10\\n\\x03val\\x18\\x01 \\x03(\\x03R\\x03val\\\"L\\n\\x11RepeatedEmbedNone\\x12\\x37\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32%.buf.validate.conformance.cases.EmbedR\\x03val\\\"f\\n\\x1dRepeatedEmbedCrossPackageNone\\x12\\x45\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x33.buf.validate.conformance.cases.other_package.EmbedR\\x03val\\\"P\\n\\x0bRepeatedMin\\x12\\x41\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32%.buf.validate.conformance.cases.EmbedB\\x08\\xbaH\\x05\\x92\\x01\\x02\\x08\\x02R\\x03val\\\")\\n\\x0bRepeatedMax\\x12\\x1a\\n\\x03val\\x18\\x01 \\x03(\\x01\\x42\\x08\\xbaH\\x05\\x92\\x01\\x02\\x10\\x03R\\x03val\\\".\\n\\x0eRepeatedMinMax\\x12\\x1c\\n\\x03val\\x18\\x01 \\x03(\\x0f\\x42\\n\\xbaH\\x07\\x92\\x01\\x04\\x08\\x02\\x10\\x04R\\x03val\\\"-\\n\\rRepeatedExact\\x12\\x1c\\n\\x03val\\x18\\x01 \\x03(\\rB\\n\\xbaH\\x07\\x92\\x01\\x04\\x08\\x03\\x10\\x03R\\x03val\\\",\\n\\x0eRepeatedUnique\\x12\\x1a\\n\\x03val\\x18\\x01 \\x03(\\tB\\x08\\xbaH\\x05\\x92\\x01\\x02\\x18\\x01R\\x03val\\\"5\\n\\x10RepeatedItemRule\\x12!\\n\\x03val\\x18\\x01 \\x03(\\x02\\x42\\x0f\\xbaH\\x0c\\x92\\x01\\t\\\"\\x07\\n\\x05%\\x00\\x00\\x00\\x00R\\x03val\\\"D\\n\\x13RepeatedItemPattern\\x12-\\n\\x03val\\x18\\x01 \\x03(\\tB\\x1b\\xbaH\\x18\\x92\\x01\\x15\\\"\\x13r\\x11\\x32\\x0f(?i)^[a-z0-9]+$R\\x03val\\\"Y\\n\\x11RepeatedEmbedSkip\\x12\\x44\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32%.buf.validate.conformance.cases.EmbedB\\x0b\\xbaH\\x08\\x92\\x01\\x05\\\"\\x03\\xc0\\x01\\x01R\\x03val\\\"8\\n\\x0eRepeatedItemIn\\x12&\\n\\x03val\\x18\\x01 \\x03(\\tB\\x14\\xbaH\\x11\\x92\\x01\\x0e\\\"\\x0cr\\nR\\x03\\x66ooR\\x03\\x62\\x61rR\\x03val\\\";\\n\\x11RepeatedItemNotIn\\x12&\\n\\x03val\\x18\\x01 \\x03(\\tB\\x14\\xbaH\\x11\\x92\\x01\\x0e\\\"\\x0cr\\nZ\\x03\\x66ooZ\\x03\\x62\\x61rR\\x03val\\\"Z\\n\\x0eRepeatedEnumIn\\x12H\\n\\x03val\\x18\\x01 \\x03(\\x0e\\x32&.buf.validate.conformance.cases.AnEnumB\\x0e\\xbaH\\x0b\\x92\\x01\\x08\\\"\\x06\\x82\\x01\\x03\\x1a\\x01\\x00R\\x03val\\\"]\\n\\x11RepeatedEnumNotIn\\x12H\\n\\x03val\\x18\\x01 \\x03(\\x0e\\x32&.buf.validate.conformance.cases.AnEnumB\\x0e\\xbaH\\x0b\\x92\\x01\\x08\\\"\\x06\\x82\\x01\\x03\\\"\\x01\\x00R\\x03val\\\"\\xe0\\x01\\n\\x16RepeatedEmbeddedEnumIn\\x12\\x66\\n\\x03val\\x18\\x01 \\x03(\\x0e\\x32\\x44.buf.validate.conformance.cases.RepeatedEmbeddedEnumIn.AnotherInEnumB\\x0e\\xbaH\\x0b\\x92\\x01\\x08\\\"\\x06\\x82\\x01\\x03\\x1a\\x01\\x00R\\x03val\\\"^\\n\\rAnotherInEnum\\x12\\x1f\\n\\x1b\\x41NOTHER_IN_ENUM_UNSPECIFIED\\x10\\x00\\x12\\x15\\n\\x11\\x41NOTHER_IN_ENUM_A\\x10\\x01\\x12\\x15\\n\\x11\\x41NOTHER_IN_ENUM_B\\x10\\x02\\\"\\xf8\\x01\\n\\x19RepeatedEmbeddedEnumNotIn\\x12l\\n\\x03val\\x18\\x01 \\x03(\\x0e\\x32J.buf.validate.conformance.cases.RepeatedEmbeddedEnumNotIn.AnotherNotInEnumB\\x0e\\xbaH\\x0b\\x92\\x01\\x08\\\"\\x06\\x82\\x01\\x03\\\"\\x01\\x00R\\x03val\\\"m\\n\\x10\\x41notherNotInEnum\\x12#\\n\\x1f\\x41NOTHER_NOT_IN_ENUM_UNSPECIFIED\\x10\\x00\\x12\\x19\\n\\x15\\x41NOTHER_NOT_IN_ENUM_A\\x10\\x01\\x12\\x19\\n\\x15\\x41NOTHER_NOT_IN_ENUM_B\\x10\\x02\\\"r\\n\\rRepeatedAnyIn\\x12\\x61\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x14.google.protobuf.AnyB9\\xbaH6\\x92\\x01\\x33\\\"1\\xa2\\x01.\\x12,type.googleapis.com/google.protobuf.DurationR\\x03val\\\"v\\n\\x10RepeatedAnyNotIn\\x12\\x62\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x14.google.protobuf.AnyB:\\xbaH7\\x92\\x01\\x34\\\"2\\xa2\\x01/\\x1a-type.googleapis.com/google.protobuf.TimestampR\\x03val\\\":\\n\\x15RepeatedMinAndItemLen\\x12!\\n\\x03val\\x18\\x01 \\x03(\\tB\\x0f\\xbaH\\x0c\\x92\\x01\\t\\x08\\x01\\\"\\x05r\\x03\\x98\\x01\\x03R\\x03val\\\"8\\n\\x18RepeatedMinAndMaxItemLen\\x12\\x1c\\n\\x03val\\x18\\x01 \\x03(\\tB\\n\\xbaH\\x07\\x92\\x01\\x04\\x08\\x01\\x10\\x03R\\x03val\\\"R\\n\\x10RepeatedDuration\\x12>\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x19.google.protobuf.DurationB\\x11\\xbaH\\x0e\\x92\\x01\\x0b\\\"\\t\\xaa\\x01\\x06\\x32\\x04\\x10\\xc0\\x84=R\\x03val\\\"6\\n\\x13RepeatedExactIgnore\\x12\\x1f\\n\\x03val\\x18\\x01 \\x03(\\rB\\r\\xbaH\\n\\x92\\x01\\x04\\x08\\x03\\x10\\x03\\xd0\\x01\\x01R\\x03val*?\\n\\x06\\x41nEnum\\x12\\x17\\n\\x13\\x41N_ENUM_UNSPECIFIED\\x10\\x00\\x12\\r\\n\\tAN_ENUM_X\\x10\\x01\\x12\\r\\n\\tAN_ENUM_Y\\x10\\x02\\x62\\x06proto3')\n_globals = globals()\n_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)", "score": 0.7911449074745178 }, { "filename": "tests/runner_test.py", "retrieved_chunk": "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nfrom google.protobuf import descriptor_pool\nfrom buf.validate.conformance.cases import oneofs_pb2 # noqa: F401\nfrom buf.validate.conformance.harness import results_pb2\nfrom tests.conformance import runner\ndef test_oneof():\n results = results_pb2.ResultSet()\n # load the results from oneof.binpb", "score": 0.78908371925354 }, { "filename": "protovalidate/internal/constraints.py", "retrieved_chunk": " if constraint := self._new_message_constraint(message_level):\n result.append(constraint)\n for oneof in desc.oneofs:\n if validate_pb2.oneof in oneof.GetOptions().Extensions:\n if constraint := OneofConstraintRules(oneof, oneof.GetOptions().Extensions[validate_pb2.oneof]):\n result.append(constraint)\n for field in desc.fields:\n if validate_pb2.field in field.GetOptions().Extensions:\n field_level = field.GetOptions().Extensions[validate_pb2.field]\n if field_level.skipped:", "score": 0.7874935269355774 } ]

[ { "filename": "tests/validate_test.py", "retrieved_chunk": "def test_oneofs():\n msg1 = oneofs_pb2.Oneof()\n msg1.y = 123\n protovalidate.validate(msg1)\n msg2 = oneofs_pb2.Oneof()\n msg2.z.val = True\n protovalidate.validate(msg2)\n violations = protovalidate.collect_violations(msg1)\n protovalidate.collect_violations(msg2, into=violations)\n assert len(violations.violations) == 0", "score": 0.8495688438415527 }, { "filename": "tests/conformance/runner.py", "retrieved_chunk": " # pool.Add(fd)\n pool = descriptor_pool.Default()\n result = harness_pb2.TestConformanceResponse()\n for name, tc in request.cases.items():\n run_any_test_case(pool, tc, result.results[name])\n return result\nif __name__ == \"__main__\":\n # Read a serialized TestConformanceRequest from stdin\n request = harness_pb2.TestConformanceRequest()\n request.ParseFromString(sys.stdin.buffer.read())", "score": 0.8018099069595337 }, { "filename": "tests/validate_test.py", "retrieved_chunk": "def test_repeated():\n msg = repeated_pb2.RepeatedEmbedSkip()\n msg.val.add(val=-1)\n protovalidate.validate(msg)\n violations = protovalidate.collect_violations(msg)\n assert len(violations.violations) == 0\ndef test_maps():\n msg = maps_pb2.MapMinMax()\n try:\n protovalidate.validate(msg)", "score": 0.7881687879562378 }, { "filename": "tests/conformance/runner.py", "retrieved_chunk": " desc: descriptor.Descriptor = pool.FindMessageTypeByName(type_name)\n # Create a message from the protobuf descriptor\n msg = message_factory.GetMessageClass(desc)()\n tc.Unpack(msg)\n return run_test_case(msg, result)\ndef run_conformance_test(\n request: harness_pb2.TestConformanceRequest,\n) -> harness_pb2.TestConformanceResponse:\n # pool = descriptor_pool.DescriptorPool()\n # for fd in request.fdset.file:", "score": 0.7856147289276123 }, { "filename": "gen/buf/validate/conformance/harness/results_pb2.py", "retrieved_chunk": "from google.protobuf.internal import builder as _builder\n# @@protoc_insertion_point(imports)\n_sym_db = _symbol_database.Default()\nfrom buf.validate.conformance.harness import harness_pb2 as buf_dot_validate_dot_conformance_dot_harness_dot_harness__pb2\nfrom google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2\nfrom google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2\nDESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\\n.buf/validate/conformance/harness/results.proto\\x12 buf.validate.conformance.harness\\x1a.buf/validate/conformance/harness/harness.proto\\x1a\\x19google/protobuf/any.proto\\x1a google/protobuf/descriptor.proto\\\"\\xcf\\x01\\n\\rResultOptions\\x12!\\n\\x0csuite_filter\\x18\\x01 \\x01(\\tR\\x0bsuiteFilter\\x12\\x1f\\n\\x0b\\x63\\x61se_filter\\x18\\x02 \\x01(\\tR\\ncaseFilter\\x12\\x18\\n\\x07verbose\\x18\\x03 \\x01(\\x08R\\x07verbose\\x12\\x16\\n\\x06strict\\x18\\x04 \\x01(\\x08R\\x06strict\\x12%\\n\\x0estrict_message\\x18\\x05 \\x01(\\x08R\\rstrictMessage\\x12!\\n\\x0cstrict_error\\x18\\x06 \\x01(\\x08R\\x0bstrictError\\\"\\x85\\x02\\n\\tResultSet\\x12\\x1c\\n\\tsuccesses\\x18\\x01 \\x01(\\x05R\\tsuccesses\\x12\\x1a\\n\\x08\\x66\\x61ilures\\x18\\x02 \\x01(\\x05R\\x08\\x66\\x61ilures\\x12\\x46\\n\\x06suites\\x18\\x03 \\x03(\\x0b\\x32..buf.validate.conformance.harness.SuiteResultsR\\x06suites\\x12I\\n\\x07options\\x18\\x04 \\x01(\\x0b\\x32/.buf.validate.conformance.harness.ResultOptionsR\\x07options\\x12+\\n\\x11\\x65xpected_failures\\x18\\x05 \\x01(\\x05R\\x10\\x65xpectedFailures\\\"\\x87\\x02\\n\\x0cSuiteResults\\x12\\x12\\n\\x04name\\x18\\x01 \\x01(\\tR\\x04name\\x12\\x1c\\n\\tsuccesses\\x18\\x02 \\x01(\\x05R\\tsuccesses\\x12\\x1a\\n\\x08\\x66\\x61ilures\\x18\\x03 \\x01(\\x05R\\x08\\x66\\x61ilures\\x12\\x42\\n\\x05\\x63\\x61ses\\x18\\x04 \\x03(\\x0b\\x32,.buf.validate.conformance.harness.CaseResultR\\x05\\x63\\x61ses\\x12\\x38\\n\\x05\\x66\\x64set\\x18\\x05 \\x01(\\x0b\\x32\\\".google.protobuf.FileDescriptorSetR\\x05\\x66\\x64set\\x12+\\n\\x11\\x65xpected_failures\\x18\\x06 \\x01(\\x05R\\x10\\x65xpectedFailures\\\"\\x97\\x02\\n\\nCaseResult\\x12\\x12\\n\\x04name\\x18\\x01 \\x01(\\tR\\x04name\\x12\\x18\\n\\x07success\\x18\\x02 \\x01(\\x08R\\x07success\\x12\\x44\\n\\x06wanted\\x18\\x03 \\x01(\\x0b\\x32,.buf.validate.conformance.harness.TestResultR\\x06wanted\\x12>\\n\\x03got\\x18\\x04 \\x01(\\x0b\\x32,.buf.validate.conformance.harness.TestResultR\\x03got\\x12*\\n\\x05input\\x18\\x05 \\x01(\\x0b\\x32\\x14.google.protobuf.AnyR\\x05input\\x12)\\n\\x10\\x65xpected_failure\\x18\\x06 \\x01(\\x08R\\x0f\\x65xpectedFailureb\\x06proto3')\n_globals = globals()\n_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)\n_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'buf.validate.conformance.harness.results_pb2', _globals)", "score": 0.7808356285095215 } ]

[ { "filename": "gen/buf/validate/conformance/cases/repeated_pb2.py", "retrieved_chunk": "_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'buf.validate.conformance.cases.repeated_pb2', _globals)\nif _descriptor._USE_C_DESCRIPTORS == False:\n DESCRIPTOR._options = None\n _EMBED.fields_by_name['val']._options = None\n _EMBED.fields_by_name['val']._serialized_options = b'\\272H\\004\\\"\\002 \\000'\n _REPEATEDMIN.fields_by_name['val']._options = None\n _REPEATEDMIN.fields_by_name['val']._serialized_options = b'\\272H\\005\\222\\001\\002\\010\\002'\n _REPEATEDMAX.fields_by_name['val']._options = None\n _REPEATEDMAX.fields_by_name['val']._serialized_options = b'\\272H\\005\\222\\001\\002\\020\\003'\n _REPEATEDMINMAX.fields_by_name['val']._options = None", "score": 0.8250262141227722 }, { "filename": "gen/buf/validate/conformance/cases/maps_pb2.py", "retrieved_chunk": "from google.protobuf.internal import builder as _builder\n# @@protoc_insertion_point(imports)\n_sym_db = _symbol_database.Default()\nfrom buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2\nDESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\\n)buf/validate/conformance/cases/maps.proto\\x12\\x1e\\x62uf.validate.conformance.cases\\x1a\\x1b\\x62uf/validate/validate.proto\\\"\\x85\\x01\\n\\x07MapNone\\x12\\x42\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x30.buf.validate.conformance.cases.MapNone.ValEntryR\\x03val\\x1a\\x36\\n\\x08ValEntry\\x12\\x10\\n\\x03key\\x18\\x01 \\x01(\\rR\\x03key\\x12\\x14\\n\\x05value\\x18\\x02 \\x01(\\x08R\\x05value:\\x02\\x38\\x01\\\"\\x8d\\x01\\n\\x06MapMin\\x12K\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32/.buf.validate.conformance.cases.MapMin.ValEntryB\\x08\\xbaH\\x05\\x9a\\x01\\x02\\x08\\x02R\\x03val\\x1a\\x36\\n\\x08ValEntry\\x12\\x10\\n\\x03key\\x18\\x01 \\x01(\\x05R\\x03key\\x12\\x14\\n\\x05value\\x18\\x02 \\x01(\\x02R\\x05value:\\x02\\x38\\x01\\\"\\x8d\\x01\\n\\x06MapMax\\x12K\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32/.buf.validate.conformance.cases.MapMax.ValEntryB\\x08\\xbaH\\x05\\x9a\\x01\\x02\\x10\\x03R\\x03val\\x1a\\x36\\n\\x08ValEntry\\x12\\x10\\n\\x03key\\x18\\x01 \\x01(\\x03R\\x03key\\x12\\x14\\n\\x05value\\x18\\x02 \\x01(\\x01R\\x05value:\\x02\\x38\\x01\\\"\\x95\\x01\\n\\tMapMinMax\\x12P\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x32.buf.validate.conformance.cases.MapMinMax.ValEntryB\\n\\xbaH\\x07\\x9a\\x01\\x04\\x08\\x02\\x10\\x04R\\x03val\\x1a\\x36\\n\\x08ValEntry\\x12\\x10\\n\\x03key\\x18\\x01 \\x01(\\tR\\x03key\\x12\\x14\\n\\x05value\\x18\\x02 \\x01(\\x08R\\x05value:\\x02\\x38\\x01\\\"\\x93\\x01\\n\\x08MapExact\\x12O\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x31.buf.validate.conformance.cases.MapExact.ValEntryB\\n\\xbaH\\x07\\x9a\\x01\\x04\\x08\\x03\\x10\\x03R\\x03val\\x1a\\x36\\n\\x08ValEntry\\x12\\x10\\n\\x03key\\x18\\x01 \\x01(\\x04R\\x03key\\x12\\x14\\n\\x05value\\x18\\x02 \\x01(\\tR\\x05value:\\x02\\x38\\x01\\\"\\x93\\x01\\n\\x07MapKeys\\x12P\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x30.buf.validate.conformance.cases.MapKeys.ValEntryB\\x0c\\xbaH\\t\\x9a\\x01\\x06\\\"\\x04\\x42\\x02\\x10\\x00R\\x03val\\x1a\\x36\\n\\x08ValEntry\\x12\\x10\\n\\x03key\\x18\\x01 \\x01(\\x12R\\x03key\\x12\\x14\\n\\x05value\\x18\\x02 \\x01(\\tR\\x05value:\\x02\\x38\\x01\\\"\\x97\\x01\\n\\tMapValues\\x12R\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x32.buf.validate.conformance.cases.MapValues.ValEntryB\\x0c\\xbaH\\t\\x9a\\x01\\x06*\\x04r\\x02\\x10\\x03R\\x03val\\x1a\\x36\\n\\x08ValEntry\\x12\\x10\\n\\x03key\\x18\\x01 \\x01(\\tR\\x03key\\x12\\x14\\n\\x05value\\x18\\x02 \\x01(\\tR\\x05value:\\x02\\x38\\x01\\\"\\xb0\\x01\\n\\x0eMapKeysPattern\\x12\\x66\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x37.buf.validate.conformance.cases.MapKeysPattern.ValEntryB\\x1b\\xbaH\\x18\\x9a\\x01\\x15\\\"\\x13r\\x11\\x32\\x0f(?i)^[a-z0-9]+$R\\x03val\\x1a\\x36\\n\\x08ValEntry\\x12\\x10\\n\\x03key\\x18\\x01 \\x01(\\tR\\x03key\\x12\\x14\\n\\x05value\\x18\\x02 \\x01(\\tR\\x05value:\\x02\\x38\\x01\\\"\\xb4\\x01\\n\\x10MapValuesPattern\\x12h\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x39.buf.validate.conformance.cases.MapValuesPattern.ValEntryB\\x1b\\xbaH\\x18\\x9a\\x01\\x15*\\x13r\\x11\\x32\\x0f(?i)^[a-z0-9]+$R\\x03val\\x1a\\x36\\n\\x08ValEntry\\x12\\x10\\n\\x03key\\x18\\x01 \\x01(\\tR\\x03key\\x12\\x14\\n\\x05value\\x18\\x02 \\x01(\\tR\\x05value:\\x02\\x38\\x01\\\"\\xe3\\x01\\n\\x0cMapRecursive\\x12G\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x35.buf.validate.conformance.cases.MapRecursive.ValEntryR\\x03val\\x1ah\\n\\x08ValEntry\\x12\\x10\\n\\x03key\\x18\\x01 \\x01(\\rR\\x03key\\x12\\x46\\n\\x05value\\x18\\x02 \\x01(\\x0b\\x32\\x30.buf.validate.conformance.cases.MapRecursive.MsgR\\x05value:\\x02\\x38\\x01\\x1a \\n\\x03Msg\\x12\\x19\\n\\x03val\\x18\\x01 \\x01(\\tB\\x07\\xbaH\\x04r\\x02\\x10\\x03R\\x03val\\\"\\xa2\\x01\\n\\x0eMapExactIgnore\\x12X\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x37.buf.validate.conformance.cases.MapExactIgnore.ValEntryB\\r\\xbaH\\n\\x9a\\x01\\x04\\x08\\x03\\x10\\x03\\xd0\\x01\\x01R\\x03val\\x1a\\x36\\n\\x08ValEntry\\x12\\x10\\n\\x03key\\x18\\x01 \\x01(\\x04R\\x03key\\x12\\x14\\n\\x05value\\x18\\x02 \\x01(\\tR\\x05value:\\x02\\x38\\x01\\\"\\xd7\\x03\\n\\x0cMultipleMaps\\x12[\\n\\x05\\x66irst\\x18\\x01 \\x03(\\x0b\\x32\\x37.buf.validate.conformance.cases.MultipleMaps.FirstEntryB\\x0c\\xbaH\\t\\x9a\\x01\\x06\\\"\\x04*\\x02 \\x00R\\x05\\x66irst\\x12^\\n\\x06second\\x18\\x02 \\x03(\\x0b\\x32\\x38.buf.validate.conformance.cases.MultipleMaps.SecondEntryB\\x0c\\xbaH\\t\\x9a\\x01\\x06\\\"\\x04\\x1a\\x02\\x10\\x00R\\x06second\\x12[\\n\\x05third\\x18\\x03 \\x03(\\x0b\\x32\\x37.buf.validate.conformance.cases.MultipleMaps.ThirdEntryB\\x0c\\xbaH\\t\\x9a\\x01\\x06\\\"\\x04\\x1a\\x02 \\x00R\\x05third\\x1a\\x38\\n\\nFirstEntry\\x12\\x10\\n\\x03key\\x18\\x01 \\x01(\\rR\\x03key\\x12\\x14\\n\\x05value\\x18\\x02 \\x01(\\tR\\x05value:\\x02\\x38\\x01\\x1a\\x39\\n\\x0bSecondEntry\\x12\\x10\\n\\x03key\\x18\\x01 \\x01(\\x05R\\x03key\\x12\\x14\\n\\x05value\\x18\\x02 \\x01(\\x08R\\x05value:\\x02\\x38\\x01\\x1a\\x38\\n\\nThirdEntry\\x12\\x10\\n\\x03key\\x18\\x01 \\x01(\\x05R\\x03key\\x12\\x14\\n\\x05value\\x18\\x02 \\x01(\\x08R\\x05value:\\x02\\x38\\x01\\x62\\x06proto3')\n_globals = globals()\n_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)\n_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'buf.validate.conformance.cases.maps_pb2', _globals)\nif _descriptor._USE_C_DESCRIPTORS == False:\n DESCRIPTOR._options = None", "score": 0.8090821504592896 }, { "filename": "gen/buf/validate/conformance/cases/repeated_pb2.py", "retrieved_chunk": "from google.protobuf.internal import builder as _builder\n# @@protoc_insertion_point(imports)\n_sym_db = _symbol_database.Default()\nfrom buf.validate.conformance.cases.other_package import embed_pb2 as buf_dot_validate_dot_conformance_dot_cases_dot_other__package_dot_embed__pb2\nfrom buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2\nfrom google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2\nfrom google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2\nDESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\\n-buf/validate/conformance/cases/repeated.proto\\x12\\x1e\\x62uf.validate.conformance.cases\\x1a\\x38\\x62uf/validate/conformance/cases/other_package/embed.proto\\x1a\\x1b\\x62uf/validate/validate.proto\\x1a\\x19google/protobuf/any.proto\\x1a\\x1egoogle/protobuf/duration.proto\\\"\\\"\\n\\x05\\x45mbed\\x12\\x19\\n\\x03val\\x18\\x01 \\x01(\\x03\\x42\\x07\\xbaH\\x04\\\"\\x02 \\x00R\\x03val\\\" \\n\\x0cRepeatedNone\\x12\\x10\\n\\x03val\\x18\\x01 \\x03(\\x03R\\x03val\\\"L\\n\\x11RepeatedEmbedNone\\x12\\x37\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32%.buf.validate.conformance.cases.EmbedR\\x03val\\\"f\\n\\x1dRepeatedEmbedCrossPackageNone\\x12\\x45\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x33.buf.validate.conformance.cases.other_package.EmbedR\\x03val\\\"P\\n\\x0bRepeatedMin\\x12\\x41\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32%.buf.validate.conformance.cases.EmbedB\\x08\\xbaH\\x05\\x92\\x01\\x02\\x08\\x02R\\x03val\\\")\\n\\x0bRepeatedMax\\x12\\x1a\\n\\x03val\\x18\\x01 \\x03(\\x01\\x42\\x08\\xbaH\\x05\\x92\\x01\\x02\\x10\\x03R\\x03val\\\".\\n\\x0eRepeatedMinMax\\x12\\x1c\\n\\x03val\\x18\\x01 \\x03(\\x0f\\x42\\n\\xbaH\\x07\\x92\\x01\\x04\\x08\\x02\\x10\\x04R\\x03val\\\"-\\n\\rRepeatedExact\\x12\\x1c\\n\\x03val\\x18\\x01 \\x03(\\rB\\n\\xbaH\\x07\\x92\\x01\\x04\\x08\\x03\\x10\\x03R\\x03val\\\",\\n\\x0eRepeatedUnique\\x12\\x1a\\n\\x03val\\x18\\x01 \\x03(\\tB\\x08\\xbaH\\x05\\x92\\x01\\x02\\x18\\x01R\\x03val\\\"5\\n\\x10RepeatedItemRule\\x12!\\n\\x03val\\x18\\x01 \\x03(\\x02\\x42\\x0f\\xbaH\\x0c\\x92\\x01\\t\\\"\\x07\\n\\x05%\\x00\\x00\\x00\\x00R\\x03val\\\"D\\n\\x13RepeatedItemPattern\\x12-\\n\\x03val\\x18\\x01 \\x03(\\tB\\x1b\\xbaH\\x18\\x92\\x01\\x15\\\"\\x13r\\x11\\x32\\x0f(?i)^[a-z0-9]+$R\\x03val\\\"Y\\n\\x11RepeatedEmbedSkip\\x12\\x44\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32%.buf.validate.conformance.cases.EmbedB\\x0b\\xbaH\\x08\\x92\\x01\\x05\\\"\\x03\\xc0\\x01\\x01R\\x03val\\\"8\\n\\x0eRepeatedItemIn\\x12&\\n\\x03val\\x18\\x01 \\x03(\\tB\\x14\\xbaH\\x11\\x92\\x01\\x0e\\\"\\x0cr\\nR\\x03\\x66ooR\\x03\\x62\\x61rR\\x03val\\\";\\n\\x11RepeatedItemNotIn\\x12&\\n\\x03val\\x18\\x01 \\x03(\\tB\\x14\\xbaH\\x11\\x92\\x01\\x0e\\\"\\x0cr\\nZ\\x03\\x66ooZ\\x03\\x62\\x61rR\\x03val\\\"Z\\n\\x0eRepeatedEnumIn\\x12H\\n\\x03val\\x18\\x01 \\x03(\\x0e\\x32&.buf.validate.conformance.cases.AnEnumB\\x0e\\xbaH\\x0b\\x92\\x01\\x08\\\"\\x06\\x82\\x01\\x03\\x1a\\x01\\x00R\\x03val\\\"]\\n\\x11RepeatedEnumNotIn\\x12H\\n\\x03val\\x18\\x01 \\x03(\\x0e\\x32&.buf.validate.conformance.cases.AnEnumB\\x0e\\xbaH\\x0b\\x92\\x01\\x08\\\"\\x06\\x82\\x01\\x03\\\"\\x01\\x00R\\x03val\\\"\\xe0\\x01\\n\\x16RepeatedEmbeddedEnumIn\\x12\\x66\\n\\x03val\\x18\\x01 \\x03(\\x0e\\x32\\x44.buf.validate.conformance.cases.RepeatedEmbeddedEnumIn.AnotherInEnumB\\x0e\\xbaH\\x0b\\x92\\x01\\x08\\\"\\x06\\x82\\x01\\x03\\x1a\\x01\\x00R\\x03val\\\"^\\n\\rAnotherInEnum\\x12\\x1f\\n\\x1b\\x41NOTHER_IN_ENUM_UNSPECIFIED\\x10\\x00\\x12\\x15\\n\\x11\\x41NOTHER_IN_ENUM_A\\x10\\x01\\x12\\x15\\n\\x11\\x41NOTHER_IN_ENUM_B\\x10\\x02\\\"\\xf8\\x01\\n\\x19RepeatedEmbeddedEnumNotIn\\x12l\\n\\x03val\\x18\\x01 \\x03(\\x0e\\x32J.buf.validate.conformance.cases.RepeatedEmbeddedEnumNotIn.AnotherNotInEnumB\\x0e\\xbaH\\x0b\\x92\\x01\\x08\\\"\\x06\\x82\\x01\\x03\\\"\\x01\\x00R\\x03val\\\"m\\n\\x10\\x41notherNotInEnum\\x12#\\n\\x1f\\x41NOTHER_NOT_IN_ENUM_UNSPECIFIED\\x10\\x00\\x12\\x19\\n\\x15\\x41NOTHER_NOT_IN_ENUM_A\\x10\\x01\\x12\\x19\\n\\x15\\x41NOTHER_NOT_IN_ENUM_B\\x10\\x02\\\"r\\n\\rRepeatedAnyIn\\x12\\x61\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x14.google.protobuf.AnyB9\\xbaH6\\x92\\x01\\x33\\\"1\\xa2\\x01.\\x12,type.googleapis.com/google.protobuf.DurationR\\x03val\\\"v\\n\\x10RepeatedAnyNotIn\\x12\\x62\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x14.google.protobuf.AnyB:\\xbaH7\\x92\\x01\\x34\\\"2\\xa2\\x01/\\x1a-type.googleapis.com/google.protobuf.TimestampR\\x03val\\\":\\n\\x15RepeatedMinAndItemLen\\x12!\\n\\x03val\\x18\\x01 \\x03(\\tB\\x0f\\xbaH\\x0c\\x92\\x01\\t\\x08\\x01\\\"\\x05r\\x03\\x98\\x01\\x03R\\x03val\\\"8\\n\\x18RepeatedMinAndMaxItemLen\\x12\\x1c\\n\\x03val\\x18\\x01 \\x03(\\tB\\n\\xbaH\\x07\\x92\\x01\\x04\\x08\\x01\\x10\\x03R\\x03val\\\"R\\n\\x10RepeatedDuration\\x12>\\n\\x03val\\x18\\x01 \\x03(\\x0b\\x32\\x19.google.protobuf.DurationB\\x11\\xbaH\\x0e\\x92\\x01\\x0b\\\"\\t\\xaa\\x01\\x06\\x32\\x04\\x10\\xc0\\x84=R\\x03val\\\"6\\n\\x13RepeatedExactIgnore\\x12\\x1f\\n\\x03val\\x18\\x01 \\x03(\\rB\\r\\xbaH\\n\\x92\\x01\\x04\\x08\\x03\\x10\\x03\\xd0\\x01\\x01R\\x03val*?\\n\\x06\\x41nEnum\\x12\\x17\\n\\x13\\x41N_ENUM_UNSPECIFIED\\x10\\x00\\x12\\r\\n\\tAN_ENUM_X\\x10\\x01\\x12\\r\\n\\tAN_ENUM_Y\\x10\\x02\\x62\\x06proto3')\n_globals = globals()\n_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)", "score": 0.8087406158447266 }, { "filename": "gen/buf/validate/conformance/cases/messages_pb2.py", "retrieved_chunk": "from google.protobuf.internal import builder as _builder\n# @@protoc_insertion_point(imports)\n_sym_db = _symbol_database.Default()\nfrom buf.validate.conformance.cases.other_package import embed_pb2 as buf_dot_validate_dot_conformance_dot_cases_dot_other__package_dot_embed__pb2\nfrom buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2\nDESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\\n-buf/validate/conformance/cases/messages.proto\\x12\\x1e\\x62uf.validate.conformance.cases\\x1a\\x38\\x62uf/validate/conformance/cases/other_package/embed.proto\\x1a\\x1b\\x62uf/validate/validate.proto\\\"l\\n\\x07TestMsg\\x12 \\n\\x05\\x63onst\\x18\\x01 \\x01(\\tB\\n\\xbaH\\x07r\\x05\\n\\x03\\x66ooR\\x05\\x63onst\\x12?\\n\\x06nested\\x18\\x02 \\x01(\\x0b\\x32\\'.buf.validate.conformance.cases.TestMsgR\\x06nested\\\"_\\n\\x0bMessageNone\\x12\\x45\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x33.buf.validate.conformance.cases.MessageNone.NoneMsgR\\x03val\\x1a\\t\\n\\x07NoneMsg\\\"3\\n\\x0fMessageDisabled\\x12\\x19\\n\\x03val\\x18\\x01 \\x01(\\x04\\x42\\x07\\xbaH\\x04\\x32\\x02 {R\\x03val:\\x05\\xbaH\\x02\\x08\\x01\\\"D\\n\\x07Message\\x12\\x39\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\'.buf.validate.conformance.cases.TestMsgR\\x03val\\\"\\\\\\n\\x13MessageCrossPackage\\x12\\x45\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\x33.buf.validate.conformance.cases.other_package.EmbedR\\x03val\\\"P\\n\\x0bMessageSkip\\x12\\x41\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\'.buf.validate.conformance.cases.TestMsgB\\x06\\xbaH\\x03\\xc0\\x01\\x01R\\x03val\\\"T\\n\\x0fMessageRequired\\x12\\x41\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\'.buf.validate.conformance.cases.TestMsgB\\x06\\xbaH\\x03\\xc8\\x01\\x01R\\x03val\\\"l\\n\\x1aMessageRequiredButOptional\\x12\\x46\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\'.buf.validate.conformance.cases.TestMsgB\\x06\\xbaH\\x03\\xc8\\x01\\x01H\\x00R\\x03val\\x88\\x01\\x01\\x42\\x06\\n\\x04_val\\\"i\\n\\x14MessageRequiredOneof\\x12\\x43\\n\\x03val\\x18\\x01 \\x01(\\x0b\\x32\\'.buf.validate.conformance.cases.TestMsgB\\x06\\xbaH\\x03\\xc8\\x01\\x01H\\x00R\\x03valB\\x0c\\n\\x03one\\x12\\x05\\xbaH\\x02\\x08\\x01\\\"\\x15\\n\\x13MessageWith3dInsideb\\x06proto3')\n_globals = globals()\n_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)\n_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'buf.validate.conformance.cases.messages_pb2', _globals)\nif _descriptor._USE_C_DESCRIPTORS == False:", "score": 0.8044332265853882 }, { "filename": "gen/buf/validate/conformance/cases/repeated_pb2.py", "retrieved_chunk": " _REPEATEDEMBEDDEDENUMIN.fields_by_name['val']._serialized_options = b'\\272H\\013\\222\\001\\010\\\"\\006\\202\\001\\003\\032\\001\\000'\n _REPEATEDEMBEDDEDENUMNOTIN.fields_by_name['val']._options = None\n _REPEATEDEMBEDDEDENUMNOTIN.fields_by_name['val']._serialized_options = b'\\272H\\013\\222\\001\\010\\\"\\006\\202\\001\\003\\\"\\001\\000'\n _REPEATEDANYIN.fields_by_name['val']._options = None\n _REPEATEDANYIN.fields_by_name['val']._serialized_options = b'\\272H6\\222\\0013\\\"1\\242\\001.\\022,type.googleapis.com/google.protobuf.Duration'\n _REPEATEDANYNOTIN.fields_by_name['val']._options = None\n _REPEATEDANYNOTIN.fields_by_name['val']._serialized_options = b'\\272H7\\222\\0014\\\"2\\242\\001/\\032-type.googleapis.com/google.protobuf.Timestamp'\n _REPEATEDMINANDITEMLEN.fields_by_name['val']._options = None\n _REPEATEDMINANDITEMLEN.fields_by_name['val']._serialized_options = b'\\272H\\014\\222\\001\\t\\010\\001\\\"\\005r\\003\\230\\001\\003'\n _REPEATEDMINANDMAXITEMLEN.fields_by_name['val']._options = None", "score": 0.8007831573486328 } ]

[ { "filename": "tests/conformance/runner.py", "retrieved_chunk": " desc: descriptor.Descriptor = pool.FindMessageTypeByName(type_name)\n # Create a message from the protobuf descriptor\n msg = message_factory.GetMessageClass(desc)()\n tc.Unpack(msg)\n return run_test_case(msg, result)\ndef run_conformance_test(\n request: harness_pb2.TestConformanceRequest,\n) -> harness_pb2.TestConformanceResponse:\n # pool = descriptor_pool.DescriptorPool()\n # for fd in request.fdset.file:", "score": 0.8358573317527771 }, { "filename": "gen/buf/validate/conformance/cases/oneofs_pb2.py", "retrieved_chunk": "from google.protobuf.internal import builder as _builder\n# @@protoc_insertion_point(imports)\n_sym_db = _symbol_database.Default()\nfrom buf.validate import validate_pb2 as buf_dot_validate_dot_validate__pb2\nDESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\\n+buf/validate/conformance/cases/oneofs.proto\\x12\\x1e\\x62uf.validate.conformance.cases\\x1a\\x1b\\x62uf/validate/validate.proto\\\")\\n\\x0cTestOneofMsg\\x12\\x19\\n\\x03val\\x18\\x01 \\x01(\\x08\\x42\\x07\\xbaH\\x04j\\x02\\x08\\x01R\\x03val\\\"0\\n\\tOneofNone\\x12\\x0e\\n\\x01x\\x18\\x01 \\x01(\\tH\\x00R\\x01x\\x12\\x0e\\n\\x01y\\x18\\x02 \\x01(\\x05H\\x00R\\x01yB\\x03\\n\\x01o\\\"\\x7f\\n\\x05Oneof\\x12\\x1a\\n\\x01x\\x18\\x01 \\x01(\\tB\\n\\xbaH\\x07r\\x05:\\x03\\x66ooH\\x00R\\x01x\\x12\\x17\\n\\x01y\\x18\\x02 \\x01(\\x05\\x42\\x07\\xbaH\\x04\\x1a\\x02 \\x00H\\x00R\\x01y\\x12<\\n\\x01z\\x18\\x03 \\x01(\\x0b\\x32,.buf.validate.conformance.cases.TestOneofMsgH\\x00R\\x01zB\\x03\\n\\x01o\\\"\\xa0\\x01\\n\\rOneofRequired\\x12\\x0e\\n\\x01x\\x18\\x01 \\x01(\\tH\\x00R\\x01x\\x12\\x0e\\n\\x01y\\x18\\x02 \\x01(\\x05H\\x00R\\x01y\\x12\\x34\\n\\x15name_with_underscores\\x18\\x03 \\x01(\\x05H\\x00R\\x13nameWithUnderscores\\x12-\\n\\x12under_and_1_number\\x18\\x04 \\x01(\\x05H\\x00R\\x0funderAnd1NumberB\\n\\n\\x01o\\x12\\x05\\xbaH\\x02\\x08\\x01\\\"s\\n\\x10OneofIgnoreEmpty\\x12\\x1c\\n\\x01x\\x18\\x01 \\x01(\\tB\\x0c\\xbaH\\tr\\x04\\x10\\x03\\x18\\x05\\xd0\\x01\\x01H\\x00R\\x01x\\x12\\x1c\\n\\x01y\\x18\\x02 \\x01(\\x0c\\x42\\x0c\\xbaH\\tz\\x04\\x10\\x03\\x18\\x05\\xd0\\x01\\x01H\\x00R\\x01y\\x12\\x1e\\n\\x01z\\x18\\x03 \\x01(\\x05\\x42\\x0e\\xbaH\\x0b\\x1a\\x06\\x18\\x80\\x01(\\x80\\x02\\xd0\\x01\\x01H\\x00R\\x01zB\\x03\\n\\x01ob\\x06proto3')\n_globals = globals()\n_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)\n_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'buf.validate.conformance.cases.oneofs_pb2', _globals)\nif _descriptor._USE_C_DESCRIPTORS == False:\n DESCRIPTOR._options = None", "score": 0.8342130184173584 }, { "filename": "gen/buf/validate/conformance/harness/results_pb2.py", "retrieved_chunk": "from google.protobuf.internal import builder as _builder\n# @@protoc_insertion_point(imports)\n_sym_db = _symbol_database.Default()\nfrom buf.validate.conformance.harness import harness_pb2 as buf_dot_validate_dot_conformance_dot_harness_dot_harness__pb2\nfrom google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2\nfrom google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2\nDESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\\n.buf/validate/conformance/harness/results.proto\\x12 buf.validate.conformance.harness\\x1a.buf/validate/conformance/harness/harness.proto\\x1a\\x19google/protobuf/any.proto\\x1a google/protobuf/descriptor.proto\\\"\\xcf\\x01\\n\\rResultOptions\\x12!\\n\\x0csuite_filter\\x18\\x01 \\x01(\\tR\\x0bsuiteFilter\\x12\\x1f\\n\\x0b\\x63\\x61se_filter\\x18\\x02 \\x01(\\tR\\ncaseFilter\\x12\\x18\\n\\x07verbose\\x18\\x03 \\x01(\\x08R\\x07verbose\\x12\\x16\\n\\x06strict\\x18\\x04 \\x01(\\x08R\\x06strict\\x12%\\n\\x0estrict_message\\x18\\x05 \\x01(\\x08R\\rstrictMessage\\x12!\\n\\x0cstrict_error\\x18\\x06 \\x01(\\x08R\\x0bstrictError\\\"\\x85\\x02\\n\\tResultSet\\x12\\x1c\\n\\tsuccesses\\x18\\x01 \\x01(\\x05R\\tsuccesses\\x12\\x1a\\n\\x08\\x66\\x61ilures\\x18\\x02 \\x01(\\x05R\\x08\\x66\\x61ilures\\x12\\x46\\n\\x06suites\\x18\\x03 \\x03(\\x0b\\x32..buf.validate.conformance.harness.SuiteResultsR\\x06suites\\x12I\\n\\x07options\\x18\\x04 \\x01(\\x0b\\x32/.buf.validate.conformance.harness.ResultOptionsR\\x07options\\x12+\\n\\x11\\x65xpected_failures\\x18\\x05 \\x01(\\x05R\\x10\\x65xpectedFailures\\\"\\x87\\x02\\n\\x0cSuiteResults\\x12\\x12\\n\\x04name\\x18\\x01 \\x01(\\tR\\x04name\\x12\\x1c\\n\\tsuccesses\\x18\\x02 \\x01(\\x05R\\tsuccesses\\x12\\x1a\\n\\x08\\x66\\x61ilures\\x18\\x03 \\x01(\\x05R\\x08\\x66\\x61ilures\\x12\\x42\\n\\x05\\x63\\x61ses\\x18\\x04 \\x03(\\x0b\\x32,.buf.validate.conformance.harness.CaseResultR\\x05\\x63\\x61ses\\x12\\x38\\n\\x05\\x66\\x64set\\x18\\x05 \\x01(\\x0b\\x32\\\".google.protobuf.FileDescriptorSetR\\x05\\x66\\x64set\\x12+\\n\\x11\\x65xpected_failures\\x18\\x06 \\x01(\\x05R\\x10\\x65xpectedFailures\\\"\\x97\\x02\\n\\nCaseResult\\x12\\x12\\n\\x04name\\x18\\x01 \\x01(\\tR\\x04name\\x12\\x18\\n\\x07success\\x18\\x02 \\x01(\\x08R\\x07success\\x12\\x44\\n\\x06wanted\\x18\\x03 \\x01(\\x0b\\x32,.buf.validate.conformance.harness.TestResultR\\x06wanted\\x12>\\n\\x03got\\x18\\x04 \\x01(\\x0b\\x32,.buf.validate.conformance.harness.TestResultR\\x03got\\x12*\\n\\x05input\\x18\\x05 \\x01(\\x0b\\x32\\x14.google.protobuf.AnyR\\x05input\\x12)\\n\\x10\\x65xpected_failure\\x18\\x06 \\x01(\\x08R\\x0f\\x65xpectedFailureb\\x06proto3')\n_globals = globals()\n_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)\n_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'buf.validate.conformance.harness.results_pb2', _globals)", "score": 0.8294703364372253 }, { "filename": "tests/conformance/runner.py", "retrieved_chunk": " # pool.Add(fd)\n pool = descriptor_pool.Default()\n result = harness_pb2.TestConformanceResponse()\n for name, tc in request.cases.items():\n run_any_test_case(pool, tc, result.results[name])\n return result\nif __name__ == \"__main__\":\n # Read a serialized TestConformanceRequest from stdin\n request = harness_pb2.TestConformanceRequest()\n request.ParseFromString(sys.stdin.buffer.read())", "score": 0.8261464834213257 }, { "filename": "tests/conformance/runner.py", "retrieved_chunk": "# segfaults when using a dynamic descriptor pool.\nfrom buf.validate.conformance.cases import (\n bool_pb2, # noqa: F401\n bytes_pb2, # noqa: F401\n enums_pb2, # noqa: F401\n filename_with_dash_pb2, # noqa: F401\n kitchen_sink_pb2, # noqa: F401\n maps_pb2, # noqa: F401\n messages_pb2, # noqa: F401\n numbers_pb2, # noqa: F401", "score": 0.8201606869697571 } ]

[ { "filename": "src/dpapi_ng/_client.py", "retrieved_chunk": " https://learn.microsoft.com/en-us/windows/win32/api/ncryptprotect/nf-ncryptprotect-ncryptunprotectsecret\n \"\"\"\n blob = DPAPINGBlob.unpack(data)\n target_sd = blob.protection_descriptor.get_target_sd()\n cache = cache or KeyCache()\n rk = cache._get_key(\n target_sd,\n blob.key_identifier.root_key_identifier,\n blob.key_identifier.l0,\n blob.key_identifier.l1,", "score": 0.8242668509483337 }, { "filename": "src/dpapi_ng/_client.py", "retrieved_chunk": " Encrypts the blob provided as DPAPI-NG Blob. This is meant to\n replicate the Win32 API `NCryptProtectSecret`_. While NCryptProtectSecret\n supports multiple protection descriptor values, currently only the SID type\n is supported.\n Encrypting the DPAPI-NG blob requires making an RPC call to the domain\n controller for the domain the blob was created in. It will attempt this\n by looking up the DC through an SRV lookup but ``server`` can be specified\n to avoid this SRV lookup.\n The RPC call requires the caller to authenticate before the key information\n is provided. Explicit credentials can be specified, if none are then the", "score": 0.810679018497467 }, { "filename": "tests/test_client.py", "retrieved_chunk": " \"kdf_sha384_ecdh_p384\",\n \"kdf_sha512_ecdh_p384\",\n ],\n)\nasync def test_async_unprotect_secret(\n scenario: str,\n) -> None:\n expected = b\"\\x00\"\n data, key_cache = _load_root_key(scenario)\n actual = await dpapi_ng.async_ncrypt_unprotect_secret(data, cache=key_cache)", "score": 0.8085006475448608 }, { "filename": "tests/test_client.py", "retrieved_chunk": " \"kdf_sha512_nonce\",\n ],\n)\nasync def test_async_protect_secret(scenario: str) -> None:\n test_data = b\"schorschii\"\n test_protection_descriptor = \"S-1-5-21-2185496602-3367037166-1388177638-1103\"\n key_cache = _load_root_key(scenario)[1]\n test_root_key_identifier = list(key_cache._root_keys.keys())[0]\n encrypted = await dpapi_ng.async_ncrypt_protect_secret(\n test_data,", "score": 0.8031477928161621 }, { "filename": "tests/test_client.py", "retrieved_chunk": " test_protection_descriptor,\n root_key_identifier=test_root_key_identifier,\n cache=key_cache,\n )\n decrypted = await dpapi_ng.async_ncrypt_unprotect_secret(encrypted, cache=key_cache)\n assert test_data == decrypted\[email protected](\n \"kdf_algo, secret_algo\",\n [\n (\"SHA1\", \"DH\"),", "score": 0.7983425259590149 } ]

[ { "filename": "src/stl_mob/envs/mujoco_robots/robots/world.py", "retrieved_chunk": " self.geom_names = [\n n for n in self.sim.model.geom_names if n != 'floor']\n # Needed to figure out the observation spaces\n self.nq = self.sim.model.nq\n self.nv = self.sim.model.nv\n # Needed to figure out action space\n self.nu = self.sim.model.nu\n # Needed to figure out observation space\n # See engine.py for an explanation for why we treat these separately\n self.hinge_pos_names = []", "score": 0.8241881132125854 }, { "filename": "src/stl_mob/envs/wrapper.py", "retrieved_chunk": " BASE_SENSORS = ['accelerometer', 'velocimeter', 'gyro', 'magnetometer']\n def __init__(self, task: TaskBase, enable_gui: bool = True):\n super().__init__(task, enable_gui)\n for wp in self.task.wp_list:\n self.add_wp_marker(wp.pos, wp.size)\n def get_obs_config(self) -> dict:\n config = {\n 'walls_num': len(self.task.task_map.obs_list),\n 'walls_locations': [obs.pos for obs in self.task.task_map.obs_list],\n 'walls_size': [obs.size for obs in self.task.task_map.obs_list],", "score": 0.808996319770813 }, { "filename": "src/stl_mob/envs/wrapper.py", "retrieved_chunk": " 'sensors_obs': self.BASE_SENSORS + extra_sensor,\n 'observe_com': False,\n 'observe_goal_comp': True\n }\n def set_pos(self, pos: Union[List, np.ndarray]):\n indx = self.gym_env.sim.model.get_joint_qpos_addr(\"robot\")\n sim_state = self.gym_env.sim.get_state()\n sim_state.qpos[indx[0]:indx[0] + 2] = pos\n self.gym_env.sim.set_state(sim_state)\n self.gym_env.sim.forward()", "score": 0.8075079321861267 }, { "filename": "src/stl_mob/envs/wrapper.py", "retrieved_chunk": " def get_obs(self) -> np.ndarray:\n pass\ndef get_env(robot_name: str, task: TaskBase, enable_gui: bool = True):\n if robot_name == \"drone\":\n return DroneEnv(task, enable_gui)\n elif robot_name == \"point\":\n return PointEnv(task, enable_gui)\n elif robot_name == \"car\":\n return CarEnv(task, enable_gui)\n elif robot_name == \"doggo\":", "score": 0.806755781173706 }, { "filename": "src/stl_mob/envs/wrapper.py", "retrieved_chunk": " def _set_goal(self, goal: Union[List, np.ndarray]):\n self.gym_env.set_goal_position(goal_xy=goal[:2])\n def get_pos(self) -> np.ndarray:\n return np.array(self.gym_env.robot_pos[:2])\n def get_obs(self) -> np.ndarray:\n return self.gym_env.obs()\nclass PointEnv(MujocoEnv):\n def get_robot_config(self) -> dict:\n return {\n \"robot_base\": f\"xmls/point.xml\",", "score": 0.8064114451408386 } ]

[ { "filename": "src/dpapi_ng/_crypto.py", "retrieved_chunk": "def content_encrypt(\n algorithm: str,\n parameters: t.Optional[bytes],\n cek: bytes,\n value: bytes,\n) -> bytes:\n if algorithm == AlgorithmOID.AES256_GCM:\n if not parameters:\n raise ValueError(\"Expecting parameters for AES256 GCM encryption but received none.\")\n reader = ASN1Reader(parameters).read_sequence()", "score": 0.849990725517273 }, { "filename": "tests/test_gkdi.py", "retrieved_chunk": " msg = gkdi.KDFParameters(name)\n assert isinstance(msg.hash_algorithm, expected)\ndef test_kdf_parameters_invalid_hash() -> None:\n with pytest.raises(NotImplementedError, match=\"Unsupported hash algorithm MD5\"):\n gkdi.KDFParameters(\"MD5\").hash_algorithm\ndef test_kdf_parameters_invalid_magic() -> None:\n data = b\"\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\xff\\xff\\xff\\xff\\x00\\x00\\x00\\x01\"\n with pytest.raises(ValueError, match=\"Failed to unpack KDFParameters as magic identifier is invalid\"):\n gkdi.KDFParameters.unpack(data)\ndef test_ffc_dh_parameters_pack() -> None:", "score": 0.8262444734573364 }, { "filename": "tests/test_gkdi.py", "retrieved_chunk": "def test_group_key_envelope_invalid_magic() -> None:\n data = b\"\\x00\\x00\\x00\\x00\"\n with pytest.raises(ValueError, match=\"Failed to unpack GroupKeyEnvelope as magic identifier is invalid\"):\n gkdi.GroupKeyEnvelope.unpack(data)\ndef test_group_key_envelope_get_kek_is_public() -> None:\n envelope = gkdi.GroupKeyEnvelope(\n version=1,\n flags=1,\n l0=0,\n l1=0,", "score": 0.8186497688293457 }, { "filename": "src/dpapi_ng/_crypto.py", "retrieved_chunk": ") -> bytes:\n if algorithm == AlgorithmOID.AES256_GCM:\n if not parameters:\n raise ValueError(\"Expecting parameters for AES256 GCM decryption but received none.\")\n reader = ASN1Reader(parameters).read_sequence()\n iv = reader.read_octet_string()\n cipher = AESGCM(cek)\n return cipher.decrypt(iv, value, None)\n else:\n raise NotImplementedError(f\"Unknown content encryption algorithm OID '{algorithm}'\")", "score": 0.799071192741394 }, { "filename": "tests/test_gkdi.py", "retrieved_chunk": " )\n assert actual == expected\ndef test_compute_kek_invalid_algorithm() -> None:\n with pytest.raises(NotImplementedError, match=\"Unknown secret agreement algorithm 'test'\"):\n gkdi.compute_kek_from_public_key(hashes.SHA256(), b\"\", \"test\", None, b\"\", 0)", "score": 0.7948977947235107 } ]

[ { "filename": "src/stl_mob/envs/mujoco_robots/robots/world.py", "retrieved_chunk": " def __init__(self, config={}, render_context=None):\n ''' config - JSON string or dict of configuration. See self.parse() '''\n self.parse(config) # Parse configuration\n self.first_reset = True\n self.viewer = None\n self.render_context = render_context\n self.update_viewer_sim = False\n self.robot = Robot(self.robot_base)\n def parse(self, config):\n ''' Parse a config dict - see self.DEFAULT for description '''", "score": 0.8270267248153687 }, { "filename": "src/stl_mob/evaluate/plan_and_ctrl_time.py", "retrieved_chunk": " self.space_dims = {\n \"point\": 2,\n \"car\": 2,\n \"doggo\": 2,\n \"drone\": 3\n }\n self.task = task\n self.robot_name = robot_name\n self.enable_gui = enable_gui\n self.store_video = store_video", "score": 0.7902175188064575 }, { "filename": "src/stl_mob/envs/mujoco_robots/robots/world.py", "retrieved_chunk": " self.config = deepcopy(self.DEFAULT)\n self.config.update(deepcopy(config))\n for key, value in self.config.items():\n assert key in self.DEFAULT, f'Bad key {key}'\n setattr(self, key, value)\n @property\n def data(self):\n ''' Helper to get the simulation data instance '''\n return self.sim.data\n # TODO: remove this when mujoco-py fix is merged and a new version is pushed", "score": 0.7849222421646118 }, { "filename": "src/stl_mob/envs/wrapper.py", "retrieved_chunk": " def _set_goal(self, goal: Union[List, np.ndarray]):\n self.gym_env.set_goal_position(goal_xy=goal[:2])\n def get_pos(self) -> np.ndarray:\n return np.array(self.gym_env.robot_pos[:2])\n def get_obs(self) -> np.ndarray:\n return self.gym_env.obs()\nclass PointEnv(MujocoEnv):\n def get_robot_config(self) -> dict:\n return {\n \"robot_base\": f\"xmls/point.xml\",", "score": 0.7836280465126038 }, { "filename": "src/stl_mob/envs/mujoco_robots/robots/world.py", "retrieved_chunk": " self.geom_names = [\n n for n in self.sim.model.geom_names if n != 'floor']\n # Needed to figure out the observation spaces\n self.nq = self.sim.model.nq\n self.nv = self.sim.model.nv\n # Needed to figure out action space\n self.nu = self.sim.model.nu\n # Needed to figure out observation space\n # See engine.py for an explanation for why we treat these separately\n self.hinge_pos_names = []", "score": 0.7810786366462708 } ]

[ { "filename": "src/dpapi_ng/_client.py", "retrieved_chunk": " https://learn.microsoft.com/en-us/windows/win32/api/ncryptprotect/nf-ncryptprotect-ncryptunprotectsecret\n \"\"\"\n blob = DPAPINGBlob.unpack(data)\n target_sd = blob.protection_descriptor.get_target_sd()\n cache = cache or KeyCache()\n rk = cache._get_key(\n target_sd,\n blob.key_identifier.root_key_identifier,\n blob.key_identifier.l0,\n blob.key_identifier.l1,", "score": 0.8301001191139221 }, { "filename": "src/dpapi_ng/_client.py", "retrieved_chunk": " Encrypts the blob provided as DPAPI-NG Blob. This is meant to\n replicate the Win32 API `NCryptProtectSecret`_. While NCryptProtectSecret\n supports multiple protection descriptor values, currently only the SID type\n is supported.\n Encrypting the DPAPI-NG blob requires making an RPC call to the domain\n controller for the domain the blob was created in. It will attempt this\n by looking up the DC through an SRV lookup but ``server`` can be specified\n to avoid this SRV lookup.\n The RPC call requires the caller to authenticate before the key information\n is provided. Explicit credentials can be specified, if none are then the", "score": 0.8144996166229248 }, { "filename": "src/dpapi_ng/_client.py", "retrieved_chunk": " seed_key[key.l0] = key\ndef ncrypt_unprotect_secret(\n data: bytes,\n server: t.Optional[str] = None,\n username: t.Optional[str] = None,\n password: t.Optional[str] = None,\n auth_protocol: str = \"negotiate\",\n cache: t.Optional[KeyCache] = None,\n) -> bytes:\n \"\"\"Decrypt DPAPI-NG Blob.", "score": 0.7945067286491394 }, { "filename": "src/dpapi_ng/_client.py", "retrieved_chunk": ") -> bytes:\n \"\"\"Encrypt DPAPI-NG Blob.\n Encrypts the blob provided as DPAPI-NG Blob. This is meant to\n replicate the Win32 API `NCryptProtectSecret`_. While NCryptProtectSecret\n supports multiple protection descriptor values, currently only the SID type\n is supported.\n Encrypting the DPAPI-NG blob requires making an RPC call to the domain\n controller for the domain the blob was created in. It will attempt this\n by looking up the DC through an SRV lookup but ``server`` can be specified\n to avoid this SRV lookup.", "score": 0.7925876379013062 }, { "filename": "src/dpapi_ng/_client.py", "retrieved_chunk": " Decrypts the DPAPI-NG blob provided. This is meant to replicate the Win32\n API `NCryptUnprotectSecret`_.\n Decrypting the DPAPI-NG blob requires making an RPC call to the domain\n controller for the domain the blob was created in. It will attempt this\n by looking up the DC through an SRV lookup but ``server`` can be specified\n to avoid this SRV lookup.\n The RPC call requires the caller to authenticate before the key information\n is provided. This user must be one who is authorized to decrypt the secret.\n Explicit credentials can be specified, if none are the current Kerberos\n ticket retrieved by ``kinit`` will be used instead. Make sure to install", "score": 0.7867850065231323 } ]

[ { "filename": "tests/test_client.py", "retrieved_chunk": " \"kdf_sha384_ecdh_p384\",\n \"kdf_sha512_ecdh_p384\",\n ],\n)\nasync def test_async_unprotect_secret(\n scenario: str,\n) -> None:\n expected = b\"\\x00\"\n data, key_cache = _load_root_key(scenario)\n actual = await dpapi_ng.async_ncrypt_unprotect_secret(data, cache=key_cache)", "score": 0.8391755223274231 }, { "filename": "tests/test_client.py", "retrieved_chunk": " test_protection_descriptor,\n root_key_identifier=test_root_key_identifier,\n cache=key_cache,\n )\n decrypted = await dpapi_ng.async_ncrypt_unprotect_secret(encrypted, cache=key_cache)\n assert test_data == decrypted\[email protected](\n \"kdf_algo, secret_algo\",\n [\n (\"SHA1\", \"DH\"),", "score": 0.8301031589508057 }, { "filename": "tests/test_client.py", "retrieved_chunk": " \"kdf_sha512_nonce\",\n ],\n)\nasync def test_async_protect_secret(scenario: str) -> None:\n test_data = b\"schorschii\"\n test_protection_descriptor = \"S-1-5-21-2185496602-3367037166-1388177638-1103\"\n key_cache = _load_root_key(scenario)[1]\n test_root_key_identifier = list(key_cache._root_keys.keys())[0]\n encrypted = await dpapi_ng.async_ncrypt_protect_secret(\n test_data,", "score": 0.8258193135261536 }, { "filename": "tests/test_client.py", "retrieved_chunk": " actual = dpapi_ng.ncrypt_unprotect_secret(data, cache=key_cache)\n assert actual == expected\[email protected]\[email protected](\n \"scenario\",\n [\n \"kdf_sha1_nonce\",\n \"kdf_sha256_nonce\",\n \"kdf_sha384_nonce\",\n \"kdf_sha512_nonce\",", "score": 0.8183128237724304 }, { "filename": "tests/test_client.py", "retrieved_chunk": " )\n decrypted = dpapi_ng.ncrypt_unprotect_secret(encrypted, cache=key_cache)\n assert test_data == decrypted\[email protected]\[email protected](\n \"scenario\",\n [\n \"kdf_sha1_nonce\",\n \"kdf_sha256_nonce\",\n \"kdf_sha384_nonce\",", "score": 0.8180642127990723 } ]

[ { "filename": "src/srtk/scorer/encoder.py", "retrieved_chunk": " pass\nclass LitSentenceEncoder(pl.LightningModule):\n \"\"\"A lightning module that wraps a sentence encoder.\"\"\"\n def __init__(self, model_name_or_path, temperature=0.07, lr=5e-5, pool='cls', loss='cross_entropy'):\n if pool not in ['cls', 'avg']:\n raise ValueError(f\"pool method must be either cls or avg, got {pool}\")\n if loss not in ['cross_entropy', 'contrastive']:\n raise ValueError(f\"loss method must be either cross entropy or contrastive, got {loss}\")\n if loss == 'contrastive' and 'NTXentLoss' not in globals():\n raise ImportError(\"pytorch_metric_learning is required for contrastive loss.\\", "score": 0.8092077970504761 }, { "filename": "src/srtk/preprocessing/score_path.py", "retrieved_chunk": " main(args)", "score": 0.7921447157859802 }, { "filename": "src/srtk/retrieve.py", "retrieved_chunk": " pathlib.Path(os.path.dirname(args.output)).mkdir(parents=True, exist_ok=True)\n kg = get_knowledge_graph(args.knowledge_graph, args.sparql_endpoint,\n prepend_prefixes=not args.omit_prefixes,\n exclude_qualifiers=not args.include_qualifiers)\n device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n scorer = Scorer(args.scorer_model_path, device)\n retriever = Retriever(kg, scorer, args.beam_width, args.max_depth)\n samples = list(srsly.read_jsonl(args.input))\n total = sum(1 for _ in srsly.read_jsonl(args.input))\n for sample in tqdm(samples, desc='Retrieving subgraphs', total=total):", "score": 0.7883753180503845 }, { "filename": "src/srtk/preprocessing/score_path.py", "retrieved_chunk": " print(f'Scored paths saved to {args.output_path}')\nif __name__ == '__main__':\n parser = argparse.ArgumentParser()\n parser.add_argument('-e', '--sparql-endpoint', default='http://localhost:1234/api/endpoint/sparql', help='knowledge graph endpoint')\n parser.add_argument('-kg', '--knowledge-graph', default='wikidata', choices=('wikidata', 'freebase', 'dbpedia'),\n help='knowledge graph name')\n parser.add_argument('--paths-file', help='the file where the paths are stored')\n parser.add_argument('--output-path', help='the file where the scores are stored')\n parser.add_argument('--metric', default='jaccard', choices=('jaccard', 'recall'), help='the metric used to score the paths')\n args = parser.parse_args()", "score": 0.784698486328125 }, { "filename": "src/srtk/preprocessing/negative_sampling.py", "retrieved_chunk": " help='knowledge graph endpoint (default: http://localhost:1234/api/endpoint/sparql)')\n parser.add_argument('-kg', '--knowledge-graph', default='wikidata', choices=['wikidata', 'freebase', 'dbpedia'],\n help='knowledge graph name')\n parser.add_argument('--scored-path-file', help='The file containing scored paths')\n parser.add_argument('--output-path', help='The path to the output file')\n parser.add_argument('--positive-threshold', type=float, default=0.5, help='The threshold to determine whether a path is positive or negative')\n parser.add_argument('--num-negative', type=int, default=15, help='The number of negative relations to sample for each positive relation')\n args = parser.parse_args()\n main(args)", "score": 0.7835079431533813 } ]

[ { "filename": "src/srtk/preprocessing/search_path.py", "retrieved_chunk": " # - answer_entities: list of answer entities\n ground_samples = srsly.read_jsonl(args.ground_path)\n total_samples = sum(1 for _ in srsly.read_jsonl(args.ground_path))\n kg = get_knowledge_graph(args.knowledge_graph, args.sparql_endpoint)\n processed_samples = []\n skipped = 0\n for sample in tqdm(ground_samples, total=total_samples, desc='Searching paths'):\n question_entities = sample['question_entities']\n answer_entities = sample['answer_entities']\n try:", "score": 0.8618740439414978 }, { "filename": "tests/test_link.py", "retrieved_chunk": " output=\"linked.jsonl\",\n knowledge_graph=\"dbpedia\",\n ground_on=\"question\",\n el_endpoint=dbpedia_endpoint,\n service=\"spotlight\",\n token=None,\n )\n link(args)\n with open(\"linked.jsonl\", \"r\", encoding=\"utf-8\") as f:\n linked = json.loads(f.readline())", "score": 0.8547901511192322 }, { "filename": "src/srtk/retrieve.py", "retrieved_chunk": " pathlib.Path(os.path.dirname(args.output)).mkdir(parents=True, exist_ok=True)\n kg = get_knowledge_graph(args.knowledge_graph, args.sparql_endpoint,\n prepend_prefixes=not args.omit_prefixes,\n exclude_qualifiers=not args.include_qualifiers)\n device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n scorer = Scorer(args.scorer_model_path, device)\n retriever = Retriever(kg, scorer, args.beam_width, args.max_depth)\n samples = list(srsly.read_jsonl(args.input))\n total = sum(1 for _ in srsly.read_jsonl(args.input))\n for sample in tqdm(samples, desc='Retrieving subgraphs', total=total):", "score": 0.8341999053955078 }, { "filename": "src/srtk/preprocessing/negative_sampling.py", "retrieved_chunk": " # - question: question text\n # - paths: list of paths\n # - path_scores: list of path scores\n samples = srsly.read_jsonl(args.scored_path_file)\n total = sum(1 for _ in srsly.read_jsonl(args.scored_path_file))\n train_records = []\n for sample in tqdm(samples, total=total, desc='Negative sampling'):\n paths = sample['paths']\n path_scores = sample['path_scores']\n question = sample['question']", "score": 0.8327142000198364 }, { "filename": "src/srtk/preprocessing/merge_ground.py", "retrieved_chunk": " samples = srsly.read_jsonl(ground_file)\n merged_samples.extend(samples)\n srsly.write_jsonl(args.output_path, merged_samples)\nif __name__ == '__main__':\n parser = argparse.ArgumentParser()\n parser.add_argument('--output-path', type=str, required=True)\n parser.add_argument('--ground-files', nargs='+', required=True)\n args = parser.parse_args()\n main(args)", "score": 0.8150532245635986 } ]

[ { "filename": "marl_env.py", "retrieved_chunk": "from reward_functions import compute_reward\nimport copy as cp\nfrom parameters import CFD_params, simulation_params, reward_function, optimization_params, \\\n nb_proc, nb_actuations, nb_actuations_deterministic, simu_name, nb_inv_envs\nfrom env_utils import run_subprocess\ngeneral_path = os.getcwd()\ncase_path = general_path+'/data/'+simu_name\nos.chdir(case_path)\nnp.warnings.filterwarnings('ignore')\nx, y, tt = sympy.symbols('x,y,t', real=True)", "score": 0.8218780755996704 }, { "filename": "sarl_env.py", "retrieved_chunk": " probes_value = self.probes_values\n return probes_value \n def compute_reward(self, data):\n if self.reward_function == 'Nusselt': \n reward = self.optimization_params[\"norm_reward\"]*(-data[0] + self.optimization_params[\"offset_reward\"])\n elif self.reward_function == 'kinEn': \n reward = self.optimization_params[\"norm_reward\"]*(-data[1] + self.optimization_params[\"offset_reward\"])\n elif self.reward_function == 'meanFlow': \n reward = self.optimization_params[\"norm_reward\"]*(-data[2] + self.optimization_params[\"offset_reward\"])\n else:", "score": 0.8140762448310852 }, { "filename": "marl_env.py", "retrieved_chunk": " if self.action_count == 1:\n self.recover_start()\n return self.probes_values\n def recentre_obs(self, probes_values):\n ''' This function is aimed at centering the data around the environment-segment \n (1 env is attached to the behaviour of 1 segment)\n '''\n obs_array = np.array(probes_values).reshape(3, self.obsGrid[0], self.obsGrid[1])\n centered_array = np.zeros((3, self.obsGrid[0], self.obsGrid[1]))\n ux = obs_array[0]", "score": 0.800013542175293 }, { "filename": "marl_env.py", "retrieved_chunk": " # Run + get the new Nusselt: self.run give the global data, \n # self.recentre_obs recenters the data according to the invariant env\n self.probes_values = self.recentre_obs(self.run('execute', self.episode_number, evolve=True))\n # Compute the reward\n reward, gen_Nus, gen_kinEn = compute_reward(self.probes_values, self.reward_function)\n self.history_parameters['Nusselt'].extend([gen_Nus])\n self.history_parameters['kinEn'].extend([gen_kinEn])\n self.history_parameters[\"time\"].extend([self.last_time])\n self.history_parameters[\"episode_number\"].extend([self.episode_number])\n self.save_history_parameters(nb_actuations)", "score": 0.793174147605896 }, { "filename": "marl_env.py", "retrieved_chunk": " # (cartesian) grid of probes\n self.obsGrid = CFD_params['dico_d'].get('obsGrid') \n # number of columns of probes per invariant environment\n self.hor_inv_probes = CFD_params.get('hor_inv_probes') \n self.simu = None\n self.base = None\n # postprocess values\n self.history_parameters = {}\n self.history_parameters['Nusselt'] = []\n self.history_parameters['kinEn'] = []", "score": 0.7681819200515747 } ]

[ { "filename": "agency/processor.py", "retrieved_chunk": " self._process = process\n @abstractmethod\n def start(self):\n \"\"\"\n Starts the processor\n \"\"\"\n @abstractmethod\n def stop(self):\n \"\"\"\n Stops the processor", "score": 0.8494786024093628 }, { "filename": "agency/processor.py", "retrieved_chunk": "from abc import ABC, ABCMeta, abstractmethod\nfrom typing import Callable\nclass Processor(ABC, metaclass=ABCMeta):\n \"\"\"\n Implements the form of concurrent processing used by a Space instance.\n A processor simply calls the process method frequently. It is intended to\n run concurrently with other processors, so it must do this in a way that\n cooperates with other processor instances.\n \"\"\"\n def __init__(self, process: Callable):", "score": 0.801802396774292 }, { "filename": "agency/spaces/native_space.py", "retrieved_chunk": " \"\"\"\n def __init__(self, processor_class: type = NativeThreadProcessor):\n super().__init__(processor_class=processor_class)\n self.__agent_queues: Dict[str, queue.Queue] = {}\n def _connect(self, agent: Agent):\n if agent.id() in self.__agent_queues.keys():\n raise ValueError(f\"Agent id already exists: '{agent.id()}')\")\n self.__agent_queues[agent.id()] = queue.Queue()\n def _disconnect(self, agent: Agent):\n del self.__agent_queues[agent.id()]", "score": 0.7986929416656494 }, { "filename": "agency/space.py", "retrieved_chunk": " def process():\n self._consume(agent)\n processor = self.__processor_class(process)\n self.__agent_processors[agent.id()] = {\n \"agent\": agent,\n \"processor\": processor,\n }\n agent._space = self\n agent.after_add()\n processor.start()", "score": 0.7981510162353516 }, { "filename": "agency/spaces/native_space.py", "retrieved_chunk": "import queue\nfrom typing import Dict\nfrom agency.agent import Agent\nfrom agency.processors.native_thread_processor import NativeThreadProcessor\nfrom agency.schema import Message\nfrom agency.space import Space\nclass NativeSpace(Space):\n \"\"\"\n A Space implementation that uses Python's built-in queue module.\n Suitable for single-process applications and testing.", "score": 0.7685678005218506 } ]

[ { "filename": "examples/demo/apps/gradio_app.py", "retrieved_chunk": " def __init__(self, id: str) -> None:\n super().__init__(id, receive_own_broadcasts=False)\n @action\n def say(self, content):\n # We don't do anything to render an incoming message here because the\n # get_chatbot_messages method will render the full message history\n pass\n def send_message(self, text):\n \"\"\"\n Sends a message as this user", "score": 0.8552810549736023 }, { "filename": "tests/test_e2e.py", "retrieved_chunk": " 'from': 'Webster',\n 'to': chatty.id(),\n 'action': {\n 'name': 'say',\n 'args': {\n 'content': 'Hello, Chatty!'\n }\n }\n }\n webster.send(first_message)", "score": 0.8173738718032837 }, { "filename": "examples/mqtt_demo/micropython/micropython_agent.py", "retrieved_chunk": " \"\"\"\n return self.__id\n def send(self, message: dict):\n \"\"\"\n Sends (out) an message\n \"\"\"\n message[\"from\"] = self.id()\n self._message_log.append(message)\n self._space._route(message=message)\n def _receive(self, message: dict):", "score": 0.8156448602676392 }, { "filename": "examples/demo/agents/mixins/say_response_methods.py", "retrieved_chunk": " self._receive({\n **self._current_message,\n \"action\": {\n \"name\": \"say\",\n \"args\": {\n \"content\": f\"ERROR: {error}\",\n }\n },\n })", "score": 0.8140994310379028 }, { "filename": "tests/test_e2e.py", "retrieved_chunk": " def say(self, content: str):\n return \"42\"\n def request_permission(self, proposed_message: dict) -> bool:\n return True\n webster = Webster(\"Webster\")\n chatty = Chatty(\"Chatty\")\n either_space.add(webster)\n either_space.add(chatty)\n first_message = {\n 'from': 'Webster',", "score": 0.8097579479217529 } ]

[ { "filename": "torchdistpackage/dist/py_comm_test.py", "retrieved_chunk": " output = torch.empty_like(tensor)\n dist.all_to_all_single(output, tensor, group=group)\n dist.barrier()\n torch.cuda.synchronize()\n num_repeat = 1\n beg=time.perf_counter()\n for _ in range(num_repeat):\n dist.all_to_all_single(output, tensor, group=group)\n dist.barrier()\n torch.cuda.synchronize()", "score": 0.7457853555679321 }, { "filename": "torchdistpackage/parallel/tensor_parallel/attn.py", "retrieved_chunk": "import torch\nfrom torch import nn as nn\nfrom .tp_utils import get_tp_group, set_tp_group, TpLinear, RowParallelLinear, ColParallelLinear, \\\n gather_from_sequence_parallel_region\ndef _split_heads(tensor, num_heads, attn_head_size):\n \"\"\"\n Splits hidden_size dim into attn_head_size and num_heads\n \"\"\"\n new_shape = tensor.size()[:-1] + (num_heads, attn_head_size)\n tensor = tensor.view(new_shape)", "score": 0.7433302402496338 }, { "filename": "torchdistpackage/ddp/zero_optim.py", "retrieved_chunk": " elcnt+=param.numel()\n if elcnt > numel_per_partition:\n partition_id+=1\n elcnt=0\n return partitions\nFREE_BUFFERS = []\nclass Bucket():\n def __init__(self, dtype, size, reduce_stream, dp_group, reduce_op) -> None:\n self.capacity = size\n self.reduce_stream = reduce_stream#torch.cuda.Stream()", "score": 0.7426943778991699 }, { "filename": "torchdistpackage/ddp/naive_ddp.py", "retrieved_chunk": " return aligned_size // tensor.element_size()\n def grad_ready(self):\n self.ready += 1\n return self.ready >= len(self.grads)\n def grad_reset(self):\n self.ready = 0\n def can_fit(self, grad):\n return self.offset + self.get_aligned_size(grad) <= self.numel\n def push(self, name, grad):\n new_grad = self.data.narrow(0, self.offset, grad.numel()).view_as(grad)", "score": 0.7288389205932617 }, { "filename": "torchdistpackage/parallel/tensor_parallel/tp_utils.py", "retrieved_chunk": " if world_size == 1:\n return input_\n # Split along first dimension.\n dim_size = input_.size()[0]\n assert dim_size % world_size == 0, \\\n \"First dimension of the tensor should be divisible by tensor parallel size\"\n local_dim_size = dim_size // world_size\n rank = torch.distributed.get_rank(get_tp_group())\n dim_offset = rank * local_dim_size\n output = input_[dim_offset:dim_offset+local_dim_size].contiguous()", "score": 0.7285924553871155 } ]

[ { "filename": "torchdistpackage/dist/py_comm_test.py", "retrieved_chunk": " output = torch.empty_like(tensor)\n dist.all_to_all_single(output, tensor, group=group)\n dist.barrier()\n torch.cuda.synchronize()\n num_repeat = 1\n beg=time.perf_counter()\n for _ in range(num_repeat):\n dist.all_to_all_single(output, tensor, group=group)\n dist.barrier()\n torch.cuda.synchronize()", "score": 0.84288489818573 }, { "filename": "torchdistpackage/dist/py_comm_test.py", "retrieved_chunk": " tensor = torch.randn(ele_num).half().cuda()\n if mode == \"all_gather\":\n tensor_list = [torch.randn(ele_num).half().cuda() for _ in range(ws)]\n # import pdb;pdb.set_trace()\n comm_op = functools.partial(comm_op, tensor_list)\n comm_op(tensor, group=group)\n comm_op(tensor, group=group)\n dist.barrier()\n torch.cuda.synchronize()\n bw=0", "score": 0.832897424697876 }, { "filename": "torchdistpackage/parallel/tensor_parallel/tp_utils.py", "retrieved_chunk": " if world_size == 1:\n return input_\n # Split along first dimension.\n dim_size = input_.size()[0]\n assert dim_size % world_size == 0, \\\n \"First dimension of the tensor should be divisible by tensor parallel size\"\n local_dim_size = dim_size // world_size\n rank = torch.distributed.get_rank(get_tp_group())\n dim_offset = rank * local_dim_size\n output = input_[dim_offset:dim_offset+local_dim_size].contiguous()", "score": 0.8237636685371399 }, { "filename": "torchdistpackage/parallel/tensor_parallel/tp_utils.py", "retrieved_chunk": " # Bypass the function if we are using only 1 GPU.\n if world_size == 1:\n return input_\n dim_size = list(input_.size())\n assert dim_size[0] % world_size == 0, \\\n \"First dimension of the tensor should be divisible by tensor parallel size\"\n dim_size[0] = dim_size[0] // world_size\n output = torch.empty(dim_size, dtype=input_.dtype,\n device=torch.cuda.current_device())\n torch.distributed._reduce_scatter_base(output, input_.contiguous(),", "score": 0.8215566873550415 }, { "filename": "torchdistpackage/dist/process_topo.py", "retrieved_chunk": " # most inner\n list_of_ranks = gen_inner_ranks(world_size, group_size)\n # print(list_of_ranks)\n for ranks in list_of_ranks:\n hook(ranks)\n else:\n inner_group_size = numpy.prod(strides)\n list_of_inner_ranks = gen_inner_ranks(world_size, inner_group_size)\n # print(list_of_inner_ranks)\n for ind in range(inner_group_size):", "score": 0.8073818683624268 } ]

[ { "filename": "torchdistpackage/parallel/pipeline_parallel/pipeline_sched.py", "retrieved_chunk": " # Collect the grad of the input_obj.\n input_obj_grad = None\n if input_obj is not None:\n if isinstance(input_obj, torch.Tensor):\n input_obj_grad = input_obj.grad\n else:\n input_obj_grad = []\n for in_tensor in input_obj:\n input_obj_grad.append(in_tensor.grad)\n return input_obj_grad", "score": 0.7417470812797546 }, { "filename": "torchdistpackage/parallel/pipeline_parallel/pipeline_sched.py", "retrieved_chunk": " output_objs.append(output_obj)\n # Before running 1F1B, need to receive first forward tensor.\n # If all microbatches are run in warmup / cooldown phase, then no need to\n # receive this tensor here.\n if num_microbatches_remaining > 0:\n if not tpc.is_first_in_pipeline_group():\n ft_shapes = comm.recv_obj_meta(ft_shapes)\n input_obj = comm.recv_forward(\n ft_shapes, dtype=dtype, scatter_gather_tensors=scatter_gather_tensors\n )", "score": 0.7304717898368835 }, { "filename": "torchdistpackage/parallel/pipeline_parallel/pipeline_sched.py", "retrieved_chunk": " micro_bs: the micro-batch batchsize\n fwd_fn: the fwd func of current stage\n extra_inputs: extra inputs for current stage, will be split into micro batches\n \"\"\"\n cur_inputs = []\n if input_obj_from_prev is not None:\n if isinstance(input_obj_from_prev, torch.Tensor):\n cur_inputs.append(input_obj_from_prev)\n elif isinstance(input_obj_from_prev, list) or isinstance(\n input_obj_from_prev, tuple", "score": 0.7040767669677734 }, { "filename": "torchdistpackage/dist/process_topo.py", "retrieved_chunk": " def get_pp_size(self):\n return self.get_group_size('pipe')\n def get_dp_size(self):\n return self.get_group_size('data')\n def get_mp_size(self):\n return self.get_group_size('model')\n def is_first_in_group(self, mode):\n return self.get_group_rank(mode) == 0\n def is_last_in_group(self, mode):\n return dist.get_rank() == self._ranks_in_group[mode][-1]", "score": 0.7025015354156494 }, { "filename": "torchdistpackage/parallel/pipeline_parallel/pipeline_sched.py", "retrieved_chunk": "import torch\nfrom torchdistpackage import tpc\nfrom . import comm\ndef _forward_step_in_forward_backward(\n input_obj_from_prev, ind, micro_bs, fwd_fn, extra_inputs=[]\n):\n \"\"\"\n params:\n input_obj_from_prev: the output of prev stage\n ind: current micro-batch index", "score": 0.6998699307441711 } ]

[ { "filename": "netbox_nornir/plugins/credentials/aws_ssm.py", "retrieved_chunk": " (tuple): Tuple of username, password, secret, key\n \"\"\"\n if isinstance(device, Device):\n device_name = device.name\n manufacturer = device.device_type.manufacturer.slug\n platform = device.platform.slug\n else:\n device_name = device[\"name\"]\n manufacturer = kwargs.get(\"manufacturer\")\n platform = kwargs.get(\"platform\")", "score": 0.8124557733535767 }, { "filename": "netbox_nornir/plugins/credentials/base.py", "retrieved_chunk": "\"\"\"Base credentials plugin for Netbox Nornir.\"\"\"\nclass BaseCredentials:\n \"\"\"Base credentials plugin for Netbox Nornir.\"\"\"\n username = None\n password = None\n secret = None\n def get_device_creds(self, device): # pylint: disable=unused-argument\n \"\"\"Return the credentials for a given device.\n Args:\n device (dcim.models.Device): Netbox device object", "score": 0.795880913734436 }, { "filename": "netbox_nornir/constraints.py", "retrieved_chunk": " \"netmiko\": \"netmiko.extras.secret\",\n \"napalm\": \"napalm.extras.optional_args.secret\",\n \"scrapli\": \"scrapli.extras.auth_secondary\",\n}\nCONNECTION_ENABLE_PASSWORD_PATHS = {\n \"netmiko\": \"netmiko.extras.enable_password\",\n \"napalm\": \"napalm.extras.optional_args.enable_password\",\n \"scrapli\": \"scrapli.extras.enable_password\",\n}", "score": 0.781349778175354 }, { "filename": "netbox_nornir/plugins/credentials/aws_ssm.py", "retrieved_chunk": " parameter_names = self.build_parameter_names(device_name, manufacturer, platform)\n credentials = self.client.get_parameters(Names=parameter_names, WithDecryption=True)[\"Parameters\"]\n if not credentials:\n credentials = self.get_default_creds()\n return (\n self.lookup_nested_dict(credentials, \"Name\", \"username\").get(\"Value\"),\n self.lookup_nested_dict(credentials, \"Name\", \"password\").get(\"Value\"),\n self.lookup_nested_dict(credentials, \"Name\", \"secret\").get(\"Value\"),\n self.lookup_nested_dict(credentials, \"Name\", \"key\").get(\"Value\"),\n )", "score": 0.7764531373977661 }, { "filename": "netbox_nornir/plugins/credentials/aws_ssm.py", "retrieved_chunk": " \"/\".join([prefix, \"device_default\", \"secret\"]),\n \"/\".join([prefix, \"device_default\", \"key\"]),\n ]\n return self.client.get_parameters(Names=parameter_names, WithDecryption=True)[\"Parameters\"]\n def get_device_creds(self, device, **kwargs):\n \"\"\"Get device credentials.\n Args:\n device (Device): NetBox device\n **kwargs: Additional arguments\n Returns:", "score": 0.7698779106140137 } ]

[ { "filename": "torchdistpackage/parallel/pipeline_parallel/pipeline_sched.py", "retrieved_chunk": " output_objs.append(output_obj)\n # Before running 1F1B, need to receive first forward tensor.\n # If all microbatches are run in warmup / cooldown phase, then no need to\n # receive this tensor here.\n if num_microbatches_remaining > 0:\n if not tpc.is_first_in_pipeline_group():\n ft_shapes = comm.recv_obj_meta(ft_shapes)\n input_obj = comm.recv_forward(\n ft_shapes, dtype=dtype, scatter_gather_tensors=scatter_gather_tensors\n )", "score": 0.7586050033569336 }, { "filename": "torchdistpackage/dist/process_topo.py", "retrieved_chunk": " if group_ranks == self._ranks_all[mode][0]:\n return True\n else:\n return False\ntorch_parallel_context = ProcessTopology()\ndef is_using_pp():\n return torch_parallel_context.is_mode_inited('pipe')\ndef test_comm():\n import torch\n tmp = torch.rand([100,1024]).cuda()", "score": 0.7543270587921143 }, { "filename": "torchdistpackage/parallel/pipeline_parallel/pipeline_sched.py", "retrieved_chunk": " not tpc.is_first_in_pipeline_group()\n ), \"pipeline 1st stage should have valid inputs!\"\n inputs = []\n micro_bs = 0\n if len(inputs) > 0:\n mini_bs = inputs[0].size(0)\n micro_bs = int(mini_bs / num_microbatches)\n # Input, output tensors only need to be saved when doing backward passes\n input_objs = None\n output_objs = None", "score": 0.7531607151031494 }, { "filename": "torchdistpackage/parallel/pipeline_parallel/pipeline_sched.py", "retrieved_chunk": " params:\n fwd_fn: the fwd func of current stage\n inputs: inputs for current stage, for the first stage this must not be None,\n for other stages, this could be None, and could also have extra inputs\n dtype: tensor dtype\n \"\"\"\n scatter_gather_tensors = False\n fwd_inputs = []\n # receve output from prev stage except for 1st stage\n if not tpc.is_first_in_pipeline_group():", "score": 0.7469180822372437 }, { "filename": "torchdistpackage/dist/process_topo.py", "retrieved_chunk": " def is_last_in_data_group(self):\n return self.is_last_in_group('data')\n def is_first_in_model_group(self):\n return self.is_first_in_group('model')\n def is_last_in_model_group(self):\n return self.is_last_in_group('model')\n def get_prev_global_rank(self, mode = 'pipe'):\n local_rank = self.get_group_rank(mode)\n world_size = self.get_group_size(mode)\n ranks_in_group = self.get_ranks_in_group(mode)", "score": 0.7426643371582031 } ]

[ { "filename": "torchdistpackage/parallel/tensor_parallel/attn.py", "retrieved_chunk": " self.qkv = ColParallelLinear(dim, dim * 3, bias=qkv_bias)\n self.attn_drop = nn.Dropout(attn_drop)\n self.proj = RowParallelLinear(dim, dim, sequence_parallel=sequence_parallel)\n self.proj_drop = nn.Dropout(proj_drop)\n self.sequence_parallel = sequence_parallel\n def _naive_attn(self, x):\n B, N, DIM = x.shape # DIM=self.head_dim*self.num_heads\n qkv_out = self.qkv(x) # B,N,3*DIM\n q, k, v = qkv_out.chunk(3, dim=-1) # B.N.DIM\n q= _split_heads(q, self.head_num_per_partition, self.head_dim)", "score": 0.8023065328598022 }, { "filename": "torchdistpackage/parallel/tensor_parallel/attn.py", "retrieved_chunk": " def __init__(self, dim, num_heads=8, qkv_bias=False, attn_drop=0., proj_drop=0.,\n tp_group = None, sequence_parallel=False):\n super().__init__()\n assert dim % num_heads == 0, 'dim should be divisible by num_heads'\n set_tp_group(tp_group)\n self.tp_size = torch.distributed.get_world_size(get_tp_group())\n self.num_heads = num_heads\n self.head_dim = dim // num_heads\n self.scale = self.head_dim ** -0.5\n self.head_num_per_partition = self.num_heads//self.tp_size", "score": 0.7961950302124023 }, { "filename": "torchdistpackage/parallel/tensor_parallel/tp_utils.py", "retrieved_chunk": " cur_rank = torch.distributed.get_rank(get_tp_group())\n start_ind = cur_rank*self.fout\n end_ind = (cur_rank+1)*self.fout\n slice = fullwt[:,start_ind:end_ind]\n with torch.no_grad():\n self.linear.weight.copy_(slice)\n def init_weight_from_full_attn(self, fullwt):\n cur_rank = torch.distributed.get_rank(get_tp_group())\n ws = torch.distributed.get_world_size(get_tp_group())\n dim=fullwt.shape[0]", "score": 0.7940035462379456 }, { "filename": "torchdistpackage/parallel/tensor_parallel/mlp.py", "retrieved_chunk": " in_features,\n hidden_features=None,\n out_features=None,\n act_layer=nn.GELU,\n tp_group = None,\n bias=True,\n drop=0.,\n sequence_parallel=False\n ):\n super().__init__()", "score": 0.7872270345687866 }, { "filename": "explore/model_parallel/mlp.py", "retrieved_chunk": " in_features,\n hidden_features=None,\n out_features=None,\n act_layer=nn.GELU,\n tp_group = None,\n bias=True,\n drop=0.,\n sequence_parallel=True\n ):\n super().__init__()", "score": 0.7871610522270203 } ]

[ { "filename": "torchdistpackage/parallel/tensor_parallel/attn.py", "retrieved_chunk": " self.qkv = ColParallelLinear(dim, dim * 3, bias=qkv_bias)\n self.attn_drop = nn.Dropout(attn_drop)\n self.proj = RowParallelLinear(dim, dim, sequence_parallel=sequence_parallel)\n self.proj_drop = nn.Dropout(proj_drop)\n self.sequence_parallel = sequence_parallel\n def _naive_attn(self, x):\n B, N, DIM = x.shape # DIM=self.head_dim*self.num_heads\n qkv_out = self.qkv(x) # B,N,3*DIM\n q, k, v = qkv_out.chunk(3, dim=-1) # B.N.DIM\n q= _split_heads(q, self.head_num_per_partition, self.head_dim)", "score": 0.7905515432357788 }, { "filename": "examples/model_parallel/test_tpmlp.py", "retrieved_chunk": " tp_mlp.fc2.init_weight_from_full(mlp.fc2.weight)\n tp_mlp.fc1.init_weight_from_full(mlp.fc1.weight)\n mlp_out = mlp(input)\n tp_mlp_out = tp_mlp(input)\n assert torch.allclose(mlp_out, tp_mlp_out)\n print(\"fwd passed\")\n mlp_out.mean().backward()\n tp_mlp_out.mean().backward()\n grad_out_buffer_2 = [torch.empty_like(tp_mlp.fc2.linear.weight.grad) for _ in range(dist.get_world_size())]\n dist.all_gather(grad_out_buffer_2, tp_mlp.fc2.linear.weight.grad)", "score": 0.789703369140625 }, { "filename": "torchdistpackage/parallel/tensor_parallel/tp_utils.py", "retrieved_chunk": " cur_rank = torch.distributed.get_rank(get_tp_group())\n start_ind = cur_rank*self.fout\n end_ind = (cur_rank+1)*self.fout\n slice = fullwt[:,start_ind:end_ind]\n with torch.no_grad():\n self.linear.weight.copy_(slice)\n def init_weight_from_full_attn(self, fullwt):\n cur_rank = torch.distributed.get_rank(get_tp_group())\n ws = torch.distributed.get_world_size(get_tp_group())\n dim=fullwt.shape[0]", "score": 0.7880468368530273 }, { "filename": "torchdistpackage/parallel/tensor_parallel/tp_utils.py", "retrieved_chunk": " dim3=fullwt.shape[1]\n fullwts = fullwt.split(dim3//3, dim=-1) # (q,k,v)\n splits = []\n for wt in fullwts:\n splits.append(wt.split(wt.shape[-1]//ws, dim=-1)[cur_rank])\n cat_full = torch.cat(splits, dim=-1)\n with torch.no_grad():\n self.linear.weight.copy_(cat_full)\nclass RowParallelLinear(nn.Module):\n def __init__(self, fin, fout, bias=True, sequence_parallel=False):", "score": 0.7796323895454407 }, { "filename": "torchdistpackage/parallel/tensor_parallel/mlp.py", "retrieved_chunk": " out_features = out_features or in_features\n hidden_features = hidden_features or in_features\n bias = bias\n self.sequence_parallel = sequence_parallel\n set_tp_group(tp_group)\n self.fc1 = ColParallelLinear(in_features, hidden_features, bias=bias)\n self.act = act_layer()\n self.fc2 = RowParallelLinear(hidden_features, out_features, bias=bias, sequence_parallel=sequence_parallel)\n self.drop2 = nn.Dropout(drop)\n def forward(self, x):", "score": 0.7789195775985718 } ]

[ { "filename": "examples/model_parallel/test_tpmlp.py", "retrieved_chunk": " tp_mlp.fc2.init_weight_from_full(mlp.fc2.weight)\n tp_mlp.fc1.init_weight_from_full(mlp.fc1.weight)\n mlp_out = mlp(input)\n tp_mlp_out = tp_mlp(input)\n assert torch.allclose(mlp_out, tp_mlp_out)\n print(\"fwd passed\")\n mlp_out.mean().backward()\n tp_mlp_out.mean().backward()\n grad_out_buffer_2 = [torch.empty_like(tp_mlp.fc2.linear.weight.grad) for _ in range(dist.get_world_size())]\n dist.all_gather(grad_out_buffer_2, tp_mlp.fc2.linear.weight.grad)", "score": 0.7854453325271606 }, { "filename": "torchdistpackage/parallel/tensor_parallel/mlp.py", "retrieved_chunk": " out_features = out_features or in_features\n hidden_features = hidden_features or in_features\n bias = bias\n self.sequence_parallel = sequence_parallel\n set_tp_group(tp_group)\n self.fc1 = ColParallelLinear(in_features, hidden_features, bias=bias)\n self.act = act_layer()\n self.fc2 = RowParallelLinear(hidden_features, out_features, bias=bias, sequence_parallel=sequence_parallel)\n self.drop2 = nn.Dropout(drop)\n def forward(self, x):", "score": 0.7775415182113647 }, { "filename": "explore/model_parallel/mlp.py", "retrieved_chunk": " out_features = out_features or in_features\n hidden_features = hidden_features or in_features\n bias = bias\n self.sequence_parallel = sequence_parallel\n set_tp_group(tp_group)\n self.fc1 = ColParallelLinear(in_features, hidden_features, bias=bias)\n self.act = act_layer()\n self.fc2 = RowParallelLinear(hidden_features, out_features, bias=bias, sequence_parallel=sequence_parallel)\n self.drop2 = nn.Dropout(drop)\n def forward(self, x):", "score": 0.7775415182113647 }, { "filename": "torchdistpackage/parallel/tensor_parallel/tp_utils.py", "retrieved_chunk": " cur_rank = torch.distributed.get_rank(get_tp_group())\n start_ind = cur_rank*self.fout\n end_ind = (cur_rank+1)*self.fout\n slice = fullwt[:,start_ind:end_ind]\n with torch.no_grad():\n self.linear.weight.copy_(slice)\n def init_weight_from_full_attn(self, fullwt):\n cur_rank = torch.distributed.get_rank(get_tp_group())\n ws = torch.distributed.get_world_size(get_tp_group())\n dim=fullwt.shape[0]", "score": 0.7748286724090576 }, { "filename": "torchdistpackage/parallel/tensor_parallel/tp_utils.py", "retrieved_chunk": " dim3=fullwt.shape[1]\n fullwts = fullwt.split(dim3//3, dim=-1) # (q,k,v)\n splits = []\n for wt in fullwts:\n splits.append(wt.split(wt.shape[-1]//ws, dim=-1)[cur_rank])\n cat_full = torch.cat(splits, dim=-1)\n with torch.no_grad():\n self.linear.weight.copy_(cat_full)\nclass RowParallelLinear(nn.Module):\n def __init__(self, fin, fout, bias=True, sequence_parallel=False):", "score": 0.7712252736091614 } ]

[ { "filename": "gf180/cells/klayout/pymacros/cells/fet.py", "retrieved_chunk": " )\n self.cell.insert(write_cells)\n self.cell.flatten(1)", "score": 0.7774673700332642 }, { "filename": "gf180/cells/klayout/pymacros/cells/res.py", "retrieved_chunk": " self.array_x,\n self.array_y,\n )\n self.cell.insert(write_cells)\n self.cell.flatten(1)", "score": 0.7638163566589355 }, { "filename": "gf180/__init__.py", "retrieved_chunk": "cells = get_cells(sys.modules[__name__])\nPDK = Pdk(\n name=\"tj\",\n cells=cells,\n layers=LAYER.dict(),\n layer_views=LAYER_VIEWS,\n # layer_stack=LAYER_STACK,\n)\nPDK.activate()", "score": 0.7622296810150146 }, { "filename": "gf180/__init__.py", "retrieved_chunk": "import sys\nfrom gdsfactory.get_factories import get_cells\nfrom gdsfactory.pdk import Pdk\nfrom gf180 import config, diode, fet, layers\nfrom gf180.cap_mim import (\n cap_mim,\n)\nfrom gf180.cap_mos import (\n cap_mos,\n cap_mos_inst,", "score": 0.757562518119812 }, { "filename": "docs/notebooks/intro.py", "retrieved_chunk": "# display_name: Python 3 (ipykernel)\n# language: python\n# name: python3\n# ---\n# %% [markdown]\n# # Layout\n#\n# ## Layout driven flow\n#\n# You can import the PDK and layout any of the standard cells", "score": 0.7493546605110168 } ]

[ { "filename": "cgi-reports.py", "retrieved_chunk": " visits = {}\n for row in rows:\n tag = TagID(row[0])\n if not tag:\n continue\n v: db.VisitRow = db.VisitRow()\n v.tag = tag\n v.time_in = VTime(row[1])\n v.time_out = VTime(row[2])\n v.duration = VTime(row[3])", "score": 0.8905900120735168 }, { "filename": "cgi-reports.py", "retrieved_chunk": " ins = {}\n for row in visitrows_in:\n thisdate = row.date\n if not thisdate or not row.block or row.bikes_in is None:\n continue\n blocktime = VTime(row.block * 60)\n if thisdate not in ins:\n ins[thisdate] = {}\n ins[thisdate][blocktime] = row.bikes_in\n outs = {}", "score": 0.878826916217804 }, { "filename": "cgi-reports.py", "retrieved_chunk": " for row in visitrows_out:\n thisdate = row.date\n if not thisdate or not row.block or row.bikes_out is None:\n continue\n blocktime = VTime(row.block * 60)\n if thisdate not in outs:\n outs[thisdate] = {}\n outs[thisdate][blocktime] = row.bikes_out\n block_fullest = 0\n block_busiest = 0", "score": 0.8632700443267822 }, { "filename": "cgi-reports.py", "retrieved_chunk": " print(\"<table>\")\n print(\"<style>td {text-align: right;}</style>\")\n print(\"<tr><th>Date</th><th>BikeIn</th><th>BikeOut</th></tr>\")\n for row in rows:\n out = VTime(row[2]).tidy if row[2] else \" \"\n linkdate = row[0]\n link = selfref(what=\"one_day_tags\", qdate=linkdate)\n print(\n f\"<tr><td>\"\n f\"<a href='{link}'>{row[0]}</a>\"", "score": 0.8572911024093628 }, { "filename": "tt_event.py", "retrieved_chunk": " if atime > as_of_when:\n continue\n if atime not in events:\n events[atime] = Event(atime)\n events[atime].bikes_in.append(tag)\n for tag, atime in day.bikes_out.items():\n if atime > as_of_when:\n continue\n if atime not in events:\n events[atime] = Event(atime)", "score": 0.8349682092666626 } ]

[ { "filename": "tt_datafile.py", "retrieved_chunk": " data.date = maybedate\n continue\n elif re.match(rf\"({HEADER_VALET_OPENS}|{HEADER_VALET_CLOSES})\", line):\n # This is an open or a close time (probably)\n section = IGNORE\n r = re.match(\n rf\"({HEADER_VALET_OPENS}|{HEADER_VALET_CLOSES}) *(.+)\", line\n )\n maybetime = VTime(r.group(2))\n if not maybetime:", "score": 0.8025543093681335 }, { "filename": "tagtracker.py", "retrieved_chunk": " # pylint: disable=global-statement\n global VALET_DATE, VALET_OPENS, VALET_CLOSES\n global check_ins, check_outs\n global NORMAL_TAGS, OVERSIZE_TAGS, RETIRED_TAGS\n global ALL_TAGS\n global COLOUR_LETTERS\n # pylint: enable=global-statement\n VALET_DATE = today_data.date\n VALET_OPENS = today_data.opening_time\n VALET_CLOSES = today_data.closing_time", "score": 0.7837943434715271 }, { "filename": "tt_reports.py", "retrieved_chunk": " all_blocks = tt_block.calc_blocks(day, end_time)\n if not all_blocks:\n earliest = day.earliest_event()\n pr.iprint(\n f\"No bikes checked in before {end_time} \"\n f\"(earliest in at {earliest})\",\n style=cfg.HIGHLIGHT_STYLE,\n )\n return\n for which in [BIKE_IN, BIKE_OUT]:", "score": 0.7771251201629639 }, { "filename": "tt_trackerday.py", "retrieved_chunk": " errors = []\n # Look for missing or bad times and dates\n if strict_datetimes:\n if not self.date or ut.date_str(self.date) != self.date:\n errors.append(f\"Bad or missing valet date {self.date}\")\n if not self.opening_time or not isinstance(\n self.opening_time, VTime\n ):\n errors.append(\n f\"Bad or missing opening time {self.opening_time}\"", "score": 0.7770014405250549 }, { "filename": "tt_dbutil.py", "retrieved_chunk": " time_in = VTime(row[1])\n time_out = VTime(row[2])\n still_in = not time_out\n if not tag or not time_in:\n continue\n day.bikes_in[tag] = time_in\n if time_out and not still_in:\n day.bikes_out[tag] = time_out\n # Tag type (regular/oversize)\n tag_type = row[3] if row[3] else day.guess_tag_type(tag)", "score": 0.7741928696632385 } ]

[ { "filename": "tt_datafile.py", "retrieved_chunk": " except OSError:\n ut.squawk(f\"ERROR: Unable to write file {filename}\")\n ut.squawk(\"exiting\")\n exit(1)", "score": 0.804120659828186 }, { "filename": "tt_datafile.py", "retrieved_chunk": " else:\n ut.squawk(\"PROGRAM ERROR: should not reach this code spot\")\n errors += 1\n continue\n if errors:\n err_msgs.append(f\"Found {errors} errors in datafile {filename}\")\n # If no colour dictionary, fake one up\n if not data.colour_letters:\n data.make_fake_colour_dict()\n # Return today's working data.", "score": 0.7962466478347778 }, { "filename": "tt_datafile.py", "retrieved_chunk": " if fline:\n text = f\"{fline}:{text}\"\n if fname:\n text = f\"{fname}:{text}\"\n message_list.append(text)\n return errs + 1\n data = TrackerDay()\n errors = 0 # How many errors found reading datafile?\n section = None\n with open(filename, \"r\", encoding=\"utf-8\") as f:", "score": 0.7905964851379395 }, { "filename": "tt_datafile.py", "retrieved_chunk": " if os.path.exists(filename):\n os.rename(filename, backuppath)\n return None\ndef read_datafile(\n filename: str, err_msgs: list[str], usable_tags: list[TagID] = None\n) -> TrackerDay:\n \"\"\"Fetch tag data from file into a TrackerDay object.\n Read data from a pre-existing data file, returns the info in a\n TrackerDay object. If no file, TrackerDay will be mostly blank.\n err_msgs is the (presumably empty) list, to which any error messages", "score": 0.7883660197257996 }, { "filename": "tt_datafile.py", "retrieved_chunk": " \"Retired tags:\\n\\n\",\n \"# Colour codes are used to format reports.\\n\",\n \"# Each line is one- or two-letter colour code then the name of the colour\\n\",\n \"# E.g. r red \\n\",\n \"Colour codes:\\n\\n\",\n ]\n if not os.path.exists(filename): # make new tags config file only if needed\n try:\n with open(filename, \"w\", encoding=\"utf-8\") as f:\n f.writelines(template)", "score": 0.786270260810852 } ]

[ { "filename": "precondition/tearfree/optimizer.py", "retrieved_chunk": " second_order_tx = second_order.apply(options.second_order_options)\n graft_tx = grafting.graft(options.grafting_options, second_order_tx)\n momentum_tx = momentum.apply(options.momentum_options)\n if callable(learning_rate):\n lr_tx = optax.scale_by_schedule(lambda x: -1.0 * learning_rate(x))\n else:\n lr_tx = optax.scale(-1.0 * learning_rate)\n return praxis_shim.sharded_chain(\n graft_tx,\n momentum_tx,", "score": 0.8848174810409546 }, { "filename": "precondition/tearfree/optimizer_test.py", "retrieved_chunk": " shape = (4,)\n options = self._no_graft_no_momentum()\n options.momentum_options = momentum_options\n tx = praxis_shim.sharded_chain(\n second_order.apply(options.second_order_options),\n momentum.apply(momentum_options),\n optax.scale(-0.1),\n )\n actual = self._unroll(options, shape)\n expected = self._unroll(tx, shape)", "score": 0.8743637800216675 }, { "filename": "precondition/tearfree/second_order.py", "retrieved_chunk": " # TODO(vladf): later, we'll need to wrap pspec as well.\n wrapped_precond_tx = praxis_shim.ShardedGradientTransformation(\n wrap_init, precond_tx.update, precond_tx.init_partition_spec\n )\n return praxis_shim.sharded_chain(\n merge_tx,\n wrapped_precond_tx,\n reshaper.unmerge(reshaper_options),\n )\ndef _reshaper_options(options: Options) -> reshaper.Options:", "score": 0.8564622402191162 }, { "filename": "precondition/tearfree/optimizer_test.py", "retrieved_chunk": " return grafting.graft(grafting_options, id_tx_shard)\n def _grafting_tx_with_momentum(\n self, grafting_options, momentum_options, lr=0.1\n ):\n return praxis_shim.sharded_chain(\n self._grafting_tx(grafting_options),\n momentum.apply(momentum_options),\n optax.scale(-lr),\n )\n @parameterized.parameters(", "score": 0.8549522161483765 }, { "filename": "precondition/tearfree/grafting.py", "retrieved_chunk": " \"\"\"Create SGD sharded gradient transform.\"\"\"\n grad_transform = optax.identity()\n return praxis_shim.ShardedGradientTransformation(\n grad_transform.init,\n grad_transform.update,\n optax.EmptyState,\n )\ndef _adafactor(options: Options) -> praxis_shim.ShardedGradientTransformation:\n \"\"\"Create AdaFactor sharded gradient transform.\"\"\"\n tx = [optax.adafactor(", "score": 0.8385974168777466 } ]

[ { "filename": "precondition/distributed_shampoo_test.py", "retrieved_chunk": " dt = self.init_params[0].dtype\n def make_shape(bigger_first_entry):\n x = tuple(self.rng.standard_normal(size=s) for s in shape)\n if bigger_first_entry:\n for xx in x:\n xx[..., 0] *= 100\n return tuple(jnp.array(xx).astype(dt) for xx in x)\n self.init_params_larger = make_shape(False)\n self.per_step_updates_larger = make_shape(True)\n @chex.all_variants(with_pmap=False)", "score": 0.8387121558189392 }, { "filename": "precondition/distributed_shampoo_test.py", "retrieved_chunk": " state = init_fn(params)\n chex.assert_tree_all_finite(state)\n pmap_fn = jax.pmap(_update, axis_name='batch')\n updates, state = pmap_fn(jnp.array([1.0]))\n chex.assert_tree_all_finite((params, updates, state))\n for _ in range(5):\n updates, state = pmap_fn(jnp.array([1.0]))\n chex.assert_tree_all_finite((params, updates, state))\n def _gen_symmetrix_matrix(self, dim, condition_number):\n u = scipy.stats.ortho_group.rvs(", "score": 0.8379061222076416 }, { "filename": "precondition/sm3.py", "retrieved_chunk": " return SM3State(\n count=jnp.zeros([], jnp.int32), stats=jax.tree_map(_init, params))\n def _get_expanded_shape(shape, i):\n rank = len(shape)\n # Replaces a `shape` of [M, N, K] with 1 in all dimensions except for i.\n # For eg: i = 1 returns [1, N, 1].\n return [1] * i + [shape[i]] + [1] * (rank - i - 1)\n def _moving_averages(grad, accumulators):\n w = (1.0 - beta2) if beta2 != 1.0 else 1.0\n if grad.ndim < 2:", "score": 0.8265843391418457 }, { "filename": "precondition/distributed_shampoo_test.py", "retrieved_chunk": " state = init_fn(params)\n chex.assert_tree_all_finite(state)\n updates, state = transform_fn(self.per_step_updates, state, params)\n chex.assert_tree_all_finite((params, updates, state))\n @chex.all_variants(with_pmap=False)\n @parameterized.named_parameters([\n {\n 'testcase_name': 'preconditioning_compute_steps_schedule',\n 'preconditioning_compute_steps': 2,\n 'end_preconditioning_steps': 100,", "score": 0.824435293674469 }, { "filename": "precondition/tearfree/shampoo_test.py", "retrieved_chunk": " \"\"\"Basic test for shampoo implementation.\"\"\"\n def setUp(self):\n super().setUp()\n jax.config.update('jax_debug_nans', True)\n def _unroll(self, options, n, shape):\n \"\"\"Generate states and grad updates n times.\"\"\"\n rng = jax.random.PRNGKey(0)\n params = jnp.zeros(shape)\n grads = jax.random.normal(rng, (n, *shape))\n return self._unroll_concrete(options, params, grads)", "score": 0.8242695927619934 } ]

[ { "filename": "tests/unit/core/test_NcData.py", "retrieved_chunk": "\"\"\"Tests for class :class:`ncdata.NcData`.\nThere is almost no behaviour, but we can test some constructor usages.\n\"\"\"\nfrom ncdata import NcData\nclass Test_NcData__init__:\n def test_noargs(self):\n sample = NcData()\n assert sample.name is None\n assert sample.dimensions == {}\n assert sample.variables == {}", "score": 0.9162826538085938 }, { "filename": "tests/unit/core/test_NcDimension.py", "retrieved_chunk": "\"\"\"Tests for class :class:`ncdata.NcDimension`.\"\"\"\nfrom unittest import mock\nimport numpy as np\nimport pytest\nfrom ncdata import NcDimension\nclass Test_NcDimension__init__:\n def test_simple(self):\n name = \"dimname\"\n # Use an array object for test size, just so we can check \"is\".\n # N.B. assumes the constructor copies the reference - which could change.", "score": 0.8715745210647583 }, { "filename": "tests/unit/core/test_NcData.py", "retrieved_chunk": " assert sample.groups == {}\n assert sample.attributes == {}\n def test_allargs(self):\n # Since there is no type checking, you can put what you like in the \"slots\".\n name = \"data_name\"\n dims = {f\"dimname_{i}\": f\"dim_{i}\" for i in range(3)}\n vars = {f\"varname_{i}\": f\"var_{i}\" for i in range(5)}\n attrs = {f\"varname_{i}\": f\"var_{i}\" for i in range(6)}\n grps = {f\"groupname_{i}\": f\"group_{i}\" for i in range(3)}\n sample1 = NcData(", "score": 0.8549075126647949 }, { "filename": "tests/unit/core/test_NcAttribute.py", "retrieved_chunk": "\"\"\"\nTests for class :class:`ncdata.NcAttribute`.\nVery simple for now, but we may add more behaviour in future.\n\"\"\"\nimport numpy as np\nimport pytest\nfrom ncdata import NcAttribute\n# Support for building testcases\n_data_types = [\n \"int\",", "score": 0.8302258253097534 }, { "filename": "tests/unit/core/test_NcData.py", "retrieved_chunk": " assert sample1.groups is grps\n assert sample1.attributes is attrs\n # Also check construction with arguments alone (no keywords).\n sample2 = NcData(name, dims, vars, attrs, grps)\n # result is a new object, but contents are references identical to the other\n assert sample2 is not sample1\n for name in dir(sample1):\n if not name.startswith(\"_\"):\n assert getattr(sample2, name) is getattr(sample1, name)\n# Note: str() and repr() of NcData are too complex to test unit-wise.", "score": 0.8294709324836731 } ]

[ { "filename": "precondition/tearfree/second_order.py", "retrieved_chunk": " if options.second_order_type == SecondOrderType.SHAMPOO:\n assert options.shampoo_options\n block_size = options.shampoo_options.block_size\n return reshaper.Options(options.merge_dims, block_size)\n if options.second_order_type == SecondOrderType.SKETCHY:\n return reshaper.Options(options.merge_dims, 0)\n else:\n raise ValueError(\n 'unknown second order type {}'.format(options.second_order_type)\n )", "score": 0.8220426440238953 }, { "filename": "precondition/tearfree/reshaper_test.py", "retrieved_chunk": " 1,\n 2,\n 1,\n ),\n }\n init = jax.tree_map(\n jnp.zeros, shapes, is_leaf=lambda x: isinstance(x, tuple)\n )\n options = reshaper.Options(merge_dims=2, block_size=2)\n init_fn, update_fn = reshaper.merge(options)", "score": 0.8144479990005493 }, { "filename": "precondition/tearfree/shampoo.py", "retrieved_chunk": " param_shape: list[int]\n large_axes: list[int]\n blocks_per_large_axis: list[int]\n blocks_axis: int\ndef _blocks_metadata(\n options: Options, param_shape: Sequence[int], debug: str\n) -> _BlocksMetadata:\n \"\"\"Generate the blocks metadata for a parameter.\"\"\"\n dims = [min(dim, options.block_size) for dim in param_shape]\n large_axes = [i for i, d in enumerate(param_shape) if d >= options.block_size]", "score": 0.8110880851745605 }, { "filename": "precondition/tearfree/shampoo.py", "retrieved_chunk": " param: praxis_shim.WeightHParams,\n ) -> praxis_shim.NestedHParams:\n meta = _blocks_metadata(options, param.shape, str(path))\n num_blocks = meta.num_blocks\n dims = meta.block_sizes\n replicated = functools.partial(\n praxis_shim.WeightHParams,\n init=None,\n dtype=jnp.float32,\n collections=None,", "score": 0.8108469843864441 }, { "filename": "precondition/tearfree/second_order.py", "retrieved_chunk": " # TODO(vladf): later, we'll need to wrap pspec as well.\n wrapped_precond_tx = praxis_shim.ShardedGradientTransformation(\n wrap_init, precond_tx.update, precond_tx.init_partition_spec\n )\n return praxis_shim.sharded_chain(\n merge_tx,\n wrapped_precond_tx,\n reshaper.unmerge(reshaper_options),\n )\ndef _reshaper_options(options: Options) -> reshaper.Options:", "score": 0.8060868382453918 } ]

[ { "filename": "tests/unit/core/test_NcVariable.py", "retrieved_chunk": " def test_minimum_args(self):\n # We can create a variable with no args.\n name = \"varname\"\n sample = NcVariable(\"varname\")\n # No data, no dtype. Variables don't have 'shape' anyway\n assert sample.name is name\n assert sample.dimensions == ()\n assert sample.data is None\n assert sample.dtype is None\n assert sample.attributes == {}", "score": 0.8825441598892212 }, { "filename": "tests/unit/core/test_NcVariable.py", "retrieved_chunk": " assert sample1.name is name\n assert sample1.dimensions is dims\n assert sample1.variables is vars\n assert sample1.groups is grps\n assert sample1.attributes is attrs\n # Also check construction with arguments alone (no keywords).\n sample2 = NcData(name, dims, vars, attrs, grps)\n # result is new object, but all contents are references identical to the other\n assert sample2 is not sample1\n for name in [n for n in dir(sample1) if n[0] != \"_\"]:", "score": 0.8608661890029907 }, { "filename": "tests/unit/core/test_NcDimension.py", "retrieved_chunk": "\"\"\"Tests for class :class:`ncdata.NcDimension`.\"\"\"\nfrom unittest import mock\nimport numpy as np\nimport pytest\nfrom ncdata import NcDimension\nclass Test_NcDimension__init__:\n def test_simple(self):\n name = \"dimname\"\n # Use an array object for test size, just so we can check \"is\".\n # N.B. assumes the constructor copies the reference - which could change.", "score": 0.8578115701675415 }, { "filename": "lib/ncdata/xarray.py", "retrieved_chunk": " def __init__(self, ncdata: NcData = None):\n if ncdata is None:\n ncdata = NcData()\n self.ncdata = ncdata\n def load(self):\n variables = {}\n for k, v in self.ncdata.variables.items():\n attrs = {\n name: attr.as_python_value()\n for name, attr in v.attributes.items()", "score": 0.8536118865013123 }, { "filename": "tests/unit/core/test_NcVariable.py", "retrieved_chunk": " def test_never_nameless(self):\n # Can't create a variable without a name.\n msg = \"required positional argument: 'name'\"\n with pytest.raises(TypeError, match=msg):\n _ = NcVariable()\n def test_allargs(self):\n # Since there is no type checking, you can put whatever you like in the \"slots\".\n name = \"data_name\"\n dims = {f\"dimname_{i}\": f\"dim_{i}\" for i in range(3)}\n vars = {f\"varname_{i}\": f\"var_{i}\" for i in range(5)}", "score": 0.8479302525520325 } ]

[ { "filename": "tt_reports.py", "retrieved_chunk": " pr.iprint()\n pr.iprint(\"Most bikes at valet at any one time\", style=cfg.SUBTITLE_STYLE)\n if not events:\n pr.iprint(\"-no bikes-\")\n return\n # Find maximum bikes on hand for the categories\n max_regular_num = max([x.num_here_regular for x in events.values()])\n max_oversize_num = max([x.num_here_oversize for x in events.values()])\n max_total_num = max([x.num_here_total for x in events.values()])\n max_regular_time = None", "score": 0.8112742900848389 }, { "filename": "tt_event.py", "retrieved_chunk": " events[atime].bikes_out.append(tag)\n # Second pass, calculate other attributes of Events.\n num_regular = 0 # Running balance of regular & oversize bikes.\n num_oversize = 0\n here_set = set()\n for atime in sorted(events.keys()):\n ev = events[atime]\n ev.num_ins = len(ev.bikes_in)\n ev.num_outs = len(ev.bikes_out)\n # How many regular & oversize bikes have we added or lost?", "score": 0.8039889931678772 }, { "filename": "tt_event.py", "retrieved_chunk": " ev.num_here_total = num_regular + num_oversize\n ev.num_ins = len(ev.bikes_in)\n ev.num_outs = len(ev.bikes_out)\n here_set = (here_set | set(ev.bikes_in)) - set(ev.bikes_out)\n ev.bikes_here = list(here_set)\n return events", "score": 0.8028319478034973 }, { "filename": "fullness_alert.py", "retrieved_chunk": " print(\n f\"Date {args.date} had {max_total} bikes; >= threshold of {args.threshold}\"\n )\nelif args.force:\n print(\n f\"Date {args.date} had {max_total} bikes; less than threshold of {args.threshold}\"\n )", "score": 0.8014035820960999 }, { "filename": "tt_event.py", "retrieved_chunk": " delta_regular = len([x for x in ev.bikes_in if x in day.regular]) - len(\n [x for x in ev.bikes_out if x in day.regular]\n )\n delta_oversize = len([x for x in ev.bikes_in if x in day.oversize]) - len(\n [x for x in ev.bikes_out if x in day.oversize]\n )\n num_regular += delta_regular\n num_oversize += delta_oversize\n ev.num_here_regular = num_regular\n ev.num_here_oversize = num_oversize", "score": 0.8012107014656067 } ]

[ { "filename": "tensorrt_export/trt_check_no_past.py", "retrieved_chunk": " input_ids: torch.Tensor = input_dict.input_ids.int().to(device)\n position_ids: torch.Tensor = input_dict.position_ids.int().to(device)\n input_tensors = (input_ids, position_ids)\n kernel = KernelNoPast(engine_path1, batch_size, num_layers)\n output_tensors = kernel.forward(input_tensors)\n # compare output\n max_diff_ = 0\n # compare logits\n logits = output_dict.logits.to(device)\n pred_logits = output_tensors[-1]", "score": 0.9123845100402832 }, { "filename": "onnx_export/run_onnx_cuda.py", "retrieved_chunk": " for layer_idx in range(num_layers):\n input_names = [\n f\"past_key_values.{layer_idx}.key\",\n f\"past_key_values.{layer_idx}.value\"\n ]\n # inputs[input_names[0]] = past_key_values\n # inputs[input_names[1]] = past_key_values\n for name in input_names:\n try:\n past_key_values = getattr(input_dict, name).data.cpu().numpy()", "score": 0.9026078581809998 }, { "filename": "onnx_export/run_onnx_trt.py", "retrieved_chunk": " # inputs[input_names[0]] = past_key_values\n # inputs[input_names[1]] = past_key_values\n for name in input_names:\n try:\n past_key_values = getattr(input_dict, name).data.cpu().numpy()\n except Exception:\n past_key_values = np.zeros(\n [1, input_ids.shape[1], 32, 128],\n dtype=one_present_key.dtype\n )", "score": 0.8790456056594849 }, { "filename": "kernel/pykernel_with_past.py", "retrieved_chunk": " on_key_value = torch.rand([65, 1, 2, 128]).to(device1)\n input_tensors1.append(on_key_value)\n output_tensors1 = kernel.forward(tuple(input_tensors1))\n print(\"first shape\", output_tensors1[0].shape)\n print(\"last shape\", output_tensors1[-1].shape)", "score": 0.8618197441101074 }, { "filename": "onnx_export/run_onnx_cpu.py", "retrieved_chunk": " f\"past_key_values.{layer_idx}.key\",\n f\"past_key_values.{layer_idx}.value\"\n ]\n # inputs[input_names[0]] = past_key_values\n # inputs[input_names[1]] = past_key_values\n for name in input_names:\n try:\n past_key_values = getattr(input_dict, name).data.cpu().numpy()\n except Exception:\n past_key_values = np.zeros(", "score": 0.8528769612312317 } ]

[ { "filename": "precondition/distributed_shampoo.py", "retrieved_chunk": " return [s.to_float() for s in statistics_list]\n else:\n return statistics_list\n def _quantize_diagonal_statistics(diagonal_statistics):\n return QuantizedValue.from_float_value(diagonal_statistics, jnp.float32)\n def _quantize_momentum(momentum_statistics):\n return QuantizedValue.from_float_value(\n momentum_statistics,\n quantized_dtype_for_momentum_buffers(momentum_statistics))\n def preconditioner_from_params(param):", "score": 0.7926802039146423 }, { "filename": "precondition/distributed_shampoo.py", "retrieved_chunk": " statistics_list, quantized_dtype_for_second_moment_statistics_buffers())\n def _maybe_quantize_preconditioners(statistics_list):\n return _maybe_quantize_matrices_with_dtype(\n statistics_list,\n quantized_dtype_for_second_moment_preconditioner_buffers())\n def _maybe_quantize_matrices_with_dtype(statistics_list, quantized_dtype):\n if quantized_dtype != jnp.float32:\n return ([\n QuantizedValue.from_float_value(\n s, quantized_dtype, extract_diagonal=True)", "score": 0.7874119281768799 }, { "filename": "precondition/distributed_shampoo.py", "retrieved_chunk": " couple it with preconditioned gradient computation. (Default True)\n decoupled_weight_decay: If True, use decoupled weight decay, otherwise\n couple with weight decay. (Default False)\n generate_training_metrics: If True, gather training metrics, otherwise avoid\n generating them (to reduce memory usage).\n reuse_preconditioner: If True, pass the previous derived preconditioner as a\n warm start to the next iteratin's inverse pth root computation.\n eigh: If True, and uses eigen decomposition for inverse-pth root.\n Returns:\n a GradientTransformation.", "score": 0.7795664668083191 }, { "filename": "precondition/distributed_shampoo.py", "retrieved_chunk": " # Preconditioner and statistics are both stores as int16 in this mode.\n # We take out the diagonal to make quantization easier.\n def quantized_dtype_for_second_moment_statistics_buffers():\n return jnp.int16 if quantize_second_moment else jnp.float32\n # Preconditioner and statistics are both stores as int16 in this mode.\n # We take out the diagonal to make quantization easier.\n def quantized_dtype_for_second_moment_preconditioner_buffers():\n return jnp.int16 if quantize_second_moment else jnp.float32\n # _quantized_matrix_inverse_pth_root_vmap implementation assumes\n # that preconditioner is quantized if and only if stats is quantized.", "score": 0.7759225964546204 }, { "filename": "precondition/distributed_shampoo.py", "retrieved_chunk": " rmsprop_update = scaled_grad / (\n jnp.sqrt(new_diagonal_statistics) + diagonal_epsilon)\n if clip_by_scaled_gradient_norm:\n scaled_grad_norm = jnp.linalg.norm(rmsprop_update) / (\n jnp.sqrt(float(rmsprop_update.size)))\n clipping_denom = jnp.maximum(\n 1., scaled_grad_norm / clip_by_scaled_gradient_norm)\n rmsprop_update /= clipping_denom\n grafting_update = rmsprop_update\n elif graft_type == GraftingType.SGD:", "score": 0.774163544178009 } ]

[ { "filename": "pyqt/PyRibbon/QxRibbonGroup.py", "retrieved_chunk": "from .QxRibbonGallery import RibbonGallery\nfrom . import QxRibbonRes_rc\nQX_RIBBON_PROP_ROW_PROPORTION = \"_qx_RibbonGroupRowProportion\"\nclass RibbonGroupOptionButton(QToolButton):\n def __init__(self, parent=None):\n super().__init__(parent)\n self.setAutoRaise(True)\n self.setCheckable(False)\n self.setToolButtonStyle(Qt.ToolButtonIconOnly)\n self.setFixedSize(16, 16)", "score": 0.8821367025375366 }, { "filename": "pyqt/PyRibbon/QxRibbonControls.py", "retrieved_chunk": " super().__init__(parent)\nclass RibbonCheckBox(QCheckBox):\n def __init__(self, parent=None):\n super().__init__(parent)\nclass RibbonComboBox(QComboBox):\n def __init__(self, parent=None):\n super().__init__(parent)\nclass RibbonControlButton(QToolButton):\n def __init__(self, parent=None):\n super().__init__(parent)", "score": 0.8786472082138062 }, { "filename": "pyqt/PyRibbon/QxRibbonContainers.py", "retrieved_chunk": "#!/usr/bin/env python3\n# Copyright (c) 2023 maminjie <[email protected]>\n# SPDX-License-Identifier: GPL-3.0\nfrom PyQt5.QtCore import Qt, QSize\nfrom PyQt5.QtGui import QIcon\nfrom PyQt5.QtWidgets import QWidget, QHBoxLayout, QLabel, QSizePolicy\nclass RibbonCtrlContainer(QWidget):\n def __init__(self, parent=None):\n super().__init__(parent)\n self.m_widget = None", "score": 0.8779878616333008 }, { "filename": "pyqt/PyRibbon/QxRibbonWindow.py", "retrieved_chunk": "class RibbonWindow(QMainWindow):\n def __init__(self, parent=None, use_ribbon=True):\n super().__init__(parent)\n self.m_useRibbon = use_ribbon\n self.m_theme = RibbonWindow.Office2013Theme\n self.m_ribbonBar: RibbonBar = None\n self.m_windowButtonGroup: WindowButtonGroup = None\n self.m_framelessHelper: FramelessHelper = None\n if self.m_useRibbon:\n self.setRibbonTheme(self.ribbonTheme())", "score": 0.8738704323768616 }, { "filename": "pyqt/PyRibbon/QxRibbonControls.py", "retrieved_chunk": "#!/usr/bin/env python3\n# Copyright (c) 2023 maminjie <[email protected]>\n# SPDX-License-Identifier: GPL-3.0\nfrom typing import Union\nfrom PyQt5.QtCore import QSize, QPoint\nfrom PyQt5.QtGui import QPaintEvent, QPainter\nfrom PyQt5.QtWidgets import QWidget, QCheckBox, QComboBox, QToolButton, \\\n QLineEdit, QMenu, QAction, QSizePolicy, QWidgetAction\nclass RibbonControl(QWidget):\n def __init__(self, parent=None):", "score": 0.8719892501831055 } ]

[ { "filename": "pyqt/demo/RibbonDemo.py", "retrieved_chunk": " buttonGroup2.addAction(self.createAction(\"center alignment\", \"res/al-center.svg\"))\n buttonGroup2.addAction(self.createAction(\"right alignment\", \"res/al-right.svg\"))\n buttonGroup2.addAction(self.createAction(\"line up on both sides\", \"res/al-bothside.svg\"))\n act = group.addWidget(buttonGroup2, RibbonGroup.Medium)\n act.setObjectName(buttonGroup2.objectName())\n group.addSeparator()\n actLargerFontSize = self.createAction(\"Larger\", \"res/largerFont.svg\", \"actLargerFontSize\")\n actLargerFontSize.triggered.connect(self.onActionFontLargerTriggered)\n group.addLargeAction(actLargerFontSize)\n actSmallFontSize = self.createAction(\"Smaller\", \"res/smallFont.svg\", \"actSmallFontSize\")", "score": 0.8910870552062988 }, { "filename": "pyqt/demo/RibbonDemo.py", "retrieved_chunk": " QToolButton.InstantPopup, RibbonGroup.Large)\n groupLayout.addAction(self.createAction(\"Medium\", \"res/layout.svg\", \"@Medium5\"),\n QToolButton.InstantPopup, RibbonGroup.Large)\n groupLayout.addAction(self.createAction(\"Large\", \"res/layout.svg\", \"@Large4\"),\n QToolButton.InstantPopup, RibbonGroup.Large)\n groupLayout.addSeparator()\n groupLayout.addAction(self.createAction(\"Medium\", \"res/layout.svg\", \"@Medium6\"),\n QToolButton.InstantPopup, RibbonGroup.Medium)\n groupLayout.addAction(self.createAction(\"Large\", \"res/layout.svg\", \"@Large5\"),\n QToolButton.InstantPopup, RibbonGroup.Large)", "score": 0.8891340494155884 }, { "filename": "pyqt/demo/RibbonDemo.py", "retrieved_chunk": " QToolButton.InstantPopup, RibbonGroup.Medium)\n groupLayout.addAction(self.createAction(\"Medium\", \"res/layout.svg\", \"@Medium2\"),\n QToolButton.InstantPopup, RibbonGroup.Medium)\n groupLayout.addAction(self.createAction(\"Small\", \"res/layout.svg\", \"@Small7\"),\n QToolButton.InstantPopup, RibbonGroup.Small)\n groupLayout.addAction(self.createAction(\"Medium\", \"res/layout.svg\", \"@Medium3\"),\n QToolButton.InstantPopup, RibbonGroup.Medium)\n groupLayout.addAction(self.createAction(\"Large\", \"res/layout.svg\", \"@Large3\"),\n QToolButton.InstantPopup, RibbonGroup.Large)\n groupLayout.addAction(self.createAction(\"Medium\", \"res/layout.svg\", \"@Medium4\"),", "score": 0.8792153000831604 }, { "filename": "pyqt/demo/RibbonDemo.py", "retrieved_chunk": " buttonGroup1.addAction(self.createAction(\"Decrease Margin\", \"res/Decrease-Margin.svg\"))\n buttonGroup1.addAction(self.createAction(\"Decrease Indent\", \"res/Decrease-Indent.svg\"))\n buttonGroup1.addAction(self.createAction(\"Wrap Image Left\", \"res/Wrap-Image Left.svg\"))\n buttonGroup1.addAction(self.createAction(\"Wrap Image Right\", \"res/Wrap-Image Right.svg\"))\n group1.addWidget(buttonGroup1, RibbonGroup.Medium)\n buttonGroup2 = RibbonButtonGroup(group1)\n titleAlignment = self.createAction(\"Align Right\", \"res/Align-Right.svg\")\n titleAlignment.setProperty(\"align\", int(Qt.AlignRight | Qt.AlignVCenter))\n buttonGroup2.addAction(titleAlignment)\n titleAlignment = self.createAction(\"Align Left\", \"res/Align-Left.svg\")", "score": 0.8717881441116333 }, { "filename": "pyqt/demo/RibbonDemo.py", "retrieved_chunk": " g.addButton(r, RibbonBar.WpsLiteStyleTwoRow)\n groupStyle.addSmallWidget(r)\n g.buttonClicked[int].connect(self.onStyleClicked)\n groupToolButtonStyle = page.addGroup(\"ribobn toolbutton style\")\n menu = RibbonMenu(self)\n itemIcon = QIcon(\"res/item.svg\")\n for i in range(5):\n a = menu.addAction(itemIcon, \"item {}\".format(i + 1))\n a.setObjectName(\"item {}\".format(i + 1))\n act = self.createAction(\"test 1\", \"res/test1.svg\")", "score": 0.8717396259307861 } ]

[ { "filename": "pyqt/PyRibbon/QxRibbonPage.py", "retrieved_chunk": " if item.isEmpty():\n if item.m_separator:\n item.m_separator.hide()\n item.m_groupWillGeometry = QRect(0, 0, 0, 0)\n item.m_separatorWillGeometry = QRect(0, 0, 0, 0)\n continue\n group = item.m_group\n if not group:\n print(\"unknow widget in RibbonPageLayout\")\n continue", "score": 0.874558687210083 }, { "filename": "pyqt/PyRibbon/QxRibbonGroup.py", "retrieved_chunk": " Auto = 0\n Large = 1\n Medium = 2\n Small = 3\n actionTriggered = pyqtSignal(QAction)\n s_groupTitleHeight = 21\nclass RibbonGroupItem(QWidgetItem):\n def __init__(self, parent):\n super().__init__(parent)\n self.action: QAction = None", "score": 0.8564708232879639 }, { "filename": "pyqt/PyRibbon/QxRibbonGroup.py", "retrieved_chunk": " return i\n return -1\n def addItem(self, item: QLayoutItem):\n print(\"Warning: RibbonGroupLayout::addItem(): please use addAction() instead\");\n def insertAction(self, index: int, act: QAction, rp=RibbonGroup.Auto):\n index = max(0, index)\n index = min(len(self.m_items), index)\n item = self._createItem(act, rp)\n if item:\n self.m_items.insert(index, item)", "score": 0.8551090955734253 }, { "filename": "pyqt/PyRibbon/QxRibbonGroup.py", "retrieved_chunk": " return btn\n def addLargeActionMenu(self, action: QAction, menu: QMenu) -> RibbonButton:\n return self.addActionMenu(action, menu, RibbonGroup.Large)\n def addWidget(self, w: QWidget, rp: int) -> QAction:\n # FIXME: using QWidgetAction will cause defaultWidget to be deleted by python gc\n action = QWidgetAction(self)\n action.setDefaultWidget(w)\n w.setAttribute(Qt.WA_Hover)\n RibbonGroup.setActionRowProportionProperty(action, rp)\n super().addAction(action)", "score": 0.8523971438407898 }, { "filename": "pyqt/PyRibbon/QxRibbonGroup.py", "retrieved_chunk": " if isinstance(action, QWidgetAction):\n widgetAction: QWidgetAction = action\n if widgetAction.parent() != self:\n widgetAction.setParent(self)\n index = self.layout().count()\n if event.before():\n index = self.m_layout.indexOf(action)\n if index == -1:\n index = self.layout().count()\n self.m_layout.insertAction(index, action, RibbonGroup.getActionRowProportionProperty(action))", "score": 0.8509024381637573 } ]

[ { "filename": "pyqt/PyRibbon/QxRibbonGroup.py", "retrieved_chunk": "from .QxRibbonGallery import RibbonGallery\nfrom . import QxRibbonRes_rc\nQX_RIBBON_PROP_ROW_PROPORTION = \"_qx_RibbonGroupRowProportion\"\nclass RibbonGroupOptionButton(QToolButton):\n def __init__(self, parent=None):\n super().__init__(parent)\n self.setAutoRaise(True)\n self.setCheckable(False)\n self.setToolButtonStyle(Qt.ToolButtonIconOnly)\n self.setFixedSize(16, 16)", "score": 0.8857588768005371 }, { "filename": "pyqt/PyRibbon/QxRibbonControls.py", "retrieved_chunk": " super().__init__(parent)\nclass RibbonCheckBox(QCheckBox):\n def __init__(self, parent=None):\n super().__init__(parent)\nclass RibbonComboBox(QComboBox):\n def __init__(self, parent=None):\n super().__init__(parent)\nclass RibbonControlButton(QToolButton):\n def __init__(self, parent=None):\n super().__init__(parent)", "score": 0.8814467191696167 }, { "filename": "pyqt/PyRibbon/QxRibbonContainers.py", "retrieved_chunk": "#!/usr/bin/env python3\n# Copyright (c) 2023 maminjie <[email protected]>\n# SPDX-License-Identifier: GPL-3.0\nfrom PyQt5.QtCore import Qt, QSize\nfrom PyQt5.QtGui import QIcon\nfrom PyQt5.QtWidgets import QWidget, QHBoxLayout, QLabel, QSizePolicy\nclass RibbonCtrlContainer(QWidget):\n def __init__(self, parent=None):\n super().__init__(parent)\n self.m_widget = None", "score": 0.8791015148162842 }, { "filename": "pyqt/PyRibbon/QxRibbonWindow.py", "retrieved_chunk": "class RibbonWindow(QMainWindow):\n def __init__(self, parent=None, use_ribbon=True):\n super().__init__(parent)\n self.m_useRibbon = use_ribbon\n self.m_theme = RibbonWindow.Office2013Theme\n self.m_ribbonBar: RibbonBar = None\n self.m_windowButtonGroup: WindowButtonGroup = None\n self.m_framelessHelper: FramelessHelper = None\n if self.m_useRibbon:\n self.setRibbonTheme(self.ribbonTheme())", "score": 0.8780995011329651 }, { "filename": "pyqt/PyRibbon/QxRibbonControls.py", "retrieved_chunk": "class RibbonLineEdit(QLineEdit):\n def __init__(self, parent=None):\n super().__init__(parent)\nclass RibbonMenu(QMenu):\n def __init__(self, *args):\n \"\"\"\n RibbonMenu(parent=None)\n RibbonMenu(title: str, parent=None)\n \"\"\"\n parent = None", "score": 0.8747355937957764 } ]

[ { "filename": "pyqt/PyRibbon/QxRibbonPage.py", "retrieved_chunk": " return self.m_group is None\nclass RibbonPageScrollButton(QToolButton):\n def __init__(self, arr: int, parent=None):\n super().__init__(parent)\n self.setArrowType(arr)\nclass RibbonPage(QWidget):\n def __init__(self, parent=None):\n super().__init__(parent)\n self.m_groupLayoutMode = RibbonGroup.ThreeRowMode\n self.m_itemList: List[RibbonPageItem] = list()", "score": 0.8952310085296631 }, { "filename": "pyqt/PyRibbon/QxRibbonGroup.py", "retrieved_chunk": "from .QxRibbonGallery import RibbonGallery\nfrom . import QxRibbonRes_rc\nQX_RIBBON_PROP_ROW_PROPORTION = \"_qx_RibbonGroupRowProportion\"\nclass RibbonGroupOptionButton(QToolButton):\n def __init__(self, parent=None):\n super().__init__(parent)\n self.setAutoRaise(True)\n self.setCheckable(False)\n self.setToolButtonStyle(Qt.ToolButtonIconOnly)\n self.setFixedSize(16, 16)", "score": 0.8892421722412109 }, { "filename": "pyqt/PyRibbon/QxRibbonBar.py", "retrieved_chunk": "class _RibbonTabData:\n def __init__(self):\n self.page: RibbonPage = None\n self.index: int = -1\nclass RibbonBar(QMenuBar):\n def __init__(self, parent=None):\n super().__init__(parent)\n self.m_iconRightBorderPosition: int = 1\n self.m_minimumPageButton: RibbonControlButton = None\n self.m_rightButtonGroup: RibbonButtonGroup = None", "score": 0.8851053714752197 }, { "filename": "pyqt/PyRibbon/QxRibbonWindow.py", "retrieved_chunk": "class RibbonWindow(QMainWindow):\n def __init__(self, parent=None, use_ribbon=True):\n super().__init__(parent)\n self.m_useRibbon = use_ribbon\n self.m_theme = RibbonWindow.Office2013Theme\n self.m_ribbonBar: RibbonBar = None\n self.m_windowButtonGroup: WindowButtonGroup = None\n self.m_framelessHelper: FramelessHelper = None\n if self.m_useRibbon:\n self.setRibbonTheme(self.ribbonTheme())", "score": 0.8841116428375244 }, { "filename": "pyqt/PyRibbon/QxRibbonPage.py", "retrieved_chunk": " self.m_sizeHint = QSize(50, 50)\n self.m_contentsMargins = QMargins(1, 1, 1, 1)\n self.m_totalWidth = 0\n self.m_XBase = 0\n self.m_isRightScrollBtnShow = False\n self.m_isLeftScrollBtnShow = False\n self.m_isPageContext = False\n self.m_isCanCustomize = True\n self.m_leftScrollBtn = RibbonPageScrollButton(Qt.LeftArrow, self)\n self.m_rightScrollBtn = RibbonPageScrollButton(Qt.RightArrow, self)", "score": 0.8793072700500488 } ]

[ { "filename": "pyqt/demo/RibbonDemo.py", "retrieved_chunk": " buttonGroup2.addAction(self.createAction(\"center alignment\", \"res/al-center.svg\"))\n buttonGroup2.addAction(self.createAction(\"right alignment\", \"res/al-right.svg\"))\n buttonGroup2.addAction(self.createAction(\"line up on both sides\", \"res/al-bothside.svg\"))\n act = group.addWidget(buttonGroup2, RibbonGroup.Medium)\n act.setObjectName(buttonGroup2.objectName())\n group.addSeparator()\n actLargerFontSize = self.createAction(\"Larger\", \"res/largerFont.svg\", \"actLargerFontSize\")\n actLargerFontSize.triggered.connect(self.onActionFontLargerTriggered)\n group.addLargeAction(actLargerFontSize)\n actSmallFontSize = self.createAction(\"Smaller\", \"res/smallFont.svg\", \"actSmallFontSize\")", "score": 0.849148690700531 }, { "filename": "pyqt/demo/RibbonDemo.py", "retrieved_chunk": " QToolButton.InstantPopup, RibbonGroup.Large)\n groupLayout.addAction(self.createAction(\"Medium\", \"res/layout.svg\", \"@Medium5\"),\n QToolButton.InstantPopup, RibbonGroup.Large)\n groupLayout.addAction(self.createAction(\"Large\", \"res/layout.svg\", \"@Large4\"),\n QToolButton.InstantPopup, RibbonGroup.Large)\n groupLayout.addSeparator()\n groupLayout.addAction(self.createAction(\"Medium\", \"res/layout.svg\", \"@Medium6\"),\n QToolButton.InstantPopup, RibbonGroup.Medium)\n groupLayout.addAction(self.createAction(\"Large\", \"res/layout.svg\", \"@Large5\"),\n QToolButton.InstantPopup, RibbonGroup.Large)", "score": 0.8460549116134644 }, { "filename": "pyqt/demo/RibbonDemo.py", "retrieved_chunk": " buttonGroup1.addAction(self.createAction(\"Decrease Margin\", \"res/Decrease-Margin.svg\"))\n buttonGroup1.addAction(self.createAction(\"Decrease Indent\", \"res/Decrease-Indent.svg\"))\n buttonGroup1.addAction(self.createAction(\"Wrap Image Left\", \"res/Wrap-Image Left.svg\"))\n buttonGroup1.addAction(self.createAction(\"Wrap Image Right\", \"res/Wrap-Image Right.svg\"))\n group1.addWidget(buttonGroup1, RibbonGroup.Medium)\n buttonGroup2 = RibbonButtonGroup(group1)\n titleAlignment = self.createAction(\"Align Right\", \"res/Align-Right.svg\")\n titleAlignment.setProperty(\"align\", int(Qt.AlignRight | Qt.AlignVCenter))\n buttonGroup2.addAction(titleAlignment)\n titleAlignment = self.createAction(\"Align Left\", \"res/Align-Left.svg\")", "score": 0.8403785228729248 }, { "filename": "pyqt/demo/RibbonDemo.py", "retrieved_chunk": " fontComWidget.currentFontChanged.connect(self.onFontComWidgetCurrentFontChanged)\n buttonGroup1.addWidget(fontComWidget)\n act = group.addWidget(buttonGroup1, RibbonGroup.Medium)\n act.setObjectName(buttonGroup1.objectName())\n buttonGroup2 = RibbonButtonGroup(group)\n buttonGroup2.setObjectName(\"button group2\")\n buttonGroup2.addAction(self.createAction(\"Bold\", \"res/bold.svg\"))\n buttonGroup2.addAction(self.createAction(\"Italic\", \"res/Italic.svg\"))\n buttonGroup2.addSeparator()\n buttonGroup2.addAction(self.createAction(\"Left alignment\", \"res/al-left.svg\"))", "score": 0.8399878740310669 }, { "filename": "pyqt/demo/RibbonDemo.py", "retrieved_chunk": " g.addButton(r, RibbonBar.WpsLiteStyleTwoRow)\n groupStyle.addSmallWidget(r)\n g.buttonClicked[int].connect(self.onStyleClicked)\n groupToolButtonStyle = page.addGroup(\"ribobn toolbutton style\")\n menu = RibbonMenu(self)\n itemIcon = QIcon(\"res/item.svg\")\n for i in range(5):\n a = menu.addAction(itemIcon, \"item {}\".format(i + 1))\n a.setObjectName(\"item {}\".format(i + 1))\n act = self.createAction(\"test 1\", \"res/test1.svg\")", "score": 0.8387415409088135 } ]

[ { "filename": "pyqt/PyRibbon/QxRibbonGroup.py", "retrieved_chunk": "from .QxRibbonGallery import RibbonGallery\nfrom . import QxRibbonRes_rc\nQX_RIBBON_PROP_ROW_PROPORTION = \"_qx_RibbonGroupRowProportion\"\nclass RibbonGroupOptionButton(QToolButton):\n def __init__(self, parent=None):\n super().__init__(parent)\n self.setAutoRaise(True)\n self.setCheckable(False)\n self.setToolButtonStyle(Qt.ToolButtonIconOnly)\n self.setFixedSize(16, 16)", "score": 0.8904858231544495 }, { "filename": "pyqt/PyRibbon/QxRibbonContainers.py", "retrieved_chunk": "#!/usr/bin/env python3\n# Copyright (c) 2023 maminjie <[email protected]>\n# SPDX-License-Identifier: GPL-3.0\nfrom PyQt5.QtCore import Qt, QSize\nfrom PyQt5.QtGui import QIcon\nfrom PyQt5.QtWidgets import QWidget, QHBoxLayout, QLabel, QSizePolicy\nclass RibbonCtrlContainer(QWidget):\n def __init__(self, parent=None):\n super().__init__(parent)\n self.m_widget = None", "score": 0.8856526017189026 }, { "filename": "pyqt/PyRibbon/QxRibbonWindow.py", "retrieved_chunk": "class RibbonWindow(QMainWindow):\n def __init__(self, parent=None, use_ribbon=True):\n super().__init__(parent)\n self.m_useRibbon = use_ribbon\n self.m_theme = RibbonWindow.Office2013Theme\n self.m_ribbonBar: RibbonBar = None\n self.m_windowButtonGroup: WindowButtonGroup = None\n self.m_framelessHelper: FramelessHelper = None\n if self.m_useRibbon:\n self.setRibbonTheme(self.ribbonTheme())", "score": 0.8847045302391052 }, { "filename": "pyqt/PyRibbon/QxRibbonControls.py", "retrieved_chunk": " super().__init__(parent)\nclass RibbonCheckBox(QCheckBox):\n def __init__(self, parent=None):\n super().__init__(parent)\nclass RibbonComboBox(QComboBox):\n def __init__(self, parent=None):\n super().__init__(parent)\nclass RibbonControlButton(QToolButton):\n def __init__(self, parent=None):\n super().__init__(parent)", "score": 0.8844826221466064 }, { "filename": "pyqt/PyRibbon/QxRibbonControls.py", "retrieved_chunk": "#!/usr/bin/env python3\n# Copyright (c) 2023 maminjie <[email protected]>\n# SPDX-License-Identifier: GPL-3.0\nfrom typing import Union\nfrom PyQt5.QtCore import QSize, QPoint\nfrom PyQt5.QtGui import QPaintEvent, QPainter\nfrom PyQt5.QtWidgets import QWidget, QCheckBox, QComboBox, QToolButton, \\\n QLineEdit, QMenu, QAction, QSizePolicy, QWidgetAction\nclass RibbonControl(QWidget):\n def __init__(self, parent=None):", "score": 0.8784869909286499 } ]

[ { "filename": "pyqt/PyRibbon/QxRibbonGroup.py", "retrieved_chunk": " sep = RibbonSeparator(group)\n widget = sep\n if not widget:\n buttonType = RibbonButton.LargeButton if rp == RibbonGroup.Large else RibbonButton.SmallButton\n button = RibbonButton(group)\n button.setAutoRaise(True)\n button.setFocusPolicy(Qt.NoFocus)\n button.setButtonType(buttonType)\n if RibbonButton.LargeButton == buttonType:\n button.setLargeButtonType(RibbonButton.Lite if group.isTwoRow() else RibbonButton.Normal)", "score": 0.8500816822052002 }, { "filename": "pyqt/PyRibbon/QxRibbonGroup.py", "retrieved_chunk": " Auto = 0\n Large = 1\n Medium = 2\n Small = 3\n actionTriggered = pyqtSignal(QAction)\n s_groupTitleHeight = 21\nclass RibbonGroupItem(QWidgetItem):\n def __init__(self, parent):\n super().__init__(parent)\n self.action: QAction = None", "score": 0.8500593900680542 }, { "filename": "pyqt/PyRibbon/QxRibbonPage.py", "retrieved_chunk": " if item.isEmpty():\n if item.m_separator:\n item.m_separator.hide()\n item.m_groupWillGeometry = QRect(0, 0, 0, 0)\n item.m_separatorWillGeometry = QRect(0, 0, 0, 0)\n continue\n group = item.m_group\n if not group:\n print(\"unknow widget in RibbonPageLayout\")\n continue", "score": 0.8475693464279175 }, { "filename": "pyqt/PyRibbon/QxRibbonButton.py", "retrieved_chunk": " menu.addAction(QIcon(\"res/logo.png\"), '2')\n menu.addAction(QIcon(\"res/logo.png\"), '3')\n # act = QAction('Test', mainWindow)\n btn = RibbonButton(mainWindow)\n btn.setFocusPolicy(Qt.NoFocus)\n # btn.setButtonType(RibbonButton.SmallButton)\n btn.setButtonType(RibbonButton.LargeButton)\n btn.setLargeButtonType(RibbonButton.Normal)\n # btn.setDefaultAction(act)\n btn.setMenu(menu)", "score": 0.8447046279907227 }, { "filename": "pyqt/demo/RibbonDemo.py", "retrieved_chunk": " buttonGroup1.addAction(self.createAction(\"Decrease Margin\", \"res/Decrease-Margin.svg\"))\n buttonGroup1.addAction(self.createAction(\"Decrease Indent\", \"res/Decrease-Indent.svg\"))\n buttonGroup1.addAction(self.createAction(\"Wrap Image Left\", \"res/Wrap-Image Left.svg\"))\n buttonGroup1.addAction(self.createAction(\"Wrap Image Right\", \"res/Wrap-Image Right.svg\"))\n group1.addWidget(buttonGroup1, RibbonGroup.Medium)\n buttonGroup2 = RibbonButtonGroup(group1)\n titleAlignment = self.createAction(\"Align Right\", \"res/Align-Right.svg\")\n titleAlignment.setProperty(\"align\", int(Qt.AlignRight | Qt.AlignVCenter))\n buttonGroup2.addAction(titleAlignment)\n titleAlignment = self.createAction(\"Align Left\", \"res/Align-Left.svg\")", "score": 0.8441475033760071 } ]

[ { "filename": "pyqt/PyRibbon/QxRibbonGroup.py", "retrieved_chunk": " sep = RibbonSeparator(group)\n widget = sep\n if not widget:\n buttonType = RibbonButton.LargeButton if rp == RibbonGroup.Large else RibbonButton.SmallButton\n button = RibbonButton(group)\n button.setAutoRaise(True)\n button.setFocusPolicy(Qt.NoFocus)\n button.setButtonType(buttonType)\n if RibbonButton.LargeButton == buttonType:\n button.setLargeButtonType(RibbonButton.Lite if group.isTwoRow() else RibbonButton.Normal)", "score": 0.851563036441803 }, { "filename": "pyqt/PyRibbon/QxRibbonGroup.py", "retrieved_chunk": " return btn\n def addLargeActionMenu(self, action: QAction, menu: QMenu) -> RibbonButton:\n return self.addActionMenu(action, menu, RibbonGroup.Large)\n def addWidget(self, w: QWidget, rp: int) -> QAction:\n # FIXME: using QWidgetAction will cause defaultWidget to be deleted by python gc\n action = QWidgetAction(self)\n action.setDefaultWidget(w)\n w.setAttribute(Qt.WA_Hover)\n RibbonGroup.setActionRowProportionProperty(action, rp)\n super().addAction(action)", "score": 0.8459206819534302 }, { "filename": "pyqt/PyRibbon/QxRibbonGroup.py", "retrieved_chunk": " Auto = 0\n Large = 1\n Medium = 2\n Small = 3\n actionTriggered = pyqtSignal(QAction)\n s_groupTitleHeight = 21\nclass RibbonGroupItem(QWidgetItem):\n def __init__(self, parent):\n super().__init__(parent)\n self.action: QAction = None", "score": 0.840175449848175 }, { "filename": "pyqt/demo/RibbonDemo.py", "retrieved_chunk": " g.addButton(r, RibbonBar.WpsLiteStyleTwoRow)\n groupStyle.addSmallWidget(r)\n g.buttonClicked[int].connect(self.onStyleClicked)\n groupToolButtonStyle = page.addGroup(\"ribobn toolbutton style\")\n menu = RibbonMenu(self)\n itemIcon = QIcon(\"res/item.svg\")\n for i in range(5):\n a = menu.addAction(itemIcon, \"item {}\".format(i + 1))\n a.setObjectName(\"item {}\".format(i + 1))\n act = self.createAction(\"test 1\", \"res/test1.svg\")", "score": 0.837626576423645 }, { "filename": "pyqt/PyRibbon/QxRibbonGallery.py", "retrieved_chunk": " self.m_buttonMore.setIcon(QIcon(':/image/res/ArrowMore.png'))\n self.m_buttonMore.clicked.connect(self.showMoreDetail)\n self.triggered.connect(self.onTriggered)\n self.m_popupWidget: RibbonGalleryViewport = None\n self.m_viewportGroup: RibbonGalleryGroup = None\n self.m_btnLayout = QBoxLayout(QBoxLayout.TopToBottom)\n self.m_btnLayout.setSpacing(0)\n self.m_btnLayout.setContentsMargins(0, 0, 0, 0)\n self.m_btnLayout.addWidget(self.m_buttonUp)\n self.m_btnLayout.addWidget(self.m_buttonDown)", "score": 0.8337386846542358 } ]

[ { "filename": "main_selfplay_test.py", "retrieved_chunk": "from ppo.ppo_policy import PPOPolicy\nfrom ppo.ppo_data_collectors import BaseDataCollector, SelfPlayDataCollector, make_env\nfrom config import get_config\nimport envs\nimport wandb\ndef main(args):\n parser = get_config()\n all_args = parser.parse_known_args(args)[0]\n all_args.buffer_size = 1000\n all_args.env_name = 'SumoAnts-v0'", "score": 0.8789619207382202 }, { "filename": "main_selfplay_test.py", "retrieved_chunk": " all_args.eval_episodes = 1\n all_args.num_env_steps = 1e6\n all_args.num_mini_batch = 1\n all_args.ppo_epoch = 4\n all_args.cuda = True\n all_args.lr = 1e-4\n # all_args.use_risk_sensitive = True\n all_args.use_gae = True\n all_args.tau = 0.5\n all_args.seed = 0", "score": 0.8619175553321838 }, { "filename": "main_pbt_selfplay.py", "retrieved_chunk": " population_elos = {}\n population_hypers = {}\n for agent_id in range(all_args.population_size):\n population[agent_id] = PPOPolicy(all_args, env.observation_space, env.action_space)\n if all_args.model_dir is not None:\n population[agent_id].restore_from_path(all_args.model_dir, epoch='latest')\n params = population[agent_id].params()\n torch.save(params, f'{save_dir}/agent{agent_id}_history0.pt')\n torch.save(params, f'{save_dir}/agent{agent_id}_latest.pt')\n population_elos[agent_id] = {0: all_args.init_elo}", "score": 0.8607075810432434 }, { "filename": "ppo/ppo_data_collectors.py", "retrieved_chunk": " self.buffer_size = args.buffer_size\n self.num_agents = getattr(self.env, 'num_agents', 1)\n self.random_side = args.random_side\n self.buffer = PPOBuffer(args, self.num_agents, self.env.observation_space, self.env.action_space)\n self.ego = PPOPolicy(args, self.env.observation_space, self.env.action_space)\n def collect_data(self, ego_params, hyper_params={}):\n self.buffer.clear()\n if 'tau' in hyper_params:\n self.buffer.tau = hyper_params['tau'] \n if 'reward' in hyper_params:", "score": 0.8543789386749268 }, { "filename": "ppo/ppo_data_collectors.py", "retrieved_chunk": " return self.env.reset()\n def step(self, action):\n return self.env.step(action)\nclass SelfPlayDataCollector(BaseDataCollector):\n def __init__(self, args):\n super().__init__(args)\n self.enm = PPOPolicy(args, self.env.observation_space, self.env.action_space)\n self.num_agents = self.num_agents // 2\n self.buffer = PPOBuffer(args, self.num_agents, self.env.observation_space, self.env.action_space)\n def collect_data(self, ego_params, enm_params, hyper_params={}):", "score": 0.8525525331497192 } ]

[ { "filename": "main_pbt_selfplay.py", "retrieved_chunk": " population_elos = {}\n population_hypers = {}\n for agent_id in range(all_args.population_size):\n population[agent_id] = PPOPolicy(all_args, env.observation_space, env.action_space)\n if all_args.model_dir is not None:\n population[agent_id].restore_from_path(all_args.model_dir, epoch='latest')\n params = population[agent_id].params()\n torch.save(params, f'{save_dir}/agent{agent_id}_history0.pt')\n torch.save(params, f'{save_dir}/agent{agent_id}_latest.pt')\n population_elos[agent_id] = {0: all_args.init_elo}", "score": 0.8475120663642883 }, { "filename": "render/render_sumoant.py", "retrieved_chunk": "ego_path = \"\"\nenm_path = \"\"\nego_policy.restore_from_params(torch.load(ego_dir+ego_path))\nenm_policy.restore_from_params(torch.load(enm_dir+enm_path))\nif render_video == True:\n env = RecordVideo(env, video_folder=\"render/render_videos\", name_prefix=f\"0.1vs0.9\")\nenv.seed(0)\nprint(\"Start render\")\nobs = env.reset()\nstep = 0", "score": 0.8442414999008179 }, { "filename": "main_pbt_selfplay.py", "retrieved_chunk": " buffer=buffers[agent_id], \n params=ego_model, \n hyper_params=population_hypers[agent_id]\n )\n train_results.append(res)\n train_infos = [ray.get(train_results[i]) for i in range(N)]\n for agent_id, (param, info) in enumerate(train_infos):\n population[agent_id].restore_from_params(param)\n torch.save(param, f'{save_dir}/agent{agent_id}_history{epoch+1}.pt')\n torch.save(param, f'{save_dir}/agent{agent_id}_latest.pt')", "score": 0.8438429832458496 }, { "filename": "ppo/ppo_data_collectors.py", "retrieved_chunk": " self.buffer_size = args.buffer_size\n self.num_agents = getattr(self.env, 'num_agents', 1)\n self.random_side = args.random_side\n self.buffer = PPOBuffer(args, self.num_agents, self.env.observation_space, self.env.action_space)\n self.ego = PPOPolicy(args, self.env.observation_space, self.env.action_space)\n def collect_data(self, ego_params, hyper_params={}):\n self.buffer.clear()\n if 'tau' in hyper_params:\n self.buffer.tau = hyper_params['tau'] \n if 'reward' in hyper_params:", "score": 0.8377060890197754 }, { "filename": "main_pbt_selfplay.py", "retrieved_chunk": " \"population_elos\": population_elos,\n \"population_hypers\": population_hypers\n }\n if all_args.use_wandb:\n for agent_id in range(N):\n wandb.log({f\"agent{agent_id}_tau\": population_hypers[agent_id]['tau']}, step=cur_steps)\n wandb.log({f\"agent{agent_id}_elo\": population_elos[agent_id][epoch]}, step=cur_steps)\n torch.save(checkpoint, f\"{save_dir}/checkpoint_latest.pt\")\nif __name__ == \"__main__\":\n main(sys.argv[1:])", "score": 0.8340445756912231 } ]

[ { "filename": "ppo/ppo_data_collectors.py", "retrieved_chunk": " obs = self.reset()\n rnn_states_actor = np.zeros((self.num_agents, self.recurrent_hidden_layers, self.recurrent_hidden_size))\n masks = np.ones((self.num_agents, 1))\n step = 0\n while True:\n action, rnn_states_actor = self.ego.act(obs, rnn_states_actor, masks)\n action = _t2n(action)\n rnn_states_actor = _t2n(rnn_states_actor)\n obs, reward, done, info = self.step(action)\n step += 1", "score": 0.9005708694458008 }, { "filename": "ppo/ppo_data_collectors.py", "retrieved_chunk": " self.ego_side = 0\n self.enm_rnn_states_actor = np.zeros((self.num_agents, self.recurrent_hidden_layers, self.recurrent_hidden_size))\n self.enm_masks = np.ones((self.num_agents, 1))\n obs = super().reset()\n return self._parse_obs(obs)\n def step(self, action):\n enm_action, enm_rnn_states_actor = self.enm.act(self.enm_obs, self.enm_rnn_states_actor, self.enm_masks)\n enm_action = _t2n(enm_action)\n self.enm_rnn_states_actor = _t2n(enm_rnn_states_actor)\n actions = np.concatenate((action, enm_action), axis=0)", "score": 0.876121997833252 }, { "filename": "toyexample/rppo.py", "retrieved_chunk": " for update in range(1, num_updates + 1):\n for step in range(0, args.num_steps):\n global_step += 1\n obs[step] = next_obs\n dones[step] = next_done\n # ALGO LOGIC: action logic\n with torch.no_grad():\n action, logprob, _, value = agent.get_action_and_value(next_obs)\n values[step] = value.flatten()\n actions[step] = action", "score": 0.864743709564209 }, { "filename": "ppo/ppo_data_collectors.py", "retrieved_chunk": " rnn_states_actor = np.zeros((self.num_agents, self.recurrent_hidden_layers, self.recurrent_hidden_size))\n rnn_states_critic = np.zeros((self.num_agents, self.recurrent_hidden_layers, self.recurrent_hidden_size))\n masks = np.zeros((self.num_agents, 1), dtype=np.float32)\n else:\n masks = np.ones((self.num_agents, 1), dtype=np.float32)\n # 3. insert experience in buffer\n self.buffer.insert(obs, actions, rewards, masks, action_log_probs, values, rnn_states_actor, rnn_states_critic)\n status_code = 0 if step > 0 else 1\n last_value = self.ego.get_values(self.buffer.obs[-1], self.buffer.rnn_states_critic[-1], self.buffer.masks[-1])\n self.buffer.compute_returns(_t2n(last_value))", "score": 0.856896162033081 }, { "filename": "toyexample/eval.py", "retrieved_chunk": " for _ in range(num_rollouts):\n state = env.reset()\n episode_reward = 0\n water_times = 0\n step = 0\n while True:\n act = policy.get_action(torch.from_numpy(np.expand_dims(state, axis=0)).to(**tpdv))\n state, reward, done, info = env.step(act.item())\n episode_reward += reward\n water_times += 1 if reward == -1 else 0", "score": 0.8511630296707153 } ]

[ { "filename": "src/client/penvm/client/world.py", "retrieved_chunk": "import threading\nimport time\nimport traceback\nfrom typing import Any, Callable, Dict, List, Tuple, Type, Union\nfrom penvm.client.config import WorldConfig\nfrom penvm.client.machine import Machine\nfrom penvm.lib.base import BaseObject\nfrom penvm.lib.misc import MachineConnectionSpec, get_uuid, get_version_string\nlogger = logging.getLogger(__name__)\nclass World(BaseObject):", "score": 0.8490337133407593 }, { "filename": "src/client/penvm/client/world.py", "retrieved_chunk": "#\n# penvm/client/world.py\n# PENVM\n#\n# Copyright 2023 J4M Solutions\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#", "score": 0.8448887467384338 }, { "filename": "src/tools/penvm-win/penvmwin.py", "retrieved_chunk": "import os\nimport os.path\nimport subprocess\nimport sys\nimport tempfile\nimport time\nimport traceback\nfrom typing import Any, Callable, Dict, List, Tuple, Type, Union\nfrom penvm.client.world import World\nHEREFILE = os.path.abspath(sys.argv[0])", "score": 0.8335403203964233 }, { "filename": "src/tools/penvm-connect/penvmconnect.py", "retrieved_chunk": "import code\nimport os.path\nimport sys\nfrom typing import Any, Callable, Dict, List, Tuple, Type, Union\nfrom penvm.client.world import World\ndef print_usage():\n progname = os.path.basename(sys.argv[0])\n print(\n f\"\"\"\\\nusage: {progname} [<networkstr>]", "score": 0.8053870797157288 }, { "filename": "src/lib/penvm/lib/thread.py", "retrieved_chunk": "#\n# penvm/lib/thread.py\n# PENVM\n#\n# Copyright 2023 J4M Solutions\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#", "score": 0.7972629070281982 } ]

[ { "filename": "main_selfplay_test.py", "retrieved_chunk": "from ppo.ppo_policy import PPOPolicy\nfrom ppo.ppo_data_collectors import BaseDataCollector, SelfPlayDataCollector, make_env\nfrom config import get_config\nimport envs\nimport wandb\ndef main(args):\n parser = get_config()\n all_args = parser.parse_known_args(args)[0]\n all_args.buffer_size = 1000\n all_args.env_name = 'SumoAnts-v0'", "score": 0.8430884480476379 }, { "filename": "main_selfplay_test.py", "retrieved_chunk": " torch.save(trainer.policy.params(), f\"{save_dir}/agent_0.pt\")\n num_epochs = int(all_args.num_env_steps // all_args.buffer_size)\n for epoch in range(num_epochs):\n # train\n params = torch.load(f\"{str(save_dir)}/agent_{epoch}.pt\")\n buffer = collector.collect_data(ego_params=params, enm_params=params, hyper_params={'tau':0.5})\n params, train_info = trainer.train(params=params, buffer=buffer)\n # eval and record info\n elo_gain, eval_info = collector.evaluate_data(ego_params=params, enm_params=params)\n cur_steps = (epoch + 1) * all_args.buffer_size", "score": 0.8402978181838989 }, { "filename": "ppo/ppo_data_collectors.py", "retrieved_chunk": " return self.env.reset()\n def step(self, action):\n return self.env.step(action)\nclass SelfPlayDataCollector(BaseDataCollector):\n def __init__(self, args):\n super().__init__(args)\n self.enm = PPOPolicy(args, self.env.observation_space, self.env.action_space)\n self.num_agents = self.num_agents // 2\n self.buffer = PPOBuffer(args, self.num_agents, self.env.observation_space, self.env.action_space)\n def collect_data(self, ego_params, enm_params, hyper_params={}):", "score": 0.8283082246780396 }, { "filename": "main_selfplay_test.py", "retrieved_chunk": " all_args.eval_episodes = 1\n all_args.num_env_steps = 1e6\n all_args.num_mini_batch = 1\n all_args.ppo_epoch = 4\n all_args.cuda = True\n all_args.lr = 1e-4\n # all_args.use_risk_sensitive = True\n all_args.use_gae = True\n all_args.tau = 0.5\n all_args.seed = 0", "score": 0.8274572491645813 }, { "filename": "ppo/ppo_data_collectors.py", "retrieved_chunk": " self.buffer_size = args.buffer_size\n self.num_agents = getattr(self.env, 'num_agents', 1)\n self.random_side = args.random_side\n self.buffer = PPOBuffer(args, self.num_agents, self.env.observation_space, self.env.action_space)\n self.ego = PPOPolicy(args, self.env.observation_space, self.env.action_space)\n def collect_data(self, ego_params, hyper_params={}):\n self.buffer.clear()\n if 'tau' in hyper_params:\n self.buffer.tau = hyper_params['tau'] \n if 'reward' in hyper_params:", "score": 0.8266037106513977 } ]

[ { "filename": "src/uiInitilalizer.py", "retrieved_chunk": " self.loadUI(currentEffect)\n def loadUI(self, effect):\n palette = self.getColors(effect)\n self.editPalette.loadPalette(palette)\n def getColors(self, effect):\n hsbColors = effect['write']['palette']\n palette = []\n for color in hsbColors:\n palette.append(colorConverter.HSBtoHEX(color['hue'], color['saturation'], color['brightness']))\n if len(palette) > 3:", "score": 0.8232254981994629 }, { "filename": "src/filemanager.py", "retrieved_chunk": " with open(File.EFFECTS.value, 'w') as effectsFile:\n json.dump(effects, effectsFile, indent=4)", "score": 0.8125982880592346 }, { "filename": "src/ui_AnnotatedSlider.py", "retrieved_chunk": " self.effectFactory.buildEffect()\n case 'Brightness:':\n if self.lightController is not None:\n self.lightController.setBrightness(self.slider.value)\n self.checkBox.set_value(True)", "score": 0.8042899370193481 }, { "filename": "src/uiInitilalizer.py", "retrieved_chunk": "from filemanager import Filemanager, File\nimport colorConverter\nclass UiInitilalizer:\n def __init__(self, effectOptionsTab, editPalette, secondaryColorCheckbox, secondaryColorInput):\n self.effectOptionsTab = effectOptionsTab\n self.editPalette = editPalette\n self.secondaryColorCheckbox = secondaryColorCheckbox\n self.secondaryColorInput = secondaryColorInput\n currentEffect = Filemanager.getValue(File.EFFECTS, \"current_effect\")\n if currentEffect is not None:", "score": 0.8024517297744751 }, { "filename": "src/ui_EffectOptionsTab.py", "retrieved_chunk": " self.nColorsPerFrame = Ui_AnnotatedSlider(min=2, max=10, value=2, description='n Colors per frame:', effectFactory=self.effectFactory)\n self.info = ui.label('No further settings available for this effect.').style('margin-top: -20%;')\n self.setEffect('Random')\n def setEffect(self, effect):\n self.currentEffect.set_text(effect)\n self.hideOptions()\n self.effectFactory.pluginType, effect = self.getEffectProps(effect)\n self.effectFactory.currentEffect = effect\n props = effect[1]\n if 'delayTime' in props:", "score": 0.7941300868988037 } ]

[ { "filename": "src/kernels/penvm/kernels/default/client.py", "retrieved_chunk": " return self.session.newput_request(\"store-get\", d)\n def store_get_state(self):\n \"\"\"See [penvm.kernels.default.server.StoreGetState][].\"\"\"\n return self.session.newput_request(\"store-get-state\")\n def store_list(self, pattern=None):\n \"\"\"See [penvm.kernels.default.server.StoreList][].\"\"\"\n d = {}\n if pattern:\n d[\"pattern\"] = pattern\n return self.session.newput_request(\"store-list\", d)", "score": 0.8637896180152893 }, { "filename": "src/kernels/penvm/kernels/core/server.py", "retrieved_chunk": "from penvm.lib.message import ErrorResponse, OkResponse, Payload, Request\nfrom penvm.lib.thread import ThreadInterrupt\nlogger = logging.getLogger(__name__)\nclass ConnectionGetState(Op):\n \"\"\"Get connection info.\n Attributes: Request:\n connection-id (str): Connection id.\n Attributes: OkResponse:\n connection-id (str): Connection id.\n initial-connection (str): Is initial machine connection.", "score": 0.8321065902709961 }, { "filename": "src/kernels/penvm/kernels/default/client.py", "retrieved_chunk": " \"\"\"See [penvm.kernels.default.server.StoreDrop][].\"\"\"\n d = {\n \"name\": name,\n }\n return self.session.newput_request(\"store-drop\", d)\n def store_get(self, name):\n \"\"\"See [penvm.kernels.default.server.StoreGet][].\"\"\"\n d = {\n \"name\": name,\n }", "score": 0.8144556879997253 }, { "filename": "src/kernels/penvm/kernels/core/server.py", "retrieved_chunk": " self.logger.error(f\"{e}\")\n self.logger.warning(f\"bad/missing sleep time ({seconds})\")\nclass Kernel(_Kernel):\n name = \"core\"\n def __init__(self):\n super().__init__()\n self.ops.update(\n {\n \"connection-get-state\": ConnectionGetState(),\n \"echo\": Echo(),", "score": 0.806441068649292 }, { "filename": "src/server/penvm/server/machine.py", "retrieved_chunk": " self.connmgr = ConnectionManager(self, host, port, self.sslcontext)\n self.kernelmgr = KernelManager(self)\n self.sessmgr = SessionManager(self)\n # self.storemgr = StorageManager(self)\n self.fkvstore = FileKVStore(f\"/tmp/penvm-store-{self.oid}-{get_uuid1()}\")\n for kernel_cls in [CoreKernel, DefaultKernel]:\n self.kernelmgr.set(kernel_cls.name, kernel_cls())\n self._background = False\n self.debug = False\n self.schedlock = threading.Lock()", "score": 0.8057481646537781 } ]

[ { "filename": "main_pbt_selfplay.py", "retrieved_chunk": " population_elos = {}\n population_hypers = {}\n for agent_id in range(all_args.population_size):\n population[agent_id] = PPOPolicy(all_args, env.observation_space, env.action_space)\n if all_args.model_dir is not None:\n population[agent_id].restore_from_path(all_args.model_dir, epoch='latest')\n params = population[agent_id].params()\n torch.save(params, f'{save_dir}/agent{agent_id}_history0.pt')\n torch.save(params, f'{save_dir}/agent{agent_id}_latest.pt')\n population_elos[agent_id] = {0: all_args.init_elo}", "score": 0.8717005848884583 }, { "filename": "main_pbt_selfplay.py", "retrieved_chunk": " torch.manual_seed(all_args.seed)\n torch.cuda.manual_seed(all_args.seed)\n tau_hyper = [float(tau) for tau in all_args.tau_list.split(' ')]\n reward_hyper = [float(r) for r in all_args.reward_list.split(' ')]\n setproctitle.setproctitle(str(all_args.env_name)+'@'+ str(all_args.user_name))\n env = make_env(all_args.env_name)\n str_time = time.strftime(\"%b%d-%H%M%S\", time.localtime())\n run_dir = Path(os.path.dirname(os.path.abspath(__file__))) / \"runs\" / all_args.env_name / all_args.experiment_name\n if not os.path.exists(run_dir):\n os.makedirs(run_dir)", "score": 0.8556603193283081 }, { "filename": "toyexample/rppo.py", "retrieved_chunk": " device = torch.device(\"cuda\" if torch.cuda.is_available() and args.cuda else \"cpu\")\n # env setup\n envs = make_env(args)\n assert isinstance(envs.action_space, gym.spaces.Discrete), \"only discrete action space is supported\"\n agent = Agent(envs.observation_space, envs.action_space).to(device)\n optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)\n # ALGO Logic: Storage setup\n obs = torch.zeros((args.num_steps, 1) + envs.observation_space.shape).to(device)\n actions = torch.zeros((args.num_steps, 1) + envs.action_space.shape).to(device)\n logprobs = torch.zeros((args.num_steps, 1)).to(device)", "score": 0.8507678508758545 }, { "filename": "toyexample/eval.py", "retrieved_chunk": " device = torch.device('cuda:0')\n tpdv = dict(dtype=torch.float32, device=device)\n env = toy.ToyEnv(wind=True, onehot_state=args.onehot_state)\n env.seed(seed)\n policy = Agent(env.observation_space, env.action_space).to(device)\n policy.restore(args.run_dir)\n ### state frequency\n state_freq = np.zeros(env.shape)\n episode_rewards = []\n violations = []", "score": 0.8431426286697388 }, { "filename": "render/render_sumoant.py", "retrieved_chunk": "num_agents = 2\nargs = sys.argv[1:]\nparser = get_config()\nall_args = parser.parse_known_args(args)[0]\nall_args.env_name = 'SumoAnts-v0'\nenv = make_env(all_args.env_name)\nego_policy = PPOPolicy(all_args, env.observation_space, env.action_space)\nenm_policy = PPOPolicy(all_args, env.observation_space, env.action_space)\nego_dir = \"\"\nenm_dir = \"\"", "score": 0.8366143107414246 } ]

[ { "filename": "src/effectFactory.py", "retrieved_chunk": " self.lightController.setColor(self.colorPalette[0])\n else:\n effectJson = copy.deepcopy(self.BASE_EFFECT)\n if self.secondaryColor is not None:\n secondaryH, secondaryS, secondaryB = colorConverter.HEXtoHSB(self.secondaryColor)\n for color in self.colorPalette:\n h, s, b = colorConverter.HEXtoHSB(color)\n effectJson['write']['palette'].append({\"hue\": h, \"saturation\": s, \"brightness\": b})\n if self.secondaryColor is not None:\n effectJson['write']['palette'].append({\"hue\": secondaryH, \"saturation\": secondaryS, \"brightness\": secondaryB})", "score": 0.8605074882507324 }, { "filename": "src/ui_EffectOptionsTab.py", "retrieved_chunk": " self.nColorsPerFrame = Ui_AnnotatedSlider(min=2, max=10, value=2, description='n Colors per frame:', effectFactory=self.effectFactory)\n self.info = ui.label('No further settings available for this effect.').style('margin-top: -20%;')\n self.setEffect('Random')\n def setEffect(self, effect):\n self.currentEffect.set_text(effect)\n self.hideOptions()\n self.effectFactory.pluginType, effect = self.getEffectProps(effect)\n self.effectFactory.currentEffect = effect\n props = effect[1]\n if 'delayTime' in props:", "score": 0.8512024879455566 }, { "filename": "src/ui_Structure.py", "retrieved_chunk": " Ui_Palette(palette, id, self.editPalette, self)\n def loadPaletteEditor(self):\n self.effectFactory = EffectFactory(self.lightController, self.eventHandler)\n self.eventHandler.setEffectFactory(self.effectFactory)\n self.editPalette = Ui_EditPalette(self.effectFactory)\n ui.separator().style('margin-top: 5%')\n with ui.row().style('margin-top: 5%'):\n ui.button(on_click=lambda: self.editPalette.addColor()).props('icon=add').tooltip(text='Add new color (max. 10)')\n ui.button(on_click=lambda: self.editPalette.remove()).props('icon=remove').tooltip(text='Remove first color')\n ui.button(on_click=lambda: self.editPalette.clear()).props('icon=delete').tooltip(text='Clear palette')", "score": 0.8493562936782837 }, { "filename": "src/ui_EditPalette.py", "retrieved_chunk": " def drawPalette(self):\n colors = self.colorButtons.copy()\n self.clear(True)\n for color in colors:\n with self.container:\n cb = Ui_ColorButton(color.colorCode, self)\n self.colorButtons.append(cb)\n def loadPalette(self, palette):\n self.clear(True)\n for color in palette:", "score": 0.8362380862236023 }, { "filename": "src/ui_EditPalette.py", "retrieved_chunk": "from nicegui import ui\nfrom ui_ColorButton import Ui_ColorButton\nimport random\nclass Ui_EditPalette:\n def __init__(self, effectFactory):\n self.effectFactory = effectFactory\n self.colorButtons = []\n self.container = ui.row()\n def addColor(self, color='#000000', updateEffect=True):\n if len(self.colorButtons) < 10:", "score": 0.8327394723892212 } ]

[ { "filename": "ppo/ppo_data_collectors.py", "retrieved_chunk": " self.ego_side = 0\n self.enm_rnn_states_actor = np.zeros((self.num_agents, self.recurrent_hidden_layers, self.recurrent_hidden_size))\n self.enm_masks = np.ones((self.num_agents, 1))\n obs = super().reset()\n return self._parse_obs(obs)\n def step(self, action):\n enm_action, enm_rnn_states_actor = self.enm.act(self.enm_obs, self.enm_rnn_states_actor, self.enm_masks)\n enm_action = _t2n(enm_action)\n self.enm_rnn_states_actor = _t2n(enm_rnn_states_actor)\n actions = np.concatenate((action, enm_action), axis=0)", "score": 0.9097487330436707 }, { "filename": "envs/slimevolley/slimevolleygym.py", "retrieved_chunk": " def step(self, action):\n obs, reward, done, info = self.env.step(action)\n self.frames.append(obs)\n return self._get_ob(), reward, done, info\n def _get_ob(self):\n assert len(self.frames) == self.n_frames\n return np.concatenate(list(self.frames), axis=2)\n#####################\n# helper functions: #\n#####################", "score": 0.8901119232177734 }, { "filename": "envs/robosumo/envs/agents.py", "retrieved_chunk": " ])\n return np.concatenate(obs)\n def before_step(self):\n self.posbefore = self.get_qpos()[:2].copy()\n def after_step(self, action):\n self.posafter = self.get_qpos()[:2].copy()\n # Control cost\n reward = - self.COST_COEFS['ctrl'] * np.square(action).sum()\n return reward\n# ------------------------------------------------------------------------------", "score": 0.8781546354293823 }, { "filename": "ppo/ppo_data_collectors.py", "retrieved_chunk": " obs = self.reset()\n rnn_states_actor = np.zeros((self.num_agents, self.recurrent_hidden_layers, self.recurrent_hidden_size))\n masks = np.ones((self.num_agents, 1))\n step = 0\n while True:\n action, rnn_states_actor = self.ego.act(obs, rnn_states_actor, masks)\n action = _t2n(action)\n rnn_states_actor = _t2n(rnn_states_actor)\n obs, reward, done, info = self.step(action)\n step += 1", "score": 0.8725178837776184 }, { "filename": "envs/robosumo/envs/sumo.py", "retrieved_chunk": " self.observation_space = self.agents[0].observation_space\n self.action_space = self.agents[0].action_space\n self.num_agents = 2\n self.is_vector_env = True\n def simulate(self, actions):\n a = np.concatenate(actions, axis=0)\n self.do_simulation(a, self.frame_skip)\n def step(self, actions):\n if not self._mujoco_init:\n return self._get_obs(), 0, False, None", "score": 0.8660010099411011 } ]

[ { "filename": "main_pbt_selfplay.py", "retrieved_chunk": " buffer=buffers[agent_id], \n params=ego_model, \n hyper_params=population_hypers[agent_id]\n )\n train_results.append(res)\n train_infos = [ray.get(train_results[i]) for i in range(N)]\n for agent_id, (param, info) in enumerate(train_infos):\n population[agent_id].restore_from_params(param)\n torch.save(param, f'{save_dir}/agent{agent_id}_history{epoch+1}.pt')\n torch.save(param, f'{save_dir}/agent{agent_id}_latest.pt')", "score": 0.8627932071685791 }, { "filename": "render/render_sumoant.py", "retrieved_chunk": "ego_path = \"\"\nenm_path = \"\"\nego_policy.restore_from_params(torch.load(ego_dir+ego_path))\nenm_policy.restore_from_params(torch.load(enm_dir+enm_path))\nif render_video == True:\n env = RecordVideo(env, video_folder=\"render/render_videos\", name_prefix=f\"0.1vs0.9\")\nenv.seed(0)\nprint(\"Start render\")\nobs = env.reset()\nstep = 0", "score": 0.8573093414306641 }, { "filename": "main_pbt_selfplay.py", "retrieved_chunk": " population_elos = {}\n population_hypers = {}\n for agent_id in range(all_args.population_size):\n population[agent_id] = PPOPolicy(all_args, env.observation_space, env.action_space)\n if all_args.model_dir is not None:\n population[agent_id].restore_from_path(all_args.model_dir, epoch='latest')\n params = population[agent_id].params()\n torch.save(params, f'{save_dir}/agent{agent_id}_history0.pt')\n torch.save(params, f'{save_dir}/agent{agent_id}_latest.pt')\n population_elos[agent_id] = {0: all_args.init_elo}", "score": 0.8547800779342651 }, { "filename": "main_pbt_selfplay.py", "retrieved_chunk": " enm_infos[agent_id] = enm_idxs\n ego_model = population[agent_id].params(device='cpu')\n results = []\n for i in range(M): \n enm_model = load_enm_params(save_dir, enm_idxs[i])\n res = data_collector_pools[agent_id][i].evaluate_data.remote(\n ego_params=ego_model, \n enm_params=enm_model, \n hyper_params=population_hypers[agent_id],\n ego_elo=population_elos[agent_id][epoch],", "score": 0.8404120206832886 }, { "filename": "ppo/ppo_data_collectors.py", "retrieved_chunk": " self.buffer_size = args.buffer_size\n self.num_agents = getattr(self.env, 'num_agents', 1)\n self.random_side = args.random_side\n self.buffer = PPOBuffer(args, self.num_agents, self.env.observation_space, self.env.action_space)\n self.ego = PPOPolicy(args, self.env.observation_space, self.env.action_space)\n def collect_data(self, ego_params, hyper_params={}):\n self.buffer.clear()\n if 'tau' in hyper_params:\n self.buffer.tau = hyper_params['tau'] \n if 'reward' in hyper_params:", "score": 0.8391616344451904 } ]

[ { "filename": "src/uiInitilalizer.py", "retrieved_chunk": " self.loadUI(currentEffect)\n def loadUI(self, effect):\n palette = self.getColors(effect)\n self.editPalette.loadPalette(palette)\n def getColors(self, effect):\n hsbColors = effect['write']['palette']\n palette = []\n for color in hsbColors:\n palette.append(colorConverter.HSBtoHEX(color['hue'], color['saturation'], color['brightness']))\n if len(palette) > 3:", "score": 0.8751862645149231 }, { "filename": "src/ui_EditPalette.py", "retrieved_chunk": " self.addColor(color, False)\n self.update()\n def shuffleColorPalette(self):\n if len(self.colorButtons) > 1:\n random.shuffle(self.colorButtons)\n self.drawPalette()\n self.update()\n def update(self):\n self.effectFactory.colorPalette = self.getColorPalette()\n self.effectFactory.buildEffect()", "score": 0.8565599918365479 }, { "filename": "src/ui_AnnotatedSlider.py", "retrieved_chunk": " self.effectFactory.buildEffect()\n case 'Brightness:':\n if self.lightController is not None:\n self.lightController.setBrightness(self.slider.value)\n self.checkBox.set_value(True)", "score": 0.844066858291626 }, { "filename": "src/uiInitilalizer.py", "retrieved_chunk": "from filemanager import Filemanager, File\nimport colorConverter\nclass UiInitilalizer:\n def __init__(self, effectOptionsTab, editPalette, secondaryColorCheckbox, secondaryColorInput):\n self.effectOptionsTab = effectOptionsTab\n self.editPalette = editPalette\n self.secondaryColorCheckbox = secondaryColorCheckbox\n self.secondaryColorInput = secondaryColorInput\n currentEffect = Filemanager.getValue(File.EFFECTS, \"current_effect\")\n if currentEffect is not None:", "score": 0.8329774141311646 }, { "filename": "src/ui_Structure.py", "retrieved_chunk": "from ui_EffectOptionsTab import Ui_EffectOptionsTab\nfrom ui_Notifier import Notifier\nfrom ui_Palette import Ui_Palette\nimport colorConverter\nimport matplotlib\nclass Ui_Structure:\n def __init__(self, light):\n self.secondaryColorInput = None\n self.secondaryColorCheckbox = None\n self.eventHandler = EventHandler()", "score": 0.8300518989562988 } ]

[ { "filename": "src/uiInitilalizer.py", "retrieved_chunk": " self.loadUI(currentEffect)\n def loadUI(self, effect):\n palette = self.getColors(effect)\n self.editPalette.loadPalette(palette)\n def getColors(self, effect):\n hsbColors = effect['write']['palette']\n palette = []\n for color in hsbColors:\n palette.append(colorConverter.HSBtoHEX(color['hue'], color['saturation'], color['brightness']))\n if len(palette) > 3:", "score": 0.8239977359771729 }, { "filename": "src/filemanager.py", "retrieved_chunk": " with open(File.EFFECTS.value, 'w') as effectsFile:\n json.dump(effects, effectsFile, indent=4)", "score": 0.8140161037445068 }, { "filename": "src/uiInitilalizer.py", "retrieved_chunk": "from filemanager import Filemanager, File\nimport colorConverter\nclass UiInitilalizer:\n def __init__(self, effectOptionsTab, editPalette, secondaryColorCheckbox, secondaryColorInput):\n self.effectOptionsTab = effectOptionsTab\n self.editPalette = editPalette\n self.secondaryColorCheckbox = secondaryColorCheckbox\n self.secondaryColorInput = secondaryColorInput\n currentEffect = Filemanager.getValue(File.EFFECTS, \"current_effect\")\n if currentEffect is not None:", "score": 0.80433589220047 }, { "filename": "src/ui_AnnotatedSlider.py", "retrieved_chunk": " self.effectFactory.buildEffect()\n case 'Brightness:':\n if self.lightController is not None:\n self.lightController.setBrightness(self.slider.value)\n self.checkBox.set_value(True)", "score": 0.8041367530822754 }, { "filename": "src/ui_EffectOptionsTab.py", "retrieved_chunk": " self.nColorsPerFrame = Ui_AnnotatedSlider(min=2, max=10, value=2, description='n Colors per frame:', effectFactory=self.effectFactory)\n self.info = ui.label('No further settings available for this effect.').style('margin-top: -20%;')\n self.setEffect('Random')\n def setEffect(self, effect):\n self.currentEffect.set_text(effect)\n self.hideOptions()\n self.effectFactory.pluginType, effect = self.getEffectProps(effect)\n self.effectFactory.currentEffect = effect\n props = effect[1]\n if 'delayTime' in props:", "score": 0.7948257327079773 } ]

[ { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_resa()\n with self.assertRaises(KeaClientError):\n self.kea.set_reservation(100, 201, {\n 'ip-address': '192.168.0.1', 'hw-address': '11:22:33:33:22:11',\n 'hostname': 'pc2.lan'})\n def test_25_set_reservation_no_conflict_ip(self):\n self.srv_conf['Dhcp4']['ip-reservations-unique'] = False\n self.kea.pull()\n self._set_std_subnet()\n self._set_std_resa()", "score": 0.8329432606697083 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_resa()\n def test_23_set_reservation_conflict_hw(self):\n self._set_std_subnet()\n self._set_std_resa()\n with self.assertRaises(KeaClientError):\n self.kea.set_reservation(100, 201, {\n 'ip-address': '192.168.0.2', 'hw-address': '11:22:33:44:55:66',\n 'hostname': 'pc2.lan'})\n def test_24_set_reservation_conflict_ip(self):\n self._set_std_subnet()", "score": 0.8325452208518982 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self.kea.set_reservation(100, 201, {\n 'ip-address': '192.168.0.1', 'hw-address': '11:22:33:33:22:11',\n 'hostname': 'pc2.lan'})\n self.assertEqual(len(self.kea.conf['subnet4'][0]['reservations']), 2)\n def test_26_del_reservation(self):\n self._set_std_subnet()\n self._set_std_resa()\n self.kea.del_resa(200)\n self.assertEqual(len(self.kea.conf['subnet4'][0]['reservations']), 0)\n def test_30_set_pool(self):", "score": 0.8299909234046936 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " 'ip-address': '192.168.0.1', 'hw-address': '11:22:33:44:55:66',\n 'hostname': 'pc.lan'})\n def _set_std_pool(self):\n self.kea.set_pool(100, 250, {'pool': '192.168.0.100-192.168.0.199'})\n def setUp(self):\n self.kea = DHCP4App('http://keasrv/api')\n self.req = MagicMock()\n self.kea.api._request_kea = self.req\n self.srv_conf = {'Dhcp4': {}}\n self.srv_check_res = True", "score": 0.8283985257148743 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_subnet()\n self.kea.del_all_subnets()\n self.kea.push()\n self.assertEqual(len(self.srv_conf['Dhcp4']['subnet4']), 0)\n def test_20_set_reservation(self):\n expected = {'subnet4': [\n {'id': 100, 'subnet': '192.168.0.0/24', 'pools': [],\n 'reservations': [{\n 'ip-address': '192.168.0.1', 'hw-address': '11:22:33:44:55:66',\n 'hostname': 'pc.lan', 'user-context': {", "score": 0.8245452642440796 } ]

[ { "filename": "src/eventHandler.py", "retrieved_chunk": "class EventHandler:\n def __init__(self):\n self.effectOptionsTab = None\n self.effectFactory = None\n def setCurrentEffect(self, effect):\n self.effectOptionsTab.setEffect(effect)\n def setEffectOptionsTab(self, effectOptionsTab):\n self.effectOptionsTab = effectOptionsTab\n def setEffectFactory(self, effectFactory):\n self.effectFactory = effectFactory", "score": 0.8454862236976624 }, { "filename": "src/ui_EffectButton.py", "retrieved_chunk": "from nicegui import ui\nclass Ui_EffectButton:\n def __init__(self, effect, eventHandler):\n self.effect = effect\n self.eventHandler = eventHandler\n ui.button(effect, on_click=self.selectEffect)\n def selectEffect(self):\n self.eventHandler.setCurrentEffect(self.effect)\n self.eventHandler.effectFactory.buildEffect()", "score": 0.8423030376434326 }, { "filename": "src/ui_AnnotatedSlider.py", "retrieved_chunk": " self.effectFactory.buildEffect()\n case 'Brightness:':\n if self.lightController is not None:\n self.lightController.setBrightness(self.slider.value)\n self.checkBox.set_value(True)", "score": 0.8402054309844971 }, { "filename": "src/effectFactory.py", "retrieved_chunk": " effectJson['write'].update({\"pluginType\": self.pluginType})\n effectJson['write'].update({\"pluginUuid\": self.currentEffect[0]})\n self.updatePropValues()\n for prop in self.currentEffect[1]:\n effectJson['write']['pluginOptions'].append({\"name\": prop, \"value\": self.propValues[prop]})\n effectString = str(effectJson).replace('\\'', '\\\"')\n self.lightController.setEffect(effectString)\n Filemanager.setValue(File.EFFECTS, \"current_effect\", effectJson)", "score": 0.8372001647949219 }, { "filename": "src/ui_AnnotatedToggle.py", "retrieved_chunk": " self.widget = Ui_Widget([self.label, self.slider, self.sep])\n def updateValue(self):\n self.effectFactory.linDirection = str(self.slider.options[self.slider.value]).lower()\n self.effectFactory.buildEffect()", "score": 0.8337043523788452 } ]

[ { "filename": "main_pbt_selfplay.py", "retrieved_chunk": " population_elos = {}\n population_hypers = {}\n for agent_id in range(all_args.population_size):\n population[agent_id] = PPOPolicy(all_args, env.observation_space, env.action_space)\n if all_args.model_dir is not None:\n population[agent_id].restore_from_path(all_args.model_dir, epoch='latest')\n params = population[agent_id].params()\n torch.save(params, f'{save_dir}/agent{agent_id}_history0.pt')\n torch.save(params, f'{save_dir}/agent{agent_id}_latest.pt')\n population_elos[agent_id] = {0: all_args.init_elo}", "score": 0.8638828992843628 }, { "filename": "main_pbt_selfplay.py", "retrieved_chunk": " buffer=buffers[agent_id], \n params=ego_model, \n hyper_params=population_hypers[agent_id]\n )\n train_results.append(res)\n train_infos = [ray.get(train_results[i]) for i in range(N)]\n for agent_id, (param, info) in enumerate(train_infos):\n population[agent_id].restore_from_params(param)\n torch.save(param, f'{save_dir}/agent{agent_id}_history{epoch+1}.pt')\n torch.save(param, f'{save_dir}/agent{agent_id}_latest.pt')", "score": 0.849175751209259 }, { "filename": "render/render_sumoant.py", "retrieved_chunk": "ego_path = \"\"\nenm_path = \"\"\nego_policy.restore_from_params(torch.load(ego_dir+ego_path))\nenm_policy.restore_from_params(torch.load(enm_dir+enm_path))\nif render_video == True:\n env = RecordVideo(env, video_folder=\"render/render_videos\", name_prefix=f\"0.1vs0.9\")\nenv.seed(0)\nprint(\"Start render\")\nobs = env.reset()\nstep = 0", "score": 0.8461970090866089 }, { "filename": "ppo/ppo_data_collectors.py", "retrieved_chunk": " self.buffer_size = args.buffer_size\n self.num_agents = getattr(self.env, 'num_agents', 1)\n self.random_side = args.random_side\n self.buffer = PPOBuffer(args, self.num_agents, self.env.observation_space, self.env.action_space)\n self.ego = PPOPolicy(args, self.env.observation_space, self.env.action_space)\n def collect_data(self, ego_params, hyper_params={}):\n self.buffer.clear()\n if 'tau' in hyper_params:\n self.buffer.tau = hyper_params['tau'] \n if 'reward' in hyper_params:", "score": 0.8451709747314453 }, { "filename": "main_pbt_selfplay.py", "retrieved_chunk": " \"population_elos\": population_elos,\n \"population_hypers\": population_hypers\n }\n if all_args.use_wandb:\n for agent_id in range(N):\n wandb.log({f\"agent{agent_id}_tau\": population_hypers[agent_id]['tau']}, step=cur_steps)\n wandb.log({f\"agent{agent_id}_elo\": population_elos[agent_id][epoch]}, step=cur_steps)\n torch.save(checkpoint, f\"{save_dir}/checkpoint_latest.pt\")\nif __name__ == \"__main__\":\n main(sys.argv[1:])", "score": 0.8428236842155457 } ]

[ { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self.kea.set_reservation(100, 201, {\n 'ip-address': '192.168.0.1', 'hw-address': '11:22:33:33:22:11',\n 'hostname': 'pc2.lan'})\n self.assertEqual(len(self.kea.conf['subnet4'][0]['reservations']), 2)\n def test_26_del_reservation(self):\n self._set_std_subnet()\n self._set_std_resa()\n self.kea.del_resa(200)\n self.assertEqual(len(self.kea.conf['subnet4'][0]['reservations']), 0)\n def test_30_set_pool(self):", "score": 0.8570398092269897 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_resa()\n with self.assertRaises(KeaClientError):\n self.kea.set_reservation(100, 201, {\n 'ip-address': '192.168.0.1', 'hw-address': '11:22:33:33:22:11',\n 'hostname': 'pc2.lan'})\n def test_25_set_reservation_no_conflict_ip(self):\n self.srv_conf['Dhcp4']['ip-reservations-unique'] = False\n self.kea.pull()\n self._set_std_subnet()\n self._set_std_resa()", "score": 0.8562538623809814 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_resa()\n def test_23_set_reservation_conflict_hw(self):\n self._set_std_subnet()\n self._set_std_resa()\n with self.assertRaises(KeaClientError):\n self.kea.set_reservation(100, 201, {\n 'ip-address': '192.168.0.2', 'hw-address': '11:22:33:44:55:66',\n 'hostname': 'pc2.lan'})\n def test_24_set_reservation_conflict_ip(self):\n self._set_std_subnet()", "score": 0.8516284227371216 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_subnet()\n self.kea.del_all_subnets()\n self.kea.push()\n self.assertEqual(len(self.srv_conf['Dhcp4']['subnet4']), 0)\n def test_20_set_reservation(self):\n expected = {'subnet4': [\n {'id': 100, 'subnet': '192.168.0.0/24', 'pools': [],\n 'reservations': [{\n 'ip-address': '192.168.0.1', 'hw-address': '11:22:33:44:55:66',\n 'hostname': 'pc.lan', 'user-context': {", "score": 0.8502246141433716 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self.kea.conf = deepcopy(newconf)\n self.kea.commit()\n self.req.assert_called_once_with('config-test', {'Dhcp4': newconf})\n self.assertEqual(self.kea.conf, self.kea.commit_conf)\n def test_03_push_wo_commit(self):\n self.kea.push()\n self.req.assert_not_called()\n def test_04_push_w_commit(self):\n newconf = {'subnet4': [{'garbage': True}]}\n self.kea.conf = deepcopy(newconf)", "score": 0.8335044980049133 } ]

[ { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_resa()\n with self.assertRaises(KeaClientError):\n self.kea.set_reservation(100, 201, {\n 'ip-address': '192.168.0.1', 'hw-address': '11:22:33:33:22:11',\n 'hostname': 'pc2.lan'})\n def test_25_set_reservation_no_conflict_ip(self):\n self.srv_conf['Dhcp4']['ip-reservations-unique'] = False\n self.kea.pull()\n self._set_std_subnet()\n self._set_std_resa()", "score": 0.851423978805542 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self.kea.set_reservation(100, 201, {\n 'ip-address': '192.168.0.1', 'hw-address': '11:22:33:33:22:11',\n 'hostname': 'pc2.lan'})\n self.assertEqual(len(self.kea.conf['subnet4'][0]['reservations']), 2)\n def test_26_del_reservation(self):\n self._set_std_subnet()\n self._set_std_resa()\n self.kea.del_resa(200)\n self.assertEqual(len(self.kea.conf['subnet4'][0]['reservations']), 0)\n def test_30_set_pool(self):", "score": 0.8511041402816772 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_subnet()\n self.kea.del_all_subnets()\n self.kea.push()\n self.assertEqual(len(self.srv_conf['Dhcp4']['subnet4']), 0)\n def test_20_set_reservation(self):\n expected = {'subnet4': [\n {'id': 100, 'subnet': '192.168.0.0/24', 'pools': [],\n 'reservations': [{\n 'ip-address': '192.168.0.1', 'hw-address': '11:22:33:44:55:66',\n 'hostname': 'pc.lan', 'user-context': {", "score": 0.847087025642395 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_resa()\n def test_23_set_reservation_conflict_hw(self):\n self._set_std_subnet()\n self._set_std_resa()\n with self.assertRaises(KeaClientError):\n self.kea.set_reservation(100, 201, {\n 'ip-address': '192.168.0.2', 'hw-address': '11:22:33:44:55:66',\n 'hostname': 'pc2.lan'})\n def test_24_set_reservation_conflict_ip(self):\n self._set_std_subnet()", "score": 0.845084547996521 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_subnet()\n self.kea.update_subnet(100, {'subnet': '192.168.0.0/24', 'opt': 1})\n self.kea.push()\n self.assertEqual(self.srv_conf['Dhcp4']['subnet4'][0]['opt'], 1)\n def test_15_del_subnet(self):\n self._set_std_subnet()\n self.kea.del_subnet(100)\n self.kea.push()\n self.assertEqual(len(self.srv_conf['Dhcp4']['subnet4']), 0)\n def test_16_del_all_subnets(self):", "score": 0.8315868377685547 } ]

[ { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_resa()\n with self.assertRaises(KeaClientError):\n self.kea.set_reservation(100, 201, {\n 'ip-address': '192.168.0.1', 'hw-address': '11:22:33:33:22:11',\n 'hostname': 'pc2.lan'})\n def test_25_set_reservation_no_conflict_ip(self):\n self.srv_conf['Dhcp4']['ip-reservations-unique'] = False\n self.kea.pull()\n self._set_std_subnet()\n self._set_std_resa()", "score": 0.8552871346473694 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self.kea.set_reservation(100, 201, {\n 'ip-address': '192.168.0.1', 'hw-address': '11:22:33:33:22:11',\n 'hostname': 'pc2.lan'})\n self.assertEqual(len(self.kea.conf['subnet4'][0]['reservations']), 2)\n def test_26_del_reservation(self):\n self._set_std_subnet()\n self._set_std_resa()\n self.kea.del_resa(200)\n self.assertEqual(len(self.kea.conf['subnet4'][0]['reservations']), 0)\n def test_30_set_pool(self):", "score": 0.8549627661705017 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_subnet()\n self.kea.del_all_subnets()\n self.kea.push()\n self.assertEqual(len(self.srv_conf['Dhcp4']['subnet4']), 0)\n def test_20_set_reservation(self):\n expected = {'subnet4': [\n {'id': 100, 'subnet': '192.168.0.0/24', 'pools': [],\n 'reservations': [{\n 'ip-address': '192.168.0.1', 'hw-address': '11:22:33:44:55:66',\n 'hostname': 'pc.lan', 'user-context': {", "score": 0.8516061902046204 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_resa()\n def test_23_set_reservation_conflict_hw(self):\n self._set_std_subnet()\n self._set_std_resa()\n with self.assertRaises(KeaClientError):\n self.kea.set_reservation(100, 201, {\n 'ip-address': '192.168.0.2', 'hw-address': '11:22:33:44:55:66',\n 'hostname': 'pc2.lan'})\n def test_24_set_reservation_conflict_ip(self):\n self._set_std_subnet()", "score": 0.8454787135124207 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_subnet()\n self.kea.update_subnet(100, {'subnet': '192.168.0.0/24', 'opt': 1})\n self.kea.push()\n self.assertEqual(self.srv_conf['Dhcp4']['subnet4'][0]['opt'], 1)\n def test_15_del_subnet(self):\n self._set_std_subnet()\n self.kea.del_subnet(100)\n self.kea.push()\n self.assertEqual(len(self.srv_conf['Dhcp4']['subnet4']), 0)\n def test_16_del_all_subnets(self):", "score": 0.8288571238517761 } ]

[ { "filename": "ppo/ppo_trainer.py", "retrieved_chunk": " old_action_log_probs_batch = check(old_action_log_probs_batch).to(**self.tpdv)\n advantages_batch = check(advantages_batch).to(**self.tpdv)\n returns_batch = check(returns_batch).to(**self.tpdv)\n value_preds_batch = check(value_preds_batch).to(**self.tpdv)\n # Reshape to do in a single forward pass for all steps\n values, action_log_probs, dist_entropy = self.policy.evaluate_actions(obs_batch,\n rnn_states_actor_batch,\n rnn_states_critic_batch,\n actions_batch,\n masks_batch)", "score": 0.8932851552963257 }, { "filename": "ppo/ppo_policy.py", "retrieved_chunk": " \"\"\"\n values, _ = self.critic(obs, rnn_states_critic, masks)\n return values\n def evaluate_actions(self, obs, rnn_states_actor, rnn_states_critic, action, masks, active_masks=None):\n \"\"\"\n Returns:\n values, action_log_probs, dist_entropy\n \"\"\"\n action_log_probs, dist_entropy = self.actor.evaluate_actions(obs, rnn_states_actor, action, masks, active_masks)\n values, _ = self.critic(obs, rnn_states_critic, masks)", "score": 0.8650494813919067 }, { "filename": "ppo/ppo_critic.py", "retrieved_chunk": " # (3) value module\n if len(self.act_hidden_size) > 0:\n self.mlp = MLPLayer(input_size, self.act_hidden_size, self.activation_id)\n self.value_out = nn.Linear(input_size, 1)\n self.to(device)\n def forward(self, obs, rnn_states, masks):\n obs = check(obs).to(**self.tpdv)\n rnn_states = check(rnn_states).to(**self.tpdv)\n masks = check(masks).to(**self.tpdv)\n critic_features = self.base(obs)", "score": 0.8638262748718262 }, { "filename": "ppo/ppo_policy.py", "retrieved_chunk": " return values, action_log_probs, dist_entropy\n def act(self, obs, rnn_states_actor, masks, deterministic=False):\n \"\"\"\n Returns:\n actions, rnn_states_actor\n \"\"\"\n actions, _, rnn_states_actor = self.actor(obs, rnn_states_actor, masks, deterministic)\n return actions, rnn_states_actor\n def prep_training(self):\n self.actor.train()", "score": 0.8516497611999512 }, { "filename": "ppo/ppo_critic.py", "retrieved_chunk": " if self.use_recurrent_policy:\n critic_features, rnn_states = self.rnn(critic_features, rnn_states, masks)\n if len(self.act_hidden_size) > 0:\n critic_features = self.mlp(critic_features)\n values = self.value_out(critic_features)\n return values, rnn_states", "score": 0.8457238674163818 } ]

[ { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self.kea.set_reservation(100, 201, {\n 'ip-address': '192.168.0.1', 'hw-address': '11:22:33:33:22:11',\n 'hostname': 'pc2.lan'})\n self.assertEqual(len(self.kea.conf['subnet4'][0]['reservations']), 2)\n def test_26_del_reservation(self):\n self._set_std_subnet()\n self._set_std_resa()\n self.kea.del_resa(200)\n self.assertEqual(len(self.kea.conf['subnet4'][0]['reservations']), 0)\n def test_30_set_pool(self):", "score": 0.8752830028533936 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_resa()\n with self.assertRaises(KeaClientError):\n self.kea.set_reservation(100, 201, {\n 'ip-address': '192.168.0.1', 'hw-address': '11:22:33:33:22:11',\n 'hostname': 'pc2.lan'})\n def test_25_set_reservation_no_conflict_ip(self):\n self.srv_conf['Dhcp4']['ip-reservations-unique'] = False\n self.kea.pull()\n self._set_std_subnet()\n self._set_std_resa()", "score": 0.8630069494247437 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_subnet()\n self.kea.del_all_subnets()\n self.kea.push()\n self.assertEqual(len(self.srv_conf['Dhcp4']['subnet4']), 0)\n def test_20_set_reservation(self):\n expected = {'subnet4': [\n {'id': 100, 'subnet': '192.168.0.0/24', 'pools': [],\n 'reservations': [{\n 'ip-address': '192.168.0.1', 'hw-address': '11:22:33:44:55:66',\n 'hostname': 'pc.lan', 'user-context': {", "score": 0.8600175976753235 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_resa()\n def test_23_set_reservation_conflict_hw(self):\n self._set_std_subnet()\n self._set_std_resa()\n with self.assertRaises(KeaClientError):\n self.kea.set_reservation(100, 201, {\n 'ip-address': '192.168.0.2', 'hw-address': '11:22:33:44:55:66',\n 'hostname': 'pc2.lan'})\n def test_24_set_reservation_conflict_ip(self):\n self._set_std_subnet()", "score": 0.8558081984519958 }, { "filename": "tests/unit/test_kea.py", "retrieved_chunk": " self._set_std_subnet()\n self.kea.update_subnet(100, {'subnet': '192.168.0.0/24', 'opt': 1})\n self.kea.push()\n self.assertEqual(self.srv_conf['Dhcp4']['subnet4'][0]['opt'], 1)\n def test_15_del_subnet(self):\n self._set_std_subnet()\n self.kea.del_subnet(100)\n self.kea.push()\n self.assertEqual(len(self.srv_conf['Dhcp4']['subnet4']), 0)\n def test_16_del_all_subnets(self):", "score": 0.8521238565444946 } ]

[ { "filename": "systematic_trading/datasets/raw/earnings_surprise.py", "retrieved_chunk": " )\n df[\"date_reported\"] = pd.to_datetime(df[\"date_reported\"])\n df[\"id\"] = range(len(df))\n df[\"symbol\"] = symbol\n df[\"date\"] = self.tag_date.isoformat()\n df = df.reindex(columns=self.expected_columns)\n self.frames[symbol] = df\n def set_dataset_df(self):\n self.dataset_df = pd.concat([f for f in self.frames.values() if f is not None])\n if self.check_file_exists():", "score": 0.7947810888290405 }, { "filename": "systematic_trading/datasets/raw/earnings_forecast.py", "retrieved_chunk": " self.dataset_df = pd.concat([f for f in self.frames.values() if f is not None])\n if self.check_file_exists():\n self.add_previous_data()\n self.dataset_df.sort_values(by=[\"symbol\", \"date\", \"id\"], inplace=True)\n self.dataset_df.reset_index(drop=True, inplace=True)\nif __name__ == \"__main__\":\n symbol = \"AAPL\"\n suffix = \"stocks\"\n tag_date = datetime(2023, 5, 26).date()\n username = \"edarchimbaud\"", "score": 0.7904599905014038 }, { "filename": "systematic_trading/datasets/raw/short_interest.py", "retrieved_chunk": " df[\"date\"] = self.tag_date.isoformat()\n df = df.reindex(columns=self.expected_columns)\n self.frames[symbol] = df\n def set_dataset_df(self):\n self.dataset_df = pd.concat([f for f in self.frames.values() if f is not None])\n if self.check_file_exists():\n self.add_previous_data()\n self.dataset_df.sort_values(by=[\"symbol\", \"date\", \"id\"], inplace=True)\n self.dataset_df.reset_index(drop=True, inplace=True)\nif __name__ == \"__main__\":", "score": 0.782071590423584 }, { "filename": "systematic_trading/datasets/raw/extended_trading.py", "retrieved_chunk": " df[\"symbol\"] = symbol\n df[\"date\"] = self.tag_date.isoformat()\n df = df.reindex(columns=self.expected_columns)\n self.frames[symbol] = df\n def set_dataset_df(self):\n self.dataset_df = pd.concat([f for f in self.frames.values() if f is not None])\n if self.check_file_exists():\n self.add_previous_data()\n self.dataset_df.sort_values(by=[\"symbol\", \"date\", \"time\"], inplace=True)\n self.dataset_df.reset_index(drop=True, inplace=True)", "score": 0.7815829515457153 }, { "filename": "systematic_trading/datasets/raw/timeseries_1mn.py", "retrieved_chunk": " data.update(indicators)\n df = pd.DataFrame(data=data)\n df[\"symbol\"] = symbol\n df = df.reindex(columns=self.expected_columns)\n self.frames[symbol] = df\n def set_dataset_df(self):\n self.dataset_df = pd.concat([f for f in self.frames.values() if f is not None])\n if self.check_file_exists():\n self.add_previous_data()\n self.dataset_df.sort_values(by=[\"symbol\", \"datetime\"], inplace=True)", "score": 0.7805352807044983 } ]

[ { "filename": "systematic_trading/datasets/index_constituents/sp500.py", "retrieved_chunk": "\"\"\"\nIndex constituents S&P 500.\n\"\"\"\nfrom datetime import date\nfrom bs4 import BeautifulSoup\nimport pandas as pd\nimport requests\nfrom tqdm import tqdm\nfrom systematic_trading.datasets.index_constituents import IndexConstituents\nfrom systematic_trading.helpers import retry_get", "score": 0.8246109485626221 }, { "filename": "systematic_trading/datasets/index_constituents/sp500.py", "retrieved_chunk": "class SP500(IndexConstituents):\n \"\"\"\n Index constituents S&P 500.\n \"\"\"\n def __init__(self, tag_date: date = None, username: str = None):\n super().__init__(\"stocks\", tag_date, username)\n self.name = f\"index-constituents-sp500\"\n def set_dataset_df(self):\n \"\"\"\n Download the list of S&P 500 constituents from Wikipedia.", "score": 0.8202863931655884 }, { "filename": "systematic_trading/datasets/index_constituents/__init__.py", "retrieved_chunk": "\"\"\"\nIndex constituents data.\n\"\"\"\nfrom datetime import date\nimport pandas as pd\nfrom systematic_trading.datasets.dataset import Dataset\nclass IndexConstituents(Dataset):\n \"\"\"\n Index constituents data.\n \"\"\"", "score": 0.7983506917953491 }, { "filename": "systematic_trading/datasets/raw/extended_trading.py", "retrieved_chunk": "if __name__ == \"__main__\":\n symbol = \"AAPL\"\n suffix = \"stocks\"\n tag_date = datetime(2023, 5, 26).date()\n username = \"edarchimbaud\"\n dataset = ExtendedTrading(suffix=suffix, tag_date=tag_date, username=username)\n dataset.append_frame(symbol)", "score": 0.7967844009399414 }, { "filename": "systematic_trading/features/predictors/__main__.py", "retrieved_chunk": "from datetime import date, timedelta\nimport click\nfrom systematic_trading.features.predictors.predictors_monthly import PredictorsMonthly\nfrom systematic_trading.features.targets.targets_monthly import TargetsMonthly\[email protected]()\[email protected](\"--username\", default=\"edarchimbaud\", help=\"Username to use\")\ndef main(suffix: str, username: str):\n tag_date = date.today() - timedelta(days=3)\n print(\"Updating feature and target datasets...\")\n features = {", "score": 0.7913792133331299 } ]

[ { "filename": "rebar/utils.py", "retrieved_chunk": " logger = params.logger\n # object to hold information about downloaded files\n info = {}\n logger.info(str(datetime.now()) + \"\\t\" + \"-\" * 40)\n logger.info(str(datetime.now()) + \"\\tDownloading reference.\")\n Entrez.email = \"[email protected]\"\n handle = Entrez.efetch(\n db=\"nucleotide\", id=accession, rettype=\"fasta\", retmode=\"text\"\n )\n record = SeqIO.read(handle, \"fasta\")", "score": 0.8501491546630859 }, { "filename": "rebar/utils.py", "retrieved_chunk": " # Export\n file_name = \"reference.fasta\"\n file_path = os.path.join(params.outdir, file_name)\n logger.info(str(datetime.now()) + \"\\tExporting reference: \" + file_path)\n SeqIO.write(record, file_path, \"fasta\")\n # Update info\n info[\"accession\"] = accession\n info[\"file\"] = file_path\n # Finish\n logger.info(str(datetime.now()) + \"\\tFinished downloading reference.\")", "score": 0.8414921760559082 }, { "filename": "test/test_wrappers.py", "retrieved_chunk": "from rebar import utils, wrappers\nimport os\ndef test_dataset_sarscov2_latest(params):\n \"\"\"Test function wrappers.dataset.\"\"\"\n params.outdir = \"test/tmp/wrappers/dataset/sars-cov-2-latest\"\n if not os.path.exists(params.outdir):\n os.makedirs(params.outdir)\n params.logger = utils.create_logger(os.path.join(params.outdir, \"test.log\"))\n wrappers.dataset(params)\ndef test_run_sarscov2_latest(params):", "score": 0.8343846201896667 }, { "filename": "rebar/wrappers.py", "retrieved_chunk": " # Initialize tag\n if params.name == \"sars-cov-2\":\n if params.tag == \"latest\":\n create_annotations(params)\n accession = \"MN908947.3\"\n info[\"reference\"] = download_reference_sequence(params, accession)\n info[\"sequences\"] = download_consensus_sequences(params)\n info[\"tree\"] = create_tree(params)\n # barcodes needs tree for clade to lineage mapping\n params.tree = os.path.join(params.outdir, \"tree.nwk\")", "score": 0.8311428427696228 }, { "filename": "test/test_wrappers.py", "retrieved_chunk": " \"\"\"Test function wrappers.run.\"\"\"\n params.outdir = \"test/tmp/wrappers/run\"\n if not os.path.exists(params.outdir):\n os.makedirs(params.outdir)\n # Disable alignment, we'll use lineage list from conftest\n params.alignment = None\n params.dataset = \"test/tmp/wrappers/dataset/sars-cov-2-latest\"\n params.logger = utils.create_logger(os.path.join(params.outdir, \"test.log\"))\n wrappers.run(params)\n# def test_no_lineages_or_alignment(params):", "score": 0.8277148008346558 } ]

[ { "filename": "systematic_trading/strategy_ideas/ssrn_paper_crawler.py", "retrieved_chunk": " is_strategy = labels[-1][\"jsonResponse\"][\"IS_STRATEGY\"][\"categories\"][0][\n \"name\"\n ]\n if is_strategy != \"Yes\":\n continue\n abstract_id = int(asset[\"externalId\"])\n paper = SsrnPaper(abstract_id)\n if paper.exists_in_kili(self.tgt_kili_project_id):\n continue\n paper.from_ssrn()", "score": 0.9045124053955078 }, { "filename": "systematic_trading/strategy_ideas/ssrn_paper_summarizer.py", "retrieved_chunk": " def __init__(self):\n self._kili_client = Kili(api_key=os.getenv(\"KILI_API_KEY\"))\n self._openai_client = ChatOpenAI(\n model_name=\"gpt-3.5-turbo\",\n openai_api_key=os.getenv(\"OPENAI_API_KEY\"),\n temperature=0,\n )\n def __parse_label(self, asset):\n label = asset[\"labels\"][-1][\"jsonResponse\"]\n is_strategy = label[\"IS_STRATEGY\"][\"categories\"][0][\"name\"]", "score": 0.8253453969955444 }, { "filename": "systematic_trading/strategy_ideas/ssrn_abstract.py", "retrieved_chunk": " project_id=project_id,\n external_id_strictly_in=[self._external_id],\n fields=[\"jsonContent\", \"labels.jsonResponse\", \"labels.labelType\"],\n disable_tqdm=True,\n )\n assert len(assets) == 1\n asset = assets[0]\n asset[\"jsonContent\"] = json.loads(requests.get(asset[\"jsonContent\"]).content)\n # abstract\n abstract_blocks = self.__find_json_content_element(", "score": 0.8094397783279419 }, { "filename": "systematic_trading/strategy_ideas/ssrn_abstract.py", "retrieved_chunk": " project_id=project_id,\n json_content_array=[json_content],\n external_id_array=[self._external_id],\n disable_tqdm=True,\n )\n if self.is_strategy != \"\":\n json_response = {\n \"IS_STRATEGY\": {\"categories\": [{\"name\": self.is_strategy}]}\n }\n self._kili_client.append_labels(", "score": 0.7967236042022705 }, { "filename": "systematic_trading/strategy_ideas/ssrn_abstract.py", "retrieved_chunk": " for label in asset[\"labels\"]\n if label[\"labelType\"] in [\"DEFAULT\", \"REVIEW\"]\n ]\n if len(labels) > 0:\n self.is_strategy = labels[-1][\"jsonResponse\"][\"IS_STRATEGY\"][\"categories\"][\n 0\n ][\"name\"]\n def __json_content_children(self, tag_id: str, title: str, text: str):\n return [\n {", "score": 0.7941957712173462 } ]

[ { "filename": "systematic_trading/strategy_ideas/ssrn_abstract_crawler.py", "retrieved_chunk": " self.is_strategy = is_strategy\n self._driver = None\n def __from_url(self, url: str):\n return int(url.split(\"=\")[-1])\n def __download_and_save_to_kili(self, abstract_ids: list):\n for abstract_id in tqdm(abstract_ids):\n abstract = SsrnAbstract(abstract_id)\n if (\n abstract.exists_in_kili(self.kili_project_id)\n or not abstract.exists_in_ssrn()", "score": 0.8559444546699524 }, { "filename": "systematic_trading/strategy_ideas/ssrn_abstract_classifier.py", "retrieved_chunk": " )\n for asset in tqdm(assets):\n abstract_id = int(asset[\"externalId\"])\n abstract = SsrnAbstract(abstract_id)\n abstract.from_kili(project_id=self.kili_project_id)\n text = str(abstract)\n try:\n prediction = classifier(text)\n except RuntimeError:\n continue", "score": 0.8501476049423218 }, { "filename": "systematic_trading/strategy_ideas/ssrn_abstract_classifier.py", "retrieved_chunk": " continue\n groundtruth_category = groundtruth_labels[-1][\"jsonResponse\"][\n \"IS_STRATEGY\"\n ][\"categories\"][0][\"name\"]\n labels.append(self.label2id[groundtruth_category])\n abstract_id = int(asset[\"externalId\"])\n abstract = SsrnAbstract(abstract_id)\n abstract.from_kili(project_id=self.kili_project_id)\n text = str(abstract)\n texts.append(text)", "score": 0.8400024175643921 }, { "filename": "systematic_trading/strategy_ideas/ssrn_strategy.py", "retrieved_chunk": "import os\nfrom kili.client import Kili\nimport requests\nfrom bs4 import BeautifulSoup\nfrom ssrn_abstract import SsrnAbstract\nclass SsrnStrategy:\n def __init__(self, abstract: SsrnAbstract):\n self.abstract = abstract\n self.trading_rules = \"\"\n self.backtrader = \"\"", "score": 0.8286561369895935 }, { "filename": "systematic_trading/strategy_ideas/ssrn_paper.py", "retrieved_chunk": "import os\nfrom kili.client import Kili\nimport requests\nfrom bs4 import BeautifulSoup\nclass SsrnPaper:\n def __init__(self, abstract_id: int):\n self.abstract_id = abstract_id\n self._external_id = str(abstract_id)\n self.pdf_path = None\n self.url = (", "score": 0.8215211033821106 } ]

[ { "filename": "systematic_trading/strategy_ideas/ssrn_abstract_classifier.py", "retrieved_chunk": " )\n for asset in tqdm(assets):\n abstract_id = int(asset[\"externalId\"])\n abstract = SsrnAbstract(abstract_id)\n abstract.from_kili(project_id=self.kili_project_id)\n text = str(abstract)\n try:\n prediction = classifier(text)\n except RuntimeError:\n continue", "score": 0.8526098728179932 }, { "filename": "systematic_trading/strategy_ideas/ssrn_abstract_classifier.py", "retrieved_chunk": " continue\n groundtruth_category = groundtruth_labels[-1][\"jsonResponse\"][\n \"IS_STRATEGY\"\n ][\"categories\"][0][\"name\"]\n labels.append(self.label2id[groundtruth_category])\n abstract_id = int(asset[\"externalId\"])\n abstract = SsrnAbstract(abstract_id)\n abstract.from_kili(project_id=self.kili_project_id)\n text = str(abstract)\n texts.append(text)", "score": 0.8243098855018616 }, { "filename": "systematic_trading/strategy_ideas/ssrn_paper.py", "retrieved_chunk": " f\"https://papers.ssrn.com/sol3/papers.cfm?abstract_id={self.abstract_id}\"\n )\n self._kili_client = Kili(api_key=os.getenv(\"KILI_API_KEY\"))\n def exists_in_kili(self, project_id: str):\n assets = self._kili_client.assets(\n project_id=project_id,\n external_id_strictly_in=[self._external_id],\n fields=[\"id\"],\n disable_tqdm=True,\n )", "score": 0.816107451915741 }, { "filename": "systematic_trading/strategy_ideas/ssrn_abstract_crawler.py", "retrieved_chunk": " self.is_strategy = is_strategy\n self._driver = None\n def __from_url(self, url: str):\n return int(url.split(\"=\")[-1])\n def __download_and_save_to_kili(self, abstract_ids: list):\n for abstract_id in tqdm(abstract_ids):\n abstract = SsrnAbstract(abstract_id)\n if (\n abstract.exists_in_kili(self.kili_project_id)\n or not abstract.exists_in_ssrn()", "score": 0.8128055334091187 }, { "filename": "systematic_trading/strategy_ideas/ssrn_paper.py", "retrieved_chunk": "import os\nfrom kili.client import Kili\nimport requests\nfrom bs4 import BeautifulSoup\nclass SsrnPaper:\n def __init__(self, abstract_id: int):\n self.abstract_id = abstract_id\n self._external_id = str(abstract_id)\n self.pdf_path = None\n self.url = (", "score": 0.8119292855262756 } ]

[ { "filename": "systematic_trading/strategy_ideas/ssrn_abstract.py", "retrieved_chunk": " self._external_id = str(abstract_id)\n self._soup = None\n def __ssrn_page(self):\n if self._soup is not None:\n return self._soup\n headers = {\n \"User-Agent\": \"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36\"\n }\n response = requests.get(self.url, headers=headers)\n self._soup = BeautifulSoup(response.content, \"html.parser\")", "score": 0.8135843873023987 }, { "filename": "systematic_trading/datasets/raw/timeseries_daily.py", "retrieved_chunk": " to_timestamp = int(datetime.timestamp(datetime.now()))\n url = f\"https://query1.finance.yahoo.com/v7/finance/download/{ticker}?period1={from_timestamp}&period2={to_timestamp}&interval=1d&events=history&includeAdjustedClose=true\"\n for _ in range(retries):\n try:\n df = pd.read_csv(url)\n df[\"Date\"] = pd.to_datetime(df[\"Date\"]).dt.date.apply(\n lambda x: x.isoformat()\n )\n return df\n except urllib.error.HTTPError:", "score": 0.7909184694290161 }, { "filename": "systematic_trading/strategy_ideas/ssrn_abstract.py", "retrieved_chunk": " publication_date_tag = soup.find(\"meta\", {\"name\": \"citation_publication_date\"})\n self.publication_date = publication_date_tag[\"content\"]\n # title\n title_tag = soup.find(\"meta\", {\"name\": \"citation_title\"})\n self.title = title_tag[\"content\"]\n def __find_json_content_element(self, json_obj, target_id: str):\n results = []\n if isinstance(json_obj, dict):\n if json_obj.get(\"id\") == target_id:\n results.append(json_obj)", "score": 0.7839019298553467 }, { "filename": "systematic_trading/datasets/knowledge_graph/stocks.py", "retrieved_chunk": " driver.get(url)\n time.sleep(60)\n body = driver.find_element(\"xpath\", \"//body\")\n body_html = body.get_attribute(\"innerHTML\")\n soup = BeautifulSoup(body_html, \"html.parser\")\n hrefs = [\n a[\"href\"]\n for a in soup.find_all(\"a\")\n if a.has_attr(\"href\")\n and a[\"href\"].startswith(\"https://en.wikipedia.org/\")", "score": 0.7774010896682739 }, { "filename": "systematic_trading/helpers.py", "retrieved_chunk": " \"sec-ch-ua-platform\": '\"macOS\"',\n \"sec-fetch-dest\": \"document\",\n \"sec-fetch-mode\": \"navigate\",\n \"sec-fetch-site\": \"none\",\n \"sec-fetch-user\": \"?1\",\n \"sec-gpc\": \"1\",\n \"upgrade-insecure-requests\": \"1\",\n \"user-agent\": \"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36\",\n }\ndef retry_get(", "score": 0.7722309231758118 } ]

[ { "filename": "src/ask_api/llm/llm_util.py", "retrieved_chunk": " raise ValueError(f\"Unsupported language ({LANG})\")\n default_llm_name = DEFAULT_LLM_MODEL\n return build_llm(default_llm_name, prompt_config)", "score": 0.778359055519104 }, { "filename": "src/ask_api/llm/llm_util.py", "retrieved_chunk": " pass\n# 构造 Default LLM\ndef build_default_llm() -> LLMBase:\n \"\"\"\n 构造 Default LLM\n :return:\n \"\"\"\n try:\n prompt_config = ALL_BASIC_PROMPTS[LANG]\n except KeyError:", "score": 0.7752182483673096 }, { "filename": "src/ask_api/llm/llm_util.py", "retrieved_chunk": "# -*- coding: utf-8 -*-\n\"\"\"\nllm 工具函数\n\"\"\"\nfrom typing import Dict\nfrom ask_api.util.askapi_log import logging\nfrom ask_api.config.askapi_config import DEFAULT_LLM_MODEL, LANG\nfrom ask_api.prompt.basic import ALL_BASIC_PROMPTS\nfrom .base import LLMBase, LLMBuilder\nLLM_BUILDERS = {}", "score": 0.7677187323570251 }, { "filename": "src/ask_api/llm/base.py", "retrieved_chunk": "# -*- coding: utf-8 -*-\n\"\"\"\nllm 主要用于生成如下信息：\n1. 函数的功能描述\n2. 用户自然语言输入与函数参数的映射\n3. 函数的返回值描述\n4. 函数的异常信息描述\n5. 与函数进行自由回答\n\"\"\"\nfrom abc import ABC, abstractmethod", "score": 0.7511031627655029 }, { "filename": "src/ask_api/ask_api.py", "retrieved_chunk": "# -*- coding: utf-8 -*-\n\"\"\"\nask api, talk with your python code\n\"\"\"\nfrom ask_api.base.session import Session, Message\nfrom ask_api.llm.llm_util import build_default_llm\nfrom ask_api.base.role import FunctionRole, UserRole, Role\nfrom ask_api.util.askapi_log import logging\nGLOBAL_SESSIONS = {}\nFUNCTION_ROLES = {}", "score": 0.7403587698936462 } ]

[ { "filename": "systematic_trading/datasets/knowledge_graph/__init__.py", "retrieved_chunk": " self.dataset_df = pd.DataFrame(columns=self.expected_columns)", "score": 0.8570556640625 }, { "filename": "systematic_trading/datasets/index_constituents/__init__.py", "retrieved_chunk": " \"founded\",\n ]\n self.dataset_df = pd.DataFrame(columns=self.expected_columns)", "score": 0.8485445976257324 }, { "filename": "systematic_trading/datasets/raw/short_interest.py", "retrieved_chunk": " df[\"date\"] = self.tag_date.isoformat()\n df = df.reindex(columns=self.expected_columns)\n self.frames[symbol] = df\n def set_dataset_df(self):\n self.dataset_df = pd.concat([f for f in self.frames.values() if f is not None])\n if self.check_file_exists():\n self.add_previous_data()\n self.dataset_df.sort_values(by=[\"symbol\", \"date\", \"id\"], inplace=True)\n self.dataset_df.reset_index(drop=True, inplace=True)\nif __name__ == \"__main__\":", "score": 0.8448754549026489 }, { "filename": "systematic_trading/datasets/raw/earnings_surprise.py", "retrieved_chunk": " )\n df[\"date_reported\"] = pd.to_datetime(df[\"date_reported\"])\n df[\"id\"] = range(len(df))\n df[\"symbol\"] = symbol\n df[\"date\"] = self.tag_date.isoformat()\n df = df.reindex(columns=self.expected_columns)\n self.frames[symbol] = df\n def set_dataset_df(self):\n self.dataset_df = pd.concat([f for f in self.frames.values() if f is not None])\n if self.check_file_exists():", "score": 0.8390322923660278 }, { "filename": "systematic_trading/datasets/raw/earnings_forecast.py", "retrieved_chunk": " \"noOfEstimates\": \"no_of_estimates\",\n },\n inplace=True,\n )\n df[\"id\"] = range(len(df))\n df[\"symbol\"] = symbol\n df[\"date\"] = self.tag_date.isoformat()\n df = df.reindex(columns=self.expected_columns)\n self.frames[symbol] = df\n def set_dataset_df(self):", "score": 0.8343704342842102 } ]

[ { "filename": "systematic_trading/datasets/knowledge_graph/wikipedia.py", "retrieved_chunk": "from tqdm import tqdm\nDRIVE = \"/Users/edba/Downloads\"\nclass Wikipedia:\n def __init__(self):\n path = os.path.join(\n DRIVE,\n \"Raw\",\n \"Wikipedia\",\n \"enwiki-20230620-pages-articles-multistream.xml.bz2\",\n )", "score": 0.8393808603286743 }, { "filename": "systematic_trading/strategies/momentum.py", "retrieved_chunk": " path = os.path.join(\"/tmp\", \"momentum.pkl\")\n if os.path.exists(path):\n df = pickle.load(open(path, \"rb\"))\n else:\n dataset = load_dataset(\"edarchimbaud/timeseries-daily-sp500\", split=\"train\")\n df = pd.DataFrame(dataset)\n pickle.dump(df, open(path, \"wb\"))\n # Data Preparation\n symbols = df[\"symbol\"].unique()\n df[\"date\"] = pd.to_datetime(df[\"date\"])", "score": 0.8382130861282349 }, { "filename": "systematic_trading/features/predictors/predictors_monthly.py", "retrieved_chunk": " \"median_of_progressive_slopes_12m_quintile\",\n \"median_of_local_slopes_12m_quintile\",\n \"barycentre_of_progressive_slopes_12m_quintile\",\n ]\n def set_dataset_df(self):\n path = os.path.join(os.getenv(\"HOME\"), \"Downloads\", \"timeseries_daily_df.pkl\")\n if os.path.exists(path):\n with open(path, \"rb\") as handler:\n timeseries_daily_df = pickle.load(handler)\n else:", "score": 0.8166234493255615 }, { "filename": "systematic_trading/datasets/knowledge_graph/wikipedia.py", "retrieved_chunk": " self.handler = bz2.BZ2File(path, \"r\")\n def __del__(self):\n self.handler.close()\n def select_pages(self, titles: list[str]):\n \"\"\"\n Returns the Wikipedia pages of companies that are traded.\n \"\"\"\n pages = {}\n for line in tqdm(self.handler, total=22962775):\n line = line.decode(\"utf-8\")", "score": 0.814620316028595 }, { "filename": "systematic_trading/features/predictors/predictors_monthly.py", "retrieved_chunk": " timeseries_daily_df = pd.DataFrame(\n load_dataset(\n f\"{self.username}/timeseries-daily-{self.suffix}\",\n revision=self.tag_date.isoformat(),\n split=\"train\",\n ),\n )\n with open(path, \"wb\") as handler:\n pickle.dump(timeseries_daily_df, handler)\n timeseries_daily_df[\"date\"] = pd.to_datetime(timeseries_daily_df[\"date\"])", "score": 0.7881819009780884 } ]

[ { "filename": "ja3requests/sessions.py", "retrieved_chunk": " def send(self, request: Request):\n \"\"\"\n Send request.\n :return:\n \"\"\"\n rep = request.send()\n response = Response(rep)\n return response", "score": 0.8024646639823914 }, { "filename": "ja3requests/base/_sessions.py", "retrieved_chunk": " \"\"\"\n def send(self, *args, **kwargs):\n \"\"\"\n Send\n :return:\n \"\"\"", "score": 0.7921831607818604 }, { "filename": "ja3requests/request.py", "retrieved_chunk": " proxy_password,\n )\n context = HTTPContext(conn)\n context.set_payload(\n method=self.method,\n headers=self.headers,\n body=self.data,\n )\n response = conn.send(context)\n return response", "score": 0.7890183925628662 }, { "filename": "ja3requests/request.py", "retrieved_chunk": " :param ready_request:\n :return:\n \"\"\"\n for k, v in ready_request.__dict__.items():\n setattr(self, k, v)\n def send(self):\n \"\"\"\n Connection sending.\n :return:\n \"\"\"", "score": 0.7781943082809448 }, { "filename": "ja3requests/context.py", "retrieved_chunk": " HTTP Context message to send\n :return:\n \"\"\"\n self.start_line = \" \".join([self.method, self.connection.path, self.version])\n self._message = \"\\r\\n\".join([self.start_line, self.put_headers()])\n self._message += \"\\r\\n\\r\\n\"\n if self.body:\n self._message += self.body\n print(self._message)\n return self._message.encode()", "score": 0.7775939106941223 } ]

[ { "filename": "systematic_trading/strategy_ideas/ssrn_abstract_classifier.py", "retrieved_chunk": " continue\n groundtruth_category = groundtruth_labels[-1][\"jsonResponse\"][\n \"IS_STRATEGY\"\n ][\"categories\"][0][\"name\"]\n labels.append(self.label2id[groundtruth_category])\n abstract_id = int(asset[\"externalId\"])\n abstract = SsrnAbstract(abstract_id)\n abstract.from_kili(project_id=self.kili_project_id)\n text = str(abstract)\n texts.append(text)", "score": 0.8940868377685547 }, { "filename": "systematic_trading/strategy_ideas/ssrn_abstract_classifier.py", "retrieved_chunk": " )\n for asset in tqdm(assets):\n abstract_id = int(asset[\"externalId\"])\n abstract = SsrnAbstract(abstract_id)\n abstract.from_kili(project_id=self.kili_project_id)\n text = str(abstract)\n try:\n prediction = classifier(text)\n except RuntimeError:\n continue", "score": 0.8554692268371582 }, { "filename": "systematic_trading/strategy_ideas/ssrn_paper_summarizer.py", "retrieved_chunk": " def __init__(self):\n self._kili_client = Kili(api_key=os.getenv(\"KILI_API_KEY\"))\n self._openai_client = ChatOpenAI(\n model_name=\"gpt-3.5-turbo\",\n openai_api_key=os.getenv(\"OPENAI_API_KEY\"),\n temperature=0,\n )\n def __parse_label(self, asset):\n label = asset[\"labels\"][-1][\"jsonResponse\"]\n is_strategy = label[\"IS_STRATEGY\"][\"categories\"][0][\"name\"]", "score": 0.8275171518325806 }, { "filename": "systematic_trading/strategy_ideas/ssrn_abstract_crawler.py", "retrieved_chunk": " self.is_strategy = is_strategy\n self._driver = None\n def __from_url(self, url: str):\n return int(url.split(\"=\")[-1])\n def __download_and_save_to_kili(self, abstract_ids: list):\n for abstract_id in tqdm(abstract_ids):\n abstract = SsrnAbstract(abstract_id)\n if (\n abstract.exists_in_kili(self.kili_project_id)\n or not abstract.exists_in_ssrn()", "score": 0.819888710975647 }, { "filename": "systematic_trading/strategy_ideas/ssrn_paper_summarizer.py", "retrieved_chunk": " )\n if not os.path.exists(target_folder):\n os.makedirs(target_folder)\n for asset in tqdm(assets):\n key_elements, is_strategy = self.__parse_label(asset)\n if is_strategy == \"NO\":\n continue\n abstract_id = int(asset[\"externalId\"])\n path = os.path.join(target_folder, f\"{abstract_id}.md\")\n if os.path.exists(path):", "score": 0.8197282552719116 } ]

[ { "filename": "ja3requests/request.py", "retrieved_chunk": " proxy_password,\n )\n context = HTTPContext(conn)\n context.set_payload(\n method=self.method,\n headers=self.headers,\n body=self.data,\n )\n response = conn.send(context)\n return response", "score": 0.8611531853675842 }, { "filename": "ja3requests/context.py", "retrieved_chunk": " HTTP Context message to send\n :return:\n \"\"\"\n self.start_line = \" \".join([self.method, self.connection.path, self.version])\n self._message = \"\\r\\n\".join([self.start_line, self.put_headers()])\n self._message += \"\\r\\n\\r\\n\"\n if self.body:\n self._message += self.body\n print(self._message)\n return self._message.encode()", "score": 0.8166239261627197 }, { "filename": "ja3requests/sessions.py", "retrieved_chunk": " def send(self, request: Request):\n \"\"\"\n Send request.\n :return:\n \"\"\"\n rep = request.send()\n response = Response(rep)\n return response", "score": 0.8139276504516602 }, { "filename": "ja3requests/response.py", "retrieved_chunk": "from .const import MAX_LINE, MAX_HEADERS\nfrom .exceptions import InvalidStatusLine, InvalidResponseHeaders, IssueError\nclass HTTPResponse(BaseResponse):\n \"\"\"\n An HTTP response from socket connection.\n \"\"\"\n def __init__(self, sock, method=None):\n super().__init__()\n self.fp = sock.makefile(\"rb\")\n self._method = method", "score": 0.794098973274231 }, { "filename": "ja3requests/context.py", "retrieved_chunk": " HTTPContext\n \"\"\"\n def __init__(self, connection):\n super().__init__()\n self.protocol = DEFAULT_HTTP_CONTEXT_PROTOCOL\n self.version = DEFAULT_HTTP_VERSION\n self.connection = connection\n @property\n def message(self):\n \"\"\"", "score": 0.7939152717590332 } ]

[ { "filename": "ja3requests/connections.py", "retrieved_chunk": " \"\"\"\n self.connection.sendall(context.message)\n response = HTTPResponse(sock=self.connection, method=context.method)\n response.begin()\n return response\n def close(self):\n \"\"\"\n Close connection.\n :return:\n \"\"\"", "score": 0.8288273811340332 }, { "filename": "ja3requests/base/_context.py", "retrieved_chunk": " self._protocol = None\n self._version = None\n self._start_line = None\n self._method = None\n self._headers = None\n self._body = None\n self._message = None\n @property\n def protocol(self):\n \"\"\"", "score": 0.8202910423278809 }, { "filename": "ja3requests/connections.py", "retrieved_chunk": "from .const import DEFAULT_HTTP_PORT\nfrom .protocol.exceptions import SocketTimeout, ConnectTimeoutError\nclass HTTPConnection(BaseHttpConnection):\n \"\"\"\n HTTP connection.\n \"\"\"\n def __init__(self):\n super().__init__()\n self.scheme = DEFAULT_HTTP_SCHEME\n self.port = DEFAULT_HTTP_PORT", "score": 0.8156838417053223 }, { "filename": "ja3requests/request.py", "retrieved_chunk": " self.headers[\"Content-Length\"] = len(self.data)\n print(self.data)\n def ready_headers(self):\n \"\"\"\n Ready http headers.\n :return:\n \"\"\"\n # Default headers\n if self.headers is None:\n self.headers = default_headers()", "score": 0.8025442361831665 }, { "filename": "ja3requests/response.py", "retrieved_chunk": " self._chunked = False\n self._content_encoding = None\n self._content_length = 0\n def __repr__(self):\n return (\n f\"<HTTPResponse [{self.status_code.decode()}] {self.status_text.decode()}>\"\n )\n def _close_conn(self):\n fp = self.fp\n self.fp = None", "score": 0.7961614727973938 } ]

[ { "filename": "core/popup.py", "retrieved_chunk": " \"\"\"\n # widget setup\n super().__init__(master = master,\n text = message,\n font = font\n )", "score": 0.8284348845481873 }, { "filename": "core/popup.py", "retrieved_chunk": "from .const import PADX, PADY\nclass Popup(ctk.CTkToplevel):\n def __init__(self, icon_path: str, message: str, font: tuple) -> None:\n \"\"\"\n A window that displays a message instructing the user to restart the app after selecting a\n new theme.\n \"\"\"\n # setup widget\n super().__init__()\n self.title(\"restart\")", "score": 0.8266583681106567 }, { "filename": "core/rename.py", "retrieved_chunk": " def __init__(self, font: tuple) -> None: # pylint: disable=unused-argument\n \"\"\"\n A popup window for the user to rename a file or directory.\n \"\"\"\n # widget setup\n super().__init__(title = \"rename\",\n text = \"Enter a new name (including the file extension):\",\n # font = font\n )", "score": 0.8251450061798096 }, { "filename": "core/goto.py", "retrieved_chunk": " def __init__(self, font: tuple) -> None: # pylint: disable=unused-argument\n \"\"\"\n A window that allows users to view a specific path.\n \"\"\"\n # widget setup\n super().__init__(title = \"go to\",\n text = \"View any path in the file explorer:\",\n # font = font\n )", "score": 0.8183077573776245 }, { "filename": "core/popup.py", "retrieved_chunk": " warning = PopupLabel(self, message, font)\n warning.grid(row = 1,\n column = 0,\n padx = PADX,\n pady = PADY\n )\nclass PopupLabel(ctk.CTkLabel):\n def __init__(self, master: ctk.CTk, message: str, font: tuple) -> None:\n \"\"\"\n The text that goes inside the popup window.", "score": 0.7949959635734558 } ]

[ { "filename": "systematic_trading/datasets/knowledge_graph/stocks.py", "retrieved_chunk": " \"sector\": \"gics_sector\",\n \"industry\": \"gics_sub_industry\",\n },\n inplace=True,\n )\n return df\n def __download_sp500(self) -> pd.DataFrame:\n dataset = load_dataset(\"edarchimbaud/index-constituents-sp500\")\n df = dataset[\"train\"].to_pandas()\n df = df[[\"symbol\", \"security\", \"gics_sector\", \"gics_sub_industry\"]]", "score": 0.8281136155128479 }, { "filename": "systematic_trading/datasets/__main__.py", "retrieved_chunk": " tag_date = date.today()\n elif now.hour < 10:\n tag_date = date.today() - timedelta(days=1)\n else:\n raise ValueError(\"This script should be run between 21:00 and 10:00\")\n tag = tag_date.isoformat()\n print(\"Updating index constituents...\")\n index_constituents = SP500(tag_date=tag_date, username=username)\n if not index_constituents.check_file_exists(tag=tag):\n index_constituents.set_dataset_df()", "score": 0.8269750475883484 }, { "filename": "systematic_trading/datasets/knowledge_graph/stocks.py", "retrieved_chunk": "from systematic_trading.helpers import nasdaq_headers\nfrom systematic_trading.datasets.knowledge_graph import KnowledgeGraph\nfrom systematic_trading.datasets.knowledge_graph.wikipedia import Wikipedia\nclass Stocks(KnowledgeGraph):\n def __init__(self, tag_date: date = None, username: str = None):\n super().__init__(\"stocks\", tag_date, username)\n self.name = f\"stocks\"\n def __download_nasdaq(self) -> pd.DataFrame:\n \"\"\"\n Returns a DataFrame of NASDAQ stocks", "score": 0.8265970945358276 }, { "filename": "systematic_trading/datasets/knowledge_graph/stocks.py", "retrieved_chunk": " df.loc[:, \"country\"] = \"United States\"\n return df\n def __download(self) -> pd.DataFrame:\n path_tgt = os.path.join(\"data\", \"stocks.raw.csv\")\n if os.path.exists(path_tgt):\n return\n self.dataset_df = pd.concat(\n [\n self.__download_nasdaq(),\n self.__download_sp500(),", "score": 0.8170117735862732 }, { "filename": "systematic_trading/datasets/knowledge_graph/stocks.py", "retrieved_chunk": " \"\"\"\n self.dataset_df = self.__download()\n self.__add_wikipedia_title()\n self.__add_wikipedia_page()\n self.__add_relationships()", "score": 0.815605878829956 } ]

[ { "filename": "tests/integration_tests/test_snowflake_database.py", "retrieved_chunk": "):\n tool = ListSnowflakeDatabaseTableNamesTool(db=snowflake_container_eth_core)\n tool_input = \"\"\n result = tool._run(tool_input, mode=\"local\")\n for i in range(len(eth_core_table_long_names_select_list)):\n assert eth_core_table_long_names_select_list[i] in result\ndef test_get_snowflake_database_table_metadata_tool_run_local_one_table(\n snowflake_container_eth_core,\n):\n tool = GetSnowflakeDatabaseTableMetadataTool(db=snowflake_container_eth_core)", "score": 0.9371585845947266 }, { "filename": "tests/integration_tests/test_snowflake_database.py", "retrieved_chunk": " tool_input = \"ethereum.core.ez_nft_transfers\"\n result = tool._run(tool_input, mode=\"local\")\n # logger.debug(f\"{result=}\")\n print(f\"{result=}\")\n assert \"ethereum.core.ez_nft_transfers\" in result\ndef test_get_snowflake_database_table_metadata_tool_run_local_single_schema(\n snowflake_container_eth_core,\n):\n tool = GetSnowflakeDatabaseTableMetadataTool(db=snowflake_container_eth_core)\n tool_input = \"ethereum.core.ez_dex_swaps,ethereum.core.ez_nft_mints, ethereum.core.ez_nft_transfers\"", "score": 0.9128690361976624 }, { "filename": "tests/integration_tests/test_snowflake_database.py", "retrieved_chunk": " QuerySnowflakeDatabaseTool,\n)\nlogging.getLogger(\"sqlalchemy.engine\").setLevel(logging.ERROR)\nlogging.getLogger(\"snowflake.connector\").setLevel(logging.ERROR)\ndef test_snowflake_container_initialization_shroomdk(snowflake_params):\n container = SnowflakeContainer(**snowflake_params)\n assert container.shroomdk is not None\n assert container.metadata_parser is not None\ndef test_list_snowflake_database_table_name_tool_run_local(\n snowflake_container_eth_core, eth_core_table_long_names_select_list", "score": 0.8893143534660339 }, { "filename": "tests/integration_tests/test_snowflake_database.py", "retrieved_chunk": " tool._run(\"invalid_input\")\ndef test_query_snowflake_database_tool_dict_shroomdk(snowflake_container):\n tool = QuerySnowflakeDatabaseTool(db=snowflake_container)\n tool_input = {\n \"database\": \"ethereum\",\n \"schema\": \"beacon_chain\",\n \"query\": \"select * from ethereum.beacon_chain.fact_attestations limit 3\",\n }\n print(f\"\\n{tool_input=}\")\n result = tool._run(tool_input, mode=\"shroomdk\")", "score": 0.8754116892814636 }, { "filename": "tests/integration_tests/test_snowflake_database.py", "retrieved_chunk": " print(f\"{result=}\")\n num_items = len(result)\n assert num_items == 3\ndef test_query_snowflake_database_tool_dict_str_shroomdk(snowflake_container):\n tool = QuerySnowflakeDatabaseTool(db=snowflake_container)\n tool_input = \"database: ethereum, schema: beacon_chain, query: select * from ethereum.beacon_chain.fact_attestations limit 3\"\n print(f\"\\n{tool_input=}\")\n result = tool._run(tool_input, mode=\"shroomdk\")\n print(f\"{result=}\")\n num_items = len(result)", "score": 0.8650140166282654 } ]

[ { "filename": "tests/integration_tests/test_snowflake_database.py", "retrieved_chunk": "):\n tool = ListSnowflakeDatabaseTableNamesTool(db=snowflake_container_eth_core)\n tool_input = \"\"\n result = tool._run(tool_input, mode=\"local\")\n for i in range(len(eth_core_table_long_names_select_list)):\n assert eth_core_table_long_names_select_list[i] in result\ndef test_get_snowflake_database_table_metadata_tool_run_local_one_table(\n snowflake_container_eth_core,\n):\n tool = GetSnowflakeDatabaseTableMetadataTool(db=snowflake_container_eth_core)", "score": 0.9630643129348755 }, { "filename": "tests/integration_tests/test_snowflake_database.py", "retrieved_chunk": " tool_input = \"ethereum.core.ez_nft_transfers\"\n result = tool._run(tool_input, mode=\"local\")\n # logger.debug(f\"{result=}\")\n print(f\"{result=}\")\n assert \"ethereum.core.ez_nft_transfers\" in result\ndef test_get_snowflake_database_table_metadata_tool_run_local_single_schema(\n snowflake_container_eth_core,\n):\n tool = GetSnowflakeDatabaseTableMetadataTool(db=snowflake_container_eth_core)\n tool_input = \"ethereum.core.ez_dex_swaps,ethereum.core.ez_nft_mints, ethereum.core.ez_nft_transfers\"", "score": 0.9273324608802795 }, { "filename": "tests/integration_tests/test_snowflake_database.py", "retrieved_chunk": " QuerySnowflakeDatabaseTool,\n)\nlogging.getLogger(\"sqlalchemy.engine\").setLevel(logging.ERROR)\nlogging.getLogger(\"snowflake.connector\").setLevel(logging.ERROR)\ndef test_snowflake_container_initialization_shroomdk(snowflake_params):\n container = SnowflakeContainer(**snowflake_params)\n assert container.shroomdk is not None\n assert container.metadata_parser is not None\ndef test_list_snowflake_database_table_name_tool_run_local(\n snowflake_container_eth_core, eth_core_table_long_names_select_list", "score": 0.886442244052887 }, { "filename": "tests/integration_tests/test_snowflake_database.py", "retrieved_chunk": " print(f\"{result=}\")\n num_items = len(result)\n assert num_items == 3\ndef test_query_snowflake_database_tool_dict_str_shroomdk(snowflake_container):\n tool = QuerySnowflakeDatabaseTool(db=snowflake_container)\n tool_input = \"database: ethereum, schema: beacon_chain, query: select * from ethereum.beacon_chain.fact_attestations limit 3\"\n print(f\"\\n{tool_input=}\")\n result = tool._run(tool_input, mode=\"shroomdk\")\n print(f\"{result=}\")\n num_items = len(result)", "score": 0.8708415627479553 }, { "filename": "tests/integration_tests/test_snowflake_database.py", "retrieved_chunk": " tool._run(\"invalid_input\")\ndef test_query_snowflake_database_tool_dict_shroomdk(snowflake_container):\n tool = QuerySnowflakeDatabaseTool(db=snowflake_container)\n tool_input = {\n \"database\": \"ethereum\",\n \"schema\": \"beacon_chain\",\n \"query\": \"select * from ethereum.beacon_chain.fact_attestations limit 3\",\n }\n print(f\"\\n{tool_input=}\")\n result = tool._run(tool_input, mode=\"shroomdk\")", "score": 0.8685919046401978 } ]

[ { "filename": "chatweb3/tools/snowflake_database/tool.py", "retrieved_chunk": " )\n result_shroomdk = result_set.rows\n return result_shroomdk\n except Exception:\n # if shroomdk fails, use snowflake\n try:\n snowflake_database = self.db.get_database(database, schema)\n result_snowflake = snowflake_database.run_no_throw(query)\n assert isinstance(result_snowflake, str)\n return result_snowflake", "score": 0.8041974306106567 }, { "filename": "chatweb3/agents/agent_toolkits/snowflake/toolkit.py", "retrieved_chunk": " GetSnowflakeDatabaseTableMetadataTool,\n ListSnowflakeDatabaseTableNamesTool,\n QuerySnowflakeDatabaseTool,\n SnowflakeQueryCheckerTool,\n)\nclass SnowflakeDatabaseToolkit(SQLDatabaseToolkit):\n \"\"\"Snowflake database toolkit.\"\"\"\n # override the db attribute to be a SnowflakeContainer\n # it contains a dictionary of SnowflakeDatabase objects\n db: SnowflakeContainer = Field(exclude=True) # type: ignore[assignment]", "score": 0.7982046604156494 }, { "filename": "tests/integration_tests/test_snowflake_database.py", "retrieved_chunk": " tool._run(\"invalid_input\")\ndef test_query_snowflake_database_tool_dict_shroomdk(snowflake_container):\n tool = QuerySnowflakeDatabaseTool(db=snowflake_container)\n tool_input = {\n \"database\": \"ethereum\",\n \"schema\": \"beacon_chain\",\n \"query\": \"select * from ethereum.beacon_chain.fact_attestations limit 3\",\n }\n print(f\"\\n{tool_input=}\")\n result = tool._run(tool_input, mode=\"shroomdk\")", "score": 0.7936077117919922 }, { "filename": "chatweb3/metadata_parser.py", "retrieved_chunk": " return schema\nclass Database:\n def __init__(self, database_name, verbose=False):\n self.name = database_name\n self.schemas = {}\n self.verbose = verbose\n def __repr__(self) -> str:\n return f\"Database(name='{self.name}', schemas={self.schemas})\"\n def __eq__(self, other):\n if isinstance(other, Database):", "score": 0.7814571857452393 }, { "filename": "create_agent.py", "retrieved_chunk": " snowflake_toolkit = CustomSnowflakeDatabaseToolkit(\n db=snowflake_container_eth_core,\n llm=llm,\n readonly_shared_memory=None,\n verbose=True,\n )\n if conversation_mode:\n snowflake_toolkit.instructions = \"\"\n memory = ConversationBufferMemory(\n memory_key=\"chat_history\", return_messages=True", "score": 0.7778205871582031 } ]

[ { "filename": "chatweb3/agents/agent_toolkits/snowflake/toolkit.py", "retrieved_chunk": " llm=self.llm,\n prompt=ChatPromptTemplate(\n input_variables=input_variables,\n messages=cast(\n List[Union[BaseMessagePromptTemplate, BaseMessage]], messages\n ), # casting it for now XXX\n ),\n callback_manager=callback_manager,\n memory=self.readonly_shared_memory,\n verbose=verbose,", "score": 0.7924656271934509 }, { "filename": "chatweb3/agents/agent_toolkits/snowflake/base.py", "retrieved_chunk": " prefix=prefix,\n suffix=suffix,\n format_instructions=format_instructions,\n input_variables=input_variables,\n # **prompt_kwargs,\n )\n llm_chain = LLMChain(\n llm=llm,\n prompt=prompt,\n callback_manager=callback_manager,", "score": 0.7786717414855957 }, { "filename": "chatweb3/agents/agent_toolkits/snowflake/base.py", "retrieved_chunk": " input_variables=input_variables,\n output_parser=output_parser,\n # prefix=prefix,\n # suffix=suffix,\n format_instructions=format_instructions if format_instructions else None\n # system_template=system_template,\n # human_template=human_template,\n ** prompt_kwargs,\n )\n # llm chain", "score": 0.7765576839447021 }, { "filename": "chatweb3/agents/agent_toolkits/snowflake/base.py", "retrieved_chunk": " llm_chain_kwargs = llm_chain_kwargs or {}\n llm_chain = LLMChain(\n llm=llm,\n prompt=prompt,\n # memory=memory,\n callbacks=callbacks,\n verbose=verbose,\n **llm_chain_kwargs,\n )\n # agent", "score": 0.7683358192443848 }, { "filename": "chatweb3/agents/agent_toolkits/snowflake/base.py", "retrieved_chunk": " llm_chain_kwargs = llm_chain_kwargs or {}\n llm_chain = LLMChain(\n llm=llm,\n prompt=prompt,\n memory=memory,\n callbacks=callbacks,\n verbose=verbose,\n **llm_chain_kwargs,\n )\n # agent", "score": 0.7666774392127991 } ]

[ { "filename": "chatweb3/tools/snowflake_database/tool.py", "retrieved_chunk": "from chatweb3.tools.base import BaseToolInput\nfrom chatweb3.tools.snowflake_database.prompt import SNOWFLAKE_QUERY_CHECKER\nfrom chatweb3.utils import \\\n parse_table_long_name_to_json_list # parse_str_to_dict\nfrom config.config import agent_config\nfrom config.logging_config import get_logger\nlogger = get_logger(\n __name__, log_level=logging.INFO, log_to_console=True, log_to_file=True\n)\nLIST_SNOWFLAKE_DATABASE_TABLE_NAMES_TOOL_NAME = \"list_snowflake_db_table_names\"", "score": 0.8479888439178467 }, { "filename": "chatweb3/agents/agent_toolkits/snowflake/toolkit_custom.py", "retrieved_chunk": "from langchain.tools import BaseTool\nfrom pydantic import Field\nfrom chatweb3.agents.agent_toolkits.snowflake.toolkit import (\n SnowflakeDatabaseToolkit,\n)\nfrom chatweb3.tools.snowflake_database.prompt import SNOWFLAKE_QUERY_CHECKER\nfrom chatweb3.tools.snowflake_database.tool_custom import (\n TOOLKIT_INSTRUCTIONS,\n CheckQuerySyntaxTool,\n CheckTableMetadataTool,", "score": 0.8359751105308533 }, { "filename": "chatweb3/agents/agent_toolkits/__init__.py", "retrieved_chunk": "\"\"\"Agent toolkits.\"\"\"\nfrom chatweb3.agents.agent_toolkits.snowflake.base import (\n create_snowflake_agent,\n create_snowflake_chat_agent,\n create_sql_chat_agent,\n)\nfrom chatweb3.agents.agent_toolkits.snowflake.toolkit import (\n SnowflakeDatabaseToolkit,\n)\n__all__ = [", "score": 0.834125280380249 }, { "filename": "tests/integration_tests/test_snowflake_database.py", "retrieved_chunk": "\"\"\"\ntest_snowflake_database.py\nThis file contains the tests for the snowflake_database module.\n\"\"\"\nimport logging\nimport pytest\nfrom chatweb3.snowflake_database import SnowflakeContainer\nfrom chatweb3.tools.snowflake_database.tool import (\n GetSnowflakeDatabaseTableMetadataTool,\n ListSnowflakeDatabaseTableNamesTool,", "score": 0.8249433040618896 }, { "filename": "chatweb3/agents/agent_toolkits/snowflake/base.py", "retrieved_chunk": "\"\"\"Snowflake agent that uses a Chat model\"\"\"\nfrom typing import Any, List, Optional, Sequence\nfrom langchain.agents.agent import AgentExecutor, AgentOutputParser\nfrom langchain.agents.agent_toolkits.sql.base import create_sql_agent\nfrom langchain.agents.agent_toolkits.sql.prompt import SQL_PREFIX, SQL_SUFFIX\nfrom langchain.agents.agent_toolkits.sql.toolkit import SQLDatabaseToolkit\nfrom langchain.agents.chat.base import ChatAgent\nfrom langchain.agents.chat.output_parser import ChatOutputParser\nfrom langchain.agents.chat.prompt import FORMAT_INSTRUCTIONS\nfrom langchain.callbacks.base import BaseCallbackManager", "score": 0.8246432542800903 } ]

[ { "filename": "metaseg/generator/build_sam.py", "retrieved_chunk": " transformer_dim=prompt_embed_dim,\n iou_head_depth=3,\n iou_head_hidden_dim=256,\n ),\n pixel_mean=[123.675, 116.28, 103.53],\n pixel_std=[58.395, 57.12, 57.375],\n )\n sam.eval()\n if checkpoint is not None:\n with open(checkpoint, \"rb\") as f:", "score": 0.7784600257873535 }, { "filename": "metaseg/generator/build_sam.py", "retrieved_chunk": "def _build_sam(\n encoder_embed_dim,\n encoder_depth,\n encoder_num_heads,\n encoder_global_attn_indexes,\n checkpoint=None,\n):\n prompt_embed_dim = 256\n image_size = 1024\n vit_patch_size = 16", "score": 0.7699218392372131 }, { "filename": "metaseg/modeling/sam.py", "retrieved_chunk": "from metaseg.modeling.prompt_encoder import PromptEncoder\nclass Sam(nn.Module):\n mask_threshold: float = 0.0\n image_format: str = \"RGB\"\n def __init__(\n self,\n image_encoder: ImageEncoderViT,\n prompt_encoder: PromptEncoder,\n mask_decoder: MaskDecoder,\n pixel_mean: List[float] = [123.675, 116.28, 103.53],", "score": 0.7640836834907532 }, { "filename": "metaseg/generator/build_sam.py", "retrieved_chunk": " state_dict = torch.load(f)\n sam.load_state_dict(state_dict)\n return sam", "score": 0.763190746307373 }, { "filename": "metaseg/generator/automatic_mask_generator.py", "retrieved_chunk": " import cv2 # type: ignore # noqa: F401\n self.predictor = SamPredictor(model)\n self.points_per_batch = points_per_batch\n self.pred_iou_thresh = pred_iou_thresh\n self.stability_score_thresh = stability_score_thresh\n self.stability_score_offset = stability_score_offset\n self.box_nms_thresh = box_nms_thresh\n self.crop_n_layers = crop_n_layers\n self.crop_nms_thresh = crop_nms_thresh\n self.crop_overlap_ratio = crop_overlap_ratio", "score": 0.7588221430778503 } ]

[ { "filename": "metaseg/generator/build_sam.py", "retrieved_chunk": " )\nbuild_sam = build_sam_vit_h\ndef build_sam_vit_l(checkpoint=None):\n return _build_sam(\n encoder_embed_dim=1024,\n encoder_depth=24,\n encoder_num_heads=16,\n encoder_global_attn_indexes=[5, 11, 17, 23],\n checkpoint=checkpoint,\n )", "score": 0.8658862113952637 }, { "filename": "metaseg/generator/build_sam.py", "retrieved_chunk": " Sam,\n TwoWayTransformer,\n)\ndef build_sam_vit_h(checkpoint=None):\n return _build_sam(\n encoder_embed_dim=1280,\n encoder_depth=32,\n encoder_num_heads=16,\n encoder_global_attn_indexes=[7, 15, 23, 31],\n checkpoint=checkpoint,", "score": 0.8478034734725952 }, { "filename": "metaseg/generator/build_sam.py", "retrieved_chunk": "def build_sam_vit_b(checkpoint=None):\n return _build_sam(\n encoder_embed_dim=768,\n encoder_depth=12,\n encoder_num_heads=12,\n encoder_global_attn_indexes=[2, 5, 8, 11],\n checkpoint=checkpoint,\n )\nbuild_sam_vit_h = {\n \"default\": build_sam,", "score": 0.8336886167526245 }, { "filename": "scripts/amg.py", "retrieved_chunk": " print(\"Loading model...\")\n sam = sam_model_registry[args.model_type](checkpoint=args.checkpoint)\n _ = sam.to(device=args.device)\n output_mode = \"coco_rle\" if args.convert_to_rle else \"binary_mask\"\n amg_kwargs = get_amg_kwargs(args)\n generator = SamAutomaticMaskGenerator(sam, output_mode=output_mode, **amg_kwargs)\n if not os.path.isdir(args.input):\n targets = [args.input]\n else:\n targets = [", "score": 0.8140631914138794 }, { "filename": "metaseg/generator/build_sam.py", "retrieved_chunk": " transformer_dim=prompt_embed_dim,\n iou_head_depth=3,\n iou_head_hidden_dim=256,\n ),\n pixel_mean=[123.675, 116.28, 103.53],\n pixel_std=[58.395, 57.12, 57.375],\n )\n sam.eval()\n if checkpoint is not None:\n with open(checkpoint, \"rb\") as f:", "score": 0.7900510430335999 } ]

[ { "filename": "metaseg/utils/transforms.py", "retrieved_chunk": " def apply_image_torch(self, image: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Expects batched images with shape BxCxHxW and float format. This\n transformation may not exactly match apply_image. apply_image is\n the transformation expected by the model.\n \"\"\"\n # Expects an image in BCHW format. May not exactly match apply_image.\n target_size = self.get_preprocess_shape(\n image.shape[0], image.shape[1], self.target_length\n )", "score": 0.8208218216896057 }, { "filename": "metaseg/modeling/transformer.py", "retrieved_chunk": " bs, c, h, w = image_embedding.shape\n image_embedding = image_embedding.flatten(2).permute(0, 2, 1)\n image_pe = image_pe.flatten(2).permute(0, 2, 1)\n # Prepare queries\n queries = point_embedding\n keys = image_embedding\n # Apply transformer blocks and final layernorm\n for layer in self.layers:\n queries, keys = layer(\n queries=queries,", "score": 0.7746446132659912 }, { "filename": "metaseg/utils/data_utils.py", "retrieved_chunk": " return image\n elif isinstance(image, Mat) or isinstance(image, np.ndarray):\n return image\n else:\n raise ValueError(\"image must be a path or cv2.Mat\")\ndef load_server_image(image_path):\n imagedir = str(uuid4())\n system(f\"mkdir -p {imagedir}\")\n image = Image.open(BytesIO(image_path))\n if image.mode != \"RGB\":", "score": 0.7675999402999878 }, { "filename": "metaseg/utils/transforms.py", "retrieved_chunk": " Expects a numpy array with shape HxWxC in uint8 format.\n \"\"\"\n target_size = self.get_preprocess_shape(\n image.shape[0], image.shape[1], self.target_length\n )\n return np.array(resize(to_pil_image(image), target_size))\n def apply_coords(\n self, coords: np.ndarray, original_size: Tuple[int, ...]\n ) -> np.ndarray:\n \"\"\"", "score": 0.762260913848877 }, { "filename": "examples/image_cv_segautomask.py", "retrieved_chunk": " points_per_batch=64,\n min_area=0,\n output_path=\"output.jpg\",\n show=True,\n save=False,\n )\nif __name__ == \"__main__\":\n image = cv_imread(\"image.png\")\n image = cv_cvtColor(image, COLOR_BGR2RGB)\n main(image)", "score": 0.7602625489234924 } ]

[ { "filename": "{{cookiecutter.project_name|lower|replace('-', '_')|replace(' ', '_')}}/src/tests/conftest.py", "retrieved_chunk": "\"\"\"Pytest configuration file.\nUsed to execute code before running tests, in this case we want to use test database.\n\"\"\"\nimport asyncio\nfrom collections.abc import AsyncGenerator\nimport pytest\nimport pytest_asyncio\nfrom httpx import AsyncClient\nfrom sqlalchemy import select\nfrom sqlalchemy.ext.asyncio import create_async_engine", "score": 0.8048558831214905 }, { "filename": "{{cookiecutter.project_name|lower|replace('-', '_')|replace(' ', '_')}}/src/core/config.py", "retrieved_chunk": " # POSTGRESQL DEFAULT DATABASE\n DB_HOST: str\n DB_USER: str\n DB_PASSWORD: str\n DB_PORT: str\n DB_NAME: str\n DATABASE_URI: str = \"\"\n TEST_DATABASE_URI: str = \"\"\n # See https://docs.pydantic.dev/usage/validators/\n @validator(\"DATABASE_URI\")", "score": 0.7981274127960205 }, { "filename": "{{cookiecutter.project_name|lower|replace('-', '_')|replace(' ', '_')}}/src/tests/conftest.py", "retrieved_chunk": "async def sqla_engine(database):\n async with async_db.async_engine.begin() as conn:\n yield conn\[email protected](scope=\"session\")\nasync def db_session(sqla_engine):\n async with async_db.async_session() as session:\n yield session\n@pytest_asyncio.fixture\nasync def default_user(database) -> User:\n async with async_db.async_session() as session:", "score": 0.7892443537712097 }, { "filename": "{{cookiecutter.project_name|lower|replace('-', '_')|replace(' ', '_')}}/src/migrations/env.py", "retrieved_chunk": "# my_important_option = config.get_main_option(\"my_important_option\")\n# ... etc.\ndef get_database_uri():\n return app_config.settings.DATABASE_URI\ndef run_migrations_offline():\n \"\"\"Run migrations in 'offline' mode.\n This configures the context with just a URL\n and not an Engine, though an Engine is acceptable\n here as well. By skipping the Engine creation\n we don't even need a DBAPI to be available.", "score": 0.7834067940711975 }, { "filename": "{{cookiecutter.project_name|lower|replace('-', '_')|replace(' ', '_')}}/src/conftest.py", "retrieved_chunk": "\"\"\"\nUsed to set environment variable before running tests.\nWe need this to use test database.\n\"\"\"\nimport os\n# This will ensure using test database\nos.environ[\"ENVIRONMENT\"] = \"PYTEST\"", "score": 0.7825509309768677 } ]

[ { "filename": "metaseg/modeling/sam.py", "retrieved_chunk": " 'image': The image as a torch tensor in 3xHxW format,\n already transformed for input to the model.\n 'original_size': (tuple(int, int)) The original size of\n the image before transformation, as (H, W).\n 'point_coords': (torch.Tensor) Batched point prompts for\n this image, with shape BxNx2. Already transformed to the\n input frame of the model.\n 'point_labels': (torch.Tensor) Batched labels for point prompts,\n with shape BxN.\n 'boxes': (torch.Tensor) Batched box inputs, with shape Bx4.", "score": 0.8510486483573914 }, { "filename": "metaseg/utils/onnx.py", "retrieved_chunk": " return transformed_size\n def _embed_points(\n self, point_coords: torch.Tensor, point_labels: torch.Tensor\n ) -> torch.Tensor:\n point_coords = point_coords + 0.5\n point_coords = point_coords / self.img_size\n point_embedding = self.model.prompt_encoder.pe_layer._pe_encoding(point_coords)\n point_labels = point_labels.unsqueeze(-1).expand_as(point_embedding)\n point_embedding = point_embedding * (point_labels != -1)\n point_embedding = (", "score": 0.8384684324264526 }, { "filename": "metaseg/utils/onnx.py", "retrieved_chunk": " def forward(\n self,\n image_embeddings: torch.Tensor,\n point_coords: torch.Tensor,\n point_labels: torch.Tensor,\n mask_input: torch.Tensor,\n has_mask_input: torch.Tensor,\n orig_im_size: torch.Tensor,\n ):\n sparse_embedding = self._embed_points(point_coords, point_labels)", "score": 0.8383728861808777 }, { "filename": "metaseg/utils/onnx.py", "retrieved_chunk": " )\n if self.return_single_mask:\n masks, scores = self.select_masks(masks, scores, point_coords.shape[1])\n upscaled_masks = self.mask_postprocessing(masks, orig_im_size)\n if self.return_extra_metrics:\n stability_scores = calculate_stability_score(\n upscaled_masks, self.model.mask_threshold, self.stability_score_offset\n )\n areas = (upscaled_masks > self.model.mask_threshold).sum(-1).sum(-1)\n return upscaled_masks, scores, stability_scores, areas, masks", "score": 0.833490788936615 }, { "filename": "metaseg/sam_predictor.py", "retrieved_chunk": " for box in input_boxes:\n image = load_box(box.cpu().numpy(), image)\n elif type(input_box[0]) == int:\n input_boxes = np.array(input_box)[None, :]\n masks, _, _ = predictor.predict(\n point_coords=input_point,\n point_labels=input_label,\n box=input_boxes,\n multimask_output=multimask_output,\n )", "score": 0.8306891918182373 } ]

[ { "filename": "pytypest/_plugin.py", "retrieved_chunk": " setattr(session, SESSION_ATTR, manager)\ndef _manage_scope(request: pytest.FixtureRequest) -> Iterator[None]:\n hub.request = request\n manager: Manager = getattr(request.session, SESSION_ATTR)\n scope = Scope(request.scope)\n manager.enter_scope(scope)\n if hub.autouse:\n for fixture in hub.autouse:\n if fixture.scope == scope:\n fixture()", "score": 0.8832249641418457 }, { "filename": "pytypest/_plugin.py", "retrieved_chunk": " yield\n manager.exit_scope(scope)\n hub.request = None\nenter_function = pytest.fixture(scope='function', autouse=True)(_manage_scope)\nenter_class = pytest.fixture(scope='class', autouse=True)(_manage_scope)\nenter_module = pytest.fixture(scope='module', autouse=True)(_manage_scope)\nenter_package = pytest.fixture(scope='package', autouse=True)(_manage_scope)\nenter_session = pytest.fixture(scope='session', autouse=True)(_manage_scope)", "score": 0.8525438904762268 }, { "filename": "tests/test_fixtrues.py", "retrieved_chunk": " req = fixtures.get_request()\n assert req.function is test_get_request\n assert req.scope == 'function'\ndef test_get_request__not_active() -> None:\n msg = 'pytest plugin is not active'\n with pytest.raises(RuntimeError, match=msg):\n fixtures.get_request()\ndef test_make_temp_dir(isolated, scoped) -> None:\n with scoped('function'):\n path = fixtures.make_temp_dir()", "score": 0.8356162309646606 }, { "filename": "tests/test_fixtrues.py", "retrieved_chunk": " with scoped('function'):\n fixt1 = request.getfixturevalue(expected)\n fixt2 = fixtures.get_pytest_fixture(expected)\n fixt3 = given()\n assert fixt1 is fixt2\n assert fixt2 is fixt3\ndef test_defer(isolated, scoped) -> None:\n log = []\n with scoped('function'):\n fixtures.defer(lambda: log.append(1))", "score": 0.8244556784629822 }, { "filename": "tests/test_fixtrues.py", "retrieved_chunk": "from __future__ import annotations\nfrom contextlib import contextmanager\nfrom pathlib import Path\nimport pytest\nimport requests\nfrom pytypest import fixtures\nclass Global:\n attr: int = 42\ndef test_get_request(isolated, scoped) -> None:\n with scoped('function'):", "score": 0.8227670192718506 } ]

[ { "filename": "metaseg/utils/onnx.py", "retrieved_chunk": " return transformed_size\n def _embed_points(\n self, point_coords: torch.Tensor, point_labels: torch.Tensor\n ) -> torch.Tensor:\n point_coords = point_coords + 0.5\n point_coords = point_coords / self.img_size\n point_embedding = self.model.prompt_encoder.pe_layer._pe_encoding(point_coords)\n point_labels = point_labels.unsqueeze(-1).expand_as(point_embedding)\n point_embedding = point_embedding * (point_labels != -1)\n point_embedding = (", "score": 0.8578788042068481 }, { "filename": "metaseg/modeling/prompt_encoder.py", "retrieved_chunk": " bs = self._get_batch_size(points, boxes, masks)\n sparse_embeddings = torch.empty(\n (bs, 0, self.embed_dim), device=self._get_device()\n )\n if points is not None:\n coords, labels = points\n point_embeddings = self._embed_points(coords, labels, pad=(boxes is None))\n sparse_embeddings = torch.cat([sparse_embeddings, point_embeddings], dim=1)\n if boxes is not None:\n box_embeddings = self._embed_boxes(boxes)", "score": 0.8523239493370056 }, { "filename": "metaseg/utils/transforms.py", "retrieved_chunk": " old_h, old_w = original_size\n new_h, new_w = self.get_preprocess_shape(\n original_size[0], original_size[1], self.target_length\n )\n coords = deepcopy(coords).to(torch.float)\n coords[..., 0] = coords[..., 0] * (new_w / old_w)\n coords[..., 1] = coords[..., 1] * (new_h / old_h)\n return coords\n def apply_boxes_torch(\n self, boxes: torch.Tensor, original_size: Tuple[int, ...]", "score": 0.8322787880897522 }, { "filename": "metaseg/utils/onnx.py", "retrieved_chunk": " )\n if self.return_single_mask:\n masks, scores = self.select_masks(masks, scores, point_coords.shape[1])\n upscaled_masks = self.mask_postprocessing(masks, orig_im_size)\n if self.return_extra_metrics:\n stability_scores = calculate_stability_score(\n upscaled_masks, self.model.mask_threshold, self.stability_score_offset\n )\n areas = (upscaled_masks > self.model.mask_threshold).sum(-1).sum(-1)\n return upscaled_masks, scores, stability_scores, areas, masks", "score": 0.8310737609863281 }, { "filename": "metaseg/utils/onnx.py", "retrieved_chunk": " def forward(\n self,\n image_embeddings: torch.Tensor,\n point_coords: torch.Tensor,\n point_labels: torch.Tensor,\n mask_input: torch.Tensor,\n has_mask_input: torch.Tensor,\n orig_im_size: torch.Tensor,\n ):\n sparse_embedding = self._embed_points(point_coords, point_labels)", "score": 0.8301534652709961 } ]

[ { "filename": "docs/examples/cq_adaptive.py", "retrieved_chunk": " .cutBlind(-1)\n .faces(\">Z\")\n .rect(10, 2)\n .cutBlind(-1)\n)\npocket = wp.faces(\">Z[1]\")\ntop = wp.faces(\">Z\").workplane()\ntool = Endmill(diameter=1)\njob = Job(top, wp).adaptive(\n pocket,", "score": 0.9615779519081116 }, { "filename": "docs/examples/cq_helix.py", "retrieved_chunk": ")\ntop = wp.faces(\">Z\").workplane()\nhole_edges = wp.faces(\"<Z\").objects[0].innerWires()\ntool = Endmill(diameter=\"0.5 mm\")\njob = Job(top, wp).helix(hole_edges, tool)", "score": 0.9105746150016785 }, { "filename": "docs/examples/cq_drill.py", "retrieved_chunk": ")\ntop = wp.faces(\">Z\").workplane()\nhole_edges = wp.faces(\"<Z\").objects[0].innerWires()\ntool = Drill(diameter=\"1 mm\")\njob = Job(top, wp).drill(hole_edges, tool)", "score": 0.9013095498085022 }, { "filename": "tests/test_helix.py", "retrieved_chunk": " .circle(0.5)\n .cutThruAll()\n )\n top = wp.faces(\">Z\").workplane()\n hole_edges = wp.faces(\"<Z\").objects[0].innerWires()\n tool = Endmill(diameter=\"0.5 mm\")\n job = Job(top, wp, \"grbl\")\n job = job.helix(hole_edges, tool)\n job.to_gcode()\n job.show()", "score": 0.9009027481079102 }, { "filename": "tests/test_drill.py", "retrieved_chunk": " .circle(0.5)\n .cutThruAll()\n )\n top = wp.faces(\">Z\").workplane()\n hole_edges = wp.faces(\"<Z\").objects[0].innerWires()\n tool = Drill(diameter=\"1 mm\")\n job = Job(top, wp, \"grbl\")\n job = job.drill(hole_edges, tool)\n job.to_gcode()\n job.show()", "score": 0.896064043045044 } ]

[ { "filename": "pytypest/_scope_manager.py", "retrieved_chunk": "from __future__ import annotations\nfrom collections import deque\nfrom dataclasses import dataclass, field\nfrom typing import Callable\nfrom ._scope import Scope\nFinalizer = Callable[[], None]\n@dataclass\nclass ScopeManager:\n scope: Scope\n _deferred: deque[Finalizer] = field(default_factory=deque)", "score": 0.8333914279937744 }, { "filename": "pytypest/_plugin.py", "retrieved_chunk": " yield\n manager.exit_scope(scope)\n hub.request = None\nenter_function = pytest.fixture(scope='function', autouse=True)(_manage_scope)\nenter_class = pytest.fixture(scope='class', autouse=True)(_manage_scope)\nenter_module = pytest.fixture(scope='module', autouse=True)(_manage_scope)\nenter_package = pytest.fixture(scope='package', autouse=True)(_manage_scope)\nenter_session = pytest.fixture(scope='session', autouse=True)(_manage_scope)", "score": 0.7954537868499756 }, { "filename": "pytypest/_plugin.py", "retrieved_chunk": " setattr(session, SESSION_ATTR, manager)\ndef _manage_scope(request: pytest.FixtureRequest) -> Iterator[None]:\n hub.request = request\n manager: Manager = getattr(request.session, SESSION_ATTR)\n scope = Scope(request.scope)\n manager.enter_scope(scope)\n if hub.autouse:\n for fixture in hub.autouse:\n if fixture.scope == scope:\n fixture()", "score": 0.7943942546844482 }, { "filename": "tests/test_fixtrues.py", "retrieved_chunk": " assert log == []\n assert log == [1]\ndef test_defer__no_scope(isolated, scoped) -> None:\n msg = 'cannot find ScopeManager for `function` scope'\n with pytest.raises(LookupError, match=msg):\n fixtures.defer(lambda: None)\n with scoped('class'):\n with pytest.raises(LookupError, match=msg):\n fixtures.defer(lambda: None)\ndef test_enter_context(isolated, scoped) -> None:", "score": 0.7809450626373291 }, { "filename": "pytypest/_scope_manager.py", "retrieved_chunk": " def defer(self, callback: Finalizer) -> None:\n self._deferred.append(callback)\n def enter_scope(self) -> None:\n assert not self._deferred\n def exit_scope(self) -> None:\n while self._deferred:\n callback = self._deferred.pop()\n callback()", "score": 0.755386471748352 } ]