Datasets:

---

suriyagunasekar

/

stackoverflow-python-with-meta-data

like 11

[ "I think you can do this in your A/setup.py file (and the same in your B/setup.py file, just change package_B_name to package_A_name:\nimport importlib.util\nspec = importlib.util.find_spec(f'{package_B_name}')\nif spec is not None:\n requirements_list.append(f'{package_B_name}>={package_B_version}')\n\nNote that this only works in Python3.3+ and only source distributions. It will not work when installing from a binary wheel (.whl)\n", "If you know how to convert a requirements.txt to a setup.py file in accordance, try this for example:\nmy-package>=minimum.version\n\nThis checks for if the package is greater than this specific version or is this minimum version, therefore making a minimum version.\n" ]

[ 0, 0 ]

[ "I don't know if I understand the question correctly but you can specify the minimum required version in the install_requires array in the setup function like so.\ninstall_requires=['locust-swarm >= 1.2', 'locust-plugins >= 1.1']\n\nI hope this answers your question, if it doesn't, let me know, and I will look into it further.\n" ]

[ -1 ]

[ "pip", "python", "python_packaging", "setup.py" ]

[ "Here is a possible solution:\nwith open('yourfile.txt') as infile:\n header = next(infile)\n ages = {}\n\n for line in infile:\n name, age, country = line.rsplit(' ', 2)\n if age not in ages:\n ages[age] = []\n ages[age].append([name, age, country])\n\n for age in ages:\n with open(f'age-{age}.txt', 'w') as agefile:\n agefile.writeline(header) \n agefile.writelines(ages[age])\n\nFor the sample you posted, the code above will leave you with files named age-19.txt, age-20.txt, and age-21.txt, with the contents separated by age, as you requested.\n" ]

[ 0 ]

[ "If you have them all in a list you can use something like this...\nalltext = [\"Names Age Country\", \"Mark 21 USA\", \"John 21 UK\",\"Elon 20 CAN\",\"Dominic 21 USA\", \"Andreas 21 UK\"]\n\nCanada = [alltext[0]] #Creates a list with your column header\nNotCanada = [alltext[0]] #Creates a list with your column header\n\nfor row in alltext[1:]:\n x = row.split()\n if x[2] == \"CAN\":\n Canada.append(row)\n else:\n NotCanada.append(row)\n\nprint(Canada)\nprint(NotCanada)\n\nWill print two different lists of your separated players.\n['Names Age Country', 'Elon 20 CAN']\n['Names Age Country', 'Mark 21 USA', 'John 21 UK', 'Dominic 21 USA', 'Andreas 21 UK']\n" ]

[ -1 ]

[ "file", "python", "txt" ]

[ "bs4 [or rather soupsieve] doesn't like it when id selectors [#id] have hyphens (-) in them for some reason, but you can get around it by using attribute selector instead\ncont = soup.select(f'div[id=\"{d1}\"]')\n\nshould work - give it a try.\n" ]

[ 1 ]

[]

[]

[ "beautifulsoup", "css", "html", "python", "scrapy" ]

[ "inspect.stack() does two things:\n\ncollect the stack by asking the interpreter for the stack frame from the caller (sys._getframe(1)) then following all the .f_back references. This is cheap.\nper frame, collect the filename, linenumber, and source file context (the source file line plus some extra lines around it if requested). The latter requires reading the source file for each stack frame. This is the expensive step.\n\nTo switch off the file context loading, set the context parameter to 0:\ninspect.stack(0)\n\nEven with context set to 0, you still incur some filesystem access per frame as the filename is determined and verified to exist for each frame.\n", "inspect.stack(0) can be faster than inspect.stack(). Even so, it is fastest to avoid calling it altogether, and perhaps use a pattern such as this instead:\nframe = inspect.currentframe()\nwhile frame:\n if has_what_i_want(frame): # customize\n return what_i_want(frame) # customize\n frame = frame.f_back\n\nNote that the last frame.f_back is None, and the loop will then end.\nsys._getframe(1) should obviously not be used because it is an internal method.\nAs an alternative, inspect.getouterframes(inspect.currentframe()) can be looped over, but this is expected to be slower than the above approach.\n", "Here's a concrete example building on the other answers, showing how to efficiently walk back up the stack to find the typical caller information (filename, line number, function name) incorporated into debug messages.\nimport sys\nfrom collections import namedtuple\n\n\nFrameInfo = namedtuple('FrameInfo', ['filename', 'lineno', 'function'])\n\n\ndef frame_info(walkback=0):\n # NOTE: sys._getframe() is a tiny bit faster than inspect.currentframe()\n # Although the function name is prefixed with an underscore, it is\n # documented and fine to use assuming we are running under CPython:\n #\n # https://docs.python.org/3/library/sys.html#sys._getframe\n #\n frame = sys._getframe().f_back\n\n for __ in range(walkback):\n f_back = frame.f_back\n if not f_back:\n break\n\n frame = f_back\n\n return FrameInfo(frame.f_code.co_filename, frame.f_lineno, frame.f_code.co_name)\n\n" ]

[ 21, 20, 0 ]

[]

[]

[ "inspect", "introspection", "python" ]

[ "The issue with the doubling of the name was a dynamic change with the webpage size providing a shortened name with small size and longer name when larger, but they were under the same tag in ('td')1. By specifically calling the 'span' with class_='CellPlayerName--long', I was able to only extract the longer version of the name. The updated working code follows:\nFlask:\n @app.route(\"/\", methods=(\"GET\", \"POST\"), strict_slashes=False)\ndef index():\n\n url = \"https://www.cbssports.com/nfl/injuries/daily\"\n source = requests.get(url)\n soup = BeautifulSoup(source.text, 'html.parser')\n\n data = soup.find('tr')\n table_data = []\n trs = soup.select('tr.TableBase-bodyTr')\n \n\n for tr in trs[1:16]:\n row = []\n row.extend([tr.select('td')[0].text])\n row.extend([tr.find('span', class_='CellPlayerName--long').text])\n row.extend([tr.select('td')[2].text])\n row.extend([tr.select('td')[3].text])\n\n table_data.append(row)\n\n data = table_data\n\n\n return render_template('index.html', data=data)\n\nHTML:\n<div class=\"w3-third\">\n <div class=\"w3-card-4 w3-container\" style=\"min-height:500px;width:97%\"> \n <div class=\"w3-col s4\">\n <h3 class=\"text-nowrap\">15 Most Recent Injuries</h3>\n <table class=\"table table-striped text-nowrap\">\n <thead class=\"table-header\">\n <th scope=\"col\">Team</th>\n <th scope=\"col\">Player</th>\n <th scope=\"col\">Position</th>\n <th scope=\"col\">Injury</th>\n </thead>\n <tbody>\n {% for element in data %}\n <tr>\n <th class=\"font-weight-light\" scope=\"col\">{{element[0]}}</th>\n <th class=\"font-weight-light\" scope=\"col\">{{element[1]}}</th>\n <th class=\"font-weight-light\" scope=\"col\">{{element[2]}}</th>\n <th class=\"font-weight-light\" scope=\"col\">{{element[3]}}</th>\n </tr>\n {% endfor %}\n </tbody>\n </table>\n </div>\n </div>\n </div>\n\nCSS All CSS here is from w3, so no code needs to be added to style.css file\n <link rel=\"stylesheet\" href=\"https://www.w3schools.com/w3css/4/w3.css\">\n\nThe updated table:\n\n" ]

[ 0 ]

[]

[]

[ "beautifulsoup", "flask", "html", "python" ]

[ "You can escape special characters:\nr'[\\^a-zA-z0-9\\s]+'\n\nBut the use case you're tackling is already addressed\nby translate(), without any need to resort to power tools\nlike regexes.\nhttps://docs.python.org/3/library/stdtypes.html#str.maketrans\n\nYou're incurring the cost of parsing / compiling the regex N\ntimes, when a single time would suffice.\nConsider defining this:\npattern = re.compile(r'[\\^a-zA-z0-9\\s]+')\n\n" ]

[ 1 ]

[]

[]

[ "dataframe", "python", "string", "symbols" ]

[ "A minAreaRect() gives you a center point, the size of the rectangle, and an angle.\nYou could just add to the shorter side length of the rectangle. Then you have a description of a \"wider rectangle\". You can then do with it whatever you want, such as call boxPoints() on it.\npadding = 42\n\nrect = cv.minAreaRect(input_to_min_area)\n\n(center, (w,h), angle) = rect # take it apart\n\nif w < h: # we don't know which side is longer, add to shorter side\n w += padding\nelse:\n h += padding\n\nrect = (center, (w,h), angle) # rebuild\n\nA box around your two endpoints, widened:\n\n", "We may add the padding in the axis that is perpendicular to the angle of the \"\nminAreaRect\".\n\nGet the angle, and convert to radians\n angle = np.deg2rad(rect[2]) # Angle of minAreaRect\n\n\nPadding in each direction is perpendicular to the angle of minAreaRect\n pad_x = 20*np.sin(angle)\n pad_y = 20*np.cos(angle)\n\n\nAdd the padding in both axes:\nAssume the order of the point in box is sorted according to the angle of rect (I don't know if it's always true - sorting the points may be required).\n box[[0, 3], 0] -= pad_x\n box[[1, 2], 0] += pad_x\n box[[0, 3], 1] += pad_y\n box[[1, 2], 1] -= pad_y\n box = np.int0(box)\n\n\n\n\nCode sample:\nimport cv2\nimport numpy as np\n\nimg = cv2.imread('sketch.png')\n\n#input_to_min_area = np.array([[584, 147], [587, 502]]) # this works instead of contour as an input to minAreaRect\n#input_to_min_area = np.array([[109, 515], [585, 144]]) # this works instead of contour as an input to minAreaRect\ninput_to_min_area = np.array([[80, 103], [590, 502]]) # this works instead of contour as an input to minAreaRect\n\nrect = cv2.minAreaRect(input_to_min_area)\nbox = cv2.boxPoints(rect)\n\nangle = np.deg2rad(rect[2]) # Angle of minAreaRect\n\n# Padding in each direction is perpendicular to the angle of minAreaRect\npad_x = 20*np.sin(angle)\npad_y = 20*np.cos(angle)\n\nbox[[0, 3], 0] -= pad_x\nbox[[1, 2], 0] += pad_x\nbox[[0, 3], 1] += pad_y\nbox[[1, 2], 1] -= pad_y\nbox = np.int0(box)\n\ncv2.drawContours(img, [box], 0, (0, 255, 255), 2)\n\ncv2.imshow('img', img)\ncv2.waitKey()\ncv2.destroyAllWindows()\n\n\nSample output:\n\n\nWe may also want to expand the box in the parallel direction.\nI am still not sure about the signs...\nIn this case it's simpler to update input_to_min_area:\nimport cv2\nimport numpy as np\n\nimg = cv2.imread('sketch.png')\n\n#input_to_min_area = np.array([[584, 147], [587, 502]]) # this works instead of contour as an input to minAreaRect\n#input_to_min_area = np.array([[109, 515], [585, 144]]) # this works instead of contour as an input to minAreaRect\ninput_to_min_area = np.array([[80, 103], [590, 502]]) # this works instead of contour as an input to minAreaRect\n\nrect = cv2.minAreaRect(input_to_min_area)\n\nangle = np.deg2rad(rect[2]) # Angle of minAreaRect\npad_x = int(round(20*np.cos(angle)))\npad_y = int(round(20*np.sin(angle)))\ntmp_to_min_area = np.array([[input_to_min_area[0, 0]+pad_x, input_to_min_area[0, 1]+pad_y], [input_to_min_area[1, 0]-pad_x, input_to_min_area[1, 1]-pad_y]])\nrect = cv2.minAreaRect(tmp_to_min_area)\n\nbox = cv2.boxPoints(rect)\n\nangle = np.deg2rad(rect[2]) # Angle of minAreaRect\n\n# Padding in each direction is perpendicular to the angle of minAreaRect\npad_x = 20*np.sin(angle)\npad_y = 20*np.cos(angle)\n\nbox[[0, 3], 0] -= pad_x\nbox[[1, 2], 0] += pad_x\nbox[[0, 3], 1] += pad_y\nbox[[1, 2], 1] -= pad_y\n\nbox = np.int0(box)\n\ncv2.drawContours(img, [box], 0, (0, 255, 255), 2)\n\ncv2.line(img, (tmp_to_min_area[0, 0], tmp_to_min_area[0, 1]), (tmp_to_min_area[1, 0], tmp_to_min_area[1, 1]), (255, 0, 0), 2)\n\ncv2.imshow('img', img)\ncv2.waitKey()\ncv2.destroyAllWindows()\n\n\nOutput:\n\n" ]

[ 3, 2 ]

[]

[]

[ "geometry", "image", "image_processing", "opencv", "python" ]

[ "You could turn the list of dicts into a single dict.\nDownside is dups would be squished, so e.g. \"carl\" would map to just a single number.\nAs it stands, you probably want to see all of carl's values,\nusing something like this:\njson_data = json.load(open('reda.json'))\nfor d in json_data:\n print(d)\n\nk = \"carl\"\nprint(f\"\\nHere is {k}:\")\nfor d in json_data:\n if k in d:\n print(k, d[k])\n\n\nTo see if e.g. \"carl\" is in the data, use this:\ndef contains_favorite_key(d: dict, k=\"carl\"):\n return k in d\n\nif any(map(contains_favorite_key, json_data)):\n print(\"found at least one occurrence!\")\n\n\n\nTo say \"bye, bye, Carl!\" use del:\nk = \"carl\"\nassert k in d\nprint(d[k])\n\ndel d[k]\n\nprint(d[k]) # Notice that this now reports KeyError.\n\n" ]

[ 1 ]

[]

[]

[ "list", "python" ]

[ "You can try to calculate values only once and then reuse them.\nfrom scipy.integrate import quad\nfrom scipy.optimize import fsolve\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# These values can be changed\nmasstot = 5\nmass = 2\ng = 9.8\nl = 9.8\nwan = (g/l)**(1/2)\nvuk = 0.1\noug = 1\n\ndef afad(lah): # Find first constant\n wan = 1\n vuk = 0.1\n oug = 1\n kan = (12*(lah**4)*((3*(vuk**2)-(wan**2))))-((16*((wan**2)-(vuk**2))-(5*oug**2))*(lah**2))+(4*(oug**2))\n return (kan)\n\nsolua = fsolve(afad, 1)[0]\n\ndef kfad(solua, wan, vuk): # Find second constant\n res = ((wan**2)-(vuk**2)-((2*(solua**2)*((2*(vuk**2))+(wan**2)))/((5*(solua**2))+4)))**(1/2)\n return (res)\n\nksol = kfad(solua, wan, vuk)\n\n\n\nres_a = {}\ndef a(t): # define acceleration of system to time\n if t in res_a:\n return res_a[t]\n\n vuk_t = vuk * t\n macro1 = 2 * solua * np.exp(vuk_t)\n ksol_t = ksol * t\n sin_ksol_t = np.sin(ksol_t)\n deg = 2 * np.arctan(solua * np.exp(-1 * vuk_t) * sin_ksol_t)\n chandeg = macro1 * (-vuk * sin_ksol_t + ksol * np.cos(ksol_t)) / (np.exp(2*vuk_t) + ((solua**2) * sin_ksol_t**2))\n\n res = (((l * (chandeg**2)) + (g * np.cos(deg))) * mass * np.sin(deg) / masstot)\n\n res_a[t] = res\n return res\n\nres_j = {}\ndef j(t):\n if t in res_j:\n return res_j[t]\n\n res = a(t)\n\n res_j[t] = res\n return res\n\ndef f(ub):\n return quad(lambda ub: quad(j, 0, ub)[0], 0, ub)[0]\n\ndef int2(bond):\n res = []\n for x in (bond):\n res.append(f(x))\n print(res)\n\n return res\n\nxs = np.linspace(0, 60, 20) # Value can be changed to alter plotting accuracy and length\nplt.plot(xs, int2(xs)) # This part of the program runs quite slowly\nplt.show()\n\nThis example looks to be 6x faster.\n", "An alternative solution to the one of @IvanPerehiniak, is to use a JIT compiler like Numba so to do many low-level optimization that the CPython interpreter do not. Indeed, numerically intensive pure-Python code running on CPython are generally very inefficient. Numpy can provide relatively good performance for large arrays but it is very slow for small one. The thing is you use a lot of small arrays and pure-Python scalar operations. Numba is not a silver-bullet though: it just mitigate many overhead from Numpy and CPython. You still have to optimize the code further if you want to get a very fast code. Hopefully, this method can be combined with the one of @IvanPerehiniak (though the dictionary need not to be global which is cumbersome in many cases). Note Numba can pre-compute global constants for you. The compilation time is done during the first call or when the function has a user-defined explicit signature.\nimport numba as nb\nfrom scipy.integrate import quad\nfrom scipy.optimize import fsolve\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport scipy\n\n# These values can be changed\nmasstot = 5.0\nmass = 2.0\ng= 9.8\nl = 9.8\nwan = (g/l)**(1/2)\nvuk = 0.1\noug = 1.0\n\[email protected]\ndef afad(lah): # Find first constant\n wan = 1.0\n vuk = 0.1\n oug = 1.0\n kan = (12*(lah**4)*((3*(vuk**2)-(wan**2))))-((16*((wan**2)-(vuk**2))-(5*oug**2))*(lah**2))+(4*(oug**2))\n return (kan)\n\nsolua = fsolve(afad, 1)\n\nintsolua = np.sum(solua) \n\[email protected]\ndef kfad(solua, wan, vuk): # Find second constant\n res = ((wan**2)-(vuk**2)-((2*(solua**2)*((2*(vuk**2))+(wan**2)))/((5*(solua**2))+4)))**(1/2)\n return (res)\n\nksol = kfad(solua, wan, vuk)\n\[email protected]\ndef deg(t, solua, vuk, ksol): # Find angle of pendulum relative to time\n res = 2*np.arctan(solua*np.exp(-1*vuk*t)*np.sin(ksol*t))\n return(res)\n\[email protected]\ndef chandeg(t, solua, vuk, ksol): # Find velocity of pendulum relative to time\n res = (((-2*solua*vuk*np.exp(vuk*t)*np.sin(ksol*t))+(2*solua*ksol*np.exp(vuk*t)*np.cos(ksol*t)))/(np.exp(2*vuk*t)+((solua**2)*(np.sin(ksol*t)**2))))\n return(res)\n\nxs = np.linspace(0, 60, 20) # Value can be changed to alter plotting accuracy and length\n\[email protected]\ndef dinte1(deg, bond, solua, vuk, ksol): # used to plot angle at at a certain time\n res = []\n for x in (bond):\n res.append(deg(x, solua, vuk, ksol))\n return res\n\[email protected]\ndef dinte2(chandeg, bond, solua, vuk, ksol): # used to plot angular velocity at a certain time\n res = []\n for x in (bond):\n res.append(chandeg(x, solua, vuk, ksol))\n return res\n\[email protected]\ndef dinte(a, bond, mass, l, solua, vuk, ksol, g, masstot ): # used to plot acceleration of system at certain time\n res = []\n for x in (bond):\n res.append(a(x, mass, l, solua, vuk, ksol, g, masstot))\n return res\n\[email protected]\ndef a(t, mass, l, solua, vuk, ksol, g, masstot): # define acceleration of system to time\n return (((mass*l*(chandeg(t, solua, vuk, ksol)**2))+(mass*g*np.cos(deg(t, solua, vuk, ksol))))*np.sin(deg(t, solua, vuk, ksol))/masstot)\n\n# See: https://stackoverflow.com/questions/71244504/reducing-redundancy-for-calculating-large-number-of-integrals-numerically/71245570#71245570\[email protected]('float64(float64)')\ndef j(t):\n return np.sum(a(t, mass, l, intsolua, vuk, ksol, g, masstot))\nj = scipy.LowLevelCallable(j.ctypes)\n\n# Cannot be jitted due to \"quad\"\ndef f(ub):\n return quad(lambda ub: quad(j, 0, ub)[0], 0, ub)[0]\n\n# Cannot be jitted due to \"f\" not being jitted\ndef int2(f, bond): # Integrates system acceleration twice to get posistion relative to time\n res = []\n for x in (bond):\n res.append(f(x))\n print(res)\n return res\n\nplt.plot(xs, int2(f, xs)) # This part of the program runs quite slowly\n#plt.plot(xs, dinte(a, xs, mass, l, solua, vuk, ksol, g, masstot))\n#plt.plot(xs, dinte2(chandeg, xs, solua, vuk, ksol))\n#plt.plot(xs, dinte1(deg, xs, solua, vuk, ksol))\nplt.show()\n\nHere are results:\nInitial solution: 35.5 s\nIvan Perehiniak's solution: 5.9 s\nThis solution (first run): 3.1 s\nThis solution (second run): 1.5 s\n\nThis solution is slower the first time the script is run because the JIT needs to compile all the functions the first time. Subsequent calls to the functions are significantly faster. In fact, int2 takes only 0.5 seconds on my machine the second time.\n" ]

[ 2, 2 ]

[]

[]

[ "differential_equations", "numpy", "python", "scipy", "simulation" ]

