Datasets:

---

suriyagunasekar

/

stackoverflow-python-with-meta-data

like 11

[ "I guess you are ok with unused **kwargs if those are at least commented in the code (space for future expansion) - but it is not the same for *args: adding positional arguments in specialized classes is much more problematic, due to possible conflicting arguments down the tree, and it would kill the possibility of multiple inheritance with different arguments as well.\nAlso, if there is any chance your classes are composable, you should just call the methods in super() and pass **kwargs ahead anyway. And that applies even if you are writing a class you think of as the base for a hyerarchy: you might come up later with mixin classes, that could be inserted before your \"base\" when composing subclasses.\n" ]

[ 0 ]

[]

[]

[ "arguments", "inheritance", "keyword_argument", "python" ]

[ "Unfortunately I can't help with the Python specific syntax but you don't need to create any subclasses. \nAfter your QListWidget is created, call setSelectionMode() with one of the multiple selection types passed in, probably QAbstractItemView::ExtendedSelection is the one you want. There are a few variations on this mode that you may want to look at.\nIn your slot for the itemSelectionChanged() signal, call selectedItems() to get a QList of QListWidgetItem pointers.\n", "For PyQT4 it's\nQListWidget.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection)\n\n", "Example of getting multiple selected values in listWidget with multiple selection.\n\nfrom PyQt5 import QtWidgets, QtCore\nclass Test(QtWidgets.QDialog):\n def __init__(self, parent=None):\n super(Test, self).__init__(parent)\n self.layout = QtWidgets.QVBoxLayout()\n self.listWidget = QtWidgets.QListWidget()\n self.listWidget.setSelectionMode(\n QtWidgets.QAbstractItemView.ExtendedSelection\n )\n self.listWidget.setGeometry(QtCore.QRect(10, 10, 211, 291))\n for i in range(10):\n item = QtWidgets.QListWidgetItem(\"Item %i\" % i)\n self.listWidget.addItem(item)\n self.listWidget.itemClicked.connect(self.printItemText)\n self.layout.addWidget(self.listWidget)\n self.setLayout(self.layout)\n\n def printItemText(self):\n items = self.listWidget.selectedItems()\n x = []\n for i in range(len(items)):\n x.append(str(self.listWidget.selectedItems()[i].text()))\n\n print (x)\n\nif __name__ == \"__main__\":\n import sys\n app = QtWidgets.QApplication(sys.argv)\n form = Test()\n form.show()\n app.exec_()\n\noutput :-\n\n", "Using PyQt5 you can set the SelectionMode of your QListWidget to allow multiple selections by using:\nfrom PyQt5 import QtWidgets \n\n\nQtWidgets.QListWidget.setSelectionMode(2)\n\nwhere\n\nSelectionMode = 0 => NoSelection\nSelectionMode = 1 => SingleSelection\nSelectionMode = 2 => MultiSelection\nSelectionMode = 3 => ExtendedSelection\nSelectionMode = 4 => ContiguousSelection\n\nReference\nIn Qt Creator you find this option here:\n\n", "In addition, you can use list comprehension to get the selected items, for example\nnum_ITEMS=[item.text() for item in self.listWidget.selectedItems()]\n\n", "After searching for much time I found out they they changed this in PyQt6. Now you have to do the following:\nfrom PyQt6.QtWidgets import QListWidget, QAbstractItemView\n# ... all your other imports\nclass MyWidget(QWidget):\ndef __init__(self):\n super(MyWidget, self).__init__()\n self.layout = QHBoxLayout()\n self.my_list_view = QListWidget()\n self.my_list_view.setSelectionMode(QAbstractItemView.SelectionMode.MultiSelection) # also try QAbstractItemView.SelectionMode.ExtendedSelection if you want the user to press CTRL for multiple selection\n\nBasically you have to import the QAbstractItemView from the widgets and use the right selection mode\n" ]

[ 34, 30, 13, 5, 4, 0 ]

[]

[]

[ "pyqt", "python", "qlistwidget", "user_interface" ]

[ "Maybe you can switch the linter, such as from 'pylint' to 'flake8' or other switches. If you don't know how to switch, you can refer to this page.\nIf it still doesn't work, maybe some extension you installed caused the problem. Try to disable the extensions, and remember to restart the VSCode. You can refer to\nthis and this page for some inspire.\n", "You should open the Visual Studio Code from the Developer Command Prompt. Using a Developer Command Prompt (and not a basic/classic/regular console) helps to make sure that all the paths and environment variables are set up correctly.\n", "You can click to Files => Preferences => Setting => Extensions => C/C++ and clicl \"v\" for all empty place.\n", "I had the same issue, you must have turned the error squiggles 'off'.\nHead to the settings.json file in your workspace (under vscode folder) and change \"C_Cpp.errorSquiggles\" to \"Enabled\".\nMight Work.\n" ]

[ 0, 0, 0, 0 ]

[]

[]

[ "python", "visual_studio_code", "vscode_settings" ]

[ "Gotcha! While you are expected to compose your delta live tables setup code in the databricks notebook environment, you are not meant to run it there. The only supported way to run your code is to head on over to the pipelines interface to run it.\nEnd of Answer.\nAlthough....\n\nThis is bad news for developers who wrote a lot of code and aren't even sure if it's syntactically valid (since the databricks IDE has only limited real-time feedback). You would now be stuck waiting for your pipeline to spin up resources, start, fail, then go through the stack trace to try and figure out where you went wrong. You're stuck with this workflow to work through logical errors, but you don't have to be stuck with it while working through syntactical errors.\nHere is a workaround I came up with:\ntry:\n import dlt # When run in a pipeline, this package will exist (no way to import it here)\nexcept ImportError:\n class dlt: # \"Mock\" the dlt class so that we can syntax check the rest of our python in the databricks notebook editor\n def table(comment, **options): # Mock the @dlt.table attribute so that it is seen as syntactically valid below\n def _(f):\n pass\n return _;\n\[email protected](comment = \"Raw Widget Data\")\ndef widgets_raw():\n return (\n spark.readStream.format(\"cloudFiles\")\n .option(\"cloudFiles.format\", \"csv\").option(\"header\", \"true\").option(\"sep\", \"|\")\n .load(\"/mnt/LandingZone/EMRAW/widgets\")\n )\n\nThe trick here is I am mocking out the dlt class to the bare minimum to pass syntax checks, so the rest of my code can be verified.\nThe annoying thing is that sql notebooks don't have this problem, when you run them, you get the pleasing message:\n\nThis Delta Live Tables query is syntactically valid, but you must create a pipeline in order to define and populate your table.\n\nUnfortunately, I find sql notebooks limiting in other ways, so pick your poison.\nEither way, hopefully it's clear that your code won't actually do anything until you run it in a pipeline. The notebook is just for setup, and it's nice to get as many syntax checks out of the way upfront before you have to start troubleshooting from the pipelines UI.\n" ]

[ 0 ]

[]

[]

[ "azure_databricks", "databricks", "delta_live_tables", "pyspark", "python" ]

[ "c:\\python27\\python.exe c:\\somescript.py %*\n\n", "Open a command line (⊞ Win+R, cmd, ↵ Enter)\nand type python -V, ↵ Enter.\nYou should get a response back, something like Python 2.7.1.\nIf you do not, you may not have Python installed. Fix this first.\nOnce you have Python, your batch file should look like\n@echo off\npython c:\\somescript.py %*\npause\n\nThis will keep the command window open after the script finishes, so you can see any errors or messages. Once you are happy with it you can remove the 'pause' line and the command window will close automatically when finished.\n", "Here's how you can put both batch code and the python one in single file:\n0<0# : ^\n''' \n@echo off\necho batch code\npython \"%~f0\" %*\nexit /b 0\n'''\n\nprint(\"python code\")\n\nthe ''' respectively starts and ends python multi line comments.\n0<0# : ^ is more interesting - due to redirection priority in batch it will be interpreted like :0<0# ^ by the batch script which is a label which execution will be not displayed on the screen. The caret at the end will escape the new line and second line will be attached to the first line.For python it will be 0<0 statement and a start of inline comment.\nThe credit goes to siberia-man\n", "Just simply open a batch file that contains this two lines in the same folder of your python script:\nsomescript.py\npause\n\n", "If you've added Python to your PATH then you can also simply run it like this.\npython somescript.py\n\n", "You can use python code directly in batch file,\nhttps://gist.github.com/jadient/9849314.\n@echo off & python -x \"%~f0\" %* & goto :eof\nimport sys\nprint(\"Hello World!\")\n\nSee explanation, Python command line -x option.\n", "--- xxx.bat ---\n@echo off\nset NAME1=\"Marc\"\nset NAME2=\"Travis\"\npy -u \"CheckFile.py\" %NAME1% %NAME2%\necho %ERRORLEVEL%\npause\n\n--- yyy.py ---\nimport sys\nimport os\ndef names(f1,f2):\n\n print (f1)\n print (f2)\n res= True\n if f1 == \"Travis\":\n res= False\n return res\n\nif __name__ == \"__main__\":\n a = sys.argv[1]\n b = sys.argv[2]\n c = names(a, b) \n if c:\n sys.exit(1)\n else:\n sys.exit(0) \n\n", "Similar to npocmaka's solution, if you are having more than one line of batch code in your batch file besides the python code, check this out: http://lallouslab.net/2017/06/12/batchography-embedding-python-scripts-in-your-batch-file-script/\n@echo off\nrem = \"\"\"\necho some batch commands\necho another batch command\npython -x \"%~f0\" %*\necho some more batch commands\ngoto :eof\n\n\"\"\"\n# Anything here is interpreted by Python\nimport platform\nimport sys\nprint(\"Hello world from Python %s!\\n\" % platform.python_version())\nprint(\"The passed arguments are: %s\" % sys.argv[1:])\n\nWhat this code does is it runs itself as a python file by putting all the batch code into a multiline string. The beginning of this string is in a variable called rem, to make the batch code read it as a comment. The first line containing @echo off is ignored in the python code because of the -x parameter.\nit is important to mention that if you want to use \\ in your batch code, for example in a file path, you'll have to use r\"\"\"...\"\"\" to surround it to use it as a raw string without escape sequences.\n@echo off\nrem = r\"\"\"\n...\n\"\"\"\n\n", "This is the syntax:\n\"python.exe path\"\"python script path\"pause\n\"C:\\Users\\hp\\AppData\\Local\\Programs\\Python\\Python37\\python.exe\" \"D:\\TS_V1\\TS_V2.py\"\npause\n\nBasically what will be happening the screen will appear for seconds and then go off take care of these 2 things:\n\nWhile saving the file you give extension as bat file but save it as a txt file and not all files and Encoding ANSI\nIf the program still doesn't run save the batch file and the python script in same folder and specify the path of this folder in Environment Variables.\n\n", "If this is a BAT file in a different directory than the current directory, you may see an error like \"python: can't open file 'somescript.py': [Errno 2] No such file or directory\". This can be fixed by specifying an absolute path to the BAT file using %~dp0 (the drive letter and path of that batch file).\n@echo off\npython %~dp0\\somescript.py %*\n\n(This way you can ignore the c:\\ or whatever, because perhaps you may want to move this script)\n", "ECHO OFF\nset SCRIPT_DRIVE = %1\nset SCRIPT_DIRECTORY = %2\n%SCRIPT_DRIVE%\ncd %SCRIPT_DRIVE%%SCRIPT_DIRECTORY%\npython yourscript.py`\n\n", "i did this and works:\ni have my project in D: and my batch file is in the desktop, if u have it in the same drive just ignore the first line and change de D directory in the second line\nin the second line change the folder of the file, put your folder \nin the third line change the name of the file \nD: \ncd D:\\python_proyects\\example_folder\\ \npython example_file.py\n", "Use any text editor and save the following code as runit.bat\n@echo off\ntitle Execute Python [NarendraDwivedi.Org]\n:main\necho.\nset/p filename=File Name :\necho. \n%filename%\ngoto main\n\nNow place this file in the folder where python script is present. Run this file and enter python script's file name to run python program using batch file (cmd)\nReference : Narendra Dwivedi - How To Run Python Using Batch File\n", "Create an empty file and name it \"run.bat\"\nIn my case i use \"py\" because it's more convenient, try:\nC:\ncd C:\\Users\\user\\Downloads\\python_script_path\npy your_script.py\n\n", "@echo off\ncall C:\\Users\\[user]\\Anaconda3\\condabin\\conda activate base\n\"C:\\Users\\[user]\\Anaconda3\\python.exe\" \"C:\\folder\\[script].py\"\n\n" ]

[ 71, 60, 19, 14, 6, 5, 3, 2, 2, 1, 0, 0, 0, 0, 0 ]

[ "start xxx.py\nYou can use this for some other file types.\n" ]

[ -1 ]

[ "batch_file", "python" ]

[ "The history data is loaded from external URL via JavaScript. You can use requests module to simulate this call:\nimport requests\nimport pandas as pd\n\n\napi_url = \"https://explorer-api.mainnet-beta.solana.com/\"\n\npayload = {\n \"id\": \"xxx\",\n \"jsonrpc\": \"2.0\",\n \"method\": \"getConfirmedSignaturesForAddress2\",\n \"params\": [\"9QgXqrgdbVU8KcpfskqJpAXKzbaYQJecgMAruSWoXDkM\", {\"limit\": 25}],\n}\n\ndata = requests.post(api_url, json=payload).json()\n\ndf = pd.DataFrame(data[\"result\"])\ndf[\"blockTime\"] = pd.to_datetime(df[\"blockTime\"], unit=\"s\")\n\nprint(df.to_markdown(index=False))\n\nPrints:\n\n\n\n\nblockTime\nconfirmationStatus\nerr\nmemo\nsignature\nslot\n\n\n\n\n2022-11-30 12:36:01\nfinalized\n\n\n4Pb3aMuiNGx1Xavj5GyeZHKAWvDp1BJAYXS3s1JjTx7uRr2qGNLGMkgPvicvMJGvKdt7gC5hTcDA822qu4th1MvR\n164077374\n\n\n2022-11-23 13:05:04\nfinalized\n\n\n5vWbZozXwTmNeqCwLDu8pgLKhf8gSbyAVuHamzDMGh3amYjtYZ5V647wkDigYQ4aRnSKNGNGzYYPtksHgYBeuF1b\n162708675\n\n\n2022-10-17 17:37:48\nfinalized\n\n\n2wYEAAZPBPu1ropcTV4k78BB6FbemhAQmnSRvRcuLHVz9j3Kh5tufMokJ5j3JsCsL8vRArUa3HtYP67bgNGJdLGk\n155859139\n\n\n2022-09-18 09:34:45\nfinalized\n\n[209] Please consider to delegate with ManyStake in order to decentralize the solana network. OG delegator will be rewarded soon with extra MEV rewards. Our vote account AuBB9st3RqhHBkzZgBSm6SVnHZNJQSHeBWCSkik4bzdA\n48r1hcNHn4vw9kzd7fJnj4HWrLqzSsDfn6Ap6Dpbb2qwj6WL1xbYmah1CifVVBhwDZDqg6fsmUHqHW9t3m454pX8\n151207313\n\n\n2022-06-19 18:35:55\nfinalized\n\n\n5v7T4aYM6dN9SK3V7Y6VS59aBcWabyNdyxLLJuKecZrTt2VqT1kW6MHobYxjGv4DHb8SYewB3Y1ZNhWML2pCFCGL\n138178511\n\n\n2022-06-19 18:33:24\nfinalized\n\n\n2ULTeYi3tqZi9xDtnPnNPYjYRGt8a8EcoAxZG2uGNkHvrNWiF3evbcSPmxN3LvGU9g1j8n9KYVqRmtzLTwhWfhr7\n138178280\n\n\n2022-06-19 18:19:04\nfinalized\n\n\n4YnvsFtHPGzgijPB7KPEsBqj4o1ZigimhiPFuoyrCv8NLivVipNFp6RTmsNhkoeCYeDhWcK3ovkCqMmjYfQj711V\n138176965\n\n\n2022-06-19 18:15:55\nfinalized\n\n\nEVTjZVQYghRK4bdMwCh6PnazRXZgSjCWvgu6XMqAiaEverkTNtkpfw2E7sRXPe973n1LnzmRnepNkCggLxZZS9S\n138176698\n\n\n2022-06-19 17:55:54\nfinalized\n\n\n2P9nSaGMfs2Daks9kGEnUp3R9UNpLZMFTudAjaVgDHJcwwxp1vDgfsn582bZb7HoDJTCrKCkBd3srcuUfXYAH1Tr\n138174836\n\n\n2022-06-19 17:41:14\nfinalized\n\n\n3Y7bmsHo3fTD3fqryPy37u6MMDGs9KGk7MLFbxw8sDx15j2sDPtRd4w8QjWWCoecLQQZHMT37Evt4D2oX1wd2sL\n138173447\n\n\n2022-06-19 17:40:46\nfinalized\n\n\n2ftBbaqKrMintETRxhH17HvDjEgX5W437BKZv8o4umeNXcs2B9WQJEm9kJEh2LfNeQMCgMkjDZXz8DziLMKvtHk3\n138173398\n\n\n2022-06-19 17:38:41\nfinalized\n\n\n7Bdy3Ah78NmRmpbFsmKtFPiqrQGDpXZ2BBr83crivSso7wwbfVzEv4TrdpurYXWJV6X9j9hKfAvLWB3769GobJA\n138173207\n\n\n2022-06-19 17:35:41\nfinalized\n\n\n61iQ9BSQ18X54nT2ZzRCUtoUyXpTKS363QZFnXBgERAtUzLscpmj8oxTfrgxn7zwemNEKf1WB2yLhn3JgfmG96MY\n138172922\n\n\n2022-06-19 17:32:16\nfinalized\n\n\n5ueuPr4qZwHxhDSWRQHZkrNpTSDa6fR9LiGyokFJ1que6rpgRaSt9AX2S7L89KLztWKmehHKwxDpQywbvXbk6WQB\n138172617\n\n\n2022-06-19 17:26:27\nfinalized\n\n\nEHRyD9ibJkt6cGgHbKbJqTuBj7bCzxeWGLBwuC8TgucvfKgv3ejqCRkG6sqUDVxQvsRWdGkQpagojRo2vajfDBa\n138172080\n\n\n2022-06-19 17:25:59\nfinalized\n\n\n3XxSXVQCKpZH48upHzYSj4nJyhWw6gpPiA6vPW8JyWwfniCh2Z29qokxQi2mtjyUiEWqthix6LKNBRpJhAQb2u8v\n138172029\n\n\n2022-06-19 17:25:46\nfinalized\n\n\n3DjUK7ENHYQLWGQ1Rw3bMqCjuzt4M6H1aPxWMVAU37vr2r64F2wXFgFsyeXqSiQ7JA1biQY691iwoEKDj5iztzg6\n138172003\n\n\n2022-06-19 17:25:14\nfinalized\n\n\ngQwiKLCuvvGDoEoniU6QR98PHTAMDyz7DVbxaYXRYWsPaC7Ekbyt9PDEpDNo7kueSddiN6V1jrwYoN3Rfir3x8w\n138171956\n\n\n2022-06-19 17:22:02\nfinalized\n\n\n52dFWxTaKL2h1MekafD12F3QWmnrDbsTxwEAMbZyiDhVNy7miVbwxX5d8NU7WioQpotG4uJ4txoFRRe2irRBqBfh\n138171653\n\n\n2022-06-19 17:21:32\nfinalized\n\n\n5yGwSWUZiaY5xAeSy5BFekJoSF3YiPiYh6GC5hyaPCDDQ3WEXWr9EzqWCf1g47ViUHekEMrsRDWuS8XN3k52hFVf\n138171595\n\n\n2022-06-19 17:20:58\nfinalized\n\n\n7SkpAQ1JNQYTUvR545pyWBQeHGEpisbgYxsUr1B2fnZm95CmGXUF4Y2UMVQbL1gbtd1mKaTTVCY3RBBpWcchaLD\n138171541\n\n\n2022-06-19 17:20:38\nfinalized\n\n\nrsYUWj8irRFk15VxkFnjcJChDGyCmpe4MrCgrAyqt9ZoXoUcQsz7wiUKWYaU9qbds7V69jDxxhxbSzSJneJsfzA\n138171506\n\n\n2022-06-19 17:20:12\nfinalized\n\n\n4hjqfREeb22rSSuwHAZ5U3g2qZXVi4ejahZxBN95ecjfV3we1ELWP1ezJsCCaSnj9zygzzhWJrzZRpCHB3Nfcnw1\n138171464\n\n\n2022-06-19 17:09:47\nfinalized\n\n\n2TXf2fwsYfCCTrkh4zfZSGhbEuZcLrKPwn8Ai4ZTpntKFS6FDU9YahRuT5cEYqYc1RJ5fMMkUtYtcbNv8ogAzVnM\n138170550\n\n\n2022-06-19 17:09:31\nfinalized\n\n\nwDMRYiqHPNtYy6WJuA1kyaWjLr7RsnemnasEYufpaxdCmroNW4dBFLPLCQnYDnyZha9uZUSgbhC91zQT3E55bpP\n138170527\n\n\n\n" ]

