Datasets:

---

suriyagunasekar

/

stackoverflow-python-with-meta-data

like 10

[ "As this is xml with namespace, you can have like\nimport xml.etree.ElementTree as ET\nroot = ET.fromstring(xml_in_qes)\nmy_ns = {'root': 'WebsiteWhereDataComesFrom.com'}\nmyUser=[]\nfor eachUser in root.findall('root:user',my_ns):\n rep=eachUser.find(\"root:rep\",my_ns)\n print(rep.text)\n myUser.append(rep.text)\n\nnote: xml_in_qes is the XML attached in this question.\n('root:user',my_ns): search user in my_ns which has key root i.e WebsiteWhereDataComesFrom.com\n", "XML data implementation:\nimport xml.etree.ElementTree as ET\nxmlstring = '''\n<ArrayOfuser>\n <user>\n <active>true</active>\n <datelastlogin>8/21/2019 9:16:30 PM</datelastlogin>\n <dept>3</dept>\n <email>useremail</email>\n <firstname>userfirstname</firstname>\n <lastname>userlastname</lastname>\n <lastupdated>2/6/2019 11:10:29 PM</lastupdated>\n <lastupdatedby>lastupdateduserinitials</lastupdatedby>\n <loginemail>userloginemail</loginemail>\n <phone1>userphone</phone1>\n <phone2/>\n <rep>userinitials1</rep>\n </user>\n <user>\n <active>true</active>\n <datelastlogin>8/21/2019 9:16:30 PM</datelastlogin>\n <dept>3</dept>\n <email>useremail</email>\n <firstname>userfirstname</firstname>\n <lastname>userlastname</lastname>\n <lastupdated>2/6/2019 11:10:29 PM</lastupdated>\n <lastupdatedby>lastupdateduserinitials</lastupdatedby>\n <loginemail>userloginemail</loginemail>\n <phone1>userphone</phone1>\n <phone2/>\n <rep>userinitials2</rep>\n </user>\n <user>\n <active>true</active>\n <datelastlogin>8/21/2019 9:16:30 PM</datelastlogin>\n <dept>3</dept>\n <email>useremail</email>\n <firstname>userfirstname</firstname>\n <lastname>userlastname</lastname>\n <lastupdated>2/6/2019 11:10:29 PM</lastupdated>\n <lastupdatedby>lastupdateduserinitials</lastupdatedby>\n <loginemail>userloginemail</loginemail>\n <phone1>userphone</phone1>\n <phone2/>\n <rep>userinitials3</rep>\n </user>\n</ArrayOfuser>\n'''\n\nuser_array = ET.fromstring(xmlstring)\n\nreplist = []\nfor users in user_array.findall('user'):\n replist.append((users.find('rep').text))\n\nprint(replist)\n\nOutput:\n['userinitials1', 'userinitials2', 'userinitials3']\n\nJSON data implementation:\nuserlist = [\n {\n \"active\": \"true\",\n \"datelastlogin\": \"8/21/2019 9:16:30 PM\",\n \"dept\": 3,\n \"email\": \"useremail\",\n \"firstname\": \"userfirstname\",\n \"lastname\": \"userlastname\",\n \"lastupdated\": \"2/6/2019 11:10:29 PM\",\n \"lastupdatedby\": \"lastupdateduserinitials\",\n \"loginemail\": \"userloginemail\",\n \"phone1\": \"userphone\",\n \"phone2\": \"\",\n \"rep\": \"userinitials1\"\n },\n {\n \"active\": \"true\",\n \"datelastlogin\": \"12/1/2022 3:31:25 PM\",\n \"dept\": 5,\n \"email\": \"useremail\",\n \"firstname\": \"userfirstname\",\n \"lastname\": \"userlastname\",\n \"lastupdated\": \"4/8/2020 3:02:08 PM\",\n \"lastupdatedby\": \"lastupdateduserinitials\",\n \"loginemail\": \"userloginemail\",\n \"phone1\": \"userphone\",\n \"phone2\": \"\",\n \"rep\": \"userinitials2\"\n },\n {\n \"active\": \"true\",\n \"datelastlogin\": \"12/1/2022 3:31:25 PM\",\n \"dept\": 5,\n \"email\": \"useremail\",\n \"firstname\": \"userfirstname\",\n \"lastname\": \"userlastname\",\n \"lastupdated\": \"4/8/2020 3:02:08 PM\",\n \"lastupdatedby\": \"lastupdateduserinitials\",\n \"loginemail\": \"userloginemail\",\n \"phone1\": \"userphone\",\n \"phone2\": \"\",\n \"rep\": \"userinitials3\"\n }\n]\n\nreplist = []\nfor user in userlist:\n replist.append(user[\"rep\"])\n\nprint(replist)\n\nOutput:\n['userinitials1', 'userinitials2', 'userinitials3']\n\n", "If you like a sorted tabel of users who have last logged on you can put the parsed values into pandas:\nimport xml.etree.ElementTree as ET\nimport pandas as pd\n\ntree = ET.parse(\"activeusers.xml\")\nroot = tree.getroot()\n\nnamespaces = {\"xmlns\":\"WebsiteWhereDataComesFrom.com\" , \"xmlns:i\":\"http://www.w3.org/2001/XMLSchema-instance\"}\n\ncolumns =[\"rep\", \"datelastlogin\"]\nlogin = []\nusr = []\nfor user in root.findall(\"xmlns:user\", namespaces):\n for lastlog in user.findall(\"xmlns:datelastlogin\", namespaces):\n login.append(lastlog.text)\n \n for activ in user.findall(\"xmlns:rep\", namespaces):\n usr.append(activ.text)\n \ndata = list(zip(usr, login))\n\n\ndf = pd.DataFrame(data, columns=columns)\ndf[\"datelastlogin\"] = df[\"datelastlogin\"].astype('datetime64[ns]')\ndf = df.sort_values(by='datelastlogin', ascending = False)\nprint(df.to_string())\n\nOutput:\n rep datelastlogin\n1 userinitials2 2022-12-01 15:31:25\n0 userinitials1 2019-08-21 21:16:30\n\n" ]

[ 1, 0, 0 ]

[]

[]

[ "json", "python", "xml" ]

[ "I am running MacOS Big Sur (11.2.3).\nWith python2, I have Tkinter built-in.\nWith python3, it has to be installed manually and it's very simple, just run:\n$ brew install python-tk\n\nTo run python2 in a terminal, execute python file.py.\nTo run python3 in a terminal, execute python3 file.py.\n", "Based on the comments from above and the fact that Python must be linked to Tcl/Tk framework:\nIf you don't have Xcode command line tools, install those:\nxcode-select --install\n\nIf you don't have Tcl/Tk brew installation (check brew list), install that:\nbrew install tcl-tk\n\nThen, run \"brew uninstall python\" if that was not installed with option --with-tcl-tk (the current official option). Then install Python again, linking it to the brew installed Tcl/Tk:\nbrew install python --with-tcl-tk\n\n", "UPDATE: Other answers have found workarounds, so this answer is now outdated.\n12/18 Update: No longer possible for various reasons.\nBelow is now outdated. You'll have to install Python directly from python.org if you want to remove those warnings.\n\n2018 Update\nbrew reinstall python --with-tcl-tk\n\n\nNote: Homebrew now uses Python 3 by default - Homebrew Blog. Docs.\n\nTesting\npython should bring up system’s Python 2, python3 should bring up Python 3.\nidle points to system Python/tcl-tk. It will show an out-dated tcl-tk error (unless you brew install python@2 --with-tcl-tk)\nidle3 should bring up Python 3 with no warnings.\nCaveat\n--with-tcl-tk will install python directly from python.org, which you'll see when you run brew info python.\nMore info here.\n", "With brew and python3 you have to install Tinker separately.\nbrew message while installing python:\n\ntkinter is no longer included with this formula, but it is available separately:\n\nbrew install [email protected]\n\n", "If you're using pyenv you can try installing tcl-tk via homebrew and then activating the env. vars. mentioned in its caveats section, as detailed in this answer. Activating those env. vars. prior to installing python via homebrew may work for you:\n※ export PATH=\"/usr/local/opt/tcl-tk/bin:$PATH\"\n※ export LDFLAGS=\"-L/usr/local/opt/tcl-tk/lib\"\n※ export CPPFLAGS=\"-I/usr/local/opt/tcl-tk/include\"\n※ export PKG_CONFIG_PATH=\"/usr/local/opt/tcl-tk/lib/pkgconfig\"\n※ export PYTHON_CONFIGURE_OPTS=\"--with-tcltk-includes='-I$(brew --prefix tcl-tk)/include' \\\n --with-tcltk-libs='-L$(brew --prefix tcl-tk)/lib -ltcl8.6 -ltk8.6'\"\n※ brew reinstall python\n\n", "On mac OSX you must install TCL separately:\nYou will find instructions and dowloadables here: https://www.tcl.tk/software/tcltk/ and there: http://wiki.tcl.tk/1013\nIt requires a little bit of effort, but it is neither complicated nor difficult.\n", "It may be because you don't have the latest Xcode command line tools so brew built python from source instead of from bottle. Try:\nxcode-select --install\nbrew uninstall python\nbrew install python --use-brewed-tk\n\n", "It is a bit more complicated now, true you still need to have xcode command line tools and homebrew as a start. But the procedure changes constantly. Homebrew took out tcl-tk support long ago, and apple still only supplies v8.5 of tcl-tk. Anyway, it is possible, and I maintain a github gist personally to fix these issues.\nLatest update is using python 3.8.1 (will probably be usable on the 3.8.x branch later too) see here, just follow the steps outlined.\ngithub gist link to install tcl-tk with python\n", "On MacOS 11.13.1 using\nbrew install python\nbrew install python-tk\n\nI can now select TkAgg in matplotlib, but when I use it in ipython I get an error message\n%pylab\nmatplotlib.use('tkagg')\nplot([0,1])\n\nresults in\n2021-05-07 21:51:02.954 Python[10773:71016] -[NSApplication macOSVersion]: unrecognized selector sent to instance 0x11779f8c0\n2021-05-07 21:51:02.956 Python[10773:71016] *** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '-[NSApplication macOSVersion]: unrecognized selector sent to instance 0x11779f8c0'\n*** First throw call stack:\n(\n 0 CoreFoundation 0x00000001a0d97db8 __exceptionPreprocess + 240\n 1 libobjc.A.dylib 0x00000001a0ac10a8 objc_exception_throw + 60\n 2 CoreFoundation 0x00000001a0e28ba0 -[NSObject(NSObject) __retain_OA] + 0\n 3 CoreFoundation 0x00000001a0cf91e4 ___forwarding___ + 1444\n 4 CoreFoundation 0x00000001a0cf8b80 _CF_forwarding_prep_0 + 96\n 5 libtk8.6.dylib 0x000000012754a844 GetRGBA + 308\n 6 libtk8.6.dylib 0x000000012754a208 SetCGColorComponents + 132\n 7 libtk8.6.dylib 0x000000012754a65c TkpGetColor + 572\n 8 libtk8.6.dylib 0x00000001274ac714 Tk_GetColor + 220\n 9 libtk8.6.dylib 0x000000012749fea0 Tk_Get3DBorder + 204\n 10 libtk8.6.dylib 0x000000012749fcac Tk_Alloc3DBorderFromObj + 144\n 11 libtk8.6.dylib 0x00000001274adadc DoObjConfig + 840\n 12 libtk8.6.dylib 0x00000001274ad690 Tk_InitOptions + 348\n 13 libtk8.6.dylib 0x00000001274ad58c Tk_InitOptions + 88\n 14 libtk8.6.dylib 0x00000001274d4cb4 CreateFrame + 1448\n 15 libtk8.6.dylib 0x00000001274d4fac TkListCreateFrame + 156\n 16 libtk8.6.dylib 0x00000001274cde80 Initialize + 1848\n 17 _tkinter.cpython-39-darwin.so 0x000000012059a31c Tcl_AppInit + 80\n 18 _tkinter.cpython-39-darwin.so 0x000000012059487c Tkapp_New + 592\n 19 _tkinter.cpython-39-darwin.so 0x000000012059410c _tkinter_create + 580\n 20 Python 0x00000001007150c4 cfunction_vectorcall_FASTCALL + 88\n 21 Python 0x00000001007bac4c call_function + 128\n 22 Python 0x00000001007b8640 _PyEval_EvalFrameDefault + 39844\n 23 Python 0x00000001007ada9c _PyEval_EvalCode + 444\n 24 Python 0x00000001006c62b4 _PyFunction_Vectorcall + 364\n 25 Python 0x00000001006c58ac _PyObject_FastCallDictTstate + 208\n 26 Python 0x0000000100739bf4 slot_tp_init + 188\n 27 Python 0x000000010073f850 type_call + 300\n 28 Python 0x00000001006c5590 _PyObject_MakeTpCall + 132\n 29 Python 0x00000001007bacd8 call_function + 268\n 30 Python 0x00000001007b86e8 _PyEval_EvalFrameDefault + 40012\n 31 Python 0x00000001006c61fc _PyFunction_Vectorcall + 180\n 32 Python 0x00000001006c8c98 method_vectorcall + 124\n 33 Python 0x00000001007bac4c call_function + 128\n 34 Python 0x00000001007b8640 _PyEval_EvalFrameDefault + 39844\n 35 Python 0x00000001007ada9c _PyEval_EvalCode + 444\n 36 Python 0x00000001006c62b4 _PyFunction_Vectorcall + 364\n 37 Python 0x00000001006c8c98 method_vectorcall + 124\n 38 Python 0x00000001006c5e40 PyVectorcall_Call + 184\n 39 Python 0x00000001007b880c _PyEval_EvalFrameDefault + 40304\n 40 Python 0x00000001007ada9c _PyEval_EvalCode + 444\n 41 Python 0x00000001006c62b4 _PyFunction_Vectorcall + 364\n 42 Python 0x00000001006c5e40 PyVectorcall_Call + 184\n 43 Python 0x00000001007b880c _PyEval_EvalFrameDefault + 40304\n 44 Python 0x00000001007ada9c _PyEval_EvalCode + 444\n 45 Python 0x00000001006c62b4 _PyFunction_Vectorcall + 364\n 46 Python 0x00000001007bac4c call_function + 128\n 47 Python 0x00000001007b8664 _PyEval_EvalFrameDefault + 39880\n 48 Python 0x00000001006c61fc _PyFunction_Vectorcall + 180\n 49 Python 0x00000001007bac4c call_function + 128\n 50 Python 0x00000001007b8664 _PyEval_EvalFrameDefault + 39880\n 51 Python 0x00000001007ada9c _PyEval_EvalCode + 444\n 52 Python 0x00000001006c62b4 _PyFunction_Vectorcall + 364\n 53 Python 0x00000001007bac4c call_function + 128\n 54 Python 0x00000001007b8664 _PyEval_EvalFrameDefault + 39880\n 55 Python 0x00000001007ada9c _PyEval_EvalCode + 444\n 56 Python 0x00000001006c62b4 _PyFunction_Vectorcall + 364\n 57 Python 0x00000001007bac4c call_function + 128\n 58 Python 0x00000001007b8664 _PyEval_EvalFrameDefault + 39880\n 59 Python 0x00000001007ada9c _PyEval_EvalCode + 444\n 60 Python 0x00000001007a86a0 builtin_exec + 356\n 61 Python 0x00000001007150c4 cfunction_vectorcall_FASTCALL + 88\n 62 Python 0x00000001007bac4c call_function + 128\n 63 Python 0x00000001007b8664 _PyEval_EvalFrameDefault + 39880\n 64 Python 0x00000001006da678 gen_send_ex + 192\n 65 Python 0x00000001007b35b4 _PyEval_EvalFrameDefault + 19224\n 66 Python 0x00000001006da678 gen_send_ex + 192\n 67 Python 0x00000001007b35b4 _PyEval_EvalFrameDefault + 19224\n 68 Python 0x00000001006da678 gen_send_ex + 192\n 69 Python 0x00000001006d1cb0 method_vectorcall_O + 108\n 70 Python 0x00000001007bac4c call_function + 128\n 71 Python 0x00000001007b85c4 _PyEval_EvalFrameDefault + 39720\n 72 Python 0x00000001006c61fc _PyFunction_Vectorcall + 180\n 73 Python 0x00000001007bac4c call_function + 128\n 74 Python 0x00000001007b8664 _PyEval_EvalFrameDefault + 39880\n 75 Python 0x00000001006c61fc _PyFunction_Vectorcall + 180\n 76 Python 0x00000001007bac4c call_function + 128\n 77 Python 0x00000001007b85c4 _PyEval_EvalFrameDefault + 39720\n 78 Python 0x00000001007ada9c _PyEval_EvalCode + 444\n 79 Python 0x00000001006c62b4 _PyFunction_Vectorcall + 364\n 80 Python 0x00000001006c8c98 method_vectorcall + 124\n 81 Python 0x00000001007bac4c call_function + 128\n 82 Python 0x00000001007b86e8 _PyEval_EvalFrameDefault + 40012\n 83 Python 0x00000001007ada9c _PyEval_EvalCode + 444\n 84 Python 0x00000001006c62b4 _PyFunction_Vectorcall + 364\n 85 Python 0x00000001007bac4c call_function + 128\n 86 Python 0x00000001007b85c4 _PyEval_EvalFrameDefault + 39720\n 87 Python 0x00000001007ada9c _PyEval_EvalCode + 444\n 88 Python 0x00000001006c62b4 _PyFunction_Vectorcall + 364\n 89 Python 0x00000001007bac4c call_function + 128\n 90 Python 0x00000001007b85c4 _PyEval_EvalFrameDefault + 39720\n 91 Python 0x00000001006c61fc _PyFunction_Vectorcall + 180\n 92 Python 0x00000001007bac4c call_function + 128\n 93 Python 0x00000001007b85c4 _PyEval_EvalFrameDefault + 39720\n 94 Python 0x00000001007ada9c _PyEval_EvalCode + 444\n 95 Python 0x00000001006c62b4 _PyFunction_Vectorcall + 364\n 96 Python 0x00000001006c8c98 method_vectorcall + 124\n 97 Python 0x00000001006c5e40 PyVectorcall_Call + 184\n 98 Python 0x00000001007b880c _PyEval_EvalFrameDefault + 40304\n 99 Python 0x00000001007ada9c _PyEval_EvalCode + 444\n 100 Python 0x00000001006c62b4 _PyFunction_Vectorcall + 364\n 101 Python 0x00000001007bac4c call_function + 128\n 102 Python 0x00000001007b8664 _PyEval_EvalFrameDefault + 39880\n 103 Python 0x00000001007ada9c _PyEval_EvalCode + 444\n 104 Python 0x0000000100805498 run_eval_code_obj + 136\n 105 Python 0x00000001008053ac run_mod + 112\n 106 Python 0x0000000100802be8 pyrun_file + 168\n 107 Python 0x000000010080250c pyrun_simple_file + 276\n 108 Python 0x00000001008023b8 PyRun_SimpleFileExFlags + 80\n 109 Python 0x0000000100822560 pymain_run_file + 320\n 110 Python 0x0000000100821b2c pymain_run_python + 412\n 111 Python 0x000000010082194c Py_RunMain + 24\n 112 Python 0x0000000100822f50 pymain_main + 36\n 113 Python 0x00000001008231c8 Py_BytesMain + 40\n 114 libdyld.dylib 0x00000001a0c38420 start + 4\n)\nlibc++abi: terminating with uncaught exception of type NSException\nAbort trap: 6\n\n", "This is what worked for me with macOS Monterey:\nbrew install [email protected]\nor\nbrew install [email protected]\nDepending on which Python version you're running.\n", "It doesn't work in any OS whatsoever that doesn't have the TCL Toolkit already installed. While it's either already installed in many Linux distributions and/or bundled with Python bundles downloaded from python.org for Windows and Linux - and a a consequence of that is generally wrongly assumed that it's part of Python - it's not the case for macOS. There's official reasons for this described in the appropriate document:\n\nIf you are using macOS 12 Monterey or later, you may see problems with file open and save dialogs when using IDLE or other tkinter-based applications. The most recent versions of python.org installers (for 3.10.0 and 3.9.8) have patched versions of Tk to avoid these problems. They should be fixed in an upcoming Tk 8.6.12 release.\n\n\nIf you are using a Python from any current python.org Python installer for macOS (3.10.0+ or 3.9.0+), no further action is needed to use IDLE or tkinter. A built-in version of Tcl/Tk 8.6 will be used.\n\n\nIf you are using macOS 10.6 or later, the Apple-supplied Tcl/Tk 8.5 has serious bugs that can cause application crashes. If you wish to use IDLE or Tkinter, do not use the Apple-supplied Pythons. Instead, install and use a newer version of Python from python.org or a third-party distributor that supplies or links with a newer version of Tcl/Tk.\n\n\nPython's integrated development environment, IDLE, and the tkinter GUI toolkit it uses, depend on the Tk GUI toolkit which is not part of Python itself. For best results, it is important that the proper release of Tcl/Tk is installed on your machine. For recent Python installers for macOS downloadable from this website, here is a summary of current recommendations followed by more detailed information.\n\n\nIt has been already mentioned but the most popular way to do it is:\n$ brew install python-tk \n\nIt will work because python-tk formulae depends on other two: python and tcl-tk (hence you don't need to additionally do brew install python).\nIf you had already installed python with homebrew\n$ brew install python \n\nYou can have tkinter with\n$ brew install tcl-tk \n\n" ]

[ 61, 25, 11, 11, 9, 6, 4, 3, 3, 0, 0 ]

[]

[]

[ "macos", "python", "python_3.x", "tkinter" ]

[ "PyFPDF has a template designer for alignment etc. however it is not the same as Acrobat or other FDF editors where a field can be copy pasted multiple times as numbered increments. It uses a different csv methodology where you would need to add each repeated name as a line entry in the data file.\n\nFor the tutoring sample see https://pyfpdf.readthedocs.io/en/latest/Templates/index.html\nHowever, there is the newer version 2 which uses much the same features so unknown if designer is fully compatible as it was dropped from that forked version. Perhaps compare the output from V1 with the inputs for V2.\nMore relavent it has a newer methodology that may do what you require by using a more modular flextemplate\n" ]

[ 0 ]

[]

[]

[ "automation", "pdf", "pyfpdf", "python" ]

[ "You can use Pykson, JSON Serializer and Deserializer for Python which is somehow like Gson. It supports lists of objects and serialization names.\nSimply define your object model as JsonObject, and use Pykson to convert it back and forth to JSON.\nclass Student(JsonObject):\n first_name = StringField(serialized_name=\"fn\")\n last_name = StringField(serialized_name=\"ln\")\n age = IntegerField(serialized_name=\"a\")\n\njson_text = '{\"fn\":\"John\", \"ln\":\"Smith\", \"a\": 25}'\nstudent = Pykson.from_json(json_text, Student)\n\nstudent_json = Pykson.to_json(student)\nassert (json_text == student_json)\n\n", "You can use Jsonic library.\nJsonic is a lightweight utility for serializing/deserializing python objects to/from JSON.\nExample:\nfrom jsonic import serialize, deserialize\n\nclass User(Serializable):\n def __init__(self, user_id: str, birth_time: datetime):\n super().__init__()\n self.user_id = user_id\n self.birth_time = birth_time\n \nuser = User('id1', datetime(2020,10,11)) \nobj = serialize(user) # {'user_id': 'id1', 'birth_time': {'datetime': '2020-10-11 00:00:00', '_serialized_type': 'datetime'}, '_serialized_type': 'User'}\nnew_user : User = deserialize(obj) # new_user is a new instance of user with same attributes\n\nJsonic has some nifty features:\n\nYou can serialize objects of types that are not extending Serializable.\nThis can come handy when you need to serialize objects of\nthird party library classes.\nSupport for custom serializers and deserializers\nSerializing into JSON string or python dict\nTransient class attributes\nSupports both serialization of private fields or leave them out of the\nserialization process.\n\nFull disclosure: I'm the creator of Jsonic\n", "You can use BSON:\nhttps://pymongo.readthedocs.io/en/stable/api/bson/index.html\nThink of BSON as \"binary JSON\", meaning both:\n\nIt's output is not simple ASCII (as JSON is)\nIt has support for arbitrary byte strings (aka \"Binary\" is a native datatype)\n\nIn addition, it natively supports:\n\ndatetime objects\nObjectId objects\n\nBSON is the \"native\" object marshaling technique of MongoDb. So it is an object type that you get access to with the \"pymongo\" library. You can load pymongo and not use it for MongoDb, and just use the BSON portion.\nWe use BSON to marshal long arrays of floating point numbers, for which JSON is an awful choice. This is useful over raw TCP sockets, or other transports that send \"byte blobs\" as their payload, such as RabbitMQ messages.\n" ]

[ 4, 1, 0 ]

[]

[]

[ "gson", "json", "python" ]

[ "Thank you for the comments, I solved my problem using the idea of firing sensors so I can get the point on the wall when the \"bullet\" hits it.\n\nAs we can see when the bullet hits the wall we can create a line that connects the point to the car. This is not the best solution, as it takes time for the bullet to hit the wall and in the meantime, the car is \"blind\".\nAs Rabbid76 commented, using raycasting may be the solution I was looking for.\nCode for reference:\nSensor Bullet class\nclass SensorBullet:\n def __init__(self, car, base_angle, vel, color):\n self.x = car.x + CAR_WIDTH/2\n self.y = car.y + CAR_HEIGHT/2\n self.angle = car.angle\n self.base_angle = base_angle\n self.vel = vel\n self.color = color\n self.img = pygame.Surface((4, 4))\n self.fired = False\n self.hit = False\n self.last_poi = None\n\n def draw(self, win):\n pygame.draw.circle(win, self.color, (self.x, self.y), 2)\n\n def fire(self, car):\n self.angle = car.angle + self.base_angle\n self.x = car.x + CAR_WIDTH/2\n self.y = car.y + CAR_HEIGHT/2\n self.fired = True\n self.hit = False\n\n def move(self):\n if(self.fired):\n radians = math.radians(self.angle)\n vertical = math.cos(radians) * self.vel\n horizontal = math.sin(radians) * self.vel\n\n self.y -= vertical\n self.x -= horizontal\n\n def collide(self, x=0, y=0):\n bullet_mask = pygame.mask.from_surface(self.img)\n offset = (int(self.x - x), int(self.y - y))\n poi = TRACK_BORDER_MASK.overlap(bullet_mask, offset)\n if poi:\n self.fired = False\n self.hit = True\n self.last_poi = poi\n return poi\n\n def draw_line(self, win, car):\n if self.hit:\n pygame.draw.line(win, self.color, (car.x + CAR_WIDTH/2, car.y + CAR_HEIGHT/2), (self.x, self.y), 1)\n pygame.display.update()\n\n def get_distance_from_poi(self, car):\n if self.last_poi is None:\n return -1\n return math.sqrt((car.x - self.last_poi[0])**2 + (car.y - self.last_poi[1])**2)\n\nMethods the car must perform to use the sensor\n# Inside car's __init__ method\nself.sensors = [SensorBullet(self, 25, 12, (100, 0, 255)), SensorBullet(self, 10, 12, (200, 0, 255)), SensorBullet(self, 0, 12, (0, 255, 0)), SensorBullet(self, -10, 12, (0, 0, 255)), SensorBullet(self, -25, 12, (0, 0, 255))]\n# ------\n\n# Cars methods\ndef fireSensors(self): \n for bullet in self.sensors:\n bullet.fire(self)\n\ndef sensorControl(self):\n #print(contains(self.sensors, lambda x: x.hit))\n\n for bullet in self.sensors:\n if not bullet.fired:\n bullet.fire(self)\n\n for bullet in self.sensors:\n bullet.move()\n\ndef get_distance_array(self):\n return [bullet.get_distance_from_poi(self) for bullet in self.sensors]\n\n\n" ]