[ "This method is very simple and will not give exact values, but it is quite close.\nYou must first take the time value before starting the download.\nThen in the function \"downloadCallback\" you return to take the value of time. Subtracting this value from the value taken before starting the download, we will have the elapsed time since the start of the download.\nNow we can calculate download speed, simply by dividing the number of bytes downloaded by the elapsed time. If you want the value in Mega bytes, you must divide by 1024 twice.\nTo calculate the remaining time, just divide the bytes remaining to be downloaded by the speed:\n from pytube import YouTube\n from datetime import datetime\n\n download_start_time = datetime.now()\n\n def downloadCallback(stream, chunk, bytes_remaining):\n global download_start_time\n seconds_since_download_start = (datetime.now()- download_start_time).total_seconds() \n total_size = stream.filesize\n bytes_downloaded = total_size - bytes_remaining\n percentage_of_completion = bytes_downloaded / total_size * 100\n speed = round(((bytes_downloaded / 1024) / 1024) / seconds_since_download_start, 2) \n seconds_left = round(((bytes_remaining / 1024) / 1024) / float(speed), 2)\n print(\"percentage_of_completion:\", round(percentage_of_completion, 2), \"%\")\n print(\"seconds_since_download_start:\", round(seconds_since_download_start, 2), \"seconds\")\n print(\"speed:\", round(speed, 2), \"Mbps\")\n print(\"seconds_left:\", round(seconds_left, 2), \"seconds\")\n print()\n\n\n def main():\n global download_start_time\n chunk_size = 1024\n url = \"https://youtu.be/BBnomwpF_uY\"\n yt = YouTube(url)\n video = yt.streams.get_highest_resolution()\n yt.register_on_progress_callback(downloadCallback)\n print(f\"Fetching \\\"{video.title}\\\"..\")\n print(f\"Fetching successful\\n\")\n print(f\"Information: \\n\"\n f\"File size: {round(video.filesize * 0.000001, 2)} MegaBytes\\n\"\n f\"Highest Resolution: {video.resolution}\\n\"\n f\"Author: {yt.author}\")\n print(\"Views: {:,}\\n\".format(yt.views))\n\n print(f\"Downloading \\\"{video.title}\\\"..\")\n\n download_start_time = datetime.now()\n video.download()\n\n main()\n\n" ]

[ 0 ]

[]

[]

[ "python", "pytube" ]

[ "I also had trouble setting up a fixture because the docs aren't super clear that you have to explicitly enable them. It isn't enough to have the @fixture decoration in features/environment.py. You also have to call use_fixture(). For example, inside before_tag(), like this:\ndef before_tag(context, tag):\n if tag == \"fixture.backup.file\":\n use_fixture(backup_file, context)\n\nThis example helped me figure that out:\nhttps://github.com/behave/behave/blob/main/features/fixture.feature#L16\n", "Here is how you can do it without @fixture, just by using the before_tag hook:\n#!/usr/bin/env python\n# FILE: features/environment.py\n\nimport logging\nfrom behave.runner import Context\nfrom behave.model import Tag\nfrom pathlib import Path\n\nlogger = logging.getLogger(__name__)\n\n\ndef rename_file(origin: Path, target: Path) -> tuple[Path, Path]:\n \"\"\"\n Will rename the `origin` to `target`, replaces existing `target`\n \"\"\"\n origin.touch()\n backup = origin.replace(target)\n logger.info(f\"File {str(origin)} renamed to {str(target)}\")\n return origin, backup\n\n\ndef before_tag(context: Context, tag: Tag):\n if tag == \"backup.file.important.txt\":\n file = Path.home() / \"important.txt\"\n backup = file.with_suffix(\".backup\")\n context.file, context.backup_file = rename_file(file, backup)\n context.add_cleanup(rename_file, context.backup_file, context.file)\n\n#!/usr/bin/env python\n# File features/steps/file_ops.py\n\nfrom pathlib import Path\nfrom behave import given\nfrom behave import when\nfrom behave import then\nfrom behave.runner import Context\nimport logging\n\nlogger = logging.getLogger(__name__)\n\n\n@given(\"the file exists\")\ndef step_impl(context: Context):\n logger.info(f\"Touching file\")\n context.file.touch()\n\n\n@when(\"I append a line to the file\")\ndef step_impl(context: Context):\n logger.info(f\"Appending a line to file\")\n context.appended = \"Test line appended\\n\"\n with open(context.file, mode=\"a\") as f:\n f.write(context.appended)\n\n\n@then(\"the line appears at the end of the file\")\ndef step_impl(context: Context):\n logger.info(f\"Checking if line was appended\")\n with open(context.file, mode=\"r\") as f:\n for n, line in enumerate(f, start=1):\n logger.info(f\"Line {n} is {line}\")\n logger.info(f\"Last line is '{line.strip()}'\")\n assert line == context.appended\n\nBut using a fixture and the fixture registry as described in the Realistic example in behave's documentation is superior, as you will likely end up having many more setup-cleanup pairs later on.\n" ]

[ 1, 0 ]

[]

[]

[ "python", "python_behave" ]

[ "I ran into this issue in my program, and decided to answer this question Q&A style!\nI came up with a very simple workaround.\nFirst, use a single waitKey call to get the key required as so-\ninp = waitKey(1)\nNow, create a dictionary with its keys as the ordinals of the buttons you're pressing, and values as the code you want to execute (use ; for multiline code, or break the code into a separate function)-\nd_exec = {\n27: \"cap.release();cv2.destroyAllWindows();break;\",\n100:\"show_crop = not show_crop\", \n99:\"show_cv = not show_cv\", \n116:\"show_curr_track = not show_curr_track\", \n115:\"save()\"\n}\n\nHere, 27 is Esc,\n99 is c,\n116 is t,\n115 is s on the keyboard for my system and so on. You can also use the ord function if you don't know the actual integer values for keys.\nFinally, you can use just the single waitKey function in conjugation with your dictionary, and the inbuilt exec function as follows-\ninp = cv2.waitKey(1)\nif inp in d_exec:\n exec(d_exec[inp])\ninp = None\n\nHere, the exec function takes in a string as an input, and runs it as python code.\nNOTE: Use ; for multiline code (as shown in dictionary line 1), or break it into single line function calls.\nMake sure to set inp back to None or some other out of dictionary value, so that the same code doesn't accidentally execute on the next iteration of the main loop.\nYou can also use the more traditional if else series beneath inp = waitKey(1), but the dictionary method looks more cleaner to me :)\n" ]

[ 0 ]

[]

[]

[ "opencv", "python" ]

[ "As already pointed out by fmw42 in the comments, the API you are using has optional arguments to deal with this.\nPlease peruse the docs for the API you use: skimage.transform.rotate\nThe docs offer a mode, which says how to fill in those pixels that don't come from the source image.\nThe modes replicate/edge and constant should be of interest to you.\n\nedge Pads with the edge values of array.\nconstant (default) Pads with a constant value, in conjunction with the cval argument (default 0, i.e. black).\n\n" ]

[ 1 ]

[]

[]

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

[ "The problem as jasonharper pointed is that 'a' is an iterable element which contains 'a' and so on. You can however, rewrite the code with another if before the yield from flatten(x) something like\nfrom collections.abc import Iterable\ndef flatten(items):\n for x in items:\n if isinstance(x, Iterable):\n if len(x)==1:\n yield next(iter(x))\n else: \n yield from flatten(x)\n else:\n yield x\n\nitems = [2, [3, 4, [5, 6], 7], 8, 'abc']\n\nfor x in flatten(items):\n print(x)\n\n", "This happens because you're exceeding the limit of the call stack I won't get into the nitty-gritty here but, you can read this article: https://towardsdatascience.com/python-stack-frames-and-tail-call-optimization-4d0ea55b0542\nRecursion is a tricky problem to get right, it's often best to avoid it when possible in my own personal opinion. If you refactor your code to use a minimal amount of recursion and use the built-in iter() function on string values it works without exiting the call stack like so.\n from collections.abc import Iterable\n\ndef flatten(items):\n for x in items:\n if isinstance(x, str):\n yield from iter(x)\n elif isinstance(x, Iterable):\n yield from flatten(x)\n else: \n yield x\n\nitems = [2, [3, 4, [5, 6], 7], 8, 'abc']\n\nfor x in flatten(items):\n print(x)\n\n" ]

[ 2, 0 ]

[]

[]

[ "python" ]

[ "if you can add .* into your keys it would solve your problem. It is about regular expression. You need to tell that we are looking for something starts with 121 and rest is not important.\nstimuli_dict = {'121.*': 'mp4', '212.*': 'mp3'}\n\n\".\" means any character, \"*\" means previous character between zero and unlimited times. for further explanations, you can check regular expressions.\n" ]

[ 2 ]

[]

[]

[ "dataframe", "python" ]

[ "message.payload.decode() Is what your looking for\n" ]

[ 0 ]

[]

[]

[ "binary", "mqtt", "paho", "parsing", "python" ]

[ "amount is not defined. Define it with a number like 5 and try then.\nYou also need to make sure the variable list is called something else, it is a python-reserved word.\nLastly, make sure the input function has parenthesis () around it. e.x. input(\"enter number: \")\n", "In python the indent is 4 spaces.\nYou need to change the variable name \"list\" because it is a built in name in python.\nYou need to put brackets after input.\namount = 5\n\nnumberList = []\ncount = 0\nwhile count < amount:\n s = int(input(\"enter a number:\"))\n numberList.append(s)\n count += 1\n\n", "I think the problem there is that you're using input() wrong, it should be:\nint(input(\"Enter a number: \"))\n\nAlso, I am assuming that you defined amount earlier in your code, otherwise you will need to in order for your code to work :D\nI also saw a comment saying that list is a python reserved function: It is, however you can use it as a variable name and it will not return an error :)\nHave a good day :D\n" ]

[ 2, 2, 0 ]

[]

[]

[ "python" ]

[ "Ok, you want a program that can calculate the average of some numbers (in any length), so I have some tips for you:\n\nyou have a while loop to repeat something (there, getting number), so get user input only once (in while loop)\nyou need a list, to add all user inputs to it... so create a list before wile loop (data = [])\nyou have a while loop and you need a break condition (equal to 0), so check it in your loop (after getting number from user)\nafter getting each number, you must add it to your list (simply, google how to add an element to a list in python)\nif input is 0, so break (as you did in your code)... but before that calculate average... the formula is sum of numbers divided by length of numbers (both of them have a builtin function in python, if you don't know, simply google it... you get as first result)\nyou want to know if 0 is first number... check it in your main if (number == 0). I mean check whether length of list is 0 or not, and if it is 0, print an error and break.\n\nbe successful... and if you have any question, comment it here :)\n" ]

[ 0 ]

[]

[]

[ "python" ]

[ "Finally I am able to connect to a device using PyBlueZ. I hope this answer will help others in the future. I tried the following:\nFirst, import the modules and discover the devices.\nimport bluetooth, subprocess\nnearby_devices = bluetooth.discover_devices(duration=4,lookup_names=True,\n flush_cache=True, lookup_class=False)\n\nWhen you discover the device you want to connect, you need to know port, the address and passkey. With that information do the next:\nname = name # Device name\naddr = addr # Device Address\nport = 1 # RFCOMM port\npasskey = \"1111\" # passkey of the device you want to connect\n\n# kill any \"bluetooth-agent\" process that is already running\nsubprocess.call(\"kill -9 `pidof bluetooth-agent`\",shell=True)\n\n# Start a new \"bluetooth-agent\" process where XXXX is the passkey\nstatus = subprocess.call(\"bluetooth-agent \" + passkey + \" &\",shell=True)\n\n# Now, connect in the same way as always with PyBlueZ\ntry:\n s = bluetooth.BluetoothSocket(bluetooth.RFCOMM)\n s.connect((addr,port))\nexcept bluetooth.btcommon.BluetoothError as err:\n # Error handler\n pass\n\nNow, you are connected!! You can use your socket for the task you need:\ns.recv(1024) # Buffer size\ns.send(\"Hello World!\")\n\nOfficial PyBlueZ documentation is available here\n", "Is there a way to connect two phones via Bluetooth , the script should be running on a Linux host. Any suggestions of using pybluez or any other APIs?\nI have seen some examples where a Linux host is used as Client and is connect a phone (which is a server), but here I'm want to use Linux host as just a device to run the script and make two phones connect via Bluetooth.\n" ]

[ 16, 0 ]

[]

[]

[ "bluetooth", "linux", "pybluez", "python" ]

[ "The problem statement provided has multiple issues. The statement would benefit from the addition of,\n\nan example of what the json file or doc variable looks like\nthe table definition for the table_name table\ncode is missing the definition of entry_data\n\nThe following solutions applies assumptions due to the missing information mentioned and uses a limited example.\n\nThe error message appears to be saying that the date_id column in the table_name PostGRES table is of type DATE. Whereas the python variable named date_id is a list of strings (or in PostGRES terms data type text[]).\nIt looks like all of the python variables input into the row variable are a lists. This is not a correct format to use for the SQL insert statement.\n\nPart 0. Assumptions\nAssumption 1 - doc looks like this\n\n[{\n\"day\":\"2022-11-30\",\n\"interact_id\":\"8675309\",\n\"case_id\":\"12345\",\n\"topic_id\":\"09876\",\n\"create_date\":\"2022-01-01\",\n\"end_date\":\"2022-12-05\"\n},\n{\n\"day\":\"2022-11-29\",\n\"interact_id\":\"8675307\",\n\"case_id\":\"12344\",\n\"topic_id\":\"08888\",\n\"create_date\":\"2022-02-02\",\n\"end_date\":\"2023-01-05\"\n}]\n\nAssumption 2 - table_name column data types are the following\n\n\n\n\ntable_name\ncolumn_name\ndata_type\n\n\n\n\ntable_name\ndate_id\nDATE\n\n\ntable_name\ninteract_id\nTEXT\n\n\ntable_name\ncase_id\nTEXT\n\n\ntable_name\ntopic_id\nTEXT\n\n\ntable_name\ncreate_date\nTEXT\n\n\ntable_name\nend_date\nTEXT\n\n\n\n\nLook this up for your table using the following command,\nSELECT \n table_name, \n column_name, \n data_type \nFROM \n information_schema.columns\nWHERE \n table_name = 'table_name';\n\nPart 1. Get rid of the python lists for each variable.\nThis solution loops through the json and inserts into the sql table for each item.\n# esablish postgres connection\npg_hook = PostgresHook(postgres_conn_id='postgres_default')\ninsert_cmd = \"\"\"\n INSERT INTO table_name (date_id,interact_id,case_id,topic_id,create_date,end_date)\n VALUES(%s,%s,%s,%s,%s,%s);\n \"\"\"\n# load file\ndoc = read_json_file(filename)\n\n# loop through items in doc\nfor i in range(len(doc)):\n date_id = i['day']\n interact_id = i['interact_id']\n case_id = i['case_id']\n topic_id = i['topic_id']\n create_date = i['create_date']\n end_date = i['end_date']\n row = (date_id, interact_id, case_id, topic_id, create_date, end_date)\n\n # insert item to table\n pg_hook.run(insert_cmd, parameters=row)\n\nPart 2. Ensure each variable matches the data type that PostGRES expects\nThe PostGRES DATE type format accepts many different input types: https://www.postgresql.org/docs/current/datatype-datetime.html#DATATYPE-DATETIME-DATE-TABLE\nyyyy-mm-dd is the recommended DATE format. So we will continue this solution with the assumption that is the format used by the table_name table\nTo fix the error, the python date_id variable will need to be reformatted to a python datetime data type using the python datetime library.\nThe python datetime format definition '%Y/%m/%d' defines the yyyy-mm-dd datetime format\ninstead of this\ndate_id = i['day']\n\nuse this to convert the string to a datetime type\ndate_id = datetime.strptime(i['day'], '%Y/%m/%d')\n\nmore about datetime.strptime function here: https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior\n" ]

[ 1 ]

[]

[]

[ "airflow", "json", "postgresql", "python" ]

[ "Simply you can use the following to return \"end_date\" of last json object:\njson =[{'id':1,'name':'name1','init_date':'date','end_date':'date'}, \n{'id':2,'name':'name2','init_date':'date','end_date':'date'}, \n{'id':3,'name':'name3','init_date':'date','end_date':'date'}, \n{'id':4,'name':'name4','init_date':'date','end_date':'date'}] \n\nprint(json[-1]['end_date'])\n\n" ]

[ 0 ]

[]

[]

[ "arrays", "json", "python" ]

[ "I think the problem is that your function returns a tuple of numbers, but root is expecting a single number.\nAssuming you want to solve each equation separately, then you could include an argument in Compound_Correlation_Function to switch between the functions:\ndef Compound_Correlation_Function(x, return_equity=True):\n \n # Here comes a long part of the code...\n \n if return_equity:\n Equity_Solve = Tranches.loc[0, 'Par_Spread_bps'] - Market_Data.iloc[0,0]\n return Equity_Solve\n else:\n Mezzanine_Solve = Tranches.loc[1, 'Par_Spread_bps'] - Market_Data.iloc[1,0]\n return Mezzanine_Solve\n\nThen pass the return_equity argument in as an extra argument via args, i.e. call\nroot(Compound_Correlation_Function, x0=0.3, args=(True,))\n\nto solve Equity_Solve, and set args=(False,) to solve Mezzanine_Solve.\nYou could also define a function wrapper that calls Compound_Correlation_Function and returns only one of the values.\n", "surely you're overthinking it. Just define two new functions:\ndef equity_solve(x):\n return Compound_Correlation_Function(x)[0]\n\ndef mezzanine_solve(x):\n return Compound_Correlation_Function(x)[1]\n\n" ]

[ 0, 0 ]

[]

[]

[ "python", "scipy_optimize" ]

[ "Following up on this. I sovled it by passing SBATCH directives as args to the sbatch command\n sbatch_args = \"\"\"--job-name=%(name)s --time=%(walltime)s --partition=defq --cpus-per-task=%(processors)s --mem=%(memory)s\"\"\" % (\n {\"walltime\": walltime\n ,\"processors\": cores\n ,\"name\": ''.join(x for x in self.binary_name if x.isalnum())\n ,\"memory\": memory\n })\n\n # Open a pipe to the sbatch command. {tee /home/ahs/schuec1/_stderr_slurmqueue | sbatch; }\n # The SLURM variables SLURM_ARRAY_* do not exist until after sbatch is called.\n # Popen.communicate has BASH interpret all variables at the same time the script is sent.\n # Because of that, the job array needs to be declared prior to the rest of the BASH script.\n\n # It seems further that all SBATCH directives are not being evaultated when passed via a string with .communicate\n # due to this, all SBATCH directives will be passed as arguments to the slurm_wrapper.sh as the first command to the Popen pipe.\n\n proc = Popen('ssh ${USER}@ch3lahpcgw1.corp.cat.com /apps/workflows/slurm_wrapper.sh sbatch %s' % sbatch_args,\n shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE,\n close_fds=True,\n executable='/bin/bash')\n\n" ]

[ 0 ]

[]

[]

[ "hpc", "python", "slurm", "subprocess", "ubuntu" ]

[ "This code:\n\n\nconst regex = /(?<!\")https:\\/\\/t.me\\/(c)?\\/?([\\+a-zA-Z0-9]+)\\/?([0-9]*)?/\nconst text = 'https://t.me/+AjFb2c8u85UfYrY0'\nconst [fullMatch, ...groups] = text.match(regex);\nconsole.log(groups);\n\n\n\nReturns [undefined, \"+AjFb2c8u85UfYrY0\", undefined]\nSo you might think the first undefined is because of your negative lookbehind, but it's not! The first undefined is the result of the (c)? capturing group.\nSo if you capture groups on a url with the /c/ pattern, here is what you'll get:\n\n\nconst regex = /(?<!\")https:\\/\\/t.me\\/(c)?\\/?([\\+a-zA-Z0-9]+)\\/?([0-9]*)?/\nconst text = 'https://t.me/c/+AjFb2c8u85UfYrY0'\nconst [fullMatch, ...groups] = text.match(regex);\nconsole.log(groups);\n\n\n\nSo there is nothing you need to do for the initial negative lookbehind not to create group. It is already working.\n" ]

[ 0 ]

[]

[]

[ "hyperlink", "python", "regex", "regex_group", "telegram" ]

[ "In the UI there is the long-standing Atlassian-suggested approach of adding a global self-transition to all statuses in a workflow, withe a Resolution screen. Then bulk transition the issues back to the same status. More info at\nhttps://confluence.atlassian.com/cloudkb/best-practices-on-using-the-resolution-field-968660796.html#Bestpracticesonusingthe%22Resolution%22field-Thefollowinginstructionsaremeanttocorrectpreviousissuesthathavetheresolutionfieldincorrectlyset.\nThen there is the way that admins with ScriptRunner do it, using the built-in script to fix resolutions.\nTo script this with an external call is harder. I guess reopening the issue and then setting the resolution when closing it again is possible, though slow\n" ]

[ 0 ]

[]

[]

[ "jira", "python", "python_jira" ]

[ "If you execute the code you'll get the following error,\nValueError: time data '05Dec22' does not match format '%d%m%Y'\n\nthis is because your time string is not in the specified format given ('%d%m%Y'). You can search for tables on the internet which show the placeholders that represent a certain formatting, if you look at the one provided here, you'll see that the formatting your string has is '%d%b%y', in this case, the %b placeholder represents the abbreviated month name and the %y placeholder is the year without century, just as your example string. Now, if you fix that in your code,\nimport datetime\n\n\ndate1 = '05Dec22'\ndate1 = datetime.datetime.strptime(date1, '%d%b%y').strftime('%m/%d/%Y')\ndate1 = str(date1)\n\nyou'll get the desired result.\nNote that you also have to change the output format in strftime. As I said before, the %y placeholder is the year without century. For you to get the year including the century, you have to use %Y.\n" ]