[ 2 ]

[]

[]

[ "get", "python", "python_requests", "solana", "url" ]

[ "Things you need to do:\n\nDefine a variable for storing total outside the loop otherwise the variable will be overridden everytime\nGet the price from the menu dictionary and add it to the total\n\nIf both changes are done, the code should look something like this\ntotal = 0\nwhile True:\n try:\n x = input(\"Item: \")\n if x in menu:\n total = total + menu[x]\n print(f\"Total: ${total}\")\n # If u want to ctrl+d out and get ur price\n except (EOFError):\n print(f\"Total: ${menu[x]}\")\n break\n # so code can handle wrong inputs\n except (KeyError):\n pass\n\n", "Define a total outside and increment that value.\nmenu = {\n \"Baja Taco\": 4.00,\n \"Burrito\": 7.50,\n \"Bowl\": 8.50,\n \"Nachos\": 11.00,\n \"Quesadilla\": 8.50,\n \"Super Burrito\": 8.50,\n \"Super Quesadilla\": 9.50,\n \"Taco\": 3.00,\n \"Tortilla Salad\": 8.00\n}\n\ntotal = 0.0\nwhile True:\n try:\n x = input(\"Item: \")\n if x in menu:\n total += menu[x] # Notice that you're just adding the menu item price here\n print(f\"Total: ${total}\")\n...\n\n" ]

[ 1, 0 ]

[]

[]

[ "python" ]

[ "You can make a cdef/cfunc function unable to raise an exception using @cython.exceptval(check=False) (or cdef float func() noexcept in the non-pure-Python syntax). See the documentation for full details about exceptions. If you do this it won't be checked.\nCython 3 has changed the default behaviour from \"cdef functions swallow exceptions\" to \"cdef functions can raise exceptions\", but it's possible to pick either.\n\nThe difference you see between staticmethod and a module-level function is probably a minor bug - there's no reason for them to behave differently.\nHowever, I'd actually expect the extra check to be an optimization in the non-error case: PyErr_Occurred() is expected to be expensive, so using -1 as a sentinal value to indicate that an error might have happened avoids it most of the time. I haven't measured it in your exact case though - it's probably a balance between skipping expensive checks vs greater code size.\nThe annotated HTML highlighting is pretty crude so is almost working on the basis that \"more text == slower\" which isn't quite right here. So don't take it too seriously.\n" ]

[ 1 ]

[]

[]

[ "arguments", "cython", "performance", "python" ]

[ "Your result is a list of Tuples. Try replacing the string 'CPC - Current - DWPI.split()' with the index (as an integer) of the item you want.\n" ]

[ 1 ]

[]

[]

[ "k_means", "python" ]

[ "You could just do\ndataframe.apply(lambda row: row[\"c2\"] if pd.notna(row[\"c2\"]) else row[\"c1\"], axis=1)\n\nOr better\ndataframe['c2'] = dataframe['c2'].fillna(dataframe['c1'])\n\n" ]

[ 1 ]

[]

[]

[ "dataframe", "lambda", "pandas", "python", "python_3.x" ]

[ "Not perfect but here is another possible method:\nimport cv2\nfrom matplotlib import pyplot as plt\nimport matplotlib\nimport numpy as np\n\nmatplotlib.use('TkAgg')\n\n\ndef remove_noise(binary_image, max_noise_size=20):\n labels_count, labeled_image, stats, centroids = cv2.connectedComponentsWithStats(\n binary_image, 8, cv2.CV_32S)\n new_image = np.zeros_like(binary_image)\n for i in range(1, labels_count):\n if stats[i, -1] <= max_noise_size:\n continue\n new_image[labeled_image == i] = 255\n return new_image\n\n\ndef main():\n original_image = cv2.imread('BWQyx.png')\n\n image = np.array(original_image)\n for y in range(image.shape[0]):\n for x in range(image.shape[1]):\n # remove grey background\n if 150 <= image[y, x, 0] <= 180 and \\\n 150 <= image[y, x, 1] <= 180 and \\\n 150 <= image[y, x, 2] <= 180:\n image[y, x, 0] = 0\n image[y, x, 1] = 0\n image[y, x, 2] = 0\n\n # remove green dashes\n if image[y, x, 0] == 0 and \\\n image[y, x, 1] == 169 and \\\n image[y, x, 2] == 0:\n image[y, x, 0] = 0\n image[y, x, 1] = 0\n image[y, x, 2] = 0\n\n image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n image[image < 128] = 0\n image[image > 128] = 255\n\n image = cv2.dilate(image, np.ones((3, 3), np.uint8), iterations=2)\n image = cv2.erode(image, np.ones((3, 3), np.uint8), iterations=2)\n\n contours, _ = cv2.findContours(\n image, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n cv2.drawContours(image, contours, -1, (0,), 2)\n\n image = remove_noise(image)\n\n contours, _ = cv2.findContours(\n image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n\n for contour in contours:\n min_area_rect = cv2.minAreaRect(contour)\n width, height = min_area_rect[1]\n if width * height > 20000 or width * height < 400:\n continue\n box = np.int0(cv2.boxPoints(min_area_rect))\n cv2.drawContours(original_image, [box], 0, (0, 0, 255), 2)\n\n plt.imshow(original_image)\n plt.show()\n\n\nif __name__ == '__main__':\n main()\n\n\nThe main idea is to remove all the grid lines by drawing over their contours. You can tune it and achieve better results. However, I feel that it is really difficult to get everything 100% right. You will need more heuristics to remove unwanted rectangles.\n" ]

[ 0 ]

[]

[]

[ "computer_vision", "image_processing", "opencv", "python", "python_3.x" ]

[ "In layman's terms, you wish to find k classification areas also known as clusters. In this case, I recommend you first read about clustering. After you acquire enough knowledge, you can advance on this related question, which generalizes this classification for a custom distance function.\n" ]

[ 0 ]

[]

[]

[ "arrays", "grouping", "manhattan", "multidimensional_array", "python" ]

[ "You can use df.values to return a numpy representation of the DataFrame then use numpy.isnan and keep other values.\nimport numpy as np\narr = df.values\nres = arr[~np.isnan(arr)]\nprint(res)\n# [1. 2. 8. 8. 25. 6.]\n\n" ]

[ 1 ]

[]

[]

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

[ "So saving soup would be... tough, and out of my experience (read more about the pickleing process if interested). You can save the page as follows:\npage = requests.get(url)\nwith open('path/to/saving.html', 'wb+') as f:\n f.write(page.content)\n\nThen later, when you want to do analysis on it:\nwith open('path/to/saving.html', 'rb') as f:\n soup = BeautifulSoup(f.read(), 'lxml')\n\nSomething like that, anyway.\n", "The following code iterates over url_list and saves all the responses into the list all_pages, which is stored to the response.pickle file.\nimport pickle\nimport requests\nfrom bs4 import BeautifulSoup\n\nall_pages = []\nfor url in url_list:\n all_pages.append(requests.get(url))\n\nwith open(\"responses.pickle\", \"wb\") as f:\n pickle.dump(all_pages, f)\n\nThen later on, you can load this data, \"soupify\" each response and do whatever you need with it.\nwith open(\"responses.pickle\", \"rb\") as f:\n all_pages = pickle.load(f)\n\nfor page in all_pages:\n soup = BeautifulSoup(page.text, 'lxml')\n # do stuff\n\n", "Working with our request:\nurl = 'https://scholar.google.com/citations?user=XpmZBggAAAAJ' \npage = requests.get(url)\nsoup = BeautifulSoup(page.text, 'lxml')\n\nyou can use this also:\nf=open(\"path/page.html\",\"w\")\nf.write(page.prettify())\nf.close\n\n" ]

[ 4, 2, 0 ]

[]

[]

[ "file", "html", "python", "save" ]

[ "That is not a valid file path. You must either use a full path\nopen(r\"C:\\description_files\\program_description.txt\",\"r\")\n\nOr a relative path\nopen(\"program_description.txt\",\"r\")\n\n", "Add 'r' in starting of path:\npath = r\"D:\\Folder\\file.txt\"\n\nThat works for me.\n", "I also ran into this fault when I used open(file_path). My reason for this fault was that my file_path had a special character like \"?\" or \"<\".\n", "I received the same error when trying to print an absolutely enormous dictionary. When I attempted to print just the keys of the dictionary, all was well!\n", "In my case, I was using an invalid string prefix.\nWrong:\npath = f\"D:\\Folder\\file.txt\"\n\nRight:\npath = r\"D:\\Folder\\file.txt\"\n\n", "I had the same problem\nIt happens because files can't contain special characters like \":\", \"?\", \">\" and etc.\nYou should replace these files by using replace() function:\nfilename = filename.replace(\"special character to replace\", \"-\")\n\n", "In my case the error was due to lack of permissions to the folder path. I entered and saved the credentials and the issue was solved.\n", "you should add one more \"/\" in the last \"/\" of path, that is:\nopen('C:\\Python34\\book.csv') to open('C:\\Python34\\\\book.csv'). For example:\nimport csv\nwith open('C:\\Python34\\\\book.csv', newline='') as csvfile:\n spamreader = csv.reader(csvfile, delimiter='', quotechar='|')\n for row in spamreader:\n print(row)\n\n", "In Windows-Pycharm: If File Location|Path contains any string like \\t then need to escape that with additional \\ like \\\\t\n", "Just replace with \"/\" for file path :\n open(\"description_files/program_description.txt\",\"r\")\n\n", "just use single quotation marks only and use 'r' raw string upfront and a single '/'\nfor eg\nf = open(r'C:/Desktop/file.txt','r')\nprint(f.read())\n\n", "I had special characters like '' in my strings, for example for one location I had a file Varzea*, then when I tried to save ('Varzea.csv') with f-string Windows complained. I just \"sanitized\" the string and all got back to normal.\nThe best way in my case was to let the strings with just letters, without special characters!\n", "for folder, subs, files in os.walk(unicode(docs_dir, 'utf-8')):\n for filename in files:\n if not filename.startswith('.'):\n file_path = os.path.join(folder, filename)\n\n", "In my case,the problem exists beacause I have not set permission for drive \"C:\\\" and when I change my path to other drive like \"F:\\\" my problem resolved.\n", "import pandas as pd\ndf = pd.read_excel ('C:/Users/yourlogin/new folder/file.xlsx')\nprint (df)\n\n", "I got this error because old server instance was running and using log file, hence new instance was not able to write to log file. Post deleting log file this issue got resolved.\n", "When I copy the path by right clicking the file---> properties-->security, it shows the error. The working method for this is to copy path and filename separately.\n", "For me this issue was caused by trying to write a datetime to file.\nNote: this doesn't work:\nmyFile = open(str(datetime.now()),\"a\")\nThe datetime.now() object contains the colon ''':''' character\nTo fix this, use a filename which avoid restricted special characters. Note this resource on detecting and replacing invalid characters:\nhttps://stackoverflow.com/a/13593932/9053474\nFor completeness, replace unwanted characters with the following:\nimport re\nre.sub(r'[^\\w_. -]', '_', filename)\nNote these are Windows restricted characters and invalid characters differ by platform.\n" ]

[ 48, 12, 9, 7, 4, 3, 3, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0 ]

[]

[]

[ "python" ]

[ "You can use doublequote=False in csv.writer:\nimport csv\n\nwith open(\"input.csv\", \"r\") as f_in, open(\"output.csv\", \"w\") as f_out:\n reader = csv.reader(f_in, delimiter=\",\", quotechar='\"', escapechar=\"\\\\\")\n writer = csv.writer(\n f_out,\n delimiter=\",\",\n quotechar='\"',\n escapechar=\"\\\\\",\n doublequote=False,\n )\n\n writer.writerow(next(reader))\n for row in reader:\n row[3] = row[3][:500]\n writer.writerow(row)\n\nThe output.csv becomes:\nc1,c2,c3,c4,c5\n17939,2507974,11,DVD version has 1 hour of extras of 5 bonus matches including: - Stacy Keibler vs Torrie Wilson in a bikini contest. - A tour of Trish Stratus' place. - Behind the scenes look at the WWE women division.,NULL\n16641,2425413,11,\"The Australian TV version had a scene included at the end where a cop car was driving in an alley way, narrowly missing someone walking. This scene was also used in the 1980 film, \\\"Alligator\\\".\",NULL\n\n" ]

[ 0 ]

[]

[]

[ "backslash", "csv", "csvreader", "python" ]

[ "I faced a similar issue, due a recent change in pip. I solved it by adding the following to the installation command:\n--use-deprecated=backtrack-on-build-failures\n\nE.g. instead of pip install numpy I now ran:\npip install numpy --use-deprecated=backtrack-on-build-failures\n\n", "I had the same problem with metadata-generation-failed. This GitHub issue comment helped me (Ubuntu 18.04):\nsudo apt-get install python-dev \nsudo apt-get install build-essential\npython -m pip install -U pip or python3 -m pip install -U pip \npip3 install --upgrade setuptools\n\n", "I had this error while trying to install dotenv. With this command:\npip install dotenv\n\nFor anyone facing this error with dotenv. The right command actually is:\npip install python-dotenv\n\n", "pip install numpy --use-deprecated=legacy-resolver can actually help, but there will be a red warning: pip's legacy dependency resolver does not consider dependency conflicts when selecting packages. anyway it solve my problem!\n" ]

[ 21, 3, 1, 0 ]

[]

[]

[ "python" ]

[ "You shouldn't use list as a variable, it is reserved in python.\nNot pretty, but you can use this\nsorted(mylist, key=lambda x: (-len(str(x).split('^')), str(x).split('^')[0]))\n\nThis is sorting according to two criteria, first if there is an exponent, and then by the value of the base.\n" ]

[ 1 ]

[]

[]

[ "exponent", "list", "python" ]

[ "Not too much of an improvement on your attempt, but you could write the resampling as\nmonths = hours.resample('D', offset='06:00:00').sum().resample('MS').sum()\n\nchanging the index labels still requires the hack you've been doing, as in adding the time delta manually and setting freq to MS\nnote that you can pass a string representation of the time delta to offset.\nThe reason two resampling operations are needed is because when the resampling frequency is greater than 'D', the offset is ignored. Once your resample at the daily level is performed with the offset, the result can be further resampled without specifying the offset.\nI believe this is buggy behaviour, and I agree with you that hours.resample('MS', offset='06:00:00').sum() should produce the expected result.\nEssentially, there are two issues:\n\nthe binning is incorrect when there is an offset applied & the frequency is greater than 'D'. The offset is ignored.\nthe offset is not reflected in the final output, the output truncates to the start or end of the period. I'm not sure if the behaviour you're expecting can be generalized for all users.\n\nThat there is a related bug issue impacting resampling with offsets. I have not determined yet whether that and the issue you face have the same root cause. Its the same root cause.\n" ]

[ 1 ]

[ "To aggregate a pandas.Series with an hourly DatetimeIndex to monthly values while considering the offset to midnight, you can use the offset parameter in the resample method to specify the offset from midnight to start the aggregation from. For example, if you want to start the aggregation from 6:00 AM, you can use an offset of pd.Timedelta('06:00:00').\nHere is an example of how you could use the offset parameter to aggregate the timeseries to monthly values while considering the offset to midnight:\nimport pandas as pd\n\nhours = pd.Series(1, pd.date_range('2020-02-23 06:00', freq = 'H', periods=1008))\n\n# Aggregate the timeseries to monthly values using the offset parameter\nmonths = hours.resample('MS', offset=pd.Timedelta('06:00:00')).sum()\n\n# Print the result\nprint(months)\n\n\nThis will print the following:\n2020-02-01 06:00:00 168\n2020-03-01 06:00:00 744\n2020-04-01 06:00:00 96\nFreq: MS, dtype: int64\n\n\n" ]

[ -1 ]

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