[ 0 ]

[]

[]

[ "euclidean_distance", "geometry", "math", "python", "raycasting" ]

[ "They aren't sharing the same memory. .data creates a memoryview object every time the attribute is accessed.\nYou can see from this session that it's a different address every time:\n>>> d.data\n<memory at 0x6ffff70bddc0>\n>>> d.data\n<memory at 0x6ffff70bdb80>\n>>> d.data\n<memory at 0x6ffff70bd1c0>\n\nIn your case, the object is reclaimed immediately after print() and the next one created happens to have the same address.\n", "In an ipython session:\nIn [38]: type(a.data)\nOut[38]: memoryview\n\nand the docs for that object:\nIn [39]: a.data?\nType: memoryview\nString form: <memory at 0x000002AE38BAF5F0>\nLength: 2\nDocstring: Create a new memoryview object which references the given object.\n\nThe print string of a memory view doesn't tell us anything about the databuffer address.\nIt can be used to make a view of the the array:\nIn [45]: aa = np.ndarray(a.shape, a.dtype, buffer=a.data) \nIn [46]: aa\nOut[46]: \narray([[1, 2, 3],\n [1, 2, 3]]) \nIn [47]: aa.base is a\nOut[47]: True\n\nThe data of __array_interface__ is closer to being a numeric address of the underlying data buffer. I don't think it can be used in code, but I find it useful when checking whether an array is a view or copy:\nIn [48]: a.__array_interface__\nOut[48]: \n{'data': (2947257325392, False),\n 'strides': None,\n 'descr': [('', '<i4')],\n 'typestr': '<i4',\n 'shape': (2, 3),\n 'version': 3}\nIn [49]: aa.__array_interface__['data']\nOut[49]: (2947257325392, False)\n\n" ]

[ 2, 1 ]

[]

[]

[ "numpy", "numpy_ndarray", "python" ]

[ "I think you want to use pandas.Series.apply which\n\nInvoke[s] function on values of Series.\n\nIt takes each value from the series, in your case df[\"Instance\"] and passes it through a function. Your function only needs to check whether the instance is in the element of subsets you're currently working on:\nfor subset in subsets:\n selected_rows = df[\"Instance\"].apply(lambda i: i in subset)\n # do things with selected rows\n\n" ]

[ 0 ]

[]

[]

[ "dataframe", "pandas", "python" ]

[ "Try:\ndf[\"desired_output\"] = df.groupby(\"id\")[\"status\"].transform(\n lambda x: df.loc[x.index, \"calc_date_id\"][(x != x.shift(-1)).idxmax()]\n)\nprint(df)\n\nPrints:\n id status calc_date_id desired_output\n0 1 Active 2022-07-05 2021-08-31\n1 1 Active 2022-06-07 2021-08-31\n2 1 Active 2021-08-31 2021-08-31\n3 1 Pending Action 2021-07-01 2021-08-31\n4 2 Pending Action 2022-11-20 2022-10-25\n5 2 Pending Action 2022-10-25 2022-10-25\n6 2 Active 2022-04-02 2022-10-25\n7 2 Pending Action 2022-02-28 2022-10-25\n8 2 Active 2021-07-01 2022-10-25\n9 3 Draft 2022-06-23 2022-06-23\n10 3 Active 2022-06-15 2022-06-23\n11 3 Draft 2022-04-07 2022-06-23\n12 3 Draft 2022-11-09 2022-06-23\n13 3 Draft 2020-08-18 2022-06-23\n14 3 Active 2020-03-19 2022-06-23\n15 3 Draft 2020-01-17 2022-06-23\n\n", "From your desired output I see, that the group \"boundaries\" are\npoints where particular value of status column occurs for the\nfirst time, regardless of id column.\nTo indicate first occurrences of values in status column, run:\nwrk = df.groupby('status', group_keys=False).apply(\n lambda grp: grp.assign(isFirst=grp.index[0] == grp.index))\nwrk.isFirst = wrk.isFirst.cumsum()\n\nTo see the result, print wrk and look at isFirst column.\nThen, to generate the result, run:\nresult = wrk.groupby('isFirst', group_keys=False).apply(\n lambda grp: grp.assign(desired_output=grp.calc_date_id.min()))\\\n .drop(columns='isFirst')\n\nNote the terminating drop to drop now unnecessary isFirst column.\nThe result, for your data sample, is:\n id status calc_date_id desired_output\n0 1 Active 2022-07-05 2021-08-31\n1 1 Active 2022-06-07 2021-08-31\n2 1 Active 2021-08-31 2021-08-31\n3 1 Pending Action 2021-07-01 2021-07-01\n4 2 Pending Action 2022-11-20 2021-07-01\n5 2 Pending Action 2022-10-25 2021-07-01\n6 2 Active 2022-04-02 2021-07-01\n7 2 Pending Action 2022-02-28 2021-07-01\n8 2 Active 2021-07-01 2021-07-01\n9 3 Draft 2022-06-23 2020-03-19\n10 3 Active 2022-06-15 2020-03-19\n11 3 Draft 2022-04-07 2020-03-19\n12 3 Draft 2022-11-09 2020-03-19\n13 3 Draft 2020-08-18 2020-03-19\n14 3 Active 2020-03-19 2020-03-19\n15 3 Draft 2022-01-17 2020-03-19\n\n" ]

[ 0, 0 ]

[]

[]

[ "dataframe", "group_by", "pandas", "python", "sorting" ]

[ "lst.append always returns None. It modifies lst in place, so all you need to do is return lst itself.\ndef append_size(lst):\n lst.append(len(lst))\n return lst\n\n\nThis is a violation, though, of the usually conventional (followed by list.append itself) that a function or method should either modify an argument in-place and return None or return a new value based on the unchanged argument.\nThere's no particular need to return lst, since presumably the caller already has a reference to the list, as they were able to pass it as an argument in the first place.\n" ]

[ 0 ]

[]

[]

[ "function", "python", "return" ]

[ "Try:\ns = \"\"\"\\\nName\nAlex\n\nAddress\n14 high street\nLondon\n\nColor\nblue\nred\n\nName\n\nBob\nColor\nblack\"\"\"\n\n\nimport pandas as pd\nfrom itertools import groupby\n\ncolnames = [\"Name\", \"Address\", \"Color\"]\n\n\ncol1, col2 = [], []\nfor k, g in groupby(\n (l for l in s.splitlines() if l.strip()), lambda l: l in colnames\n):\n (col2, col1)[k].append(\" \".join(g))\n\ndf = pd.DataFrame({\"col1\": col1, \"col2\": col2})\ndf = df.assign(col3=df.col1.eq(\"Name\").cumsum()).pivot(\n index=\"col3\", columns=\"col1\", values=\"col2\"\n)\ndf.index.name, df.columns.name = None, None\n\n\ndf[\"Color\"] = df[\"Color\"].str.split()\ndf = df.explode(\"Color\").fillna(\"\")\n\nprint(df[colnames])\n\nPrints:\n Name Address Color\n1 Alex 14 high street London blue\n1 Alex 14 high street London red\n2 Bob black\n\n", "Here's a vanilla python way to tackle the problem (rather than using pandas)\n\nLoad your data (you'll probably read the data from your file, but we'll use this placeholder instead)\n\ns = \"\"\"\nName\nAlex\n\nAddress\n14 high street\nLondon\n\nColor\nblue\nred\n\nName\n\nBob\nColor\nblack\n\"\"\"\n\n\nSplit up each entry by lines with 'Name'\n\nentities = [e for e in s.split('Name')]\n\nproduces\n[\n '\\n',\n '\\nAlex\\n\\nAddress\\n14 high street\\nLondon\\n\\nColor\\nblue\\nred\\n\\n',\n '\\n\\nBob\\nColor\\nblack\\n'\n]\n\n\nReplace the newlines with spaces, then clean up duplicate spaces\n\nentities = [e.replace('\\n',' ').replace(' ',' ') for e in entities]\n\nproduces\n[\n ' ',\n ' Alex Address 14 high street London Color blue red ',\n ' Bob Color black '\n]\n\n\nSplit each entry by space and toss any empty list entries\n\nentities = [\n [x for x in e.split(' ') if x != '']\n for e in entities\n]\n\nproduces\n[\n [],\n ['Alex', 'Address', '14', 'high', 'street', 'London', 'Color', 'blue', 'red'],\n ['Bob', 'Color', 'black']\n]\n\n\nGet rid of any empty entities\n\nentities = [e for e in entities if len(e) > 0]\n\nproduces\n[\n ['Alex', 'Address', '14', 'high', 'street', 'London', 'Color', 'blue', 'red'],\n ['Bob', 'Color', 'black']\n]\n\n\nEstablish our tokens, then for the index of each token, capture the list elements that appear before the next token\n\n# We'll store our findings here. \n# We'll use the name, which is the first element of our 'entity' list, \n# as the key for this dict.\n\nproperties = {}\n\nfor entity in entities:\n # We'll figure out where each token shows up in our list\n token_indices = []\n for token in tokens:\n # we could use \n # token_indices.append(entity.index(token)) \n # if we knew that each token would only show up once\n token_indices += [i for i,t in enumerate(entity) if t==token]\n\n # now we'll sort the list of indices so that we can be sure\n # we're dealing with them in order\n token_indices = sorted(token_indices)\n \n # since we haven't seen this person before, we'll establish a \n # dict for their properties.\n\n\n\n individual_properties = {}\n \n for k,_ in enumerate(token_indices):\n this_tkn_name = entity[token_indices[k]]\n this_tkn_idx = token_indices[k]\n next_tkn_idx = token_indices[k+1]\n\n # We'll iterate over each token's index\n if k+1 < len(token_indices):\n # this isn't the last token\n individual_properties[\n this_tkn_name\n ] = ' '.join(entity[this_tkn_idx+1:next_tkn_idx])\n\n else:\n # this is the last token\n individual_properties[\n this_tkn_name\n ] = ' '.join(entity[this_tkn_idx+1:])\n \n # the first element in the entity list is their name, so we can\n # find that with entity[0]\n properties[entity[0]] = individual_properties\n\nproduces\n{\n 'Alex': {\n 'Address': '14 high street London', \n 'Color': 'blue red'\n },\n 'Bob': {\n 'Color': 'black'\n }\n}\n\nNOTE: Depending on what you want to do with this, you may need further processing. Maybe you know what the colors are a list so you could use split(' ') to get a list instead of a single string.\n" ]

[ 2, 0 ]

[]

[]

[ "dataframe", "python", "python_re", "string" ]

[ "It looks like you are trying to install the aiogram library for Python, but you are encountering an error related to Microsoft Visual C++ 14.0 or greater. This error is occurring because the aiogram library has a dependency on the yarl library, which requires Microsoft Visual C++ 14.0 or greater to be installed on your system in order to build.\nTo fix this error, you will need to install Microsoft Visual C++ 14.0 or greater on your system. The error message provides a link to the Microsoft C++ Build Tools page, where you can download and install the necessary tools. Once you have installed Microsoft Visual C++ 14.0 or greater, you should be able to install the aiogram library successfully.\nHere are the steps to install Microsoft Visual C++ 14.0 or greater and fix the error:\n\nOpen the following link in your web browser: https://visualstudio.microsoft.com/visual-cpp-build-tools/\n\nOn the Microsoft C++ Build Tools page, click the \"Download\" button to download the installer for the build tools.\n\nRun the downloaded installer and follow the on-screen instructions to install Microsoft Visual C++ 14.0 or greater on your system.\n\nOnce the installation is complete, try installing the aiogram library again using pip. It should now install successfully without any errors.\n\n\n" ]

[ 0 ]

[]

[]

[ "aiogram", "python", "telegram_bot" ]

[ "It looks like you're trying to check if the username already exists in the database. To do this, you can use an SQL SELECT query to check if the username exists in the users table. If the query returns a result, then the username already exists and you can prompt the user to enter a different username.\nHere's one way you could implement this:\ndef signupInfo():\n #takes input for username and checks it is alphanumeric, username will also act as primary key so a validation for it being unique will occur\n username = input(\"Choose username: \")\n\n #check if username is alphanumeric or has enough characters\n while username.isalpha() == False or len(username) <= 3:\n username = input(\"invalid username, try again: \")\n\n #check for if the username is unique\n uniqueUserCheck = '''SELECT * FROM users WHERE `username` = ?'''\n cursor.execute(uniqueUserCheck, [username])\n user = cursor.fetchone()\n if user is not None:\n username = input(\"Choose a unique user: \")\n\n\nNote that in your current implementation, if the username is not unique, you will only prompt the user to enter a new username once, but the code does not check if the new username is unique. To fix this, you can use a while loop to keep prompting the user until they enter a unique username.\nHere's one way you could do this:\ndef signupInfo():\n #takes input for username and checks it is alphanumeric, username will also act as primary key so a validation for it being unique will occur\n username = input(\"Choose username: \")\n\n #check if username is alphanumeric or has enough characters\n while username.isalpha() == False or len(username) <= 3:\n username = input(\"invalid username, try again: \")\n\n #check for if the username is unique\n uniqueUserCheck = '''SELECT * FROM users WHERE `username` = ?'''\n cursor.execute(uniqueUserCheck, [username])\n user = cursor.fetchone()\n\n # keep prompting the user until they enter a unique username\n while user is not None:\n username = input(\"Choose a unique user: \")\n cursor.execute(uniqueUserCheck, [username])\n user = cursor.fetchone()\n\n\n" ]

[ 1 ]

[]

[]

[ "python", "sql", "validation" ]

[ "To use two different hidden layer node layouts and two activation functions with the MLPRegressor class, you can specify the hidden layer node layouts and activation functions as a list. For example:\nfrom sklearn.neural_network import MLPRegressor\n\n# Define the hidden layer node layout\nhidden_layer_sizes = (100)\n\n# Define the activation function\nactivation = 'relu'\n\n# Create the MLPRegressor model\nmodel = MLPRegressor(hidden_layer_sizes=hidden_layer_sizes, activation=activation, solver='lbfgs')\n\n# Fit the model to your data\nmodel.fit(X, Y)\n\nThe hidden_layer_sizes and activation parameters should be specified as lists with the same length. The model will then use the first hidden layer node layout with the first activation function, the second hidden layer node layout with the second activation function, and so on.\nYou may also want to consider using a different solver than 'lbfgs'. The 'lbfgs' solver is generally not recommended for use with neural networks because it can be slow and may not always converge. Some other solvers that may work well with the MLPRegressor class are 'adam' and 'sgd'.\n" ]

[ 1 ]

[]

[]

[ "artificial_intelligence", "deep_learning", "neural_network", "python", "scikit_learn" ]

[ "Here is a regex solution you could use:\n([12]\\d{3}-[01]\\d-[0-3]\\d)(\\D*?)(?:(?:luego de|pasados|tras)(?: ya)?(?: unos)? (\\d+) dias|(\\d+) dias (?:despues|luego))\n\nThis regex requires that there are no other digits between the date and the days. It also is a bit loose on grammar. It would also match \"luego de ya 3 dias\". You can of course make it more precise with a longer regex, but you get the picture.\nIn a program:\nfrom datetime import datetime, timedelta\nimport re\n\ndef add(datestr, days):\n return (datetime.strptime(datestr, \"%Y-%m-%d\") \n + timedelta(days=int(days))).strftime('%Y-%m-%d')\n\ninput_texts = [\n \"tras la aparicion del objeto misterioso el 2022-12-30 visitamos ese sitio nuevamente revisando detras de los arboles pero recien tras 3 dias ese objeto aparecio de nuevo tras 2 arboles\",\n \"luego el 2022-11-15 fuimos nuevamente a dicho lugar pero nada ocurrio y 3 dias despues ese objeto aparecio en el cielo durante el atardecer de aquel dia de verano\",\n \"Me entere del misterioso suceso ese 2022-11-01 y el 2022-11-15 fuimos al monte pero nada ocurrio, pero luego de 13 dias ese objeto aparecio en el cielo\"\n]\n\nfor input_text in input_texts:\n result = re.sub(r\"([12]\\d{3}-[01]\\d-[0-3]\\d)(\\D*?)(?:(?:luego de|pasados|tras)(?: ya)?(?: unos)? (\\d+) dias|(\\d+) dias (?:despues|luego))\",\n lambda m: m[1] + m[2] + add(m[1], m[3] or m[4]), \n input_text)\n print(result)\n\n" ]

[ 1 ]

[]

[]

[ "datetime", "python", "python_3.x", "regex", "regex_group" ]

[ "for i, (x,y) in enumerate(zip(dfa['a'], dfb['b'])):\n # apply your logic - 'when length of list is <=1 then take value...' and save it in dfa['a'][i]\n if len(x) <= 1:\n dfa.loc[i]['a'] = y\n\n", "Here is an approach using pandas.DataFrame.mask.\nFirst, make sure that the values of each dataframe/column are lists :\ndf1[\"a\"]= df1[\"a\"].str.strip(\"[]\").str.split(\",\") #skip if already a list\ndf2[\"a\"]= df2[\"a\"].str.strip(\"[]\").str.split(\",\") #skip if already a list\n\nThen, use pandas.Series.str.len :\nout = df1.mask(df1[\"a\"].str.len().le(1), other=df2[\"a\"], axis=0)\n\nOr use pandas.Series.transform :\nout = df1.mask(df1[\"a\"].transform(len).le(1), other=df2[\"a\"], axis=0)\n\n# Output :\nprint(out)\n a\n0 [5, 2, 7]\n1 [1, 2, 3]\n2 [7, 5]\n\n", "You can use numpy.where() to evaluate the criteria and return which version you want.\nIn this solution, I combine the two lists and then convert to a set to remove duplicates, and then convert back to a list because that is what you want at the end, I believe. Note that this does change the elements (you can [2,5,7] instead of [5,2,7])\nnew_df = np.where(\n df1['a'].apply(len)<=1,\n (df1['a'] + df2['a']).apply(set).apply(list),\n df1['a'])\n\n" ]

[ 0, 0, 0 ]

[]

[]

[ "pandas", "python" ]

[ "pandas.DataFrames are composed of Series objects (where a Series is simply a column. Series are container objects similar to Python lists and can actually be converted into a list by using their Series.tolist method.\nast.literal_eval is being applied on each element inside of your Series, converting them a string into dictionary, those dictionaries as then stored back into a Series.\nSo pretty much your code is working- but if you want a list of dictionaries instead of a Series of dictionaries, you'll need to the following:\nimport ast \nimport pandas as pd\nmovie = pd.read_csv(\"tmdb_5000_movies.csv\")\nmovie['genres'] = movie['genres'].apply(lambda x : ast.literal_eval(str(x)))\n\ngenres = movie['genres'].tolist()\nprint(genres)\n\n" ]

[ 1 ]

[]

[]

[ "pandas", "python" ]

[ "class Handler(watchdog.events.PatternMatchingEventHandler):\n def __init__(self):\n watchdog.events.PatternMatchingEventHandler.__init__(self, patterns=['*.pdf'],\n ignore_patterns = None,\n ignore_directories = False,\n case_sensitive = False)\n def on_created(self, event):\n print(f\"File was created at {event.src_path}\")\n OCRscript(self, event)\n def on_deleted(self, event):\n print(f\"File was deleted at {event.src_path}\")\n\nevent_handler = Handler()\nobserver = watchdog.observers.Observer()\nobserver.schedule(event_handler, \"C://Users//Installer//Desktop//tesseract test\",\n recursive = False)\nobserver.start()\nobserver.join()\n\nThis is the code I have been using to have a continually running watchdog. I call my other funcitions from within the class to ensure that the watchdog continues running. I have the functions I'm calling defined outside of the class just for debugging purposes. It helped me figure out which step was broken.\n" ]

[ 0 ]

[]

[]

[ "python", "python_watchdog", "tkinter" ]

[ "I think you're better off using a function based view with the typical \"if request.method = POST\" logic, this isn't really what the generic list view is for.\n@loginrequired\ndef device_list_view(request):\n context = {}\n if request.method = POST:\n form = SelectForm(request.POST)\n if form.is_valid():\n # if a request was posted and is valid, do your thing:\n # maybe your thing is to give your map view the device id\n # and render it\n # assuming your form has a field called device_id:\n context['device_id'] = form.device_id \n return render(request, 'tracking/device_map.html', context)\n \n # either request method is not post or the form wasn't valid\n user_devices = Device.objects.filter(who_added=request.user)\n device_forms = []\n for i, device in enumerate(user_devices):\n form = SelectForm(instance=device, prefix=i)\n device_forms.append(form)\n context['device_forms'] = device_forms\n return render(request, 'tracking/home.html', context)\n \n\nThe key part here is the if-else logic of checking whether the request was POST or not, you'll need to tweak it based on exactly what you want to happen. It sounds like what you're really doing is creating one form from which you're pulling multiple device_ids. This is a good reference for what's going on with the prefix bit and should help you decide whether to do things that way or with one form like you're trying.\n" ]

[ 0 ]

[]

[]

[ "django", "post", "python" ]

[ "Cleaning the input text for transformer models is not required. Removing stop words (which are considered as noise in conventional text representation like bag-of-words or tf-idf) can and probably will worsen the predictions of your BERT model.\nSince BERT is making use of the self-attention mechanism these 'stop words' are valuable information for BERT.\nConsider the following example:\nPython's NLTK library considers words like 'her' or 'him' as stop words. Let's say we want to process a text like: 'I told her about the best restaurants in town'.\nRemoving stop words with NLTK would give us: 'I told best restaurants town'. As you can see a lot of information is being discarded. Sure, we could try and train a classic ML classifier (i.e. topic classification, here food) but BERT captures a lot more semantic information based on the surroundings of words.\n", "You need to tokenize your text first. The BertTokenizer class handles everything you need from raw text to tokens. See this:\nfrom transformers import BertTokenizer, BertModel\nimport torch\n\ntokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\nmodel = BertModel.from_pretrained('bert-base-uncased')\n\ninputs = tokenizer(\"Hello, my dog is cute\", return_tensors=\"pt\")\noutputs = model(**inputs)\n\nlast_hidden_states = outputs.last_hidden_state\n\n", "According to me, pre-processing is not required while training as well as inferring from BERT. I can explain it with a few examples:\n\nSo as to continue to @Arthuro's answer, the stop words actually are valuable and BERT internally maps relations between different words.\nWe even should not clean things like a hyperlink or things like Twitter handle mentions (eg. @someones_twitter_handle). The reason is subword tokenization! BERT uses a special subword tokenization called WordPiece Tokenization. WordPiece tokenizer breaks the words into subwords. HuggingFace has a really nice article that explains how this works.\n\n" ]

[ 1, 0, 0 ]

[]

[]

[ "bert_language_model", "data_preprocessing", "nlp", "python", "text_classification" ]

[ "This type of execution in programs/script is usually done through the task scheduler\nA simple tutorial would be following the next steps:\n1: At the windows search box, type: task scheduler\n2: Open Task scheduler\n3: From Action menu select Create Task.\n4: At General tab, type a name for the task. e.g. \"StartPythonScript\" and select Run with highest privileges.\n5.1: At Triggers tab, click New.\n5.2: Select to begin the task: At system startup and click OK.\n6.1: At Actions tab, click New.\n6.2: At New Action window, select the option start a program and then click Browse.\n6.3: Choose the script that you want to run at startup and click Open.\n6.4: Click OK.\n7: At Conditions tab, clear the Start the task only if the computer is on AC Power checkbox and click OK.\n8: Restart your PC to apply the change.\nHope this solution will help you, anyway you can learn more about task scheduler here: https://learn.microsoft.com/en-us/windows/win32/taskschd/task-scheduler-start-page\n" ]

[ 0 ]

[]

[]

[ "app_startup", "python" ]

[ "IIUC, you can use numpy.where with pandas.DataFrame.sum.\nTry this :\ndf[\"impression\"] = np.where(df.sum(axis=1).gt(0), 1, 0)\n\n# Output :\nprint(df)\n​\n Day_1 Day_2 Day_3 impression\nuser1 2 2 1 1\nuser2 4 0 1 1\nuser3 8 0 0 1\nuser4 0 0 0 0\n\nIf you want to select a specific columns/days, you can use pandas.DataFrame.filter :\nnum_days = 2\nl = list(range(1, num_days+1))\npat= \"|\".join([str(x) for x in l])\n\nsub_df = df.filter(regex=\"Day_[{}]\".format(pat))\n\ndf[\"impression\"] = np.where(sub_df.sum(axis=1).gt(0), 1, 0)\n\n", "You can use the DataFrame.loc method to select the columns you want to sum, and then use the DataFrame.sum method to compute the sum of these columns. You can then use the DataFrame.clip method to set values less than 1 to 0 and values greater than or equal to 1 to 1. Finally, you can use the DataFrame.assign method to add the new impression column to the dataframe.\nimport pandas as pd\n\ndf = pd.DataFrame({'Day_1': [2, 4, 8, 0],\n 'Day_2': [2, 0, 0, 0],\n 'Day_3': [1, 1, 0, 0],\n index=['user1', 'user2', 'user3', 'user4'])\n\nnum_days = 2\nimp_cols = ['Day_'+str(i) for i in range(1, num_days+1)]\n\ndf = df.loc[:, imp_cols].sum(axis=1).clip(0, 1).to_frame(\"impression\")\n\ndf = df.assign(impression=impression)\n\n" ]

[ 1, 1 ]

[]

[]

[ "dataframe", "pandas", "python" ]

[ "There's not currently any Python property that would control the HTML background color. HTML and CSS is vast territory, so instead of trying to make a corresponding Python property for every possible style option, Bokeh provides a general mechanism for supplying your own HMTL templates so that any standard familiar CSS can be applied. \nThis is most easily accomplished by adding a templates/index.html file to a Directory-style Bokeh App. The template should be Jinja2 template. There are two substitutions required to be defined in the <head>:\n\n{{ bokeh_css }}\n{{ bokeh_js }}\n\nas well as two required in <body>:\n\n{{ plot_div }}\n{{ plot_script }}\n\nThe app will appear wherever the plot_script appears in the template. Apart from this, you can apply whatever HTML and CSS you need. You can see a concrete example here:\nhttps://github.com/bokeh/bokeh/blob/master/examples/app/crossfilter\nA boiled down template that changes the page background might look like this:\n<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <style>\n body { background: #2F2F2F; }\n </style>\n <meta charset=\"utf-8\">\n {{ bokeh_css }}\n {{ bokeh_js }}\n </head>\n <body>\n {{ plot_div|indent(8) }}\n {{ plot_script|indent(8) }}\n </body>\n</html>\n\n", "Changing the .bk-root style worked for me:\nfrom bokeh.resources import Resources\nfrom bokeh.io.state import curstate\nfrom bokeh.io import curdoc, output_file, save\nfrom bokeh.util.browser import view\nfrom bokeh.models.widgets import Panel, Tabs\nfrom bokeh.plotting import figure \n\nclass MyResources(Resources):\n @property\n def css_raw(self):\n return super().css_raw + [\n \"\"\".bk-root {\n background-color: #000000;\n border-color: #000000;\n }\n \"\"\"\n ]\n\nf = figure(height=200, width=200)\nf.line([1,2,3], [1,2,3])\n\ntabs = Tabs( tabs=[ Panel( child=f, title=\"TabTitle\" ) ], height=500 )\n\noutput_file(\"BlackBG.html\")\ncurstate().file['resources'] = MyResources(mode='cdn')\nsave(tabs)\nview(\"./BlackBG.html\")\n\n", "If you are using row or column for displaying several figures in the document, a workaround is setting the background attribute like this:\ncurdoc().add_root(row(fig1, fig2, background=\"beige\"))\n", "I know it is not the cleanest way to do it, but a workaround would be to modify file.html inside bokeh template folder\nFILE PATH\nCODE SNIPPET\n" ]