[ 0 ]

[]

[]

[ "datetime", "python", "string" ]

[ "The function returns None because you never have a return statement in it. It does mutate total, but it gets mutated in-place.\nTry printing the value of total after the function runs.\n>>> linked_list_values(a)\nNone\n>>> total\n[5, 3, 9] # Assuming a.next == b and b.next == c\n\n", "Your function isn't returning anything for the statement at the bottom to print meaning Python is gonna read the return value of your function as None. A simple fix would be to add a return statement after the recursive call.\na = Node(5)\nb = Node(3) \nc = Node(9) \ntotal = [] \ndef linked_list_values(head): \n if head == None: \n return None \n total.append(head.num) \n linked_list_values(head.next)\n return total \nprint(linked_list_values(a))\n\n" ]

[ 2, 0 ]

[]

[]

[ "linked_list", "python" ]

[ "Core idea: matchTemplate.\nApproach:\n\npick a template manually from the picture\n\nhistogram equalization for badly lit inputs (or always)\n\n\nmatchTemplate with suitable matching mode\n\nalso using copyMakeBorder to catch instances clipping the border\n\n\nthresholding and non-maximum suppression\n\nI'll skip the boring parts and use the first example input.\nManually picked template:\n\nscores = cv.matchTemplate(haystack, template, cv.TM_CCOEFF_NORMED)\n\nThresholding and NMS:\nlevelmask = (scores >= 0.3)\n\nlocalmax = cv.dilate(scores, None, iterations=26)\nlocalmax = (scores == localmax)\n\ncandidates = levelmask & localmax\n\n(nlabels, labels, stats, centroids) = cv.connectedComponentsWithStats(candidates.astype(np.uint8), connectivity=8)\nprint(nlabels-1, \"found\") # background counted too\n# and then draw a circle for each centroid except label 0\n\nAnd that finds 766 instances. I see a few false negatives (missed) and saw a false positive too once, but that looks like less than 1%.\n\n" ]

[ 2 ]

[]

[]

[ "detection", "opencv", "python" ]

[ "Something along these lines should work:\ncombined_features = courses_data[selected_features[0]]\nfor feature in selected_features[1:]:\n combined_features += ' ' + courses_data[feature]\n\n", "Since you are dealing with a pandas dataframe you could just do\ndf2 = courses_data[selected_features].copy()\nprint(df2)\n\nOR\ndf2 = courses_data.filter(selected_features, axis=1)\nprint(df2)\n\nSource\n", "combined_features = \"\"\nselected_features = ['course_name','course_link','university_name','course_type',\n 'university_logo', 'time_required', 'course_language',\n 'course_subtitles', 'course_skills', 'course_rating',\n 'category', 'sub_category', 'course_level']\n\nfor feature in selected_features:\n combined_features += courses_data[feature] + \" \"\n\nprint(combined_features)\n\n" ]

[ 1, 1, 1 ]

[]

[]

[ "dataframe", "for_loop", "python" ]

[ "Figured out a workaround by editing the existing formatter:\nLOG = logging.getLogger()\nLOG.setLevel(logging.INFO)\nlog_handler = LOG.handlers[0]\nlog_handler.setFormatter(logging.Formatter('[%(levelname)s] %(asctime)s.%(msecs)dZ [%(filename)s] [%(funcName)s] %(message)s\\n'))\n\n" ]

[ 0 ]

[]

[]

[ "aws_lambda", "python" ]

[ "This seems to be much faster:\nlist(map(lambda x: lead(Qxx[x], x), range(121)))\n\nPerformance:\nThe OP's solution:\n%%timeit\n\n[[lead(qx,n) for n in range(len(qx))] for qx in Qxx]\n\n178 ms ± 3.32 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n\nMy solution:\n%%timeit\n\nlist(map(lambda x: lead(Qxx[x], x), range(121)))\n\n1.63 ms ± 60.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n\nData:\nQxx = np.array(np.tile(np.arange(121), 121)).reshape((121, 121))\n\n" ]

[ 1 ]

[]

[]

[ "numpy", "python" ]

[ "You can do division normalization in Python/OpenCV to mitigate some of that issue. You basically blur the image and then divide the image by the blurred version.\nInput:\n\nimport cv2\nimport numpy as np\n\n# read the image\nimg = cv2.imread('dark_spots.jpg')\n\n# convert to gray\ngray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n\n# blur\nsmooth = cv2.GaussianBlur(gray, None, sigmaX=10, sigmaY=10)\n\n# divide gray by morphology image\ndivision = cv2.divide(gray, smooth, scale=255)\n\n# save results\ncv2.imwrite('dark_spots_division.jpg',division)\n\n# show results\ncv2.imshow('smooth', smooth) \ncv2.imshow('division', division) \ncv2.waitKey(0)\ncv2.destroyAllWindows()\n\nResults:\n\n" ]

[ 2 ]

[]

[]

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

[ "The name of the enum would be enum_type.__name__.\nBe aware that the square bracket look-up (i.e. enum_type[value]) is actually looking up by member name, not member value. Member value would be enum_type(value).\n" ]

[ 1 ]

[]

[]

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

[ "After getting some useful info in StackExchange.\nBasic Example of solution on Python:\nfrom scipy.spatial.transform import Rotation as Rotation\n\nRobotPoint = gps.getValues()\nSTR = Rotation.from_quat(InertialUnit.getQuaternion())\nfor RelativeCloudPoint in lidar.getPointCloud():\n Point2 = STR.apply(RelativeCloudPoint)\n GlobalCloudPoint = RelativeCloudPoint + RobotPoint\n\nUsing InternalUnit to get Quaternion for spartial rotation matrix. Then apply it to relative coordinates. After that add to it real robot coordinates from GPS. In the end you will get global coordinates of points you need.\n" ]

[ 0 ]

[]

[]

[ "compass", "coordinate_transformation", "lidar", "python", "webots" ]

[ "Apparently the answer is super simple(!), there is nothing special we need to do - SQLAlchemy support it by itself.\nMeaning - you can set the specific column to be INT in the DB, but enum in the model, and when querying the DB SQLAlchemy will convert it by itself. same goes when inserting to the DB :)\nI used it with declarative enum, it means it's values are strings (and it has a function - from_string()).\nSo once I used VARCHAR columns, it worked like a charm! \n", "Sqlalchemy checks the db if native type enum is available.\nIf the db does not support this, the default type is VARCHAR.\nSo you can\nEnum(MyEnum, native_enum=False)\n\n" ]

[ 0, 0 ]

[]

[]

[ "enums", "mysql", "orm", "python", "sqlalchemy" ]

[ "You can't store a multidimensional array in a pandas Series. So when you create your \"array\" in your example, you're actually creating a pandas column with object dtype, where each element is a python list.\nOne option for storing a MultiDimensional array as HDF5 is by using xarray, another pydata project which extends the pandas concept of labeled indices, but to N dimensions.\nThe xarray equivalent of your example goes something like this:\nimport xarray as xr\n\nds = xr.Dataset({\n \"Value\": ((\"x\", \"y\"), [[1, 2], [3, 4], [5, 6]]),\n})\n\nds.to_netcdf(\"foo.h5\", engine=\"h5netcdf\")\n\nThis creates a valid HDF5 file using the NetCDF4 standard, using the h5netcdf package, which is built on h5py.\n" ]

[ 0 ]

[]

[]

[ "hdf5", "pandas", "python" ]

[ "f_read = open(tweets_file_name, \"r\")\nf_write = open(tweets_file_name, \"w\")\n\nYou're opening the file for reading and then also opening it for writing, which destroys the existing contents.\n" ]

[ 0 ]

[]

[]

[ "dictionary", "file", "python", "traversal" ]

[ "The user's input will be a string, so you need to check if the parse to the float was successful. You can do that with a try/except, and then loop back over asking for more input:\nprint(\"First, what was the total for the bill?\")\n\nmeal_price = None\nwhile meal_price == None:\n try:\n meal_price = float(input(\"Bill (Numerical values only):\"))\n except ValueError:\n print(\"That didn't look like a number, please try again\")\nprint(meal_price)\n\n", "Adding on to @OliverRadini's answer, you use the same structure a lot for each of your inputs that could be generalized into a single function like so\ndef get_input(prompt, datatype):\n value = input(prompt)\n try:\n a = datatype(value)\n return a\n except:\n print(\"Input failed, please use {:s}\".format(str(datatype)))\n return get_input(prompt, datatype)\n\na = get_input(\"Bill total: \", float)\nprint(a)\n\n", "Perhaps the main point of confusion is that input() will always return what the user enters as a string.\nTherefore trying to check whether meal_price is something other than a string will always fail.\nOnly some strings can be converted into floats - if you try on an inappropriate string, an exception (specifically, a ValueError) will be raised.\nSo this is where you need to learn a bit about exception handling. Try opening with this block:\nmeal_price = None\n\nwhile meal_price is None:\n\n try:\n meal_price = float(input(\"Bill (Numerical values only): \"))\n except ValueError:\n print(\"Please remember to enter only a numerical value.\\n\")\n\nThis will try to execute your statement, but in the event it encounters a value error, you tell it not to raise the exception, but to instead print a message (and the loop restarts until they get it right, or a different kind of error that you haven't handled occurs).\n", "Thank you all! After looking into your comments and making the amendments, my program works perfectly! You lot rock!!\ndef calculation():\n tip_percent = tip / 100\n tip_amount = bill * tip_percent\n meal_and_tip = tip_amount + bill\n total_to_return = meal_and_tip / to_split\n return total_to_return\n\ndef user_input(prompt, datatype):\n value = input(prompt)\n try:\n input_to_return = datatype(value)\n return input_to_return\n except ValueError:\n print(\"Input failed, please use {:s}\".format(str(datatype)))\n return user_input(prompt, datatype)\n\n\nprint(\"\\nWelcome to the \\\"Bill Tip Calculator\\\"!\")\nprint(\"\\nAll you need to do is:\\n1.) Enter your bill\\n2.) Enter the amount of \npeople (if bill is being split)\\n3.) Enter the amount you would like to \ntip.\")\nprint(\"\\n\\n1.) What was the total for the bill?\")\nbill = user_input(\"Total Bill: \", float)\nprint(\"\\nAwesome, the total for your meal was \" + \"$\" + str(bill) + \".\")\nprint(\"\\n\\n2.) How many people are splitting the bill?\")\nto_split = user_input(\"Number of People: \", int)\nprint(\"\\nSo the bill is divided\", str(to_split), \"way(s).\")\nprint(\"\\n\\n3.) What percent of the bill would you like to leave as a tip? \n(Enter a numeral value only. No special characters.)\")\ntip = user_input(\"Tip: \", int)\nprint(\"\\nYou would like to tip\", str(tip) + \"%! Nice!\")\ntotal = calculation()\nprint(\"\\n\\n\\n\\nYour total is \" + \"$\" + str(total), \"each! Thank you for using \nthe \\\"Bill Tip Calculator\\\"!\")\n\n" ]

[ 0, 0, 0, 0 ]

[]

[]

[ "if_statement", "python" ]

[ "There are many possible causes for XHR errors. You can refer to this article, and I think the easiest way is to restart or reinstall vscode.\n" ]

[ 0 ]

[]

[]

[ "python", "visual_studio_code" ]

[ "I think you should add conditions for Dropdown. Something as below:\[email protected](\n Output('the_graph', 'figure'),\n [Input('the_year', 'value'),\n Input('the_country', 'value')]\n)\n\ndef update_graph(sel_year, sel_country):\n dff = data[(data['year']>=sel_year[0]) & (data['year']<=sel_year[1])]\n if sel_country == []:\n dff_2 = dff.copy()\n elif sel_country != []:\n dff_2 = dff[dff['country'].isin(sel_country)]\n \n graph = px.line(\n dff_2,\n x=dff_2['year'],\n y=ddff_2['pop'],\n color=dff_2['country'],\n markers=True,\n )\n \n return graph\n\n" ]

[ 0 ]

[]

[]

[ "plotly_dash", "python" ]

[ "You could build a lookup table using a dict:\nlookup = {(True, True, True, True): func_1,\n (True, True, True, False): func_2,\n (True, True, False, True): func_3,\n ... etc.\n }\nfunc = lookup[a(x), b(x), c(x), d(x)]\nfunc()\n\n", "You can count the number of True booleans using arithmetic operators\nnumTrue = (a(x) == True) + (b(x) == True) + (c(x) == True) + (d(x) == True)\nif numTrue==4:\n # foo\nelif numTrue==3:\n # bar\nelif numTrue==2:\n # ...\nelif numTrue==1:\n #...\nelse:\n # ...\n\nNote that I kept your redundant structure x==True, which, from a boolean point a view is just a convoluted version of x. But at least, now, I am sure that your booleans (since I know nothing of a(x) and others) are True or False, not other truthiness are falseness.\n", "\nincluding when only 3 of them are true\n\nThis suggests you'd like to know that N of the 4 values are true:\nvals = a(x), b(x), c(x), d(x)\nnum_true = sum(map(bool, vals))\n\n\nGiven such a vector of booleans, there are 2 ** 4 == 16 possibilities.\nWe can put 16 values into a dict named d and go from there.\nk = \" \".join(map(str, map(int, map(bool, vals))))\nprint(d[k])\n\n\nIf the identities don't matter to you,\nthen sort so we have fewer than 16 possibilities:\nk = \" \".join(sorted(map(str, map(int, map(bool, vals)))))\n\n", "The solution with the lookup table is great but if you wanted to do something that takes less memory and around the same speed. You can use the if statement results to build on each other this way you'd only have 2^4(16) cases i.e:\nif (a(x)):\n if(b(x):\n if(c(x)):\n if(d(x)):\n #do x\n else:\n #do y\n else:\n if (d(x)):\n #do z\n else:\n #do w\n #...\n\n" ]

[ 2, 0, 0, 0 ]

[]

[]

[ "boolean_expression", "if_statement", "python" ]

[ "I had the same issue aswell, it was cured by placing the whole file path into the kwarg in config:\ndef config(filename='/Users/gramb0t/Desktop/python-postgre/data/database.ini', section='postgresql'):\n", "#just remove the $FILEDIR. it worked for me.\n\nfrom configparser import ConfigParser\n\ndef config(filename=\"database.ini\", section=\"postgresql\"):\n # create a parser\n parser = ConfigParser()\n # read config file\n parser.read(filename)\n\n # get section, default to postgresql\n db = {}\n if parser.has_section(section):\n params = parser.items(section)\n for param in params:\n db[param[0]] = param[1]\n else:\n raise Exception(\n \"Section {0} not found in the {1} file\".format(section, filename)\n )\n\n return db\n\n", "the problem in path\nfor solve this you can use os to get dir to database.ini as following example\nimport os\nBASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))\nparams = config(filename=BASE_DIR+'\\memory\\database.ini', section='postgresql_pc__server')\n\n", "# The thing is, you made a mistake. You don’t need to add or invent anything, just do this: #\n\ndef config(filename=r'/database.ini', section='postgresql'):\n parser = ConfigParser()\n parser.read(filename)\n # получить раздел, по умолчанию postgresql\n db = {}\n\n if parser.has_section(section):\n print(section)\n params = parser.items(section)\n\n for param in params:\n db[param[0]] = param[1]\n else:\n raise Exception(\"Раздел {0} не найдено в {1} файл\".format(section, filename))\n return db\n \n## but if you are in the main directory then (r, '/') you most likely need to remove and leave everything as in the documentation ##\n\n" ]

[ 7, 3, 2, 0 ]

[]

[]

[ "configparser", "python", "python_2.7" ]

[ "Try the below looping through the list of tickers, appending the dataframes as you loop onto the CSV.\nimport pandas as pd\nfrom yahooquery import Ticker\n\n\nsymbols = [#All Of Your Symbols Here]\nfor tick in symbols:\n faang = Ticker(tick)\n faang.summary_detail\n df = pd.DataFrame(faang.summary_detail).T\n \n df.to_csv('summary_detailsample.csv', mode='a', index=True, header=False)\n\n" ]

[ 2 ]

[]

[]

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

[ "g = person_in_charge_raw.groupby(['BRANCH_NO', 'CUSTOMER_NO'])\ng.agg('|'.join).reset_index()\n\n" ]

[ 2 ]

[]

[]

[ "pandas", "pipe", "python" ]

[ "Do you have multiple python environments on your machine? Make sure you are using the one you have sklearn installed on.\nYou can use the following code to check the interpreter you are using, and then use the obtained path to install the sklearn package for the current environment.\nimport sys\nprint(sys.executable)\n\n\nOr select the interpreter that has installed the sklearn package in the Select Interpreter panel(Ctrl+Shift+P --> Python:Select Interpreter), and then create a new terminal activation environment.\n\n" ]

[ 0 ]

[]

[]

[ "python", "scikit_learn", "visual_studio_code" ]

[ "This is caused by faust not waiting for agent/table initialisation in client-only mode. Just replace FastAPI's app startup handler with something like that:\[email protected]_event(\"startup\")\nasync def startup():\n # set up the faust app\n faust_app = worker.set_faust_app_for_api()\n await faust_app.start_client()\n await asyncio.sleep(5.0) # wait for agents and table to initialise \n await faust_app.topics.on_client_only_start() # resubscribe to topics\n\nPlease note that in case you're using faust-streaming fork please make sure to use a version newer than 5th of October 2022 as it had another code issue preventing this code to work.\n" ]

[ 0 ]

[]

[]

[ "apache_kafka_streams", "async_await", "fastapi", "faust", "python" ]

[ "I was able to solve it by creating an ALTER statement and first making that column TEXT then combining date_format and str_to_date like I did on S_DATE. Still not really sure why I had to do that for one column and not the other.\n" ]

[ 0 ]

[]

[]

[ "date_format", "load_data_infile", "mysql", "python", "str_to_date" ]

[ "You define this method, but you don't really run it.\nAdd another line at the last:\nget_isu_worldrecord_db(engine)\n\n" ]

[ 1 ]

[]

[]

[ "mysql_workbench", "python", "visual_studio_code" ]

[ "Does the following solve your problem?\nnew_list=[]\nfor i in json_data:\n if not i in new_list:\n new_list.append(i)\nprint(new_list)\n\n", "Even though OP asked to do this in Python, this can readily be done in jq using function unique with a single update assignment:\n$ jq '.[].permissions[].collections |= unique' json.txt \n[\n {\n \"authType\": \"ldap\",\n \"password\": \"\",\n \"permissions\": [\n {\n \"collections\": [\n \"aks9098\",\n \"aks9099\",\n \"aks9100\",\n \"aks9101\",\n \"aks9102\",\n \"aks9103\"\n ],\n \"project\": \"Central Project\"\n }\n ],\n \"role\": \"devSecOps\",\n \"username\": \"[email protected]\"\n },\n {\n \"authType\": \"ldap\",\n \"password\": \"\",\n \"permissions\": [\n {\n \"collections\": [\n \"aks9098\",\n \"aks9099\",\n \"aks9100\",\n \"aks9101\",\n \"aks9102\",\n \"aks9103\"\n ],\n \"project\": \"Central Project\"\n }\n ],\n \"role\": \"devSecOps\",\n \"username\": \"[email protected]\"\n },\n {\n \"authType\": \"ldap\",\n \"password\": \"\",\n \"permissions\": [\n {\n \"collections\": [\n \"aks9098\",\n \"aks9099\",\n \"aks9100\",\n \"aks9101\",\n \"aks9102\",\n \"aks9103\"\n ],\n \"project\": \"Central Project\"\n }\n ],\n \"role\": \"devSecOps\",\n \"username\": \"[email protected]\"\n }\n]\n\nTo invoke this in Python, one could do this:\nimport subprocess\nreturn_obj = subprocess.run([\"jq\", \".[].permissions[].collections |= unique\",\"json.txt\"], stdout=subprocess.PIPE)\njson_data = return_obj.stdout.decode()\n\n" ]

[ 0, 0 ]

[]

[]

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

[ "The Ray scheduler decides how many Ray tasks run concurrently based on their num_cpus value (along with other resource types for more advanced use cases). By default, this value is set to 1, meaning that you can run parallel tasks up to the total number of cores. By setting it to 16, you are telling Ray that each task requires all 16 CPUs to run, so essentially you are running the square tasks sequentially. Try running it again with just a plain @ray.remote!\nYou may also want to warm up Ray by running a few times within the same script, since there is some cost from process startup at the beginning.\nFinally, in an actual workload, you would probably want to do more than multiply two integers together. Each task will finish nearly instantaneously, so you will see more overhead than benefit from the extra work of distributing the execution. There's some good info on this anti-design pattern here.\n" ]

[ 2 ]

[]

[]

[ "joblib", "parallel_processing", "python", "ray" ]

[ "I think you're missing the fact that the @command decorator turns the foo function into a Command that uses the original foo as callback. The original function is still accessible as foo.callback but foo is a Command. Still, you can't use a partial object as callback because it lacks __name__, but you can work around that passing the name explicitly:\nbar = functools.partial(foo.callback, myname=\"bar\")\ncli.command(\"bar\")(bar)\n\n# Alternative:\ncli.add_command(click.Command(\"bar\", callback=bar))\n\n" ]