[ "This link maybe help you to build the model SIR-derived ODE models\nalso here by I have code for you:\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nBeta = 1.00205\nGamma = 0.23000\nN = 1000\n\ndef func_S(t,I,S):\n return - Beta*I*S/N\n\ndef func_I(t,I,S):\n return Beta*I*S/N - Gamma*I\n\ndef func_R(t,I):\n return Gamma*I\n\n\n# physical parameters\nI0 = 1\nR0 = 0\nS0 = N - I0 - R0\nt0 = 0\ntn = 50\n\n\n\n# Numerical Parameters\nndata = 1000\n\n\n\nt = np.linspace(t0,tn,ndata)\nh = t[2] - t[1]\n\nS = np.zeros(ndata)\nI = np.zeros(ndata)\nR = np.zeros(ndata)\n\nS[0] = S0\nI[0] = I0\nR[0] = R0\n\n\nfor i in range(ndata-1):\n k1 = func_S(t[i], I[i], S[i])\n k2 = func_S(t[i]+0.5*h, I[i], S[i]+h+0.5*k1)\n k3 = func_S(t[i]+0.5*h, I[i], S[i]+h+0.5*k2)\n k4 = func_S(t[i]+h, I[i], S[i]+h+k3)\n \n S[i+1] = S[i] + (h/6)*(k1 + 2*k2 + 2*k3 + k4)\n \n kk1 = func_I(t[i], I[i], S[i])\n kk2 = func_I(t[i]+0.5*h, I[i], S[i]+h+0.5*kk1)\n kk3 = func_I(t[i]+0.5*h, I[i], S[i]+h+0.5*kk2)\n kk4 = func_I(t[i]+h, I[i], S[i]+h+kk3)\n \n I[i+1] = I[i] + (h/6)*(kk1 + 2*kk2 + 2*kk3 + kk4)\n \n l1 = func_R(t[i], I[i])\n l2 = func_R(t[i]+0.5*h, I[i])\n l3 = func_R(t[i]+0.5*h, I[i])\n l4 = func_R(t[i]+h, I[i])\n \n R[i+1] = R[i] + (h/6)*(l1 + 2*l2 + 2*l3 + l4)\n \n \nplt.figure(1)\nplt.plot(t,S)\nplt.plot(t,I)\nplt.plot(t,R)\nplt.show()\n\nthe output will be like this:\n\n", "The easiest way to get a value at time 50 is to compute a value at time 50. As you compute data over 100 days, with about 10 data points per day, reflect this in the time array construction\ntime = np.linspace(0,days,10*days+1)\n\nNote that linspace(a,b,N) produces N nodes that have between them a step of size (b-a)/(N-1).\nThen you get the data for day 50 at time index 500 (and the 9 following).\nFor this slow-moving system and this relatively small time step, you will get reasonable accuracy with the implemented order-1 method, but will get better accuracy with a higher-order method like RK4.\nYou need to apply associated updates to all components everywhere. This requires to interleave the RK4 steps that you have, as for instance the corrected step\n S_k2 = derivada_S(time[i] + (h/2), I[i] + (h/2)*I_k1, S[i] + (h/2)*S_k1)\n\nrequires that the value I_k1 is previously computed. Note also that h should be a factor to S_k1, it should not be added.\nIn total you should get\nfor i in range(data-1):\n S_k1 = derivada_S(time[i], I[i], S[i])\n I_k1 = derivada_I(time[i], I[i], S[i])\n R_k1 = derivada_R(time[i], I[i])\n\n S_k2 = derivada_S(time[i] + (1/2)*h, I[i] + (h/2)*I_k1, S[i] + (h/2)*S_k1)\n I_k2 = derivada_I(time[i] + (1/2)*h, I[i] + (h/2)*I_k1, S[i] + (h/2)*S_k1)\n R_k2 = derivada_R(time[i] + (1/2)*h, I[i] + (h/2)*I_k1)\n\n S_k3 = derivada_S(time[i] + (h/2), I[i] + (h/2)*I_k2, S[i] + (h/2)*S_k2)\n I_k3 = derivada_I(time[i] + (h/2), I[i] + (h/2)*I_k2, S[i] + (h/2)*S_k2)\n R_k3 = derivada_R(time[i] + (h/2), I[i] + (h/2)*I_k2)\n\n S_k4 = derivada_S(time[i] + h, I[i] + I_k3, S[i] + S_k3)\n I_k4 = derivada_I(time[i] + h, I[i] + I_k3, S[i] + S_k3)\n R_k4 = derivada_R(time[i] + h, I[i] + I_k3)\n \n S[i+1] = S[i] + (h/6)*(S_k1 + 2*S_k2 + 2*S_k3 + S_k4)\n I[i+1] = I[i] + (h/6)*(I_k1 + 2*I_k2 + 2*I_k3 + I_k4)\n R[i+1] = R[i] + (h/6)*(R_k1 + 2*R_k2 + 2*R_k3 + R_k4)\n\nNote that h is a factor to I_k1, S_k1 etc. You have a sum there.\nReplacing just this piece of code gives the plot\n\nBut there is another problem before that. You defined the time step as 0.05 so that t=50 is reached at the last place. As the system is autonomous, the contents of the time array makes no difference, but the labeling of the x axis has to be divided by 2. The values that you want are in fact the last values computed with data = 10*time_k+1.\nS[-1]=0.10483, I[-1]=8.11098e-05, R[-1]=0.89509\n\nFor the previous discussion to remain valid, you could also set h=t[1]-t[0], so that t=50 is reached in the middle at i=500.\n", "You can use the integrator available at scipy.integrate.solve_ivp, and with it use the fourth-order Runge-Kutta method (DOP853, RK23, RK45 and Radau).\n##########################################\n# AUTHOR : CARLOS DUARDO DA SILVA LIMA #\n# DATE : 12/01/2022 #\n# LANGUAGE: python #\n# IDE : GOOGLE COLAB #\n# PROBLEM : MODEL SIR #\n##########################################\n\nimport numpy as np\nfrom scipy.integrate import odeint, solve_ivp, RK45\nimport matplotlib.pyplot as plt\n\nt_i = 0.0 # START TIME\nt_f = 50.0 # FINAL TIME\nN = 1000\n\n#t = np.linspace(t_i,t_f,N)\nt_span = np.array([t_i,t_f])\n\n# INITIAL CONDITIONS OF THE SOR MODEL\nS0 = 0.99\nI0 = 0.01\nR0 = 0.0\nr0 = np.array([S0,I0,R0])\n\n# ORDINARY DIFFERENTIAL EQUATIONS OF THE SIR MODEL\ndef SIR(t,y,b,k):\n s,i,r = y\n ode1 = -b*s*i\n ode2 = b*s*i-k*i\n ode3 = k*i\n return np.array([ode1,ode2,ode3])\n\n# INTEGRATION OF ORDINARY DIFFERENTIAL EQUATIONS (FOURTH ORDER RUNGE-KUTTA, RADAU)\n#sol_solve_ivp = solve_ivp(SIR,t_span,y0 = r0,method='Radau', rtol=1E-09, atol=1e-09, args = (0.8,0.3125))\nsol_solve_ivp = solve_ivp(SIR,t_span,y0 = r0,method='RK45', rtol=1E-09, atol=1e-09, args = (0.8,0.3125))\n\n# T, S, I, R FUNCTIONS\nt_= sol_solve_ivp.t\ns = sol_solve_ivp.y[0, :]\ni = sol_solve_ivp.y[1, :]\nr = sol_solve_ivp.y[2, :]\n\n# GRAPHIC\nplt.figure(1)\nplt.style.use('dark_background')\nplt.figure(figsize = (8,8))\nplt.plot(t_,s,'c-',t_,i,'g-',t_,r,'y-',lw=1.5)\n#plt.title(r'$\\frac{dS(t)}{dt} = -bs(t)i(t)$, $\\frac{dI(t)}{dt} = bs(t)i(t)-ki(t)$ and $\\frac{dR(t)}{dt} = ki(t)$')\nplt.title(r'SIR Model', color = 'm')\nplt.xlabel(r'$t(t)$', color = 'm')\nplt.ylabel(r'$S(t)$, $I(t)$ and $R(t)$', color = 'm')\nplt.legend(['S', 'I', 'R'], shadow=True)\nplt.grid(lw = 0.95,color = 'white',linestyle = '--')\nplt.show()\n\n''' SEARCH WEBSITES\nhttps://en.wikipedia.org/wiki/Compartmental_models_in_epidemiology\nhttps://www.maa.org/press/periodicals/loci/joma/the-sir-model-for-spread-of-disease-the-differential-equation-model\n'''\n\nOutput Chart\n" ]

[ 2, 0, 0 ]

[]

[]

[ "model", "python", "runge_kutta" ]

[ "object dtype is a catch-all dtype that basically means not int, float, bool, datetime, or timedelta. So it is storing them as a list. convert_objects tries to convert a column to one of those dtypes.\nYou want\nIn [63]: df\nOut[63]: \n a b c\n0 1 [1, 2, 3] foo\n1 1 [2, 5] bar\n2 2 [5, 6] baz\n\n\nIn [64]: df.groupby('a').agg({'b': 'sum', 'c': lambda x: ' '.join(x)})\nOut[64]: \n c b\na \n1 foo bar [1, 2, 3, 2, 5]\n2 baz [5, 6]\n\nThis groups the data frame by the values in column a. Read more about groupby.\nThis is doing a regular list sum (concatenation) just like [1, 2, 3] + [2, 5] with the result [1, 2, 3, 2, 5]\n", "df.groupby('column_a').agg(sum)\n\nThis works because of operator overloading sum concatenates the lists together. The index of the resulting df will be the values from column_a:\n", "The approach proposed above using df.groupby('column_a').agg(sum) definetly works. However, you have to make sure that your list only contains integers, otherwise the output will not be the same.\nIf you want to convert all of the lists items into integers, you can use:\ndf['column_a'] = df['column_a'].apply(lambda x: list(map(int, x)))\n\n", "The accepted answer suggests to use groupby.sum, which is working fine with small number of lists, however using sum to concatenate lists is quadratic.\nFor a larger number of lists, a much faster option would be to use itertools.chain or a list comprehension:\ndf = pd.DataFrame({'column_a': ['1', '1', '2'],\n 'column_b': [['1', '2', '3'], ['2', '5'], ['5', '6']]})\n\nitertools.chain:\nfrom itertools import chain\nout = (df.groupby('column_a', as_index=False)['column_b']\n .agg(lambda x: list(chain.from_iterable(x)))\n )\n\nlist comprehension:\nout = (df.groupby('column_a', as_index=False, sort=False)['column_b']\n .agg(lambda x: [e for l in x for e in l])\n )\n\noutput:\n column_a column_b\n0 1 [1, 2, 3, 2, 5]\n1 2 [5, 6]\n\nComparison of speed\nUsing n repeats of the example to show the impact of the number of lists to merge:\ntest_df = pd.concat([df]*n, ignore_index=True)\n\n\nNB. also comparing the numpy approach (agg(lambda x: np.concatenate(x.to_numpy()).tolist())).\n", "Use numpy and simple \"for\" or \"map\":\nimport numpy as np\nu_clm = np.unique(df.column_a.values)\nall_lists = []\n\nfor clm in u_clm:\n df_process = df.query('column_a == @clm')\n list_ = np.concatenate(df.column_b.values)\n all_lists.append((clm, list_.tolist()))\n\ndf_sum_lists = pd.DataFrame(all_lists)\nIt's faster in 350 times than a simple \"groupby-agg-sum\" approach for huge datasets.\n" ]

[ 83, 23, 3, 1, 0 ]

[ "Thanks, helped me\nmerge.fillna(\"\", inplace = True) new_merge = merge.groupby(['id']).agg({ 'q1':lambda x: ','.join(x), 'q2':lambda x: ','.join(x),'q2_bookcode':lambda x: ','.join(x), 'q1_bookcode':lambda x: ','.join(x)}) \n" ]

[ -1 ]

[ "pandas", "python" ]

[ "there's a problem with multiprocessing and jupyterlab, so you should use pathos instead.\nimport multiprocessing as mp\nimport numpy as np\nimport scipy.constants as constants\nfrom concurrent.futures import ProcessPoolExecutor\nimport pathos.multiprocessing as mpathos\n\nNmin = 0\nNmax = 20\nperiods = np.linspace(Nmin, Nmax, 2*Nmax +1) # 0.5 steps\n\nresults = dict()\n\ndef identity(a):\n return a\n\nwith mp.Manager() as manager:\n sharedresults = manager.dict()\n\n with mpathos.Pool() as pool:\n print(\"pools are active\")\n for result in pool.imap(identity, periods): \n #sharedresults[per] = res\n print(result)\n\norderedResult = []\nfor k,v in sorted(results.items()):\n oderedResult.append(v)\n\n" ]

[ 1 ]

[]

[]

[ "jupyter_lab", "multiprocessing", "python" ]

[ "You can implement my-tables-out component id as the input to the next callback function and 'loop' for each table (since it is in a result list).\nIn your current implementation, it does not make sense to have table-1, table-2, table-3, etc. changing the data component because it is not possible in Dash to have multiple inputs changing the same output component.\n" ]

[ 0 ]

[]

[]

[ "plotly_dash", "python" ]

[ "There are a few issues with the code you posted.\nFirst, you are trying to access a global variable called myDict from inside the makeDict function. However, you also define a local variable with the same name inside the function, which shadows the global variable. As a result, any modifications made to the local myDict inside the function do not affect the global myDict.\nOne way to fix this would be to remove the local myDict variable and just use the global myDict variable inside the makeDict function. However, using global variables in this way can make your code difficult to understand and maintain. A better approach would be to pass the dictionary as an argument to the makeDict function, and return the updated dictionary from the function.\nHere is how you could modify the code to fix these issues:\nmyDict = {}\n\ndef addKeyValuePair(myDict, listItem):\n try: \n key = listItem.split(': ')[0].replace('\\\\','')\n value = listItem.split(': ')[1].replace('\\\\r\\\\n','').replace('\\\\','')\n myDict.update({key:value})\n except:\n pass \n\ndef makeDict(dataList):\n myDict = {}\n for listItem in dataList:\n addKeyValuePair(myDict, listItem)\n\n return myDict\n\nTo use this updated makeDict function, you would call it like this:\nfrom Toolkit import makeDict\n\nfinalDict = makeDict(dataList)\n\nI hope this helps!\n" ]

[ 1 ]

[]

[]

[ "dictionary", "global_variables", "python" ]

[ "Probably the only way to get acceptable performance (with pygame) is to use pygame.mask.Mask and convolve(). Create a mask size of the screen:\nmask = pygame.mask.Mask(screen.get_size())\n\nCreate a convolution mask with the following pattern:\n[False, True, False]\n[True, True, True ]\n[False, True, False]\n\nconvolution_mask = pygame.mask.Mask((3, 3))\nconvolution_mask.set_at(p) for p in [(0, 1), (1, 1), (2, 1), (1, 0), (1, 2)]]\n\nSet a bit in the mask on mouse click:\nif event.type == pygame.MOUSEBUTTONDOWN:\n mask.set_at(event.pos)\n\nCreate a convolution with the convolution mask in each frame:\nmask = mask.convolve(convolution_mask , offset=(-1, -1))\n\nConvert the mask into a surface and blit it on the screen:\nsurface = mask.to_surface(setcolor = (255, 0, 0), unsetcolor = (255, 255, 255))\nscreen.blit(surface, (0, 0))\n\n\nimport pygame\nimport sys\n\npygame.init()\nscreen = pygame.display.set_mode((500, 500))\nclock = pygame.time.Clock()\n\nmask = pygame.mask.Mask(screen.get_size())\nconvolution_mask = pygame.mask.Mask((3, 3))\n[convolution_mask.set_at(p) for p in [(0, 1), (1, 1), (2, 1), (1, 0), (1, 2)]]\n\nrun = True\nwhile run:\n clock.tick(60)\n for event in pygame.event.get():\n if event.type == pygame.QUIT:\n run = False\n if event.type == pygame.MOUSEBUTTONDOWN:\n mask.set_at(event.pos)\n\n mask = mask.convolve(convolution_mask, offset=(-1, -1))\n\n surface = mask.to_surface(setcolor = (255, 0, 0), unsetcolor = (255, 255, 255))\n screen.blit(surface, (0, 0))\n pygame.display.update()\n\npygame.quit()\nsys.exit()\n\n" ]

[ 0 ]

[]

[]

[ "pygame", "python" ]

[ "You could do it like this:\nfrom asyncio import gather, create_task\ntasks = []\nfor i in range(len(data)):\n candlestick = data[i]\n candlesticks = data[0: i + 1]\n tasks.append(create_task(strategy.execute(candlesticks, candlestick.startTime)))\nresults = await gather(*tasks, return_exceptions=False)\n\n", "If you want to use map() specifically, you could do this:\nfrom asyncio import gather, create_task\n\nawait gather(\n *map(\n lambda i: create_task(\n strategy.execute(data[0: i + 1], data[i].startTime)\n ),\n range(len(data))\n)\n\n" ]

[ 0, 0 ]

[]

[]

[ "python" ]

[ "Yoy should provide a minimum reproducible example. But assuming that you have the year in another column, the way to go could be\ndf['TrueEarn'] = np.where((df['YEAR'] >= 1991) & (df['YEAR'] <= 2005),\n df['Earnings'] / 10000, df['Earnings'])\n\nAs @wjandrea says, this can be done directly with pandas, but numpy is faster. Benchmark with a toy dataframe:\ndf = pd.DataFrame(\n {\"YEAR\": np.random.randint(1991, 2020, size=50000), \"Earnings\": np.random.uniform(0, 2e10, size=50000)}\n)\n\n \n%timeit df[\"TrueEarn\"] = np.where((df[\"YEAR\"] >= 1991) & (df[\"YEAR\"] <= 2005), df[\"Earnings\"] / 10000, df[\"Earnings\"])\n\n695 µs ± 3.17 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\nVS with pandas mask\n%timeit df[\"TrueEarn\"] = df[\"Earnings\"].mask(df[\"YEAR\"].between(1991, 2005), df[\"Earnings\"] / 10000)\n\n959 µs ± 4.45 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n" ]

[ 0 ]

[]

[]

[ "pandas", "python" ]

[ "You can group by the neighbourhood and sign type and do a size to have the count of each sign type in each neighbourhood.\nSample code\ndf.groupby([\"neighbourhood\", \"sign_type\"]).size()\n\n" ]

[ 0 ]

[]

[]

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

[ "You still have some debugging work ahead of you.\nTake a look at the columns: team.c\n\nVerify spellings.\nPut each column (like \"hos_name\") on its own line, so it can easily be # commented out.\nSimplify the query. Start with an easy query of just a single column, and build up from there until you encounter breakage.\nRemove both filters, and add them back one-by-one.\n\nTackling it methodically in that way will soon show you the mismatch\nbetween code and table.\nEverything looks good to me.\nBut then, I cannot view e.g. SELECT * FROM dialog_logger output.\nI usually spell it .filter() rather than .where() -- whatever,\nprolly works much the same.\nBTW, print(qry) will show you the rendered SQL query,\nwhich can sometimes shed a bit of light on the situation.\n", "I don't think sqlalchemy 1.3.13 suports that usage. Try this, note the columns are in a list, this changes in 1.4 and beyond:\n# THIS IS FOR sqlalchemy < 1.4 ONLY!!!\nqry = sa.select([team.c.hos_name, team.c.hos_id, team.c.datetime, team.c.patient_cel_number,\n team.c.hospital_cel_number, team.c.message, team.c.direction]).where(\n team.c.datetime > '2022-11-01 00:00:00').where(team.c.datetime < '2022-11-30 00:00:00')\n\nI think your exception is related to the fact that the 3rd argument in the old select() function is expected to be a from_obj and not just another column: OLD select()\nI'm putting this warnings about 1.3/1.4 so people don't come here and try the same queries in 1.4+. I understand if you can't upgrade because of the 3rd party tools.\n" ]

[ 0, 0 ]

[]

[]

[ "jupyter", "python", "sqlalchemy" ]

[ "pd.Series.nlargest\nmySeries.nlargest(1)\n\na 3\ndtype: int64\n\n", "One with boolean indexing (just an alternative) i.e \nmySeries[mySeries.index==mySeries.idxmax()]\n\nor \nmySeries[mySeries == mySeries.max()]\n\nor(Thanks @piRSquared)\nmySeries[[mySeries.idxmax()]]\n\nOutput: \n\na 3\ndtype: int64\n\n" ]

[ 11, 1 ]

[ "You could do:\nfoo.value_counts()[:1].index.tolist()[0]}\n\n" ]

[ -1 ]

[ "pandas", "python" ]

[ "I had similar problems on Windows. I didn't find a solution for Windows itself, but using WSL(2) you can get this working properly.\nLyonk71 whom (co-)made the pandas-dedupe package also made an installation video, see below.\nhttps://www.youtube.com/watch?v=dq183fOB1Xg&t\nHope this helps you out, success!\n", "I had the same problem I solved it by disabling multiprocessing. You can disable multiprocessing by setting n_cores=0 as shown below:\npandas_dedupe.dedupe_dataframe(df, ['first_name', 'last_name'], n_cores=0)\n\nThis should resolve the error.\n" ]

[ 0, 0 ]

[]

[]

[ "duplicates", "pandas", "permissionerror", "python", "windows" ]

[ "You can escape the single quotes around the format specifier like this:\n>>> s = 'select * from table where \"state\" = \\'{}\\''.format(state)\n>>> print(s)\nselect * from table where \"state\" = 'PA'\n\n" ]

[ 0 ]

[]

[]

[ "formatting", "python", "single_quotes", "string" ]

[ "You define the response variable inside the lambda_handler function. But you are referencing it in the global scope, outside of that function, here:\nquery_execution_id = response['QueryExecutionId']\n\nThe variable isn't defined on that scope, thus the error message. It appears that you may simply be missing indentation on all these lines:\nquery_execution_id = response['QueryExecutionId']\n \ntime.sleep(10)\n \nresult = client.get_query_results(QueryExecutionId=query_execution_id)\n \nfor row in results['ResultSet']['Rows']:\n print(row)\n\nIn Python indentation is syntax! If you intend those lines to be part of the lambda_handler function, then they need to have the correct indentation to place them inside the scope of the function, like so:\ndef lambda_handler(event, context):\n # Execution\n response = client.start_query_execution(\n QueryString=query,\n QueryExecutionContext={\n 'Database': DATABASE\n },\n ResultConfiguration={\n 'OutputLocation': output,\n }\n )\n \n query_execution_id = response['QueryExecutionId']\n \n time.sleep(10)\n \n result = client.get_query_results(QueryExecutionId=query_execution_id)\n \n for row in results['ResultSet']['Rows']:\n print(row)\n\n" ]

[ 0 ]

[]

[]

[ "amazon_athena", "aws_lambda", "python" ]

[ "You can use this:\nnumber = 5.999999998\nnew_number = int(number * 1e3) / 1e3\n\n", "Here is a short code.\n\nx = 4/3\n\n# round up to 3 decimal places\nx = round(x, 3)\n\nprint(x)\n\n\n" ]

[ 3, 0 ]

[]

[]

[ "numbers", "python" ]

[ "For your def's you dont need to use a for ... in range(...) loop, rather you can just call upon that value by the value of user_value. I've decided to not include def edit_contact(): in this as it currently doesn't edit anything, all it does is add a new element within contacts with that in mind\ncontacts = {\"Mohamed\": {\"name\": \"Mohamed Sayed\", \"number\": \"017624857447\", \"birthday\": \"24.11.1996\", \"address\": \"Ginnheim 60487\"},\n \"Ahmed\": {\"name\": \"Ahmed Sayed\", \"number\": \"0123456789\", \"birthday\": \"06.06.1995\", \"address\": \"India\"}}\n\ndef add_contact():\n for _ in range(0, 1):\n contact = {}\n name = input(\"Enter the name: \")\n number = input(\"Enter the number: \")\n birthday = input(\"Enter the birthday\")\n address = input(\"Enter the address\")\n contact[\"name\"] = name\n contact[\"number\"] = number\n contact[\"birthday\"] = birthday\n contact[\"address\"] = address\n print(contact)\n contacts[name] = contact\nadd_contact()\nprint(contacts)\n\n\n\ndef del_contact(contacts):\n user_input = input(\"Please enter the name of the contact you want to delete: \")\n contacts = contacts.pop(user_input)\ndel_contact(contacts)\nprint(contacts)\n\n\ndef edit_contact():\n user_input = input(\"please enter the contact you want to edit: \")\n for k, v in contacts:\n if user_input == contacts[\"name\"]:\n contacts.update(user_input)\n\n\ndef list_contact():\n pass\n\ndef show_contact():\n user_input = input(\"please enter the contact you want to show: \")\n print(contacts[user_input])\n #you can use 'contacts[user_input]['name', 'number', 'birthday' or 'address']' to call upon specific elements within the list\n\nshow_contact()\n\nHope this helps.\n" ]