[ 6, 3, 1, 0 ]

[ "From Bokeh documentation:\n\nThe background fill style is controlled by the background_fill_color\n and background_fill_alpha properties of the Plot object:\nfrom bokeh.plotting import figure, output_file, show\n\noutput_file(\"background.html\")\n\np = figure(plot_width=400, plot_height=400)\np.background_fill_color = \"beige\"\np.background_fill_alpha = 0.5\n\np.circle([1, 2, 3, 4, 5], [2, 5, 8, 2, 7], size=10)\n\nshow(p)\n\n\n\n" ]

[ -1 ]

[ "bokeh", "python" ]

[ "Set view=None in your message.edit function call to remove all of the buttons.\n" ]

[ 0 ]

[]

[]

[ "discord", "pycord", "python" ]

[ "Managed to shrink it to one \"for\" loop. I am using \"any\" and \"all\" in combination with \"mask\".\nimport pandas as pd\nimport itertools\n\n\ndf = pd.DataFrame({'TFD': ['AA', 'SL', 'BB', 'D0', 'Dk', 'FF'],\n 'Snack': [1, 0, 1, 1, 0, 0],\n 'Trans': [1, 1, 1, 0, 0, 1],\n 'Dop': [1, 0, 1, 0, 1, 1]}).set_index('TFD')\n\ndf[\"all\"] = 0 # adding artifical columns so the results contains \"all\"\nlist_of_columns = list(df.columns)\nmy_result_list = [] # empty list where we put the results\ncomb = itertools.combinations_with_replacement(list_of_columns, 2)\nfor item in comb:\n temp_list = list_of_columns[:] # temp_list holds columns of interest\n if item[0] == item[1]:\n temp_list.remove(item[0])\n my_col_list = [item[0]] # my_col_list holds which occurance we count\n else:\n temp_list.remove(item[0])\n temp_list.remove(item[1])\n my_col_list = [item[0], item[1]]\n\n mask = df.loc[:, temp_list].any(axis=1) # creating mask so we know which rows to look at\n distance = df.loc[~mask, my_col_list].all(axis=1).sum() # calculating ocurrance\n my_result_list.append([item[0], item[1], distance]) # occurance info recorded in the list\n my_result_list.append([item[1], item[0], distance]) # occurance put in reverse so we get square form in the end\n\nresult = pd.DataFrame(my_result_list).drop_duplicates().pivot(index=1, columns=0, values=2) # construc DataFrame in squareform\nlist_of_columns.remove(\"all\")\nresult.loc[\"all\", \"all\"] = df.loc[:, list_of_columns].all(axis=1).sum() # fill in all/all occurances\nprint(result)\n\n" ]

[ 0 ]

[]

[]

[ "pandas", "python" ]

[ "My limited undestanding is that my python interpreter and packages are managed under Anaconda using Conda package manager, and my virtualenv was originally installed using pip..\nuninstalling virtualenv with pip and re-installing with conda fixed the issue\npip uninstall virtualenv\n\nconda install virtualenv\n\n", "I had this same issue when trying to install py2.7 on a newer system.\nThe root issue was that virtualenv was part of py3.7 and thus was not compatible:\n$ virtualenv -p python2.7 env\nRunning virtualenv with interpreter /usr/local/bin/python2.7\nNew python executable in /Users/blah/env/bin/python\nERROR: The executable /Users/blah/env/bin/python is not functioning\nERROR: It thinks sys.prefix is u'/Library/Frameworks/Python.framework/Versions/2.7' (should be u'/Users/blah/env')\nERROR: virtualenv is not compatible with this system or executable\n\n$ which virtualenv\n/Library/Frameworks/Python.framework/Versions/3.7/bin/virtualenv\n\n# install proper version of virtualenv \n$ pip2.7 install virtualenv\n\n$ /Library/Frameworks/Python.framework/Versions/2.7/bin/virtualenv -p python2.7 env\n\n$ . ./env/bin/activate\n(env) $ \n\n" ]

[ 34, 0 ]

[]

[]

[ "bash", "python", "virtualenv" ]

[ "Yes you need to groupby 'director_id', 'match_id' and then do a transform but the transform just needs to look at the difference between next element in both directions. In one direction you need to see if it equals 1 and in another -1 and then subset using the resulting True/False values.\ndf = df[\n df.groupby([\"director_id\", \"match_id\"])[\"calyear\"].transform(\n lambda x: (x.diff().eq(1)) | (x[::-1].diff().eq(-1))\n )\n]\n\nprint(df):\n director_id match_id calyear\n0 282 1111 2006\n1 282 1111 2007\n4 600 3333 2010\n5 600 3333 2011\n6 600 3333 2012\n8 600 3355 2015\n9 600 3355 2016\n11 753 4444 2008\n12 753 4444 2009\n\n" ]

[ 2 ]

[]

[]

[ "pandas", "python" ]

[ "The function print takes a parameter - you are giving it the result of backwards_alphabet(starting_letter).\nSince you aren't explicit about what backwards_alphabet() returns - which you do would with by including return 'this is what I am returning', it will return None by default.\nSo, you are calling print(None) and it prints 'None'.\nSince your function backwards_alphabet() already has all of the printing within it, you don't want to do print(backwards_alphabet(...)), you just want to call backwards_alphabet(...) by itself.\n" ]

[ 1 ]

[]

[]

[ "python" ]

[ "You can convert my_array to dict to simplify the retrieval of values:\nmy_array = [[\"var1\", 1], [\"var2\", 2], [\"var3\", 3], [\"var4\", 4], [\"var5\", 5]]\n\ndct = dict(my_array)\n\n# print var1\nprint(dct[\"var1\"])\n\nPrints:\n1\n\n" ]

[ 0 ]

[]

[]

[ "list", "python", "python_3.x" ]

[ "I was working on a similar functionality to implement a Plugin Architecture and ran into the same issue. Quoting @Gao Yuan from a similar question :-\n\nPyinstaller (currently v 3.4) can't detect imports like importlib.import_module(). The issue and solutions are detailed in Pyinstaller's documentation, which I pasted below as an entry point.\n\nBut of-course there is always a way. Instead you can use importlib.util.spec_from_file_location to load and then compile the module\nMinimum wokring example\niterface.py\n# from dependency import VARIABLE\n# from PySide6.QtCore import Qt\n\ndef hello_world():\n print(f\"this is a plugin calling QT {Qt.AlignmentFlag.AlignAbsolute}\")\n print(f\"this is a plugin calling DEPENDENCY {VARIABLE}\")\n\ncli.py\nimport sys\nimport types\nfrom pprint import pprint\nimport importlib.util\nimport sys\nif __name__ == \"__main__\":\n module_name = \"dependency\"\n module_file = \"plugins/abcplugin/dependency.py\"\n if spec:=importlib.util.spec_from_file_location(module_name, module_file):\n dependency = importlib.util.module_from_spec(spec)\n sys.modules[module_name] = dependency\n spec.loader.exec_module(dependency)\n\n module_name = \"interface\"\n module_file = \"plugins/abcplugin/interface.py\"\n if spec:=importlib.util.spec_from_file_location(module_name, module_file):\n interface = importlib.util.module_from_spec(spec)\n sys.modules[module_name] = interface\n spec.loader.exec_module(interface)\n\n sys.modules[module_name].hello_world()\n\nproject structure\ncli.exe\nplugins\n abcplugin\n __init__.py\n interface.py\n dependency.py\n\n complus\n __init__.py\n ...\n\nThumb Rules\n\nPlugin must always be relative to .exe\nAs you can notice I commented out # from dependency import VARIABLE in line one of interface.py. If you scripts depend on scripts in the same plugin, then you must load dependency.py before loading interface.py. You can then un-comment the line.\nIn pyinstaller.spec file you need to add hiddenimports in this case PySide6 and then un-comment # from PySide6.QtCore import Qt\nAlways use absolute imports when designing a plugin in reference to your project root folder. You can then set the module name to plugins.abcplugin.interface and plugins.abcplugin.dependency and also update from dependency import VARIABLE to from plugins.abcplugin.dependency import VARIABLE \n\nHope people find this usefull, cheers!!\n" ]

[ 0 ]

[]

[]

[ "dynamic_import", "pyinstaller", "python" ]

[ "With the help of itertools.groupby and itertools.chain, your goal can be achieved in a single line:\nfrom itertools import groupby\nfrom itertools import chain\n\ndict1 = {'key1':'x', 'key2':['one', 'two', 'three']}\ndict2 = {'key1':'x', 'key2':['four', 'five', 'six']}\ndict3 = {'key1':'y', 'key2':['one', 'two', 'three']}\nlist_of_dicts = [dict1, dict2, dict3]\n\nresult = [{'key1': k, 'key2': list(chain(*[x['key2'] for x in v]))} for k, v in groupby(list_of_dicts, lambda x: x['key1'])]\n\nprint(result)\n[{'key1': 'x', 'key2': ['one', 'two', 'three', 'four', 'five', 'six']}, {'key1': 'y', 'key2': ['one', 'two', 'three']}]\n\n", "Build an intermediate dict that uses key1 as a key to aggregate the key2 lists, and then build the final list of dicts out of that:\n>>> my_dicts = [\n... {'key1':'x', 'key2':['one', 'two', 'three']},\n... {'key1':'x', 'key2':['four', 'five', 'six']},\n... {'key1':'y', 'key2':['one', 'two', 'three']},\n... ]\n>>> agg_dict = {}\n>>> for d in my_dicts:\n... agg_dict.setdefault(d['key1'], []).extend(d['key2'])\n...\n>>> [{'key1': key1, 'key2': key2} for key1, key2 in agg_dict.items()]\n[{'key1': 'x', 'key2': ['one', 'two', 'three', 'four', 'five', 'six']}, {'key1': 'y', 'key2': ['one', 'two', 'three']}]\n\n" ]

[ 2, 0 ]

[]

[]

[ "dictionary", "list", "python" ]

[ "Yes, if you try to do sync work in a async method it will block FastAPI, something like this:\[email protected](\"/healthcheck\")\nasync def health_check():\n result = some_network_operation()\n return result\n\nWhere some_network_operation() is blocking the event loop because it is a synchronous method.\n", "I think I may have an answer to my question, which is that there are some weird edge cases where a sync endpoint handler can block FastAPI.\nFor instance, if we adjust the some_network_operation in my example to the following, it will block the entire application.\ndef some_network_operation():\n \"\"\" No, this is not a network operation, but it illustrates the point \"\"\"\n block = pow (363,100000000000000)\n\nI reached this conclusion based on this question: pow function blocking all threads with ThreadPoolExecutor.\nSo, it looks like the GIL maybe the culprit here.\nThat SO question suggests using the multiprocessing module (which will get around GIL). However, I tried this, and it still resulted in the same behavior. So my root problem remains unsolved.\nEither way, here is the entire example in the question edited to reproduce the problem:\nfrom fastapi import FastAPI\n\napp = FastAPI()\n\n\[email protected](\"/\")\nasync def root():\n return {\"message\": \"Hello World\"}\n\n\[email protected](\"/healthcheck\")\ndef health_check():\n result = some_network_operation()\n return result\n\n\ndef some_network_operation():\n block = pow(363,100000000000000)\n\n" ]

[ 0, 0 ]

[]

[]

[ "fastapi", "python", "sockets", "tcp" ]

[ "In fact, the solution was to import my customized class MultiColumnLabelEncoder as a pip package (You can find it through pip install multilllabelencoder==1.0.5).\nThen I passed the pip package to the .yml file or in the InferenceConfig of the azure ml environment.\nIn the score.py file, I imported the class as follows :\nfrom multilabelencoder import multilabelencoder\ndef init():\n global model\n\n # Call the custom encoder to be used dfor unpickling the model\n encoder = multilabelencoder.MultiColumnLabelEncoder() \n # Get the path where the deployed model can be found.\n model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'k_means_model_45.pkl')\n model = joblib.load(model_path)\n\nThen the deployment was successful. \nOne more important thing is I had to use the same pip package (multilabelencoder) in the training pipeline as here :\nfrom multilabelencoder import multilabelencoder \npipe = Pipeline([\n (\"encoder\", multilabelencoder.MultiColumnLabelEncoder(columns)),\n ('k-means', kmeans),\n])\n#Training the pipeline\ntrainedModel = pipe.fit(df)\n\n", "I am facing the same problem, trying to deploy a model that has dependency on some of my own scripts and got the error message:\n ModuleNotFoundError: No module named 'my-own-module-name'\n\nFound this \"Private wheel files\" solution in MS documentation and it works. The difference from the solution above is now I do not need to publish my scripts to pip. I think many people might face the same situation that for some reason you cannot or do not want to publish your scripts. Instead, your own wheel file is saved under your own blob storage.\nFollowing the documentation, I did the following steps and it worked for me. Now I can deploy my model that has dependency in my own scripts.\n\nPackage your own scripts that the model is dependent on into wheel file, and the wheel file is saved locally.\n\"your_path/your-wheel-file-name.whl\"\n\nFollow the instructions in the \"Private wheel files\" solution in MS documentation. Below is the code that worked for me.\n\n\n\nfrom azureml.core.environment import Environment\nfrom azureml.core.conda_dependencies import CondaDependencies\n\nwhl_url = Environment.add_private_pip_wheel(workspace=ws,file_path = \"your_pathpath/your-wheel-file-name.whl\")\n\nmyenv = CondaDependencies()\nmyenv.add_pip_package(\"scikit-learn==0.22.1\")\nmyenv.add_pip_package(\"azureml-defaults\")\nmyenv.add_pip_package(whl_url)\n\nwith open(\"myenv.yml\",\"w\") as f:\n f.write(myenv.serialize_to_string())\n\nMy environment file now looks like:\nname: project_environment\ndependencies:\n # The python interpreter version.\n\n # Currently Azure ML only supports 3.5.2 and later.\n\n- python=3.6.2\n\n- pip:\n - scikit-learn==0.22.1\n - azureml-defaults\n - https://myworkspaceid.blob.core/azureml/Environment/azureml-private-packages/my-wheel-file-name.whl\nchannels:\n- conda-forge\n\nI'm new to Azure ml. Learning by doing and communicating with the community. This solution works fine for me, hope that it helps.\n", "An alternative method that works for me is to register a \"model_src\"-directory containing both the pickled model and a custom module, instead of registering only the pickled model. Then, specify the custom module in the scoring script during deployment, e.g., using python's os module. Example below using sdk-v1:\nExample of \"model_src\"-directory\nmodel_src\n │\n ├─ utils # your custom module\n │ └─ multilabelencoder.py\n │\n └─ models # your pickled files\n └─ k_means_model_45.pkl \n\nRegister \"model_src\" in sdk-v1\nmodel = Model.register(model_path=\"./model_src\",\n model_name=\"kmeans\", \n description=\"model registered as a directory\",\n workspace=ws\n)\n\nCorrespondingly, when defining the inference config\ndeployment_folder = './model_src'\nscript_file = 'models/score.py'\nservice_env = Environment.from_conda_specification(kmeans-service,\n './environment.yml' # wherever yml is located locally\n)\ninference_config = InferenceConfig(source_directory=deployment_folder,\n entry_script=script_file,\n environment=service_env\n)\n\nContent of scoring script, e.g., score.py\n# Specify model_src as your parent\nimport os\ndeploy_dir = os.path.join(os.getenv('AZUREML_MODEL_DIR'),'model_src')\n\n# Import custom module\nimport sys\nsys.path.append(\"{0}/utils\".format(deploy_dir)) \nfrom multilabelencoder import MultiColumnLabelEncoder\n\nimport joblib\n\ndef init():\n global model\n\n # Call the custom encoder to be used dfor unpickling the model\n encoder = MultiColumnLabelEncoder() # Use as intended downstream \n \n # Get the path where the deployed model can be found.\n model = joblib.load('{}/models/k_means_model_45.pkl'.format(deploy_dir))\n\n\nThis method provides flexibility in importing various custom scripts in my scoring script.\n" ]

[ 4, 4, 0 ]

[]

[]

[ "azure_machine_learning_service", "azure_machine_learning_studio", "pickle", "python" ]

[ "@Tatthew you can do this with GroupBy.apply:\nimport pandas as pd\ndf = pd.DataFrame({'Date': ['2000-01-01', '2000-01-03',\n '2000-01-03', '2001-01-01',\n '2001-01-02', '2001-01-03',\n '2002-01-01', '2002-01-02',\n '2002-01-03'],\n 'Precipitation': [1, 6, 5, 3, 1, 0,\n 10, 8, 12]})\ndf = df.astype({'Date': datetime64})\ndf.groupby(df.Date.dt.year).apply(lambda df: df.Precipitation[df.Precipitation > 2].count())\n\n", "You can use this bit of code:\n# convert \"Precipitation\" and \"date\" values to proper types\ndf['Precipitation'] = df['Precipitation'].astype(int)\ndf[\"date\"] = pd.to_datetime(df[\"date\"])\n\n# find rows that have \"Precipitation\" > 2\ndf['Count']= df.apply(lambda x: x[\"Precipitation\"] > 2, axis=1)\n\n# group df by year and drop the \"Precipitation\" column\ndf.groupby(df['date'].dt.year).sum().drop(columns=['Precipitation'])\n\n", "@Tatthew you can do this with query and Groupby.size too.\nimport pandas as pd\ndf = pd.DataFrame({'Date': ['2000-01-01', '2000-01-03',\n '2000-01-03', '2001-01-01',\n '2001-01-02', '2001-01-03',\n '2002-01-01', '2002-01-02',\n '2002-01-03'],\n 'Precipitation': [1, 6, 5, 3, 1, 0,\n 10, 8, 12]})\ndf = df.astype({'Date': datetime64})\nabove_threshold = df.query('Precipitation > 2')\nabove_threshold.groupby(above_threshold.Date.dt.year).size()\n\n" ]

[ 0, 0, 0 ]

[]

[]

[ "dataframe", "pandas", "python" ]

[ "It looks like you are trying to access the value of the grade dictionary by using the value of the grade variable as a key. This won't work because the keys of the grade dictionary are strings (e.g. 'A', 'B', 'C'), but the value of the grade variable is also a string (e.g. 'A', 'B', 'C'), so you are trying to use a string as an index for a dictionary.\nTo fix this error, you should use the grade variable directly to access the value in the grade dictionary, like this:\nsections[sec][\"total\"] += grades[grade]\n\nThis will add the value associated with the grade string in the grades dictionary to the total field in the sections dictionary.\nHere is the updated code with this change:\ngrades = {'A': 100, 'B': 89, 'C': 79, 'D': 74, 'F': 69}\n\n# this section reads the file\n\n\ndef calculate_average():\n file = open(\"grades.txt\", \"r\")\n sections = {}\n for line in file:\n [_, sec, grade] = line.split(\"\\t\")\n grade = grade.strip()\n if sec in sections:\n sections[sec][\"count\"] += 1\n sections[sec][\"total\"] += grades[grade]\n else:\n sections[sec] = {}\n sections[sec][\"count\"] = 1\n sections[sec][\"total\"] = grades[grade]\n file.close()\n\n# This section calculates the average data based on file\n\n for sec, secdata in sections.items():\n avg = secdata[\" total \"] / secdata[\" count\"]\n print(\" {0} : {1}\".format(sec, round(avg, 2)))\n\n\nif __name__ == \"__main__\":\n calculate_average()\n\n", "You probably mean:\nsections[sec][\"total\"] = grades[grade]\n\n" ]

[ 0, 0 ]

[ "Welcome to SO\nThe error message you are getting is because you are trying to use the grade as a key to access the value in the grades dictionary. However, the grade variable contains the actual grade (e.g. 'A', 'B', etc.), not the key. To fix this, you need to use the grade variable to access the corresponding value in the grades dictionary, like this:\nsections[sec][\"total\"] = grades[grade]\n\nHere is the complete calculate_average function with this change applied:\ndef calculate_average():\n file = open(\"grades.txt\", \"r\")\n sections = {}\n for line in file:\n [_, sec, grade] = line.split(\"\\t\")\n grade = grade.strip()\n if sec in sections:\n sections[sec][\"count\"] += 1\n sections[sec][\"total\"] += grades[grade]\n else:\n sections[sec] = {}\n sections[sec][\"count\"] = 1\n sections[sec][\"total\"] = grades[grade]\n file.close()\n\n for sec, secdata in sections.items():\n avg = secdata[\" total \"] / secdata[\" count\"]\n print(\" {0} : {1}\".format(sec, round(avg, 2)))\n\nHowever, I think you can optimise this function a bit better.\nIt is good practice to use the with statement when working with files, as it ensures that the file is properly closed even if an error occurs. This ensures that the file is automatically closed when the with block is exited, even if an error occurs.\nSecondly, you can eliminate the need for the if statement inside the for loop that processes the lines in the file. Instead, the if statement is moved outside the for loop and only executed once for each section.\nA third improvement would be within the format of the string. You can use the below code to round which is more pythonic.\nprint(\" {sec} : {avg:.2f}\".format(sec=sec, avg=avg))\n\nFinally, you don't need to unpack your variables into a list you can remove this.\nI also think your variables could be renamed better to give you a final result of:\ndef calculate_average():\n with open(\"grades.txt\", \"r\") as file:\n sections = {}\n for line in file:\n _, section, grade = line.split(\"\\t\")\n grade = grade.strip()\n if section not in sections:\n sections[section] = {\"count\": 0, \"total\": 0}\n sections[section][\"count\"] += 1\n sections[section][\"total\"] += grades[grade]\n\n for section, section_data in sections.items():\n avg = section_data[\"total\"] / section_data[\"count\"]\n print(\" {section} : {avg:.2f}\".format(section=section, avg=avg))\n\nAnother possible improvement could be to use:\nsections[section][\"total\"] += grades.get(grade, 0)\n# rather than\nsections[section][\"total\"] += grades[grade]\n\nThis could stop exceptions being raised if the grade is not in the dictionary but it depends on your desired behaviour.\n" ]

[ -1 ]

[ "python" ]

[ "The code appears to be correctly importing the necessary modules and using them to create a Proxy object and a webdriver.Chrome object.\nHowever, there are a few issues with the code that may cause it to not work as expected:\nThe proxy_url variable is set to \"127.0.0.1:9009\", which is the localhost IP address and port number. This is not a valid proxy server, and it will not allow the webdriver.Chrome object to access the internet. You should replace this with a valid proxy server IP address and port number.\nThe response variable is not being used in the code. The requests.get() method is used to get a response from the proxy API, but the response is not being saved or used in any way. You should either use the response to get a valid proxy server IP address and port number, or remove the requests.get() method from the code.\nThe sleep() method is imported but not used in the code. This is not causing any errors, but it is unnecessary and can be removed from the code.\nHere is the corrected code:\nfrom selenium import webdriver\nfrom selenium.webdriver.common.proxy import *\nfrom selenium.webdriver.common.by import By\nimport requests\n\nresponse = requests.get(\"http://proxy.tinsoftsv.com/api/changeProxy.php?key=mykey_apiG&location=0\")\nproxy_url = response.json()[\"ip\"]\n\nproxy = Proxy({\n 'proxyType': ProxyType.MANUAL,\n 'httpProxy': proxy_url,\n 'sslProxy': proxy_url,\n 'noProxy': ''})\n\ncapabilities = webdriver.DesiredCapabilities.CHROME\nproxy.add_to_capabilities(capabilities)\n\ndriver = webdriver.Chrome(desired_capabilities=capabilities)\ndriver.get(\"https://whoer.net/zh\")\n\n", "To change the IP address used by your Selenium webdriver, you can do the following:\nfrom selenium import webdriver\nfrom selenium.webdriver.common.proxy import *\nfrom selenium.webdriver.common.by import By\nfrom time import sleep\nimport requests\n\n# Get the latest IP address from the proxy service\nresponse = requests.get(\"http://proxy.tinsoftsv.com/api/changeProxy.php?key=mykey_apiG&location=0\")\nip = response.json()[\"ip\"]\nport = response.json()[\"port\"]\n\n# Update the proxy URL with the new IP address\nproxy_url = f\"{ip}:{port}\"\n\n# Create a proxy object with the updated proxy URL\nproxy = Proxy({\n 'proxyType': ProxyType.MANUAL,\n 'httpProxy': proxy_url,\n 'sslProxy': proxy_url,\n 'noProxy': ''})\n\n# Update the capabilities object to use the new proxy\ncapabilities = webdriver.DesiredCapabilities.CHROME\nproxy.add_to_capabilities(capabilities)\n\n# Create a new instance of the webdriver with the updated capabilities\ndriver = webdriver.Chrome(desired_capabilities=capabilities)\ndriver.get(\"https://whoer.net/zh\")\n\n" ]

[ 0, 0 ]

[]

[]

[ "api", "python", "python_3.x", "selenium", "selenium_webdriver" ]

[ "The error message you are getting suggests that the DataFrame object you are trying to modify is immutable, which means that it cannot be changed. To solve this problem, you will need to create a new DataFrame object that contains the concatenated column. You can do this using the withColumn method, which creates a new DataFrame by adding a new column to the existing DataFrame. Here is an example of how you can use withColumn to concatenate the three columns in your DataFrame and create a new DataFrame:\nfrom pyspark.sql.functions import concat\n\n# Concatenate the columns and create a new DataFrame\ndf2 = df.withColumn(\"fullname\", concat(df[\"firstname\"], df[\"middlename\"], df[\"lastname\"]))\n\nThis will create a new DataFrame called df2 that contains the concatenated column. You can then use this new DataFrame for any further operations you need to perform on your data.\nAlternatively, if you don't need to keep the original DataFrame and want to modify the existing DataFrame, you can use the withColumn method in place of the assignment operator (=) to add the new column to the existing DataFrame:\nfrom pyspark.sql.functions import concat\n\n# Concatenate the columns and add the new column to the existing DataFrame\ndf = df.withColumn(\"fullname\", concat(df[\"firstname\"], df[\"middlename\"], df[\"lastname\"]))\n\nThis will add the new column to the existing DataFrame and you can then use the updated DataFrame for any further operations you need to perform.\n" ]

[ 1 ]

[]

[]

[ "databricks", "dataframe", "pandas", "pyspark", "python" ]

[ "I believe you are overthinking. Just remove the regular expression part, take the text and you will be fine.\nimport requests\nfrom bs4 import BeautifulSoup\n\nreqs = requests.get(url)\nsoup = BeautifulSoup(reqs.text, 'html.parser')\nresult = soup.find('section', attrs={'class':'onecol habonecol'}).text\nprint(result)\n\n", "You can query inside every section for the string you want. Like so:\ns.find('section', attrs={'class':'onecol habonecol'}).find(string=re.compile(r'.sentinel.*'))\n\nUsing this regular expression you will match any text that has sentinel in it, be careful that you will have to match some characters like spaces, that's why there is a . at beginning of the regex, you might want a more robust regex which you can test here:\nhttps://regex101.com/\n", "I ended up finding another method not using the string argument in find(), instead using something like the code below, which pulls the first instance of a section that contains a partial text match.\nsections = soup.find_all('section', attrs={'class':'onecol habonecol'})\n\n\nfor s in sections:\n text = s.text\n if 'CIcyano' in text:\n print(s)\n break\n\nlinks = s.find('a')\ndwn_url = links.get('href')\n\nThis works for my purposes and fetches the first instance of the matching filename, and grabs the URL.\n" ]

[ 0, 0, 0 ]

[]

[]

[ "beautifulsoup", "html", "partial", "python" ]