[ 1 ]

[]

[]

[ "python", "python_click" ]

[ "Add the below code and try:\nfrom selenium import webdriver\nfrom selenium.webdriver.chrome.service import Service\nfrom selenium.webdriver.chrome.options import Options\n\noptions = Options()\noptions.add_experimental_option(\"detach\", True)\n\ndriver = webdriver.Chrome(service=Service(<chromedriver.exe path>), options=options)\n\ndriver.get(<URL>)\n\n" ]

[ 0 ]

[]

[]

[ "python", "selenium" ]

[ "crosstab\npd.crosstab(df['Type'], df['Generation']).rename(columns=lambda x: f'Generation_{x}')\n\nresult:\nGeneration Generation_1 Generation_2 Generation_3\nType \nFire 2 0 0\nGrass 2 1 1\n\n\nor you can use add_prefix instead rename\npd.crosstab(df['Type'], df['Generation']).add_prefix('Generation_')\n\n\nand you can change order of index by reindex\npd.crosstab(df['Type'], df['Generation']).add_prefix('Generation_').reindex(df['Type'].unique())\n\nresult:\nGeneration Generation_1 Generation_2 Generation_3\nType \nGrass 2 1 1\nFire 2 0 0\n\n" ]

[ 0 ]

[]

[]

[ "pandas", "pivot", "python" ]

[ "I've been struggling a lot with this and turns out there are quite a few points that have to be set in order to achieve complete consistency for every case:\nFirst of all, make sure the data (and the order of the data) that you feed to your model is consistent. Then, for the model weights initialization:\n1)numpy random seed\nimport numpy as np\nnp.seed(1)\n\n2)tensor flow random seed\nimport tensorflow as tf\ntf.set_random_seed(2)\n\n3)python random seed\nimport random\nrandom.seed(3)\n\nAdditionally to that, you have to set two (if you have multiprocessing capabilities) arguments to model.fit. These ones are not often mentioned on the answers I've seen around:\nmodel.fit(..., shuffle=False, use_multiprocessing=False)\n\nOnly then I have achieved complete consistency in training runs.\nHope that helps people!\n", "tf.keras.initializers objects have a seed argument for reproducible initialization.\nimport tensorflow as tf\nimport numpy as np\n\ninitializer = tf.keras.initializers.GlorotUniform(seed=42)\n\nfor _ in range(10):\n print(np.round(initializer((4,)), 3))\n\n[-0.377 -0.003 0.373 -0.831]\n[-0.377 -0.003 0.373 -0.831]\n[-0.377 -0.003 0.373 -0.831]\n[-0.377 -0.003 0.373 -0.831]\n[-0.377 -0.003 0.373 -0.831]\n[-0.377 -0.003 0.373 -0.831]\n[-0.377 -0.003 0.373 -0.831]\n[-0.377 -0.003 0.373 -0.831]\n[-0.377 -0.003 0.373 -0.831]\n[-0.377 -0.003 0.373 -0.831]\n\nIn a Keras layer, you can use it like this:\ntf.keras.layers.Dense(1024, \n activation='relu', \n input_dim=2048,\n kernel_initializer=tf.keras.initializers.GlorotUniform(seed=42))\n\n", "I think a better practice is\ntf.keras.utils.set_random_seed(\n seed\n)\n\nref: https://www.tensorflow.org/api_docs/python/tf/keras/utils/set_random_seed\n" ]

[ 2, 1, 0 ]

[]

[]

[ "keras", "python", "reproducible_research", "tensorflow" ]

[ "Can you try adding append to corresponding index\nmylist[2][2].append(555)\n" ]

[ 1 ]

[]

[]

[ "python" ]

[ "Assign two variables, then in the loop body you can split the second variable into two more variables.\nfor pais, value in dirs.items():\n tipos, nombres = value\n\n" ]

[ 0 ]

[]

[]

[ "for_loop", "items", "python", "valueerror" ]

[ "Doing this would only make sense if A is an abstract base class, meaning that A is only meant to be used as a base for other classes, not instantiated directly. If that were the case, you would define methodB on class A, but leave it unimplemented:\nclass A(object):\n def methodA(self):\n print(\"in methodA\")\n\n def methodB(self):\n raise NotImplementedError(\"Must override methodB\")\n\n\nfrom parent import A\nclass B(A):\n def methodB(self):\n print(\"am in methodB\")\n\nThis isn't strictly necessary. If you don't declare methodB anywhere in A, and instantiate B, you'd still be able to call methodB from the body of methodA, but it's a bad practice; it's not clear where methodA is supposed to come from, or that child classes need to override it.\nIf you want to be more formal, you can use the Python abc module to declare A as an abstract base class.\nfrom abc import ABC, abstractmethod\n\nclass A(ABC):\n\n def methodA(self):\n print(\"in methodA\")\n\n @abstractmethod\n def methodB(self):\n raise NotImplementedError(\"Must override methodB\")\n\nOr if using Python 2.x:\nfrom abc import ABCMeta, abstractmethod\n\nclass A(object):\n __metaclass__ = ABCMeta\n\n def methodA(self):\n print(\"in methodA\")\n\n @abstractmethod\n def methodB(self):\n raise NotImplementedError(\"Must override methodB\")\n\nUsing this will actually prevent you from instantiating A or any class that inherits from A without overriding methodB. For example, if B looked like this:\nclass B(A):\n pass\n\nYou'd get an error trying to instantiate it:\nTraceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\nTypeError: Can't instantiate abstract class B with abstract methods methodB\n\nThe same would happen if you tried instantiating A.\n", "You can do something like this:\nclass A():\n def foo(self):\n self.testb()\n\nclass B(A):\n def testb(self):\n print('lol, it works')\nb = B()\nb.foo()\n\nWhich would return this of course:\nlol, it works\n\nNote, that in fact there is no call from parent, there is just call of function foo from instance of child class, this instance has inherited foo from parent, i.e. this is impossible:\na=A()\na.foo()\n\nwill produce:\n AttributeError: A instance has no attribute 'testb'\nbecause\n>>> dir(A)\n['__doc__', '__module__', 'foo']\n>>> dir(B)\n['__doc__', '__module__', 'foo', 'testb']\n\nWhat I've wanted to show that you can create instance of child class, and it will have all methods and parameters from both parent and it's own classes. \n", "There are three approaches/ways to do this ! but I highly recommend to use the approach #3 because composition/decoupling has certain benefits in terms of design pattern. (GOF)\n## approach 1 inheritance \nclass A():\n def methodA(self):\n print(\"in methodA\")\n def call_mehtodB(self):\n self.methodb()\n\nclass B(A):\n def methodb(self):\n print(\"am in methodb\")\n\nb=B()\nb.call_mehtodB()\n\n\n## approach 2 using abstract method still class highly coupled\nfrom abc import ABC, abstractmethod\nclass A(ABC):\n def methodA(self):\n print(\"in methodA\")\n @abstractmethod \n def methodb(self):\n pass\n\nclass B(A):\n\n def methodb(self):\n print(\"am in methodb\")\n\nb=B()\nb.methodb()\n\n#approach 3 the recommended way ! Composition \n\nclass A():\n def __init__(self, message):\n self.message=message\n\n def methodA(self):\n print(self.message)\n\nclass B():\n def __init__(self,messageB, messageA):\n self.message=messageB\n self.a=A(messageA)\n\n def methodb(self):\n print(self.message)\n\n def methodA(self):\n print(self.a.message)\n\nb=B(\"am in methodb\", \"am in methodA\")\nb.methodb()\nb.methodA()\n\n", "You could use the function anywhere so long as it was attached to an object, which it appears to be from your sample. If you have a B object, then you can use its methodb() function from absolutely anywhere.\nparent.py:\nclass A(object):\n def methoda(self):\n print(\"in methoda\")\n\ndef aFoo(obj):\n obj.methodb()\n\nchild.py\nfrom parent import A\nclass B(A):\n def methodb(self):\n print(\"am in methodb\")\n\nYou can see how this works after you import:\n>>> from parent import aFoo\n>>> from child import B\n>>> obj = B()\n>>> aFoo(obj)\nam in methodb\n\nGranted, you will not be able to create a new B object from inside parent.py, but you will still be able to use its methods if it's passed in to a function in parent.py somehow.\n", "If the both class in same .py file then you can directly call child class method from parents class.\nIt gave me warning but it run well.\nclass A(object):\ndef methodA(self):\n\n print(\"in methodA\")\n\n Self.methodb()\n\nclass B(A):\ndef methodb(self):\n\n print(\"am in methodb\")\n\n", "You can certainly do this -\nparent.py\nclass A(object):\n def __init__(self,obj):\n self.obj_B = obj\n\n def test(self): \n self.obj_B.methodb()\n\nchild.py\nfrom parent import A\n\nclass B(A):\n def __init__(self,id):\n self.id = id\n super().__init__(self)\n \n def methodb(self):\n print(\"in method b with id:\",self.id)\n\nNow if you want to call it from class B object\n\nb1 = B(1)\nb1.test()\n\n>>> in method b with id: 1\n\nOr if you want to call it from class A object\nb2 = B(2)\na = A(b2)\na.test()\n\n>>> in method b with id: 2\n\nYou can even make new objects in super class by invoking class dict objects of the object passed to super class from child class.\n" ]

[ 46, 20, 2, 1, 0, 0 ]

[]

[]

[ "class", "inheritance", "parent", "python" ]

[ "If you are in Python 3.10+ you could try pairwise:\nAnd you should try NOT to use the built-in list as the variable name.\nIt's quite easy and straightforward to make this one-line into a function.\n\nfrom itertools import pairwise\n\n>>>[b-a for a, b in pairwise(lst)] # List Comprehension\n[3, 4, 4]\n\n# Or just zip()\ndiffs = [b-a for a, b in zip(lst, lst[1:]) ] # no import \n\n\n", "You can simply loop for each item starting from element 1:\ndef diff(source):\n return [source[i] - source[i - 1] for i in range(1, len(source))]\n\nprint(diff([4, 7, 11, 15])) # [3, 4, 4]\n\n", "num_list = [4, 7, 11, 15]\n\ndef difference(numbers):\n diff_list = []\n\n for i in range(1, len(numbers)):\n diff_list.append(numbers[i] - numbers[i - 1])\n\n return diff_list\n\n\nprint(difference(num_list)) # [3, 4, 4]\n\n" ]

[ 3, 0, 0 ]

[]

[]

[ "for_loop", "list", "python" ]

[ "def mostrar_index(request):\n imagenes = Avatar.objects.filter(user=request.user.id)\n return render(request, 'index.html', {'avatar': imagenes})\n\n{% if request.user.is_authenticated %}\n {% if avatar %}\n <img src=\"{{avatar.images.url}}\" alt=\"\">\n {% else %}\n <img src=\"{% static 'default/image.ext' %}\" alt=\"\">\n {% endif %}\n <h1>Hola {{user.username}} como te va? </h1>\n <p>Si deseas deslogearte haz click aqui! </p>\n <li> <a href=\"{% url 'Logout'%}\">Logout</a> </li>\n{% else %}\n...\n{% endif %}\n\n" ]

[ 0 ]

[]

[]

[ "css", "django", "html", "python" ]

[ "try:\n\npip install --upgrade pip\n\nOn Windows the recommended command is:\n\npython -m pip install --upgrade pip\n\n", "You're almost there. Check the error logs carefully. You'll notice it's asking for:\nIs libxml2 installed?\n\nTry installing that with pip then retry.\n" ]

[ 0, 0 ]

[]

[]

[ "pandas", "python" ]

[ "Perhaps you've reconfigured your environment somehow? (Try Runtime menu -> Reset all runtimes...) Your snippets works exactly as written for me --\n\n", "logging.basicConfig can be run just once*\nAny subsequent call to basicConfig is ignored.\n* unless you are in Python 3.8 and use the flag force=True\nlogging.basicConfig(filename='app.log',\n level=logging.DEBUG,\n force=True, # Resets any previous configuration\n )\n\n\nWorkarounds (2)\n(1) You can easily reset the Colab workspace with this command\nexit\n\nWait for it to come back and try your commands again.\n(2) But, if you plan to do the reset more than once and/or are learning to use logging, maybe it is better to use %%python magic to run the entire cell in a subprocess. See photo below.\n\n\n\nWhat is it that I am missing here?\n\nDeeper understanding of how logging works. It is a bit tricky, but there are many good webs explaining the gotchas.\n\nIn Colab\nhttps://realpython.com/python-logging\n\n", "[This answer][1] cover the issue.\nYou have to:\n\nClear your log handlers from the environment with logging.root.removeHandler\nSet log level with logging.getLogger('RootLogger').setLevel(logging.DEBUG).\n\nSetting level with logging.basicConfig only did not work for me.\n" ]

[ 7, 2, 0 ]

[]

[]

[ "error_handling", "google_colaboratory", "jupyter_notebook", "logging", "python" ]

[ "When you load a JSON file into Python using json.load, it creates a copy of that JSON in Python. When that copy is changed, these changes are not reflected in the file.\nSo what you need to do is then transfer your changed copy back to the file.\nThis can be achieved via a method in the same json library as you're using, dump. Additionally, we need to supply an additional parameter to open to specify that we are writing to the file, not just reading.\nimport json\n\njson_data = json.load(open('reda.json'))\nk = \"carl\"\nfor d in json_data:\n if k in d:\n del d[k]\n\njson.dump(json_data, open('reda.json','w'))\n\nReferences\n\nPython 3.11.0 Documentation: json.dump\nPython 3.11.0 Documentation: open\n\n" ]

[ 2 ]

[]

[]

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