[ 0 ]

[]

[]

[ "dictionary", "for_loop", "list", "loops", "python" ]

[ "You cannot do conditional updates with the EMR DynamoDB connector which Glue uses. It does a complete overwrite of the data. For that you would have to use Boto3 and distribute it using forEachPartition across the Spark executors.\n" ]

[ 0 ]

[]

[]

[ "amazon_dynamodb", "aws_glue", "python" ]

[ "The reason why you are getting an error it is because the function append_trace() is expecting a single trace in the form you've declared them. However, the graph object Figure has the function add_traces() with which you can pass the data parameter as a list with more than one trace.\nTherefore, I suggest two simple solutions:\nSolution 1: Append traces individually\nfrom plotly.graph_objs.scatter import Line\nimport plotly.graph_objs as go\ntrace11 = go.Scatter(x = [0, 1, 2], y = [0, 0, 0], line = Line({'color': 'rgb(0, 0, 128)', 'width': 1}))\ntrace12 = go.Scatter(x = [0, 1, 2], y = [1, 1, 1], line = Line({'color': 'rgb(128, 0, 0)', 'width': 1}))\ntrace21 = go.Scatter(x = [0, 1, 2], y = [0.5, 0.5, 0.5], line = Line({'color': 'rgb(0, 0, 128)', 'width': 1}))\ntrace22 = go.Scatter(x = [0, 1, 2], y = [1.5, 1.5, 1.5], line = Line({'color': 'rgb(128, 0, 0)', 'width': 1}))\n\nfrom plotly.subplots import make_subplots\nfig = make_subplots(rows=1, cols=2)\nfig.append_trace(trace11, row=1, col=1)\nfig.append_trace(trace12, row=1, col=1)\nfig.append_trace(trace21, row=1, col=2)\nfig.append_trace(trace22, row=1, col=2)\nfig.show()\n\nSolution 2: Use the function add_traces(data,rows,cols) instead\nfrom plotly.graph_objs.scatter import Line\nimport plotly.graph_objs as go\ntrace11 = go.Scatter(x = [0, 1, 2], y = [0, 0, 0], line = Line({'color': 'rgb(0, 0, 128)', 'width': 1}))\ntrace12 = go.Scatter(x = [0, 1, 2], y = [1, 1, 1], line = Line({'color': 'rgb(128, 0, 0)', 'width': 1}))\ntrace21 = go.Scatter(x = [0, 1, 2], y = [0.5, 0.5, 0.5], line = Line({'color': 'rgb(0, 0, 128)', 'width': 1}))\ntrace22 = go.Scatter(x = [0, 1, 2], y = [1.5, 1.5, 1.5], line = Line({'color': 'rgb(128, 0, 0)', 'width': 1}))\n\nfrom plotly.subplots import make_subplots\nfig = make_subplots(rows=1, cols=2)\ndata1 = [trace11, trace12]\ndata2 = [trace21, trace22]\nfig.add_traces(data1, rows=1, cols=1)\nfig.add_traces(data2, rows=1, cols=2)\nfig.show()\n\n", "I was running into a similar problem myself while doing the Interactive Python Dashboards with Plotly and Dash Udemy course and figured out how to get my code to work so I will post my problematic code and what ended up working for me so you can compare. Keep in mind I am not a programmer or computer scientist by trade so I can't provide all the ins and out of what's going on behind the scenes... Just what works for me.. Also, I literally got my code working while reviewing your code and noticed that we were both passing in lists, while other code that works for the append_trace() call does not pass in a list. I hope this helps.\nFirst, tools.make_subplots() is deprecated based on my research of this issue, and the import of tools from plotly is not used anywhere in my code. I think you need to use:\nfrom plotly.subplots import make_subplots\n\nNext, I think I was simply using a list where it was inappropriate. Here is my original code that did not work:\nimport plotly.offline as pyo\nimport plotly.graph_objs as go\nfrom plotly import tools\nfrom plotly.subplots import make_subplots\nimport pandas as pd\n\ndf1 = pd.read_csv('Data/2010SantaBarbaraCA.csv')\ndf2 = pd.read_csv('Data/2010YumaAZ.csv')\ndf3 = pd.read_csv('Data/2010SitkaAK.csv')\n\n\ntrace1 = [go.Heatmap(x=df1['DAY'],\n y=df1['LST_TIME'],\n z=df1['T_HR_AVG'].values.tolist(),\n zmin=5,\n zmax=40)] # z= cannot accept a pandas column, needs to be a list\n\ntrace2 = [go.Heatmap(x=df2['DAY'],\n y=df2['LST_TIME'],\n z=df2['T_HR_AVG'].values.tolist(),\n zmin=5,\n zmax=40)] # z= cannot accept a pandas column, needs to be a list\n\ntrace3 = [go.Heatmap(x=df3['DAY'],\n y=df3['LST_TIME'],\n z=df3['T_HR_AVG'].values.tolist(),\n zmin=5,\n zmax=40)] # z= cannot accept a pandas column, needs to be a list\n\n# fig = tools.make_sublots(rows=1,\n# columns=3,\n# subplot_titles=['Santa Barbara CA','Yuma AZ', 'Sitka AK'],\n# shared_yaxes=True)\n\nfig = make_subplots(rows=1,\n cols=3,\n subplot_titles=['Santa Barbara CA', 'Yuma AZ', 'Sitka AK'],\n shared_yaxes=True)\n\n\n# fig.append_trace(trace#, row#, column#)\nfig.append_trace(trace1, row=1, col=1)\nfig.append_trace(trace2, row=1, col=2)\nfig.append_trace(trace3, row=1, col=3)\n\n# data = [trace1, trace2, trace3]\n\n# layout = go.Layout(title='Santa Barbara California Temperatures')\n\npyo.plot(fig)\n\nNotice I had my trace#'s defined with brackets\ntrace1 = [go.Heatmap(x=df1['DAY'],\n y=df1['LST_TIME'],\n z=df1['T_HR_AVG'].values.tolist(),\n zmin=5,\n zmax=40)]\n\nWhen I removed the brackets from each of my trace declarations my code worked. Here is my code that works:\nimport plotly.offline as pyo\nimport plotly.graph_objs as go\nfrom plotly import tools\nfrom plotly.subplots import make_subplots\nimport pandas as pd\n\ndf1 = pd.read_csv('Data/2010SantaBarbaraCA.csv')\ndf2 = pd.read_csv('Data/2010YumaAZ.csv')\ndf3 = pd.read_csv('Data/2010SitkaAK.csv')\n\n\ntrace1 = go.Heatmap(x=df1['DAY'],\n y=df1['LST_TIME'],\n z=df1['T_HR_AVG'].values.tolist(),\n zmin=5,\n zmax=40) # z= cannot accept a pandas column, needs to be a list\n\ntrace2 = go.Heatmap(x=df2['DAY'],\n y=df2['LST_TIME'],\n z=df2['T_HR_AVG'].values.tolist(),\n zmin=5,\n zmax=40) # z= cannot accept a pandas column, needs to be a list\n\ntrace3 = go.Heatmap(x=df3['DAY'],\n y=df3['LST_TIME'],\n z=df3['T_HR_AVG'].values.tolist(),\n zmin=5,\n zmax=40) # z= cannot accept a pandas column, needs to be a list\n\n# fig = tools.make_sublots(rows=1,\n# columns=3,\n# subplot_titles=['Santa Barbara CA','Yuma AZ', 'Sitka AK'],\n# shared_yaxes=True)\n\nfig = make_subplots(rows=1,\n cols=3,\n subplot_titles=['Santa Barbara CA', 'Yuma AZ', 'Sitka AK'],\n shared_yaxes=True)\n\n\n# fig.append_trace(trace#, row#, column#)\nfig.append_trace(trace1, row=1, col=1)\nfig.append_trace(trace2, row=1, col=2)\nfig.append_trace(trace3, row=1, col=3)\n\n# data = [trace1, trace2, trace3]\n\n# layout = go.Layout(title='Santa Barbara California Temperatures')\n\npyo.plot(fig)\n\nI know you are using Scatter and I am using Heatmaps but I think your issue may be(apart from using tools for make_subplots()) that you are passing data1 and data2 into your append_trace() calls as lists, and I don't think the append_trace() call likes this. I would suggest not passing in a list to the append_trace() call and seeing if that works. If it does then you may need to adjust your data variables to not be listed and go from there. I hope this helps.\n", "While trying to make subplots of histograms, I ran into a similar problem.\nMy error occurred as I was trying for loops in the wrong way, but the solution below solves the issue you are having. I used add_trace instead of append_trace and used for loop for ease of future use.\nfrom plotly.graph_objs.scatter import Line\nfrom plotly.subplots import make_subplots\nimport plotly.graph_objs as go\n\ntrace11 = go.Scatter(\n x = [0, 1, 2],\n y = [0, 0, 0],\n line = Line({'color': 'rgb(0, 0, 128)', 'width': 1})\n)\n\ntrace12 = go.Scatter(\n x=[0, 1, 2],\n y=[1, 1, 1],\n line = Line({'color': 'rgb(128, 0, 0)', 'width': 1})\n)\n\ntrace21 = go.Scatter(\n x = [0, 1, 2],\n y = [0.5, 0.5, 0.5],\n line = Line({'color': 'rgb(0, 0, 128)', 'width': 1})\n)\n\ntrace22 = go.Scatter(\n x=[0, 1, 2],\n y=[1.5, 1.5, 1.5],\n line = Line({'color': 'rgb(128, 0, 0)', 'width': 1})\n)\ntrace=[trace11, trace12, trace21, trace22]\n\nplot_rows=2\nplot_cols=2\nfig = make_subplots(rows=plot_rows, cols=plot_cols)\n\nx=0\nfor i in range(1, plot_rows + 1):\n for j in range(1, plot_cols + 1):\n fig.add_trace(trace[x],\n row=i,\n col=j)\n x+=1\n\nfig.update_layout(height=600, width=600)\nfig.show()\n\n", "My issue was that I was trying to use a px (plotly express) plot in a trace. The problem, I discovered, is that px returns a complete figure, but add_trace (add_traces, append_trace) wants just the data.\nWhat solved this for me was adding \".data[0]\" to the end of my px figure name:\nfig = go.Figure()\ndf = pd.DataFrame({'x':[1,2,3,4], 'y':[5,6,7,8]})\nfig2 = px.scatter(df, x=\"x\", y=\"y\")\nfig.add_trace(fig2.data[0])\nfig.show()\n\nOR you if you use add_traces (plural) you don't need the [0] qualifier.\nfig = go.Figure()\ndf = pd.DataFrame({'x':[1,2,3,4], 'y':[5,6,7,8]})\nfig2 = px.scatter(df, x=\"x\", y=\"y\")\nfig.add_traces(fig2.data)\nfig.show()\n\nHope this helps someone save time.\n" ]

[ 6, 0, 0, 0 ]

[]

[]

[ "plotly", "python" ]

[ "You can use a Window with rank:\nfrom pyspark.sql import functions as F, Window\n\n# you can order by the column you prefer, not only id\nw = Window.partitionBy('vehicle', 'EU_variant').orderBy('id')\ndf.withColumn(\n 'ECU_Variant_rank', \n F.concat_ws('', F.col('EU_variant'), F.lit('('), F.rank().over(w), F.lit(')'))\n)\n\nHere the result:\n+---+-------+------+----+------------+----------------+\n|id |vehicle|asIs |EU |EU_variant |ECU_Variant_rank|\n+---+-------+------+----+------------+----------------+\n|1 |A3345 |PQ1298|FV1 |FV1_variant |FV1_variant(1) |\n|2 |A3346 |PQ1287|FV2 |FV2_variant |FV2_variant(1) |\n|3 |A3346 |PQ1207|FV2 |FV2_variant |FV2_variant(2) |\n|4 |A3347 |null |QP9 |QP9_variant |QP9_variant(1) |\n|5 |A3347 |null |QP9 |QP9_variant |QP9_variant(2) |\n|6 |A3347 |null |QP3 |QP3_variant |QP3_variant(1) |\n|7 |A3348 |MP6553|YR34|YR34_variant|YR34_variant(1) |\n|8 |A3348 |MP6554|YR35|YR35_variant|YR35_variant(1) |\n|9 |A3348 |MP6554|YR35|YR35_variant|YR35_variant(2) |\n+---+-------+------+----+------------+----------------+\n\n" ]

[ 1 ]

[]

[]

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

[ "A .gitignore file will not help you there - you need to remove the dependencies from your project's history. There are two ways to do that:\nThe traditional way involves git-filter-branch. I've done that once in the past. It works, but it's easy to get wrong.\nThe alternative is to use BFG. I have no personal experience, but it seems to be easier to use, and claims to be faster. So if I were you, I'd give BFG a try.\nWhichever way you try, make a lokal backup!\nWhen you're done rewriting history, you can use a .gitignore to prevent yourself from re-adding the unwanted files.\n", "Welcome to Stackoverflow!\nAs you already sensed by yourself, Git is not really made to work with volumes of data that are as large as you say (15.5GB). The most important thing you have to do right now is identify which files you want to keep track of, and which files are just \"binary files\" that don't have to be versioned. You don't have to use any other tool than your brain for this (but looking around with any type of file explorer will teach you a lot).\nDeciding what to keep\nIt is important to be quite severe here. As a general approach (there can be exceptions), try to keep out the following files:\n\nAny file that is >1MB. There will surely be exceptions, but in general this is a good rule of thumb.\nAnything that is binary/non text based. Git is made to work with diffs on files and this is not user-friendly with non-text based files. Examples: images, videos, powerpoints, ...\nAnything that is generated by code (for example results of compilations, or data processing, ...)\nAnything that is generated by a tool you use (for example folders created by your IDE)\nAny data file. Git is not really made for version control of data. It's really your code you want to version control.\n\nCreating a git repository\nIt seems like you have made a git repository already, but unless you have very important history you want to keep I suggest starting anew from where you are now. If it's for a university project I can imagine it being fine that you lose your history until now. If it's not fine for you to lose your history, you will have to change your history and delete large files from your repo (a risky operation I would not recommend to a new Git user. More info can be found in this SO post).\nI'm suggesting to start a fresh repository because I feel you will learn more in this way, but if you prefer to change your history go ahead!\nTo start off a fresh repository, go to the root directory of your project and copy the .git folder to some place as a backup. This is often a hidden folder, and it contains all of your history!\nThen, delete this .git folder (making sure that you have kept your backup .git folder somewhere).\nAfter than, execute the git init command. You have a fresh git repository to work with! Typing git status will show a bunch of untracked files.\nPopulating your gitignore\nThe first thing we will do now is make our .gitignore file, before committing anything else. Let's say that you decided in your first step to ignore the following:\n\nall *.xlsx files\neverything inside of the build/ directory\nall *.log files\n\nIn that case, you should create a text file (with any text editor: your IDE or notepad or anything) called .gitignore. Open this up with your text editor of choice and add the following text in there:\n*.xlsx\nbuild/*\n*.log\n\nNow save the file. You have made your .gitignore file! Now add and commit the file (using a good commit message) and type git status. You should see none of the unwanted files appearing! Now you can commit all the rest of your files (properly check git status to see that no unwanted files are tracked by git before committing them!) and you have a clean lightweight repo.\nMaintaining your gitignore\nIt's normal for the gitignore file to evolve during the project. Don't hesitate to add new lines in there if a new file type/folder enters the project that is actually unwanted in the repository.\nHope this helps you a bit!\n" ]

[ 0, 0 ]

[]

[]

[ "git", "github", "github_desktop", "pycharm", "python" ]

[ "Currently dealing with the same issue, with my Python script doing almost exactly as yours does. My initial workaround for running the script on a set schedule was utilizing datetime variables and while True loops, then switched to apscheduler for convenience. Switching back to the workaround again ran the script flawlessly. Hopefully this helps anyone else also dealing with this issue!\n" ]

[ 0 ]

[]

[]

[ "python", "scheduled_tasks", "selenium", "selenium_chromedriver", "taskscheduler" ]

[ "I think you are confused about what a decorator is and what the word wrapping typically refers to. Neither of those apply here, if I understood your intent correctly.\nOf course you can subclass some existing class that you may or may not have any control over and override its methods. And of course you can conveniently call the parent class' methods from inside your own methods. In Python you typically use the built in super proxy class for that. But none of this has anything to do with decoration or wrapping.\nIf you want to override a superclass' method, you should take care to match its signature. Otherwise you would be violating type safety. If all you care about are a few specific arguments but not all of them, you can cheat a bit and collect the rest in the catch-all *args, **kwargs parameters, but you should then pass them along to the superclass' method call.\nAlso, you seemed to be calling the ConfigParser.get method inside your overridden getint method. But I am pretty sure that was a typo/mistake because you are clearly expecting the returned value that you assign to ret to be an int, whereas get returns a str. So you should be calling super().getint(...) there.\nFinally, if we are already at it, it is good form to properly annotate your functions with types. (see PEP 484 for details)\nHere is what I think you need:\nfrom configparser import ConfigParser\nfrom typing import Any\n\n\nclass MyConfigParser(ConfigParser):\n def getint(self, section: str, option: str, *args: Any, **kwargs: Any) -> int:\n ret = super().getint(section, option, *args, **kwargs)\n print(\"overridden `getint`\")\n ret += 1\n return ret # type: ignore[no-any-return]\n\n\nif __name__ == \"__main__\":\n config = MyConfigParser()\n config.read(\"my-file.ini\")\n print(config.getint(\"a\", \"b\"))\n\nThe output with your example ini-file:\n\noverridden `getint`\n2\n\nThere are a lot of questions and answers on this platform about super and subclassing as well as decorators. I would suggest you search a bit and read up on those.\n" ]

[ 1 ]

[]

[]

[ "configparser", "python" ]

[ "You can use pd.concat because append is getting deprecated. Ref\ndct = {\"a\": 300, \"b\": 88}\ndf_new = pd.concat([df, pd.Series(dct).to_frame().T]\n ).iloc[1:, :].reset_index(drop=True)\nprint(df_new)\n\n# If maybe the values of 'dict' have multiple items.\n# dct = {\"a\": [300, 400], \"b\": [88, 98]}\n# df_new = pd.concat([df, pd.DataFrame(dct)]\n# ).iloc[1:, :].reset_index(drop=True)\n\nYou can add a new row to df with pandas.DataFrame.append then drop the first-row base number of index. (At the end use reset_index if it is necessary)\ndct = {\"a\": 300, \"b\": 88}\ndf_new = df.append(dct, ignore_index=True).drop(0, axis=0).reset_index(drop=True)\nprint(df_new)\n\nOutput:\n a b\n0 380 40\n1 390 45\n2 300 88\n\n", "Using concat:\ndf = pd.concat([df.iloc[1:],\n pd.DataFrame.from_dict({0: d}, orient='index')], \n ignore_index=True)\n\nOutput:\n a b\n0 380 40\n1 390 45\n2 300 88\n\n", "You can append new row to existing dataframe by df.append(). In your example, this would be\nnew_row = {\"a\": 300, \"b\": 88}\ndf2 = df.append(new_row, ignore_index=True)\n\n(Notice that append works both for Dataframe and dict objects, but the later requires ignore_index=True.\nAnd you can remove the first row from dataframe by one of the following methods:\n\nSelect using iloc\n\ndf3 = df2.iloc[1:, :]\n\nThis slices all rows but the first one, and all columns.\n\nUse drop to remove the first row.\n\ndf3 = df2.drop(df.index[0], axis=0, inplace=False)\n\nOr you could use inplace=True to modify df2 inplace, None will be returned in that case.\n" ]