[ "You want user.upper(), not user.capitalize().\nFrom the help-text:\n>>> help(str.capitalize)\nHelp on method_descriptor:\n\ncapitalize(self, /)\n Return a capitalized version of the string.\n\n More specifically, make the first character have upper case and the rest lower\n case.\n\n>>> help(str.upper)\nHelp on method_descriptor:\n\nupper(self, /)\n Return a copy of the string converted to uppercase.\n\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "In PostgreSQL, you would do this by passing a row object to the function. For example, row_to_json is a function that accepts a row and returns JSON, so given this table\n Table \"public.users\"\n Column │ Type │ Collation │ Nullable │ Default \n═══════════════════╪═══════════════════╪═══════════╪══════════╪══════════════════════════════\n id │ integer │ │ not null │ generated always as identity\n name │ character varying │ │ │ \n registration_date │ date │ │ │ \n\nthis query\nselect name, row_to_json(users) from users;\n\ncould return\n name │ row_to_json \n═══════╪══════════════════════════════════════════════════════════\n Alice │ {\"id\":1,\"name\":\"Alice\",\"registration_date\":\"2022-10-27\"}\n Bob │ {\"id\":2,\"name\":\"Bob\",\"registration_date\":\"2022-10-27\"}\n\nTranslating this to SQLAlchemy, if you are only passing the columns from the table underlying the model (so no relationships), you can use FromClause.table_valued as a shortcut.\nq = sa.select(User.name, sa.func.row_to_json(User.__table__.table_valued()))\n\nIf you do require values from relationships, or only a subset of the table's fields, you need to use a subquery to specify the them*:\nsubq = sa.select(User.id, User.name).subquery() \nq = sa.select(sa.func.row_to_json(subq.table_valued()))\n\n\n* This part of the answer is inspired by this answer by Anatoly Ressin.\n" ]

[ 1 ]

[]

[]

[ "python", "sql", "sqlalchemy" ]

[ "Figured it out. I needed to typecast those columns to the long type first because the Dynamic frame is unsure about the data type.\ndynamicFrame_dept_summary = dynamicFrame_dept_summary.resolveChoice( specs =[('VOLUME','cast:long')]).resolveChoice( specs = [('MINUTES','cast:long')]).resolveChoice( specs = [('PLAN_MINUTES','cast:long')]).resolveChoice( specs = [('PLAN_RATE','cast:long')])\n" ]

[ 0 ]

[]

[]

[ "amazon_s3", "amazon_web_services", "aws_glue", "postgresql", "python" ]

[ "Try uninstall and reinstall Telethon again\nI also Can't login!\n", "form me work ok and i have testet\npython need to run all time\n\n\n#exit()\nimport sys\nfrom telethon import TelegramClient, events\nimport logging\nimport time\nimport telethon.tl.functions as _fn \n\n\nlogging.basicConfig(format='[%(levelname) 5s/%(asctime)s] %(name)s: %(message)s', level=logging.WARNING)\n\napi_id = row[2]\napi_hash = row[3] \nclient = TelegramClient(path+str(api_id), api_id, api_hash)\n\[email protected](events.NewMessage)\n\nasync def my_event_handler(event):\n print(event.raw_text)\n print(event)\n #add(event.raw_text)\n\nclient.start()\nclient.run_until_disconnected()\n\n\nprint('Finish...')\n\n\n\n" ]

[ 0, 0 ]

[]

[]

[ "python", "telegram", "telethon" ]

[ "Use dictionaries and zip:\ncreatures = {'easy': ['slime', 'dog', 'chicken'],\n 'medium': ['orc', 'wolf'],\n 'hard': ['dragon', 'golem', 'vampire']}\n\nattacks = {'easy': ['spits juice', 'bites', 'pecks'],\n 'medium': ['slams', 'howls'],\n 'hard': ['breaths fire', 'throws rocks', 'transforms']}\n\nchoice = 'medium'\n\nlinked = list(zip(creatures[choice], attacks[choice]))\n\nOutput:\n[('orc', 'slams'), ('wolf', 'howls')]\n\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "Simply loop through the string and splice the string according to the substring length and compare the splice string with the substring if it is equal return True.\nIllustration*\nstrs = \"Coding\"\nsubstr = \"ding\"\nslen = 4\ni = 0\n\ncheck = strs[i:slen+i]==substr\n\n# 1st iteration\nstrs[0:4+0] == ding\ncodi == ding # False\n\n# 2nd iteration\ni=1\nstrs[1:4+1] == ding\nodin == ding # False\n\n# 3rd iteration\ni=2\nstrs [2:4+2] == ding\nding == ding # True\n\n\nSolution\ndef str_exist(string, substring, slen):\n for i in range(len(string)):\n if string[i:slen+i] == substring:\n return True\n return False\n\nsubstring = \"high-level program\"\nstring = \"Python is a high-level programming language\"\nslen = len(substring)\n\nprint(str_exist(string, substring, slen))\n\n\nOUTPUT\nTrue\n\n", "Check this out. I've added comments in my code for better understanding of what this algorithm is doing.\ndef check_substr(S: str, sub_str: str) -> bool:\n \"\"\"\n This function tells whether the given sub-string \n in a string is present or not.\n \n Parameters\n S: str: The original string\n sub_str: str: The sub-string to be checked\n \n Returns\n result: boolean: Whether the string is present or not\n \"\"\"\n i = 0\n pointer = 0\n \n while (i < len(S)):\n # This means that we are already in that word\n # whose sub-part is already matched. For eg:\n # `program` in `programming`. Therefore we are\n # going to skip the rest of the word and check\n # the next word instead.\n if (S[i] != ' ' and pointer == len(sub_str)):\n while (i < len(S) and S[i] != ' '):\n i += 1\n i += 1\n pointer = 0\n \n if (i >= len(S)):\n break\n \n # If we encounter a space, we check whether we\n # have already found the sub-string or not.\n elif (S[i] == ' ' and pointer == len(sub_str)):\n break\n \n if (S[i] == sub_str[pointer]):\n pointer += 1\n \n else:\n # If the current element of the original \n # string matched with the first element of\n # the sub-string then we increment the \n # pointer by 1. Otherwise we set it to 0.\n pointer = 1 if (S[i] == sub_str[0]) else 0\n \n i += 1\n \n return pointer == len(sub_str)\n \nS = \"Python is a high-level programming\"\nprint(check_substr(S, \"high-level program\"))\nprint(check_substr(S, \"programming language\"))\n\nOutput\nFalse\nFalse\n\nTime Complexity\nO(n)\n\nEdits:\nAs @PGHE pointed out in the comments, we can also do the checking in punctuation characters and not only in spaces. Since the OP hasn't mentioned anything about the punctuation, I'm keeping this answer as it is.\n", "Add spaces on both sides of the substring and string, then test 'substring in string'\n" ]

[ 1, 1, 1 ]

[]

[]

[ "contains", "python", "regex", "string", "substring" ]

[ "Just in case there's someone still seeking for the answer.\nI ran into this same problem just today and realized since I already have Anaconda installed, I should not have used pip install virtualenv to install virtual environment as this would give me the error message when trying to initiate it later. Instead, I tried conda install virtualenv then entered virtualenv env_mysite and problem solved.\n", "Like @RyanWilcox mentioned, you might be inadvertently pointing virtualenv to the wrong Python installation. Virtualenv comes with a -p flag to let you specify which interpreter to use.\nIn my case,\nvirtualenv test_env\n\nthrew the same error as yours, while\nvirtualenv -p python test_env\n\nworked perfectly.\nIf you call virtualenv -h, the documentation for the -p flag will tell you which python it thinks it should be using; if it looks wonky, try passing -p python. For reference, I'm on virtualenv 1.11.6.\n", "In case anyone in the future runs into this problem - this is caused by your default Python distribution being conda. Conda has it's own virtual env set up process but if you have the conda distribution of python and still wish to use virtualenv here's how:\n\nFind the other python distribution on your machine: ls -ls /usr/bin/python*\nTake note of the availble python version that is not conda and run the code below (note for python 3 and above you have to upgrade virtualenv first): virtualenv -p python2.7(or your python version) flaskapp\n\n", "I've run across this problem myself. I wrote down the instructions in a README, which I have pasted below....\nI have found there are two things that work:\n\nMake sure you're running the latest virtualenv (1.5.1, of this writting)\nIf you're using a non system Python as your standard Python (which python to check) Forcefully use the System supplied one.\nInstead of virtualenv thing use /usr/bin/python2.6 PATH/TO/VIRTUALENV thing (or whatever which \npython returned to you - this is what it did for me when I ran into this issue)\n\n", "I had the same problem and as I see it now, it was caused by a messy Python installation. I have OS X installed for over a year since I bought a new laptop and I have already installed and reinstalled Python for several times using different sources (official binaries, homebrew, official binaries + hand-made adjustments as described here). Don't ask me why I did that, I'm just a miserable newbie believing everything will fix itself after being re-installed. \nSo, I had a number of different Pythons installed here and there as well as many hardlinks pointing at them inconsistently. Eventually I got sick of all of them and reinstalled OS X carefully cleaned the system from all the Pythons I found using find utility. Also, I have unlinked all the links pointing to whatever Python from everywhere. Then I've installed a fresh Python using homebrew, installed virtualenv and everything works as a charm now.\nSo, my recipe is:\nsudo find / -iname \"python*\" > python.log\nThen analyze this file, remove and unlink everything related to the version of Python you need, reinstall it (I did it with homebrew, maybe official installation will also work) and enjoy. Make sure you unlink everything python-related from /usr/bin and /usr/local/bin as well as remove all the instances of Frameworks/Python.framework/Versions/<Your.Version> in /Library and /System/Library. \nIt may be a dirty hack, but it worked for me. I prefer not to keep any system-wide Python libraries except pip and virtualenv and create virtual environments for all of my projects, so I do not care about removing the important libraries. If you don't want to remove everything, still try to understand whether your Pythons are, what links point to them and from where. Then think what may cause the problem and fix it.\n", "I ran into a variation of this \"not functioning\" error.\nI was trying to create an environment in a folder that included the path \".../Programming/Developing...\" which is actually \"/Users/eric/Documents/Programming:Developing/\"\nand got this error:\nImportError: No module named site\nERROR: The executable env/bin/python2.7 is not functioning\nERROR: It thinks sys.prefix is u'/Users/eric/Documents/Programming:Developing/heroku' (should be u'/Users/eric/Documents/Programming:Developing/heroku/env')\nERROR: virtualenv is not compatible with this system or executable\n\nI tried the same in a different folder and it worked fine, no errors and env/bin has what I expect (activate, etc.).\n", "I got the same problem and I found that it happens when you do not specify the python executable name properly. So for python 2x, for example:\nvirtualenv --system-site-packages -p python mysite\nBut for python 3.6 you need to specify the executable name like python3.6\nvirtualenv --system-site-packages -p python3.6 mysite \n", "On on OSX 10.6.8 leopard, after having \"upgraded\" to Lion, then downgrading again (ouch - AVOID!), I went through the Wolf Paulus method a few months ago, completely ignorant of python. Deleted python 2.7 altogether and \"replaced\" it with 3.something. My FTP program stopped working (Fetch) and who knows what else relies on Python 2.7. So at that point I downloaded the latest version of 2.7 from python.org and it's installer got me up and running - until i tried to use virtualenv.\nWhat seems to have worked for me this time was totally deleting Python 2.7 with this code:\nsudo rm -R /System/Library/Frameworks/Python.framework/Versions/2.7\n\nremoving all the links with this code: \nsudo rm /usr/bin/pydoc\nsudo rm /usr/bin/python\nsudo rm /usr/bin/pythonw\nsudo rm /usr/bin/python-config\n\nI had tried to install python with homebrew, but apparently it will not work unless all of XTools is installed, which I have been avoiding, since the version of XTools compatible with 10.6 is ancient and 4GB and mostly all I need is GCC, the compiler, which you can get here.\nSo I just installed with the latest download from python.org.\nThen had to reinstall easy_install, pip, virtualenv.\nDefinitely wondering when it will be time for a new laptop, but there's a lot to be said for buying fewer pieces of hardware (slave labor, unethical mining, etc).\n", "The above solutions failed for me, but the following worked:\npython3 -m venv --without-pip <ENVIRONMENT_NAME>\n. <ENVIRONMENT_NAME>/bin/activate\ncurl https://bootstrap.pypa.io/get-pip.py | python\ndeactivate\n\nIt's hacky, but yes, the core problem really did just seem to be pip.\n", "I did the following steps to get virtualenv working : \nUpdate virtualenv as follows : \n==> sudo pip install --upgrade virtualenv\n\nInitialize python3 virtualenv :\n==> virtualenv -p python3 venv\n\n", "I had this same issue, and I can confirm that the problem was with an outdated virtualenv.py file. \nIt was not necessary to do a whole install --upgrade. \nReplacing the virtualenv.py file with the most recent version sufficed. \n", "I also had this problem, and I tried the following method which worked for me:\nconda install virtualenv\n\nvirtualenv --system-site-packages /anaconda/envs/tensorflow (here envs keeps all the virtual environments made by user)\nsource /anaconda/envs/tensorflow/bin/activate\n\nHope it's helpful.\n", "I had this same issue when trying to install py2.7 on a newer system. The root issue was that virtualenv was part of py3.7 and thus was not compatible:\n$ virtualenv -p python2.7 env\nRunning virtualenv with interpreter /usr/local/bin/python2.7\nNew python executable in /Users/blah/env/bin/python\nERROR: The executable /Users/blah/env/bin/python is not functioning\nERROR: It thinks sys.prefix is u'/Library/Frameworks/Python.framework/Versions/2.7' (should be u'/Users/blah/env')\nERROR: virtualenv is not compatible with this system or executable\n\n$ which virtualenv\n/Library/Frameworks/Python.framework/Versions/3.7/bin/virtualenv\n\n# install proper version of virtualenv \n$ pip2.7 install virtualenv\n\n$ /Library/Frameworks/Python.framework/Versions/2.7/bin/virtualenv -p python2.7 env\n\n$ . ./env/bin/activate\n(env) $ \n\n", "If you continue to have trouble with virtualenv, you might try pythonbrew, instead. It's an alternate solution to the same problem. It works more like Ruby's rvm: It builds and creates an entire instance of Python, under $HOME/.pythonbrew, and then sets up some bash functions that allow you to switch easily between versions. Where virtualenv shadows the system version of Python, using symbolic links as part of its solution, pythonbrew builds entirely self-contained installations of Python.\nI used virtualenv for years. It's a decent solution, but I've switched to pythonbrew lately. Having completely self-contained Python instances means that installing a new one takes awhile (since pythonbrew actually compiles Python from scratch), but the self-contained nature of each installation appeals to me. And disk is cheap.\n" ]

[ 109, 6, 5, 4, 3, 1, 1, 0, 0, 0, 0, 0, 0, -3 ]

[ "Open terminal and type /Library/Frameworks/Python.framework/Versions/\nthen type ls /Library/Frameworks/Python.framework/Versions/2.7/bin/\n if you are using Python2(or any other else).\nEdit ~/.bash_profile and add the following line:\nexport PATH=$PATH:/Library/Frameworks/Python.framework/Versions/2.7/bin/\ncat ~/.bash_profile\n\nIn my case the content of ~/.bash_profile is as follows:\nexport PATH=$PATH:/Library/Frameworks/Python.framework/Versions/2.7/bin/\nNow the virtualenv command should work.\n" ]

[ -1 ]

[ "macos", "operating_system", "python", "virtualenv" ]

[ "One can add a namespace in front of the module name.\nPybind11Extension(\"mypackage.python_example\",\n [\"src/main.cpp\"],\n ...\n)\n\nBut the name in PYBIND11_MODULE should stay as it is.\nPYBIND11_MODULE(python_example, m) {\n\nThis will add a folder during the build: mypackage/python_example.cpython-38-x86_64-linux-gnu.so\nThis way you can import it like this:\nimport mypackage.python_example\n\nThanks to Marc Gliss for his answer in the comments.\n" ]

[ 0 ]

[]

[]

[ "c++", "packaging", "pybind11", "python" ]

[ "One possibility is to use re.findall:\nimport re\ntext = 'AGACGCCTGGGAACTGCGGCCGCGGGCTCGCGCTCCTCGCCAGGCCCTGCCGCCGGGCTGCCATCCTTGCCCTGCCATGTCTCGCCGGAAGCCTGCGTCGGGCGGCCTCGCTGCCTCCAGCTCAGCCCCTGCGAGGCAAGCGGTTTTGAGCCGATTCTTCCAGTCTACGGGAAGCCTGAAATCCACCTCCTCCTCCACAGGTGCAGCCGACCAGGTGGACCCTGGCGCTgcagcggctgcagcggccgcagcggccgcagcgCCCCCAGCGCCCCCAGCTCCCGCCTTCCCGCCCCAGCTGCCGCCGCACATA'\npattern = \"CCT\"\ncount = sum(1 for _ in re.findall(pattern, text))\n\nThe sum(1 for ...) is a common pattern to count the number of items, a generator returns. See e.g. this answer.\n", "Here is a modified version of your code that will allow the user to input a string of nucleotides and a pattern to search for. It will then output the number of times the pattern appears in the string. Note that this code is case sensitive, so \"AGC\" and \"agc\" will be treated as different patterns.\ndef pattern_count(text, pattern):\n count = 0\n for i in range(len(text) - len(pattern) + 1):\n if text[i: i + len(pattern)] == pattern:\n count = count + 1\n return count\n\nwhile True:\n print(\"Input the string of nucleotides:\")\n text = input()\n\n print(\"Input the pattern to search for:\")\n pattern = input()\n\n count = pattern_count(text, pattern)\n print(\"The pattern appears {} times in the string.\".format(count))\n\nOne potential optimization you could make to your code is to use the built-in count() method to count the number of times a pattern appears in a string. This would avoid the need to loop over the string and check each substring manually. Here is how you could modify your code to use this method:\ndef pattern_count(text, pattern):\n return text.count(pattern)\n\nwhile True:\n print(\"Input the string of nucleotides:\")\n text = input()\n\n print(\"Input the pattern to search for:\")\n pattern = input()\n\n count = pattern_count(text, pattern)\n print(\"The pattern appears {} times in the string.\".format(count))\n\n", "Here's a fixed version of your code:\ndef pattern_count(text, pattern):\n count = 0\n for i in range(len(text) - len(pattern) + 1):\n if text[i: i + len(pattern)] == pattern:\n count += 1\n return count\n\n\nwhile True:\n text = 'AGACGCCTGGGAACTGCGGCCGCGGGCTCGCGCTCCTCGCCAGGCCCTGCCGCCGGGCTGCCATCCTTGCCCTGCCATGTCTCGCCGGAAGCCTGCGTCGGGCGGCCTCGCTGCCTCCAGCTCAGCCCCTGCGAGGCAAGCGGTTTTGAGCCGATTCTTCCAGTCTACGGGAAGCCTGAAATCCACCTCCTCCTCCACAGGTGCAGCCGACCAGGTGGACCCTGGCGCTgcagcggctgcagcggccgcagcggccgcagcgCCCCCAGCGCCCCCAGCTCCCGCCTTCCCGCCCCAGCTGCCGCCGCACATA'\n print(\"Input Pattern:\")\n pattern = input(\"\")\n\n print(pattern_count(text, pattern))\n\nThe issues with your code were that you had an extra indentation in the for loop, which caused the return statement to be executed after the first iteration of the loop, instead of after all iterations. I also added a += operator to increase the count, instead of overwriting the count with the result of count + 1. Finally, I moved the return statement outside the for loop, so that it returns the count after all iterations of the loop have been completed.\n" ]

[ 1, 0, 0 ]

[]

[]

[ "bioinformatics", "biopython", "dna_sequence", "python", "repeat" ]

[ "I encountered the same issue earlier today, got it solved by typing this command in my visual studio terminal\nnpm install -g ganache-cli\n(Note: You must have Nodejs already installed)\nAfter the installation simply run the command below\nganache-cli --version\nto check if it was installed properly\n", "I used npm install -g ganache and it solved my problem, but when I want to start Ganache-cli, run with npx ganache-cli.\n", "you might have to add it to path\nC:\\Users\\userName\\AppData\\Local\\Yarn\\bin\n\n" ]

[ 2, 0, 0 ]

[]

[]

[ "ganache", "installation", "python", "terminal", "visual_studio" ]

[ "The error message gives the following exception: KeyError: ';,'.\nI suggest verifying that your CSV-file doesn't contain any errors first. Are you able to open it in e.g. Excel? If yes: are you using the correct separator and delimiter? (See the sep and delimiter parameters in the documentation)\n" ]

[ 0 ]

[]

[]

[ "pandas", "python" ]