[ "You can use a global variable within other functions by declaring it as global within each function that assigns a value to it:\nglobvar = 0\n\ndef set_globvar_to_one():\n global globvar # Needed to modify global copy of globvar\n globvar = 1\n\ndef print_globvar():\n print(globvar) # No need for global declaration to read value of globvar\n\nset_globvar_to_one()\nprint_globvar() # Prints 1\n\nSince it's unclear whether globvar = 1 is creating a local variable or changing a global variable, Python defaults to creating a local variable, and makes you explicitly choose the other behavior with the global keyword.\nSee other answers if you want to share a global variable across modules.\n", "If I'm understanding your situation correctly, what you're seeing is the result of how Python handles local (function) and global (module) namespaces.\nSay you've got a module like this:\n# sample.py\n_my_global = 5\n\ndef func1():\n _my_global = 42\n\ndef func2():\n print _my_global\n\nfunc1()\nfunc2()\n\nYou might expecting this to print 42, but instead it prints 5. As has already been mentioned, if you add a 'global' declaration to func1(), then func2() will print 42.\ndef func1():\n global _my_global \n _my_global = 42\n\nWhat's going on here is that Python assumes that any name that is assigned to, anywhere within a function, is local to that function unless explicitly told otherwise. If it is only reading from a name, and the name doesn't exist locally, it will try to look up the name in any containing scopes (e.g. the module's global scope).\nWhen you assign 42 to the name _my_global, therefore, Python creates a local variable that shadows the global variable of the same name. That local goes out of scope and is garbage-collected when func1() returns; meanwhile, func2() can never see anything other than the (unmodified) global name. Note that this namespace decision happens at compile time, not at runtime -- if you were to read the value of _my_global inside func1() before you assign to it, you'd get an UnboundLocalError, because Python has already decided that it must be a local variable but it has not had any value associated with it yet. But by using the 'global' statement, you tell Python that it should look elsewhere for the name instead of assigning to it locally.\n(I believe that this behavior originated largely through an optimization of local namespaces -- without this behavior, Python's VM would need to perform at least three name lookups each time a new name is assigned to inside a function (to ensure that the name didn't already exist at module/builtin level), which would significantly slow down a very common operation.)\n", "You may want to explore the notion of namespaces. In Python, the module is the natural place for global data:\n\nEach module has its own private symbol table, which is used as the global symbol table by all functions defined in the module. Thus, the author of a module can use global variables in the module without worrying about accidental clashes with a user’s global variables. On the other hand, if you know what you are doing you can touch a module’s global variables with the same notation used to refer to its functions, modname.itemname.\n\nA specific use of global-in-a-module is described here - How do I share global variables across modules?, and for completeness the contents are shared here:\n\nThe canonical way to share information across modules within a single program is to create a special configuration module (often called config or cfg). Just import the configuration module in all modules of your application; the module then becomes available as a global name. Because there is only one instance of each module, any changes made to the module object get reflected everywhere. For example:\n\n\nFile: config.py\n\n\nx = 0 # Default value of the 'x' configuration setting\n\n\n\nFile: mod.py\n\nimport config\nconfig.x = 1\n\n\nFile: main.py\n\nimport config\nimport mod\nprint config.x\n\n", "Python uses a simple heuristic to decide which scope it should load a variable from, between local and global. If a variable name appears on the left hand side of an assignment, but is not declared global, it is assumed to be local. If it does not appear on the left hand side of an assignment, it is assumed to be global. \n>>> import dis\n>>> def foo():\n... global bar\n... baz = 5\n... print bar\n... print baz\n... print quux\n... \n>>> dis.disassemble(foo.func_code)\n 3 0 LOAD_CONST 1 (5)\n 3 STORE_FAST 0 (baz)\n\n 4 6 LOAD_GLOBAL 0 (bar)\n 9 PRINT_ITEM \n 10 PRINT_NEWLINE \n\n 5 11 LOAD_FAST 0 (baz)\n 14 PRINT_ITEM \n 15 PRINT_NEWLINE \n\n 6 16 LOAD_GLOBAL 1 (quux)\n 19 PRINT_ITEM \n 20 PRINT_NEWLINE \n 21 LOAD_CONST 0 (None)\n 24 RETURN_VALUE \n>>> \n\nSee how baz, which appears on the left side of an assignment in foo(), is the only LOAD_FAST variable.\n", "If you want to refer to a global variable in a function, you can use the global keyword to declare which variables are global. You don't have to use it in all cases (as someone here incorrectly claims) - if the name referenced in an expression cannot be found in local scope or scopes in the functions in which this function is defined, it is looked up among global variables.\nHowever, if you assign to a new variable not declared as global in the function, it is implicitly declared as local, and it can overshadow any existing global variable with the same name.\nAlso, global variables are useful, contrary to some OOP zealots who claim otherwise - especially for smaller scripts, where OOP is overkill.\n", "\nIf I create a global variable in one function, how can I use that variable in another function?\n\nWe can create a global with the following function:\ndef create_global_variable():\n global global_variable # must declare it to be a global first\n # modifications are thus reflected on the module's global scope\n global_variable = 'Foo' \n\nWriting a function does not actually run its code. So we call the create_global_variable function:\n>>> create_global_variable()\n\nUsing globals without modification\nYou can just use it, so long as you don't expect to change which object it points to: \nFor example, \ndef use_global_variable():\n return global_variable + '!!!'\n\nand now we can use the global variable:\n>>> use_global_variable()\n'Foo!!!'\n\nModification of the global variable from inside a function\nTo point the global variable at a different object, you are required to use the global keyword again:\ndef change_global_variable():\n global global_variable\n global_variable = 'Bar'\n\nNote that after writing this function, the code actually changing it has still not run:\n>>> use_global_variable()\n'Foo!!!'\n\nSo after calling the function:\n>>> change_global_variable()\n\nwe can see that the global variable has been changed. The global_variable name now points to 'Bar':\n>>> use_global_variable()\n'Bar!!!'\n\nNote that \"global\" in Python is not truly global - it's only global to the module level. So it is only available to functions written in the modules in which it is global. Functions remember the module in which they are written, so when they are exported into other modules, they still look in the module in which they were created to find global variables.\nLocal variables with the same name\nIf you create a local variable with the same name, it will overshadow a global variable:\ndef use_local_with_same_name_as_global():\n # bad name for a local variable, though.\n global_variable = 'Baz' \n return global_variable + '!!!'\n\n>>> use_local_with_same_name_as_global()\n'Baz!!!'\n\nBut using that misnamed local variable does not change the global variable:\n>>> use_global_variable()\n'Bar!!!'\n\nNote that you should avoid using the local variables with the same names as globals unless you know precisely what you are doing and have a very good reason to do so. I have not yet encountered such a reason.\nWe get the same behavior in classes\nA follow on comment asks:\n\nwhat to do if I want to create a global variable inside a function inside a class and want to use that variable inside another function inside another class?\n\nHere I demonstrate we get the same behavior in methods as we do in regular functions:\nclass Foo:\n def foo(self):\n global global_variable\n global_variable = 'Foo'\n\nclass Bar:\n def bar(self):\n return global_variable + '!!!'\n\nFoo().foo()\n\nAnd now:\n>>> Bar().bar()\n'Foo!!!'\n\nBut I would suggest instead of using global variables you use class attributes, to avoid cluttering the module namespace. Also note we don't use self arguments here - these could be class methods (handy if mutating the class attribute from the usual cls argument) or static methods (no self or cls).\n", "In addition to already existing answers and to make this more confusing:\n\nIn Python, variables that are only referenced inside a function are\n implicitly global. If a variable is assigned a new value anywhere\n within the function’s body, it’s assumed to be a local. If a variable\n is ever assigned a new value inside the function, the variable is\n implicitly local, and you need to explicitly declare it as ‘global’.\nThough a bit surprising at first, a moment’s consideration explains\n this. On one hand, requiring global for assigned variables provides a\n bar against unintended side-effects. On the other hand, if global was\n required for all global references, you’d be using global all the\n time. You’d have to declare as global every reference to a built-in\n function or to a component of an imported module. This clutter would\n defeat the usefulness of the global declaration for identifying\n side-effects.\n\nSource: What are the rules for local and global variables in Python?.\n", "With parallel execution, global variables can cause unexpected results if you don't understand what is happening. Here is an example of using a global variable within multiprocessing. We can clearly see that each process works with its own copy of the variable:\nimport multiprocessing\nimport os\nimport random\nimport sys\nimport time\n\ndef worker(new_value):\n old_value = get_value()\n set_value(random.randint(1, 99))\n print('pid=[{pid}] '\n 'old_value=[{old_value:2}] '\n 'new_value=[{new_value:2}] '\n 'get_value=[{get_value:2}]'.format(\n pid=str(os.getpid()),\n old_value=old_value,\n new_value=new_value,\n get_value=get_value()))\n\ndef get_value():\n global global_variable\n return global_variable\n\ndef set_value(new_value):\n global global_variable\n global_variable = new_value\n\nglobal_variable = -1\n\nprint('before set_value(), get_value() = [%s]' % get_value())\nset_value(new_value=-2)\nprint('after set_value(), get_value() = [%s]' % get_value())\n\nprocessPool = multiprocessing.Pool(processes=5)\nprocessPool.map(func=worker, iterable=range(15))\n\nOutput:\nbefore set_value(), get_value() = [-1]\nafter set_value(), get_value() = [-2]\npid=[53970] old_value=[-2] new_value=[ 0] get_value=[23]\npid=[53971] old_value=[-2] new_value=[ 1] get_value=[42]\npid=[53970] old_value=[23] new_value=[ 4] get_value=[50]\npid=[53970] old_value=[50] new_value=[ 6] get_value=[14]\npid=[53971] old_value=[42] new_value=[ 5] get_value=[31]\npid=[53972] old_value=[-2] new_value=[ 2] get_value=[44]\npid=[53973] old_value=[-2] new_value=[ 3] get_value=[94]\npid=[53970] old_value=[14] new_value=[ 7] get_value=[21]\npid=[53971] old_value=[31] new_value=[ 8] get_value=[34]\npid=[53972] old_value=[44] new_value=[ 9] get_value=[59]\npid=[53973] old_value=[94] new_value=[10] get_value=[87]\npid=[53970] old_value=[21] new_value=[11] get_value=[21]\npid=[53971] old_value=[34] new_value=[12] get_value=[82]\npid=[53972] old_value=[59] new_value=[13] get_value=[ 4]\npid=[53973] old_value=[87] new_value=[14] get_value=[70]\n\n", "As it turns out the answer is always simple.\nHere is a small sample module with a simple way to show it in a main definition:\ndef five(enterAnumber,sumation):\n global helper\n helper = enterAnumber + sumation\n\ndef isTheNumber():\n return helper\n\nHere is how to show it in a main definition:\nimport TestPy\n\ndef main():\n atest = TestPy\n atest.five(5,8)\n print(atest.isTheNumber())\n\nif __name__ == '__main__':\n main()\n\nThis simple code works just like that, and it will execute. I hope it helps.\n", "What you are saying is to use the method like this:\nglobvar = 5\n\ndef f():\n var = globvar\n print(var)\n\nf() # Prints 5\n\nBut the better way is to use the global variable like this:\nglobvar = 5\ndef f():\n global globvar\n print(globvar)\nf() #prints 5\n\nBoth give the same output.\n", "You need to reference the global variable in every function you want to use.\nAs follows:\nvar = \"test\"\n\ndef printGlobalText():\n global var #wWe are telling to explicitly use the global version\n var = \"global from printGlobalText fun.\"\n print \"var from printGlobalText: \" + var\n\ndef printLocalText():\n #We are NOT telling to explicitly use the global version, so we are creating a local variable\n var = \"local version from printLocalText fun\"\n print \"var from printLocalText: \" + var\n\nprintGlobalText()\nprintLocalText()\n\"\"\"\nOutput Result:\nvar from printGlobalText: global from printGlobalText fun.\nvar from printLocalText: local version from printLocalText\n[Finished in 0.1s]\n\"\"\"\n\n", "Try this:\ndef x1():\n global x\n x += 1\n print('x1: ', x)\n\ndef x2():\n global x\n x = x+1\n print('x2: ', x)\n\nx = 5\nprint('x: ', x)\nx1()\nx2()\n\n# Output:\n# x: 5\n# x1: 6\n# x2: 7\n\n", "You're not actually storing the global in a local variable, just creating a local reference to the same object that your original global reference refers to. Remember that pretty much everything in Python is a name referring to an object, and nothing gets copied in usual operation.\nIf you didn't have to explicitly specify when an identifier was to refer to a predefined global, then you'd presumably have to explicitly specify when an identifier is a new local variable instead (for example, with something like the 'var' command seen in JavaScript). Since local variables are more common than global variables in any serious and non-trivial system, Python's system makes more sense in most cases.\nYou could have a language which attempted to guess, using a global variable if it existed or creating a local variable if it didn't. However, that would be very error-prone. For example, importing another module could inadvertently introduce a global variable by that name, changing the behaviour of your program.\n", "In case you have a local variable with the same name, you might want to use the globals() function.\nglobals()['your_global_var'] = 42\n\n", "Following on and as an add on, use a file to contain all global variables all declared locally and then import as:\nFile initval.py:\nStocksin = 300\nPrices = []\n\nFile getstocks.py:\nimport initval as iv\n\ndef getmystocks(): \n iv.Stocksin = getstockcount()\n\n\ndef getmycharts():\n for ic in range(iv.Stocksin):\n\n", "Writing to explicit elements of a global array does not apparently need the global declaration, though writing to it \"wholesale\" does have that requirement:\nimport numpy as np\n\nhostValue = 3.14159\nhostArray = np.array([2., 3.])\nhostMatrix = np.array([[1.0, 0.0],[ 0.0, 1.0]])\n\ndef func1():\n global hostValue # mandatory, else local.\n hostValue = 2.0\n\ndef func2():\n global hostValue # mandatory, else UnboundLocalError.\n hostValue += 1.0\n\ndef func3():\n global hostArray # mandatory, else local.\n hostArray = np.array([14., 15.])\n\ndef func4(): # no need for globals\n hostArray[0] = 123.4\n\ndef func5(): # no need for globals\n hostArray[1] += 1.0\n\ndef func6(): # no need for globals\n hostMatrix[1][1] = 12.\n\ndef func7(): # no need for globals\n hostMatrix[0][0] += 0.33\n\nfunc1()\nprint \"After func1(), hostValue = \", hostValue\nfunc2()\nprint \"After func2(), hostValue = \", hostValue\nfunc3()\nprint \"After func3(), hostArray = \", hostArray\nfunc4()\nprint \"After func4(), hostArray = \", hostArray\nfunc5()\nprint \"After func5(), hostArray = \", hostArray\nfunc6()\nprint \"After func6(), hostMatrix = \\n\", hostMatrix\nfunc7()\nprint \"After func7(), hostMatrix = \\n\", hostMatrix\n\n", "I'm adding this as I haven't seen it in any of the other answers and it might be useful for someone struggling with something similar. The globals() function returns a mutable global symbol dictionary where you can \"magically\" make data available for the rest of your code. \nFor example:\nfrom pickle import load\ndef loaditem(name):\n with open(r\"C:\\pickle\\file\\location\"+\"\\{}.dat\".format(name), \"rb\") as openfile:\n globals()[name] = load(openfile)\n return True\n\nand \nfrom pickle import dump\ndef dumpfile(name):\n with open(name+\".dat\", \"wb\") as outfile:\n dump(globals()[name], outfile)\n return True\n\nWill just let you dump/load variables out of and into the global namespace. Super convenient, no muss, no fuss. Pretty sure it's Python 3 only.\n", "Reference the class namespace where you want the change to show up. \nIn this example, runner is using max from the file config. I want my test to change the value of max when runner is using it.\nmain/config.py\nmax = 15000\n\nmain/runner.py\nfrom main import config\ndef check_threads():\n return max < thread_count \n\ntests/runner_test.py\nfrom main import runner # <----- 1. add file\nfrom main.runner import check_threads\nclass RunnerTest(unittest):\n def test_threads(self):\n runner.max = 0 # <----- 2. set global \n check_threads()\n\n", "global_var = 10 # will be considered as a global variable\n\n\ndef func_1():\n global global_var # access variable using variable keyword\n global_var += 1\n\n\ndef func_2():\n global global_var\n global_var *= 2\n print(f\"func_2: {global_var}\")\n\n\nfunc_1()\nfunc_2()\nprint(\"Global scope:\", global_var) # will print 22\n\nExplanation:\nglobal_var is a global variable and all functions and classes can access that variable.\nThe func_1() accessed that global variable using the keyword global which points to the variable which is written in the global scope. If I didn't write the global keyword the variable global_var inside func_1 is considered a local variable that is only usable inside the function. Then inside func_1, I have incremented that global variable by 1.\nThe same happened in func_2().\nAfter calling func_1 and func_2, you'll see the global_var is changed\n", "Globals are fine - Except with Multiprocessing\nGlobals in connection with multiprocessing on different platforms/envrionments \nas Windows/Mac OS on the one side and Linux on the other are troublesome.\nI will show you this with a simple example pointing out a problem which I run into some time ago. \nIf you want to understand, why things are different on Windows/MacOs and Linux you \nneed to know that, the default mechanism to start a new process on ...\n\nWindows/MacOs is 'spawn'\nLinux is 'fork'\n\nThey are different in Memory allocation an initialisation ... (but I don't go into this\nhere). \nLet's have a look at the problem/example ...\nimport multiprocessing\n\ncounter = 0\n\ndef do(task_id):\n global counter\n counter +=1\n print(f'task {task_id}: counter = {counter}')\n\nif __name__ == '__main__':\n\n pool = multiprocessing.Pool(processes=4)\n task_ids = list(range(4))\n pool.map(do, task_ids)\n\nWindows\nIf you run this on Windows (And I suppose on MacOS too), you get the following output ...\ntask 0: counter = 1\ntask 1: counter = 2\ntask 2: counter = 3\ntask 3: counter = 4\n\nLinux\nIf you run this on Linux, you get the following instead. \ntask 0: counter = 1\ntask 1: counter = 1\ntask 2: counter = 1\ntask 3: counter = 1\n\n", "There are 2 ways to declare a variable as global:\n1. assign variable inside functions and use global line\ndef declare_a_global_variable():\n global global_variable_1\n global_variable_1 = 1\n\n# Note to use the function to global variables\ndeclare_a_global_variable() \n\n2. assign variable outside functions:\nglobal_variable_2 = 2\n\nNow we can use these declared global variables in the other functions:\ndef declare_a_global_variable():\n global global_variable_1\n global_variable_1 = 1\n\n# Note to use the function to global variables\ndeclare_a_global_variable() \nglobal_variable_2 = 2\n\ndef print_variables():\n print(global_variable_1)\n print(global_variable_2)\nprint_variables() # prints 1 & 2\n\nNote 1:\nIf you want to change a global variable inside another function like update_variables() you should use global line in that function before assigning the variable:\nglobal_variable_1 = 1\nglobal_variable_2 = 2\n\ndef update_variables():\n global global_variable_1\n global_variable_1 = 11\n global_variable_2 = 12 # will update just locally for this function\n\nupdate_variables()\nprint(global_variable_1) # prints 11\nprint(global_variable_2) # prints 2\n\nNote 2:\nThere is a exception for note 1 for list and dictionary variables while not using global line inside a function:\n# declaring some global variables\nvariable = 'peter'\nlist_variable_1 = ['a','b']\nlist_variable_2 = ['c','d']\n\ndef update_global_variables():\n \"\"\"without using global line\"\"\"\n variable = 'PETER' # won't update in global scope\n list_variable_1 = ['A','B'] # won't update in global scope\n list_variable_2[0] = 'C' # updated in global scope surprisingly this way\n list_variable_2[1] = 'D' # updated in global scope surprisingly this way\n\nupdate_global_variables()\n\nprint('variable is: %s'%variable) # prints peter\nprint('list_variable_1 is: %s'%list_variable_1) # prints ['a', 'b']\nprint('list_variable_2 is: %s'%list_variable_2) # prints ['C', 'D']\n\n", "Though this has been answered, I am giving solution again as I prefer single line\nThis is if you wish to create global variable within function\ndef someFunc():\n x=20\n globals()['y']=50\nsomeFunc() # invoking function so that variable Y is created globally \nprint(y) # output 50\nprint(x) #NameError: name 'x' is not defined as x was defined locally within function\n\n", "Like this code:\nmyVar = 12\n\ndef myFunc():\n myVar += 12\n\nKey:\nIf you declare a variable outside the strings, it become global.\nIf you declare a variable inside the strings, it become local.\nIf you want to declare a global variable inside the strings, use the keyword global before the variable you want to declare:\nmyVar = 124\ndef myFunc():\n global myVar2\n myVar2 = 100\nmyFunc()\nprint(myVar2)\n\nand then you have 100 in the document.\n", "Initialized = 0 #Here This Initialized is global variable \n\ndef Initialize():\n print(\"Initialized!\")\n Initialized = 1 #This is local variable and assigning 1 to local variable\nwhile Initialized == 0: \n\nHere we are comparing global variable Initialized that 0, so while loop condition got true\n Initialize()\n\nFunction will get called.Loop will be infinite\n#if we do Initialized=1 then loop will terminate \n\nelse:\n print(\"Lets do something else now!\")\n\n" ]

[ 5007, 874, 267, 115, 74, 68, 57, 41, 35, 33, 30, 30, 27, 23, 20, 17, 9, 8, 8, 7, 6, 5, 1, 0 ]

[ "if you want to access global var you just add global keyword inside your function\nex:\nglobal_var = 'yeah'\ndef someFunc():\n global global_var;\n print(nam_of_var)\n\n" ]

[ -1 ]

[ "global_variables", "python", "scope" ]

[ "To avoid division by zero, I would avoid dividing the values by zero. Please take a look at the following example.\nI hope this helps.\nBest regards\nimport pandas as pd\n\ndata = {'id': [0, 1, 2, 3, 4], 'memory': [7568, 53759, 41140, 10558, 44436], 'price': [751.64, 885.17, 1067.78, 0, 1023.13]}\ndf = pd.DataFrame(data)\n\n# adding a new column and setting the values to \"none\"\ndf['new'] = \"none\"\n\nfor i in range(len(df)):\n if df.iat[i,2] != 0:\n df.iat[i, 3] = df.iat[i, 1] / df.iat[i, 2]\n \nprint(df)\n\n\n" ]

[ 1 ]

[]

[]

[ "python" ]

[ "Adding a user selection dropdown will accomplish your goal. Use a graph object to draw a graph for each type of fruit and show the Show/Hide setting. All and only each type will be available as a type of dropdown. Give the list of Show/Hide as input for the button. Now, the drop-down selection will toggle between show and hide. Please refer to the examples in the reference.\nimport plotly.graph_objects as go\n\nfig = go.Figure()\n\nfor f in df['fruit'].unique():\n dff = df.query('fruit == @f')\n fig.add_trace(go.Scatter(mode='markers', x=dff.lb, y=dff.price, name=f, visible=True))\n \nfig.update_layout(\n updatemenus=[\n dict(\n active=0,\n buttons=list([\n dict(label=\"ALL\",\n method=\"update\",\n args=[{\"visible\": [True, True, True]},\n {\"title\": \"All fruit\"}]),\n dict(label=\"Orange\",\n method=\"update\",\n args=[{\"visible\": [True, False, False]},\n {\"title\": \"Orange\"}]),\n dict(label=\"Apple\",\n method=\"update\",\n args=[{\"visible\": [False, True, False]},\n {\"title\": \"Apple\"}]),\n dict(label=\"Kiwi\",\n method=\"update\",\n args=[{\"visible\": [False, False, True]},\n {\"title\": \"Kiwi\"}]),\n ]),\n )\n ])\n\nfig.show()\n\n\n" ]

[ 0 ]

[]

[]

[ "pandas", "plotly", "python" ]

[ "As the error states, you can only use .str with string columns, and you have a float64. There won't be any commas in a float, so what you have won't really do anything, but in general, you could cast it first:\ndc_listings['price'].astype(str).str.replace...\n\nFor example:\nIn [18]: df\nOut[18]:\n a b c d e\n0 0.645821 0.152197 0.006956 0.600317 0.239679\n1 0.865723 0.176842 0.226092 0.416990 0.290406\n2 0.046243 0.931584 0.020109 0.374653 0.631048\n3 0.544111 0.967388 0.526613 0.794931 0.066736\n4 0.528742 0.670885 0.998077 0.293623 0.351879\n\nIn [19]: df['a'].astype(str).str.replace(\"5\", \" hi \")\nOut[19]:\n0 0.64 hi 8208 hi hi 4779467\n1 0.86 hi 7231174332336\n2 0.04624337481411367\n3 0. hi 44111244991 hi 194\n4 0. hi 287421814241892\nName: a, dtype: object\n\n", "Two ways:\n\nYou can use series to fix this error.\ndc_listings['price'].series.str.replace(',', '')\n\n\n\n\n\nAnd if series doesn't work you can also alteratively use apply(str) as shown below:\ndc_listings['price'].apply(str).str.replace(',', '')\n\n\n\n", "If price is a dtype float 64 then the data is not a string.\nYou can try dc_listings['price'].apply(function)\n", "Randy has the solution to handle your problem with changing the whole column into str type. But when you have non-str-type value (like NA, list, dict, a custom class) inside that column and wanted to filter those special values in the future, i suggest you create your own function and then apply it to the str value only, like this:\ndc_listings['price'] = dc_listings['price'].apply(\n lambda x: x.replace(',', '') if type(x) is str else x\n)\n\nor more clearly, using def :\ndef replace_substring_or_return_value(value):\n if type(value) is str: return x.replace(',', '')\n else: return value\n\ndc_listings['price'] = dc_listings['price'].apply(\n replace_substring_or_return_value\n)\n\nALTHOUGH this might be a bad practice, because you should use the same data type for every value in a column\n" ]

[ 148, 14, 0, 0 ]

[]

[]

[ "pandas", "python" ]

[ "Put this format in your function try:\ncollection.find([\n {\n \"$Date\" : {\n \"$gte\": begin, \n \"$lte\": end \n } \n }\n ])\n\n" ]

[ 1 ]

[]

[]

[ "pymongo", "python" ]

[ "The problem was apparently that the service account was associated with too many roles, perhaps as a results of previous configuration attempts.\nThese steps resolved the issue:\n\nremoved all (three) roles for the offending service account (member) my_sa under IAM & Admin / IAM\ndeleted my_sa under IAM & Admin / Service accounts\nrecreated my_sa (again with role Storage / Storage Admin)\n\nEffects are like this:\n\nmy_sa shows up with one role (Storage Admin) under IAM & Admin / IAM\nmy_sa shows up as member under Storage / Browser / my_bucket / Edit bucket permissions\n\n", "It's worth noting, that you need to wait up to a few minutes for permissions to be working in case you just assigned them. At least that's what happened to me after:\ngcloud projects add-iam-policy-binding xxx --member\n\"serviceAccount:[email protected]\" --role \"roles/storage.objectViewer\"\n\n", "Go to your bucket's permissions section and open add permissions section for your bucket. For example, insufficient service, which gcloud tells you, is;\[email protected] \n\nAdd this service as user then give these roles;\n\nCloud Storage - Storage Admin\nCloud Storage - Storage Object Admin\nCloud Storage - Storage Object Creator\n\nThen you should have sufficient permissions to make changes on your bucket.\n", "For me, it was because deployed with the \"default-bucket\" as parameter needed for the storage emulator.\nadmin.storage().bucket('default-bucket'); // do not deploy that\n\nTo fix it, I set the default bucket name at the initialization of the firebase admin.\nconst admin = require('firebase-admin');\n\nconst config = process.env.FUNCTIONS_EMULATOR ? {\n storageBucket: 'default-bucket',\n} : {\n storageBucket: 'YOUT_FIREBASE_STORAGE_BUCKET',\n};\n\nadmin.initializeApp(config);\n\nconst bucket = admin.storage().bucket();\n\n", "I just realized this happens some times when you are just creating the Firebase/Firestore/Storage project by first time.\nIf you got this error in your first installation/deploy/setup, just wait 1 minute and try again.\nSeems like some delays in the Google Cloud deploys/serving are responsible of this.\n", "I got this error when I copied a cloud function from another project because I forgot to update the storage bucket. Silly mistake.\nadmin.initializeApp({\n storageBucket: \"gs://*****.appspot.com\",\n});\n\n", "in my case, after the service account is created, interface returns error: \"service account does not have storage.objects.get access for Google Cloud Storage\".\nBut, When I tried again the next day, everything was fine :)\n" ]

[ 24, 18, 16, 1, 1, 0, 0 ]

[]

[]

[ "google_cloud_platform", "google_cloud_storage", "python", "service_accounts" ]