[ 1, 1, 0 ]

[]

[]

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

[ "tl;dr: You lack connectivity.\nThe jenkins library depends on import requests,\nwhich is reporting the connectivity error.\nRegrettably, it uses ProxyError in the diagnostic.\nThe rationale goes like this:\n\nWe're making a GET request for the application.\nOptionally the \"GET from server S\" will be turned into \"GET from proxy P\" if proxying is in use.\nEventually we try to contact some host, S or P. Might as well tell a proxy user that state of S is unknown, but state of P is \"down\".\n\nHere ends the \"why mention proxying?\" diagnostic rant.\nWhen you say \"I'm not using proxying\", I believe you.\nThe diagnostic can be a bit of a red herring for\nfolks who are not yet familiar with it.\n\nWhen I probe ebs.usps.gov (56.207.107.97) on ports 443, 80, or with ICMP, I see zero response packets.\nYou're in a different part of the net, with different\nfilters between you and server, so your mileage might vary.\nI wouldn't describe that host as a \"public server\",\nsince it offers me no responses.\n\nIt appears you sent SYN to tcp port 443,\nand either some network device discarded that packet,\nor the server replied with SYN-ACK and that\nreply packet was discarded.\nMost likely the server is down or your request was discarded.\n", "The final part of the traceback says:\nProxyError: HTTPSConnectionPool(host='ebs.usps.gov', port=443)\n\nWhich most likely indicates that you have proxy settings that your Python code inherits from somewhere when it runs. It could be environment variables ((HTTP|HTTPS)_PROXY) on POSIX sort of platforms or something similar... If you need to to use a proxy to reach the Jenkins instance, then the issue is in the proxy itself. It blocks your access for some reason. If you do not need to use a proxy, then you should remove the settings affecting your Python code when you run it.\nAlso, see what J_H said...\n" ]

[ 0, 0 ]

[]

[]

[ "api", "jenkins", "json", "python" ]

[ "This is a bit too long to answer as a comment, and so ...\nIf what these tasks are doing is all or mostly all CPU-processing with very little waiting, then you should not be creating a processing pool greater than the number of CPU cores you have. See below for the general idea. Instead of using a multithreading pool, you could simply have a single multiprocessing pool and restructure code to do the iterating in the main process:\nfrom multiprocessing.pool import ThreadPool, Pool\nimport multiprocessing\nfrom functools import partial\n\n# subtask\ndef update(args): \n ...\n return updated_a\n\n\n# task\n# This runs in a multithreading pool, but it\n# is mostly waiting for the multiprocessing pool to generate\n# results:\ndef task(process_pool, args):\n ...\n for i in range(200):\n # evaluations\n ...\n self.arraies = list(process_pool.map(update, [[..., a] for a in self.arraies]))\n ...\n return result\n\n\n# required for spawned processes:\nif __name__ == '__main__':\n ...\n ss = np.random.SeedSequence()\n tasks_seeds = ss.spawn(N_ITERATIONS + 1)\n streams = [np.random.default_rng(s) for s in tasks_seeds]\n # Use number of cpu cores:\n with multiprocessing.get_context('spawn').Pool() as process_pool:\n task_args = [[...,streams[i]] for i in range(N_ITERATIONS)]\n # Limit thread pool size to a maximum of 200 (rather arbitrary):\n with ThreadPool(min(200, len(task_args))) as thread_pool:\n # pass the pool as the first argument:\n worker = partial(task, process_pool)\n results = p.map(worker, task_args)\n\n" ]

[ 0 ]

[]

[]

[ "for_loop", "multiprocessing", "parallel_processing", "pool", "python" ]

[ "using axis = 1 did the trick.\ndf[\"ColC\"] = df[[\"ColA\", \"ColB\"]].apply(lambda x: customFunc(x.ColA, x.ColB), axis = 1)\n\n" ]

[ 0 ]

[]

[]

[ "pandas", "python" ]

[ "For rotating back, we may compute the inverse transformation, and apply it to the rotated image:\nExample:\ninv_rotation_mat = cv2.invertAffineTransform(rotation_mat) # Get inverse transformation matrix\nunrotated_mat = cv2.warpAffine(rotated_mat, inv_rotation_mat, (mat.shape[1], mat.shape[0])) # Apply warp (and set the destination size to original size of mat).\n\n\nComplete code sample:\nimport cv2\n\nimg = cv2.imread('lena.jpg')\n\ndef rotate_image(mat, angle):\n \"\"\"\n Rotates an image (angle in degrees) and expands image to avoid cropping\n \"\"\"\n\n height, width = mat.shape[:2] # image shape has 3 dimensions\n image_center = (width/2, height/2) # getRotationMatrix2D needs coordinates in reverse order (width, height) compared to shape\n\n rotation_mat = cv2.getRotationMatrix2D(image_center, angle, 1.)\n\n # rotation calculates the cos and sin, taking absolutes of those.\n abs_cos = abs(rotation_mat[0,0]) \n abs_sin = abs(rotation_mat[0,1])\n\n # find the new width and height bounds\n bound_w = int(height * abs_sin + width * abs_cos)\n bound_h = int(height * abs_cos + width * abs_sin)\n\n # subtract old image center (bringing image back to origo) and adding the new image center coordinates\n rotation_mat[0, 2] += bound_w/2 - image_center[0]\n rotation_mat[1, 2] += bound_h/2 - image_center[1]\n\n # rotate image with the new bounds and translated rotation matrix\n rotated_mat = cv2.warpAffine(mat, rotation_mat, (bound_w, bound_h))\n return (rotated_mat, rotation_mat) # Also return rotation_mat\n\n\nModifiedVersionRotation, T = rotate_image(img, 35)\n\niT = cv2.invertAffineTransform(T)\n\nunrotated_img = cv2.warpAffine(ModifiedVersionRotation, iT, (img.shape[1], img.shape[0]))\n\n#cv2.imwrite(\"lenarot.jpg\", ModifiedVersionRotation)\n#cv2.imwrite(\"lenarotback.jpg\", unrotated_img)\ncv2.imwrite(\"lenarot.png\", ModifiedVersionRotation)\ncv2.imwrite(\"lenarotback.png\", unrotated_img)\n\n\n\n# Show images for testing\ncv2.imshow('ModifiedVersionRotation', ModifiedVersionRotation)\ncv2.imshow('img', img)\ncv2.imshow('unrotated_img', unrotated_img)\ncv2.waitKey()\ncv2.destroyAllWindows()\n\n\nModifiedVersionRotation:\n\nunrotated_img:\n\nOriginal image:\n\n\nThe \"restored\" image looks blurred, because each warp (forward and backward) applies bi-linear interpolation that blurs the image a little.\n" ]

[ 3 ]

[]

[]

[ "image_processing", "opencv", "python" ]

[ "Nevermind I figured it out. I had to use a javascript executor to pull the text with the following code.\nelement = driver.find_element_by_xpath('//input[@id=\"soa_h_date\"]')\ndate = driver.execute_script(\"return arguments[0].value\",element)\n\n" ]

[ 0 ]

[]

[]

[ "html", "python", "selenium", "selenium_webdriver" ]

[ "You've mentioned that snapshot.get_positions() returns some 2D array, suppose of shape (p, q). So I expect that Y is a 3D array with some shape (m, p, q), where m is the number of snapshots in the trajectory. You also expect m to scale rather high.\nLet's see a basic way to speed up the distance calculation, on the setting m=1000:\nimport numpy as np\n\n# dummy inputs\nm = 1000\np, q = 4, 5\nY = np.random.randn(m, p, q)\n\n# your current method\ndef foo():\n return [np.sqrt(((((Y[i]- Y[j])**2))*3).mean()) for i in range(m) for j in range(i + 1, m)]\n\n# vectorized approach -> compute the upper triangle of the pairwise distance matrix\ndef bar():\n u, v = np.triu_indices(Y.shape[0], 1)\n return np.sqrt((3 * (Y[u] - Y[v]) ** 2).mean(axis=(-1, -2)))\n\n# Check for correctness\n\nout_1 = foo()\nout_2 = bar()\nprint(np.allclose(out_1, out_2))\n# True\n\nIf we test the time required:\n%timeit -n 10 -r 3 foo()\n# 3.16 s ± 50.3 ms per loop (mean ± std. dev. of 3 runs, 10 loops each)\n\nThe first method is really slow, it takes over 3 seconds for this calculation. Let's check the second method:\n%timeit -n 10 -r 3 bar()\n# 97.5 ms ± 405 µs per loop (mean ± std. dev. of 3 runs, 10 loops each)\n\nSo we have a ~30x speedup here, which would make your large calculation in python much more feasible than using the original code. Feel free to test out with other sizes of Y to see how it scales compared to the original.\n\nJIT\nIn addition, you can also try out JIT, mainly jax or numba. It is fairly simple to port the function bar with jax.numpy, for example:\nimport jax\nimport jax.numpy as jnp\n\[email protected]\ndef jit_bar(Y):\n u, v = jnp.triu_indices(Y.shape[0], 1)\n return jnp.sqrt((3 * (Y[u] - Y[v]) ** 2).mean(axis=(-1, -2)))\n\n# check for correctness\n\nprint(np.allclose(bar(), jit_bar(Y)))\n# True\n\nIf we test the time of the jitted jnp op:\n%timeit -n 10 -r 3 jit_bar(Y)\n# 10.6 ms ± 678 µs per loop (mean ± std. dev. of 3 runs, 10 loops each)\n\nSo compared to the original, we could reach even up to ~300x speed.\nNote that not every operation can be converted to jax/jit so easily (this particular problem is conveniently suitable), so the general advice is to simply avoid python loops and use numpy's broadcasting/vectorization capabilities, like in bar().\n", "Stick to Julia.\nIf you already made it in a language which runs faster, why are you trying to use python in the first place?\n", "Your question is about speeding up Python, relative to Julia, so I'd like to offer some Julia code for comparison.\nSince your data is most naturally expressed as a list of 4x5 arrays, I suggest expressing it as a vector of SMatrixes:\nsumdiff2(A, B) = sum((A[i] - B[i])^2 for i in eachindex(A, B))\nfunction dists(Y)\n M = length(Y)\n V = Vector{float(eltype(eltype(Y)))}(undef, sum(1:M-1))\n Threads.@threads for i in eachindex(Y)\n ii = sum(M-i+1:M-1) # don't worry about this sum\n for j in i+1:lastindex(Y)\n ind = ii + (j-i)\n V[ind] = sqrt(3 * sumdiff2(Y[i], Y[j])/length(Y[i]))\n end\n end\n return V\nend\n\nusing Random: randn\nusing StaticArrays: SMatrix\nYs = [randn(SMatrix{4,5,Float64}) for _ in 1:1000];\n\nBenchmarks:\n# single-threaded\njulia> using BenchmarkTools\njulia> @btime dists($Ys);\n 6.561 ms (2 allocations: 3.81 MiB)\n\n# multi-threaded with 6 cores\njulia> @btime dists($Ys);\n 1.606 ms (75 allocations: 3.82 MiB)\n\nI was not able to install jax on my computer, but when comparing with @Mercury's numpy code I got\nfoo: 5.5seconds\nbar: 179ms\n\ni.e. approximately 3400x speedup over foo.\nIt is possible to write this as a one-liner at a ~2-3x performance cost.\n", "While Python tends to be slower than Julia for many tasks, it is possible to write numerical codes as fast as Julia in Python using Numba and plain loops. Indeed, Numba is based on LLVM-Lite which is basically a JIT-compiler based on the LLVM toolchain. The standard implementation of Julia also use a JIT and the LLVM toolchain. This means the two should behave pretty closely besides the overhead introduced by the languages that are negligible once the computation is performed in parallel (because the resulting computation will be memory-bound on nearly all modern platforms).\nThis computation can be parallelized in both Julia and Python (still using Numba). While writing a sequential computation is quite straightforward, writing a parallel computation is if bit more complex. Indeed, computing the upper triangular values can result in an imbalanced workload and so to a sub-optimal execution time. An efficient strategy is to compute, for each iteration, a pair of lines: one comes from the top of the upper triangular part and one comes from the bottom. The top line contains m-i items while the bottom one contains i+1 items. In the end, there is m+1 items to compute per iteration so the number of item is independent of the iteration number. This results in a much better load-balancing. The line of the middle needs to be computed separately regarding the size of the input array.\nHere is the final implementation:\nimport numba as nb\nimport numpy as np\n\[email protected](inline='always', fastmath=True)\ndef compute_line(tmp, res, i, m):\n offset = (i * (2 * m - i - 1)) // 2\n factor = 3.0 / n\n for j in range(i + 1, m):\n s = 0.0\n for k in range(n):\n s += (tmp[i, k] - tmp[j, k]) ** 2\n res[offset] = np.sqrt(s * factor)\n offset += 1\n return res\n\[email protected]('()', parallel=True, fastmath=True)\ndef fastest():\n m, n = Y.shape[0], Y.shape[1] * Y.shape[2]\n res = np.empty(m*(m-1)//2)\n tmp = Y.reshape(m, n)\n for i in nb.prange(m//2):\n compute_line(tmp, res, i, m)\n compute_line(tmp, res, m-i-1, m)\n if m % 2 == 1:\n compute_line(tmp, res, (m+1)//2, m)\n return res\n\n# [...] same as others\n%timeit -n 100 fastest()\n\n\nResults\nHere are performance results on my machine (with a i5-9600KF having 6 cores):\nfoo (seq, Python, Mercury): 4910.7 ms\nbar (seq, Python, Mercury): 134.2 ms\njit_bar (seq, Python, Mercury): ???\ndists (seq, Julia, DNF) 6.9 ms\ndists (par, Julia, DNF) 2.2 ms\nfastest (par, Python, me): 1.5 ms <-----\n\n(Jax does not work on my machine so I cannot test it yet)\nThis implementation is the fastest one and succeed to beat the best Julia code so far.\n\nOptimal implementation\nNote that for large arrays like (200_000,4,5), all implementations provided so far are inefficient since they are not cache friendly. Indeed, the input array will take 32 MiB and will not for on the cache of most modern processors (and even if it could, one need to consider the space needed for the output and the fact that caches are not perfect). This can be fixed using tiling, at the expense of an even more complex code. I think such an implementation should be optimal if you use Z-order curves.\n" ]

[ 6, 4, 2, 1 ]

[]

[]

[ "julia", "numpy", "python" ]

[]

[]

[ "This creates a list of lists, grouping the phrases.\nfinal_list = []\nsublist = []\nfor phrase in starting_list:\n if re.match('^[а-яёА-ЯЁ]', phrase):\n final_list.append(sublist)\n sublist = [phrase]\n else:\n sublist += [phrase]\n\n" ]

[ -1 ]

[ "list", "python", "string" ]

[ "thelist[:] = [d for d in thelist if d.get('id') != 2]\n\nEdit: as some doubts have been expressed in a comment about the performance of this code (some based on misunderstanding Python's performance characteristics, some on assuming beyond the given specs that there is exactly one dict in the list with a value of 2 for key 'id'), I wish to offer reassurance on this point.\nOn an old Linux box, measuring this code:\n$ python -mtimeit -s\"lod=[{'id':i, 'name':'nam%s'%i} for i in range(99)]; import random\" \"thelist=list(lod); random.shuffle(thelist); thelist[:] = [d for d in thelist if d.get('id') != 2]\"\n10000 loops, best of 3: 82.3 usec per loop\n\nof which about 57 microseconds for the random.shuffle (needed to ensure that the element to remove is not ALWAYS at the same spot;-) and 0.65 microseconds for the initial copy (whoever worries about performance impact of shallow copies of Python lists is most obviously out to lunch;-), needed to avoid altering the original list in the loop (so each leg of the loop does have something to delete;-).\nWhen it is known that there is exactly one item to remove, it's possible to locate and remove it even more expeditiously:\n$ python -mtimeit -s\"lod=[{'id':i, 'name':'nam%s'%i} for i in range(99)]; import random\" \"thelist=list(lod); random.shuffle(thelist); where=(i for i,d in enumerate(thelist) if d.get('id')==2).next(); del thelist[where]\"\n10000 loops, best of 3: 72.8 usec per loop\n\n(use the next builtin rather than the .next method if you're on Python 2.6 or better, of course) -- but this code breaks down if the number of dicts that satisfy the removal condition is not exactly one. Generalizing this, we have:\n$ python -mtimeit -s\"lod=[{'id':i, 'name':'nam%s'%i} for i in range(33)]*3; import random\" \"thelist=list(lod); where=[i for i,d in enumerate(thelist) if d.get('id')==2]; where.reverse()\" \"for i in where: del thelist[i]\"\n10000 loops, best of 3: 23.7 usec per loop\n\nwhere the shuffling can be removed because there are already three equispaced dicts to remove, as we know. And the listcomp, unchanged, fares well:\n$ python -mtimeit -s\"lod=[{'id':i, 'name':'nam%s'%i} for i in range(33)]*3; import random\" \"thelist=list(lod); thelist[:] = [d for d in thelist if d.get('id') != 2]\"\n10000 loops, best of 3: 23.8 usec per loop\n\ntotally neck and neck, with even just 3 elements of 99 to be removed. With longer lists and more repetitions, this holds even more of course:\n$ python -mtimeit -s\"lod=[{'id':i, 'name':'nam%s'%i} for i in range(33)]*133; import random\" \"thelist=list(lod); where=[i for i,d in enumerate(thelist) if d.get('id')==2]; where.reverse()\" \"for i in where: del thelist[i]\"\n1000 loops, best of 3: 1.11 msec per loop\n$ python -mtimeit -s\"lod=[{'id':i, 'name':'nam%s'%i} for i in range(33)]*133; import random\" \"thelist=list(lod); thelist[:] = [d for d in thelist if d.get('id') != 2]\"\n1000 loops, best of 3: 998 usec per loop\n\nAll in all, it's obviously not worth deploying the subtlety of making and reversing the list of indices to remove, vs the perfectly simple and obvious list comprehension, to possibly gain 100 nanoseconds in one small case -- and lose 113 microseconds in a larger one;-). Avoiding or criticizing simple, straightforward, and perfectly performance-adequate solutions (like list comprehensions for this general class of \"remove some items from a list\" problems) is a particularly nasty example of Knuth's and Hoare's well-known thesis that \"premature optimization is the root of all evil in programming\"!-)\n", "Here's a way to do it with a list comprehension (assuming you name your list 'foo'):\n[x for x in foo if not (2 == x.get('id'))]\n\nSubstitute 'john' == x.get('name') or whatever as appropriate.\nfilter also works:\nfoo.filter(lambda x: x.get('id')!=2, foo)\nAnd if you want a generator you can use itertools:\nitertools.ifilter(lambda x: x.get('id')!=2, foo)\nHowever, as of Python 3, filter will return an iterator anyway, so the list comprehension is really the best choice, as Alex suggested.\n", "This is not properly an anwser (as I think you already have some quite good of them), but... have you considered of having a dictionary of <id>:<name> instead of a list of dictionaries?\n", "# assume ls contains your list\nfor i in range(len(ls)):\n if ls[i]['id'] == 2:\n del ls[i]\n break\n\nWill probably be faster than the list comprehension methods on average because it doesn't traverse the whole list if it finds the item in question early on.\n", "Supposed your python version is 3.6 or greater, and that you don't need the deleted item this would be less expensive...\nIf the dictionaries in the list are unique :\nfor i in range(len(dicts)):\n if dicts[i].get('id') == 2:\n del dicts[i]\n break\n\nIf you want to remove all matched items :\nfor i in range(len(dicts)):\n if dicts[i].get('id') == 2:\n del dicts[i]\n\nYou can also to this to be sure getting id key won't raise keyerror regardless the python version\n\nif dicts[i].get('id', None) == 2\n\n", "You can try the following: \na = [{'id': 1, 'name': 'paul'},\n {'id': 2, 'name': 'john'}]\n\nfor e in range(len(a) - 1, -1, -1):\n if a[e]['id'] == 2:\n a.pop(e)\n\nIf You can't pop from the beginning - pop from the end, it won't ruin the for loop.\n", "You could try something along the following lines:\ndef destructively_remove_if(predicate, list):\n for k in xrange(len(list)):\n if predicate(list[k]):\n del list[k]\n break\n return list\n\n list = [\n { 'id': 1, 'name': 'John' },\n { 'id': 2, 'name': 'Karl' },\n { 'id': 3, 'name': 'Desdemona' } \n ]\n\n print \"Before:\", list\n destructively_remove_if(lambda p: p[\"id\"] == 2, list)\n print \"After:\", list\n\nUnless you build something akin to an index over your data, I\ndon't think that you can do better than doing a brute-force \"table\nscan\" over the entire list. If your data is sorted by the key you\nare using, you might be able to employ the bisect module to\nfind the object you are looking for somewhat faster.\n", "From the update on pep448 on unpacking generalisations (python 3.5 and onwards) while iterating a list of dicts with a temporary variable, let's say row, You can take the dict of the current iteration in, using **row, merge new keys in or use a boolean operation to filter out dict(s) from your list of dicts.\nKeep in mind **row will output a new dictionary.\nFor example your starting list of dicts :\ndata = [{'id': 1, 'name': 'paul'},{'id': 2, 'name': 'john'}]\n\nif we want to filter out id 2 :\ndata = [{**row} for row in data if data['id']!=2]\n\nif you want to filter out John :\ndata = [{**row} for row in data if data['name']!='John']\n\nnot directly related to the question but if you want to a add new key :\ndata = [{**row, 'id_name':str(row['id'])+'_'+row['name']} for row in data]\n\nIt's also a tiny bit faster than the accepted solution.\n" ]