[ "In python, when you create a new instance of an object, you are creating a new object in memory. For example:\na = ListNode(-1)\nb = ListNode(-1)\n\nIn this case, you are creating two separate ListNode objects, a and b, which are stored in different locations in memory.\nOn the other hand, when you use the assignment operator = in the following way:\na = b = ListNode(-1)\n\nYou are creating a single ListNode object and assigning it to two different variables, a and b. This means that a and b will both reference the same object in memory. Any changes made to the object through either a or b will be reflected in the other variable.\nIn other words, the difference between the two examples is that in the first case, you are creating two separate objects, while in the second case, you are creating a single object and assigning it to multiple variables.\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "30 seconds is default timeout value for gunicorn.\nTo increase it use --timeout <seconds> parameter on your gunicorn config.\nAlso if you run gunicorn under nginx, don't forget to manage nginx's settings:\nproxy_connect_timeout <seconds>s;\nproxy_read_timeout <seconds>s;\n\nUPDATE:\nit's better and safer to send files from flask by using send_from_directory\n" ]

[ 3 ]

[]

[]

[ "flask", "gunicorn", "python" ]

[ "To get a list of all quarter hours between two timestamps in Python, you can use the dateutil.rrule module to create a dateutil.rrule.rrule object with the freq argument set to dateutil.rrule.MINUTELY and the interval argument set to 15 to generate a list of datetime objects separated by 15 minute intervals. You can then iterate over the rrule object and extract the time from each datetime object to create a list of quarter-hour timestamps.\nHere's an example:\nfrom datetime import datetime\nfrom dateutil.rrule import rrule, MINUTELY\n\n# Timestamps for start and end\ntimestamp1 = 1605653932\ntimestamp2 = 1605656932\n\n# Create a datetime object for the start timestamp\nstart = datetime.fromtimestamp(timestamp1)\n\n# Create a datetime object for the end timestamp\nend = datetime.fromtimestamp(timestamp2)\n\n# Create a list of quarter-hour timestamps between the start and end timestamps\ntimestamps = []\nfor dt in rrule(freq=MINUTELY, interval=15, dtstart=start, until=end):\n timestamps.append(dt.strftime('%H:%M'))\n\n# Print the list of quarter-hour timestamps\nprint(timestamps)\n\nThis code will generate a list of quarter-hour timestamps in the format 'HH:MM', where HH is the hour and MM is the minute, for all quarter hours between the start and end timestamps. For the timestamps 1605653932 and 1605656932, the output would be:\n['23:58', '00:13', '00:28', '00:43']\n\nIf you want to start with the next quarter-hour after the start timestamp, you can change the code as follows:\nfrom datetime import datetime, timedelta\nfrom dateutil.rrule import rrule, MINUTELY\n\n# Timestamps for start and end\ntimestamp1 = 1605653932\ntimestamp2 = 1605656932\n\n# Create a datetime object for the start timestamp\nstart = datetime.fromtimestamp(timestamp1)\n\n# Create a datetime object for the end timestamp\nend = datetime.fromtimestamp(timestamp2)\n\n# Find the next quarter-hour after the start timestamp\nstart_minutes = start.minute\nstart_next_quarter_hour = start + timedelta(minutes=15 - start_minutes % 15)\n\n# Create a list of quarter-hour timestamps between the start and end timestamps\ntimestamps = []\nfor dt in rrule(freq=MINUTELY, interval=15, dtstart=start_next_quarter_hour, until=end):\n timestamps.append(dt.strftime('%H:%M'))\n\n# Print the list of quarter-hour timestamps\nprint(timestamps)\n\nThis will give the following output:\n['00:00', '00:15', '00:30', '00:45']\n\n" ]

[ 0 ]

[]

[]

[ "python", "timestamp" ]

[ "Opening a file in \"w+\" erases any content in the file. readlines() returns an empty list and trying to get value results in an IndexError. You can test for a file's existence with os.path.exists or os.path.isfile, or you could use an exception handler to deal with that case.\nStart with last_line set to a sentinel value. If the open fails, or if no lines are read, last_line will not be updated and you can base file creation on that.\nlast_line = None\ntry:\n with open(HIGH_SCORES_FILE_PATH) as file:\n for last_line in file:\n pass \nexcept OSError:\n pass\n\nif last_line is None:\n with open(HIGH_SCORES_FILE_PATH, \"w\") as file:\n file.write('Jogo:\\n0\\n')\n last_line = '0\\n'\n\n", "To read the last line of a file, you can use the seek method and set the position to the beginning of the file, then move the file cursor to the end of the file. Then, you can use the readline method to read the last line.\nwith open(HIGH_SCORES_FILE_PATH, \"w+\") as file:\n file.seek(0, 2) # Move cursor to the end of the file\n last_line = file.readline()\n if last_line == '\\n':\n with open(HIGH_SCORES_FILE_PATH, 'a') as file:\n file.write('Jogo:')\n file.write('\\n')\n file.write(str(0))\n file.write('\\n')\n\nNote that if the file is empty, readline will return an empty string, so you should check for that case as well.\nwith open(HIGH_SCORES_FILE_PATH, \"w+\") as file:\n file.seek(0, 2) # Move cursor to the end of the file\n last_line = file.readline()\n if last_line == '' or last_line == '\\n':\n with open(HIGH_SCORES_FILE_PATH, 'a') as file:\n file.write('Jogo:')\n file.write('\\n')\n file.write(str(0))\n file.write('\\n')\n\n" ]

[ 1, 0 ]

[]

[]

[ "file", "python" ]

[ "After your line\nmove = input('\\nWhat will you do next?\\n>').split() # next move input\n\nYou should jump back to the beginning of the loop, using continue.\n", "while True:\n if len(move) < 2: # for one word inputs\n # handle the input in various ways\n move = input('\\nWhat will you do next?\\n>').split() # next move input\n if len(move) == 2: # 2 word inputs\n\nWhen a single-word command is entered, it is handled in the first if block, and then a new move is entered.\nThe problem is that since the second block is an if and not an elif, it processes the new move immediately.\nGenerally it's better to ask for user input in only one place, near the top of the loop:\nwhile True:\n move = input(\"...\").split()\n if len(move) < 2:\n # handle it\n elif len(move) == 2:\n # handle it\n else:\n # handle it\n \n\n" ]

[ 1, 0 ]

[]

[]

[ "python" ]

[ "This should be more safe and idiomatic.\nclass CtxObj:\n \"\"\"\n Add an async context manager that calls `_ctx` to run the context.\n\n Usage::\n class Foo(CtxObj):\n @asynccontextmanager\n async def _ctx(self):\n yield self # or whatever\n\n async with Foo() as self_or_whatever:\n pass\n \"\"\"\n\n async def __aenter__(self):\n self.__ctx = ctx = self._ctx() # pylint: disable=E1101,W0201\n return await ctx.__aenter__()\n\n def __aexit__(self, *tb):\n return self.__ctx.__aexit__(*tb)\n\n\[email protected](eq=False)\nclass CombinedReceiveStream(CtxObj):\n \"\"\"Combines multiple streams into a single one, annotating each item with position index of the origin stream\"\"\"\n\n streams: Sequence[anyio.abc.ObjectReceiveStream[T_Item]]\n max_buffer_size_items: int = 32\n\n def __post_init__(self) -> None:\n self._queue_send, self._queue_receive = anyio.create_memory_object_stream(\n max_buffer_size=self.max_buffer_size_items,\n # Should be: `item_type=tuple[int, T_Item] | None`\n )\n self._pending = set(range(len(self.streams)))\n\n @asynccontextmanager\n async def _ctx(self):\n async with anyio.create_task_group() as tg:\n for i in self._pending:\n tg.start_soon(self._copier, i)\n\n yield self\n tg.cancel_scope.cancel()\n\n\n async def _copier(self, idx: int) -> None:\n stream = self.streams[idx]\n async for item in stream:\n await self._queue_send.send((idx, item))\n self._pending.remove(idx)\n if not self._pending:\n await self._queue_send.aclose()\n\n\n async def receive(self) -> tuple[int, T_Item]:\n return await self._queue_receive.receive()\n\n def __aiter__(self):\n return self\n\n async def __anext__(self):\n try:\n return await self.receive()\n except anyio.EndOfStream:\n raise StopAsyncIteration() from None\n\n" ]

[ 1 ]

[]

[]

[ "anyio", "python", "python_trio" ]

[ "To configure pylint to interpret a decorator as defining a class method, you can add the following to your pylintrc file:\n[TYPECHECK]\nignored-decorators=validator\n\nThis will tell pylint to ignore the validator decorator when checking for the first argument of a method. Note that this will not affect other checks or warnings related to the validator decorator, such as the use of cls instead of self. If you want to suppress those as well, you can add the cls-is-class option to your pylintrc file:\n[TYPECHECK]\nignored-decorators=validator\ncls-is-class=true\n\nThis will tell pylint to interpret the cls argument in methods decorated with validator as referring to the class itself, rather than an instance of the class.\n" ]

[ 1 ]

[]

[]

[ "class_method", "pylint", "pylintrc", "python" ]

[ "So it seems that 'pydub' library by default is not able to play .mp3 songs. You will neeed to convert it into .wav format and then execute the command again.\nSo here is your code with some minor modifications:\nfrom pydub import AudioSegment\nfrom pydub.playback import play\n\nsong = AudioSegment.from_mp3(\"C:\\\\Users\\\\ryanc\\\\Music\\\\rr.mp3\")\nplay(song)\n\nNow in order to work for this you need to have the ffmpeg installed. If not it will gain throw an error. Download ffmpeg and paste the code to your script directory.\nHere is the link to make you better understand the process.\n", "If saving the mp3 to a file isn't a pain for you, then using the audio playback extension is the easiest option.\nhttps://marketplace.visualstudio.com/items?itemName=sukumo28.wav-preview\n", "Try this link..\nhttps://github.com/jiaaro/pydub/issues/209\nAdding f.close() line in playback.py to close the stream works magic.\ndef _play_with_ffplay(seg):\nwith NamedTemporaryFile(\"w+b\", suffix=\".wav\") as f:\n f.close() # close the file stream\n seg.export(f.name, \"wav\")\n subprocess.call([PLAYER, \"-nodisp\", \"-autoexit\", \"-hide_banner\", f.name])\n\n", "The solution is to install pyAudio from python package\n" ]

[ 1, 0, 0, 0 ]

[]

[]

[ "pydub", "python" ]

[ "Ok, the solution was told to me that it could be in another question.\nWhat to do is to overwrite the handler function of the Flask Api object.\nWith that, you can configure the format with which each query will be answered, even the ones that contain an error.\ndef response_structure(code_status: int, response=None, message=None):\n if code_status == 200 or code_status == 201:\n status = 'Success'\n else:\n status = 'Error'\n\n args = dict()\n args['status'] = status\n if message is not None:\n args['message'] = message\n\n if response is not None:\n args['response'] = response\n\n return args, code_status\n\n\nclass ExtendAPI(Api):\n\n def handle_error(self, e):\n return response_structure(e.code, str(e))\n\nOnce the function is overwritten, you must use this new one to create\nusers_bp = Blueprint('users', __name__)\napi = ExtendAPI(users_bp)\n\nWith this, we can then use the flask functions to respond with the structure that we define.\nif request.args.get('name') is None:\n abort(400)\n\nResponse JSON\n{\n \"response\": \"400 Bad Request: The browser (or proxy) sent a request that this server could not understand.\",\n \"status\": \"Error\"\n}\n\n" ]

[ 0 ]

[]

[]

[ "flask", "python" ]

[ "In C#, the / operator performs integer division (ignores the fractional part) when both values are type int. For example, 3 / 2 = 1, since the fractional part (0.5) is dropped.\nAs a result, in your equation, the operation (r - l) / 2 is evaluating to -23, since (3 - 50) / 2 = -47 / 2 = -23 (again, the fractional part is dropped). Then, 50 + (-23) = 27.\nHowever, Python does not do this. By default, all division, whether between integers or doubles, is \"normal\" division - the fractional part is kept. Because of that, the result is the same as you'd get on a calculator: 50 + (3 - 50) / 2 = 26.5\nIf you want C# to calculate this the same way as Python, the easiest way is to make one of the numbers a double. Adding .0 to the end of the divisor should do the trick:\n// changed '2' to '2.0'\nvar gg = l + (r - l) / 2.0;\ndouble x = l + (r - l) / 2.0;\n\n\n26\n26.5\n\n" ]

[ 0 ]

[]

[]

[ "c#", "floor_division", "math", "python" ]

[ "This is how I would do it. I don't recommend looping when using pandas. There are a lot of tools that it is often not needed. Some caution on this. Your spreadsheet has NaN and I think that is actually numpy np.nan equivalent. You also have blanks I am thinking that it is a \"\" equivalent.\n# dictionary of your data\ncompanies = {\n 'Comp ID': ['C1', '', np.nan, 'C2', '', np.nan, 'C3',np.nan],\n 'Address': ['10 foo', 'Suite A','foo city', '11 spam','STE 100','spam town', '12 ham', 'Myhammy'],\n 'phone': ['888-321-4567', '', np.nan, '888-321-4567', '', np.nan, '888-321-4567',np.nan],\n 'Type': ['W_sale', '', np.nan, 'W_sale', '', np.nan, 'W_sale',np.nan],\n}\n# make the frames needed. \ndf = pd.DataFrame( companies)\ndf1 = pd.DataFrame() # blank frame for suite and town columns\n\n# Need a where clause it is similar to a if() statement in excel\ndf1['Suite'] = np.where( df['Comp ID']=='', df['Address'], np.nan)\ndf1['City/State'] = np.where( df['Comp ID'].isna(), df['Address'], np.nan)\n# copy values to rows above\ndf1 = df1[['Suite','City/State']].backfill()\n# joint the frames together on index\ndf = df.join(df1)\ndf.drop_duplicates(subset=['City/State'], keep='first', inplace=True)\n# set the column order to what you want\ndf = df[['Comp ID', 'Type', 'Address', 'Suite', 'City/State', 'phone' ]]\n\noutput\n\n\n\n\nComp ID\nType\nAddress\nSuite\nCity/State\nphone\n\n\n\n\nC1\nW_sale\n10 foo\nSuite A\nfoo city\n888-321-4567\n\n\nC2\nW_sale\n11 spam\nSTE 100\nspam town\n888-321-4567\n\n\nC3\nW_sale\n12 ham\n\nMyhammy\n888-321-4567\n\n\n\n" ]

[ 0 ]

[]

[]

[ "conditional_statements", "dataframe", "insert", "pandas", "python" ]

[ "This gives the same output with less complication. itertools.product is a function that gives you all the combinations of each state listed. A TOGGLE filter can be zero or one, while a FALSE or TRUE state only provides a zero or one state, respectively.\nDoes this manage the states you want?\nimport itertools\n\nTOGGLE = [0,1]\nFALSE = [0]\nTRUE = [1]\n\ndef toggle_filters(toggle_state):\n for state in itertools.product(*toggle_state):\n print(*state)\n\ntoggle_filters([TOGGLE, TOGGLE, TOGGLE])\nprint()\ntoggle_filters([TOGGLE, TOGGLE, FALSE])\n\nOutput:\n0 0 0\n0 0 1\n0 1 0\n0 1 1\n1 0 0\n1 0 1\n1 1 0\n1 1 1\n\n0 0 0\n0 1 0\n1 0 0\n1 1 0\n\n" ]

[ 2 ]

[]

[]

[ "python" ]

[ "Because division of sum by length is mean, you can instead df_missing.sum()/len(df) use df_missing.mean():\nresult = df.isna().mean()\n\nThen filter by DataFrame.loc with : for all rows and columns by mask:\ndf = df.loc[:,result > .1]\n\n", "it should be df = df.loc[:,result < .1] as the user only want to keep the columns that have less than 10% of the rows missing\n", "pandas has built in methods for such things:\ndf_clean = df.dropna(axis=1, thresh=(len(df)*.1), inplace=False)\nOr if you don't want to create an extra dataframe object you can do it inplace:\ndf.dropna(axis=1, thresh=(len(df)*.1), inplace=True)\n" ]

[ 4, 1, 0 ]

[]

[]

[ "pandas", "python" ]

[ "IIUC, you can use a negative pandas.Index.isin :\na1= a1[~a1.isin(fer)]\n\n# Output :\nprint(a1)\n​\nDatetimeIndex(['2022-08-22', '2022-08-29', '2022-09-05', '2022-09-12',\n '2022-09-19', '2022-09-26', '2022-10-03', '2022-10-10',\n '2022-10-17', '2022-10-24', '2022-10-31', '2022-11-07',\n '2022-11-21', '2022-11-28', '2022-12-05', '2022-12-12',\n '2022-12-19'],\n dtype='datetime64[ns]', freq=None)\n\n", "Here's a code snippet that hopefully answers your question. The code snippet uses the pandas package to remove a list of blacklisted dates from a list of dates. It does this by first generating a list of every Monday between a specified start and end date using the generate_mondays function. It then defines a list of blacklisted Mondays and converts both lists to pandas Series objects.\nNext, the code uses the Series.isin() method to create a Boolean mask indicating which dates in the mondays Series are not in the blacklisted_mondays Series. This mask is then used to filter the mondays Series, and the resulting Series is converted to a list using the tolist() method.\nThe resulting list of non-blacklisted Mondays can be accessed by calling the non_blacklisted_mondays variable, which is the final line of the code snippet. This variable contains a list of all the Mondays between the start and end dates, with the blacklisted Mondays removed.\n# Import the date and timedelta classes from the datetime module\nfrom datetime import date, timedelta\n\n# Import the pandas package\nimport pandas as pd\n\n# Function to generate a list of every Monday between two dates\ndef generate_mondays(start_date, end_date):\n # Create a variable to hold the list of Mondays\n mondays = []\n\n # Create a variable to hold the current date, starting with the start date\n current_date = start_date\n\n # Calculate the number of days between the start date and the first Monday\n # We use (7 - start_date.weekday()) % 7 to find the number of days to the\n # next Monday, and then subtract one to get the number of days to the first\n # Monday\n days_to_first_monday = (7 - start_date.weekday()) % 7 - 1\n\n # Add the number of days to the first Monday to the current date to move to\n # the first Monday\n current_date += timedelta(days=days_to_first_monday)\n\n # Loop until we reach the end date\n while current_date <= end_date:\n # Append the current date to the list of Mondays\n mondays.append(current_date)\n\n # Move to the next Monday by adding 7 days\n current_date += timedelta(days=7)\n\n # Return the list of Mondays\n return mondays\n\n# Set the start and end dates\nstart_date = date(2022, 1, 1)\nend_date = date(2022, 12, 31)\n\n# Generate a list of every Monday between the start and end dates\nmondays = generate_mondays(start_date, end_date)\n\n# Define a list of blacklisted Mondays\nblacklisted_mondays = [\n date(2022, 1, 10),\n date(2022, 2, 14),\n date(2022, 3, 21),\n]\n\n# Convert the list of mondays and the list of blacklisted mondays to pandas\n# Series objects\nmondays_series = pd.Series(mondays)\nblacklisted_mondays_series = pd.Series(blacklisted_mondays)\n\n# Use the pandas Series.isin() method to create a Boolean mask indicating\n# which dates in the mondays Series are not in the blacklisted_mondays Series\nmask = ~mondays_series.isin(blacklisted_mondays_series)\n\n# Use the mask to filter the mondays Series and convert the resulting Series\n# to a list\nnon_blacklisted_mondays = mondays_series[mask].tolist()\n\n# Print the resulting list of non-blacklisted Mondays\nprint(non_blacklisted_mondays)\n\n" ]

[ 1, 1 ]

[]

[]

[ "datetime", "pandas", "python" ]

[ "The problem is with your js code. As I can see, you make fetch call providing parameters and not providing callback for response processing.\nIt should be:\nfetch(`${window.origin}/`, {\n method: 'POST',\n headers: {'content-type': 'application/json'},\n body: JSON.stringify({\n 'message': false\n })\n})\n.then((response) => response.json())\n.then((data) => {\n console.log('Success:', data);\n})\n.catch((error) => {\n console.error('Error:', error);\n});\n\nAnd in backend it's better to return json response for api calls instead of html. To do it you can change your code:\nfrom flask import jsonify\n\n...\n if post_data['message'] == False:\n print('false')\n print('not detected')\n return jsonify(error='not detected')\n\nRef: https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#uploading_json_data\n", "There's something else wrong. I copied your code exactly and ran\ncurl.exe --header \"Content-Type: application/json\" -d '{\\\"message\\\":false}' http://localhost:5000\n\nand got\n <p>not detected</p>\n\n" ]

[ 1, 0 ]

[]

[]

[ "flask", "post", "python" ]

[ "The problem is that you're trying to access a field in a dictionary by its value. You are also trying to return a new dictionary, but you are changing the original dictionary. You should create a separate dictionary and use dict.items() instead. Like this:\ndef classifyMarks(marks):\n result = {}\n for (subject, grade) in marks.items():\n if grade >= 70:\n result[subject] = \"Distinction\"\n elif grade >= 60:\n result[subject] = \"Merit\"\n elif grade >= 50:\n result[subject] = \"Pass\"\n else:\n result[subject] = \"Fail\"\n return result\n\n\nmarks = {\n \"Maths\": 20,\n \"English\": 30,\n \"Science\": 40,\n \"Business\": 50,\n \"PE\": 60\n}\n\nmarks = classifyMarks(marks)\nprint(marks)\n\n" ]

[ 1 ]

[]

[]

[ "python", "python_3.x" ]

[ "Here is a way to get that information using Requests:\nimport requests\nfrom bs4 import BeautifulSoup as bs\nimport pandas as pd\n\npd.set_option('display.max_columns', None)\npd.set_option('display.max_colwidth', None)\n\nheaders = {\n 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36'\n}\n\ns = requests.Session()\ns.headers.update(headers)\n\nbig_list = []\n\nfor x in range(1, 3):\n r = s.get(f'https://magnumbikes.com/collections/e-bikes?page={x}&sort_by=best-selling')\n soup = bs(r.text, 'html.parser')\n items = soup.select('div[class=\"collection-filter__item\"]')\n for i in items:\n title = i.select_one('h3 a').get_text() \n url = 'https://magnumbikes.com' + i.select_one('h3 a').get('href')\n big_list.append((title, url))\ndf = pd.DataFrame(big_list, columns=['Bike', 'Url'])\nprint(df.to_markdown())\n\nResult in terminal:\n\n\n\n\n\nBike\nUrl\n\n\n\n\n0\nNomad\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-nomad\n\n\n1\nPathfinder 350\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-pathfinder-350\n\n\n2\nMetro S\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-metro-s\n\n\n3\nScout\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-scout\n\n\n4\nPayload\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-payload\n\n\n5\nPeak T7\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-peak-t7\n\n\n6\nMetro 750\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-metro-750\n\n\n7\nPathfinder T\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-pathfinder-t\n\n\n8\nRanger 1.0\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-ranger\n\n\n9\nLow rider 1.0\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-low-rider-2019\n\n\n10\nPathfinder 500\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-pathfinder-500\n\n\n11\nCruiser 1.0\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-cruiser-1-0\n\n\n12\nSummit 27.5\"\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-summit-27-5\n\n\n13\nMetro X\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-metro-x\n\n\n14\nPeak T5\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-peak-t5\n\n\n15\nPremium 3 Low Step\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-premium-3-low-step\n\n\n16\nNavigator X\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-navigator-x\n\n\n17\nCosmo X\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-cosmo-x\n\n\n18\nCosmo+\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-cosmo-1\n\n\n19\nCosmo S\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-cosmo-s\n\n\n20\nLow rider 2.0\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-low-rider\n\n\n21\nNavigator S\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-navigator-s\n\n\n22\nRanger 2.0\nhttps://magnumbikes.com//collections/e-bikes/products/ranger-2-0\n\n\n23\nPremium 3 High Step\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-premium-3-high-step\n\n\n24\nVoyager\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-voyager\n\n\n25\nCruiser 2.0\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-cruiser\n\n\n26\nCosmo\nhttps://magnumbikes.com//collections/e-bikes/products/magnum-cosmo\n\n\n\n\n​\nYou can use Selenium if you wish - just observe the urls accessed (taken from Dev tools - Network tab) and the locators.\n" ]

[ 0 ]

[]

[]

[ "python", "selenium", "selenium_webdriver", "web_scraping" ]

[ "You'll need to extract the code from your callback URL. If authentication is successful, Spotify will make a request to your redirect_uri with the code in the query (e.g http://localhost:7777/callback?code=...).\nThe easiest way to do that is probably spin up a Flask server (or equivalent) with a GET callback endpoint and grab the code there. Then you can exchange it for the authorization token in the same endpoint if you'd like. This example may be helpful: https://github.com/spotify/web-api-auth-examples/blob/master/authorization_code/app.js#L60\n" ]

[ 1 ]

[]

[]

[ "authorization", "python", "spotify" ]

[ "You can specify the starting point for a sum by passing it as a parameter. For example, sum([1,2,3], 10) produces 16 (10 + 1 + 2 + 3), and sum([[1], [2], [3]], []) produces [1,2,3].\nSo if you pass an appropriate (\"zero-like\") X object as the second parameter to your sum, ie sum([x1, x2, x3,...], x0) you should get the results you're looking for\nSome example code, per request. Given the following definitions:\nclass X: \n def __init__(self, val): \n self.val = val \n def __add__(self, other):\n return X(self.val + other.val) \n \n def __repr__(self): \n return \"X({})\".format(self.val) \n \nclass Y: \n def __init__(self, val): \n self.val = val \n def __add__(self, other):\n return X(self.val + other.val) \n \n def __repr__(self): \n return \"Y({})\".format(self.val) \n\n\nI get the following results:\n>>> sum([Y(1), Y(2), Y(3)], Y(0))\nX(6)\n>>> sum([Y(1), Y(2), Y(3)], Y(0))\nX(6)\n>>>\n\n(note that Y returns an X object - but that the two objects' add methods are compatible, which may not be the case in the OP's situation)\n" ]

[ 4 ]

[ "Assuming that you can add an X to a Y (i.e. __add__ is defined for Y and accepts an object of class X), then you can use\nreduce from functools, a generic way to apply an operation to a number of objects, either with or without a start value.\nfrom functools import reduce\n\nxes = [x1, x2, x3]\ny = reduce(lambda a,b: a+b, xes)\n\n", "What if you did something like:\nY = [ex[0]=+X for x in ex[1:]][0]\n\nI haven’t tested it yet though, on mobile\n" ]

[ -1, -1 ]

[ "python" ]

[ "numpy tries to use threads when multiplying matricies of size 100 or larger, and the default CBLAS implementation of threaded multiplication is ... sub optimal, as opposed to other backends like intel-MKL or ATLAS.\nif you force it to use only 1 thread using the answers in this post you will get a continuous line for numpy performance.\n" ]

[ 7 ]

[]

[]

[ "linear_algebra", "numerical_computing", "numpy", "python" ]

[ "Even if ı have installed the jupyterthemes and upgrade it, ı have the same issue when ı write down the command (!jt -t [themename]) into one of the jupyter notebook's cells. The solution that ı have found is open up the Anaconda prompt and after installing the jupyterthemes, write the command (jt -t exampletheme) and restart the jupyter notebook.\n", "I had the same problem. I was using a conda environment with Python 3.7 installed. After I switched the kernel to the original standard \"Python 3\" kernel with Python 3.9 install, then the jt commands worked for me. Not sure if it was an environment issue or a python version issue.\n" ]

[ 1, 0 ]

[]

[]

[ "jupyter", "path", "python" ]

[ "Eureka!!! Last Ubuntu version (22.04) seems to have brought the solution by itself. It now has a \"layer\" for desktop icons you can interact with. This also gave me the clue to find a smarter solution on Mint/Cinnamon (testing in other OS is still pending). This is the code which seems to work OK, for those with the same issue:\nimport time\n\nimport Xlib.display\nimport ewmh\nimport pywinctl\n\nDISP = Xlib.display.Display()\nSCREEN = DISP.screen()\nROOT = DISP.screen().root\nEWMH = ewmh.EWMH(_display=DISP, root=ROOT)\n\n\ndef sendBehind(hWnd):\n w = DISP.create_resource_object('window', hWnd.id)\n w.unmap()\n w.change_property(DISP.intern_atom('_NET_WM_WINDOW_TYPE', False), Xlib.Xatom.ATOM,\n 32, [DISP.intern_atom('_NET_WM_WINDOW_TYPE_DESKTOP', False), ],\n Xlib.X.PropModeReplace)\n DISP.flush()\n w.map()\n\n # This will try to raise the desktop icons layer on top of the window\n # Ubuntu: \"@!0,0;BDHF\" is the new desktop icons NG extension\n # Mint: \"Desktop\" name is language-dependent. Using its class (nemo-desktop)\n desktop = _xlibGetAllWindows(title=\"@!0,0;BDHF\", klass=('nemo-desktop', 'Nemo-desktop'))\n for d in desktop:\n w = DISP.create_resource_object('window', d)\n w.raise_window()\n\n return '_NET_WM_WINDOW_TYPE_DESKTOP' in EWMH.getWmWindowType(hWnd, str=True)\n\n\ndef bringBack(hWnd):\n\n w = DISP.create_resource_object('window', hWnd.id)\n\n w.unmap()\n w.change_property(DISP.intern_atom('_NET_WM_WINDOW_TYPE', False), Xlib.Xatom.ATOM,\n 32, [DISP.intern_atom('_NET_WM_WINDOW_TYPE_NORMAL', False), ],\n Xlib.X.PropModeReplace)\n DISP.flush()\n w.change_property(DISP.intern_atom('_NET_WM_STATE', False), Xlib.Xatom.ATOM,\n 32, [DISP.intern_atom('_NET_WM_STATE_FOCUSED', False), ],\n Xlib.X.PropModeReplace)\n DISP.flush()\n w.map()\n EWMH.setActiveWindow(hWnd)\n EWMH.display.flush()\n return '_NET_WM_WINDOW_TYPE_NORMAL' in EWMH.getWmWindowType(hWnd, str=True)\n\n\ndef _xlibGetAllWindows(parent=None, title: str = \"\", klass=None):\n\n parent = parent or ROOT\n allWindows = [parent]\n\n def findit(hwnd):\n query = hwnd.query_tree()\n for child in query.children:\n allWindows.append(child)\n findit(child)\n\n findit(parent)\n if not title and not klass:\n return allWindows\n else:\n return [window for window in allWindows if ((title and window.get_wm_name() == title) or\n (klass and window.get_wm_class() == klass))]\n\n\nhWnd = pywinctl.getActiveWindow()\nsendBehind(hWnd._hWnd)\ntime.sleep(3)\nbringBack(hWnd._hWnd)\n\n" ]

[ 1 ]

[]

[]

[ "gnome", "pyqt5", "python", "ubuntu", "xlib" ]

[ "Do you want two subplots, or do you want both bars next to each other? Either way, check out this other thread which should give you the answer to both. In the second case, you would want a secondary Y-axis (as illustrated in the post)\n" ]

[ 0 ]

[]

[]

[ "data_cleaning", "data_science", "pandas", "python" ]

[ "They are called ANSI escape sequence. Basically you output some special bytes to control how the terminal text looks. Try this:\nx = input('Name: \\u001b[1m') # anything from here on will be BOLD\n\nprint('\\u001b[0m', end='') # anything from here on will be normal\nprint('Your input is:', x)\n\n\\u001b[1m tells the terminal to switch to bold text. \\u001b[0m tells it to reset.\nThis page gives a good introduction to ANSI escape sequence.\n", "You can do the following with colorama:\nfrom colorama import init,Style,Fore,Back\nimport os\n\nos.system('cls')\n\ndef inputer(prompt) :\n init()\n print(Style.NORMAL+prompt + Style.BRIGHT+'',end=\"\")\n x = input()\n return x\n\n## -------------------------\n\ninputer(\"Input your name: \")\n\nand the output will be as follows:\n\nInput your name: John\n\nref. : https://youtu.be/wYPh61tROiY\n" ]

[ 4, 0 ]

[]

[]

[ "python", "python_3.x" ]

[ "import numpy as np\nimport torch\n\n\nclass TS_SS:\n def __init__(self):\n self.thetaval = 0\n self.vecnorm1 = 0\n self.vecnorm2 = 0\n\n def Theta(self, vec1, vec2):\n return (torch.arccos(torch.mm(vec1,vec2.T)/(self.vecnorm1*self.vecnorm2.T))\n + np.radians(10))\n\n def Triangle(self, vec1, vec2):\n self.thetaval = self.Theta(vec1, vec2)\n return ((self.vecnorm1 * self.vecnorm2.T * torch.sin(self.thetaval))\n / 2)\n\n\n\n def Sector(self, vec1: np.ndarray, vec2: np.ndarray):\n ED = torch.cdist(vec1,vec2,p=2)\n MD = torch.abs(self.vecnorm1 - self.vecnorm2.T)\n # theta = self.Theta(vec1, vec2)\n return (1/2) * ((ED + MD) ** 2) * self.thetaval\n\n def __call__(self, vec1, vec2):\n self.thetaval = 0\n self.vecnorm1 = vec1.norm(p=2, dim=1, keepdim=True)\n self.vecnorm2 = vec2.norm(p=2, dim=1, keepdim=True)\n return self.Triangle(vec1, vec2) * self.Sector(vec1, vec2)\n\n\nv1 = torch.tensor([[3.0,4.0]])\nv2 = torch.tensor([[4.0,3.0]])\nsimilarity = TS_SS()\nprint(similarity(v1, v2))\n\n" ]

[ 0 ]

[]

[]

[ "cosine_similarity", "nlp", "python", "similarity", "vectorization" ]

[ "You have confused Unicode with UTF-8. Latin-1 is a subset of Unicode, but it is not a subset of UTF-8. Avoid like the plague ever thinking about individual code units. Just use code points. Do not think about UTF-8. Think about Unicode instead. This is where you are being confused.\nSource Code for Demo Program\nUsing Unicode in Python is very easy. It’s especially with Python 3 and wide builds, the only way I use Python, but you can still use the legacy Python 2 under a narrow build if you are careful about sticking to UTF-8. \nTo do this, always your source code encoding and your output encoding correctly to UTF-8. Now stop thinking of UTF-anything and use only UTF-8 literals, logical code point numbers, or symbolic character names throughout your Python program. \nHere’s the source code with line numbers:\n% cat -n /tmp/py\n 1 #!/usr/bin/env python3.2\n 2 # -*- coding: UTF-8 -*-\n 3 \n 4 from __future__ import unicode_literals\n 5 from __future__ import print_function\n 6 \n 7 import sys\n 8 import os\n 9 import re\n 10 \n 11 if not ((\"PYTHONIOENCODING\" in os.environ)\n 12 and\n 13 re.search(\"^utf-?8$\", os.environ[\"PYTHONIOENCODING\"], re.I)):\n 14 sys.stderr.write(sys.argv[0] + \": Please set your PYTHONIOENCODING envariable to utf8\\n\")\n 15 sys.exit(1)\n 16 \n 17 print('1a: el ni\\xF1o')\n 18 print('2a: el nin\\u0303o')\n 19 \n 20 print('1a: el niño')\n 21 print('2b: el niño')\n 22 \n 23 print('1c: el ni\\N{LATIN SMALL LETTER N WITH TILDE}o')\n 24 print('2c: el nin\\N{COMBINING TILDE}o')\n\nAnd here are print functions with their non-ASCII characters uniquoted using the \\x{⋯} notation:\n% grep -n ^print /tmp/py | uniquote -x\n17:print('1a: el ni\\xF1o')\n18:print('2a: el nin\\u0303o')\n20:print('1b: el ni\\x{F1}o')\n21:print('2b: el nin\\x{303}o')\n23:print('1c: el ni\\N{LATIN SMALL LETTER N WITH TILDE}o')\n24:print('2c: el nin\\N{COMBINING TILDE}o')\n\nSample Runs of Demo Program\nHere’s a sample run of that program that shows the three different ways (a, b, and c) of doing it: the first set as literals in your source code (which will be subject to StackOverflow’s NFC conversions and so cannot be trusted!!!) and the second two sets with numeric Unicode code points and with symbolic Unicode character names respectively, again uniquoted so you can see what things really are:\n% python /tmp/py\n1a: el niño\n2a: el niño\n1b: el niño\n2b: el niño\n1c: el niño\n2c: el niño\n\n% python /tmp/py | uniquote -x\n1a: el ni\\x{F1}o\n2a: el nin\\x{303}o\n1b: el ni\\x{F1}o\n2b: el nin\\x{303}o\n1c: el ni\\x{F1}o\n2c: el nin\\x{303}o\n\n% python /tmp/py | uniquote -v\n1a: el ni\\N{LATIN SMALL LETTER N WITH TILDE}o\n2a: el nin\\N{COMBINING TILDE}o\n1b: el ni\\N{LATIN SMALL LETTER N WITH TILDE}o\n2b: el nin\\N{COMBINING TILDE}o\n1c: el ni\\N{LATIN SMALL LETTER N WITH TILDE}o\n2c: el nin\\N{COMBINING TILDE}o\n\nI really dislike looking at binary, but here is what that looks like as binary bytes:\n% python /tmp/py | uniquote -b\n1a: el ni\\xC3\\xB1o\n2a: el nin\\xCC\\x83o\n1b: el ni\\xC3\\xB1o\n2b: el nin\\xCC\\x83o\n1c: el ni\\xC3\\xB1o\n2c: el nin\\xCC\\x83o\n\nThe Moral of the Story\nEven when you use UTF-8 source, you should think and use only logical Unicode code point numbers (or symbolic named characters), not the individual 8-bit code units that underlie the serial representation of UTF-8 (or for that matter of UTF-16). It is extremely rare to need code units instead of code points, and it just confuses you.\nYou will also get more reliably behavior if you use a wide build of Python3 than you will get with alternatives to those choices, but that is a UTF-32 matter, not a UTF-8 one. Both UTF-32 and UTF-8 are easy to work with, if you just go with the flow.\n", "UTF-8 is not a subset of Latin-1. UTF-8 encodes ASCII with the same single bytes. For all other code points, it's all multiple bytes.\nPut simply, \\xf1 is not valid UTF-8, as Python tells you. \"Unexpected end of input\" indicates that this byte marks the beginning of a multi-byte sequence which is not provided.\nI recommend you read up on UTF-8.\n", "\nMy understanding is that latin1 is a subset of utf8.\n\nWrong. Latin-1, aka ISO 8859-1 (and sometimes erroneously as Windows-1252), is not a subet of UTF-8. ASCII, on the other hand, is a subset of UTF-8. ASCII strings are valid UTF-8 strings, but generalized Windows-1252 or ISO 8859-1 strings are not valid UTF-8, which is why s.decode('UTF-8') is throwing a UnicodeDecodeError.\n", "It's the first byte of a multi-byte sequence in UTF-8, so it's not valid by itself.\nIn fact, it's the first byte of a 4 byte sequence.\nBits Last code point Byte 1 Byte 2 Byte 3 Byte 4 Byte 5 Byte 6\n21 U+1FFFFF 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx\n\nSee here for more info.\n", "the easy way (python 3)\ns='\\xf1'\nbytes(s, 'utf-8').decode('utf-8')\n#'ñ'\n\nif you are trying decode escaped unicode you can use:\ns='Autom\\\\u00e1tico'\nbytes(s, \"utf-8\").decode('unicode-escape')\n#'Automático'\n\n" ]

[ 9, 4, 1, 1, 0 ]

[]

[]

[ "encoding", "python", "unicode", "utf_8" ]

[ "The nBonacci sequence will always have to start with n ones, or the sequence could never start. Therefore, we can just take advantage of the range() function and slice the existing list:\ndef nfib(n, m):\n lst = [1] * n\n for i in range(n, m):\n lst.append(sum(lst[i-n:i]))\n return lst\n\n\nprint(nfib(3, 8)) # => [1, 1, 1, 3, 5, 9, 17, 31]\n\n", "If you wanted to the fibonacci sequence recursively, you could do\ndef fib(x, y, l):\n if len(l) == y:\n return l\n return fib(x, y, l + [sum(l[-x:])])\n\n\nnum = 3\nprint(fib(num, 8, [1 for _ in range(num)])) #[1, 1, 1, 3, 5, 9, 17, 31]\n\n" ]

[ 1, 1 ]

[]

[]

[ "fibonacci", "iteration", "python" ]

[ "That's because you gave it a second argument. You can only give it the string you want to see displayed. This isn't a free-form print statement. Try this:\nRadius = eval(input(\"Enter the radius of circle #\" + str(i + 1)))\n\nThis gives you a single string value to send to input.\nAlso, be very careful with using eval.\n", "input only takes one argument, if you want to create a string with your i value you can use\nRadius = eval(input(\"Enter the radius of circle #{} \".format(i + 1)))\n\nAlso it is very dangerous to use eval to blindly execute user input.\n", "\nTypeError: input expected at most 1 arguments, got 2\n\nThats because you provided two arguments for input function but it expects one argument (yeah I rephrased error message...).\nAnyway, use this:\nRadius = float(input(\"Enter the radius of circle #\" + str(i + 1)))\n\nDon't use eval for this. (Other answer explains why)\nFor future issues, it's worth using help function from within python interpreter. Try help(input) in python interpreter. \n", "In golang I got the exact same error using database/sql when I tried this code:\n err := db.QueryRow(\"SELECT ... WHERE field=$1 \", field, field2).Scan(&count)\n if err != nil {\n return false, err\n }\n\nit turns out the solution was to do add 1 parameter instead of 2 parameters to the varargs of the function.\nso the solution was this:\n err := db.QueryRow(\"SELECT ... WHERE field=$1 \", field).Scan(&count)\n // notice field2 is missing here\n if err != nil {\n return false, err\n }\n\nI hope this helps anyone, particularly since this is the first google result when googling this issue.\nalso guys, always provide context to your errors.\nHTH\n" ]

[ 1, 1, 0, 0 ]

[]

[]

[ "python", "python_3.x" ]

[ "Interesting problem but I think your method does not work.\nWhen your model's entropy is high, i.e. it is unsure which class to choose for that particular sample input, it does not necessarily mean that that sample is an anomaly, it just means that the model is perhaps struggling to select the correct normal class.\nI suggest adding some abnormal samples (some random unrelated images, if your samples are images), between 1% to 10% of your data, and labelling them as class 7. Then train your model with those (and perhaps give more penalty for misclassifying the class 7).\nWhen you have your unseen samples, you classify them using your trained model. If they are classified as class 7, then you know they are anomalies.\nHope this helps.\n" ]

[ 2 ]

[]

[]

[ "anomaly_detection", "conv_neural_network", "machine_learning", "python", "tensorflow" ]

[ "You most probably did pip install nostril before you installed the actual nostril package that you needed (just like I did). This would have caused another package that is used for testing to be installed alongside. You can either uninstall both nostril packages and then re-install just the nostril package you need.\nOr you can directly import the nonsense object from nonsense_detector as below if you need both the packages\nfrom nostril.nonsense_detector import nonsense\n\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "The methods canvasx and canvasy of the Canvas widget will convert screen pixels (ie: what's visible on the screen) into canvas pixels (the location in the larger virtual canvas).\nYou can feed it an x or y of zero to get the virtual pixel at the top-left of the visible window, and you can give it the width and height of the widget to get the pixel at the bottom-right of the visible window.\nx0 = canvas.canvasx(0)\ny0 = canvas.canvasy(0)\nx1 = canvas.canvasx(canvas.winfo_width())\ny1 = canvas.canvasy(canvas.winfo_height())\n\nThe canonical tcl/tk documentation says this about the canvasx method:\n\npathName canvasx screenx ?gridspacing?: Given a window x-coordinate in the canvas screenx, this command returns the canvas x-coordinate that is displayed at that location. If gridspacing is specified, then the canvas coordinate is rounded to the nearest multiple of gridspacing units.\n\n\nHere is a contrived program that will print the coordinates of the top-left and bottom right visible pixels every five seconds.\nimport tkinter as tk\n\nroot = tk.Tk()\ncanvas_frame = tk.Frame(root, bd=1, relief=\"sunken\")\nstatusbar = tk.Label(root, bd=1, relief=\"sunken\")\n\nstatusbar.pack(side=\"bottom\", fill=\"x\")\ncanvas_frame.pack(fill=\"both\", expand=True)\n\ncanvas = tk.Canvas(canvas_frame, width=800, height=800, bd=0, highlightthickness=0)\nysb = tk.Scrollbar(canvas_frame, orient=\"vertical\", command=canvas.yview)\nxsb = tk.Scrollbar(canvas_frame, orient=\"horizontal\", command=canvas.xview)\ncanvas.configure(yscrollcommand=ysb.set, xscrollcommand=xsb.set)\n\ncanvas_frame.grid_rowconfigure(0, weight=1)\ncanvas_frame.grid_columnconfigure(0, weight=1)\ncanvas.grid(row=0, column=0, sticky=\"nsew\")\nysb.grid(row=0, column=1, sticky=\"ns\")\nxsb.grid(row=1, column=0, sticky=\"ew\")\n\nfor row in range(70):\n for column in range(10):\n x = column * 80\n y = row * 80\n canvas.create_rectangle(x, y, x+64, y+64, fill=\"gray\")\n canvas.create_text(x+32, y+32, anchor=\"c\", text=f\"{row},{column}\")\n\ncanvas.configure(scrollregion=canvas.bbox(\"all\"))\n\ndef show_coords():\n x0 = int(canvas.canvasx(0))\n y0 = int(canvas.canvasy(0))\n x1 = int(canvas.canvasx(canvas.winfo_width()))\n y1 = int(canvas.canvasy(canvas.winfo_height()))\n statusbar.configure(text=f\"{x0},{y0} / {x1},{y1}\")\n root.after(5000, show_coords)\n\nshow_coords()\n\nroot.mainloop()\n\n" ]

[ 1 ]

[]

[]

[ "canvas", "python", "scroll", "tkinter", "visible" ]

[ "If you are actually dealing with Pydantic models, I would argue this is one of the use cases for validators.\nThere is not really any need for recursion because you can just define the validator on your own base model, if you want it to apply to all models (that inherit from it):\nfrom pydantic import BaseModel as PydanticBaseModel\nfrom pydantic import validator\n\n\ndef process_string(string: str) -> str:\n return string.replace(\"a\", \"\")\n\n\nclass BaseModel(PydanticBaseModel):\n @validator(\"*\", pre=True, each_item=True)\n def preprocess(cls, v: object) -> object:\n if isinstance(v, str):\n return process_string(v)\n return v\n\n\nclass OtherModel(BaseModel):\n other_id: int\n some_name: str\n\n\nclass DummyModel(BaseModel):\n location_id: int\n other_models: list[OtherModel]\n name: str\n surname: str\n one_other_model: OtherModel\n\nIf you want to be more selective and apply the same validator to specific models, they can be made reusable as well:\nfrom pydantic import BaseModel, validator\n\n\ndef preprocess(v: object) -> object:\n if isinstance(v, str):\n return v.replace(\"a\", \"\")\n return v\n\n\nclass OtherModel(BaseModel):\n other_id: int\n some_name: str\n\n _preprocess = validator(\"*\", pre=True, allow_reuse=True)(preprocess)\n\n\nclass DummyModel(BaseModel):\n location_id: int\n other_models: list[OtherModel]\n name: str\n surname: str\n one_other_model: OtherModel\n\n _preprocess = validator(\n \"*\",\n pre=True,\n each_item=True,\n allow_reuse=True,\n )(preprocess)\n\n\nclass NotProcessed(BaseModel):\n field: str\n\nWe can test both versions like this:\nif __name__ == \"__main__\":\n dummy = DummyModel.parse_obj({\n \"location_id\": 1,\n \"other_models\": [\n {\"other_id\": 1, \"some_name\": \"foo\"},\n {\"other_id\": 2, \"some_name\": \"spam\"},\n ],\n \"name\": \"bar\",\n \"surname\": \"baz\",\n \"one_other_model\": {\"other_id\": 2, \"some_name\": \"eggs\"},\n })\n print(dummy.json(indent=4))\n\nThe output in both cases is the same:\n{\n \"location_id\": 1,\n \"other_models\": [\n {\n \"other_id\": 1,\n \"some_name\": \"foo\"\n },\n {\n \"other_id\": 2,\n \"some_name\": \"spm\"\n }\n ],\n \"name\": \"br\",\n \"surname\": \"bz\",\n \"one_other_model\": {\n \"other_id\": 2,\n \"some_name\": \"eggs\"\n }\n}\n\n" ]

[ 2 ]

[]

[]

[ "pydantic", "python", "python_3.x", "recursion" ]

[ "Twisted uses non-blocking socket operations: data written to or read from sockets are just enough to not block. Filesender in effect sends chunks of data until all are sent and you need to buffer them until they are complete.\nI would write the server part as:\nclass TestServer(Protocol):\n \n def connectionMade(self):\n filesender = FileSender()\n f = open('00000.jpg', 'rb')\n d = filesender.beginFileTransfer(f, self.transport)\n d.addCallback(lambda _: self.transport.loseConnection()) # signals end of transmission\n\nThen the client as:\nclass TestClient(Protocol):\n\n def __init__(self):\n self.f = open('13.jpg', 'wb')\n\n def connectionMade(self):\n print(\"Client did connection\")\n\n def dataReceived(self, data):\n self.f.write(data) # I would buffer all the received data and\n # write them all at once for efficiencey\n # but this one will do\n\n def connectionLost(self, reason: failure.Failure = connectionDone):\n self.f.close() # server is done sending all chunks, close the file\n print(\"Client lost Connection Protocol\")\n\nHTH\n" ]

[ 0 ]

[]

[]

[ "networking", "python", "twisted" ]

[ "There is no built-in way of generating a sequence of numbers, the canonical way of doing so is to do one of:\n\nUse loop\nWrite a utility function that uses loop\n\nAn example implementation would be (this only accepts counting \"from low\" to \"high\"):\n(defun range (max &key (min 0) (step 1))\n (loop for n from min below max by step\n collect n))\n\nThis allows you to specify an (optional) minimum value and an (optional) step value.\nTo generate odd numbers: (range 10 :min 1 :step 2)\n", "alexandria implements scheme's iota:\n(ql:quickload :alexandria)\n(alexandria:iota 4 :start 2 :step 2)\n;; (2 4 6 8)\n\n", "Here's how I'd approach the problem:\n(defun generate (from to &optional (by 1))\n #'(lambda (f)\n (when (< from to)\n (prog1 (or (funcall f from) t)\n (incf from by)))))\n\n(defmacro with-generator ((var from to &optional (by 1)) &body body)\n (let ((generator (gensym)))\n `(loop with ,generator = (generate ,from ,to ,by)\n while\n (funcall ,generator\n #'(lambda (,var) ,@body)))))\n\n(with-generator (i 1 10)\n (format t \"~&i = ~s\" i))\n\nBut this is just the general idea, there's a lot of room for improvement.\n\nOK, since there seems to be a discussion here. I've assumed that what is really needed is the analogue to Python's range generator function. Which, in certain sense generates a list of numbers, but does it so by yielding a number each iteration (so that it doesn't create more then one item at a time). Generators are a somewhat rare concept (few languages implement it), so I assumed that the mention of Python suggested that this exact feature is desired.\nFollowing some criticism of my example above, here's a different example that illustrates the reason to why a generator might be used rather then a simple loop.\n(defun generate (from to &optional (by 1))\n #'(lambda ()\n (when (< from to)\n (prog1 from\n (incf from by)))))\n\n(defmacro with-generator\n ((var generator &optional (exit-condition t)) &body body)\n (let ((g (gensym)))\n `(do ((,g ,generator))\n (nil)\n (let ((,var (funcall ,g)))\n (when (or (null ,var) ,exit-condition)\n (return ,g))\n ,@body))))\n\n(let ((gen\n (with-generator (i (generate 1 10) (> i 4))\n (format t \"~&i = ~s\" i))))\n (format t \"~&in the middle\")\n (with-generator (j gen (> j 7))\n (format t \"~&j = ~s\" j)))\n\n;; i = 1\n;; i = 2\n;; i = 3\n;; i = 4\n;; in the middle\n;; j = 6\n;; j = 7\n\nThis is, again, only an illustration of the purpose of this function. It is probably wasteful to use it for generating integers, even if you need to do that in two steps, but generators are best with parsers, when you want to yield a more complex object which is built based upon the previous state of the parser, for example, and a bunch of other things. Well, you can read an argument about it here: http://en.wikipedia.org/wiki/Generator_%28computer_programming%29\n", "Using recursion:\n(defun range (min max &optional (step 1))\n (when (<= min max)\n (cons min (range (+ min step) max step))))\n\n", "In simple form specifying start, stop, step:\n(defun range (start stop step) \n (do (\n (i start (+ i step)) \n (acc '() (push i acc))) \n ((>= i stop) (nreverse acc))))\n\n", "You may want to try snakes:\n\"Python style generators for Common Lisp. Includes a port of itertools.\"\nIt is available in Quicklisp. There may be other Common Lisp libraries that can help.\n", "Not finding what I wanted nor wanting to use an external package, I ended up writing my own version which differs from the python version (hopefully improving on it) and avoids loop. If you think it is really inefficient and can improve on it, please do. \n;; A version of range taking the form (range [[first] last [[step]]]).\n;; It takes negative numbers and corrects STEP to the same direction\n;; as FIRST to LAST then returns a list starting from FIRST and\n;; ending before LAST\n(defun range (&rest args)\n (case (length args) \n ( (0) '()) \n ( (1) (range 0 (car args) (if (minusp (car args)) -1 1))) \n ( (2) (range (car args) (cadr args) \n (if (>= (car args) (cadr args)) -1 1))) \n ( (3) (let* ((start (car args)) (end (cadr args)) \n (step (abs (caddr args))))\n (if (>= end start)\n (do ((i start (+ i step))\n (acc '() (push i acc)))\n ((>= i end) (nreverse acc)))\n (do ((i start (- i step))\n (acc '() (push i acc)))\n ((<= i end) (nreverse acc))))))\n (t (error \"ERROR, too many arguments for range\"))))\n\n\n;; (range-inc [[first] last [[step]]] ) includes LAST in the returned range\n(defun range-inc (&rest args)\n (case (length args)\n ( (0) '())\n ( (1) (append (range (car args)) args))\n ( (2) (append (range (car args) (cadr args)) (cdr args)))\n ( (3) (append (range (car args) (cadr args) (caddr args))\n (list (cadr args))))\n (t (error \"ERROR, too many arguments for range-inc\"))))\n\nNote: I wrote a scheme version as well\n", "Here is a range function to generate a list of numbers.\nWe use the do \"loop\". If there is such a thing as a functional loop, then do macro is it. Although there is no recursion, when you construct a do, I find the thinking is very similar. You consider each variable in the do in the same way you consider each argument in a recursive call.\nI use list* instead of cons. list* is exactly the same as cons except you can have 1, 2, or more arguments. (list 1 2 3 4 nil) and (cons 1 (cons 2 (cons 3 (cons 4 nil)))).\n(defun range (from-n to-n &optional (step 1)) ; step defaults to 1\n (do ((n from-n (+ n step)) ; n initializes to from-n, increments by step\n (lst nil (list* n lst))) ; n \"pushed\" or \"prepended\" to lst\n\n ((> n to-n) ; the \"recursion\" termination condition\n (reverse lst)))) ; prepending with list* more efficient than using append\n ; however, need extra step to reverse lst so that\n ; numbers are in order\n\nHere is a test session:\n\nCL-USER 23 > (range 0 10)\n(0 1 2 3 4 5 6 7 8 9 10)\nCL-USER 24 > (range 10 0 -1)\nNIL\nCL-USER 25 > (range 10 0 1)\nNIL\nCL-USER 26 > (range 1 21 2)\n(1 3 5 7 9 11 13 15 17 19 21)\nCL-USER 27 > (reverse (range 1 21 2))\n(21 19 17 15 13 11 9 7 5 3 1)\nCL-USER 28 > \n\nThis version does not work for decreasing sequences. However, you see that you can use reverse to get a decreasing sequence.\n", "Needed to implement (range n) in a tiny Lisp that just had dotimes and setq available:\n(defun range (&rest args)\n (let ( (to '()) )\n (cond \n ((= (length args) 1) (dotimes (i (car args))\n (push i to)))\n ((= (length args) 2) (dotimes (i (- (cadr args) (car args)))\n (push (+ i (car args)) to))))\n (nreverse to)))\n\nExample:\n> (range 10)\n(0 1 2 3 4 5 6 7 8 9)\n\n> (range 10 15)\n(10 11 12 13 14)\n\n", "Just in case, here is an analogue to user1969453's answer that returns a vector instead of a list:\n(defun seq (from to &optional (step 1))\n (do ((acc (make-array 1 :adjustable t :fill-pointer 0))\n (i from (+ i step)))\n ((> i to) acc) (vector-push-extend i acc)))\n\nOr, if you want to pre-allocate the vector and skip the 'vector-push' idiom:\n(defun seq2 (from to &optional (step 1))\n (let ((size (+ 1 (floor (/ (- to from) step))))) ; size is 1 + floor((to - from) / step))\n (do ((acc (make-array size))\n (i from (+ i step))\n (count 0 (1+ count)))\n ((> i to) acc) (setf (aref acc count) i))))\n\n" ]

[ 41, 19, 6, 4, 2, 1, 1, 0, 0, 0 ]

[ "Recursive solution:\n(defun range(min max &optional (step 1))\n (if (> min max)\n ()\n (cons min (range (+ min step) max step))))\n\nExample:\n(range 1 10 3)\n(1 4 7 10)\n\n" ]

[ -1 ]

[ "common_lisp", "number_sequence", "python" ]

[ "To get the maximum value of sales for each region, you can use the 'idxmax()' function on the groupby object. This will return the index of the maximum value for each group, which you can then use to index into the original data frame to get the corresponding rows.\nHere is an example:\n# Get the maximum sales for each region\nmax_sales = sales_by_state.groupby(level=0)['Sales'].idxmax()\n\n# Use the index of the maximum sales to index into the original data frame\nmax_sales_by_state = df_n.loc[max_sales]\n\nThis will return a new data frame containing the rows from the original data frame that correspond to the maximum sales for each region. You can then access the values in the 'State or Province' column to get the maximum state for each region.\nAlternatively, you can use the 'apply()' method on the groupby object to apply a custom function to each group. This function can return the state with the maximum sales for the group, which you can then use to create a new column in the data frame containing the maximum state for each region.\nHere is an example:\n# Define a custom function that returns the state with the maximum sales for a group\ndef get_max_state(group):\n # Index into the group to get the state with the maximum sales\n return group.loc[group['Sales'].idxmax()]['State or Province']\n\n# Apply the custom function to each group and create a new column with the results\nsales_by_state['Max State'] = sales_by_state.groupby(level=0).apply(get_max_state)\n\nThis will add a new column to the 'sales_by_state' data frame containing the maximum state for each region.\n" ]

[ 1 ]

[]

[]

[ "dataframe", "group_by", "max", "pandas", "python" ]

[ "Solved:\nDetailed explanation here: https://stackoverflow.com/a/64472088/16044321\nThe issue is specific to how Python performs a DLL/SO search on Windows. While the ctypes docs do not specify this, the CDLL() function requires the optional argument winmode=0 to work correctly on Windows when loading a .dll or .so. This issue is also specific to Python versions greater than 3.8.\nThus, simply changing the 2nd line to cFile = ctypes.CDLL(\"libchess.so\", winmode=0) works as expected.\n" ]

[ 0 ]

[]

[]

[ "ctypes", "python", "shared_libraries" ]

[ "@JohanC's Answer:\nDid you consider creating the axes the usual way, as in fig, ax = plt.subplots(figsize = (7,4)) (in the main code, not inside the animate function)? And leaving out the call to plt.axes()?\n" ]

[ 0 ]

[]

[]

[ "matplotlib", "matplotlib_basemap", "python" ]

[ "Ok, it appears what is missing from the code samples provided by GCP are the steps to build and use a service object.\nDocumentation on that can be found here: https://github.com/googleapis/google-api-python-client/blob/main/docs/start.md#building-and-calling-a-service\nSo for my sample above the last line would actually be:\nservice = build('cloudidentity', 'v1')\nsearch_transitive_memberships(service, 'groups/01234567abcdefg', 50)\nservice.close\n\nAfter importing build from googleapiclient.discovery\nGithub link above also details how to provide oauth creds for it to work.\n" ]

[ 1 ]

[]

[]

[ "gcloud", "google_cloud_platform", "google_iam", "python" ]

[ "This is less for the person that asked the question but more for people like myself that come here from Python Crash Course with the same question and don't get the answer they were looking for:\nIf, like me, you were running the code from your text editor (in my case VS Code), it's possible that the terminal window within the editor wasn't in the proper directory. I didn't realize myself, because I was thinking that because I opened the .py file from the correct working directory in the terminal that everything should work as planned. It wasn't until I realized that the terminal in the editor is a separate instance (thus making the present working directory home instead of my folder for PCC work) that I was able to get the program to run as intended.\nIn short, navigate to the proper directory in your editor's terminal instance and the program should run as intended.\nHope this helps!\nimage with terminal open on desktop and in text editor to show working directory difference\n", "I used full path of the file along with r, which is for raw string. Worked for me.\nexample:\nfilename = **r**'C:\\Python\\CrashCourse\\pi_digits.txt'\n\nwith open(filename) as file_object:\n content = file_object.read()\n print(content)\n\n", "The path to the file is relative to where you run the python file from, not from where the python file is located. \nEither run your code from the same directory as the files, or make the file path absolute, based on the python file's location.\nimport os\n\nwith open(os.path.join(os.path.dirname(__file__), 'pi_digits.txt')) as file_object:\n contents = file_object.read()\n print(contents)\n\nHope that helps\n", "You can try getting the full path to the file\nimport os\n\ndir_path = os.path.dirname(os.path.realpath(__file__))\npi_digits = os.path.join(dir_path, 'pi_digits.txt')\n\nwith open(pi_digits, r) as file_object:\n print(file_object.read())\n\n", "Try this:\nwith open('c:\\\\Workspace\\\\Crash Course\\\\Lessons\\\\Ch 10\\\\pi_digits.txt') as file_object:\n contents = file_object.read()\n print(contents)\n\n" ]

[ 2, 2, 0, 0, 0 ]

[ "You might have to enable \"Execute in file dir\"\nvscode setting\n", "The comment that Travis1797 posted is much better for VS code users that are just starting out with learning python.\nClick on the cog icon in the bottom left hand of corner of vscode\nThen click settings.\nThen type: execute in file dir\n(WARNING: this is only useful when calling upon files saved in the same directory as your python file using the method explained in the python crash course)\nTHE HIGHER VOTED POSTS WORK WITHOUT THE NEED TO CHANGE SETTINGS WITHIN VSCODE.\nClick the checkbox next to the wording thats states \"When executing a file...\" and run your code again and it works.\nPs(I spent over an hour trying to figure out what I was doing wrong and also solving it with the comments above but this was the most python elegant solution )\n" ]

[ -1, -1 ]

[ "python" ]

[ "It looks like you're using the webdriver.Chrome() syntax to create a new instance of the Chrome web driver, but this is incorrect. Instead, you need to use the webdriver.Chrome(ChromeDriverManager().install()) syntax to create a new instance of the Chrome web driver and automatically download and install the appropriate version of the Chrome driver.\nTry this code:\nfrom selenium import webdriver\nfrom webdriver_manager.chrome import ChromeDriverManager\nimport time\nimport random \n\nweb = webdriver.Chrome(ChromeDriverManager().install())\nweb.get('https://freesim.vodafone.co.uk/check-out-payasyougo-campaign')\n\ntime.sleep(10)\n\nrandom_words = [\"Adriel\", \"Anabelle\", \"Abagail\", \"Milo\", \"Raven\", \"Halle\", \"Max\", \"Collin\", \"Dane\", \"Jaylynn\", \"Micah\"]\n\nFirstName = \"Max\"\nfirst = web.find_element(\"xpath\", '//*[@id=\"txtFirstName\"]/div[5]/div[5]/div/div/div[1]/div[1]/div/input')\nfirst.send_keys(FirstName)\n\nLastName = \"Lombardo\"\nlast = web.find_element(\"xpath\", '//*[@id=\"txtLastName\"]/div[5]/div[5]/div/div/div[1]/div[2]/div/input')\nlast.send_keys(LastName)\n\nEmail = random.choice(random_words) + \"@westlondonmail.xyz\"\nemailpath = web.find_element(\"xpath\", '/html/body/form/div[5]/div[5]/div/div/div[1]/div[3]/div/input')\nemailpath.send_keys(Email)\n\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "Your function to build a new instance from user input should be a classmethod or a staticmethod, since you want to call it to create a new instance.\nI'd also suggest using @dataclass so you don't need to copy and paste all the variable names in __init__, and using an f-string in your full_info function so you don't hit an error when you try to add coins to the name strings.\nAll together it might look like:\nfrom dataclasses import dataclass\n\n@dataclass\nclass Player: \n firstname: str\n lastname: str\n coins: int\n\n def full_info(self) -> str:\n return f\"{self.firstname} {self.lastname} {self.coins}\"\n\n @classmethod\n def from_user_input(cls) -> 'Player':\n return cls(\n firstname=input(\"Please enter your first name:\"),\n lastname=input(\"Please enter your second name: \"),\n coins=100,\n )\n\nThen you can call Player.from_user_input() to prompt the user for a name and return a new Player object:\n>>> player = Player.from_user_input()\nPlease enter your first name:Bob\nPlease enter your second name: Small\n>>> player\nPlayer(firstname='Bob', lastname='Small', coins=100)\n>>> player.full_info()\n'Bob Small 100'\n\n", "If you want to stay close to your original code, a few changes will work:\nclass Players(): \n def __init__ (self, firstname, lastname, coins): #initialising attributes\n self.firstname = firstname \n self.lastname = lastname\n self.coins= coins\n \n def full_info(self):\n return self.firstname + ' ' + self.lastname + ' ' + str(self.coins)\n \ndef get_user_input():\n firstname= input(\"Please enter your first name:\")\n lastname= input (\"Please enter your second name: \")\n coins= 100 #they are assigned automatically \n return Players(firstname, lastname, coins)\n\nAn example:\na=get_user_input()\n\nPlease enter your first name:UN\n\nPlease enter your second name: Owen\n\na.full_info()\nOut[21]: 'UN Owen 100'\n\n" ]

[ 2, 0 ]

[]

[]

[ "input", "object", "oop", "python" ]

[ "Instead of using OR,AND,XOR, we may sum the two images.\nBefore summing the images, replace the 255 values with 100 (keeping the range of uint8 [0, 255]).\nIn the summed image, there are going to be three values:\n\n0 - Background\n100 - Non-overlapping area\n200 - Overlapping area\n\nWe may assume that pixels with value 100 that touches value 200 belongs to the same original blob.\nFor clearing the overlapping pixels (200) with the touching pixels (100 around them), we may use cv2.floodFill.\nAfter clearing the overlapping pixels and the pixels around them, the pixels that are left (with value 100) are the new blobs.\nExample for clearing the pixels using cv2.floodFill:\nif sum_img[y, x] == 200:\n cv2.floodFill(sum_img, None, (x, y), 0, loDiff=100, upDiff=0)\n\nSetting loDiff=100 is used for filling pixels=100 (and pixels=200) with 0 value (200-loDiff=100, so the 100 is filled with zero).\nFor making the solution better, we may find contours (of pixels=200), and ignore the tiny contours.\n\nCode sample:\nimport cv2\nimport numpy as np\n\n# Read input images as Grayscale.\nimg1 = cv2.imread('image1.png', cv2.IMREAD_GRAYSCALE)\nimg2 = cv2.imread('image2.png', cv2.IMREAD_GRAYSCALE)\n\n# Replace 255 with 100 (we want the sum img1+img2 not to overflow)\nimg1[img1 >= 128] = 100\nimg2[img2 >= 128] = 100\n\n# Sum two images - in the sum, the value of overlapping parts of blobs is going to be 200\nsum_img = img1 + img2\n\ncv2.floodFill(sum_img, None, (0, 0), 0, loDiff=0, upDiff=0) # Remove the white frame.\n\ncv2.imshow('sum_img before floodFill', sum_img) # Show image for testing.\n\n# Find pixels with value 200 (the overlapping blobs).\nthesh = cv2.threshold(sum_img, 199, 255, cv2.THRESH_BINARY)[1]\n\n# Find contours (of overlapping blobs parts)\ncnts = cv2.findContours(thesh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[0]\n\n\n# Iterate contours and fill the overlapping part, and the non-zero pixels around it (i.e with value 100) with zero.\nfor c in cnts:\n area_tresh = 50\n area = cv2.contourArea(c)\n if area > area_tresh: # Ignore very tiny contours\n x, y = tuple(c[0, 0]) # Get coordinates of first pixel in the contour\n if sum_img[y, x] == 200:\n cv2.floodFill(sum_img, None, (x, y), 0, loDiff=100, upDiff=0) # Setting loDiff=100 is set for filling pixels=100 (and pixels=200)\n\nsum_img[sum_img == 200] = 0 # Remove the small remainders\n\n#thesh = cv2.cvtColor(thesh, cv2.COLOR_GRAY2BGR) # Convert to BGR for testing (for drawing the contours)\n#cv2.drawContours(thesh, cnts, -1, (0, 255, 0), 2) # Draw contours for testing\n\n# Show images for testing.\ncv2.imshow('thesh', thesh)\ncv2.imshow('sum_img after floodFill', sum_img)\ncv2.waitKey()\ncv2.destroyAllWindows()\n\n\nNote:\nWe may dilate the images first, if the two blobs in proximity are considered to be the same blob (I don't no if a blob can \"swim\")\nOutput sum_img (after floodFill):\n\n\nUpdate:\nThe above solution finds the blobs that exist in image1 and not in image2 and blobs exist in image2 and not in image1.\nIn case we want to find only the blobs that are new in image2, and we also assume that blobs that are close in both images are the same one, we may add the following stages:\n\nDilate img1 and img2 before summing (two close blobs are going to be overlapping).\nRemove the dilated pixels from sum_img at the end.\nRemove from sum_img all the blobs that exist only in img1 (and not in img2).\n\n\nCode sample:\nimport cv2\nimport numpy as np\n\n# Read input images as Grayscale.\nimg1 = cv2.imread('image1.png', cv2.IMREAD_GRAYSCALE)\nimg2 = cv2.imread('image2.png', cv2.IMREAD_GRAYSCALE)\n\n# Replace 255 with 100 (we want the sum img1+img2 not to overflow)\nimg1[img1 >= 128] = 100\nimg2[img2 >= 128] = 100\n\n# Dilate both images - assume close blobs are the same blob (two blobs are considered overlapped even if they are close but not tuching).\ndilated_img1 = cv2.dilate(img1, np.ones((11, 11), np.uint8))\ndilated_img2 = cv2.dilate(img2, np.ones((11, 11), np.uint8))\n\n# Sum two images - in the sum, the value of overlapping parts of blobs is going to be 200\nsum_img = dilated_img1 + dilated_img2\n\ncv2.floodFill(sum_img, None, (0, 0), 0, loDiff=0, upDiff=0) # Remove the white frame.\n\n#cv2.imshow('sum_img before floodFill', sum_img) # Show image for testing.\n\n# Find pixels with value 200 (the overlapping blobs).\nthesh = cv2.threshold(sum_img, 199, 255, cv2.THRESH_BINARY)[1]\n\n# Find contours (of overlapping blobs parts)\ncnts = cv2.findContours(thesh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[0]\n\n\n# Iterate contours and fill the overlapping part, and the non-zero pixels around it (i.e with value 100) with zero.\nfor c in cnts:\n area_tresh = 0 # Optional\n area = cv2.contourArea(c)\n if area > area_tresh: # Ignore very tiny contours\n x, y = tuple(c[0, 0]) # Get coordinates of first pixel in the contour\n if sum_img[y, x] == 200:\n cv2.floodFill(sum_img, None, (x, y), 0, loDiff=100, upDiff=0) # Setting loDiff=100 is set for filling pixels=100 (and pixels=200)\n\nsum_img[sum_img == 200] = 0 # Remove the small remainders\n\nsum_img[(img1 == 0) & (dilated_img1 == 100)] = 0 # Remove dilated pixels from dilated_img1\nsum_img[(img2 == 0) & (dilated_img2 == 100)] = 0 # Remove dilated pixels from dilated_img2\nsum_img[(img1 == 100) & (img2 == 0)] = 0 # Remove all the blobs that are only in first image (assume new blobs are \"bored\" only in image2)\n\n# Visualization:\nmerged_img = cv2.merge((sum_img*2, img1*2, img2*2))\n\n# The output image is img1, without the \noutput_image = img1.copy()\noutput_image[sum_img == 100] = 0\n\n# Show images for testing.\ncv2.imshow('sum_img', sum_img)\ncv2.imshow('merged_img', merged_img)\ncv2.waitKey()\ncv2.destroyAllWindows()\n\n\nOutput (sum_img*2):\n\nVisualization for testing (merged_img):\n\nGreen - exist only in img1\nYellow - exist both in img1 and img2\nMagenta - exist only in img2, and not too close to blob in img1 (we are looking for the magenta blobs).\n\n\n" ]

[ 3 ]

[]

[]

[ "computer_vision", "matlab", "object_tracking", "opencv", "python" ]

[ "You should be able to use df.groupby() with .size() to get the counts for moves of the same date/time/pallet id/product/move type.\ndf.groupby(['Hour','Date','PALLET_ID','PROD_CODE','CASE_QTY','Move Type']).size().reset_index(name='Total Moves')\n\nSource: Get statistics for each group (such as count, mean, etc) using pandas GroupBy?\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "Try passing the full path of the file dates.txt:\ncwd = os.getcwd()\nfile_name = \"dates.txt\"\nfile_path = os.path.join(cwd, file_name)\n\n# Double check that file exist\nassert os.path.isfile(file_path) is True\n\nwith open(file_path, 'rU') as fp:\n data = read_csv_fp(fp, skip, delimiter)\n fp.close()\n\n" ]

[ 0 ]

[]

[]

[ "python", "python_2.7" ]

[ "One reason for the time consumption is not using an ndpointer for the return value and copying it into a Python list. Instead use the following restype. You won't need the later reshape as well. But take the commenters' advice and don't reinvent the wheel.\ndef mult_matrix_cpp(a, b):\n shape = a.shape[0] * a.shape[1]\n libmatmult.mult_matrix.restype = np.ctypeslib.ndpointer(dtype=np.float64, ndim=2, shape=a.shape, flags=\"C\")\n return libmatmult.mult_matrix(a, b, *a.shape, *b.shape , a.shape[0] * a.shape[1])\n\n", "One way to do this is to create a function that takes two two-dimensional arrays (representing matrices) as arguments, and returns a two-dimensional array containing the result of the matrix multiplication.\nThe code for this function could look like this:\n#include <stdio.h>\n\n// This function multiplies two matrices, and returns the result\n// in a two-dimensional array\nint** matrix_multiply(int** matrix1, int** matrix2, int rows1, int cols1, int rows2, int cols2) {\n int** matrix_result = (int**)malloc(rows1 * sizeof(int*));\n int i, j, k;\n\n // Check if the matrices can be multiplied\n if (cols1 != rows2) {\n printf(\"Matrices cannot be multiplied!\\n\");\n return NULL;\n }\n\n // Perform matrix multiplication\n for (i = 0; i < rows1; i++) {\n matrix_result[i] = (int*)malloc(cols2 * sizeof(int));\n for (j = 0; j < cols2; j++) {\n matrix_result[i][j] = 0;\n for (k = 0; k < cols1; k++) {\n matrix_result[i][j] += matrix1[i][k] * matrix2[k][j];\n }\n }\n }\n\n return matrix_result;\n}\n\nint main(void) {\n // Example matrices\n int** matrix1 = (int**)malloc(2 * sizeof(int*));\n matrix1[0] = (int*)malloc(2 * sizeof(int));\n matrix1[1] = (int*)malloc(2 * sizeof(int));\n matrix1[0][0] = 1; matrix1[0][1] = 2;\n matrix1[1][0] = 3; matrix1[1][1] = 4;\n\n int** matrix2 = (int**)malloc(2 * sizeof(int*));\n matrix2[0] = (int*)malloc(2 * sizeof(int));\n matrix2[1] = (int*)malloc(2 * sizeof(int));\n matrix2[0][0] = 5; matrix2[0][1] = 6;\n matrix2[1][0] = 7; matrix2[1][1] = 8;\n\n // Do matrix multiplication\n int** matrix_result = matrix_multiply(matrix1, matrix2, 2, 2, 2, 2);\n\n // Print the result\n int i, j;\n for (i = 0; i < 2; i++) {\n for (j = 0; j < 2; j++) {\n printf(\"%d \", matrix_result[i][j]);\n }\n printf(\"\\n\");\n }\n\n return 0;\n}\n\n" ]

[ 1, 0 ]

[]

[]

[ "c++", "ctypes", "numpy", "python" ]

[ "The below code snippet should give you an idea on how to go about. This code updates, the value of the counter variable present within a file counter_file.txt\nimport os\n\ncounter_file = open(r'./counter_file.txt', 'r+')\ncontent_lines = []\n\nfor line in counter_file:\n if 'counter=' in line:\n line_components = line.split('=')\n int_value = int(line_components[1]) + 1\n line_components[1] = str(int_value)\n updated_line= \"=\".join(line_components)\n content_lines.append(updated_line)\n else:\n content_lines.append(line)\n\ncounter_file.seek(0)\ncounter_file.truncate()\ncounter_file.writelines(content_lines)\ncounter_file.close()\n\nHopefully, this sheds some light on how to go about with solving your problem\n", "You can create a general text file replacer based on a dictionary containing what to look for as keys and as corresponding values what to replace:\nIn the template text file put some flags where you want variables:\n['<namef>', 'namel', 'email', 'adress', 'city', 'state', 'zip', 'phone', 'phone 2']\n\ncredits = <credit_var>\n\nThen create a mapping dictionary:\nmap_dict = {'<namef>':'New name', '<credit_var>':1}\n\nThen rewrite the text file doing the replacements:\nnewfile = open('new_file.txt', 'w')\nfor l in open('template.txt'):\n for k,v in map_dict.iteritems():\n l = l.replace(k,str(v))\n newfile.write(l)\nnewfile.close()\n\n", "Rather than creating new files like new_file.txt or template.txt, you can use your existing file. Here I am using client_name and client_credit_score as place holders reflecting user data:\nclient_name=\"Joseph\"\nclient_credit_score=1\n\nmap_dict = {'<namef>':f'{client_name}', '<credit_var>':f'{client_credit_score}'}\ntemplate = \"\"\"['<namef>', 'namel', 'email', 'adress', 'city', 'state', 'zip', 'phone', 'phone 2'] \ncredits = <credit_var>\"\"\"\n\nwith open('existing_file.txt', 'w') as f:\n for k,v in map_dict.items():\n template = template.replace(k,str(v))\n f.write(template)\n\nHere the existing_file.txt will have this code initially (like you question):\n['namef', 'namel', 'email', 'adress', 'city', 'state', 'zip', 'phone', 'phone 2']\ncredits = 0\n\nAnd thanks to the map_dict, all the keys will be updated with new values in your file. Here's what output will look like:\n['Joseph', 'namel', 'email', 'adress', 'city', 'state', 'zip', 'phone', 'phone 2']\ncredits = 1\n\nNote: Special thanks to @Saullo and @Tarun for the above answer.\n" ]

[ 4, 1, 0 ]

[]

[]

[ "file", "python", "python_3.x", "variables" ]

[ "If you look into what text.txt actually is, it's probably something like this:\nline1\\nline2\\nline3\n\nNotice how each line is divided by a new line character (\\n). This means the last line doesn't have a new line at the end of it, so when you write it to newText.txt, it won't have a newline.\nWhat you can do is strip away all possible new lines, then add one yourself:\nwith open('newtext.txt', 'w') as f:\n for line in reversed(lines):\n f.write(line.strip() + \"\\n\")\n\n" ]

[ 1 ]

[]

[]

[ "append", "python", "reverse" ]

[ "Based the comment from Kenny Ostrom\n output = {\"Assists per game\": [game_info['ast'] for game_info in result['data']]}\n\nwhich is going to result like you asked\n {'Assists per game': [9, 8]}\n\n" ]

[ 0 ]

[]

[]

[ "dictionary", "json", "list", "python", "python_3.x" ]

[ "A fully symbolic matrix has a complicated expression for its inverse (shown below). Feel free to substitute whatever you like for the entries of the matrix but it's unlikely that you can do anything useful with such an expression.\nHere is the inverse of a fully symbolic 4x4 matrix (computed in less than a second):\nIn [8]: from sympy import *\n\nIn [9]: from sympy.polys.matrices import DomainMatrix\n\nIn [10]: dm = DomainMatrix.from_Matrix(Matrix(symbols('x:16')).reshape(4, 4))\n\nIn [11]: dm.to_field().inv().to_Matrix()\nOut[11]: \n⎡ \n⎢─────────────────────────────────────────────────────────────────────────────\n⎢-x₀⋅x₁₀⋅x₁₃⋅x₇ + x₀⋅x₁₀⋅x₁₅⋅x₅ + x₀⋅x₁₁⋅x₁₃⋅x₆ - x₀⋅x₁₁⋅x₁₄⋅x₅ + x₀⋅x₁₄⋅x₇⋅x₉\n⎢ \n⎢ \n⎢─────────────────────────────────────────────────────────────────────────────\n⎢-x₀⋅x₁₀⋅x₁₃⋅x₇ + x₀⋅x₁₀⋅x₁₅⋅x₅ + x₀⋅x₁₁⋅x₁₃⋅x₆ - x₀⋅x₁₁⋅x₁₄⋅x₅ + x₀⋅x₁₄⋅x₇⋅x₉\n⎢ \n⎢ \n⎢─────────────────────────────────────────────────────────────────────────────\n⎢-x₀⋅x₁₀⋅x₁₃⋅x₇ + x₀⋅x₁₀⋅x₁₅⋅x₅ + x₀⋅x₁₁⋅x₁₃⋅x₆ - x₀⋅x₁₁⋅x₁₄⋅x₅ + x₀⋅x₁₄⋅x₇⋅x₉\n⎢ \n⎢ \n⎢─────────────────────────────────────────────────────────────────────────────\n⎣-x₀⋅x₁₀⋅x₁₃⋅x₇ + x₀⋅x₁₀⋅x₁₅⋅x₅ + x₀⋅x₁₁⋅x₁₃⋅x₆ - x₀⋅x₁₁⋅x₁₄⋅x₅ + x₀⋅x₁₄⋅x₇⋅x₉\n\n -x₁₀⋅x₁\n──────────────────────────────────────────────────────────────────────────────\n - x₀⋅x₁₅⋅x₆⋅x₉ + x₁⋅x₁₀⋅x₁₂⋅x₇ - x₁⋅x₁₀⋅x₁₅⋅x₄ - x₁⋅x₁₁⋅x₁₂⋅x₆ + x₁⋅x₁₁⋅x₁₄⋅x\n \n x₁₀⋅x₁₂\n──────────────────────────────────────────────────────────────────────────────\n - x₀⋅x₁₅⋅x₆⋅x₉ + x₁⋅x₁₀⋅x₁₂⋅x₇ - x₁⋅x₁₀⋅x₁₅⋅x₄ - x₁⋅x₁₁⋅x₁₂⋅x₆ + x₁⋅x₁₁⋅x₁₄⋅x\n \n x₁₁⋅x₁\n──────────────────────────────────────────────────────────────────────────────\n - x₀⋅x₁₅⋅x₆⋅x₉ + x₁⋅x₁₀⋅x₁₂⋅x₇ - x₁⋅x₁₀⋅x₁₅⋅x₄ - x₁⋅x₁₁⋅x₁₂⋅x₆ + x₁⋅x₁₁⋅x₁₄⋅x\n \n -x₁₀⋅x\n──────────────────────────────────────────────────────────────────────────────\n - x₀⋅x₁₅⋅x₆⋅x₉ + x₁⋅x₁₀⋅x₁₂⋅x₇ - x₁⋅x₁₀⋅x₁₅⋅x₄ - x₁⋅x₁₁⋅x₁₂⋅x₆ + x₁⋅x₁₁⋅x₁₄⋅x\n\n₃⋅x₇ + x₁₀⋅x₁₅⋅x₅ + x₁₁⋅x₁₃⋅x₆ - x₁₁⋅x₁₄⋅x₅ + x₁₄⋅x₇⋅x₉ - x₁₅⋅x₆⋅x₉ \n──────────────────────────────────────────────────────────────────────────────\n₄ - x₁⋅x₁₄⋅x₇⋅x₈ + x₁⋅x₁₅⋅x₆⋅x₈ - x₁₀⋅x₁₂⋅x₃⋅x₅ + x₁₀⋅x₁₃⋅x₃⋅x₄ + x₁₁⋅x₁₂⋅x₂⋅x\n \n⋅x₇ - x₁₀⋅x₁₅⋅x₄ - x₁₁⋅x₁₂⋅x₆ + x₁₁⋅x₁₄⋅x₄ - x₁₄⋅x₇⋅x₈ + x₁₅⋅x₆⋅x₈ \n──────────────────────────────────────────────────────────────────────────────\n₄ - x₁⋅x₁₄⋅x₇⋅x₈ + x₁⋅x₁₅⋅x₆⋅x₈ - x₁₀⋅x₁₂⋅x₃⋅x₅ + x₁₀⋅x₁₃⋅x₃⋅x₄ + x₁₁⋅x₁₂⋅x₂⋅x\n \n₂⋅x₅ - x₁₁⋅x₁₃⋅x₄ - x₁₂⋅x₇⋅x₉ + x₁₃⋅x₇⋅x₈ + x₁₅⋅x₄⋅x₉ - x₁₅⋅x₅⋅x₈ \n──────────────────────────────────────────────────────────────────────────────\n₄ - x₁⋅x₁₄⋅x₇⋅x₈ + x₁⋅x₁₅⋅x₆⋅x₈ - x₁₀⋅x₁₂⋅x₃⋅x₅ + x₁₀⋅x₁₃⋅x₃⋅x₄ + x₁₁⋅x₁₂⋅x₂⋅x\n \n₁₂⋅x₅ + x₁₀⋅x₁₃⋅x₄ + x₁₂⋅x₆⋅x₉ - x₁₃⋅x₆⋅x₈ - x₁₄⋅x₄⋅x₉ + x₁₄⋅x₅⋅x₈ \n──────────────────────────────────────────────────────────────────────────────\n₄ - x₁⋅x₁₄⋅x₇⋅x₈ + x₁⋅x₁₅⋅x₆⋅x₈ - x₁₀⋅x₁₂⋅x₃⋅x₅ + x₁₀⋅x₁₃⋅x₃⋅x₄ + x₁₁⋅x₁₂⋅x₂⋅x\n\n \n──────────────────────────────────────────────────────────────────────────────\n₅ - x₁₁⋅x₁₃⋅x₂⋅x₄ - x₁₂⋅x₂⋅x₇⋅x₉ + x₁₂⋅x₃⋅x₆⋅x₉ + x₁₃⋅x₂⋅x₇⋅x₈ - x₁₃⋅x₃⋅x₆⋅x₈ \n \n \n──────────────────────────────────────────────────────────────────────────────\n₅ - x₁₁⋅x₁₃⋅x₂⋅x₄ - x₁₂⋅x₂⋅x₇⋅x₉ + x₁₂⋅x₃⋅x₆⋅x₉ + x₁₃⋅x₂⋅x₇⋅x₈ - x₁₃⋅x₃⋅x₆⋅x₈ \n \n \n──────────────────────────────────────────────────────────────────────────────\n₅ - x₁₁⋅x₁₃⋅x₂⋅x₄ - x₁₂⋅x₂⋅x₇⋅x₉ + x₁₂⋅x₃⋅x₆⋅x₉ + x₁₃⋅x₂⋅x₇⋅x₈ - x₁₃⋅x₃⋅x₆⋅x₈ \n \n \n──────────────────────────────────────────────────────────────────────────────\n₅ - x₁₁⋅x₁₃⋅x₂⋅x₄ - x₁₂⋅x₂⋅x₇⋅x₉ + x₁₂⋅x₃⋅x₆⋅x₉ + x₁₃⋅x₂⋅x₇⋅x₈ - x₁₃⋅x₃⋅x₆⋅x₈ \n\n \n─────────────────────────────────────────────────────────── ─────────────────\n- x₁₄⋅x₃⋅x₄⋅x₉ + x₁₄⋅x₃⋅x₅⋅x₈ + x₁₅⋅x₂⋅x₄⋅x₉ - x₁₅⋅x₂⋅x₅⋅x₈ -x₀⋅x₁₀⋅x₁₃⋅x₇ + \n \n \n─────────────────────────────────────────────────────────── ─────────────────\n- x₁₄⋅x₃⋅x₄⋅x₉ + x₁₄⋅x₃⋅x₅⋅x₈ + x₁₅⋅x₂⋅x₄⋅x₉ - x₁₅⋅x₂⋅x₅⋅x₈ -x₀⋅x₁₀⋅x₁₃⋅x₇ + \n \n \n─────────────────────────────────────────────────────────── ─────────────────\n- x₁₄⋅x₃⋅x₄⋅x₉ + x₁₄⋅x₃⋅x₅⋅x₈ + x₁₅⋅x₂⋅x₄⋅x₉ - x₁₅⋅x₂⋅x₅⋅x₈ -x₀⋅x₁₀⋅x₁₃⋅x₇ + \n \n \n─────────────────────────────────────────────────────────── ─────────────────\n- x₁₄⋅x₃⋅x₄⋅x₉ + x₁₄⋅x₃⋅x₅⋅x₈ + x₁₅⋅x₂⋅x₄⋅x₉ - x₁₅⋅x₂⋅x₅⋅x₈ -x₀⋅x₁₀⋅x₁₃⋅x₇ + \n\n \n──────────────────────────────────────────────────────────────────────────────\nx₀⋅x₁₀⋅x₁₅⋅x₅ + x₀⋅x₁₁⋅x₁₃⋅x₆ - x₀⋅x₁₁⋅x₁₄⋅x₅ + x₀⋅x₁₄⋅x₇⋅x₉ - x₀⋅x₁₅⋅x₆⋅x₉ + \n \n \n──────────────────────────────────────────────────────────────────────────────\nx₀⋅x₁₀⋅x₁₅⋅x₅ + x₀⋅x₁₁⋅x₁₃⋅x₆ - x₀⋅x₁₁⋅x₁₄⋅x₅ + x₀⋅x₁₄⋅x₇⋅x₉ - x₀⋅x₁₅⋅x₆⋅x₉ + \n \n \n──────────────────────────────────────────────────────────────────────────────\nx₀⋅x₁₀⋅x₁₅⋅x₅ + x₀⋅x₁₁⋅x₁₃⋅x₆ - x₀⋅x₁₁⋅x₁₄⋅x₅ + x₀⋅x₁₄⋅x₇⋅x₉ - x₀⋅x₁₅⋅x₆⋅x₉ + \n \n \n──────────────────────────────────────────────────────────────────────────────\nx₀⋅x₁₀⋅x₁₅⋅x₅ + x₀⋅x₁₁⋅x₁₃⋅x₆ - x₀⋅x₁₁⋅x₁₄⋅x₅ + x₀⋅x₁₄⋅x₇⋅x₉ - x₀⋅x₁₅⋅x₆⋅x₉ + \n\n -x₁⋅x₁₀⋅x₁₅ + x₁⋅x₁₁⋅x₁₄ \n──────────────────────────────────────────────────────────────────────────────\nx₁⋅x₁₀⋅x₁₂⋅x₇ - x₁⋅x₁₀⋅x₁₅⋅x₄ - x₁⋅x₁₁⋅x₁₂⋅x₆ + x₁⋅x₁₁⋅x₁₄⋅x₄ - x₁⋅x₁₄⋅x₇⋅x₈ +\n \n x₀⋅x₁₀⋅x₁₅ - x₀⋅x₁₁⋅x₁₄ -\n──────────────────────────────────────────────────────────────────────────────\nx₁⋅x₁₀⋅x₁₂⋅x₇ - x₁⋅x₁₀⋅x₁₅⋅x₄ - x₁⋅x₁₁⋅x₁₂⋅x₆ + x₁⋅x₁₁⋅x₁₄⋅x₄ - x₁⋅x₁₄⋅x₇⋅x₈ +\n \n x₀⋅x₁₁⋅x₁₃ - x₀⋅x₁₅⋅x₉ -\n──────────────────────────────────────────────────────────────────────────────\nx₁⋅x₁₀⋅x₁₂⋅x₇ - x₁⋅x₁₀⋅x₁₅⋅x₄ - x₁⋅x₁₁⋅x₁₂⋅x₆ + x₁⋅x₁₁⋅x₁₄⋅x₄ - x₁⋅x₁₄⋅x₇⋅x₈ +\n \n -x₀⋅x₁₀⋅x₁₃ + x₀⋅x₁₄⋅x₉ \n──────────────────────────────────────────────────────────────────────────────\nx₁⋅x₁₀⋅x₁₂⋅x₇ - x₁⋅x₁₀⋅x₁₅⋅x₄ - x₁⋅x₁₁⋅x₁₂⋅x₆ + x₁⋅x₁₁⋅x₁₄⋅x₄ - x₁⋅x₁₄⋅x₇⋅x₈ +\n\n+ x₁₀⋅x₁₃⋅x₃ - x₁₁⋅x₁₃⋅x₂ - x₁₄⋅x₃⋅x₉ + x₁₅⋅x₂⋅x₉ \n──────────────────────────────────────────────────────────────────────────────\n x₁⋅x₁₅⋅x₆⋅x₈ - x₁₀⋅x₁₂⋅x₃⋅x₅ + x₁₀⋅x₁₃⋅x₃⋅x₄ + x₁₁⋅x₁₂⋅x₂⋅x₅ - x₁₁⋅x₁₃⋅x₂⋅x₄ \n \n x₁₀⋅x₁₂⋅x₃ + x₁₁⋅x₁₂⋅x₂ + x₁₄⋅x₃⋅x₈ - x₁₅⋅x₂⋅x₈ \n──────────────────────────────────────────────────────────────────────────────\n x₁⋅x₁₅⋅x₆⋅x₈ - x₁₀⋅x₁₂⋅x₃⋅x₅ + x₁₀⋅x₁₃⋅x₃⋅x₄ + x₁₁⋅x₁₂⋅x₂⋅x₅ - x₁₁⋅x₁₃⋅x₂⋅x₄ \n \n x₁⋅x₁₁⋅x₁₂ + x₁⋅x₁₅⋅x₈ + x₁₂⋅x₃⋅x₉ - x₁₃⋅x₃⋅x₈ \n──────────────────────────────────────────────────────────────────────────────\n x₁⋅x₁₅⋅x₆⋅x₈ - x₁₀⋅x₁₂⋅x₃⋅x₅ + x₁₀⋅x₁₃⋅x₃⋅x₄ + x₁₁⋅x₁₂⋅x₂⋅x₅ - x₁₁⋅x₁₃⋅x₂⋅x₄ \n \n+ x₁⋅x₁₀⋅x₁₂ - x₁⋅x₁₄⋅x₈ - x₁₂⋅x₂⋅x₉ + x₁₃⋅x₂⋅x₈ \n──────────────────────────────────────────────────────────────────────────────\n x₁⋅x₁₅⋅x₆⋅x₈ - x₁₀⋅x₁₂⋅x₃⋅x₅ + x₁₀⋅x₁₃⋅x₃⋅x₄ + x₁₁⋅x₁₂⋅x₂⋅x₅ - x₁₁⋅x₁₃⋅x₂⋅x₄ \n\n \n──────────────────────────────────────────────────────────────────────────────\n- x₁₂⋅x₂⋅x₇⋅x₉ + x₁₂⋅x₃⋅x₆⋅x₉ + x₁₃⋅x₂⋅x₇⋅x₈ - x₁₃⋅x₃⋅x₆⋅x₈ - x₁₄⋅x₃⋅x₄⋅x₉ + x\n \n \n──────────────────────────────────────────────────────────────────────────────\n- x₁₂⋅x₂⋅x₇⋅x₉ + x₁₂⋅x₃⋅x₆⋅x₉ + x₁₃⋅x₂⋅x₇⋅x₈ - x₁₃⋅x₃⋅x₆⋅x₈ - x₁₄⋅x₃⋅x₄⋅x₉ + x\n \n \n──────────────────────────────────────────────────────────────────────────────\n- x₁₂⋅x₂⋅x₇⋅x₉ + x₁₂⋅x₃⋅x₆⋅x₉ + x₁₃⋅x₂⋅x₇⋅x₈ - x₁₃⋅x₃⋅x₆⋅x₈ - x₁₄⋅x₃⋅x₄⋅x₉ + x\n \n \n──────────────────────────────────────────────────────────────────────────────\n- x₁₂⋅x₂⋅x₇⋅x₉ + x₁₂⋅x₃⋅x₆⋅x₉ + x₁₃⋅x₂⋅x₇⋅x₈ - x₁₃⋅x₃⋅x₆⋅x₈ - x₁₄⋅x₃⋅x₄⋅x₉ + x\n\n \n───────────────────────────────────────── ───────────────────────────────────\n₁₄⋅x₃⋅x₅⋅x₈ + x₁₅⋅x₂⋅x₄⋅x₉ - x₁₅⋅x₂⋅x₅⋅x₈ -x₀⋅x₁₀⋅x₁₃⋅x₇ + x₀⋅x₁₀⋅x₁₅⋅x₅ + x₀\n \n \n───────────────────────────────────────── ───────────────────────────────────\n₁₄⋅x₃⋅x₅⋅x₈ + x₁₅⋅x₂⋅x₄⋅x₉ - x₁₅⋅x₂⋅x₅⋅x₈ -x₀⋅x₁₀⋅x₁₃⋅x₇ + x₀⋅x₁₀⋅x₁₅⋅x₅ + x₀\n \n \n───────────────────────────────────────── ───────────────────────────────────\n₁₄⋅x₃⋅x₅⋅x₈ + x₁₅⋅x₂⋅x₄⋅x₉ - x₁₅⋅x₂⋅x₅⋅x₈ -x₀⋅x₁₀⋅x₁₃⋅x₇ + x₀⋅x₁₀⋅x₁₅⋅x₅ + x₀\n \n \n───────────────────────────────────────── ───────────────────────────────────\n₁₄⋅x₃⋅x₅⋅x₈ + x₁₅⋅x₂⋅x₄⋅x₉ - x₁₅⋅x₂⋅x₅⋅x₈ -x₀⋅x₁₀⋅x₁₃⋅x₇ + x₀⋅x₁₀⋅x₁₅⋅x₅ + x₀\n\n \n──────────────────────────────────────────────────────────────────────────────\n⋅x₁₁⋅x₁₃⋅x₆ - x₀⋅x₁₁⋅x₁₄⋅x₅ + x₀⋅x₁₄⋅x₇⋅x₉ - x₀⋅x₁₅⋅x₆⋅x₉ + x₁⋅x₁₀⋅x₁₂⋅x₇ - x₁\n \n \n──────────────────────────────────────────────────────────────────────────────\n⋅x₁₁⋅x₁₃⋅x₆ - x₀⋅x₁₁⋅x₁₄⋅x₅ + x₀⋅x₁₄⋅x₇⋅x₉ - x₀⋅x₁₅⋅x₆⋅x₉ + x₁⋅x₁₀⋅x₁₂⋅x₇ - x₁\n \n \n──────────────────────────────────────────────────────────────────────────────\n⋅x₁₁⋅x₁₃⋅x₆ - x₀⋅x₁₁⋅x₁₄⋅x₅ + x₀⋅x₁₄⋅x₇⋅x₉ - x₀⋅x₁₅⋅x₆⋅x₉ + x₁⋅x₁₀⋅x₁₂⋅x₇ - x₁\n \n \n──────────────────────────────────────────────────────────────────────────────\n⋅x₁₁⋅x₁₃⋅x₆ - x₀⋅x₁₁⋅x₁₄⋅x₅ + x₀⋅x₁₄⋅x₇⋅x₉ - x₀⋅x₁₅⋅x₆⋅x₉ + x₁⋅x₁₀⋅x₁₂⋅x₇ - x₁\n\n -x₁⋅x₁₄⋅x₇ + x₁⋅x₁₅⋅x₆ + x₁₃⋅x₂⋅x₇ - x₁₃⋅\n──────────────────────────────────────────────────────────────────────────────\n⋅x₁₀⋅x₁₅⋅x₄ - x₁⋅x₁₁⋅x₁₂⋅x₆ + x₁⋅x₁₁⋅x₁₄⋅x₄ - x₁⋅x₁₄⋅x₇⋅x₈ + x₁⋅x₁₅⋅x₆⋅x₈ - x₁\n \n x₀⋅x₁₄⋅x₇ - x₀⋅x₁₅⋅x₆ - x₁₂⋅x₂⋅x₇ + x₁₂⋅x\n──────────────────────────────────────────────────────────────────────────────\n⋅x₁₀⋅x₁₅⋅x₄ - x₁⋅x₁₁⋅x₁₂⋅x₆ + x₁⋅x₁₁⋅x₁₄⋅x₄ - x₁⋅x₁₄⋅x₇⋅x₈ + x₁⋅x₁₅⋅x₆⋅x₈ - x₁\n \n -x₀⋅x₁₃⋅x₇ + x₀⋅x₁₅⋅x₅ + x₁⋅x₁₂⋅x₇ - x₁⋅x\n──────────────────────────────────────────────────────────────────────────────\n⋅x₁₀⋅x₁₅⋅x₄ - x₁⋅x₁₁⋅x₁₂⋅x₆ + x₁⋅x₁₁⋅x₁₄⋅x₄ - x₁⋅x₁₄⋅x₇⋅x₈ + x₁⋅x₁₅⋅x₆⋅x₈ - x₁\n \n x₀⋅x₁₃⋅x₆ - x₀⋅x₁₄⋅x₅ - x₁⋅x₁₂⋅x₆ + x₁⋅x₁\n──────────────────────────────────────────────────────────────────────────────\n⋅x₁₀⋅x₁₅⋅x₄ - x₁⋅x₁₁⋅x₁₂⋅x₆ + x₁⋅x₁₁⋅x₁₄⋅x₄ - x₁⋅x₁₄⋅x₇⋅x₈ + x₁⋅x₁₅⋅x₆⋅x₈ - x₁\n\nx₃⋅x₆ + x₁₄⋅x₃⋅x₅ - x₁₅⋅x₂⋅x₅ \n──────────────────────────────────────────────────────────────────────────────\n₀⋅x₁₂⋅x₃⋅x₅ + x₁₀⋅x₁₃⋅x₃⋅x₄ + x₁₁⋅x₁₂⋅x₂⋅x₅ - x₁₁⋅x₁₃⋅x₂⋅x₄ - x₁₂⋅x₂⋅x₇⋅x₉ + x\n \n₃⋅x₆ - x₁₄⋅x₃⋅x₄ + x₁₅⋅x₂⋅x₄ \n──────────────────────────────────────────────────────────────────────────────\n₀⋅x₁₂⋅x₃⋅x₅ + x₁₀⋅x₁₃⋅x₃⋅x₄ + x₁₁⋅x₁₂⋅x₂⋅x₅ - x₁₁⋅x₁₃⋅x₂⋅x₄ - x₁₂⋅x₂⋅x₇⋅x₉ + x\n \n₁₅⋅x₄ - x₁₂⋅x₃⋅x₅ + x₁₃⋅x₃⋅x₄ \n──────────────────────────────────────────────────────────────────────────────\n₀⋅x₁₂⋅x₃⋅x₅ + x₁₀⋅x₁₃⋅x₃⋅x₄ + x₁₁⋅x₁₂⋅x₂⋅x₅ - x₁₁⋅x₁₃⋅x₂⋅x₄ - x₁₂⋅x₂⋅x₇⋅x₉ + x\n \n₄⋅x₄ + x₁₂⋅x₂⋅x₅ - x₁₃⋅x₂⋅x₄ \n──────────────────────────────────────────────────────────────────────────────\n₀⋅x₁₂⋅x₃⋅x₅ + x₁₀⋅x₁₃⋅x₃⋅x₄ + x₁₁⋅x₁₂⋅x₂⋅x₅ - x₁₁⋅x₁₃⋅x₂⋅x₄ - x₁₂⋅x₂⋅x₇⋅x₉ + x\n\n \n──────────────────────────────────────────────────────────────────────────────\n₁₂⋅x₃⋅x₆⋅x₉ + x₁₃⋅x₂⋅x₇⋅x₈ - x₁₃⋅x₃⋅x₆⋅x₈ - x₁₄⋅x₃⋅x₄⋅x₉ + x₁₄⋅x₃⋅x₅⋅x₈ + x₁₅⋅\n \n \n──────────────────────────────────────────────────────────────────────────────\n₁₂⋅x₃⋅x₆⋅x₉ + x₁₃⋅x₂⋅x₇⋅x₈ - x₁₃⋅x₃⋅x₆⋅x₈ - x₁₄⋅x₃⋅x₄⋅x₉ + x₁₄⋅x₃⋅x₅⋅x₈ + x₁₅⋅\n \n \n──────────────────────────────────────────────────────────────────────────────\n₁₂⋅x₃⋅x₆⋅x₉ + x₁₃⋅x₂⋅x₇⋅x₈ - x₁₃⋅x₃⋅x₆⋅x₈ - x₁₄⋅x₃⋅x₄⋅x₉ + x₁₄⋅x₃⋅x₅⋅x₈ + x₁₅⋅\n \n \n──────────────────────────────────────────────────────────────────────────────\n₁₂⋅x₃⋅x₆⋅x₉ + x₁₃⋅x₂⋅x₇⋅x₈ - x₁₃⋅x₃⋅x₆⋅x₈ - x₁₄⋅x₃⋅x₄⋅x₉ + x₁₄⋅x₃⋅x₅⋅x₈ + x₁₅⋅\n\n \n─────────────────────── ─────────────────────────────────────────────────────\nx₂⋅x₄⋅x₉ - x₁₅⋅x₂⋅x₅⋅x₈ -x₀⋅x₁₀⋅x₁₃⋅x₇ + x₀⋅x₁₀⋅x₁₅⋅x₅ + x₀⋅x₁₁⋅x₁₃⋅x₆ - x₀⋅x\n \n \n─────────────────────── ─────────────────────────────────────────────────────\nx₂⋅x₄⋅x₉ - x₁₅⋅x₂⋅x₅⋅x₈ -x₀⋅x₁₀⋅x₁₃⋅x₇ + x₀⋅x₁₀⋅x₁₅⋅x₅ + x₀⋅x₁₁⋅x₁₃⋅x₆ - x₀⋅x\n \n \n─────────────────────── ─────────────────────────────────────────────────────\nx₂⋅x₄⋅x₉ - x₁₅⋅x₂⋅x₅⋅x₈ -x₀⋅x₁₀⋅x₁₃⋅x₇ + x₀⋅x₁₀⋅x₁₅⋅x₅ + x₀⋅x₁₁⋅x₁₃⋅x₆ - x₀⋅x\n \n \n─────────────────────── ─────────────────────────────────────────────────────\nx₂⋅x₄⋅x₉ - x₁₅⋅x₂⋅x₅⋅x₈ -x₀⋅x₁₀⋅x₁₃⋅x₇ + x₀⋅x₁₀⋅x₁₅⋅x₅ + x₀⋅x₁₁⋅x₁₃⋅x₆ - x₀⋅x\n\n \n──────────────────────────────────────────────────────────────────────────────\n₁₁⋅x₁₄⋅x₅ + x₀⋅x₁₄⋅x₇⋅x₉ - x₀⋅x₁₅⋅x₆⋅x₉ + x₁⋅x₁₀⋅x₁₂⋅x₇ - x₁⋅x₁₀⋅x₁₅⋅x₄ - x₁⋅x\n \n \n──────────────────────────────────────────────────────────────────────────────\n₁₁⋅x₁₄⋅x₅ + x₀⋅x₁₄⋅x₇⋅x₉ - x₀⋅x₁₅⋅x₆⋅x₉ + x₁⋅x₁₀⋅x₁₂⋅x₇ - x₁⋅x₁₀⋅x₁₅⋅x₄ - x₁⋅x\n \n \n──────────────────────────────────────────────────────────────────────────────\n₁₁⋅x₁₄⋅x₅ + x₀⋅x₁₄⋅x₇⋅x₉ - x₀⋅x₁₅⋅x₆⋅x₉ + x₁⋅x₁₀⋅x₁₂⋅x₇ - x₁⋅x₁₀⋅x₁₅⋅x₄ - x₁⋅x\n \n \n──────────────────────────────────────────────────────────────────────────────\n₁₁⋅x₁₄⋅x₅ + x₀⋅x₁₄⋅x₇⋅x₉ - x₀⋅x₁₅⋅x₆⋅x₉ + x₁⋅x₁₀⋅x₁₂⋅x₇ - x₁⋅x₁₀⋅x₁₅⋅x₄ - x₁⋅x\n\n x₁⋅x₁₀⋅x₇ - x₁⋅x₁₁⋅x₆ - x₁₀⋅x₃⋅x₅ + x₁₁⋅x₂⋅x₅ - x₂⋅x₇⋅x₉ +\n──────────────────────────────────────────────────────────────────────────────\n₁₁⋅x₁₂⋅x₆ + x₁⋅x₁₁⋅x₁₄⋅x₄ - x₁⋅x₁₄⋅x₇⋅x₈ + x₁⋅x₁₅⋅x₆⋅x₈ - x₁₀⋅x₁₂⋅x₃⋅x₅ + x₁₀⋅\n \n -x₀⋅x₁₀⋅x₇ + x₀⋅x₁₁⋅x₆ + x₁₀⋅x₃⋅x₄ - x₁₁⋅x₂⋅x₄ + x₂⋅x₇⋅x₈ \n──────────────────────────────────────────────────────────────────────────────\n₁₁⋅x₁₂⋅x₆ + x₁⋅x₁₁⋅x₁₄⋅x₄ - x₁⋅x₁₄⋅x₇⋅x₈ + x₁⋅x₁₅⋅x₆⋅x₈ - x₁₀⋅x₁₂⋅x₃⋅x₅ + x₁₀⋅\n \n -x₀⋅x₁₁⋅x₅ + x₀⋅x₇⋅x₉ + x₁⋅x₁₁⋅x₄ - x₁⋅x₇⋅x₈ - x₃⋅x₄⋅x₉ +\n──────────────────────────────────────────────────────────────────────────────\n₁₁⋅x₁₂⋅x₆ + x₁⋅x₁₁⋅x₁₄⋅x₄ - x₁⋅x₁₄⋅x₇⋅x₈ + x₁⋅x₁₅⋅x₆⋅x₈ - x₁₀⋅x₁₂⋅x₃⋅x₅ + x₁₀⋅\n \n x₀⋅x₁₀⋅x₅ - x₀⋅x₆⋅x₉ - x₁⋅x₁₀⋅x₄ + x₁⋅x₆⋅x₈ + x₂⋅x₄⋅x₉ - \n──────────────────────────────────────────────────────────────────────────────\n₁₁⋅x₁₂⋅x₆ + x₁⋅x₁₁⋅x₁₄⋅x₄ - x₁⋅x₁₄⋅x₇⋅x₈ + x₁⋅x₁₅⋅x₆⋅x₈ - x₁₀⋅x₁₂⋅x₃⋅x₅ + x₁₀⋅\n\n x₃⋅x₆⋅x₉ \n──────────────────────────────────────────────────────────────────────────────\nx₁₃⋅x₃⋅x₄ + x₁₁⋅x₁₂⋅x₂⋅x₅ - x₁₁⋅x₁₃⋅x₂⋅x₄ - x₁₂⋅x₂⋅x₇⋅x₉ + x₁₂⋅x₃⋅x₆⋅x₉ + x₁₃⋅\n \n- x₃⋅x₆⋅x₈ \n──────────────────────────────────────────────────────────────────────────────\nx₁₃⋅x₃⋅x₄ + x₁₁⋅x₁₂⋅x₂⋅x₅ - x₁₁⋅x₁₃⋅x₂⋅x₄ - x₁₂⋅x₂⋅x₇⋅x₉ + x₁₂⋅x₃⋅x₆⋅x₉ + x₁₃⋅\n \n x₃⋅x₅⋅x₈ \n──────────────────────────────────────────────────────────────────────────────\nx₁₃⋅x₃⋅x₄ + x₁₁⋅x₁₂⋅x₂⋅x₅ - x₁₁⋅x₁₃⋅x₂⋅x₄ - x₁₂⋅x₂⋅x₇⋅x₉ + x₁₂⋅x₃⋅x₆⋅x₉ + x₁₃⋅\n \nx₂⋅x₅⋅x₈ \n──────────────────────────────────────────────────────────────────────────────\nx₁₃⋅x₃⋅x₄ + x₁₁⋅x₁₂⋅x₂⋅x₅ - x₁₁⋅x₁₃⋅x₂⋅x₄ - x₁₂⋅x₂⋅x₇⋅x₉ + x₁₂⋅x₃⋅x₆⋅x₉ + x₁₃⋅\n\n \n──────────────────────────────────────────────────────────────────────────────\nx₂⋅x₇⋅x₈ - x₁₃⋅x₃⋅x₆⋅x₈ - x₁₄⋅x₃⋅x₄⋅x₉ + x₁₄⋅x₃⋅x₅⋅x₈ + x₁₅⋅x₂⋅x₄⋅x₉ - x₁₅⋅x₂⋅\n \n \n──────────────────────────────────────────────────────────────────────────────\nx₂⋅x₇⋅x₈ - x₁₃⋅x₃⋅x₆⋅x₈ - x₁₄⋅x₃⋅x₄⋅x₉ + x₁₄⋅x₃⋅x₅⋅x₈ + x₁₅⋅x₂⋅x₄⋅x₉ - x₁₅⋅x₂⋅\n \n \n──────────────────────────────────────────────────────────────────────────────\nx₂⋅x₇⋅x₈ - x₁₃⋅x₃⋅x₆⋅x₈ - x₁₄⋅x₃⋅x₄⋅x₉ + x₁₄⋅x₃⋅x₅⋅x₈ + x₁₅⋅x₂⋅x₄⋅x₉ - x₁₅⋅x₂⋅\n \n \n──────────────────────────────────────────────────────────────────────────────\nx₂⋅x₇⋅x₈ - x₁₃⋅x₃⋅x₆⋅x₈ - x₁₄⋅x₃⋅x₄⋅x₉ + x₁₄⋅x₃⋅x₅⋅x₈ + x₁₅⋅x₂⋅x₄⋅x₉ - x₁₅⋅x₂⋅\n\n ⎤\n─────⎥\nx₅⋅x₈⎥\n ⎥\n ⎥\n─────⎥\nx₅⋅x₈⎥\n ⎥\n ⎥\n─────⎥\nx₅⋅x₈⎥\n ⎥\n ⎥\n─────⎥\nx₅⋅x₈⎦\n\n" ]

[ 2 ]

[]

[]

[ "matrix", "python", "sympy", "tensor" ]

[ "You're missing a conflict_action in your sql statement. See https://www.postgresql.org/docs/current/sql-insert.html#:~:text=ON%20CONFLICT%20DO%20NOTHING%20simply,can%20perform%20unique%20index%20inference. for details.\nEG You might want ON CONFLICT (country, year, month) DO NOTHING\n" ]

[ 2 ]

[]

[]

[ "postgresql", "python" ]

[ "PyPI will not read your package distributions for the image. You have to use the image's external link, for example:\n.. image:: https://raw.githubusercontent.com/greyli/flask-share/master/images/demo.png\n\nIf you are using Markdown description, use this:\n\n\nBe sure to replace the URL in the above examples with your image URL, here I use the image hosted by GitHub, the real demo is on PyPI.\nP.S. To get the image's raw link on GitHub, right-click the image and choose Copy image address.\n", "Go to the image address in the Github repository. The path shown will be like this:\nhttps://github.com/tensorbored/kds/blob/master/docs/_static/readme_lift.png\n\nChange the blob term in the image address to raw\nhttps://github.com/tensorbored/kds/raw/master/docs/_static/readme_lift.png\n\n", "If you have your images on Github, navigate to the image then right click on download button and copy link address:\n\nThen you can add it in your README.md file:\n\n\nIt should be rendered properly both on Github and PyPi.\n", "Setting ?raw=True at the end of GitHub image link seems to work.\nexample:\n\n\nI had found this somewhere on the internet previously, but couldn't find it now. I'll credit the original author when I find it again.\n", "The long_description_content_type should be text/x-rst if you use restructured text syntax (README.rst). Assuming that is what you are using based on \".. image::\". If you save the image on GitHub and use that external link for the image then it works (typically something like raw.githubusercontent.com.... as described in one of the above answers).\nIt does work as shown in this pypi package:\nhttps://pypi.org/project/gammath-spot/\n" ]

[ 34, 8, 3, 3, 0 ]

[]

[]

[ "github", "pypi", "python", "readme", "restructuredtext" ]

[ "Use Pandas merge\nimport pandas as pd\n\n# load the data from the two tables into pandas dataframes\ndf1 = pd.read_csv('A.csv')\ndf2 = pd.read_csv('B.csv')\n\n# merge the df using 'id' column\nmerged_df = pd.merge(df1, df2, on='id')\n\nprint(merged_df)\n\n" ]

[ 1 ]

[]

[]

[ "pandas", "python" ]