[ "On the assumption that by 'errors' you mean a TypeError, this is caused because of line 13, wordDict[word] = wordList(word).\nwordList is a list, and by using the ()/brackets you're telling Python that you want to call that list as a function. Which it cannot do.\nAccording to your task, you are to instead find the occurrences of words in the list, which you could achieve with the .count() method. This method basically returns the total number of occurrences of an element in a list. (Feel free to read more about it here)\nWith this modification, (this is assuming you want wordDict to contain a dictionary with the word as the key, and the occurrence as the value) your freqAll function would look something like this:\ndef freqAll(self):\n wordList = self.fmtText.split()\n\n wordDict = {}\n for word in set(wordList):\n wordDict[word] = wordList.count(word) # wordList.count(word) returns the number of times the string word appears as an element in wordList\n\n return wordDict\n\nAlthough you could also achieve this same task with a class known as collections.Counter, (of course this means you have to import collections) which you can read more about here\n" ]

[ 1 ]

[]

[]

[ "class", "coursera_api", "python" ]

[ "DGLGraph.apply_edges(func, edges='ALL', etype=None, inplace=False) is used to update edge features using the function 'func' on all the edges in 'edges'.\nDGLGraph.send_and_recv(edges, message_func, reduce_func, apply_node_func=None, etype=None, inplace=False) is used to pass messages, reduce messages and update the node features for all the edges in 'edges'.\nTo get your forward method to work you can update your code as below\ndef forward(self, g, inputs):\n g.ndata['h'] = inputs\n g.send_and_recv(g.edges(), fn.copy_src(\"h\", \"m\"), fn.sum(\"m\", \"h\"))\n h = g.ndata.pop(\"h\")\n\n return self.linear(h)\n\nYou can use your own message_func (message generation) and reduce_func (message aggregation) to fit your purpose.\n", "try code below, it may solve your problem\ndef forward(self, g, inputs):\n g.ndata['h'] = inputs\n g.send_and_recv(g.edges(), gcn_message, gcn_reduce)\n h = g.ndata.pop('h')\n return self.linear(h)\n\n" ]

[ 0, 0 ]

[]

[]

[ "deep_learning", "dgl", "graph", "graph_neural_network", "python" ]

[ "Looks dictdiff might be useful in your case. The following example is not the same as your output, but I hope it is useful.\nimport dictdiffer\n\nfruits = {\n \"appel\": 3962.00,\n \"waspeen\": 3304.07,\n \"ananas\": 24,\n}\nfruits2 = {\n \"appel\": 3962.00,\n \"waspeen\": 3304.07,\n \"ananas\": 30,\n}\n\ndiff = list(dictdiffer.diff(first=fruits, second=fruits2))\nprint(diff) # [('change', 'ananas', (24, 30))]\n\n", "Following the same principle from my last answer. Since you are trying to compare two dictionaries with same keys, you can just iterate over both of them at once, compare the values and if they differ append the key to a condition list:\ndef compare_data(request):\n fruits = {\"appel\": 3962.00,\"waspeen\": 3304.07,\"ananas\": 24,}\n fruits2 = {\"appel\": 3962.00,\"waspeen\": 3304.07,\"ananas\": 30,}\n diff_set = []\n\n for k, v in fruits.items():\n if fruits[k] != fruits2[k]:\n diff_set.append(k)\n\n context = {\n 'fruits': fruits, \n 'fruits2': fruits2, \n 'diff_set': diff_set, \n }\n return render(request, 'main/data_compare.html', context)\n\ntemplate.html:\n{% extends 'base.html' %}\n\n{% block content %}\n <div class=\"container center\">\n {% for key, value in fruits.items %}\n <span {% if key in diff_set %} style=\"color: red;\" {% endif %}>{{ key }}: {{value}}</span><br>\n {% endfor %}\n </div>\n\n <div class=\"container center\">\n {% for key, value in fruits2.items %}\n <span {% if key in diff_set %} style=\"color: red;\"{% endif %}>{{ key }}: {{value}}</span><br>\n {% endfor %}\n </div>\n{% endblock %}\n\nEdit\nIn your case, everything is showing red because of your IF statement:\n{% if diff_set %}...{% endif %}\n\nWhich checks if the 'diff_set' variable contains any values. It does, so it returns True every iteration.\nIn order to use your 'diff_set' data structure:\n[('ananas', 24), ('ananas', 30)]\nOne needs to loop through the list and check if if the first value of the tuple is equal to the key value. Even if you do that, with current html structure it would print 'ananas' in red twice.\n" ]

[ 0, 0 ]

[]

[]

[ "django", "python" ]

[ "You want to handle an exception with the except clause that will be raised in the future after the corresponding try statement. It's impossible, and unnatural if it's possible.\nInstead, do in other way like this example.\ndef createObj():\n def handle_exception(e):\n print(\"Bad boy!\")\n return Obj_A(handle_exception)\n\nclass Obj_A(object):\n def __init__(self, handle_exception):\n self.handle_exception = handle_exception\n\n def myFunc(self, var):\n try:\n return self.Obj_B(self, var)\n except Exception as e:\n self.handle_exception(e)\n\n" ]

[ 0 ]

[]

[]

[ "python", "python_3.x" ]

[ "You can use DataFrame.values to get an numpy array of the data and then use NumPy functions such as argsort() to get the most correlated pairs. \nBut if you want to do this in pandas, you can unstack and sort the DataFrame:\nimport pandas as pd\nimport numpy as np\n\nshape = (50, 4460)\n\ndata = np.random.normal(size=shape)\n\ndata[:, 1000] += data[:, 2000]\n\ndf = pd.DataFrame(data)\n\nc = df.corr().abs()\n\ns = c.unstack()\nso = s.sort_values(kind=\"quicksort\")\n\nprint so[-4470:-4460]\n\nHere is the output:\n2192 1522 0.636198\n1522 2192 0.636198\n3677 2027 0.641817\n2027 3677 0.641817\n242 130 0.646760\n130 242 0.646760\n1171 2733 0.670048\n2733 1171 0.670048\n1000 2000 0.742340\n2000 1000 0.742340\ndtype: float64\n\n", "@HYRY's answer is perfect. Just building on that answer by adding a bit more logic to avoid duplicate and self correlations and proper sorting:\nimport pandas as pd\nd = {'x1': [1, 4, 4, 5, 6], \n 'x2': [0, 0, 8, 2, 4], \n 'x3': [2, 8, 8, 10, 12], \n 'x4': [-1, -4, -4, -4, -5]}\ndf = pd.DataFrame(data = d)\nprint(\"Data Frame\")\nprint(df)\nprint()\n\nprint(\"Correlation Matrix\")\nprint(df.corr())\nprint()\n\ndef get_redundant_pairs(df):\n '''Get diagonal and lower triangular pairs of correlation matrix'''\n pairs_to_drop = set()\n cols = df.columns\n for i in range(0, df.shape[1]):\n for j in range(0, i+1):\n pairs_to_drop.add((cols[i], cols[j]))\n return pairs_to_drop\n\ndef get_top_abs_correlations(df, n=5):\n au_corr = df.corr().abs().unstack()\n labels_to_drop = get_redundant_pairs(df)\n au_corr = au_corr.drop(labels=labels_to_drop).sort_values(ascending=False)\n return au_corr[0:n]\n\nprint(\"Top Absolute Correlations\")\nprint(get_top_abs_correlations(df, 3))\n\nThat gives the following output:\nData Frame\n x1 x2 x3 x4\n0 1 0 2 -1\n1 4 0 8 -4\n2 4 8 8 -4\n3 5 2 10 -4\n4 6 4 12 -5\n\nCorrelation Matrix\n x1 x2 x3 x4\nx1 1.000000 0.399298 1.000000 -0.969248\nx2 0.399298 1.000000 0.399298 -0.472866\nx3 1.000000 0.399298 1.000000 -0.969248\nx4 -0.969248 -0.472866 -0.969248 1.000000\n\nTop Absolute Correlations\nx1 x3 1.000000\nx3 x4 0.969248\nx1 x4 0.969248\ndtype: float64\n\n", "Few lines solution without redundant pairs of variables:\ncorr_matrix = df.corr().abs()\n\n#the matrix is symmetric so we need to extract upper triangle matrix without diagonal (k = 1)\n\nsol = (corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))\n .stack()\n .sort_values(ascending=False))\n\n#first element of sol series is the pair with the biggest correlation\n\nThen you can iterate through names of variables pairs (which are pandas.Series multi-indexes) and theirs values like this:\nfor index, value in sol.items():\n # do some staff\n\n", "Combining some features of @HYRY and @arun's answers, you can print the top correlations for dataframe df in a single line using:\ndf.corr().unstack().sort_values().drop_duplicates()\n\nNote: the one downside is if you have 1.0 correlations that are not one variable to itself, the drop_duplicates() addition would remove them\n", "I liked Addison Klinke's post the most, as being the simplest, but used Wojciech Moszczyńsk’s suggestion for filtering and charting, but extended the filter to avoid absolute values, so given a large correlation matrix, filter it, chart it, and then flatten it:\nCreated, Filtered and Charted\ndfCorr = df.corr()\nfilteredDf = dfCorr[((dfCorr >= .5) | (dfCorr <= -.5)) & (dfCorr !=1.000)]\nplt.figure(figsize=(30,10))\nsn.heatmap(filteredDf, annot=True, cmap=\"Reds\")\nplt.show()\n\n\nFunction\nIn the end, I created a small function to create the correlation matrix, filter it, and then flatten it. As an idea, it could easily be extended, e.g., asymmetric upper and lower bounds, etc.\ndef corrFilter(x: pd.DataFrame, bound: float):\n xCorr = x.corr()\n xFiltered = xCorr[((xCorr >= bound) | (xCorr <= -bound)) & (xCorr !=1.000)]\n xFlattened = xFiltered.unstack().sort_values().drop_duplicates()\n return xFlattened\n\ncorrFilter(df, .7)\n\n\nFollow-Up\nEventually, I refined the functions\n# Returns correlation matrix\ndef corrFilter(x: pd.DataFrame, bound: float):\n xCorr = x.corr()\n xFiltered = xCorr[((xCorr >= bound) | (xCorr <= -bound)) & (xCorr !=1.000)]\n return xFiltered\n\n# flattens correlation matrix with bounds\ndef corrFilterFlattened(x: pd.DataFrame, bound: float):\n xFiltered = corrFilter(x, bound)\n xFlattened = xFiltered.unstack().sort_values().drop_duplicates()\n return xFlattened\n\n# Returns correlation for a variable from flattened correlation matrix\ndef filterForLabels(df: pd.DataFrame, label): \n try:\n sideLeft = df[label,]\n except:\n sideLeft = pd.DataFrame()\n\n try:\n sideRight = df[:,label]\n except:\n sideRight = pd.DataFrame()\n\n if sideLeft.empty and sideRight.empty:\n return pd.DataFrame()\n elif sideLeft.empty: \n concat = sideRight.to_frame()\n concat.rename(columns={0:'Corr'},inplace=True)\n return concat\n elif sideRight.empty:\n concat = sideLeft.to_frame()\n concat.rename(columns={0:'Corr'},inplace=True)\n return concat\n else:\n concat = pd.concat([sideLeft,sideRight], axis=1)\n concat[\"Corr\"] = concat[0].fillna(0) + concat[1].fillna(0)\n concat.drop(columns=[0,1], inplace=True)\n return concat\n\n", "You can do graphically according to this simple code by substituting your data.\ncorr = df.corr()\n\nkot = corr[corr>=.9]\nplt.figure(figsize=(12,8))\nsns.heatmap(kot, cmap=\"Greens\")\n\n\n", "Use the code below to view the correlations in the descending order.\n# See the correlations in descending order\n\ncorr = df.corr() # df is the pandas dataframe\nc1 = corr.abs().unstack()\nc1.sort_values(ascending = False)\n\n", "Lot's of good answers here. The easiest way I found was a combination of some of the answers above. \ncorr = corr.where(np.triu(np.ones(corr.shape), k=1).astype(np.bool))\ncorr = corr.unstack().transpose()\\\n .sort_values(by='column', ascending=False)\\\n .dropna()\n\n", "Combining most the answers above into a short snippet:\ndef top_entries(df):\n mat = df.corr().abs()\n \n # Remove duplicate and identity entries\n mat.loc[:,:] = np.tril(mat.values, k=-1)\n mat = mat[mat>0]\n\n # Unstack, sort ascending, and reset the index, so features are in columns\n # instead of indexes (allowing e.g. a pretty print in Jupyter).\n # Also rename these it for good measure.\n return (mat.unstack()\n .sort_values(ascending=False)\n .reset_index()\n .rename(columns={\n \"level_0\": \"feature_a\",\n \"level_1\": \"feature_b\",\n 0: \"correlation\"\n }))\n\n", "Use itertools.combinations to get all unique correlations from pandas own correlation matrix .corr(), generate list of lists and feed it back into a DataFrame in order to use '.sort_values'. Set ascending = True to display lowest correlations on top \ncorrank takes a DataFrame as argument because it requires .corr().\n def corrank(X: pandas.DataFrame):\n import itertools\n df = pd.DataFrame([[(i,j),X.corr().loc[i,j]] for i,j in list(itertools.combinations(X.corr(), 2))],columns=['pairs','corr']) \n print(df.sort_values(by='corr',ascending=False))\n\n corrank(X) # prints a descending list of correlation pair (Max on top)\n\n", "The following function should do the trick. This implementation\n\nRemoves self correlations\nRemoves duplicates\nEnables the selection of top N highest correlated features\n\nand it is also configurable so that you can keep both the self correlations as well as the duplicates. You can also to report as many feature pairs as you wish. \n\ndef get_feature_correlation(df, top_n=None, corr_method='spearman',\n remove_duplicates=True, remove_self_correlations=True):\n \"\"\"\n Compute the feature correlation and sort feature pairs based on their correlation\n\n :param df: The dataframe with the predictor variables\n :type df: pandas.core.frame.DataFrame\n :param top_n: Top N feature pairs to be reported (if None, all of the pairs will be returned)\n :param corr_method: Correlation compuation method\n :type corr_method: str\n :param remove_duplicates: Indicates whether duplicate features must be removed\n :type remove_duplicates: bool\n :param remove_self_correlations: Indicates whether self correlations will be removed\n :type remove_self_correlations: bool\n\n :return: pandas.core.frame.DataFrame\n \"\"\"\n corr_matrix_abs = df.corr(method=corr_method).abs()\n corr_matrix_abs_us = corr_matrix_abs.unstack()\n sorted_correlated_features = corr_matrix_abs_us \\\n .sort_values(kind=\"quicksort\", ascending=False) \\\n .reset_index()\n\n # Remove comparisons of the same feature\n if remove_self_correlations:\n sorted_correlated_features = sorted_correlated_features[\n (sorted_correlated_features.level_0 != sorted_correlated_features.level_1)\n ]\n\n # Remove duplicates\n if remove_duplicates:\n sorted_correlated_features = sorted_correlated_features.iloc[:-2:2]\n\n # Create meaningful names for the columns\n sorted_correlated_features.columns = ['Feature 1', 'Feature 2', 'Correlation (abs)']\n\n if top_n:\n return sorted_correlated_features[:top_n]\n\n return sorted_correlated_features\n\n\n", "I didn't want to unstack or over-complicate this issue, since I just wanted to drop some highly correlated features as part of a feature selection phase.\nSo I ended up with the following simplified solution:\n# map features to their absolute correlation values\ncorr = features.corr().abs()\n\n# set equality (self correlation) as zero\ncorr[corr == 1] = 0\n\n# of each feature, find the max correlation\n# and sort the resulting array in ascending order\ncorr_cols = corr.max().sort_values(ascending=False)\n\n# display the highly correlated features\ndisplay(corr_cols[corr_cols > 0.8])\n\nIn this case, if you want to drop correlated features, you may map through the filtered corr_cols array and remove the odd-indexed (or even-indexed) ones.\n", "I was trying some of the solutions here but then I actually came up with my own one. I hope this might be useful for the next one so I share it here:\ndef sort_correlation_matrix(correlation_matrix):\n cor = correlation_matrix.abs()\n top_col = cor[cor.columns[0]][1:]\n top_col = top_col.sort_values(ascending=False)\n ordered_columns = [cor.columns[0]] + top_col.index.tolist()\n return correlation_matrix[ordered_columns].reindex(ordered_columns)\n\n", "This is a improve code from @MiFi. This one order in abs but not excluding the negative values.\n def top_correlation (df,n):\n corr_matrix = df.corr()\n correlation = (corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(np.bool))\n .stack()\n .sort_values(ascending=False))\n correlation = pd.DataFrame(correlation).reset_index()\n correlation.columns=[\"Variable_1\",\"Variable_2\",\"Correlacion\"]\n correlation = correlation.reindex(correlation.Correlacion.abs().sort_values(ascending=False).index).reset_index().drop([\"index\"],axis=1)\n return correlation.head(n)\n\ntop_correlation(ANYDATA,10)\n\n", "simple is better\nfrom collections import defaultdict\nres = defaultdict(dict)\ncorr = returns.corr().replace(1, -1)\nnames = list(corr)\n\nfor name in names:\n idx = corr[name].argmax()\n max_pairwise_name = names[idx]\n res[name][max_pairwise_name] = corr.loc[max_pairwisename, name]\n\nNow res contains the maximum pairwise correlation for each pair\n" ]

[ 128, 71, 60, 29, 20, 14, 13, 3, 3, 2, 2, 1, 0, 0, 0 ]

[]

[]

[ "correlation", "pandas", "python" ]

[ "There is no DIMSE message type during association request. Only after an association has already been through request and acceptance are DIMSE messages allowed to be sent.\n" ]

[ 0 ]

[]

[]

[ "pynetdicom", "python" ]

[ "Hopefully someone will provide a better answer, but in case no one does, this will definitely work, so…\nZeroth, I'm assuming you don't want to just end up sorted on loan, but to preserve whatever original order was in x, which may or may not have anything to do with the order of the loan column. (Otherwise, the problem is easier, and less interesting.)\nFirst, you're asking it to sort based on the join keys. As the docs explain, that's the default when you don't pass a sort argument.\n\nSecond, if you don't sort based on the join keys, the rows will end up grouped together, such that two rows that merged from the same source row end up next to each other, which means you're still going to get a, c, b.\nYou can work around this by getting the rows grouped together in the order they appear in the original x by just merging again with x (on either side, it doesn't really matter), or by reindexing based on x if you prefer. Like this:\nx.merge(x.merge(y, how='left', on='state', sort=False))\n\n\nAlternatively, you can cram an x-index in there with reset_index, then just sort on that, like this:\nx.reset_index().merge(y, how='left', on='state', sort=False).sort('index')\n\n\nEither way obviously seems a bit wasteful, and clumsy… so, as I said, hopefully there's a better answer that I'm just not seeing at the moment. But if not, that works.\n", "I might have a much more simple solution:\ndf_z = df_x.join(df_y.set_index('state'), on = 'state')\n\nHope it helps\n", "The fastest way I've found to merge and restore order - if you are merging \"left\" - is to include the original order as a column in the left dataframe before merging, then use that to restore the order after merging:\nimport pandas\nloans = [ 'a', 'b', 'c' ]\nstates = [ 'OR', 'CA', 'OR' ]\nx = pandas.DataFrame({ 'loan' : loans, 'state' : states })\ny = pandas.DataFrame({ 'state' : [ 'CA', 'OR' ], 'value' : [ 1, 2]})\n\nimport numpy as np\nx[\"Order\"] = np.arange(len(x))\n\nz = x.merge(y, how='left', on='state').set_index(\"Order\").ix[np.arange(len(x)), :]\n\nThis method is faster than sorting. Here it is as a function:\ndef mergeLeftInOrder(x, y, on=None):\n x = x.copy()\n x[\"Order\"] = np.arange(len(x))\n z = x.merge(y, how='left', on=on).set_index(\"Order\").ix[np.arange(len(x)), :]\n return z\n\n", "Pandas has a merge_ordered function, so your solution is now as simple as:\nz = pd.merge_ordered(x, y, on='state')\n\n", "I tried the following and it does preserve the original order of loans:\nz = pandas.merge(x, y, on='state', how='left')\n\nI hope it helps! Please do let me know if there are any drawbacks of my method. Thanks.\n" ]

[ 27, 6, 4, 4, 0 ]

[ "Use pd.merge_ordered(), documentation here. \nFor your example,\nz = pd.merge_ordered(x, y, how='left', on='state')\n\nEDIT: Just wanted to point out that default behavior for this function is an outer merge, different from the default behavior of the more common .merge()\n" ]

[ -3 ]

[ "pandas", "python" ]

[ "Set T(n) = the times fib(n) call fib(4)\nWe know that\nT(4)=1, T(5)=1\n\nT(n) = T(n-1)+T(n-2)\n\nSo\nT(6) = T(5) + T(4) = 2\nT(7) = T(6) + T(5) = 3\nT(8) = T(7) + T(6) = 5\nT(9) = T(8) + T(7) = 8\nT(10) = T(9) + T(8) = 13\n\nAlso you can make some changes in your code\na = 0\n\ndef fib ( n ):\n if(n==4):\n global a\n a=a+1\n print(a)\n\n if n < 3:\n return 1\n\n else:\n return fib(n-1) + fib(n-2)\n\nfib(10)\n\n", "You can add a counter to the function\ndef fib (n, cntr = None):\n if cntr is None:\n cntr = {}\n cntr[n] = cntr.get(n, 0) + 1 # update count of current argumenet\n \n if n < 3:\n return 1\n else:\n return fib(n-1, cntr) + fib(n-2, cntr) # mutate cntr in recursive calls\n\nTest\ncntr = {} # Initialize counter\nprint(fib(10, cntr)) # Calculate fib(10)\n# Output: 55\n\nprint(cntr[4]) # get count of number of times fib(4) called\n# Output: 13\n\n" ]