[ 143, 11, 8, 8, 2, 1, 0, 0 ]

[]

[]

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

[ "This is the below action that is being performed with the below code.\nSDD.loc[DFF.index, 'RDD'] = SDD.loc[DFF.index, 'DlvDate']\nBasically in this above line the following operations are being done.\nAll the index columns of DFF Dataframe and All the Index columns of SDD Dataframe are joined. A new column is created named 'RDD' on the SDD Dataframe and for all matching index values of DFF Dataframe , SDD.DlvDate column value is set in the RDD column and for unmatched values , null is set.\nThe equivalent pyspark is left joining the dataframes where SDD is the left dataframe , then with a \"case when then\" needs to check if any of the joining col of DFF dataframe is null then set the SDD dataframe DlvDate as null.\n" ]

[ 1 ]

[]

[]

[ "pandas", "python" ]

[ "This is no longer a problem and the solution is real frustrating - it was Docker's fault. For ~6 months there was a bug in Docker that was dropping connections (ultimately leading to the timeouts mentioned above) which was finally fixed in Docker Desktop 4.14.\nThe moment I upgraded Docker (it had just come out at the time and I thought I would try the hail Mary upgrade having already turned every dial and adjusted every config param without any luck), it finally stopped timing out and dropping connections. I was suddenly able to send through tens of thousands of concurrent requests without issue.\nTLDR: uWSGI, Nginx, nor my config were at fault here. Docker had a bug that has been patched. If others on macOS are facing this problem, try upgrading to at least Docker Dekstop 4.14.\n" ]

[ 4 ]

[]

[]

[ "docker", "nginx", "python", "traffic", "uwsgi" ]

[ "To the function, review_to_sent(row) you are not passing the whole row, you are passing only the row values of a particular column called sentiment so\nMethod 1:\nChange calling methodology by doing apply on dataframe like\ndf.apply(Review_to_Sent(row))\n\nMethod 2:\nRemove row[‘sentiment’] from the check condition.\n" ]

[ 0 ]

[]

[]

[ "csv", "pandas", "python" ]

[ "Just rearrange, such as\nc = [j if item>0 else 99 for j, item in enumerate(b)]\n\nproduces\n[99, 1, 99, 3, 99, 5, 99, 7, 99]\n\n" ]

[ 1 ]

[]

[]

[ "python" ]

[ "I was debugging it wrong. I spent last 5 hours trying to figure this out. Thanks to everyone who mentioned the comment!\nfor anyone experiencing the same issue, when you are debugging using a launch.json file. make sure your args are like this \"args\": [\n\"--serviceA\", \"--activate\"\n],\nI had set up args like this \"--serviceA --activate\"\n" ]

[ 0 ]

[]

[]

[ "argparse", "arguments", "command_line", "command_line_arguments", "python" ]

[ "You should use the re.MULTILINE flag to search multiple lines\nimport re\npattern = r\"(c\\nd)\"\nstring = \"\"\"\na\nb\nc\nd\ne\nf\n\"\"\"\n\nmatch = re.search(pattern, string, flags=re.MULTILINE)\nprint(match)\n\nTo get the start line, you could count the newline characters as follows\nstart, stop = match.span()\nstart_line = string[:start].count('\\n')\n\nYou could do the same for the end_line, or if you know how many lines is your pattern, you can just add this info to avoid counting twice.\nTo also get the start column, you can check the line itself, or a pure regex solution could also look line:\npattern = \"(?:.*\\n)*(\\s*(c\\s*\\n\\s*d)\\s*)\"\nmatch = re.match(pattern, string, flags=re.MULTILINE)\nstart_column = match.start(2) - match.start(1)\nstart_line = string[:match.start(1)].count('\\n')\nprint(start_line, start_column)\n\nHowever, I think difflib could be more useful here.\n" ]

[ 0 ]

[]

[]

[ "match", "python", "python_re" ]

[ "jq --slurpfile patch patch.json '\n (.spec.containers |= map(.command |= (. + $patch[].spec.containers[0].command | unique) |\n .volumeMounts |= (. + $patch[].spec.containers[0].volumeMounts | unique))) |\n (.spec.volumes |= (. + $patch[].spec.volumes | unique))\n' kube-apiserver.json\n\nI have added unique to ensure that commands, volumeMounts and volumes only appear once. This has the side effect of sorting the arrays.\nYou can remove unique if you do not want it.\nThere is a problem in your question: spec.containers is an array. In your example, this array contains only one element and my code adds the first element from the patch to each container.\nOr would you like the patch to be merged based on position? In that case this solution does not work.\n" ]

[ 0 ]

[]

[]

[ "jq", "json", "python", "text_processing" ]

[ "Yes! You can leverage the setUp/tearDown methods of the unittest.TestCase and the fact that unittest.mock.patch in its \"pure\" form (i.e. not as context manager or decorator) returns a \"patcher\" object that has start/stop methods to control when exactly it should do its magic.\nYou can call on the patcher to start inside setUp and to stop inside tearDown and if you keep a reference to it in an attribute of your test case, you can easily stop it manually in selected test methods. Here is a full working example:\nfrom unittest import TestCase\nfrom unittest.mock import patch\n\n\nclass Foo:\n @staticmethod\n def bar() -> int:\n return 1\n\n\nclass TestMyThing(TestCase):\n def setUp(self) -> None:\n self.foo_bar_patcher = patch.object(Foo, \"bar\", return_value=42)\n self.mock_foo_bar = self.foo_bar_patcher.start()\n super().setUp()\n\n def tearDown(self) -> None:\n self.foo_bar_patcher.stop()\n super().tearDown()\n\n def test_a(self):\n self.assertEqual(42, Foo.bar())\n\n def test_b(self):\n self.assertEqual(42, Foo.bar())\n\n def test_c(self):\n self.assertEqual(42, Foo.bar())\n\n def test_d(self):\n self.foo_bar_patcher.stop()\n self.assertEqual(1, Foo.bar())\n\nThis patching behavior is the same, regardless of the different variations like patch.object (which I used here), patch.multiple etc.\nNote that for this example it is not necessary to keep a reference to the actual MagicMock instance generated by the patcher in an attribute, like I did with mock_foo_bar. I just usually do that because I often want to check something against the mock instance in my test methods.\nIt is worth mentioning that you can also use setUpClass/tearDownClass for this, but then you need to be careful with re-starting the patch, if you stop it because those methods are (as the name implies) only called once for each test case, whereas setUp/tearDown are called once before/after each test method.\nPS: The default implementations of setUp/tearDown on TestCase do nothing, but it is still good practice IMO to make a habit of calling the superclass' method, unless you deliberately want to omit that call.\n" ]

[ 1 ]

[]

[]

[ "python", "python_unittest", "unit_testing" ]

[ "If you're dfoing the looping in Python, as you are doing here, then you don't need to do any looping in Javascript. The HTML you create will already have all of the data enumerated:\ndf2 = ['Sat Nov 12 11:57:21 CST 2022',\n 'Wed Nov 23 18:13:31 CST 2022',\n 'Wed Nov 23 18:13:32 CST 2022',\n 'Thu Nov 10 19:07:50 CST 2022',\n 'Fri Nov 11 09:54:54 CST 2022',\n 'Fri Nov 11 10:18:36 CST 2022',\n 'Sat Nov 26 10:50:05 CST 2022',\n 'Sat Nov 12 11:57:50 CST 2022']\n\n\n\nf.write(''' \n <html>\n <head> \n <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"> \n </head> \n <body> \n''')\n\nfor count, value in enumerate(df2):\n f.write(''' \n <div id=\"myHTMLWrapper\"> '''+value+''' </div>\n '<button class=\"test\">'''+value+'''</button>';\n ''')\n\nf.write('''\n </body>\n</html>\n''')\n\n" ]

[ 2 ]

[]

[]

[ "html", "javascript", "loops", "python" ]

[ "It looks like the issue you are experiencing is that when you try to access the values of the aqi_parameter dictionary in your template, you are using the string names of the dictionary keys instead of the keys themselves.\nFor example, in your template, you are trying to access the coordinates value by using aqi_parameter.coordinates, but this will not work because coordinates is not a property of the aqi_parameter object. Instead, you need to use the square bracket notation to access the values of the dictionary, like this: aqi_parameter['coordinates'].\nHere is an example of how you can access the values of the aqi_parameter dictionary in your template:\n<p>Coordinates: {{ aqi_parameter['coordinates'] }}</p>\n<p>Temperature: {{ aqi_parameter['temperatureC'] }}</p>\n<p>Pressure: {{ aqi_parameter['pressure'] }}</p>\n<p>Humidity: {{ aqi_parameter['humidity'] }}</p>\n<p>AQI: {{ aqi_parameter['aqius'] }}</p>\n\n" ]

[ 0 ]

[]

[]

[ "api", "class", "function", "python" ]

[ "There's the function .equals()\ndf1['system_id'].equals(df2f['systemID'])\n\nwhich will return a boolean\n" ]

[ 0 ]

[]

[]

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

[ "Don't use floats if you can avoid it, this is just how they work:\n>>> print (\"%40.18f\\n\" % (1669836415.8800698))\n **1669836415.880069732666015625 <<<< the actual value**\n\n>>> print (\"%40.7f\\n\" % (1669836415.8800698))\n **1669836415.8800697 <<<< the rounded value**\n\n" ]

[ 0 ]

[]

[]

[ "floating_point", "precision", "python" ]

[ "Given the path is not being utilized, it is being overridden by a shell alias. This can be confirmed by typing set | grep python\nIf you are using virtualenv:\nTry: /usr/bin/python3 -m venv python3.8.9\nThe common MacOS python managers are:\n\npythonz\n\nList installs using pythonz list\nChange using: /usr/bin/python3 -m venv python3.8.9\n\npythonbrew\n\nList installs pythonbrew list\nUse pythonbrew switch 3.8.9 to move to the new version.\n\npyenv\n\nClaims to use only $PATH. Included for completeness, but just in case\nList installs pyenv versions\nUse pyenv global 3.8.9 to move to the new version.\n\nTo remove any of these remove the appropriate line from your ~/.bashrc or ~/.zshrc file.\nYou can locate the line with grep ~/.bashrc python.\n", "I can give you some general troubleshooting tips and a band-aid that can replace a symlink.\n$(which python) -V\n\nThis should get you the version for python3.\nOther thing worth checking:\nwhich python2\n\nThis should point to some standard location, /usr/bin/python2 for example. If it isn't pointed there, might be worth understanding why.\nIn general, Macs have some quirks. The fact that a new MacBook M4 ships with Python2 as the default is a smell that you probably shouldn't try to overwrite the default value, and for whatever reason it doesn't seem to want you to.\nSimple answer: set an alias.\necho 'alias python=\"python3\"' >> ~/.zshrc && source;\n\nThis will work for you and should not interfere with any potential other systems.\nBetter answer:\nAs others have described, create a virtual environment and source venv/bin/activate.\n", "I simply created a symlink where the actual\npython -V is located.\nExecute the following commands:\n\ntype python#in my case was /usr/bin/python3which is a symlink to the installed version. It appears in cyan color. Change the directory, switch there.\ncd /usr/bin/ (where the python3 is, and let's list for the python words\nls pyth* #in my case was python3 and python3.10\nHow to make a symlink:\nln [OPTION]... [-T] TARGET LINK_NAME\nsudo ln -s python3.10 python\n\nYou'll have a simplest symlink without a number at the end.\n\nLets try: python\n\nOptionally you can remove the one with the number at the end.\n" ]

[ 4, 3, 0 ]

[]

[]

[ "apple_m1", "python", "symlink", "unix" ]

[ "Since you're dealing with xml, you should use a proper xml parser. Note that in this case you have to deal with namespaces as well.\nSo try this:\nfrom lxml import etree\n#load your file\ndoc = etree.parse(\"users.xml\")\n#declare namespaces\nns = {'xx': 'WebsiteWhereDataComesFrom.com'}\n\n#locate your deletion targets\ntargets = doc.xpath('//xx:user[xx:active=\"false\"]',namespaces=ns)\nfor target in targets:\n target.getparent().remove(target)\n\n#save your file\nwith open(\"newfile.xml\", 'a') as file:\n file.write(etree.tostring(doc).decode())\n\nThis should have your expected output.\n" ]

[ 0 ]

[]

[]

[ "python", "xml" ]

[ "To create a category tree in Python, you can define a CategoryTree class that has the following methods:\n\nadd_category(name: str, parent: Optional[str]): This method should add a new category with the given name and parent to the category tree. If a null value is provided as the parent, the category should be added as a root category.\nget_children(name: str): This method should return the direct children of the category with the given name in any order.\ninvalid_argument_exception(name: str): This method should raise an InvalidArgumentException exception when adding a category that has already been added anywhere in the CategoryTree or if a parent is specified but does not exist.\nHere is an example of how you can implement this CategoryTree class:\n\nclass CategoryTree:\n def __init__(self):\n self.categories = {}\n\n def add_category(self, name: str, parent: Optional[str]):\n if name in self.categories:\n self.invalid_argument_exception(f\"Category {name} already exists\")\n\n if parent is not None and parent not in self.categories:\n self.invalid_argument_exception(f\"Parent {parent} does not exist\")\n\n self.categories[name] = parent\n\n def get_children(self, name: str):\n children = []\n for category, parent in self.categories.items():\n if parent == name:\n children.append(category)\n return children\n\n def invalid_argument_exception(self, message: str):\n raise InvalidArgumentException(message)\n\nIn the code above, the CategoryTree class has a dictionary categories that stores the name and parent of each category. The add_category() method first checks if the given category name already exists in the categories dictionary. If it does, it raises an InvalidArgumentException with an appropriate error message. It then checks if the given parent exists in the categories dictionary. If it does not, it raises an InvalidArgumentException with an appropriate error message. Finally, it adds the category to the categories dictionary.\nThe get_children() method iterates over the categories dictionary and returns all the categories whose parent is the given category name.\nThe invalid_argument_exception() method simply raises an InvalidArgumentException with the given error message.\nYou can use this CategoryTree class as follows:\ntree = CategoryTree()\ntree.add_category(\"fruit\", None)\ntree.add_category(\"vegetable\", None)\ntree.add_category(\"apple\", \"fruit\")\ntree.add_category(\"banana\", \"fruit\")\ntree.add_category(\"carrot\", \"vegetable\")\ntree.add_category(\"tomato\", \"vegetable\")\n\nprint(tree.get_children(\"fruit\")) # [\"apple\", \"banana\"]\nprint(tree.get_children(\"vegetable\")) # [\"carrot\", \"tomato\"]\n\nIn the code above, we first create a CategoryTree object and add several categories to it. We then print the direct children of the \"fruit\" and \"veget\ntree = CategoryTree()\ntree.add_category(\"fruit\", None)\ntree.add_category(\"vegetable\", None)\ntree.add_category(\"apple\", \"fruit\")\ntree.add_category(\"banana\", \"fruit\")\ntree.add_category(\"carrot\", \"vegetable\")\ntree.add_category(\"tomato\", \"vegetable\")\n\nprint(tree.get_children(\"fruit\")) # [\"apple\", \"banana\"]\nprint(tree.get_children(\"vegetable\")) # [\"carrot\", \"tomato\"]\n\n" ]

[ 0 ]

[]

[]

[ "exception", "python", "tree" ]

[ "This can be caused by the two sides of the connection disagreeing over whether the connection timed out or not during a keepalive. (Your code tries to reused the connection just as the server is closing it because it has been idle for too long.) You should basically just retry the operation over a new connection. (I'm surprised your library doesn't do this automatically.)\n", "I know this is a very old question but it may be that you need to set the request headers. This solved it for me.\nFor example 'user-agent', 'accept' etc. here is an example with user-agent:\nurl = 'your-url-here'\nheaders = {'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.75 Safari/537.36'}\nr = requests.get(url, headers=headers)\n\n", "there are many causes such as \n\nThe network link between server and client may be temporarily going down.\nrunning out of system resources.\nsending malformed data.\n\nTo examine the problem in detail, you can use Wireshark.\nor you can just re-request or re-connect again.\n", "For me this problem arised while trying to connect to the SAP Hana database. When I got this error, \nOperationalError: Lost connection to HANA server (ConnectionResetError(10054, 'An existing connection was forcibly closed by the remote host', None, 10054, None))\nI tried to run the code for connection(mentioned below), which created that error, again and it worked. \n\n\n import pyhdb\n connection = pyhdb.connect(host=\"example.com\",port=30015,user=\"user\",password=\"secret\")\n cursor = connection.cursor()\n cursor.execute(\"SELECT 'Hello Python World' FROM DUMMY\")\n cursor.fetchone()\n connection.close()\n\n\nIt was because the server refused to connect. It might require you to wait for a while and try again. Try closing the Hana Studio by logging off and then logging in again. Keep running the code for a number of times.\n", "I got the same error ([WinError 10054] An existing connection was forcibly closed by the remote host) with websocket-client after setting ping_interval = 2 in websocket.run_forever(). (I had multiple threads connecting to the same host.)\nSetting ping_interval = 10 and ping_timeout = 9 solved the issue. May be you need to reduce the amount of requests and stop making host busy otherwise it will forcibly disconnect you.\n", "I fixed it with a while try loop, waiting for the response to set the variable in order to exit the loop.\nWhen the connection has an exception, it waits five seconds, and continues looking for the response from the connection.\nMy code before fix, with the failed response HTTPSConnectionPool(host='etc.com', port=443): Max retries exceeded with url: / (Caused by ConnectTimeoutError(<urllib3.connection.HTTPSConnection object at 0x000001E9955A2050>, 'Connection to example.net timed out. (connect timeout=None)'))\n \n\nfrom __future__ import print_function\nimport sys\nimport requests\n\n\ndef condition_questions(**kwargs):\n proxies = {'https': 'example.com', 'http': 'example.com:3128'}\n print(kwargs, file=sys.stdout)\n headers = {'etc':'etc',}\n body = f'''<etc>\n </etc>'''\n\n try:\n response_xml = requests.post('https://example.com', data=body, headers=headers, proxies=proxies)\n except Exception as ex:\n print(\"exception\", ex, file=sys.stdout)\n log.exception(ex)\n finally:\n print(\"response_xml\", response_xml, file=sys.stdout)\n return response_xml\n\nAfter fix, with successful response response_xml <Response [200]>:\n\nimport time\n...\n\nresponse_xml = ''\n while response_xml == '':\n try:\n response_xml = requests.post('https://example.com', data=body, headers=headers, proxies=proxies)\n break\n except Exception as ex:\n print(\"exception\", ex, file=sys.stdout)\n log.exception(ex)\n time.sleep(5)\n continue\n finally:\n print(\"response_xml\", response_xml, file=sys.stdout)\n return response_xml\n\nbased on Jatin's answer here --\"Just do this,\nimport time\n\npage = ''\nwhile page == '':\n try:\n page = requests.get(url)\n break\n except:\n print(\"Connection refused by the server..\")\n print(\"Let me sleep for 5 seconds\")\n print(\"ZZzzzz...\")\n time.sleep(5)\n print(\"Was a nice sleep, now let me continue...\")\n continue\n\nYou're welcome :)\"\n" ]