[ 1, 0 ]

[]

[]

[ "fibonacci", "python", "recursion" ]

[ "you can get nearest low following code:\ndf.apply(lambda x: x[x < x[-1]].max(), axis=1)\n\noutput:\n0 68\n1 165\n2 61\ndtype: int64\n\nget nearest low and high and make result to columns:\ndf[['nxt_low', 'nxt_high']] = df.apply(lambda x: [x[x < x[-1]].max(), x[x > x[-1]].min()], axis=1, result_type='expand')\n\ndf:\n id a b c d value nxt_low nxt_high\n0 1001 156 131 97 68 71 68 97\n1 1002 224 203 165 122 180 165 203\n2 1003 67 61 54 50 66 61 67\n\n\nIf id is nearest low or high, modify code a bit.\ndf[['nxt_low', 'nxt_high']] = df.iloc[:, 1:].apply(lambda x: [x[x < x[-1]].max(), x[x > x[-1]].min()], axis=1, result_type='expand')\n\n", "Here is a way:\ncols = ['a','b','c','d']\ndf2 = df[cols].sub(df['value'],axis=0)\ndf = (df.assign(nxt_low = df.where(df2.lt(0)).max(axis=1),\nnxt_high = df.where(df2.gt(0)).min(axis=1)))\n\nOutput:\n id a b c d value nxt_low nxt_high\n0 1001 156 131 97 68 71 68.0 97.0\n1 1002 224 203 165 122 180 165.0 203.0\n2 1003 67 61 54 50 66 61.0 67.0\n\n" ]

[ 2, 1 ]

[]

[]

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

[ "If you wanted to only respond to messages on a specific channel and you know the name of the channel, you could do this:\nchannel = discord.utils.get(ctx.guild.channels, name=\"channel name\")\nchannel_id = channel.id\n\nThen you would check if the id matched the one channel you wanted it to be in. To get a channel or server's id, you need to enable discord developer mode. After than you could just right click on the server or channel and copy the id.\nTo get a server's id you need to add this piece of code as a command:\[email protected](pass_context=True)\nasync def getguild(ctx):\n id = ctx.message.guild.id # the guild is the server\n # do something with the id (print it out)\n\nAfter you get the server id, you can delete the method.\nAnd to check if a message is sent by a person or a bot, you could do this in the on_message method:\ndef on_message(self, message):\n if (message.author.bot):\n # is a bot\n pass\n\n\n", "So just to make the bot not respond to DMs, add this code after each command:\nif message.guild:\n # Message comes from a server.\nelse:\n # Message comes from a DM.\n\nThis makes it better to separate DM from server messages. You just now have to move the \"await message.channel.send\" function.\n", "I assume that you are asking for a bot that only listens to your commands. Well, in that case, you can create a check to see if the message is sent by you or not. It can be done using,\[email protected]\nasync def on_message(message):\nif message.author.id == <#your user id>:\n await message.channel.send('message detected')\n ...#your code\n\n", "You Can Use Simplest And Best Way\[email protected]()\nasync def check(ctx):\n if not isinstance(ctx.channel, discord.channel.DMChannel):\n Your Work...\n\n" ]

[ 1, 1, 0, 0 ]

[]

[]

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

[ "If you're trying to json.dump() it into a JSON file, using the json.dump() function you could pass in the indent argument for indentation (appears to be what you want) You can read more about it here\nAn example:\njson.dump(jsonData, jsonFile, indent=2) # indentation is usually in spaces, so 2 would mean 2 spaces indentation, but you can replace it with '\\t' for tabs\n\nAll this does is add indentation to the file to make it easier to read\n" ]

[ 1 ]

[]

[]

[ "dictionary", "python", "python_re" ]

[ "This is another solution without boto3 and only using requests\nimport hashlib\nimport hmac\nimport logging\nfrom collections import OrderedDict\nfrom urllib.parse import urlencode\nimport defusedxml.ElementTree as ET\nfrom sdc_etl_libs.api_helpers.API import API\nimport sys, datetime, hashlib, hmac \nimport requests\nimport json\nfrom bs4 import BeautifulSoup\ndef get_session_token_from_xml(content):\n soup = BeautifulSoup(content, \"xml\")\n return soup.find('SessionToken').text, soup.find('AccessKeyId').text, soup.find('SecretAccessKey').text\n\ndef set_params(action_):\n\n logging.info(f\"Setting params according to action {action_}\")\n params = dict()\n if action_ == 'AssumeRole':\n params['Version'] = '2011-06-15'\n params['Action'] = action_\n params['RoleSessionName'] = <<ROLE NAME>>\n params['RoleArn'] = <<ROLE ARN>>\n params['DurationSeconds']='3600'\n elif action_ == 'orders':\n params['MarketplaceIds'] = <<MARKET PLACE>>\n params['LastUpdatedAfter'] = '2022-11-27T14:00:00Z'\n params['LastUpdatedBefore'] = '2022-11-27T16:00:00Z'\n else:\n raise Exception(\"Action is not implemented.\")\n return params\ndef _get_access_token(lwa_app_id, lwa_client_secret, refresh_token):\n url = \"https://api.amazon.com/auth/O2/token\"\n\n payload=f'client_id={lwa_app_id}&client_secret={lwa_client_secret}&refresh_token={refresh_token}&grant_type=refresh_token'\n headers = {\n 'Host': 'api.amazon.com',\n 'Content-Type': 'application/x-www-form-urlencoded',\n }\n\n response = requests.request(\"POST\", url, headers=headers, data=payload)\n\n return response\ndef format_params_to_create_signature(params_to_format_):\n \"\"\"\n URL encodes the parameter name and values\n https://docs.developer.amazonservices.com/en_US/dev_guide/DG_QueryString.html\n :param params_to_format_: dict. Parameters that should be ordered in natural byte order\n and url encoded.\n :return: str.\n \"\"\"\n logging.info(\"Format params.\")\n params_in_order = OrderedDict(sorted(params_to_format_.items()))\n params_formatted = urlencode(params_in_order, doseq=True)\n return params_formatted\n\ndef sign(key, msg):\n \n return hmac.new(key, msg.encode('utf-8'), hashlib.sha256).digest()\n\ndef getSignatureKey(key, dateStamp, regionName, serviceName):\n kDate = sign(('AWS4' + key).encode('utf-8'), dateStamp)\n kRegion = sign(kDate, regionName)\n kService = sign(kRegion, serviceName)\n kSigning = sign(kService, 'aws4_request')\n return kSigning\n\ndef _get_signature_request(action, access_key, secret_key, service, host, region, endpoint, \nmethod: str = 'GET', access_token: str = None, security_token: str = None):\n \n # ************* REQUEST VALUES *************\n params = set_params(action)\n fparams = format_params_to_create_signature(params)\n request_parameters = fparams\n\n # Read AWS access key from env. variables or configuration file. Best practice is NOT\n # to embed credentials in code.\n if access_key is None or secret_key is None:\n raise Exception(\"Access key or secret key are not implemented.\")\n\n # Create a date for headers and the credential string\n t = datetime.datetime.utcnow()\n amzdate = t.strftime('%Y%m%dT%H%M%SZ')\n datestamp = t.strftime('%Y%m%d') # Date w/o time, used in credential scope\n # ************* TASK 1: CREATE A CANONICAL REQUEST *************\n # http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html\n\n # Step 1 is to define the verb (GET, POST, etc.)--already done.\n\n # Step 2: Create canonical URI--the part of the URI from domain to query \n # string (use '/' if no path)\n if action == 'AssumeRole':\n canonical_uri = '/' \n else:\n canonical_uri = '/orders/v0/orders' \n\n # Step 3: Create the canonical query string. In this example (a GET request),\n # request parameters are in the query string. Query string values must\n # be URL-encoded (space=%20). The parameters must be sorted by name.\n # For this example, the query string is pre-formatted in the request_parameters variable.\n canonical_querystring = request_parameters\n\n # Step 4: Create the canonical headers and signed headers. Header names\n # must be trimmed and lowercase, and sorted in code point order from\n # low to high. Note that there is a trailing \\n.\n\n # Step 5: Create the list of signed headers. This lists the headers\n # in the canonical_headers list, delimited with \";\" and in alpha order.\n # Note: The request can include any headers; canonical_headers and\n # signed_headers lists those that you want to be included in the \n # hash of the request. \"Host\" and \"x-amz-date\" are always required.\n if action == 'AssumeRole':\n canonical_headers = 'host:' + host + '\\n' + 'x-amz-date:' + amzdate + '\\n'\n\n signed_headers = 'host;x-amz-date'\n else:\n canonical_headers = 'host:' + host + '\\n' + 'x-amz-access-token:' + \\\n access_token + '\\n' + 'x-amz-date:' + amzdate + '\\n' + 'x-amz-security-token:' + \\\n security_token + '\\n'\n\n signed_headers = 'host;x-amz-access-token;x-amz-date;x-amz-security-token'\n \n\n # Step 6: Create payload hash (hash of the request body content). For GET\n # requests, the payload is an empty string (\"\").\n payload_hash = hashlib.sha256(('').encode('utf-8')).hexdigest()\n\n # Step 7: Combine elements to create canonical request\n canonical_request = method + '\\n' + canonical_uri + '\\n' + canonical_querystring + '\\n' + canonical_headers + '\\n' + \\\n signed_headers + '\\n' + payload_hash\n\n # ************* TASK 2: CREATE THE STRING TO SIGN*************\n # Match the algorithm to the hashing algorithm you use, either SHA-1 or\n # SHA-256 (recommended)\n algorithm = 'AWS4-HMAC-SHA256'\n credential_scope = datestamp + '/' + region + '/' + service + '/' + 'aws4_request'\n string_to_sign = algorithm + '\\n' + amzdate + '\\n' + credential_scope + '\\n' + \\\n hashlib.sha256(canonical_request.encode('utf-8')).hexdigest()\n\n # ************* TASK 3: CALCULATE THE SIGNATURE *************\n # Create the signing key using the function defined above.\n signing_key = getSignatureKey(secret_key, datestamp, region, service)\n # Sign the string_to_sign using the signing_key\n signature = hmac.new(signing_key, (string_to_sign).encode('utf-8'), hashlib.sha256).hexdigest()\n \n # ************* TASK 4: ADD SIGNING INFORMATION TO THE REQUEST *************\n # The signing information can be either in a query string value or in \n # a header named Authorization. This code shows how to use a header.\n # Create authorization header and add to request headers\n authorization_header = algorithm + ' ' + 'Credential=' + access_key + '/' + credential_scope + ', ' + \\\n 'SignedHeaders=' + signed_headers + ', ' + 'Signature=' + signature\n # The request can include any headers, but MUST include \"host\", \"x-amz-date\", \n # and (for this scenario) \"Authorization\". \"host\" and \"x-amz-date\" must\n # be included in the canonical_headers and signed_headers, as noted\n # earlier. Order here is not significant.\n # Python note: The 'host' header is added automatically by the Python 'requests' library.\n if action == 'AssumeRole':\n headers = {'x-amz-date':amzdate, 'Authorization':authorization_header}\n else:\n headers = {\n 'authorization': authorization_header,\n 'host': host,\n 'x-amz-access-token': access_token,\n 'x-amz-date': amzdate, \n 'x-amz-security-token': security_token\n }\n\n # ************* SEND THE REQUEST *************\n request_url = endpoint + '?' + canonical_querystring\n logging.info(f\"BEGIN REQUEST++++++++++++++++++++++++++++++++++++'\")\n logging.info(f\"Request URL = {request_url}\")\n r = requests.get(request_url, headers=headers)\n\n logging.info('\\nRESPONSE++++++++++++++++++++++++++++++++++++')\n logging.info('Response code: %d\\n' % r.status_code)\n\n return r\n\nthe way to run in is the following\nservice = 'sts'\nhost = 'sts.amazonaws.com'\nregion = 'us-east-1'\nendpoint = 'https://sts.amazonaws.com'\nresponse = _get_signature_session('AssumeRole', access_key, secret_key, service, host, region, endpoint)\naccess_token = json.loads(_get_access_token(lwa_app_id, lwa_client_secret, refresh_token).content)['access_token']\ntmp_session_token_, tmp_access_key, tmp_secret_access_key = get_session_token_from_xml(response.content.decode('utf-8'))\n\nafter that you will have the temporal session token, the temporal access key ath the temporal secret key. finally to get the all orders is in the following code\nservice = 'execute-api'\nhost = 'sellingpartnerapi-na.amazon.com'\nregion = 'us-east-1'\nendpoint = 'https://sellingpartnerapi-na.amazon.com/orders/v0/orders'\nresponse = _get_signature_session('orders', tmp_access_key, tmp_secret_access_key, service, host, region, endpoint,\n access_token = access_token, security_token = tmp_session_token_)\n\n", "After some research and testing, I modified the python app, and it works!\nBefore reading the code below, READ THIS.\nYou must execute pip install boto3 to make it work.\nHere are the docs: https://pypi.org/project/boto3/\nI'm putting the credentials in a raw dict instead of following the boto3 docs structure because it was just for testing. If you want to test it with the code, just replace the credentials dict values.\nNotice that it is working with the sandbox environment and getOrders endpoint, and you must specify your own RoleSessionName.\nHere is the code:\n\n# AWS Version 4 signing example\n\n# EC2 API (DescribeRegions)\n\n# See: http://docs.aws.amazon.com/general/latest/gr/sigv4_signing.html\n# This version makes a GET request and passes the signature\n# in the Authorization header.\nimport sys, os, base64, datetime, hashlib, hmac \nimport requests # pip install requests\nimport boto3\n\ncredentials = {\n \n 'lwa_refresh_token': 'whatever',\n 'lwa_client_secret': 'whatever',\n 'lwa_client_id': 'whatever',\n 'aws_secret_access_key': 'whatever',\n 'aws_access_key': 'whatever',\n 'role_arn': 'whatever:role/whatever'\n}\n\n\n# get Access Token and assign to 'x-amz-access-token'\nresponse = requests.post('https://api.amazon.com/auth/o2/token',\n headers={'Content-Type': 'application/x-www-form-urlencoded'},\n data={\n 'grant_type': 'refresh_token',\n 'refresh_token': credentials['lwa_refresh_token'],\n 'client_id': credentials['lwa_client_id'],\n 'client_secret': credentials['lwa_client_secret']\n }\n)\ncredentials['x-amz-access-token'] = response.json()['access_token']\n\n# get AWS STS Session Token and assign to 'x-amz-security-token'\nsts_client = boto3.client(\n 'sts',\n aws_access_key_id=credentials['aws_access_key'],\n aws_secret_access_key=credentials['aws_secret_access_key']\n)\n\nassumed_role_object=sts_client.assume_role(\n RoleArn=credentials['role_arn'],\n RoleSessionName=\"whatever role sesion name you got\"\n)\ncredentials['x-amz-security-token'] = assumed_role_object['Credentials']['SessionToken']\ncredentials['aws_access_key'] = assumed_role_object['Credentials']['AccessKeyId']\ncredentials['aws_secret_access_key'] = assumed_role_object['Credentials']['SecretAccessKey']\n\n# ************* REQUEST VALUES *************\nmethod = 'GET'\nservice = 'execute-api'\nhost = 'sandbox.sellingpartnerapi-na.amazon.com'\nregion = 'us-east-1'\nendpoint = 'https://sandbox.sellingpartnerapi-na.amazon.com/orders/v0/orders'\nrequest_parameters = 'CreatedAfter=TEST_CASE_200&MarketplaceIds=ATVPDKIKX0DER'\n\n# Key derivation functions. See:\n# http://docs.aws.amazon.com/general/latest/gr/signature-v4-examples.html#signature-v4-examples-python\ndef sign(key, msg):\n return hmac.new(key, msg.encode('utf-8'), hashlib.sha256).digest()\n\ndef getSignatureKey(key, dateStamp, regionName, serviceName):\n kDate = sign(('AWS4' + key).encode('utf-8'), dateStamp)\n kRegion = sign(kDate, regionName)\n kService = sign(kRegion, serviceName)\n kSigning = sign(kService, 'aws4_request')\n return kSigning\n\n# Read AWS access key from env. variables or configuration file. Best practice is NOT\n# to embed credentials in code.\naccess_key = credentials['aws_access_key']\n# No deberia de ser security-token, si no secret_access_key?¿\nsecret_key = credentials['aws_secret_access_key']\nif access_key is None or secret_key is None:\n print('No access key is available.')\n sys.exit()\n\n# Create a date for headers and the credential string\nt = datetime.datetime.utcnow()\namzdate = t.strftime('%Y%m%dT%H%M%SZ')\ndatestamp = t.strftime('%Y%m%d') # Date w/o time, used in credential scope\n\n\n# ************* TASK 1: CREATE A CANONICAL REQUEST *************\n# http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html\n\n# Step 1 is to define the verb (GET, POST, etc.)--already done.\n\n# Step 2: Create canonical URI--the part of the URI from domain to query \n# string (use '/' if no path)\ncanonical_uri = '/orders/v0/orders' \n\n# Step 3: Create the canonical query string. In this example (a GET request),\n# request parameters are in the query string. Query string values must\n# be URL-encoded (space=%20). The parameters must be sorted by name.\n# For this example, the query string is pre-formatted in the request_parameters variable.\ncanonical_querystring = request_parameters\n\n# Step 4: Create the canonical headers and signed headers. Header names\n# must be trimmed and lowercase, and sorted in code point order from\n# low to high. Note that there is a trailing \\n.\ncanonical_headers = 'host:' + host + '\\n' + 'user-agent:' + 'Ladder data ingestion' + '\\n' + 'x-amz-access-token:' + credentials['x-amz-access-token'] + '\\n' + 'x-amz-date:' + amzdate + '\\n' + 'x-amz-security-token:' + credentials['x-amz-security-token'] + '\\n'\n \n# Step 5: Create the list of signed headers. This lists the headers\n# in the canonical_headers list, delimited with \";\" and in alpha order.\n# Note: The request can include any headers; canonical_headers and\n# signed_headers lists those that you want to be included in the \n# hash of the request. \"Host\" and \"x-amz-date\" are always required.\nsigned_headers = 'host;user-agent;x-amz-access-token;x-amz-date;x-amz-security-token'\n\n# Step 6: Create payload hash (hash of the request body content). For GET\n# requests, the payload is an empty string (\"\").\npayload_hash = hashlib.sha256(('').encode('utf-8')).hexdigest()\n\n# Step 7: Combine elements to create canonical request\ncanonical_request = method + '\\n' + canonical_uri + '\\n' + canonical_querystring + '\\n' + canonical_headers + '\\n' + signed_headers + '\\n' + payload_hash\nprint(\"My Canonical String:\")\nprint(canonical_request+'\\n')\n\n# ************* TASK 2: CREATE THE STRING TO SIGN*************\n# Match the algorithm to the hashing algorithm you use, either SHA-1 or\n# SHA-256 (recommended)\nalgorithm = 'AWS4-HMAC-SHA256'\ncredential_scope = datestamp + '/' + region + '/' + service + '/' + 'aws4_request'\nstring_to_sign = algorithm + '\\n' + amzdate + '\\n' + credential_scope + '\\n' + hashlib.sha256(canonical_request.encode('utf-8')).hexdigest()\nprint(\"My String to Sign\")\nprint(string_to_sign+'\\n')\n\n# ************* TASK 3: CALCULATE THE SIGNATURE *************\n# Create the signing key using the function defined above.\nsigning_key = getSignatureKey(secret_key, datestamp, region, service)\n\n# Sign the string_to_sign using the signing_key\nsignature = hmac.new(signing_key, (string_to_sign).encode('utf-8'), hashlib.sha256).hexdigest()\n\n\n# ************* TASK 4: ADD SIGNING INFORMATION TO THE REQUEST *************\n# The signing information can be either in a query string value or in \n# a header named Authorization. This code shows how to use a header.\n# Create authorization header and add to request headers\nauthorization_header = algorithm + ' ' + 'Credential=' + access_key + '/' + credential_scope + ', ' + 'SignedHeaders=' + signed_headers + ', ' + 'Signature=' + signature\n\n# The request can include any headers, but MUST include \"host\", \"x-amz-date\", \n# and (for this scenario) \"Authorization\". \"host\" and \"x-amz-date\" must\n# be included in the canonical_headers and signed_headers, as noted\n# earlier. Order here is not significant.\n# Python note: The 'host' header is added automatically by the Python 'requests' library.\nheaders = {\n 'authorization': authorization_header,\n 'host': host,\n 'user-agent': 'Ladder data ingestion',\n 'x-amz-access-token': credentials['x-amz-access-token'],\n 'x-amz-date': amzdate, \n 'x-amz-security-token': credentials['x-amz-security-token']\n}\n\n\n# ************* SEND THE REQUEST *************\nrequest_url = endpoint + '?' + canonical_querystring\n\nprint('\\nBEGIN REQUEST++++++++++++++++++++++++++++++++++++')\nprint('Request URL = ' + request_url)\nr = requests.get(request_url, headers=headers)\n\nprint('\\nRESPONSE++++++++++++++++++++++++++++++++++++')\nprint('Response code: %d\\n' % r.status_code)\nprint(r.text)\n\n\nIf you replace your credentials in the code, and it doesn't work, you may need to regenerate them. You can leave a comment here or open a new question and link it in a comment, so I can check it.\nI've also made a request to getOrder() endpoint, let me know if you have any problem pointing to sandbox.\n" ]

[ 1, 0 ]

[]

[]

[ "amazon_product_api", "api", "python" ]

[ "I'll first break down the error:\nA NoneType object is basically the None object in Python. You could consider it to be basically an object with no value. If you're getting this error, it means you're trying to use the .round() method on something that either returns None, or a None value.\nNow about your code:\nYou use the .round() method on a print() function, which returns None. So instead you should remove that and just have something like this:\nprint((\"The length in inches\",round(inches,2))) # Removed extra .round()\nprint((\"The length in feet\",round(feet,2)))\n\nFull code:\ncm = int(input(\"Write height in Centimeters:\"))\ninches = 0.394*cm\nfeet = 0.0328*cm\nprint((\"The length in inches\",round(inches,2)))\nprint((\"The length in feet\",round(feet,2)))\n\n", "try this\ncm = int(input(\"Write height in Centimeters:\"))\ninches = 0.394*cm\nfeet = 0.0328*cm\nprint((\"The length in inches\",round(inches,2)))\nprint((\"The length in feet\",round(feet,2)))\n\n", "You are attempting to call a method called round() as a class method of print. Print is not an object but a function which returns None, so you are attempting to call round() on None. Remove the .round(inches, 2) and .round(feet, 2) and your code should run as expected.\n", "NoneType in Python is a data type that simply shows that an object has no value/has a value of None.\nNoneType does't have a round attribute as error said.\nin your code you are using round attribut in print statement:\nprint((\"The length in inches\",round(inches,2))).round(inches,2)\nthat is why python give you error.\nyour code should be:\nprint((\"The length in inches\",round(inches,2)))\n\n" ]

[ 1, 0, 0, 0 ]

[]

[]

[ "python" ]

[ "There is surprisingly little about this online. I was able to find someone else's discussion of this over at python/typing's Github, which I distilled using your example.\nThe crux of this solution is Callback Protocols, which are functionally equivalent to Callable, but additionally enable us to modify the return type of __get__ (essentially removing the self parameter) as is done for standard methods.\nfrom __future__ import annotations\n\nfrom typing import Any, Callable, Concatenate, Generic, ParamSpec, Protocol, TypeVar\n\nfrom requests import Request\n\nP = ParamSpec(\"P\")\nR = TypeVar(\"R\", covariant=True)\n\n\nclass Method(Protocol, Generic[P, R]):\n def __get__(self, instance: Any, owner: type | None = None) -> Callable[P, R]:\n ...\n\n def __call__(self_, self: Any, *args: P.args, **kwargs: P.kwargs) -> R:\n ...\n\n\ndef request_wrapper(f: Callable[Concatenate[Any, Request, P], R]) -> Method[P, R]:\n def inner(self, *args: P.args, **kwargs: P.kwargs) -> R:\n return f(self, Request(), *args, **kwargs)\n\n return inner\n\n\nclass Thing:\n @request_wrapper\n def takes_int_str(self, request: Request, x: int, y: str) -> int:\n print(request)\n return x + 7\n\n\nthing = Thing()\nthing.takes_int_str(1, \"a\")\n\n" ]

[ 0 ]

[]

[]

[ "python", "python_3.10", "typing" ]

[ "Using async def endpoint\nIf an object is a co-routine, it needs to be awaited. FastAPI is based on Starlette, and Starlette methods for returning the request body are async methods (see source code here); thus, one needs to await them (using an async def endpoint). For example:\nfrom fastapi import Request\n\[email protected](\"/input\")\nasync def input_request(request: Request):\n return await request.body()\n\nUpdate 1 - Using def endpoint\nAlternatively, if you are confident that the incoming data is a valid JSON, you can define your endpoint with def instead, and use the Body field, as shown below (for more options on how to post JSON data, see this answer):\nfrom fastapi import Body\n\[email protected](\"/input\")\ndef input_request(payload: dict = Body(...)):\n return payload\n\nIf, however, the incoming data are in XML format, as in the example you provided, you could pass them via Files instead, as shown below—as long as you have control over how client data are sent (have a look here as well).\nfrom fastapi import File\n\[email protected](\"/input\") \ndef input_request(contents: bytes = File(...)): \n return contents\n\nUpdate 2 - Using def endpoint and async dependency\nAs described in this post, you can use an async dependency function to pull out the body from the request. You can use async dependencies on non-async (i.e., def) endpoints as well. Hence, if there is some sort of blocking code in this endpoint that prevents you from using async/await—as I am guessing this might be the reason in your case—this is the way to go.\nNote: I should also mention that this answer—which explains the difference between def and async def endpoints (that you might be aware of)—also provides solutions when you are required to use async def (as you might need to await for coroutines inside a route), but also have some synchronous expensive CPU-bound operation that might be blocking the server. Please have a look.\nExample of the approach described earlier can be found below. You can uncomment the time.sleep() line, if you would like to confirm yourself that a request won't be blocking other requests from going through, as when you declare an endpoint with normal def instead of async def, it is run in an external threadpool (regardless of the async def dependency function).\nfrom fastapi import FastAPI, Depends, Request\nimport time\n\napp = FastAPI()\n\nasync def get_body(request: Request):\n return await request.body()\n\[email protected](\"/input\")\ndef input_request(body: bytes = Depends(get_body)):\n print(\"New request arrived.\")\n #time.sleep(5)\n return body\n\n", "For convenience, you can simply use asgiref, this package supports async_to_sync and sync_to_async:\nfrom asgiref.sync import async_to_sync\n\nsync_body_func = async_to_sync(request.body)\nprint(sync_body_func())\n\nasync_to_sync execute an async function in a eventloop, sync_to_async execute a sync function in a threadpool.\n" ]

[ 9, 0 ]

[]

[]

[ "fastapi", "python", "starlette" ]

[ "You can use the F objects:\nfrom django.db.models import F\n\nTable.objects.filter(...).update(column=F(\"column\") + \"100\")\n\nYou don't need to check if column == \"\" because it won't matter when you append \"100\" to it.\n" ]

[ 1 ]

[]

[]

[ "django", "python" ]

[ "You can use tasks.loop, creating a task that updates every minute and changes the bot's Status to the current time.\ntasks.loop is a decorator which executes the decorated function repeatedly at a defined interval. Then you just need to spawn the loop in an asynchronous context, of which I personally use setup_hook in this example.\nfrom discord.ext import tasks\nimport datetime\n\[email protected](minutes=1):\nasync def set_status(): # name is unimportant, but it must not take arguments\n name = datetime.datetime.utcnow().strftime(\"%H:%M\")\n activity = discord.Game(name=name)\n await client.change_presence(activity=activity)\n\[email protected]\nasync def setup_hook(): # name is important, and it must not take arguments\n set_status.start()\n\nReplacing client with the name of your client as appropriate (usually client or bot).\n" ]

[ 0 ]

[]

[]

[ "bots", "discord", "python" ]

[ "Is the SLSQP method compatible with functions that return boolean values true and false? I would rework function constraint1 to return real values instead of boolean values. If SLSQP is compatible with boolean functions, could you point me to the documentation that states this?\nWhen I saw this message, \"df = fun(x) - f0 TypeError: numpy boolean subtract,\" I found this odd because why would the computation of the derivative involve substraction of boolean values. After looking through your code, I noticed that the function constraint1 is returning boolean values true and false. Traditionally, the objective and constraint functions return real values. I would rework function constraint1 to return real values.\n" ]

[ 1 ]

[]

[]

[ "optimization", "python", "scipy", "scipy_optimize", "scipy_optimize_minimize" ]

[ "You can try ax.spines[\"bottom\"].set_linewidth(3).\n" ]

[ 0 ]

[]

[]

[ "jupyter_notebook", "matplotlib", "python", "seaborn" ]

[ "So i've tried to copy the similar method on a simple dataset and i've seem to make it work, here's the code snippet\nmx = max(df1['Salary'])\nplc = df.loc[df1['Salary']==mx]['Name']\nprint('Max Sal : ' + str(plc.iloc[0]))\n\nOutput:\nMax Sal : Farah\n\nAccording to this post on Stack Overflow, when you use df.loc[df1['Salary']==mx]['Name'] , A Series Object is returned, and so to retrieve the value of the desired column, you use [0], if I understood the post correctly.\nSo for your code, you can replace\nregion = regions.loc[regions['AveragePrice']==regionMax]\nprint(f\"The highest average price for both types of potatoes is ${regionMax} from {region['region']}.\")\n\n\nwith\nregion = regions.loc[regions['AveragePrice']==regionMax]['region']\n\nprint(f\"The highest average price for both types of potatoes is ${regionMax} from {region}.\")\n\n\nThis should work. Hope this helps!\n" ]

[ 0 ]

[]

[]

[ "dataframe", "python" ]

[]

[]

[ "I suggest you to learn about association, composition and aggregation and inheritance and when to use them, so that you have better understanding of relation between objects and classes at the high level.\nalso in your code you can't have two init method in one class i highly recommend to have clear understanding of python OOP with writing pseudo codes.\n" ]

[ -1 ]

[ "class", "object", "python" ]

[ "I would consider changing the serializer as below,\nclass VideoManageSerializer(serializers.ModelSerializer):\n video_tag_id = serializers.PrimaryKeyRelatedField(\n many=True,\n queryset=VideoTag.objects.all(),\n write_only=True,\n )\n tags = VideoVideoTagSerializer(many=True, read_only=True)\n\n class Meta:\n model = Video\n fields = \"__all__\"\n\n # POST\n def create(self, validated_data):\n tags = validated_data.pop(\"video_tag_id\")\n video_instance = Video.objects.create(**validated_data)\n for tag in tags:\n VideoVideoTag.objects.create(videoId=video_instance, videoTagId=tag)\n return video_instance\n\nThings that have changed -\n\nAdded a new write_only field named video_tag_id that supposed to accept \"list of PKs of VideoTag\".\nChanged the tags field to read_only so that it won't take part in the validation process, but you'll get the \"nested serialized output\".\nChanged create(...) method to cooperate with the new changes.\nThe POST payload has been changed as below (note that tags has been removed and video_tag_id has been introduced)\n{\n \"deleted\":false,\n \"publishedOn\":\"2022-11-28\",\n \"decoratedThumbnail\":\"https://t3.ftcdn.net/jpg/02/48/42/64/360_F_248426448_NVKLywWqArG2ADUxDq6QprtIzsF82dMF.jpg\",\n \"rawThumbnail\":\"https://t3.ftcdn.net/jpg/02/48/42/64/360_F_248426448_NVKLywWqArG2ADUxDq6QprtIzsF82dMF.jpg\",\n \"videoUrl\":\"https://www.youtube.com/watch?v=jNQXAC9IVRw\",\n \"title\":\"Video with tags\",\n \"duration\":120,\n \"visibility\":1,\n \"video_tag_id\":[1,2,3]\n}\n\n\n\nRefs\n\nDRF: Simple foreign key assignment with nested serializer?\nDRF - write_only\nDRF - read_only\n\n" ]

[ 3 ]

[]

[]

[ "api", "django", "django_rest_framework", "python", "sql" ]

[ "So following the steps from @Gordon Davisson:\nI tried pasting open -a '/Applications/Microsoft Excel.app' '/Users/andersballeby/Desktop/McDonalds Programmer/Main Project/McDonalds-Leader-Panel/skiftplaner/November/onsdag d. 30-11/Skiftplan (onsdag - MID - 12:00 - 17:00).xlsx' into my terminal, which returned the same error message as on the image at the top of this thread.\nThen i tried pasting the other command: ls '/Users/andersballeby/Desktop/McDonalds Programmer/Main Project/McDonalds-Leader-Panel/skiftplaner/November/onsdag d. 30-11/Skiftplan (onsdag - MID - 12:00 - 17:00).xlsx' which just returned the same file with no interesting properties at all.\nThen by removing the file and simply just looking at the ls November/onsdag d.30-11/ folder, i saw this:\nSkiftplan (onsdag - MID - 12:00 - 17:00).xlsx\nSkiftplan (onsdag - MID - 12:00 - 17:Skiftplan (onsdag - MID - 12:00 - 17:~$00).xlsx\n\nThis got me to look in my finder directory folder, and I could only see the first file, not the second file.\nAfter this i tried closing all instances of excel and somehow it just works now, if i try doing ls November/onsdag d.30-11/ again, it only returns the single file im looking for:\nSkiftplan (onsdag - MID - 12:00 - 17:00).xlsx\n\nThis now went on to fully function in the program, and it's now able to open the excel file without any errors or complications whatsoever.\n" ]

[ 0 ]

[]

[]

[ "macos", "openpyxl", "operating_system", "python", "python_3.x" ]

[ "That's because you're trying to mutate project_1 field two times in a single query. Mongo just doesn't know how to deal with that.\nYou should consider splitting two operations:\ndb.collection.update_many({'dataset_path': 'path_to_dataset'}, {'$rename': {\"project_1\": \"renamed_project_1\"}})\ndb.collection.update_many({'dataset_path': 'path_to_dataset'}, {'$set': {\"renamed_project_1.model_1\": \"new_model_1_path\"}})\n\n", "db.collection.update_many({}, {\"$rename\": {\"old_value\": \"new_value\"}})\n\n" ]

[ 0, 0 ]

[]

[]

[ "mongodb", "pymongo", "pymongo_3.x", "python" ]

[ "You can use getattr\nfrom fuzzywuzzy import fuzz\nfrom fuzzywuzzy import process\nmethod_name1 ='token_sort_ratio'\nmethod_name2 ='partial_ratio'\nmethod_name3 ='ratio'\n\ndef compare_alg(l1, l2, alg):\n print(getattr(fuzz, alg)(l1,l2))\n\ncompare_alg(\"Catherine M Gitau\",\"Catherine Gitau\", method_name1)\ncompare_alg(\"Catherine M Gitau\",\"Catherine Gitau\", method_name2)\ncompare_alg(\"Catherine M Gitau\",\"Catherine Gitau\", method_name3)\n\n" ]

[ 1 ]

[]

[]

[ "python" ]

[ "This is now supported via the render_template_as_native_obj.\nPlease add the following argument to your DAG object for Jinja to apply correct typing for basic python objects:\nrender_template_as_native_obj=True\n\n", "This is not supported currently but will be supported when https://github.com/apache/airflow/pull/14603 is merged.\n" ]

[ 1, 0 ]

[]

[]

[ "airflow", "python", "templating" ]

[ "Thanks to @martineau's comment, I figured out how to draw a dotted line. Here is my code.\ncur_x = 0\ncur_y = 0\nimage_width = 600\nfor x in range(cur_x, image_width, 4):\n draw.line([(x, cur_y), (x + 2, cur_y)], fill=(170, 170, 170))\n\nThis will draw a dotted line of gray color.\n", "I decided to write up the idea I suggested in the comments - namely to draw the shapes with solid lines and then overlay a thresholded noisy image to obliterate parts of the line.\nI made all the noise on a smaller image and then scaled it up so that the noise was \"more clumped\" instead of tiny blobs.\nSo this is just the generation of the test image:\n#!/usr/local/bin/python3\n\nimport numpy as np\nfrom PIL import Image, ImageDraw\n\n# Make empty black image\nim = Image.new('L', (640,480))\n\n# Draw white rectangle and ellipse\ndraw = ImageDraw.Draw(im)\ndraw.rectangle([20,20,620,460],outline=255)\ndraw.ellipse([100,100,540,380],outline=255)\n\nAnd this is generating the noise overlay and overlaying it - you can just delete this sentence and join the two lumps of code together:\n# Make noisy overlay, 1/4 the size, threshold at 50%, scale up to full-size\nnoise = np.random.randint(0,256,(120,160),dtype=np.uint8)\nnoise = (noise>128)*255\nnoiseim = Image.fromarray(noise.astype(np.uint8))\nnoiseim = noiseim.resize((640,480), resample=Image.NEAREST)\n\n# Paste the noise in, but only allowing the white shape outlines to be affected\nim.paste(noiseim,mask=im)\nim.save('result.png')\n\nThe result is this:\n\nThe solidly-drawn image is like this:\n\nThe noise is like this:\n\n", "The following function draws a dashed line. It might be slow, but it works and I needed it. \n\"dashlen\" is the length of the dashes, in pixels. - \n\"ratio\" is the ratio of the empty space to the dash length (the higher the value the more empty space you get)\nimport math # math has the fastest sqrt\n\ndef linedashed(x0, y0, x1, y1, dashlen=4, ratio=3): \n dx=x1-x0 # delta x\n dy=y1-y0 # delta y\n # check whether we can avoid sqrt\n if dy==0: len=dx\n elif dx==0: len=dy\n else: len=math.sqrt(dx*dx+dy*dy) # length of line\n xa=dx/len # x add for 1px line length\n ya=dy/len # y add for 1px line length\n step=dashlen*ratio # step to the next dash\n a0=0\n while a0<len:\n a1=a0+dashlen\n if a1>len: a1=len\n draw.line((x0+xa*a0, y0+ya*a0, x0+xa*a1, y0+ya*a1), fill = (0,0,0))\n a0+=step \n\n", "I know this question is a bit old (4 y.o. at the time of my writing this answer), but as it happened I was in need of drawing a patterned line.\nSo I concocted my own solution here: https://codereview.stackexchange.com/questions/281582/algorithm-to-traverse-a-path-through-several-data-points-and-draw-a-patterned-li\n(Sorry the solution was a bit long, better to just look there. The code works, though, that's why it's in CodeReview SE).\nProvide the right \"pattern dictionary\", where blank segments are represented by setting color to None, and you should be good to go.\n" ]

[ 4, 1, 0, 0 ]

[]

[]

[ "python", "python_imaging_library" ]

[ "Not a fancy solution but I am passing these updates statements as a list. Since I need only up to three update statements for this to work.\nqueries = [update1, update2, update3]\nfor i, q in enumerate(queries):\n df = pd.read_sql(q,con, param= params)\n\n" ]

[ 0 ]

[]

[]

[ "python", "snowflake_cloud_data_platform" ]

[ "We can use a list comprehension along with re.search here:\nimport re\n\nstring_list = ['ds-pfoo-svcp', 'ds-abc-pbar-svcp','ds-abc-ptee-xyz-svcp']\noutput = [re.search(r'ds(?:-\\w+)*?-p(\\w+)-', x).group(1) for x in string_list]\nprint(output) # ['foo', 'bar', 'tee']\n\n" ]

[ 3 ]

[]

[]

[ "python", "regex" ]

[ "I figured it out. First I must say that I wasn't getting the input I wanted in python.\nIn python to get the each list of dictionaries output how I wanted I had to do take this approach:\nr = [{\"symbol\":10},{\"symbol\":15},{\"symbol\":25}]\nh = [{\"sy\":15},{\"sy\":23},{\"sy\":64}]\ni = [{\"sl\":45},{\"sl\":67},{\"sl\":98}]\nc = 0\nn = []\nfor p in r,h,i:\n print(r[c][\"symbol\"])\n print(h[c][\"sy\"])\n print(i[c][\"sl\"])\n c+=1\n\n" ]

[ 0 ]

[]

[]

[ "flask", "jinja2", "jinjava", "python" ]

[ "From the webbrowser documentation:\n\nNote that on some platforms, trying to open a filename using this function, may work and start the operating system’s associated program. However, this is neither supported nor portable.\n\nSo it seems that webbrowser can't do what you want. Why did you expect that it would?\n", "adding file:// + full path name does the trick for any wondering\n" ]

[ 0, 0 ]

[]

[]

[ "python" ]

[ "if player_choice == \"1\":\n print(\"The chest contains billions of dollars but the money seems to\")\nprint(\"be engulfed in a strange green light which happens to be\")\nprint(\"radioactive!\")\nprint(\"You start feeling light headed and then die!\")\nprint(\"GAME OVER!\")\n\nOnly the lines that are indented underneath the if statement are part of it.\nSo in this example, only print(\"The chest ..\") is actually under the if statement.\nOnce Python sees a non-indented line, it considers the if block to be terminated. So in this example, one it saw print(\"be engulfed...\"), Python thought the if block was over.\nBut then it saw an elif with no apparent preceding if, so it complained.\nEvery line that is conditional on the if statement needs to be indented. Not just the first one.\n", "As John Gordon Mentioned , Indentation is important in Python.\nWhen you create an if else statement for example :\nif(a<b)\n{\n printf(\"a is less than b\");\n}\nelse{\nprintf(\"a is greater than b\");\n}\n\nIn this code snippet of a basic if-else statement in C, you can observe that the indentation doesn't matter as the {} determine what code is executed or not. That's not the case for Python however.\n\nif a>b:\n print(a)\nprint(b)\n\nHere, a is printed if a>b but b is always printed. So if you want multiple lines to be excecuted in a if-else statement. You would have to change it to\nif a>b:\n print(a)\n print(b)\n\nThe same rule applies for Looping and other conditional statements as well.\nHere's a post from W3schools to know more about indentations in python.\n" ]

[ 1, 0 ]

[]

[]

[ "python" ]