[ 24, 15, 13, 2, 2, 0 ]

[]

[]

[ "python", "twitter", "web_crawler" ]

[ "The checkbutton has a documented method named deselect which does what the name implies.\nif timer >= timer_interval_minutes:\n self.timer.deselect()\n\n" ]

[ 1 ]

[]

[]

[ "python", "tkinter" ]

[ "I was given an answer, I hope that someone who faces the same problem will find this topic\nsheduler.add_job(thread_maintaining_communication,\"interval\", seconds=20)\nbot.add_custom_filter(asyncio_filters.StateFilter(bot))\nsheduler.start()\nloop = asyncio.get_event_loop() \nloop.run_until_complete(bot.polling(skip_pending=True))\n\n" ]

[ 0 ]

[]

[]

[ "apscheduler", "asynchronous", "python" ]

[ "IIUC you need a column that represents the size of each group in each row. Then you need to use groupby.transform.\ndf[\"group_size\"] = (\n df.assign(group_size=1)\n .groupby([\"user_id\", \"artist_id\"])[\"group_size\"]\n .transform(\"count\")\n)\n\n" ]

[ 0 ]

[]

[]

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

[ "Finally found a question that lead me to a solution, but I still welcome feedback and comments!\nThis question:\nhttps://softwareengineering.stackexchange.com/q/243044\n(they asked which is preferred)\nasks about single python file distribution where you have a file foo.py which has an internal thing (function,class,etc) called useful_thing\nThey provide 2 file architectures so one could use from foo import useful_thing\n(which would also allow the functionality of:\nimport foo\nfoo.useful_thing\n\n)\nThe file structures they provide in their question are:\n$ tree -a ./foo_folder/\n./foo_folder/\n├── setup.py\n├── README.rst\n├── ...etc...\n└── foo.py\n\n0 directories, 4 files\n\nand\n$ tree -a ./foo_folder/\n./foo_folder/\n├── setup.py\n├── README.rst\n├── ...etc...\n└── foo\n ├── module.py\n └── __init__.py\n\n2 directories, 4 files\n\nwhere useful_thing is defined in module.py and the contents of __init__.py would be:\nfrom foo.module import useful_thing\n\nThis question and the answer:\nhttps://softwareengineering.stackexchange.com/a/243045\n(which says: use whichever works for you)\nProvides a couple of example packages that are distributions of just one module. Specifically https://pypi.org/project/six/ which I used the structure to get my tool working as both a CLI tool and import.\nThis was the final result:\n$ tree ./mytool/\n./mytool/\n├── mytool.egg-info\n│   ├── dependency_links.txt\n│   ├── entry_points.txt\n│   ├── PKG-INFO\n│   ├── requires.txt\n│   ├── SOURCES.txt\n│   └── top_level.txt\n├── mytool_helper.py\n├── mytool.py\n└── setup.py\n\n1 directory, 9 files\n\ncontents of setup.py:\n\"\"\"\nThe setup module for mytool\n\"\"\"\n\n# To use a consistent encoding\nfrom os import path\n\n# Always prefer setuptools over distutils\nfrom setuptools import setup, find_packages\n\nimport mytool # NOTE: this is importing the file\n\nversion = '0.0.2'\n\nhere = path.abspath(path.dirname(__file__)) # NOTE: This is leftover, I should probably prune\n\nsetup(\n name='mytool',\n version=version,\n\n description='Do stuff with a string',\n\n\n #packages=find_packages(), # NOTE: I commented this because I don't think it's technically a \"package\" anymore just a moduel\n py_modules=['mytool'],\n\n classifiers=[\n 'Programming Language :: Python :: 3'\n ],\n install_requires=[\n 'argparse',\n 'pyyaml'\n ],\n extras_require={\n },\n entry_points={\n 'console_scripts': [\n 'mytool=mytool:main' # NOTE: have to change this here because the file structure is different\n ]\n }\n)\n\ncontents of mytool.py (simplified):\nimport json\nimport argparse\n\nfrom mytool_helper import HelperClass # NOTE:You just import the helper file/module directly here rather than as a module as part of a package.\n\n# various string manipulation functions\n#...\n\ndef process_string(in_string):\n result = HelperClass.parse_string(in_string)\n # Do stuff with string\n return result.to_string()\n\n\ndef main():\n # This just gets the input via argparse\n input_string = _get_input_string()\n result_string = process_string(input_string)\n print(json.dumps(result_string, indent=4, default=str))\n\n\nif __name__ == \"__main__\":\n main()\n\nWhich allows for it to be installed in an editable manner with pip:\npip install -e /home/user/project/mytool/\n\nThe CLI usage: mytool string_to_process\nIn script:\n\nimport mytool\nresult = mytool.process_string(\"string_to_process\")\n\nI may have still confused terms here, but this should help someone with structure and file contents.\nI should probably also explain some of the other pieces, or provide links, for things like how to make the CLI part of the tool (https://setuptools.pypa.io/en/latest/userguide/entry_point.html)\n" ]

[ 0 ]

[]

[]

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

[ "Since the turtle draws from a edge, we need to move the turtle to compensate for the radius of the entire image. To simplify this move, we align the starting point of the image with one (X) axis. We also switch from absolute coordinates (setheading()) to relative coordinates (right()) so our initial rotational offset doesn't get lost or need to be added to every position:\nimport turtle\nimport math\n\nradius = 50\nnum_of = 13\n\ndef flower():\n outer_radius = radius * 3.5 / math.pi\n\n turtle.penup()\n turtle.setx(-outer_radius) # assumes heading of 0\n turtle.pendown()\n\n turtle.right(180 / num_of)\n\n for _ in range(num_of):\n turtle.right(180 - 360 / num_of)\n turtle.circle(radius * 3.5 / num_of, 180)\n\nturtle.speed('fastest')\nturtle.dot() # mark turtle starting location\n\nflower()\n\nturtle.hideturtle()\nturtle.done()\n\n\nTo get the radius of the flower, we add up the diameters of all the petals and use the standard circumference to radius formula. There are probably simplifications, math-wise and code-wise, we could make.\n" ]

[ 1 ]

[]

[]

[ "flower", "python", "python_turtle", "turtle_graphics" ]

[ "I am having this issue too. What I have learned is that in the Metadata field there is DockerBuildArgs: that you can also add. Example:\n Metadata:\n DockerBuildArgs:\n MY_VAR: <some variable>\n\nWhen I add this it does make it to the DockerBuildArgs dict.\n" ]

[ 1 ]

[]

[]

[ "amazon_web_services", "aws_lambda", "aws_sam_cli", "docker", "python" ]

[ "c should not be a global. You need to rebuild it from scratch every time the button is clicked. adej also does not need to be a global.\nThis works. Also, delete the global definitions of c and adej.\ndef receipt():\n c = []\n if feature1.get() == 1:\n c.append(\"Pizza\")\n if feature2.get() == 1:\n c.append(\"Hamburger\")\n if feature3.get() == 1:\n c.append(\"Cola\")\n adej = \"You've ordered \" + ' '.join(c)\n label1.config(text=adej)\n\n" ]

[ 1 ]

[]

[]

[ "python", "tkinter" ]

[ "You can set a group on your extension view:\n<field name=\"groups_id\" eval=\"[(4,ref('helpdesk.group_helpdesk_user'))]\"/>\nWill look like this:\n<odoo>\n <data>\n <record id=\"helpdesk_ticket_smart_button\" model=\"ir.ui.view\">\n <field name=\"name\">partner.helpdesk.ticket.smart.buttons</field>\n <field name=\"model\">res.partner</field>\n <field name=\"inherit_id\" ref=\"base.view_partner_form\" />\n <field name=\"groups_id\" eval=\"[(4,ref('helpdesk.group_helpdesk_user'))]\"/>\n <field name=\"arch\" type=\"xml\">\n <div name=\"button_box\" position=\"inside\">\n <button class=\"oe_stat_button\" type=\"object\" name=\"action_view_helpdesk_tickets\" icon=\"fa-ticket\">\n <field string=\"Tickets\" name=\"helpdesk_ticket_count\" widget=\"statinfo\"/>\n </button>\n </div>\n </field>\n </record>\n </data>\n</odoo>\n\nOdoo will only load the extension view for users in the groups that are set on the view.\n", "While the answer provided by CZoellner should indeed work, another and more robust solution would be to add a groups attribute to your button definition:\n<button class=\"oe_stat_button\" type=\"object\" name=\"action_view_helpdesk_tickets\" groups=\"helpdesk.group_helpdesk_user\">\n <field string=\"Tickets\" name=\"helpdesk_ticket_count\" widget=\"statinfo\"/>\n</button>\n\nThe reason this solution is more robust in my opinion is because you or some of your collegues may later want to add some more changes to this view, but those changes may have to be available for everybody.\n" ]

[ 1, 1 ]

[]

[]

[ "access_rights", "odoo", "odoo_14", "python" ]

[ "using partial from functools to create a new function that only takes the first argument.\nfrom functools import partial\n\ndef get_service_enums(context, enum):\n print(context, enum)\n\npartial_function = partial(get_service_enums, enum=\"second_thing\")\npartial_function(\"first_thing\")\n\nfirst_thing second_thing\n\n", "Does it not work for you to pass the function and its argument separately\nColumnDef(enum_values=get_service_enums, enum)\n\nwith the class ColumnDef in charge of passing in enum when the function is invoked?\nIf not, functools.partial is your friend:\nimport functools\n\n# New version of get_service_enums with enum = 42\nmy_func = functools.partial(get_service_enums, enum=42)\nmy_func('hello') # hello, 42\n\nColumnDef(enum_values=my_func)\n\n" ]

[ 1, 1 ]

[]

[]

[ "python", "python_3.x" ]

[ "can you try this:\ndf = df.applymap(lambda s: s.lower() if type(s) == str else s) #lower string values\ndf.columns = df.columns.str.lower() #lower for columns\ndf['name']=df['name'].str.replace(r'\\W+', '') #remove any non-word character\n\n#output\n'''\n name date status number\n0 abcdef 2022-07-11 yes io123-07\n1 ghijkl 2022-07-12 no io456-08\n'''\n\n" ]

[ 0 ]

[]

[]

[ "datetime", "nlp", "python", "python_regex" ]

[ "One workaround might be to use apply to get the DataFrame.sum:\ndf.groupby(level=0, axis=1).apply(lambda x: x.sum(axis=1, skipna=False))\n\nOutput:\n a b\n0 3.0 2.0\n1 NaN 2.0\n\n", "Another possible solution:\ncols, ldf = df.columns.unique(), len(df)\n\npd.DataFrame(\n np.reshape([sum(df.loc[i, x]) for i in range(ldf) for x in cols],\n (len(cols), ldf)), \n columns=cols)\n\nOutput:\n a b\n0 3.0 2.0\n1 NaN 2.0\n\n" ]

[ 2, 0 ]

[]

[]

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

[ "Do not create the font object in each frame. Creating a font object is a very expensive operation because the font must be read from the resource and decoded. Create the font before the application loop, but use it in the application loop:\nmyfont = pygame.font.SysFont(\"monospace\", 15) # <-- INSERT\n\ndone = False\nwhile not done:\n # [...]\n\n # myfont = pygame.font.SysFont(\"monospace\", 15) <-- DELETE\n\n" ]

[ 0 ]

[]

[]

[ "pygame", "pysdl2", "python" ]

[ "In order to receive all data from a connection in socketserver, you can use the makefile method of the socket object. This method returns a file-like object that can be used to read data from the connection. Here is an example of how you could use this method to receive all data from the connection:\nclass ConnectionHandler(BaseRequestHandler):\n\ndef handle(self):\n # Use the makefile method to get a file-like object for the connection\n file_like_obj = self.request.makefile('rb')\n # Read all data from the file-like object\n data = file_like_obj.read()\n print(data.decode())\n\nThis approach allows you to read all data from the connection without having to manually manage the receive buffer. Additionally, since the makefile method returns a file-like object, you can use the familiar file operations like read, readline, and readlines to read data from the connection.\nHowever, keep in mind that using the makefile method to read data from the connection will consume the data from the receive buffer. This means that if you also want to use the recv method to read data from the connection, you will need to call the recv method before calling the makefile method.\nIn your specific example, it looks like you are using SSL to encrypt the data that is sent over the connection. In this case, you should use the SSL_makefile method instead of the makefile method in order to get a file-like object for the connection. This method is similar to the makefile method, but it is used for SSL connections. Here is an example of how you could use the SSL_makefile method to receive all data from an SSL connection:\nclass ConnectionHandler(BaseRequestHandler):\n\ndef handle(self):\n # Use the SSL_makefile method to get a file-like object for the SSL connection\n file_like_obj = self.request.SSL_makefile('rb')\n # Read all data from the file-like object\n data = file_like_obj.read()\n print(data.decode())\n\nI hope this helps. Let me know if you have any questions.\n", "Using self.request.recv() without an actual value on how many bytes to read seems to obtain the whole buffer from the client\n" ]

[ 2, 0 ]

[]

[]

[ "python", "recv", "socketserver", "tcp" ]

[ "wrfpython's getvar function, while it takes units as a parameter, only uses this (as far as I can tell) to convert values in the arrays before returning them. To use this with MetPy you need to attach proper units. I would do this using a small helper function:\nfrom metpy.units import units\n\ndef metpy_getvar(file, name, units_str):\n return getvar(file, name, units=units_str) * units(units_str)\n\nz = metpy_getvar(ncfile, \"z\", units=\"m\")\nua = metpy_getvar(ncfile, \"ua\", units=\"m s-1\")\nva = metpy_getvar(ncfile, \"va\", units=\"m s-1\")\n\nThat should eliminate the complaints about missing units.\nEDIT: Fix name collision in hastily written function.\n", "I've made some progress: an updated script and the resulting plot are included below. Part of the problem was that I needed to pass dx, dy, and lat into the function metpy.calc.geostrophic_wind, as they were seemingly not being read automatically from the numpy array.\nThere are still (at least) two problems:\nI've passed x_dim=-2 and y_dim=-1 in an effort to set [X,Y] order. (The documentation here https://unidata.github.io/MetPy/latest/api/generated/metpy.calc.geostrophic_wind.html says the default is x_dim = -1 and y_dim=-2 for [...Y,X] order, but does not say what to set x_dim and y_dim to for [...X,Y] order, so I just guessed.) However, I am still getting ``UserWarning: Horizontal dimension numbers not found. Defaulting to (..., Y, X) order.''\nSecondly, as you can see in the plot there is something weird going on with the geostrophic wind component at the coastlines.\nu-component of geostrophic wind at 300 mb\nHere is my current script:\nimport numpy as np\nfrom netCDF4 import Dataset\nimport metpy.calc as mpcalc\nfrom metpy.units import units\nimport matplotlib.pyplot as plt\nfrom matplotlib.cm import get_cmap\n\nfrom wrf import getvar, interplevel, to_np, get_basemap, latlon_coords\n\n# Open the NetCDF file\nfilename = \"wrfout_d01_2016-10-04_12:00:00\"\nncfile = Dataset(filename)\n\nz = getvar(ncfile, \"z\", units=\"m\") * units.meter\n\n# Smooth height data\nz = mpcalc.smooth_gaussian(z, 3)\n\ndx = 4000.0 * units.meter\ndy = 4000.0 * units.meter\n\nlat = getvar(ncfile, \"lat\") * units.degrees\n\ngeo_wind_u, geo_wind_v = mpcalc.geostrophic_wind(z,dx,dy,lat,x_dim=-2,y_dim=-1)\n\n#####\n\np = getvar(ncfile, \"pressure\")\nz = getvar(ncfile, \"z\", units=\"m\")\n\nht_300 = interplevel(z, p, 300)\n\n#geostrophic wind components on 300 mb level\ngeo_wind_u_300 = interplevel(geo_wind_u, p, 300)\ngeo_wind_v_300 = interplevel(geo_wind_v, p, 300)\n\n# Get the lat/lon coordinates\nlats, lons = latlon_coords(ht_300)\n\n# Get the basemap object\nbm = get_basemap(ht_300)\n\n# Create the figure\nfig = plt.figure(figsize=(12,12))\nax = plt.axes()\n\n# Convert the lat/lon coordinates to x/y coordinates in the projection space\nx, y = bm(to_np(lons), to_np(lats))\n\n# Add the 300 mb height contours\nlevels = np.arange(8640., 9690., 40.)\ncontours = bm.contour(x, y, to_np(ht_300), levels=levels, colors=\"black\")\nplt.clabel(contours, inline=1, fontsize=10, fmt=\"%i\")\n\n# Add the wind contours\nlevels = np.arange(10, 70, 5)\ngeo_u_contours = bm.contourf(x, y, to_np(geo_wind_u_300), levels=levels, cmap=get_cmap(\"YlGnBu\"))\nplt.colorbar(geo_u_contours, ax=ax, orientation=\"horizontal\", pad=.05, shrink=0.75)\n\n# Add the geographic boundaries\nbm.drawcoastlines(linewidth=0.25)\nbm.drawstates(linewidth=0.25)\nbm.drawcountries(linewidth=0.25)\n\nplt.title(\"300 mb height (m) and u-component of geostrophic wind (m s-1) at 1200 UTC on 04-10-2016\", fontsize=12)\n\nplt.savefig('geo_u_300mb_04-10-2016_1200_smoothed.png', bbox_inches='tight')\n\n", "The data presented by raw WRF-ARW datasets and by variables extracted via wrf-python do not have metadata that interact well with MetPy's assumptions about unit attributes, coordinate variables, and grid projections (from the CF Conventions). Instead, I would recommend using xwrf, a recently released package for working with WRF data in a more CF-Conventions-friendly way. With xwrf, your example would look like:\nimport metpy.calc as mpcalc\nimport xarray as xr\nimport xwrf\n\n# Open the NetCDF file\nfilename = \"wrfout_d01_2016-10-04_12:00:00\"\nds = xr.open_dataset(filename).xwrf.postprocess()\n\n# Extract the geopotential height and wind variables\nz = ds['geopotential_height']\nua = ds['wind_east']\nva = ds['wind_north']\n\n# Smooth height data\nz = mpcalc.smooth_gaussian(z, 3)\n\n# Compute the geostrophic wind\ngeo_wind_u, geo_wind_v = mpcalc.geostrophic_wind(z)\n\n# Calculate ageostrophic wind components\nageo_wind_u = ua - geo_wind_u\nageo_wind_v = va - geo_wind_v\n\n" ]

[ 2, 0, 0 ]

[]

[]

[ "metpy", "python", "python_xarray" ]

[ "In python, the exponent operator is not ^ but **. The ^ operator is actually the bitwise XOR operator.\n" ]

[ 0 ]

[]

[]

[ "exponent", "python", "variable_assignment" ]

[ "its resolved now. I just tried to use %pip install transformers==3.4.0, instead of !pip install transformers==3.4.0 in jupyter book, and it worked. I can proceed with the project for now. Although I don't know what I did wrong in my python command line earlier that caused the inconsistency. Will open a new thread.\n" ]

[ 0 ]

[]

[]

[ "jupyter_notebook", "python" ]

[ "You need to enable message Intents in the Discord site, then specify the messages intent in the code. That should work for you.\n" ]

[ 0 ]

[]

[]

[ "asynchronous", "discord.py", "heroku", "python" ]

[ "You can index np.lib.stride_tricks.sliding_window_view using your x and y indices:\nimport numpy as np\n\nh = np.arange(49).reshape(7,7)\n\nx_indices = np.array([1,3,4])\ny_indices = np.array([2,3,5])\n\na = 1\nwindow = (2*a+1, 2*a+1)\n\nout = np.lib.stride_tricks.sliding_window_view(h, window)[x_indices-a, y_indices-a]\n\nout:\narray([[[ 1, 2, 3],\n [ 8, 9, 10],\n [15, 16, 17]],\n\n [[16, 17, 18],\n [23, 24, 25],\n [30, 31, 32]],\n\n [[25, 26, 27],\n [32, 33, 34],\n [39, 40, 41]]])\n\nNote that you may need to pad h first to handle windows around your coordinates that reach \"outside\" h.\n" ]

[ 4 ]

[]

[]

[ "array_broadcasting", "numpy", "numpy_slicing", "python" ]

[ "Basically, as far as I can see, you have two meaningful columns in your DataFrame.\nThus, I would suggest using \"Index\" column as the index indeed:\ndf.set_index(df.columns[0], inplace=True)\n\nThat way you might use .loc:\ndf_out = pd.concat(\n [\n df.loc[first_position, \"Column A\"].reset_index(drop=True),\n df.loc[last_position, \"Column B\"].reset_index(drop=True)\n ],\n axis=1\n)\n\nHowever, having indexes stored in separate lists you would need to watch them yourselves, which may be not too convenient.\nInstead, I would re-organize it with slicing:\ndf_out = pd.concat(\n [\n df[[\"Column A\"]][:-1].reset_index(drop=True),\n df[[\"Column B\"]][1:].reset_index(drop=True)\n ],\n axis=1\n)\n\nIn either cases, index is being destroyed. If that matters, then the scenario without .reset_index(drop=True) would be required.\n" ]

[ 1 ]

[]

[]

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

[ "In line 21 call for a class method is made without using the self keyword.\n x = self.getItemClassiness(item)\n\nSimilarly on line 8 in self keyword is required with as parameter for function definition of getItemClassiness\ndef getItemClassiness(self, item):\n\n", "You should declare getItemClassiness as a static method because it doesn't require a specific instance. Then you can call the function as you would an instance method.\n @staticmethod\n def getItemClassiness(item):\n ...\n \n \n def getClassiness(self):\n ...\n for item in self.items:\n x = self.getItemClassiness(item)\n\nBut still it won't give you 15 for the last test case, because \"bowtie\" != \"bowtie\\n\". If you intend to ignore white space at the start or the end of the string, use str.strip().\n", "Here is what I did using Static Method. Got the right output in Test Cases.\nclass Classy(object):\ndef __init__(self):\n self.items = []\n \ndef addItem(self, item):\n self.items.append(item)\n \n@staticmethod\ndef getItemClassiness(item):\n if item == \"tophat\":\n return 2\n if item == \"bowtie\":\n return 4\n if item == \"monocle\":\n return 5\n return 0\n\n\ndef getClassiness(self):\n total = 0\n for item in self.items:\n x = self.getItemClassiness(item)\n total += x\n return total\n\n" ]

[ 0, 0, 0 ]

[]

[]

[ "function", "python" ]

[ "Your mistake is thinking execution starts with if __name__ == \"__main__\":. That check is a guard that prevents the guarded code from executing when imported as a module, rather than run as the main script. The unguarded code always runs, regardless of how the module is loaded, so if the guard is at the bottom of the file, the rest of the file is run before it is reached.\nSo if you have a module:\n# foo.py\nprint(\"foo\")\n\nAnd a script:\n# main.py\nimport foo\n\ndef main():\n print(\"Main\")\n\nif __name__ == '__main__':\n main()\n\nand you run python3 main.py, execution of main.py begins with import foo, which ends up printing foo immediately. Then main.py defines the main function (defining functions without calling them is still executing code; if Python had skipped to the guarded code, main wouldn't exist), then the guard is checked, the check passes, and main is called. Basically every bit of top-level code (typically imports, global constants, functions, and class definitions) is executed before the guarded block is reached; normally that top-level code does nothing visible, but if an imported module tried to do some real work and logged during the process, it would take effect before you ever reached your guarded \"main script\" code.\n" ]

[ 1 ]

[]

[]

[ "buck", "python" ]

[ "you need to map all the datatypes correctly, i only used a sample to show you how top start.\nBut to be correct you need to rebuild all https://www.postgresql.org/docs/current/sql-createtable.html if you want to have all options\nSo i repeat my comment, best is to backup your database on database server with a backup tool, and use hat instead.\nimport pandas as pd\ndf = pd.DataFrame({'hello':[1], 'world':[2]})\ndf.name = 'Ones'\nindextext = \"hello\"\ndef typeconversion(x):\n return {\n 'int64': 'bigint ',\n 'float64': 'FLOAT'\n }[x]\n\ndef get_sql(df,Indexx_table):\n\n STR_sql = \"CREATE TABLE \" + df.name + \"( \"\n\n for (col1, col2) in zip(df.columns, df.dtypes): \n STR_sql += col1 + \" \" + typeconversion(col2.name) + ','\n #remove last comma\n STR_sql = STR_sql[:-1]\n if Indexx_table:\n STR_sql += \", PRIMARY KEY (\" + Indexx_table + \")\"\n STR_sql += \")\"\n return STR_sql\n\nprint(get_sql(df,indextext))\n\nresult is\nCREATE TABLE Ones( hello bigint ,world bigint , PRIMARY KEY (hello))\n\n" ]

[ 0 ]

[]

[]

[ "pandas", "postgresql", "python", "sql" ]

[ "If your question is about the purpose of typing.Generic I would suggest you read through PEP 484. It has a section dedicated to user defined generic classes with some examples specifically for this, but the entire document is worthwhile reading IMHO. If you are unsure about the entire concept of generic types, the Wikipedia articles on parametric polymorphism and generic programming might even be worth skimming.\nIn very simple terms, you can use the Generic base class to define your own classes in a generic way, i.e. parameterized with regards to one or more type arguments. These type parameters are constructed via typing.TypeVar. It is worth noting that in most cases these things are only relevant for the purposes of type safety, which is not really enforced by Python itself. Instead, static type checkers (most IDEs have them built-in) deal with those things.\nAs to your example, it is entirely possible to define your class in a generic way and thus improve your own coding experience because you'll likely get useful auto-suggestions and warnings by your IDE. This only really becomes useful, if you use the type variables somewhere else throughout your class. Example:\nfrom typing import Generic, TypeVar\n\n\nclass Base:\n pass\n\n\nModelType = TypeVar(\"ModelType\", bound=Base)\n\n\nclass CRUDBase(Generic[ModelType]):\n def __init__(self, model: type[ModelType]):\n self.model = model\n\n def get_model_instance(self) -> ModelType:\n return self.model()\n\n\nclass Sub(Base):\n def foo(self) -> None:\n print(\"hi mom\")\n\n\nif __name__ == \"__main__\":\n crud_a = CRUDBase(Sub)\n crud_b = CRUDBase(Base)\n a = crud_a.get_model_instance()\n b = crud_b.get_model_instance()\n a.foo()\n b.foo() # error\n\nA good type checker like mypy will know, that a is of the Sub type and thus has the foo method, whereas b is of the Base type and therefore does not. And it will know so just from the way we annotated CRUDBase.\nPyCharm for example struggles with this (don't know why). Fortunately, we can help it out with explicit type annotations because we defined CRUDBase as a generic type:\n...\n crud_a: CRUDBase[Sub] = CRUDBase(Sub)\n crud_b: CRUDBase[Base] = CRUDBase(Base)\n a = crud_a.get_model_instance()\n b = crud_b.get_model_instance()\n a.foo()\n b.foo() # PyCharm marks `foo` and complains\n\nNotice that so far there is nothing particularly \"abstract\" about our CRUDBase. It is fully self-contained and functioning like this (albeit not very useful yet).\nIf you want a class to be an abstract base and not be directly instantiated, the abc module provides you with the tools you need. You can define an abstract base class and abstract methods on it that all subclasses must implement. But I think it is clear now that this is a different concept. The idea is that an abstract class is not intended to be instantiated, only its subclasses are.\nI hope this helps point you in a few useful directions.\n" ]

[ 0 ]

[]

[]

[ "abstract_class", "crud", "generics", "python", "type_variables" ]

[ "I think this might be a Qt bug. There's an easy workaround:\nl = pg.GraphicsLayout()\nl.layout.setContentsMargins(0, 0, 0, 0)\n\nTo understand this, let's look at a modified example:\nfrom pyqtgraph.Qt import QtGui, QtCore\nimport pyqtgraph as pg\n\napp = QtGui.QApplication([])\nview = pg.GraphicsView()\nview.show()\nview.resize(800,600)\n\nclass R(QtGui.QGraphicsWidget):\n # simple graphics widget that draws a rectangle around its geometry\n def boundingRect(self):\n return self.mapRectFromParent(self.geometry()).normalized()\n def paint(self, p, *args):\n p.setPen(pg.mkPen('y'))\n p.drawRect(self.boundingRect())\n\nl = QtGui.QGraphicsGridLayout()\nr1 = R()\nr2 = R()\nr3 = R()\nr1.setLayout(l)\nl.addItem(r2, 0, 0)\nl.addItem(r3, 1, 0)\n\nview.scene().addItem(r1)\n\nIn this example, calling l.setContentsMargins(...) has the expected effect, but calling r1.setContentsMargins(...) does not. The Qt docs suggest that the effect should have been the same, though: http://qt-project.org/doc/qt-4.8/qgraphicswidget.html#setContentsMargins\n", "For anyone going through this in 2022, use a pg.GraphicsLayoutWidget :\n# GraphicsLayoutWidget is now recommended\nw = pg.GraphicsLayoutWidget(border=(30,20,255))\nwin.centralWidget.layout.setContentsMargins(0,0,0,0)\nwin.centralWidget.layout.setSpacing(0)\n\nNotice how there is no spacing between each blue border of each plot :\n\n" ]

[ 2, 0 ]

[]

[]

[ "pyqt", "pyqtgraph", "python" ]

[ "Two options here with comments.\nFirst do imports\nimport datetime\nimport time\n\n\none uses a while loop - probably not a good solution but highlights one way to wait for a condition to be met.\n\ndef loop_until_tomorrow():\n \"\"\" Will use a while loop to iterate until tomorrow \"\"\"\n\n #get current date\n currentDate = datetime.datetime.now().date()\n # loop attempts \n times = 0 \n # this will loop infiniatly if condition is never met \n while True:\n # increment by one each iteration\n times += 1\n #get date now\n now = datetime.datetime.now().date()\n if currentDate != now:\n # return when condition met \n print(\"\\nDay has changed\")\n return \n else: \n # print attempts and sleep here to avoid program hanging \n print(f\"Attempt: {times}\".ljust(13) + \" - Not tomorrow yet!\", end=\"\\r\")\n time.sleep(5)\n\n\nthe other - sleeps for the amount of seconds from now till tomorrow\n\ndef sleep_until_tomorrow():\n\n \"\"\"wait till tomorrow using time.sleep\"\"\"\n \n #get date now\n now = datetime.datetime.now()\n #get tomorrows date \n tomorrow_date = now.date() + datetime.timedelta(days=1)\n #set to datetime\n tomorrow_datetime = datetime.datetime(year=tomorrow_date.year, month=tomorrow_date.month, day=tomorrow_date.day, hour=0, minute=0, second=0)\n #get seconds\n seconds_til_tomorrow = (tomorrow_datetime-now).total_seconds()\n #sleep\n time.sleep(seconds_til_tomorrow)\n\n", "You can use schedule for that purpose, which will give you the flexibility to refactore the code when needed without having to write a chunck of code.\nfrom schedule import every, repeat, run_pending\nimport time\n\n#just to give you the idea on how to implement the module. \n@repeat(every().day.at(\"7:15\"))\ndef remind_me_its_a_new_day():\n print(\"Hey there it's a new day! \")\n\nwhile True:\n run_pending()\n time.sleep(1)\n\n" ]

[ 2, 1 ]

[]

[]

[ "python", "sleep", "time" ]

[ "Use groupby.cumsum and subtraction with to_numpy():\ndf[['New_Account1', 'New_Account2']] = (df[['Account_1', 'Account_2']]\n - df.groupby('Names')[['Less_1', 'Less_2']]\n .cumsum().to_numpy()\n )\n\nOutput:\n Names Account_1 Account_2 ID_Movement Less_1 Less_2 New_Account1 New_Account2\n0 Peter 35 70 Movement_1 0 5 35 65\n1 Peter 35 70 Movement_2 6 0 29 65\n2 Peter 35 70 Movement_3 1 0 28 65\n3 Peter 35 70 Movement_4 0 2 28 63\n4 Jhon 55 60 Movement_5 6 0 49 60\n5 Jhon 55 60 Movement_6 0 2 49 58\n6 Jhon 55 60 Movement_7 0 3 49 55\n7 Jhon 55 60 Movement_8 12 0 37 55\n8 Jhon 55 60 Movement_9 6 0 31 55\n9 William 34 88 Movement_10 0 8 34 80\n10 William 34 88 Movement_11 0 9 34 71\n11 William 34 88 Movement_12 0 5 34 66\n\n", "Try to use lambda\ndf['New_Account1'] = df.apply(lambda row : (row['Account 1'] - row['Less_1']), axis = 1)\n\n" ]

[ 3, 0 ]

[]

[]

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

[ "I used this code to acheive what I need\nfile_name = \"test.csv\"\nbucket = \"my_bucket\"\n\ndef main():\n url = \"https://api0.solar.sheffield.ac.uk/pvlive/v3/pes/10?start=2021-01-01T00:00:00&end=2021-07-06T00:00:00&data_format=csv\"\n x = requests.get(url,headers={'Content-Type': 'application/json', 'Accept': 'application/json', 'Accept-Encoding': 'gzip, deflate',})\n\n\n\n s3_resource = boto3.resource('s3')\n s3_resource.Object(bucket, 'snowflake/csv/df1.csv').put(Body=x.content)\n\n\nif __name__ == \"__main__\":\n main()\n\n" ]

[ 1 ]

[ "per the OP(Original Post),\ndid you try\n(line 11) s3 = boto3.client(\"s3\") -- OP: bot03.client(\"s3\")\n" ]

[ -1 ]

[ "amazon_s3", "amazon_web_services", "api", "python" ]

[ "Try this code, I was a bit confused by what you had there but you can simplify the operation a bit. This will achieve the same result. I hope this helps you solve your problem.\ndef openAndSeperate(filename):\n with open(filename,'r') as file:\n priceList = {}\n for i in file:\n i = i.strip('\\n').split(',')\n priceList[i[0]] = float(str(i[1])[1:])\n return priceList\n\n\ndef main():\n filename = 'price_file.txt'#input('Enter File Name: \\n')\n priceList = openAndSeperate(filename)\n print(priceList)\n\n\n\nif __name__ == '__main__':\n main()\n\n" ]

[ 1 ]

[]

[]

[ "function", "python" ]

[ "As a rule of thumb, if you every find yourself in a situation, where your code does not work because of floating point arithmetic, it is very likely that at least one of the following sentences applies to you:\n\nYou work in a very niche field of research.\nYou have a bug in your code.\nYou are dealing with a mathematically ill-posed problem.\n\nIn your case, you have a bug in your code. Your C++ code and your Python code do not do the same thing:\n\nYou have an index error (you should get targetPosX from data[4] not from data[3])\nIn your Python code, the second argument to the arctan2 function is 2.0*self.prevDistEgoToTarget, while in the C++ code it's distEgoToTarget.\nYour Python code does one more iteration than your C++ code.\n\nThese errors can easily be found by printing all intermediate values in just one iteration. You don't even need a debugger for this. If you fix these issues, you get a vp value of 0.08624797012674965 from Python and 0.086247970126749646 from C++ after 700 iterations. I would argue that the difference is negligible.\n", "IEEE754 guarantees a few things such as:\n\nThe format of FP values\nBasic operations (+,-,*,/ and sqrt) are exact. The result is as if you did the calculation with infinite precision, and then rounded the result.\n\nWhat IEEE754 does not guarantee is that other functions such as arctan are rounded in the same way. And therefore, Python and C++ can reasonably differ by 1 ULP.\n[background]\nThe problem with \"exact rounding\" is that you need an algorithm to do it correctly. For the 5 basic functions, there were well-known, efficient algorithms at the time IEEE754 was drafted. Since then, efficient algorithms have been discovered for more functions, but there are many, many functions that still do not have such algorithms. In particular, many functions still use tables and interpolation, and that's almost automatically inexact.\n" ]

[ 1, 0 ]

[]

[]

[ "c++", "floating_point", "python", "python_3.x" ]

[ "You nedd add () because & has higher precedence than ==:\ndf3 = df[(df['count'] == '2') & (df['price'] == '100')]\nprint (df3)\n id count price\n0 1 2 100\n\nIf need check multiple values use isin:\ndf4 = df[(df['count'].isin(['2','7'])) & (df['price'].isin(['100', '221']))]\nprint (df4)\n id count price\n0 1 2 100\n3 4 7 221\n\nBut if check numeric, use:\ndf3 = df[(df['count'] == 2) & (df['price'] == 100)]\nprint (df3)\n\ndf4 = df[(df['count'].isin([2,7])) & (df['price'].isin([100, 221]))]\nprint (df4)\n\n", "if you want to do by index id you could do:\nnew_df = (df.iloc[[1]]).append(df.iloc[[6]])\n" ]

[ 18, 0 ]

[]

[]

[ "pandas", "python" ]

[ "If I understand you correctly:\nout = dict(\n zip(data[\"item_number\"], (v for v in data[\"total\"].values() if v != 0))\n)\nprint(out)\n\nPrints:\n{\n \"1\": 22,\n \"2\": 35,\n \"3\": 108,\n \"4\": 70,\n \"5\": 24,\n \"6\": 75,\n \"7\": 123,\n \"8\": 224,\n \"9\": 28,\n}\n\n", "Either use a count variable instead of enumerate(), or filter before enumerating.\nCount variable\nindex = 0\nfor value in data['total'].values():\n if value != 0:\n print((data['item_number'][index], value))\n index += 1\n\nOutput:\n('1', 22)\n('2', 35)\n('3', 108)\n('4', 70)\n('5', 24)\n('6', 75)\n('7', 123)\n('8', 224)\n('9', 28)\n\nFilter first\nfor index, value in enumerate(v for v in data['total'].values() if v != 0):\n print((data['item_number'][index], value))\n\n(Same output)\nAnd this can be simplified further using zip() like in Andrej's answer.\n\nNote: I'm not using a dict here for simplicity and because your code as posted doesn't use one. I think it's obvious how you would incorporate one though.\n", "There are two tasks at hand here:\n\nFilter out the zero values from data[\"total\"]\nCreate a dictionary, where keys are the elements of data[\"item_number\"], and values are from the filtered collection we created above.\n\nSo, let's do that:\nfiltered_values = [val for val in data[\"total\"].values() if val]\n# [22, 35, 108, 70, 24, 75, 123, 224, 28]\n\nnew_dict = dict(zip(data[\"item_number\"], filtered_values))\n\nWhich gives the required new_dict:\n{'1': 22,\n '2': 35,\n '3': 108,\n '4': 70,\n '5': 24,\n '6': 75,\n '7': 123,\n '8': 224,\n '9': 28}\n\nYou can save one loop through your data[\"total\"] if you define filtered_values as a generator expression, or combine the two lines:\nnew_dict = dict(zip(data[\"item_number\"], (val for val in data[\"total\"].values() if val)))\n\n" ]

[ 1, 1, 1 ]

[]

[]

[ "python" ]

[ "Try using \"sudo\" or any user with enough privileges like \"root\"\n", "Try putting \"--user\" at the end of the command\n" ]

[ 0, 0 ]

[]

[]

[ "linux", "pip", "python", "python_3.x" ]

[ "Got this working:\nimport pandas as pd\nfrom yahooquery import Ticker\n\nsymbols = ['MSFT','GOOG','AAPL'] #I have to put 75,000+ symbols here.\nheader = [\"regularMarketPrice\", \"marketCap\"]\n\nfor tick in symbols:\n faang = Ticker(tick)\n faang.price\n df = pd.DataFrame(faang.price,{\"regularMarketPrice\":[1],\"marketCap\":[2]}).T \n#adding the {...} fixed a 'scalar value' error as well.\n try:\n df.to_csv('mktcaptest.csv', mode='a', index=True, header=False, columns=header)\n except KeyError:\n continue\n\n" ]

[ 0 ]

[]

[]

[ "arrays", "csv", "dataframe", "pandas", "python" ]

[ "You need to specify the parameter skip_blank_lines=False from pandas.read_csv. Here's a fixed version of your code:\nimport pandas as pd\n\ndf = pd.read_csv(f'{cwd}/data.csv', header=None, na_filter=False, skip_blank_lines=False)\ndf\n\nOutputs:\n\nOr:\nimport pandas as pd\n\ndf = pd.read_csv(f'{cwd}/data.csv', header=None, skip_blank_lines=False)\ndf\n\nOutputs:\n\n" ]

[ 0 ]

[]

[]

[ "pandas", "python" ]