Datasets:

---

suriyagunasekar

/

stackoverflow-python-with-meta-data

like 12

[ "spark.sql(\"set spark.sql.legacy.timeParserPolicy=LEGACY\")\n\n w = Window.partitionBy('id')\n( #column cum_a =1 when col1=a else cum_a=0. Once populated, calculate the cumulative sum of cum_a for every id ordered by timestamp\n df.withColumn('cum_a', sum(when(col('col1')=='a',1).otherwise(0)).over(w.orderBy(to_timestamp('timestamp','dd.MM.yyyy HH:mm:ss'))))\n #Find the maximum cum_a value per id \n .withColumn('max', max('cum_a').over(w))\n #Filter out where cum_a equals to max value of cum_a per id \n .where(((col('cum_a')==col('max'))))\n #Drop unwamted intermediatary columns\n .drop('cum_a','max')\n).show()\n\n\n+---+----+-------------------+\n| id|col1| timestamp|\n+---+----+-------------------+\n| 1| a|01.01.2022 10:00:00|\n| 1| b|01.01.2022 10:01:00|\n| 1| d|01.01.2022 10:02:00|\n| 2| a|01.01.2022 13:00:00|\n| 2| c|01.01.2022 13:01:00|\n+---+----+-------------------+\n\n" ]

[ 1 ]

[]

[]

[ "group_by", "pyspark", "python" ]

[ "try this:\ndf3 = pd.merge(df1,df2, how='left', left_on=['Date','name'], right_on=['Date','name'])\n\n", "\ndf1 = df1.merge(df2, how='left', on=['Date', 'name']) # what this line does is it merges df1 and df2 based on the 'Date' and 'name' columns. The resulting df1 has the 'pick' column from df2 appended to it.\ndf1['pick'] = df1['pick_y'].fillna(df1['pick_x']) # this line replaces the NaN values in the 'pick' column with the values from the 'pick_x' column.\ndf1 = df1.drop(['pick_x', 'pick_y', 'index'], axis=1) # this line drops the 'pick_x', 'pick_y' and 'index' columns as they are no longer needed.\n\noutput:\n Date name score stat1 stat2 pick\n0 2022-1-1 ABC 23.3 0.234 34 NaN\n1 2022-1-2 ABC 21.1 0.431 14 NaN\n2 2022-1-3 ABC 29.9 1.31 4 21.1\n3 2022-1-4 ABC 11.3 9.31 3 NaN\n\n" ]

[ 1, 1 ]

[]

[]

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

[ "You are looking to see if 3 character extents in the password match 3 character rows from the keyboard using re.search:\nre.search(self.password[i:i+3], row1)\n\nBut that's the problem. If your password contains a regex control character, re will try to use it. In your example \"aSD7V^&*gS77+\", you'll try the sequence \"*gS\". But that's not a valid regex. \"*\" tells regex to repeat the previous character zero or more times. But there is no character before it, hence re.error: nothing to repeat at position 0\nUse in instead.\nself.password[i:i+3] in row1\n\n" ]

[ 1 ]

[]

[]

[ "python" ]

[ "First of all that command will not start 50 workers, but 1 worker with 50 processes. I'd also recommend to just use as many processes as you have cores available. (Let's say 8 for the rest of my answer.)\nMy guess here is that the other processes are idle because you only perform one task. If you want to do concurrent work, you'll have to split up your work in parts that can be executed concurrently. The easiest way to do this is just make a separate task for every link you want to scrape. The worker will then start working on scraping 8 links and when it finishes 1 it will start on the next one until it has finished scraping all 150.\nso your calling code of your task should roughly like:\nfor link in links:\n scrape_link.delay(link)\n\nwith scrape_link your task function that will look something like:\[email protected]\ndef scrape_link(link):\n #scrape the link and its sub-links\n\n", "I know it's been sometime since this was posted but if anyone is researching this you can use Flower to monitor Celery tasks.\n" ]

[ 4, 0 ]

[]

[]

[ "celery", "django", "python" ]

[ "For anyone who sees this, I figured out a solution using 'scatter' in pytorch however it is a bit ad-hoc. Here is the equivalent code for numpy.\noutcome = np.concatenate((outcome, -outcome), axis=1)\ntemp = np.put_along_axis(np.zeros((20, 10)), match, outcomes, 1)\nscores = np.sum(temp, axis=0)\n\n" ]

[ 0 ]

[]

[]

[ "data_science", "machine_learning", "numpy", "python", "pytorch" ]

[ "You can use the Json data embedded inside the HTML page to get the annual info:\nimport json\nimport requests\nimport pandas as pd\nfrom bs4 import BeautifulSoup\n\n\nurl = \"https://www.onthesnow.com/alberta/lake-louise/historical-snowfall\"\n\nsoup = BeautifulSoup(requests.get(url).content, \"html.parser\")\n\ndata = json.loads(soup.select_one(\"#__NEXT_DATA__\").text)\ndf = pd.DataFrame(data[\"props\"][\"pageProps\"][\"snowfallInfoAnnual\"])\nprint(df.to_markdown(index=False))\n\nPrints:\n\n\n\n\ndate\ntotalSnow\nsnowDays\nbaseDepth\nsummitDepth\nmaxBaseDepth\nbiggestSnowfall\n\n\n\n\n2012-01-01\n467\n80\n25.2892\n128.724\n118\n28\n\n\n2013-01-01\n756\n89\n111.013\n123.061\n207\n40\n\n\n2014-01-01\n465\n64\n77.3352\n105.181\n158\n34\n\n\n2015-01-01\n339\n60\n75.5234\n95.4746\n125\n54\n\n\n2016-01-01\n544\n95\n99.4935\n147.88\n177\n30\n\n\n2017-01-01\n737\n89\n114.79\n153.75\n192\n41\n\n\n2018-01-01\n505\n81\n98.2466\n124.705\n158\n71\n\n\n2019-01-01\n537\n73\n76.7257\n84.805\n188\n36\n\n\n2020-01-01\n445\n76\n88.5694\n110.969\n183\n38\n\n\n2021-01-01\n669\n96\n118.13\n168.105\n178\n54\n\n\n2022-01-01\n111\n14\n39.9333\n47.7667\n52\n24\n\n\nAverage\n507\n75\n85\n118\n158\n41\n\n\n\n", "I would leave this in a comment but I don't have enough reputation, but you can get the data directly:\nMonthly:\nhttps://api.onthesnow.com/api/v2/resort/368/snowfall/monthly\nAnnual:\nhttps://api.onthesnow.com/api/v2/resort/368/snowfall/annual\nExample data returned:\n{\"snowfallItems\":[{\"date\":\"2012-01-01\",\"totalSnow\":467,\"snowDays\":80,\"baseDepth\":25.2892,\"summitDepth\":128.72395779996586,\"maxBaseDepth\":118,\"biggestSnowfall\":28}]}\nNote: Each measurement is in centimetres rather than inches so you might have to convert it.\nEdit: The other (BETTER) answer basically does this and makes things beautiful in a table too\n", "If you can use find_all() function instead of find() while searching tables, you can get the annual table as well. So the code should be like:\nfrom bs4 import BeautifulSoup\nimport requests \n\ndef historic_snowfall():\n #Resort naming convetion on OpenSnow.com\n # Revelstoke, BC: british-columbia, revelstoke-mountain\n # Whistler, BC: british-columbia, whistler-blackcomb\n # Lake Louise, AB: alberta, lake-louise\n # Big Sky, MT: montana, big-sky-resort\n # Snowbird, UT: utah, snowbird\n # Palisades: califronia, squaw-valley-usa\n # Steamboat, CO: colorado, steamboat\n # Copper Mountain, CO: colorado, copper-mountain\n # Aspen, CO: colorado, aspen-snowmass\n # Jackson Hole, WY: wyoming, jackson-hole\n # Taos, NM: taos-ski-valley\n \n resort_table = ['alberta/lake-louise',\n 'montana/big-sky-resort',\n 'utah/snowbird',\n 'california/squaw-valley-usa',\n 'colorado/steamboat',\n 'colorado/copper-mountain',\n 'colorado/aspen-snowmass',\n 'wyoming/jackson-hole',\n 'new-mexico/taos-ski-valley'\n ]\n\n resort = (resort_table[1])\n \n hsnow_url = 'https://www.onthesnow.com/' + resort + '/historical-snowfall'\n page = requests.get(hsnow_url) \n soup = BeautifulSoup(page.content, \"html.parser\")\n \n\n data = []\n data2 = []\n table = soup.find_all('table') # Find table\n\n table_body_1 = table[0].find('tbody') # Find body of table\n rows_table_1 = table_body_1.find_all('tr') #find rows within table\n for row in rows_table_1:\n cols = row.find_all('td') # within rows pull column data\n cols = [ele.text.strip() for ele in cols]\n data.append([ele for ele in cols if ele]) # Get rid of empty values\n\n table_body_2 = table[1].find('tbody') # Find body of table\n rows_table_2 = table_body_2.find_all('tr') #find rows within table\n for row in rows_table_2:\n cols = row.find_all('td') # within rows pull column data\n cols = [ele.text.strip() for ele in cols]\n data2.append([ele for ele in cols if ele]) # Get rid of empty values\n \n return data,data2 #returns monthly averages not yearly results\n\n\nprint(historic_snowfall())\n\n" ]

[ 1, 1, 1 ]

[]

[]

[ "beautifulsoup", "python", "web_scraping" ]

[ "Create a custom compare function and pass it to sort/sorted using functools.cmp_to_key:\ndef angle_compare(a, b):\n def cmp(a, b):\n return (a > b) - (b > a)\n\n if (a < 0) == (b < 0): # both positive or both negative\n return cmp(a, b)\n return cmp(b, a)\n\n>>> Pi = 3.14\n>>> l1 = [Pi/4, 0, Pi/2, -Pi/20, Pi, -Pi/4, -Pi, -3*Pi/4, 3*Pi/4, -Pi/2, -Pi/10]\n>>> sorted(l1, key=functools.cmp_to_key(angle_compare))\n[0, 0.785, 1.57, 2.355, 3.14, -3.14, -2.355, -1.57, -0.785, -0.314, -0.157]\n\n" ]

[ 1 ]

[]

[]

[ "angle", "geometry", "python", "range", "sorting" ]

[ "zlib is not a python package, you can try yum/apt-get install zlib-devel or yum/apt-get install zlib. \n", "For Ubuntu:\n sudo apt-get install zlib1g-dev\n", "On mac using homebrew:\nbrew install zlib\n\n" ]

[ 3, 3, 0 ]

[]

[]

[ "pip", "python", "zlib" ]

[ "forestfire_df will have to be defined before it is displayed, for example with a line like:\nforestfire_df = pd.read_csv(\"forestfires.csv\")\n\n" ]

[ 0 ]

[]

[]

[ "google_colaboratory", "python" ]

[ "Since HTML essentially forgets all of Python after it is initially executed I was unable to find an obvious way to transfer this data without using a database.\nWhat I resorted to instead was using HTML input element with type set to hidden to pass the necessary data to the next form and then retrieve it there using the request.forms.get() function.\n\n" ]

[ 0 ]

[]

[]

[ "bottle", "list", "python", "web_based" ]

[ "You don't need a dataframe\nwith open('test.csv', 'a') as f:\n for item in Vagas:\n on_click = teste2.get('onclick')\n f.write(on_click+'\\n')\n\nor with a dataframe:\ntemp=[]\nfor i in Vagas:\n on_click = teste2.get('onclick')\n temp.append(on_click)\n\ndf = pd.DataFrame(temp)\ndf.to_csv('test.csv', mode='a', header=False, index=False)\n\n" ]

[ 0 ]

[]

[]

[ "dataframe", "pandas", "python", "selenium", "web_scraping" ]

[ "So, strictly speaking, inflection point is indeed a change of sign of curvature. Which, for a 3 times differenciable function, is a point at which there is a change of sign of the 2nd derivative (the second derivative is 0, and the third derivative is not).\nIn your case, since the data are very discrete (only 24 data, one per hour in the day, I surmise), it is quite tricky to talk about second and third derivative. But if we give a try, we can see that, not only the point you are interested in are not inflection points (when the second derivative is 0, that means that the first derivative is locally constant. Which means that the slope is constant. And the points you seem to be interested in are, on the contrary, points where there is a change of slope. The the opposite of an inflection point!.\nThey are tho, inflection points of the derivative, since it seems that they are local extremum of the second derivative, so, at least if we had a continuous enough curve to dare speak of 3rd derivative, one could that that the extrema of second derivative are the 0 of the 3rd derivative. And 3rd derivative is the 2nd derivative of the 1st derivative. So, you could say that you are interested in the inflection points of the 1st derivative, that is of the slope.\nSee code below:\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\nraw = np.array([52.33, 50.154444444444444, 48.69222222222223, 46.49111111111111, 44.01444444444444, 43.30555555555556, 43.034444444444446, 40.62888888888889, 40.38111111111111, 39.07666666666667, 38.339999999999996, 36.41444444444445, 36.37888888888889, 36.17111111111111, 35.666666666666664, 33.827777777777776, 29.35222222222222, 28.60888888888889, 24.43, 22.078888888888887, 21.756666666666664, 20.345555555555556, 19.874444444444446, 19.763333333333335])\nx=np.arange(24)\n\nrawb=np.roll(raw, 1)\nrawa=np.roll(raw,-1)\n\n\nder2=rawb+rawa-2*raw\nder2[0]=der2[-1]=np.nan\nder2abs=np.abs(der2)\noffs = der2abs/(der2abs+np.roll(der2abs, -1))\nyoffs = raw*(1-offs) + rawa*offs\nchsign=(der2*np.roll(der2,-1))<0\n\n\ns=1.5\nmxder2 = (((der2>np.roll(der2,-1)) & (der2>np.roll(der2,1))) | ((der2<np.roll(der2,-1)) & (der2<np.roll(der2,1)))) & (der2abs>s)\n\nfig, ax=plt.subplots()\nax2=ax.twinx()\n\nax.plot(raw)\nax2.plot([0]*24)\nax2.plot(der2)\n\nax.scatter(x[mxder2], raw[mxder2], 80, c='r', marker='*')\nax.scatter((x+offs)[chsign], yoffs[chsign], 30, c='g', marker='o')\nplt.show()\n\nIt shows\n\nThe blue line are your data.\nThe orange line is the second derivative.\nThe green dots are the points where second derivative is 0.\nWhile the red stars are the points where second derivative is an extrema (with a minimum absolute value: we don't count local extrema of area where second derivative is almost flatlining 0).\nFrom what you have shown, you seem more interested in red stars!\nThe green dots are not just too numerous. Even filtering them (from an unknown criteria) would not do: they are all quite boring!\nWhat makes the situation, and the vocabulary, ambiguous is the fact that we are talking about discrete points in reality. Inflection point are points where second derivative is 0. That is where 1st derivative is an extrema. And you need on the contrary points where second derivative is extreme. On so discrete set of data, you can be both tho. And maybe that was the case in your paper: points with sharp change of slopes are points where second derivative are extremely positive, but is surronded by 2 extremely negative second derivative (or the opposite).\nBut, my point is, you seem more interested in red stars.\nAs for how I compute that:\nder2 is the second derivative, using discrete scheme y[-dt]-2y[0]+y[dt]\nder2abs is its absolute value.\noffs is a barycenter weighted by successive values of der2abs. Where there is a change of sign of the 2nd derivative, between index i and i+1, this account for an estimation of the exact position of the 0: offs is 0 if the 0 is at index i, 1 if it is at index 1, 0.5 if it is in the middle between i and i+1, etc. offs makes no sense where there is no change of sign (and we won't use those values).\nyoffs is the raw value using the same barycenter. So, yoffs is yoffs[i], yoffs[i+1], yoffs[i+0.5] in the 3 previous cases (what would be yoffs[i+0.5] were a legal thing). Like offs, makes sense only where there is a change of sign of der2.\nchsign is precisely what says where those change of sign occur.\nSo, we just have to plot yoffs[chsign] vs (x+offs)[chsign] to filter the cases where the second derivative are 0.\nThe red stars are easier to compute:\nWe just find all the points whose second derivative is either bigger or smaller than its 2 neighbor. And filter those to add a minimum value condition (|secondDerivative| must be at least 1.5)\n" ]

[ 1 ]

[]

[]

[ "numpy", "python" ]

[ "The port for SSL is 465 and not 587, however when I used SSL the mail arrived to the junk mail.\nFor me the thing that worked was to use TLS over regular SMTP instead of SMTP_SSL.\nNote that this is a secure method as TLS is also a cryptographic protocol (like SSL).\nimport smtplib, ssl\n\nport = 587 # For starttls\nsmtp_server = \"smtp.gmail.com\"\nsender_email = \"[email protected]\"\nreceiver_email = \"[email protected]\"\npassword = input(\"Type your password and press enter:\")\nmessage = \"\"\"\\\nSubject: Hi there\n\nThis message is sent from Python.\"\"\"\n\ncontext = ssl.create_default_context()\nwith smtplib.SMTP(smtp_server, port) as server:\n server.ehlo() # Can be omitted\n server.starttls(context=context)\n server.ehlo() # Can be omitted\n server.login(sender_email, password)\n server.sendmail(sender_email, receiver_email, message)\n\nprovided thanks to the real python tutorial.\n", "this is how i solved same problem\nimport ssl\n\n\nsender = \"[email protected]\"\npassword = \"password123\"\n \nwhere_to_email = \"[email protected]\"\ntheme = \"this is subject\"\nmessage = \"this is your message, say hi to reciever\"\n \nsender_password = password\nsession = smtplib.SMTP_SSL('smtp.yandex.ru', 465)\nsession.login(sender, sender_password)\nmsg = f'From: {sender}\\r\\nTo: {where_to_email}\\r\\nContent-Type: text/plain; charset=\"utf-8\"\\r\\nSubject: {theme}\\r\\n\\r\\n'\nmsg += message\nsession.sendmail(sender, where_to_email, msg.encode('utf8'))\nsession.quit()\n\n", "google no longer lets you turn this feature off, meaning it just wont work no matter what you do, yahoo appears to be the same way\n", "Code to send email via python:\nimport smtplib , ssl\nimport getpass\nserver = smtplib.SMTP_SSL(\"smtp.gmail.com\",465)\nserver.ehlo()\nserver.starttls\npassword = getpass.getpass() # to hide your password while typing (feels cool)\nserver.login(\"[email protected]\", password)\nserver.sendmail(\"[email protected]\" , \"[email protected]\" , \"I am trying out python email through coding\")\nserver.quit()\n\n#turn off LESS SECURE APPS to make this work on your gmail\n", "Connect to a host on a given port.\nport − If you are providing a host argument, then you need to specify a port, where the SMTP server is listening. Usually, this port would be 25.\nIf the port is zero, the standard SMTP-over-SSL port (465) is used.\nTry this\nserver = smtplib.SMTP_SSL('smtp.mail.com', 465)\n\n" ]

[ 64, 1, 1, 0, 0 ]

[]

[]

[ "python", "smtplib", "ssl" ]

[]

[]

[ "If the data is too big then you can read the CSV in chunks with the pandas library fairly easily.\nHere's a link to the documentation: https://pandas.pydata.org/docs/reference/api/pandas.read_csv.html\nAnd a stack overflow that shows how to do it: https://stackoverflow.com/a/25962187/4719158\nTo filter and process just look into the pandas library, there are millions of examples online and your questions to do this kind of operation have most likely been answered here before, so just look it up.\n" ]

[ -1 ]

[ "dataframe", "python" ]

[ "To output multiple date objects with ranges of 7 days, you can use a loop to generate the date ranges and then apply the same filtering logic to your DataFrame for each range. Here is an example of how you might do this:\nfrom pyspark.sql.functions import col, to_date, asc\nfrom pyspark.sql.types import TimestampType\nimport datetime\n\n# Start and end dates for the date range\nstart_date = \"2022-01-01\"\nend_date = \"2022-12-31\"\n\n# Create a Spark session\nspark = SparkSession.builder.appName(\"Date Iteration\").getOrCreate()\n\n# Create a DataFrame with a single column containing the date range\ndate_range_df = spark.range(start_date, end_date) \\\n .withColumn(\"date\", to_date(col(\"id\")))\n\n# Create a list to store the DataFrames for each date range\ndate_ranges = []\n\n# Iterate through the dates in the DataFrame and filter the data for each range\nfor date in date_range_df.select(\"date\").collect():\n # Calculate the start and end dates for the range\n date_from = date.date\n date_to = date_from + datetime.timedelta(days=7)\n \n # Filter the DataFrame for the current date range\n df = NewSpark.where((NewSpark.datetype >= date_from) & (NewSpark.datetype <= date_to)) \\\n .orderBy(asc(\"datetype\"))\n \n # Add the filtered DataFrame to the list\n date_ranges.append(df)\n\n# Print the DataFrame for each date range\nfor i, df in enumerate(date_ranges):\n print(f\"Date range {i+1}:\")\n df.show()\n\nIn this example, we use a for loop to iterate through the dates in the DataFrame and calculate the start and end dates for each range of 7 days. We then use the where() and orderBy() functions to filter the original DataFrame for each range and sort the results by the datetype column. Finally, we print the resulting DataFrame for each date range.\nI hope this helps!\n" ]

[ 0 ]

[]

[]

[ "apache_spark_sql", "datetime", "pyspark", "python" ]

[ "As noted above, an answer is to use set_extra_widget instead of add\n check_box_1 = Gtk.CheckButton(label=\"Recurse source directory\")\n check_box_1.connect(\"toggled\", enable_recurse)\n choose_file_dialog.set_extra_widget(check_box_1)\n\nBut I do not like the placement of the checkbox in the lower left corner, so I hope someone has a better answer.\n" ]

[ 0 ]

[]

[]

[ "gtk", "python" ]

[ "If you take the frames variable with for loop it will give you the image on the y-axis.if you use while loop and read the next frame, the code will work. You can try the example below.\ncap = cv2.VideoCapture(r\"C:\\Users\\HP\\Downloads\\VID_20221128_112556.mp4\")\nret, frame = cap.read()\ncount=0\nwhile(ret):\n stops.append(frame)\n cv2.imwrite(\"../stack/croppedframe%d.jpg\" % count,frame[500:1300,100:1000])\n print(count)\n count += 1\n ret, frame = cap.read()\n\n" ]

[ 3 ]

[]

[]

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

[ "I think I've found a workaround.\nsensor.at(t) + satellite\ndoes not work, but it looks like:\n-(-sensor.at(t)-satellite) does work, and gives the required GCRF vector for the satellite.\nThis seems a bit hacky though, surely there's a more 'correct' method. I won't mark this as the accepted answer just yet, but I will if no one else posts a better method.\n" ]

[ 2 ]

[]

[]

[ "python", "skyfield" ]

[ "You can now :). It took me about 10 minutes to put together a demo using Jupyter proxy widget to load a wavesurfer control into a notebook. It works in Chrome but I haven't tested it anywhere else. It should work anywhere wavesurfer and Jupyter work.\nHere is a screenshot\n\nSee the pastable text from the notebook here:\nhttps://github.com/AaronWatters/jp_doodle/blob/master/notebooks/misc/wavesurfer%20demo.ipynb\nFor information on jp_proxy widgets look here:\nhttps://github.com/AaronWatters/jp_proxy_widget\n", "In the time since I posted this question, a few new solutions have emerged:\n\nScott Condron: Building Tools to Interact With Your Data\nBuilding Tools to Interact With Your Data 2020-10-21-interactive-audio-plots-in-jupyter-notebook.ipynb\n\nThese solutions use holoview, have a playhead linked between the audio and the plots, and can run fully on the browser.\n" ]

[ 4, 0 ]

[]

[]

[ "audio", "jupyter", "python", "signal_processing", "visualization" ]

[ "Use the ndmin argument (new in 1.23.0):\nnumpy.genfromtxt(input_file, ndmin=2)\n\nIf you're on a version before 1.23.0, you'll have to do something else. If you don't have missing data, you can use numpy.loadtxt, which supports ndmin since 1.16.0:\nnumpy.loadtxt(input_file, ndmin=2)\n\nOr if you know that your input will always have multiple columns, you can add the extra dimension with numpy.atleast_2d:\nnumpy.atleast_2d(numpy.genfromtxt(input_file))\n\n(If you don't know how many rows or columns your input will have, it's impossible to distinguish the genfromtxt output for a single row or a single column, so atleast_2d won't help.)\n" ]

[ 1 ]

[]

[]

[ "numpy", "python" ]

[ "remove eval and your code is correct:\nmark = raw_input(\"What is your mark?\")\ntry:\n int(mark)\nexcept ValueError:\n try:\n float(mark)\n except ValueError:\n print(\"This is not a number\")\n\nJust checking for a float will work fine:\ntry:\n float(mark)\nexcept ValueError:\n print(\"This is not a number\")\n\n", "Is it easier to declare a global value than to pass an argument,\nIn my case it's also gives an error.\ndef getInput():\n global value\n value = input()\n while not value.isnumeric():\n print(\"enter a number\")\n value = input(\"enter again\")\n return int(value)\n\ngetInput()\nprint(value)\n\n#can't comment :)\n", "You can simply cae to float or int and catch the exception (if any). Youre using eval which is considered poor and you add a lot of redundant statements.\ntry:\n mark= float(raw_input(\"What is your mark?\"))\nexcept ValueError:\n print \"This is not a number\"\n\n\"Why not use eval?\" you ask, well... Try this input from the user: [1 for i in range (100000000)]\n", "import re\n\npattern = re.compile(\"^[0-9][0-9]\\*\\\\.?[0-9]*\")\n\nstatus = re.search(pattern, raw_input(\"Enter the Mark : \"))\n\nif not status:\n\n print \"Invalid Input\"\n\n", "you can use the String object method called isnumeric. it's more efficient than try- except method. see the below code.\ndef getInput(prompt):\n value = input(prompt)\n while not value.isnumeric():\n print(\"enter a number\")\n value = input(\"enter again\")\n return int(value)\n\n", "Might be a bit too late but to do this you can do this:\nfrom os import system\nfrom time import sleep\nwhile True:\n try:\n numb = float(input(\"Enter number>>>\"))\n break\n\n except ValueError:\n system(\"cls\")\n print(\"Error! Numbers only!\")\n sleep(1)\n system(\"cls\")\n\nbut to make it within a number range you can do this:\nfrom os import system\nfrom time import sleep\nwhile True:\n try:\n numb = float(input(\"Enter number within 1-5>>>\"))\n if numb > 5 or numb < 1:\n raise ValueError\n else:\n break\n\n except ValueError:\n system(\"cls\")\n print(\"Error! Numbers only!\")\n sleep(1)\n system(\"cls\")\n\n" ]

[ 10, 4, 0, 0, 0, 0 ]

[ "Actually if you going to use eval() you have to define more things.\nacceptables=[1,2,3,4,5,6,7,8,9,0,\"+\",\"*\",\"/\",\"-\"]\ntry:\n mark= eval(int(raw_input(\"What is your mark?\")))\nexcept ValueError:\n print (\"It's not a number!\")\nif mark not in acceptables:\n print (\"You cant do anything but arithmetical operations!\")\n\nIt's a basically control mechanism for eval().\n" ]

[ -1 ]

[ "python", "python_2.x" ]

[ "As pandas is a Python library, you can install it using pip - the Python's package management system. If you are using Python 2 >=2.7.9 or Python 3 >=3.4, pip is already installed with your Python. Ensure that Python has been added to PATH\nThen, to install pandas, just simply do:\n$ pip install pandas\n\n", "I think the above answers are very well put already.\njust to add to that.\nWindows:\n1.open cmd\n2.type python -m pip install pandas\n3.restart your visual studio code\nLinux or macOS:\n1.open terminal\n2.type pip install pandas\n3.restart your visual studio code\n", "you can install using pip \npip install pandas\n", "For anyone else in a similar situation, I'd recommend following along with this VS Code official tutorial.\nIt guides you to use Conda instead of Pip, and setup a Python environment, along with installing various packages like Pandas, Jupyter, etc.\nhttps://code.visualstudio.com/docs/datascience/data-science-tutorial\nFor example, after installing the Python extension for VSCode and Miniconda or Anaconda:\nconda create -n myenv python=3.9 pandas\n\n", "I also had the same question. As a newbie, I did not understand the answer. Perhaps these notes will help others in the same boat.\nYou need to type this into command prompt (not visual studio or python): pip install pandas\nBefore you do that, you must \"Ensure that Python has been added to PATH\". This did not make sense to me, but there are pages on this if you Google.\nAlso useful to know: CMD and Terminal = Command Prompt (please correct me if that's not true).\nHopefully this helps others. Thanks\n", "In terminal on vscode, check and make sure python is installed:\npy -3 --version\nThen you can install libraries with:\npy -m pip install packagename\nThis was a simple solution I came up with since the others weren't working on my system.\nHopefully this helps!\n" ]

[ 6, 6, 3, 3, 0, 0 ]

[ "You need to start off by installing Anaconda in order to create an environment for Pandas; you can manage this environment with Anaconda.\nGo to your terminal then run conda create -n myenv python=3.9 pandas jupyter seaborn scikit-learn keras tensorflow. It will create environments for all of the libraries mentioned above.\nPS : this is an old post, please check python's latest version\nAfter that click on your Kernel1 (top right) and chose the environment that is associated with Anaconda\n" ]

[ -1 ]

[ "python", "visual_studio_code" ]

[ "Performance-wise, the main difference between the Apps Script and Python versions is that the Apps Script code logs about 20,000 values in the Apps Script console, which is slow, while the Python code outputs 1 value.\nThe Apps Script code has several syntactical and semantical errors, including:\n\nverify_unique() is undefined\ncol.set({}, pass) does not make sense; perhaps use an Array instead of a Map, find if a value is already in the list with col.includes(pass), insert values with col.push(pass), and use col instead of Array.from(col.values()) to retrieve the values\nvar prefixe = prefixe; is superfluous\n\nSee Apps Script at Stack Overflow and Clean Code JavaScript.\n", "I think the code could be quite a bit easier. I did not study your code extensively. But this would be my approach to solve the problem. As you can see it takes less than one second to generate 20'000 passwords.\nWhat actually really takes a long time is the duplicate check.\nAside from thath be careful when generating passwords without a cryptographically secure random algorithm.\nPlease have a look at this for how to use Crypto.getRandomValues()\n\n\nconst CHARACTER_POOL =\n \"123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnpqrstuvwxyz'(-è_çà)=:;,!.\";\nconst PASSWORDS_TO_GENERATE = 20000;\nconst PASSWORD_LENGTH = 6;\nconst PREFIX = \"\";\n\nconst createPassword = () => {\n let password = \"\";\n for (let i = 0; i < PASSWORD_LENGTH; i++) {\n // this is not secure\n password += CHARACTER_POOL.charAt(\n Math.floor(Math.random() * CHARACTER_POOL.length)\n );\n }\n return `${PREFIX}${password}`;\n};\n\nconst generatePassword = () => {\n const passwords = [];\n while (passwords.length < PASSWORDS_TO_GENERATE) {\n const password = createPassword();\n if (!passwords.includes(password)) {\n passwords.push(password);\n }\n }\n return passwords;\n};\n\nconst start = new Date().getTime();\nconst passwords = generatePassword();\nconsole.log(`It took ${(new Date().getTime() - start) / 1000} to generate ${passwords.length} passwords`);\nconsole.log(passwords);\n\n\n\n", "That's a lot of code for what seems a pretty straightforward problem. I didn't look closely at your version, but here's how I might handle the problem. It creates 20000 in about 20 milliseconds on my mid-level machine.\n\n\nconst genPasswords = (chars) => (n, length = 6, pre = '') => Array .from (\n {length: n}, \n () => pre + Array.from({length}, () => chars[~~(Math.random() * chars.length)]) .join('')\n)\n\nconst pwdGen = genPasswords (\"123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnpqrstuvwxyz'(-è_çà)=:;,!.\")\n\nconsole.time('generate 20000')\nconst res = pwdGen (20000, 6, 'FOULE')\nconsole.timeEnd('generate 20000')\n\nconsole .log (res)\n.as-console-wrapper {max-height: 100% !important; top: 0}\n\n\n\nI store the characters to use in a closure, returning a function that takes the number to generate, their length, and a prefix.\n" ]

[ 2, 1, 0 ]

[]

[]

[ "algorithm", "generator", "google_apps_script", "javascript", "python" ]

[ "A solution with beautifulsoup:\nimport requests\nfrom bs4 import BeautifulSoup\n\nurl = \"https://www.thetutorsdirectory.com/usa/sitemap/sitemap_l1.xml\"\n\nheaders = {\n \"User-Agent\": \"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:107.0) Gecko/20100101 Firefox/107.0\"\n}\n\nsoup = BeautifulSoup(requests.get(url, headers=headers).content, \"xml\")\n\nfor link in soup.select(\"loc\"):\n print(link.text)\n\nPrints:\n\n...\n\nhttps://www.thetutorsdirectory.com/usa/location/private-tutor-wichita-falls\nhttps://www.thetutorsdirectory.com/usa/location/private-tutor-wilmington\nhttps://www.thetutorsdirectory.com/usa/location/private-tutor-winston-salem\nhttps://www.thetutorsdirectory.com/usa/location/private-tutor-woodbridge\nhttps://www.thetutorsdirectory.com/usa/location/private-tutor-worcester-usa\nhttps://www.thetutorsdirectory.com/usa/location/private-tutor-yonkers\n\n" ]

[ 1 ]

[]

[]

[ "parsing", "python", "selenium", "xml" ]

[ ">>> import re\n>>> re.sub(\"[^0-9]\", \"\", \"sdkjh987978asd098as0980a98sd\")\n'987978098098098'\n\n", "Not sure if this is the most efficient way, but:\n>>> ''.join(c for c in \"abc123def456\" if c.isdigit())\n'123456'\n\nThe ''.join part means to combine all the resulting characters together without any characters in between. Then the rest of it is a list comprehension, where (as you can probably guess) we only take the parts of the string that match the condition isdigit.\n", "This should work for both strings and unicode objects in Python2, and both strings and bytes in Python3:\n# python <3.0\ndef only_numerics(seq):\n return filter(type(seq).isdigit, seq)\n\n# python ≥3.0\ndef only_numerics(seq):\n seq_type= type(seq)\n return seq_type().join(filter(seq_type.isdigit, seq))\n\n", "@Ned Batchelder and @newacct provided the right answer, but ...\nJust in case if you have comma(,) decimal(.) in your string:\nimport re\nre.sub(\"[^\\d\\.]\", \"\", \"$1,999,888.77\")\n'1999888.77'\n\n", "Just to add another option to the mix, there are several useful constants within the string module. While more useful in other cases, they can be used here.\n>>> from string import digits\n>>> ''.join(c for c in \"abc123def456\" if c in digits)\n'123456'\n\nThere are several constants in the module, including:\n\nascii_letters (abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ)\nhexdigits (0123456789abcdefABCDEF)\n\nIf you are using these constants heavily, it can be worthwhile to covert them to a frozenset. That enables O(1) lookups, rather than O(n), where n is the length of the constant for the original strings.\n>>> digits = frozenset(digits)\n>>> ''.join(c for c in \"abc123def456\" if c in digits)\n'123456'\n\n", "Many right answers but in case you want it in a float, directly, without using regex:\nx= '$123.45M'\n\nfloat(''.join(c for c in x if (c.isdigit() or c =='.'))\n\n123.45\nYou can change the point for a comma depending on your needs.\nchange for this if you know your number is an integer\nx='$1123' \nint(''.join(c for c in x if c.isdigit())\n\n1123\n", "Fastest approach, if you need to perform more than just one or two such removal operations (or even just one, but on a very long string!-), is to rely on the translate method of strings, even though it does need some prep:\n>>> import string\n>>> allchars = ''.join(chr(i) for i in xrange(256))\n>>> identity = string.maketrans('', '')\n>>> nondigits = allchars.translate(identity, string.digits)\n>>> s = 'abc123def456'\n>>> s.translate(identity, nondigits)\n'123456'\n\nThe translate method is different, and maybe a tad simpler simpler to use, on Unicode strings than it is on byte strings, btw:\n>>> unondig = dict.fromkeys(xrange(65536))\n>>> for x in string.digits: del unondig[ord(x)]\n... \n>>> s = u'abc123def456'\n>>> s.translate(unondig)\nu'123456'\n\nYou might want to use a mapping class rather than an actual dict, especially if your Unicode string may potentially contain characters with very high ord values (that would make the dict excessively large;-). For example:\n>>> class keeponly(object):\n... def __init__(self, keep): \n... self.keep = set(ord(c) for c in keep)\n... def __getitem__(self, key):\n... if key in self.keep:\n... return key\n... return None\n... \n>>> s.translate(keeponly(string.digits))\nu'123456'\n>>> \n\n", "An easy way:\nstr.isdigit() returns True if str contains only numeric characters. Call filter(predicate, iterable) with str.isdigit as predicate and the string as iterable to return an iterable containing only the string's numeric characters. Call str.join(iterable) with the empty string as str and the result of filter() as iterable to join each numeric character together into one string.\nFor example:\na_string = \"!1a2;b3c?\"\nnumeric_filter = filter(str.isdigit, a_string)\nnumeric_string = \"\".join(numeric_filter)\nprint(numeric_string)\n\nAnd the output is:\n123\n\n", "There are a lot of correct answers here. Some are faster or slower than others. The approach used in Ehsan Akbaritabar's and tzot's answers, filter with str.isdigit, is really fast; as is translate, from Alex Martelli's answer, once the setup is done. These are the two fastest methods. However, if you are only doing the substitution once, the setup penalty for translate is significant.\nWhich way is the best may depend on your use case. One replacement in a unit test? I'd go for filter using isdigit. It requires no imports, uses builtins only, and is quick and easy:\n''.join(filter(str.isdigit, string_to_filter))\n\nIn a pandas or pyspark DataFrame, with millions of rows, the efficiency of translate is probably worth it, if you don't use the methods the DataFrame provides (which tend to rely on regex).\nIf you want to take the use translate approach, I'd recommend some changes for Python 3:\nimport string\n\nunicode_non_digits = dict.fromkeys(\n [x for x in range(65536) if chr(x) not in string.digits]\n)\nstring_to_filter.translate(unicode_non_digits)\n\n\n\n\n\nMethod\nLoops\nRepeats\nBest of result per loop\n\n\n\n\nfilter using isdigit\n1000\n15\n0.83 usec\n\n\ngenerator using isdigit\n1000\n15\n1.6 usec\n\n\nusing re.sub\n1000\n15\n1.94 usec\n\n\ngenerator testing membership in digits\n1000\n15\n1.23 usec\n\n\ngenerator testing membership in digits set\n1000\n15\n1.19 usec\n\n\nuse translate\n1000\n15\n0.797 usec\n\n\nuse re.compile\n1000\n15\n1.52 usec\n\n\nuse translate but make translation table every time\n20\n5\n1.21e+04 usec\n\n\n\n\nThat last row in the table is to show the setup penalty for translate. I used the default number and repeat options when creating the translation table every time, otherwise it takes too long.\nThe raw output from my timing script:\n/bin/zsh /Users/henry.longmore/Library/Application\\ Support/JetBrains/PyCharm2022.2/scratches/scratch_4.sh\n+/Users/henry.longmore/Library/Application Support/JetBrains/PyCharm2022.2/scratches/scratch_4.sh:6> which python\n/Users/henry.longmore/.pyenv/shims/python\n+/Users/henry.longmore/Library/Application Support/JetBrains/PyCharm2022.2/scratches/scratch_4.sh:7> python --version\nPython 3.10.6\n+/Users/henry.longmore/Library/Application Support/JetBrains/PyCharm2022.2/scratches/scratch_4.sh:8> set +x\n-----filter using isdigit\n1000 loops, best of 15: 0.83 usec per loop\n-----generator using isdigit\n1000 loops, best of 15: 1.6 usec per loop\n-----using re.sub\n1000 loops, best of 15: 1.94 usec per loop\n-----generator testing membership in digits\n1000 loops, best of 15: 1.23 usec per loop\n-----generator testing membership in digits set\n1000 loops, best of 15: 1.19 usec per loop\n-----use translate\n1000 loops, best of 15: 0.797 usec per loop\n-----use re.compile\n1000 loops, best of 15: 1.52 usec per loop\n-----use translate but make translation table every time\n using default number and repeat, otherwise this takes too long\n20 loops, best of 5: 1.21e+04 usec per loop\n\nThe script I used for the timings:\nNUMBER=1000\nREPEAT=15\nUNIT=\"usec\"\nTEST_STRING=\"abc123def45ghi6789\"\nset -x\nwhich python\npython --version\nset +x\necho \"-----filter using isdigit\"\npython -m timeit --number=$NUMBER --repeat=$REPEAT --unit=$UNIT \"''.join(filter(str.isdigit, '${TEST_STRING}'))\"\necho \"-----generator using isdigit\"\npython -m timeit --number=$NUMBER --repeat=$REPEAT --unit=$UNIT \"''.join(c for c in '${TEST_STRING}' if c.isdigit())\"\necho \"-----using re.sub\"\npython -m timeit --number=$NUMBER --repeat=$REPEAT --unit=$UNIT --setup=\"import re\" \"re.sub('[^0-9]', '', '${TEST_STRING}')\"\necho \"-----generator testing membership in digits\"\npython -m timeit --number=$NUMBER --repeat=$REPEAT --unit=$UNIT --setup=\"from string import digits\" \"''.join(c for c in '${TEST_STRING}' if c in digits)\"\necho \"-----generator testing membership in digits set\"\npython -m timeit --number=$NUMBER --repeat=$REPEAT --unit=$UNIT --setup=\"from string import digits; digits = {*digits}\" \"''.join(c for c in '${TEST_STRING}' if c in digits)\"\necho \"-----use translate\"\npython -m timeit --number=$NUMBER --repeat=$REPEAT --unit=$UNIT --setup=\"import string; unicode_non_digits = dict.fromkeys([x for x in range(65536) if chr(x) not in string.digits])\" \"'${TEST_STRING}'.translate(unicode_non_digits)\"\necho \"-----use re.compile\"\npython -m timeit --number=$NUMBER --repeat=$REPEAT --unit=$UNIT --setup=\"import re; digit_filter = re.compile('[^0-9]')\" \"digit_filter.sub('', '${TEST_STRING}')\"\necho \"-----use translate but make translation table every time\"\necho \" using default number and repeat, otherwise this takes too long\"\npython -m timeit --unit=$UNIT --setup=\"import string\" \"unicode_non_digits = dict.fromkeys([x for x in range(65536) if chr(x) not in string.digits]); '${TEST_STRING}'.translate(unicode_non_digits)\"\n\n\n\n" ]

[ 376, 127, 23, 18, 10, 8, 5, 2, 0 ]

[]

[]

[ "numbers", "python" ]

[ "You need to add demoA to the list of paths used for import.\nimport sys\nsys.path.append('..')\n\nimport demoA.test1 as test1\n\ntest1.hello()\n\n" ]

[ 0 ]

[]

[]

[ "import", "python" ]

[]

[]

[ "Instead of writing thousands of lines of code for all the possible permutations, better approach would be to use recursive functions.\nFor example you give your function your 2d array and then the function recursively moves till the end of line and then into the next line checking if checker is placed on the current node. If not function will run till the last node in 2D array and then return that there are no 4 in a row. If the function finds a checker, it will check the surronding nodes accordingly to see if there are 4 checkers in a row, horizontally, vertically or diagonally. Since you are always searching left to right, top to bottom, you only need to check 3 directions, right, down and diagonally down/right. After that be smart and dont run the same process when you hit the checker that you already checked but it did not create 4 in a row with a surrounding ones, you could maybe have a temp list that is the copy of the argument list in which after you checked the checkers and they do not constitue 4 in a row, you change their valeus to 0 per say.\nYou run this function after every checker insert. You just need to write one right recursive function (think graphs, DFS, BFS)\n" ]

[ -1 ]

[ "multidimensional_array", "python", "python_3.x", "python_turtle" ]

[ "You can use numpy's random generators.\nimport numpy as np\n\n# as per kwinkunks suggestion\nrng = np.random.default_rng()\n\narr1 = rng.normal(1, 2, 1000).reshape(1000, 1)\narr2 = rng.normal(-1, 0.5, 1000).reshape(1000, 1)\n\narr1[:5]\n\narray([[-2.8428678 ],\n [ 2.52213097],\n [-0.98329961],\n [-0.87854616],\n [ 0.65674208]])\n\narr2[:5]\n\narray([[-0.85321735],\n [-1.59748405],\n [-1.77794019],\n [-1.02239036],\n [-0.57849622]])\n\nAfter that, you can concatenate.\nnp.concatenate([arr1, arr2], axis = 1)\n\n# output\narray([[-2.8428678 , -0.85321735],\n [ 2.52213097, -1.59748405],\n [-0.98329961, -1.77794019],\n ...,\n [ 0.84249042, -0.26451526],\n [ 0.6950764 , -0.86348222],\n [ 3.53885426, -0.95546126]])\n\n", "Use np.random.normal directly:\nimport numpy as np\nnp.random.normal([1, -1], [2, 0.5], (1000, 2))\n\n", "You can just create two normal distributions with the mean and std for each and stack them.\nnp.hstack((np.random.normal(1, 2, size=(1000,1)), np.random.normal(-1, 0.5, size=(1000,1))))\n\n" ]

[ 1, 1, 0 ]

[]

[]

[ "numpy", "python" ]

[ "Use reindex to get all columns you need. It'll preserve the ones that are already there and put in empty columns otherwise.\np = p.reindex(columns=['1Sun', '2Mon', '3Tue', '4Wed', '5Thu', '6Fri', '7Sat'])\n\nSo, your entire code example should look like this:\ndf = pd.read_csv(CsvFileName)\n\np = df.pivot_table(index=['Hour'], columns='DOW', values='Changes', aggfunc=np.mean).round(0)\np.fillna(0, inplace=True)\n\ncolumns = [\"1Sun\", \"2Mon\", \"3Tue\", \"4Wed\", \"5Thu\", \"6Fri\", \"7Sat\"]\np = p.reindex(columns=columns)\np[columns] = p[columns].astype(int)\n\n", "I had a very similar issue. I got the same error because the csv contained spaces in the header. My csv contained a header \"Gender \" and I had it listed as: \n[['Gender']]\n\nIf it's easy enough for you to access your csv, you can use the excel formula trim() to clip any spaces of the cells.\nor remove it like this \ndf.columns = df.columns.to_series().apply(lambda x: x.strip())\n", "please try this to clean and format your column names:\ndf.columns = (df.columns.str.strip().str.upper()\n .str.replace(' ', '_')\n .str.replace('(', '')\n .str.replace(')', ''))\n\n", "I had the same issue. \nDuring the 1st development I used a .csv file (comma as separator) that I've modified a bit before saving it. \nAfter saving the commas became semicolon.\nOn Windows it is dependent on the \"Regional and Language Options\" customize screen where you find a List separator. This is the char Windows applications expect to be the CSV separator.\nWhen testing from a brand new file I encountered that issue.\nI've removed the 'sep' argument in read_csv method\nbefore: \ndf1 = pd.read_csv('myfile.csv', sep=',');\n\nafter: \ndf1 = pd.read_csv('myfile.csv');\n\nThat way, the issue disappeared.\n" ]

[ 46, 28, 2, 0 ]

[ "I had a some extra space in csv file ahead of Thermal_Rating\nso i just removed the space and saved the csv file, rerun the df, and it worked\n" ]

[ -1 ]

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

[ "zip isn't supposed to be used like that. zip returns a one-off iterator, not designed to be useful beyond the context of a single loop. If you want to loop over the items of two lists (or other iterables) together, you call zip and iterate over the iterator it gives you. If you want to iterate again, you call zip again.\nIt looks like you're recording item names and prices in two lists, new_item and price_item. In that case, when you need to record a new item, append the name to new_item and append the price to price_item. Don't do anything with a zip iterator at this point - you shouldn't even have a zip iterator at this point.\nWhen you need to iterate over these two lists together, then you call zip.\n(Another approach would be to just keep a list of (item, price) tuples, or a list of instances of some class that records price and other item info, but the above is how you'd do things with separate lists and zip.)\n" ]

[ 2 ]

[]

[]

[ "python", "python_3.x" ]

[ "I solved the problem.\nJust reinstall your Anaconda.\n!!Warning!!: you will lose your lib.\nReferring solution:\nProblem with Torch 1.11\n", "The version may not be exactly as same as yours, but maybe this question asked on 2020-09-04 helps.\n", "My problem was solved by creating a new conda environment and installing PyTorch there. Everything worked perfectly on the first try in the new environment. Reinstalling Anaconda will work too, but this solution is less costly.\n", "In my case PyTorch broke after playing around with TensorFlow (installing different CPU and CUDA versions). I've just run Anaconda Prompt (with administrative privileges) and ordered Anaconda to update all possible packages by running following command:\nconda update --all\n\nAfter that the problem with PyTorch disappeared.\n" ]

[ 1, 0, 0, 0 ]

[]

[]

[ "deep_learning", "python", "pytorch", "windows" ]

[ "I have managed to solve the problem via different approach (executing code directLy instead of function creation from it). Thanks @chepner for inspiration!\n" ]

[ 0 ]

[]

[]

[ "code_generation", "code_inspection", "python" ]

[ "Your problem seems to be updating the rendered DOM periodically.\nYou'll probably need JavaScript to handle that.\nThere are plenty of frameworks that can enable this efficiently.\nConsider looking for popular solutions, like ReactJS or VueJS.\n", "A simple solution would be to get the data by fetching it from javascript using await fetch(). You can then set up an updater by using setInterval().\nFlask\[email protected]('/refresh')\ndef refresh();\n try:\n token=getToken()\n if(token!='null' or token!=''):\n plazas=getInfo(token,parkingID)\n except:\n return \"Error refreshing!\"\n\nJavascript\nvar element = document.getElementsByClassName(\"num\")\n\nasync function reload() {\n // make a request to reload\n const promise = await fetch(\"/refresh\")\n // get the text from the request, alternatively you can also use .json() to \n // retrieve json\n const text = await promise.text()\n element.innerHTML = text\n}\n\n// refresh every 30 seconds\nwindow.onload = setInterval(reload, 30000)\n\n" ]

[ 0, 0 ]

[]

[]

[ "flask", "html", "javascript", "jinja2", "python" ]

[ "To answer my own question:\nI created a conda environment and installed an older version of Python (3.7) in it and that seems to have fixed the problem.\nI found these links to be helpful:\nHow to downgrade the Python Version from 3.8 to 3.7 on windows?\nconda install downgrade python version\nJupyter Notebook - Cannot Connect to Kernel\nHow to find the version of jupyter notebook from within the notebook\npip command to downgrade jupyter notebook\nHow to check python anaconda version installed on Windows 10 PC?\nhttps://towardsdatascience.com/get-your-conda-environment-to-show-in-jupyter-notebooks-the-easy-way-17010b76e874\n" ]

[ 0 ]

[]

[]

[ "jupyter", "object_detection_api", "python", "python_3.x", "tensorflow" ]

[ "The reason for the odd behavior is that in create you're redefining self.window to be the newly created window. It no longer represents the original window. So, when you print the title of what you think is the main window you actually are printing the title of the child window.\nIf you want to create a child of a root window, you need to create instances of Toplevel. You can then pass the root window in as the master of the Toplevel to create the parent/child relationship.\ndef child(self, title):\n new_window = Toplevel(master=self.window)\n new_window.title(title)\n\nWhen you do this, child windows will automatically be deleted when the parent dies. You don't have to do anything at all to make that happen, that's the default behavior of tkinter widgets.\nBear in mind that if you create more than one instance of Tk, each is isolated from the other. Images, variables, fonts, and other widgets created in one cannot communicate with or be moved to another. Each gets their own separate internal tcl interpreter.\n" ]

[ 0 ]

[]

[]

[ "python", "tkinter" ]

[ "try this:\nif thelist == []:\n return []\nif thelist[0] % 2 == 0:\n return oddsevens(thelist[1:]) + thelist[:1]\nelse:\n return thelist[:1] + oddsevens(thelist[1:])\n\nLet me know if you have any further questions!\n" ]

[ 2 ]

[]

[]

[ "python", "recursion" ]

[ "#If score is a global variable then:\nscore = 0\nroot = tk.Tk()\nroot.geometry('900x700+50+50')\nentry_object = tk.Entry(root, width=40)\nentry_object.pack()\n\ndef increment():\n global score\n score += 1\n\nbutton_object = tk.Button(root, text='submit', command=increment() )\nroot.mainloop()\n\n#If it's an atribute from an object \"player\" then:\nroot = tk.Tk()\nroot.geometry('900x700+50+50')\nentry_object = tk.Entry(root, width=40)\nentry_object.pack()\n\ndef increment():\n for player in players:\n if player.accumulated_score <= 10:\n player.accumulated_score += score\nbutton_object = tk.Button(root, text='submit', command=increment() )\nroot.mainloop()\n\n" ]

[ 0 ]

[]

[]

[ "python", "tkinter" ]

[ "You need to install expat-dev package before running get-pip.py\nRUN \\\n set -eu; \\\n apk update --no-cache; \\\n apk add --no-cache \\\n expat-dev \\\n ;\n\n" ]

[ 0 ]

[]

[]

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

[ "You can have your with statement early in your code and have all the other functions that use the file (and probably many that don't use the file but are called in between the ones that do) indented from it and pass the file to them.\nThis may not be wonderful to refactor things to this given the current code and complexity...\ndef main():\n with open('file.txt','w') as file:\n my_func_1()\n my_func_2(file)\n my_func_3\n my_func_4(file)\n ...\n\ndef my_func_1():\n ...\n\ndef my_func_2(file):\n ...\n file.write('thing to write')\n ...\n\ndef my_func_3():\n ...\n\ndef my_func_4(file):\n ...\n file.write('thing to write')\n ...\n\n", "Unless you can put everything into with block like in scotscotmcc's answer, I'd probably just do it without with. Just open the file, write to it, then .close() it.\nBut here's an idea for using with and not putting the code into the with block. A generator that writes to the file what you send it:\ndef printer(filename):\n with open(filename, 'w') as f:\n while True:\n print((yield), file=f)\n\n# Demo usage\np = printer('test.txt')\nnext(p)\np.send('foo')\np.send('bar')\np.close()\n\n# Check the resulting file\nwith open('test.txt') as f:\n print(repr(f.read()))\n\nOutput (Try it online!):\n'foo\\nbar\\n'\n\nI don't think it's any better than just open+close a file, though. I just tried it for fun / out of curiosity.\n", "Based on @CharlieBONS comment and some Singleton patterns for python, I created this solution. I still suspect there is something better, closer to the file loggers in logging, but I have not had the time to dive into that.\nThe previous solution was based on logging to a file with a specific logging level, but since the python library needs to hook into other solutions with their own logging configurations, like AirFlow, i had to abandon this.\nimport json\nimport logging\nimport os\nfrom pathlib import Path\nfrom typing import List\n\n\nclass MyWriter:\n\n __instance = None\n __inited = False\n\n def __new__(cls, path_to_file: Path) -> \"MyWriter\":\n if cls.__instance is None:\n cls.__instance = super().__new__(cls)\n return cls.__instance\n\n def __init__(self, path_to_file: Path) -> None:\n if type(self).__inited:\n return\n self.cache: List[str] = []\n self.path_to_file: Path = path_to_file\n if self.path_to_file.is_file():\n os.remove(self.path_to_file)\n type(self).__inited = True\n\n def write(self, string_to_write: str, flush=False):\n try:\n if string_to_write:\n self.cache.append(f\"{string_to_write)}\\n\")\n if len(self.cache) > 1000 or flush:\n with open(self.path_to_file, \"a\") as my_file:\n extradata_file.writelines(self.cache)\n self.cache = []\n logging.debug(\"My Writer flushing the cache\")\n except Exception as ee:\n error_message = \"Something went wrong in My Writer\"\n logging.error(error_message)\n raise ee\n\n def flush(self):\n self.write(\"\", True)\n\n" ]

[ 2, 1, 0 ]

[]

[]

[ "python", "python_3.x" ]

[ "Simply do it this way\ndef verify_app_log_cur_day2(self, anypoint_monitoring, organization_id, int, applist, access_token):\n headers = {\"Authorization\": f\"Bearer {access_token}\"}\n payload = {}\n log_list = []\n for item in applist:\n url = f\"{anypoint_monitoring}/organizations/{organization_id}/environments/{int}/applications/{item}/logs}\"\n response = requests.request(\"GET\", url, headers=headers, data=payload)\n\n # Functionality:\n if response.status_code == 503:\n response = requests.request(\"GET\", url, headers=headers, data=payload)\n if response.status_code == 503:\n continue \n else:\n log_list.append(response.json())\n\n return log_list\n\n" ]

[ 0 ]

[]

[]

[ "http_status_code_503", "python", "python_3.x", "rest" ]

[ "As @COLDSPEED so eloquently pointed out the error explicitly tells you to install xlrd.\npip install xlrd\n\nAnd you will be good to go.\n", "Since December 2020 xlrd no longer supports xlsx-Files as explained in the official changelog. You can use openpyxl instead:\npip install openpyxl\n\nAnd in your python-file:\nimport pandas as pd\npd.read_excel('path/to/file.xlsx', engine='openpyxl')\n\n", "Either use:\npip install xlrd\n\nAnd if you are using conda, use \nconda install -c anaconda xlrd\n\nThat's it. good luck.\n", "If you are in ubuntu this work for me:\npython3 -m pip install openpyxl\npython3 -m pip install xlrd\n\n", "This happened to me after I ran a script with cProfile a la python3 -m cProfile script.py even though xlrd was already installed and had never thrown this error before. it persisted even under python3 script.py. (Granted, I agree this wasn't what happened to OP, given the obvious import error)\nHowever, for cases like mine, the following fixed the issue, despite being told \"requirement already met\" in every case.\npip install --upgrade pandas\npip install --upgrade xlrd\n\nPretty confounding stuff; not sure if cProfile was the cause or just a coincidence\nThe following should work, assuming your pip install operated on python2.\npython3 -m pip install xlrd\n\n", "I was getting an error \n\n\"ImportError: Install xlrd >= 1.0.0 for Excel support\"\n\non Pycharm for below code\nimport pandas as pd\ndf2 = pd.read_excel(\"data.xlsx\")\nprint(df2.head(3))\nprint(df2.tail(3))\n\nSolution : pip install xlrd\nIt resolved error after using this.\nAlso no need to use \"import xlrd\"\n", "This works for me:\nFor Python 3\n\npip3 install xlrd --user\n\nFor Python2\n\npip install xlrd --user\n\n", "I don't know if this will be helpful for someone, but I had the same problem.\nI wrote pip install xlrd in the anaconda prompt while in the specific environment and it said it was installed, but when I looked at the installed packages it wasn't there.\nWhat solved the problem was \"moving\" (I don't know the terminology for it) into the Scripts folder of the specific environment and do the pip install xlrd there.\nHope this is useful for someone :D\n", "Was getting the error while I was using jupyter.\nModuleNotFoundError: No module named 'xlrd'\n...\nImportError: Install xlrd >= 0.9.0 for Excel support\n\nit was resolved for me after using.\n!pip install xlrd\n\n", "I encountered same problem and took 2 hours to figure it out.\n\npip install xlrd (latest)\npip install pandas (latest)\nGo to C:\\Python27\\Lib\\site-packages and check for xlrd folder (if there are 2 of them) delete the old version\nopen a new terminal and use pandas to read excel. It should work.\n\n", "I had the same problem and none of the above answers worked. If you go into the settings (CTRL + ALT + s) and search for project interpreter you will see all of the installed packages. Click the + button at the top right and search for xlrd, then click install package at the bottom left. \nI had already done the \"pip install xlrd\" command from the file location of my python.exe before this, so you may need to do that as well. (you can find the file location by searching it in windows search bar and right click -> open file location, then type cmd into the file explorer address bar)\n", "This can be because your required libraries are been installed in Python environment instead of Spyder.\nhttps://github.com/spyder-ide/spyder/wiki/Working-with-packages-and-environments-in-Spyder\n", "I had the same problem. Actually, the problem is that even after installing packages/libraries using pip these packages are not integrated with IDE. So, need to add libraries specifically to the ide.\n", "First of all you need to install xlrd & pandas packages. Then try below code.\nimport xlrd\nimport pandas as pd\n\nxl = pd.ExcelFile(\"fileName.xlsx\")\nprint(xl.parse(xl.sheet_names[0]))\n\n", "You need to install the \"xlrd\" lib\nFor Linux (Ubuntu and Derivates):\nInstalling via pip:\npython -m pip install --user xlrd\nInstall system-wide via a Linux package manager:\n*sudo apt-get install python-xlrd\nWindows:\nInstalling via pip:\n*pip install xlrd\nDownload the files:\nhttps://pypi.org/project/xlrd/\n", "Another possibility, is the machine has an older version of xlrd installed separately, and it's not in the \"..:\\Python27\\Scripts..\" folder.\nIn another word, there are 2 different versions of xlrd in the machine.\n\nwhen you check the version below, it reads the one not in the \"..:\\Python27\\Scripts..\" folder, no matter how updated you done with pip.\nprint xlrd.__version__\n\nDelete the whole redundant sub-folder, and it works. (in addition to xlrd, I had another library encountered the same)\n", "I encountered a similar issue trying to use xlrd in jupyter notebook. I notice you are using a virtual environment and that was the key to my issue as well. I had xlrd installed in my venv, but I had not properly installed a kernel for that virtual environment in my notebook.\nTo get it to work, I created my virtual environment and activated it.\nThen... pip install ipykernel\nAnd then... ipython kernel install --user --name=myproject\nFinally, start jupyter notebooks and when you create a new notebook, select the name you created (in this example, 'myproject')\nHope that helps.\n", "Please make sure your python or python3 can see xlrd installation. I had a situation where python3.5 and python3.7 were installed in two different locations. While xlrd was installed with python3.5, I was using python3 (from python3.7 dir) to run my script and got the same error reported above. When I used the correct python (viz. python3.5 dir) to run my script, I was able to read the excel spread sheet without a problem. \n", "As @WojciechJakubas mentioned to install openpyxl instead of xlrd, I used openpyxl and it worked.\n\npip install openpyxl\n\nimport openpyxl\npath = \"path to file.xlxs\"\nwb_obj = openpyxl.load_workbook(path)\nsheet_obj = wb_obj.active\nlength_col = sheet_obj.max_row\nprint(\"Length of rows : \", length_col)\n\nI hope it will help lot of people in 2023.\n" ]

[ 150, 110, 37, 9, 7, 6, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0 ]

[]

[]

[ "excel", "pandas", "python", "python_2.7" ]

[ "You can use apache_beam.io.jdbc to read from your MySQL database, and the BigQuery I/O to write on BigQuery.\nBeam knowledge is expected, so I recommend looking at Apache Beam Programming Guide first.\nIf you are looking for something pre-built, we have the JDBC to BigQuery Google-provided template, which is open-source (here), but it is written in Java.\n", "If you only want to copy data from MySQL to BigQuery, you can firstly export your MySql data to Cloud Storage, then load this file to a BigQuery table.\nI think no need using Dataflow in this case because you don't have complex transformations and business logics. It only corresponds to a copy.\nExport the MySQL data to Cloud Storage via a sql query and gcloud cli :\ngcloud sql export csv INSTANCE_NAME gs://BUCKET_NAME/FILE_NAME \\\n--database=DATABASE_NAME \\\n--offload \\\n--query=SELECT_QUERY \\\n--quote=\"22\" \\\n--escape=\"5C\" \\\n--fields-terminated-by=\"2C\" \\\n--lines-terminated-by=\"0A\"\n\nLoad the csv file to a BigQuery table via gcloud cli and bq :\nbq load \\\n --source_format=CSV \\\n mydataset.mytable \\\n gs://mybucket/mydata.csv \\\n ./myschema.json\n\n./myschema.json is the BigQuery table schema.\n" ]

[ 1, 0 ]

[]

[]

[ "etl", "google_bigquery", "google_cloud_dataflow", "mysql", "python" ]

[ "len() is very fast - it runs in contant time (see Cost of len() function) so I would not build a new data structure just to cache its answer. Just use it each time you need it.\nBuilding a whole extra data structure, that would definitely be using more resources, and most likely slower. Just make sure you write your loop over my_dict.items(), not over the keys, so you don't unnecessarily redo the key lookups inside the loop.\nE.g., use something like this for efficient looping over your dict:\nmy_dict = <some dict where the values are lists>\n\nfor key, value in my_dict.items():\n # use key, value (your list) and len(value) (its length) as needed\n\n" ]

[ 0 ]

[]

[]

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

[ ".keys() is a set-like view, not a sequence, and you can only index sequences.\nIf you just want the first key, you can manually create an iterator for the dict (with iter) and advance it once (with next):\nself.instance_id = next(iter(get_instance_metadata(data='meta-data/instance-id')))\n\nYour second attempt was foiled by mistakes in where you performed the conversion to list, and should have been:\nself.instance_id = list(get_instance_metadata(data='meta-data/instance-id').keys())[0] # The .keys() is unnecessary, but mostly harmless\n\nbut it would be less efficient than the solution I suggest, as your solution would have to make a shallow copy of the entire set of keys as a list just to get the first element (big-O O(n) work), where next(iter(thedict)) is O(1).\n" ]

[ 0 ]

[]

[]

[ "python", "python_3.x" ]

[ "My solution was to reimplement OAuth2UserHandler, exposing code_verifier and allowing the caller to store it and provide it back to the handler later.\nExample implementation (fork of tweepy's implementation):\nimport tweepy\nfrom oauthlib.oauth2 import OAuth2Error\nfrom requests.auth import HTTPBasicAuth\nfrom requests_oauthlib import OAuth2Session\n\nclass NotTweepyOAuth2UserHandler(OAuth2Session):\n def __init__(\n self, client_id: str, client_secret: str, redirect_uri: str, scope: list[str], code_verifier: str | None = None\n ):\n super().__init__(client_id, redirect_uri=redirect_uri, scope=scope)\n self.auth = HTTPBasicAuth(client_id, client_secret)\n self.code_verifier = code_verifier or str(self._client.create_code_verifier(128))\n\n def get_authorization_url(self) -> str:\n url, state_seems_unnecessary = self.authorization_url(\n \"https://twitter.com/i/oauth2/authorize\",\n code_challenge=self._client.create_code_challenge(self.code_verifier, \"S256\"),\n code_challenge_method=\"S256\",\n )\n return url\n\n def fetch_token(self, authorization_response):\n return super().fetch_token(\n \"https://api.twitter.com/2/oauth2/token\",\n authorization_response=authorization_response,\n auth=self.auth,\n include_client_id=True,\n code_verifier=self.code_verifier,\n )\n\ndef _oauth2_handler(callback_url: str, code_verifier: str | None) -> OAuth2UserHandler:\n return NotTweepyOAuth2UserHandler(\n MY_TWITTER_KEY,\n MY_TWITTER_SECRET,\n callback_url,\n [\"offline.access\", \"users.read\", \"tweet.read\"],\n code_verifier=code_verifier,\n )\n\n\ndef get_twitter_authorize_url_and_verifier(callback_url: str) -> tuple[str, str]:\n handler = _oauth2_handler(callback_url, None)\n authorize_url = handler.get_authorization_url()\n # the caller can now store code_verifier somehow\n return authorize_url, handler.code_verifier\n\ndef get_twitter_token(callback_url: str, current_url: str, twitter_verifier: str) -> dict:\n# then pass twitter_verifier back in here\nhandler = _oauth2_handler(callback_url, twitter_verifier)\n try:\n return handler.fetch_token(current_url)\n except OAuth2Error as e:\n raise TwitterAuthError(e.description) from e\n\nNow we can store code_verifier somewhere and complete the authorization loop to get our twitter oauth2 bearer token.\n" ]

[ 0 ]

[]

[]

[ "oauth_2.0", "python", "tweepy", "twitter_oauth" ]

[ "for item in nums:\n if int(item) < 0:\n nums.remove(item)\n\nproblem is probbably here, since you iterate thru a list for which you remove elements in the iterations of the for el in list loop.\nYou should just use list comprenhension to copy positive integers to a new list and return it.\nSo the return list would be:\nonlyPositiveIntegers = [x for x in nums if x >= 0]\n\n" ]

[ 0 ]

[ "nums.sort() \nfor item in nums:\n if int(item) >= 0:\n break\n nums.remove(item)\nprint(*nums)\n\niterate only through -ve no. and remove them.\n" ]

[ -1 ]

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

[ "In the Docker HTTP API, the Inspect a Container API call (GET /containers/{id}/json) includes a Stats field with OpenAPI type ContainerState. That contains a field Status. Its possible values are \"created\" \"running\" \"paused\" \"restarting\" \"removing\" \"exited\" \"dead\"\nThe higher-level Docker SDKs and CLI tools all ultimately wrap this API, so any container status from docker-py or docker ps will be derived from one of these values. The Up 3 hours output, for example, looks like a combination of a running state and a calculated container uptime. The list you quote largely doesn't look like container statuses (\"push\" is not a valid action on a container) and it might go with some other object.\n" ]

[ 1 ]

[]

[]

[ "docker", "python" ]

[ "Your code never calls client.connect(). In fact it doesn't interact with any paramiko module at all inside the while loop.\n" ]

[ 0 ]

[]

[]

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

[ "With the current version of Anaconda (4.1.0) you can simply right-click on a python script in Windows File Explorer and choose \"Open with\". The first time you do this you need to select \"Choose default program\" and then browse to spyder.exe in the Script directory in your Anaconda installation. Also make sure that the \"Always use the selected program to open this kind of file\" is unchecked and then click OK. From now on spyder.exe will always be listed as one of the options when you select \"Open with\" from the right-click menu in Windows File Explorer.\n", "(Spyder maintainer here) This functionality is available as part of our Windows installer. In other words, if you install Spyder with it, then you'll see a new entry in the Open with menu of the Windows Explorer that allows you to open Python files directly on Spyder.\nUnfortunately, it's not possible for us to do the same for other installation methods (i.e. when using Anaconda or pip). That's why need to implement hacks as the ones mentioned in other answers here.\n", "I have had a similar problem with another piece of software that I use. \nMy work around for this problem is to set the file association for .py files to C:\\Anaconda\\Scripts\\spider-script.py via the Open with dialog. If you now try to open your File.py by double clicking you'll receive an error like\n\n~\\file.py is not a valid Win32 application.\n\nThis can be resolved by editing the spyder-script.py registry key:\nHKEY_USERS\\S-1-5-21-3559708500-1520960832-86631148-1002\\Software\\Classes\\Applications\\spyder-script.py\\shell\\open\\command\n\nand replacing the default value \"C:\\Anaconda\\Scripts\\spyder-script.py\" %1 with \"C:\\Anaconda\\python.exe\" \"C:\\Anaconda\\Scripts\\spyder-script.py\" %1. Use the search function for this key if the path isn't the same for your machine, and of course use the appropriate path for your python installation. spyder-script.py should now execute in a python shell.\nFrom the docstring of ftype, \n\n...Within an open command string, %0 or %1 are substituted with the file name being launched through the association.\n\n", "What is working very well for me in Windows (10), is associating the *.py files with a batch file (let's say \"SpyderBATCH.bat\") containing this line :\n[ANACONDA_FOLDER_PATH]\\pythonw.exe\" \"[ANACONDA_FOLDER_PATH]\\cwp.py\" \"[ANACONDA_FOLDER_PATH]\" \"[ANACONDA_FOLDER_PATH]/pythonw.exe\" \"[ANACONDA_FOLDER_PATH]/Scripts/spyder-script.py\" %1 \n\nWhere [ANACONDA_FOLDER_PATH] has to be replaced with the full path to the Anaconda folder (usually under \"Program Files\"). \nWhat Windows does, when double-clicking on a python script (let's say \"file.py\"), is pass to SpyderBATCH, as parameter number %1, the full path to \"file.py\".\nThen Spyder is launched and displays the script \"file.py\" in the editor view.\n", "I figured I would post my solution for this as well.\nI have Spyder installed in multiple different environments. You can't simply call the spyder-script.py script without errors, because the environment must be activated.\n@echo off\ncall [YOUR_CONDA_PATH]\\Scripts\\activate.bat [YOUR_CONDA_PATH]\ncall conda activate [YOUR ENVIRONMENT]\ncall start [YOUR_CONDA_PATH]\\envs\\[YOUR ENVIRONMENT]\\pythonw.exe \"[YOUR_CONDA_PATH]\\envs\\[YOUR ENVIRONMENT]\\Scripts\\spyder-script.py\" %1\n\nYou can remove the second line and remove the environment extension from the third line if you have Spyder installed in your base environment.\nHopefully for anyone experiencing any weirdness with the other solution, this one will do the trick by activating the environment correctly.\n", "The solution from JoeB152 worked perfectly for me!\nIf you are interested in adding the spyder icon (or any other) to the .py-files and if you would like to avoid the cmd-pop-up, I found out the following workaround which is feasible without admin rights:\n\nDownload the portable version of Bat To Exe Converter (I used v3.0.10).\nOpen your custom .bat-file in the Bat to Exe Converter.\nIn the options settings, activate \"Icon\" and give the path to the respective icon (for me it's in: .../AppData/Local/Continuum/anaconda3/Scripts/spyder.ico).\nSet Exe-Format to Invisible (no empty cmd window would pop up anymore)\nConvert your .bat-file to an .exe-file.\nAs usual, set to open .py-files with the newly created .exe.\n\nEnjoy!\nEnvironment:\nWindows 10,\nConda 4.8.2,\nSpyder 4.0.1,\nPython 3.7\n", "This problem is related to anaconda installation defaults - it does not register itself in PATH by default an dicourages users to do so. After proprly registering all directories in path, spyder.exe works as expected.\nHow to know, what to register?\nlocate and activate.bat an run it in cmd, then run echo %PATH% and manually register all directories mentioning anaconda.\nAlternatively, reinstall anaconda with PATH registratin enabled.\nThen you can associate .py files wit spyder.exe and association will work.\n", "System: Windows 11, Python 3.9.7 (Installed through Anaconda3)\nThis solution will allow you to double click .py files and have them open in the Spyder in the environment of your choice, but does NOT associate .py files with the icon for Spyder.\nI'm answering because it took me over an hour to understand & piecemeal together all the (great) solutions that are provided in this thread to get something that works (thanks Martin Sorgel, JoeB152 and Max-K).\nNOTE: Some commentors above say to use a Bat-to-Exe converter & that will let you get the icon too.. but, DON'T! All of the ones you're finding via google have got some bad malware in them and my computer ended up deleting the .exe's I was making using that method because they had a Trojan in them.\nFull Solution:\nSTEP 1: Make a .bat file that will launch Spyder in a specific environment.\n1.1 Open a plain text editor (e.g. Notepad, etc.) and copy/paste the text below into it.\n@echo off\ncall [YOUR_CONDA_PATH]\\Scripts\\activate.bat [YOUR_CONDA_PATH]\ncall conda activate [YOUR ENVIRONMENT]\ncall start [YOUR_CONDA_PATH]\\envs\\[YOUR ENVIRONMENT]\\pythonw.exe \"[YOUR_CONDA_PATH]\\envs\\[YOUR ENVIRONMENT]\\Scripts\\spyder-script.py\" %1\n\nUpdate [YOUR_CONDA_PATH] in the text above with the path to Anaconda3 on your computer. Mine was C:\\Users\\myusername\\Anaconda3\\ & yours is likely similar.\n1.2 Save this new file as spyderlaunch.bat and place it on your computer somewhere that you'll NEVER move it (otherwise you'll have to do STEP 2 each time you move this file. I save mine in a python_env_settings folder where I keep info on what packages I installed manually in my different environments).\nNOTE: JoeB152 says you can remove the second line and remove the environment extension from the third line of the text above if you have Spyder installed in your base environment. I'm not sure if this works...\n1.3 Make sure your new .bat files works! It works if when you double click on spyderlaunch.bat, that it launches and opens Spyder in the environment you want it to! (Spyder will show the environment it opens in on the bottom right hand side: ).\nSTEP 2: Tell your computer to associate (i.e. open) all .py files with the spyderlaunch.bat file you just created.\n2.1 Open an Anaconda Terminal with \"run as an administrator\" (by right clicking on the application) and run the following 2, separate commands. Update[PATH_TO_YOUR.batfile] to wherever you saved spyderlaunch.bat in 1.2.\nassoc .py=Python \nftype Python=\"[PATH_TO_YOUR.batfile]\" \"%1\" %*\n\nErrors?\nIf you don't run the Anaconda Terminal application as an administrator you will be denied access to associate .py=Python. If that's not your issue, then check that the spaces and quotation marks are exactly where they appear above. In particular, you may want to make sure there is a space in between the quotation marks around [PATH_TO_YOUR.batfile] and those around %1.\n", "I was unable to find a spyder.exe on my installation of conda. However in my users/.anaconda/navigator/scripts I found a spyder.bat file. Using this to open the file opens an anaconda prompt and shortly after spyder will open the file. The file icon is broken but it works for me. Hope this might help. \n", "(Comment in relation to the responses by JoeB152 and Jessica Haskins - I am new, so I cannot leave comments)\nI found that their suggested .bat file works once you copy-paste the following file from A to B:\nA) C:\\Users\\USERNAME\\Anaconda3\\Scripts\\spyder-script.py\nB) C:\\Users\\USERNAME\\Anaconda3\\envs\\ENVRIONMENT_NAME\\Scripts\\\n...where ENVIRONMENT_NAME is the name of your environment, such as main or test.\nThe .bat file contains:\n@echo off\ncall C:\\Users\\bloggsj\\Anaconda3\\Scripts\\activate.bat C:\\Users\\bloggsj\\Anaconda3\\\ncall conda activate C:\\Users\\bloggsj\\Anaconda3\\\ncall start C:\\Users\\bloggsj\\Anaconda3\\envs\\main\\pythonw.exe \"C:\\Users\\bloggsj\\Anaconda3\\envs\\main\\Scripts\\spyder-script.py\" %1\n\nThen associate .py files with that .bat file (e.g., via the 'Open with...' dialogue).\nAlternatively, you could try using in the last line of the .bat file the file path: \"C:\\Users\\bloggsj\\Anaconda3\\Scripts\\spyder-script.py\"\n", "\nGet Spyder by itself:\nhttps://docs.spyder-ide.org/current/installation.html\n\nSet your default file opener to your newly installed spyder\n\n\nTo be able to add packages:\n\nMake sure Anaconda is installed.\nGo to Spyder preferences\nGo to Python interpreter\nSelect: \"Use the following Python interpreter\"\nSelect file path with Anaconda and hit apply\n\nNow you should be able to open files directed using Spyder and update your environment using Anaconda.\n" ]

[ 13, 6, 6, 2, 2, 1, 1, 1, 0, 0, 0 ]

[]

[]

[ "ide", "python", "spyder", "windows" ]

[ "I haven't used this package before, but looking at the docs it seems that window_top and window_left on the root Page instance are what you're after (assuming this is a desktop app). See relevant docs here: https://flet.dev/docs/controls/page#window_top.\n" ]

[ 0 ]

[]

[]

[ "desktop_application", "flutter", "position", "python" ]

[ "We can try using a regex replacement with a callback function:\ninp = \"coin flute egg oak\"\noutput = re.sub(r'\\w+', lambda m: re.sub(r'([b-df-hj-np-tv-z]+)(\\w+)', r'\\2\\1ay', m.group()) if not re.search(r'^[AEIOUaeiou]', m.group()) else m.group() + 'yay', inp)\nprint(output) # oincay uteflay eggyay oakyay\n\n", "Your input fetches the user input but string[0] refers only to the first char in the string. You need to use the .split() method to split the string into words and loop thru those words. However, now that you do this, you want to print it onto 1 line. Therefore, change the end parameter in print to something like a space.\ntry something like this:\nsentance = input('String: ').split()\nfor word in sentance: # loop thru each word\n if word[0].upper() in 'BCDFGJKLMNPQSTVXZHRWY':\n print(word.replace(word[0],'') + word[0]+'ay', end = \" \")\n elif word[0].upper() in 'AEIOUY':\n print(word + 'yay', end = \" \")\nprint() # just to skip to a new line once its done\n\nI modified the variable names for clarity. Hope this helps!\n", "You need to find the first vowel and then take case 1 or 2 depending on if that was past first char (0-indexed) or not.\ndef porcus(sin):\n vowels = set(\"aeiouy\")\n\n for vowel1, ch in enumerate(sin.lower()):\n #identify first vowel - `ch in \"aeiouy\"` would work too.\n if ch in vowels:\n break\n else:\n return f\"{sin}ay\"\n\n if not vowel1:\n #starts with vowel\n return f\"{sin}yay\"\n \n #take from vowel position to end, add start before and ay\n res = sin[vowel1:] + sin[:vowel1] + \"ay\"\n \n return res\n\n\ninps = \"coin flute egg oak The\" \nexps = \"oincay uteflay eggyay oakyay eThay\"\n\ndataexp = zip(\n inps.split(),exps.split()\n)\n\nfor inp, exp in dataexp:\n got = porcus(inp)\n msg = f\"{str(inp):100.100} \\n exp :{exp}:\\n got :{got}:\\n\"\n if exp == got:\n print(f\"✅! {msg}\")\n else:\n print(f\"❌! {msg}\")\n\noutput:\n✅! coin \n exp :oincay:\n got :oincay:\n\n✅! flute \n exp :uteflay:\n got :uteflay:\n\n✅! egg \n exp :eggyay:\n got :eggyay:\n\n✅! oak \n exp :oakyay:\n got :oakyay:\n\n✅! The \n exp :eThay:\n got :eThay:\n\n\nYou can plug in xkcd too. I assumed you'd want xkcday.\nre. whole sentence print(\" \".join([porcus(w) for w in sentence.split()])) oughta work.\n" ]

[ 0, 0, 0 ]

[]

[]

[ "python" ]

[ "You need first to know the type of flow you are trying to implement\nFirst you need to know what is the grant type of your client_id in the twitter side, i see in the callback there is code that means you are in normal authorization code or Authorization Code Flow with Proof Key for Code (PKCE), to know that check in your first call to twitter if you see in the params code_challenge and code_challenge_method if yes It's PKCE flow;\nSecond, I see that you have successfully done the first step of flow, then if you are in the PKCE, you need in your callback to send another request to get a final token like this:\n client_id=your client_id&\n code_verifier=the code generated by the application in the first step&\n redirect_uri=http%3A%2F%2Flocalhost%3A8080%2Fcallback&\n grant_type=authorization_code&\n code=the code sent from twitter\n\n", "I'm not sure what the docs looked like back in March, but to do this now you simply need to build the request headers with the code argument from the redirect URL. From the example url you gave (https://example/v1/browser-callback), your code is:\nall0UTY5TVVMYmctNjZEQVpYYYYYYYYZZZZZXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\nAnd the curl request you would make for a private client to retrieve the user's bearer and refresh token would be:\ncurl --location --request POST 'https://api.twitter.com/2/oauth2/token' \\\n--header 'Content-Type: application/x-www-form-urlencoded' \\\n--header 'Authorization: Basic YOUR_BASE64_ENCODED_ClientID:ClientSecret_HERE'\\\n--data-urlencode 'code=all0UTY5TVVMYmctNjZEQVpYYYYYYYYZZZZZXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX' \\\n--data-urlencode 'grant_type=authorization_code' \\\n--data-urlencode 'redirect_uri=https://example/v1/browser-callback' \\\n--data-urlencode 'code_verifier=challenge'\n\nwhere YOUR_BASE64_ENCODED_ClientID:ClientSecret_HERE is (per the docs):\n\nTo create the basic authorization header you will need to base64 encoding on your Client ID and Client Secret which can be obtained from your App’s “Keys and Tokens” page inside of the developer portal.\n\nYou'll need to make this request to get the initial bearer token/refresh token for private clients within 30 seconds of receiving the code at your callback URL after the user has authorized your app.\n" ]

[ 0, 0 ]

[]

[]

[ "oauth_2.0", "python", "twitter", "twitter_oauth", "twitterapi_python" ]

[ "I noticed my plan output had \"'s around the code. So I tried a multiline string in Python \"\"\" and it continued to fail. Bearing in mind I assumed SSM was smart enough to strip quotes if it doesn't want them.\nAnyway, the mistake was adding quotes around the template variable:\n# Mistake\n Script: |-\n \"${script}\" # My script should be injected here :) \n\nSolution\n Script: |-\n ${script} \n\nAfter that I decided okay now that it works, can I remove the indent() method I'm using and I got the YAML not well-formed error back.\nSo using:\nlocals {\n script = indent(8, file(\"${path.module}/automations/test.py\"))\n}\n\nresource \"aws_ssm_document\" \"test_script\" {\n name = \"test-script\"\n document_format = \"YAML\"\n document_type = \"Automation\"\n content = templatefile(\"${path.module}/automations/test.yaml\", {\n ssm_automation_assume_role = aws_iam_role.ssm_automation.arn\n script = local.script\n })\n}\n\nWorks great with:\nmainSteps:\n - name: RunDMSRolesScript\n action: aws:executeScript\n inputs:\n Runtime: python3.8\n Handler: handler\n InputPayload:\n Action: \"create\"\n Script: |-\n ${script}\n\nIf it helps anyone, this is what my SSM Script looks like in the AWS UI when it runs without errors. Formatted correctly and AWS seems to append \" around it but turned into \"\\\" when I provided quotes in my YAML template which would've broken the script as it's now a string literal.\n\"def handler(event, context):\n print(event)\n import boto3\n\n iam = boto3.client('iam')\n response = iam.get_role(\n RoleName='test-role'\n )\n print(response)\"\n\nThat's one way to lose 3 hours!\n" ]

[ 0 ]

[]

[]

[ "aws_ssm", "python", "terraform" ]

[ "The problem is in how you are applying the ? to make each of the subsections optional. A ? applies to just the term immediately preceding it. In your case, this is just the closing parentheses for each subsection Because of this, you are requiring the opening parentheses and the number or letter unconditionally for each subsection term. To fix this, just wrap the complete subsection terms in an extra set of parentheses, and apply the ? to those groups. This code:\nimport re\n\ndata = \"PC 182(A)(1); PC 25400(A)(1); PC 25850(C)(6); PC 32310; VC 12500(A); VC 22517; VC 23103(A)\"\n\nexp = re.compile(r\"(?P<lawType>[A-Z]{2})[ ](?P<lawNumber>[0-9.]*[A-Z]?)(?:\\((?P<subsection>[A-Z])\\))?(?:\\((?P<subsubsection>[0-9])\\))?\")\n\ndef main():\n r = exp.findall(data)\n print(r)\n\nmain()\n\nproduces:\n[('PC', '182', 'A', '1'), ('PC', '25400', 'A', '1'), ('PC', '25850', 'C', '6'), ('PC', '32310', '', ''), ('VC', '12500', 'A', ''), ('VC', '22517', '', ''), ('VC', '23103', 'A', '')]\n\nHere's an example of how to use your expression to pick out the information for each law individually, making use of your group labels:\ndef main():\n p = 0\n while True:\n m = exp.search(data[p:])\n if not m:\n break\n print('Type:', m.group('lawType'))\n print('Number:', m.group('lawNumber'))\n if m.group('subsection'):\n print('Subsection:', m.group('subsection'))\n if m.group('subsubsection'):\n print('Subsubsection:', m.group('subsubsection'))\n print()\n p += m.end()\n\nResult\nType: PC\nNumber: 182\nSubsection: A\nSubsubsection: 1\n\nType: PC\nNumber: 25400\nSubsection: A\nSubsubsection: 1\n\nType: PC\nNumber: 25850\nSubsection: C\nSubsubsection: 6\n\nType: PC\nNumber: 32310\n\nType: VC\nNumber: 12500\nSubsection: A\n\nType: VC\nNumber: 22517\n\nType: VC\nNumber: 23103\nSubsection: A\n\nNoticing how you were pre-splitting your data before applying your regex, I thought you might want to see how I would process each term using only regex matching.\n" ]

[ 0 ]

[]

[]

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

[ "Maybe it is not the most optimized solution, but this is an implementation I used before with numpy library for Python:\ndef convolution2d(image, kernel, bias):\n m, n = kernel.shape\n if (m == n):\n y, x = image.shape\n y = y - m + 1\n x = x - m + 1\n new_image = np.zeros((y,x))\n for i in range(y):\n for j in range(x):\n new_image[i][j] = np.sum(image[i:i+m, j:j+m]*kernel) + bias\n return new_image\n\nI hope this code helps other guys with the same doubt.\nRegards.\n", "Edit [Jan 2019]\n@Tashus comment bellow is correct, and @dudemeister's answer is thus probably more on the mark. The function he suggested is also more efficient, by avoiding a direct 2D convolution and the number of operations that would entail.\nPossible Problem\nI believe you are doing two 1d convolutions, the first per columns and the second per rows, and replacing the results from the first with the results of the second. \nNotice that numpy.convolve with the 'same' argument returns an array of equal shape to the largest one provided, so when you make the first convolution you already populated the entire data array.\nOne good way to visualize your arrays during these steps is to use Hinton diagrams, so you can check which elements already have a value.\nPossible Solution\nYou can try to add the results of the two convolutions (use data[:,c] += .. instead of data[:,c] = on the second for loop), if your convolution matrix is the result of using the one dimensional H_r and H_c matrices like so:\n\nAnother way to do that would be to use scipy.signal.convolve2d with a 2d convolution array, which is probably what you wanted to do in the first place.\n", "Since you already have your kernel separated you should simply use the sepfir2d function from scipy:\nfrom scipy.signal import sepfir2d\nconvolved = sepfir2d(data, H_r, H_c)\n\nOn the other hand, the code you have there looks all right ...\n", "It might not be the most optimized solution either, but it is approximately ten times faster than the one proposed by @omotto and it only uses basic numpy function (as reshape, expand_dims, tile...) and no 'for' loops:\ndef gen_idx_conv1d(in_size, ker_size):\n \"\"\"\n Generates a list of indices. This indices correspond to the indices\n of a 1D input tensor on which we would like to apply a 1D convolution.\n\n For instance, with a 1D input array of size 5 and a kernel of size 3, the\n 1D convolution product will successively looks at elements of indices [0,1,2],\n [1,2,3] and [2,3,4] in the input array. In this case, the function idx_conv1d(5,3) \n outputs the following array: array([0,1,2,1,2,3,2,3,4]).\n\n args:\n in_size: (type: int) size of the input 1d array.\n ker_size: (type: int) kernel size.\n\n return:\n idx_list: (type: np.array) list of the successive indices of the 1D input array\n access to the 1D convolution algorithm.\n\n example:\n >>> gen_idx_conv1d(in_size=5, ker_size=3)\n array([0, 1, 2, 1, 2, 3, 2, 3, 4])\n \"\"\"\n f = lambda dim1, dim2, axis: np.reshape(np.tile(np.expand_dims(np.arange(dim1),axis),dim2),-1)\n out_size = in_size-ker_size+1\n return f(ker_size, out_size, 0)+f(out_size, ker_size, 1)\n\ndef repeat_idx_2d(idx_list, nbof_rep, axis):\n \"\"\"\n Repeats an array of indices (idx_list) a number of time (nbof_rep) \"along\" an axis\n (axis). This function helps to browse through a 2d array of size\n (len(idx_list),nbof_rep).\n\n args:\n idx_list: (type: np.array or list) a 1D array of indices.\n nbof_rep: (type: int) number of repetition.\n axis: (type: int) axis \"along\" which the repetition will be applied.\n\n return\n idx_list: (type: np.array) a 1D array of indices of size len(idx_list)*nbof_rep.\n\n example:\n >>> a = np.array([0, 1, 2])\n >>> repeat_idx_2d(a, 3, 0) # repeats array 'a' 3 times along 'axis' 0\n array([0, 0, 0, 1, 1, 1, 2, 2, 2])\n\n >>> repeat_idx_2d(a, 3, 1) # repeats array 'a' 3 times along 'axis' 1\n array([0, 1, 2, 0, 1, 2, 0, 1, 2])\n\n >>> b = np.reshape(np.arange(3*4), (3,4))\n >>> b[repeat_idx_2d(np.arange(3), 4, 0), repeat_idx_2d(np.arange(4), 3, 1)]\n array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])\n \"\"\"\n assert axis in [0,1], \"Axis should be equal to 0 or 1.\"\n tile_axis = (nbof_rep,1) if axis else (1,nbof_rep)\n return np.reshape(np.tile(np.expand_dims(idx_list, 1),tile_axis),-1)\n\ndef conv2d(im, ker):\n \"\"\"\n Performs a 'valid' 2D convolution on an image. The input image may be\n a 2D or a 3D array.\n\n The output image first two dimensions will be reduced depending on the \n convolution size. \n\n The kernel may be a 2D or 3D array. If 2D, it will be applied on every\n channel of the input image. If 3D, its last dimension must match the\n image one.\n\n args:\n im: (type: np.array) image (2D or 3D).\n ker: (type: np.array) convolution kernel (2D or 3D).\n\n returns:\n im: (type: np.array) convolved image.\n\n example:\n >>> im = np.reshape(np.arange(10*10*3),(10,10,3))/(10*10*3) # 3D image\n >>> ker = np.array([[0,1,0],[-1,0,1],[0,-1,0]]) # 2D kernel\n >>> conv2d(im, ker) # 3D array of shape (8,8,3)\n \"\"\"\n if len(im.shape)==2: # if the image is a 2D array, it is reshaped by expanding the last dimension\n im = np.expand_dims(im,-1)\n\n im_x, im_y, im_w = im.shape\n\n if len(ker.shape)==2: # if the kernel is a 2D array, it is reshaped so it will be applied to all of the image channels\n ker = np.tile(np.expand_dims(ker,-1),[1,1,im_w]) # the same kernel will be applied to all of the channels \n\n assert ker.shape[-1]==im.shape[-1], \"Kernel and image last dimension must match.\"\n\n ker_x = ker.shape[0]\n ker_y = ker.shape[1]\n\n # shape of the output image\n out_x = im_x - ker_x + 1 \n out_y = im_y - ker_y + 1\n\n # reshapes the image to (out_x, ker_x, out_y, ker_y, im_w)\n idx_list_x = gen_idx_conv1d(im_x, ker_x) # computes the indices of a 1D conv (cf. idx_conv1d doc)\n idx_list_y = gen_idx_conv1d(im_y, ker_y)\n\n idx_reshaped_x = repeat_idx_2d(idx_list_x, len(idx_list_y), 0) # repeats the previous indices to be used in 2D (cf. repeat_idx_2d doc)\n idx_reshaped_y = repeat_idx_2d(idx_list_y, len(idx_list_x), 1)\n\n im_reshaped = np.reshape(im[idx_reshaped_x, idx_reshaped_y, :], [out_x, ker_x, out_y, ker_y, im_w]) # reshapes\n\n # reshapes the 2D kernel\n ker = np.reshape(ker,[1, ker_x, 1, ker_y, im_w])\n\n # applies the kernel to the image and reduces the dimension back to the one of original input image\n return np.squeeze(np.sum(im_reshaped*ker, axis=(1,3)))\n\nI tried to add a lot of comments to explain the method but the global idea is to reshape the 3D input image to a 5D one of shape (output_image_height, kernel_height, output_image_width, kernel_width, output_image_channel) and then to apply the kernel directly using the basic array multiplication. Of course, this methods is then using more memory (during the execution the size of the image is thus multiply by kernel_height*kernel_width) but it is faster.\nTo do this reshape step, I 'over-used' the indexing methods of numpy arrays, especially, the possibility of giving a numpy array as indices into a numpy array.\nThis methods could also be used to re-code the 2D convolution product in Pytorch or Tensorflow using the base math functions but I have no doubt in saying that it will be slower than the existing nn.conv2d operator...\nI really enjoyed coding this method by only using the numpy basic tools.\n", "I checked out many implementations and found none for my purpose, which should be really simple. So here is a dead-simple implementation with for loop\ndef convolution2d(image, kernel, stride, padding):\n image = np.pad(image, [(padding, padding), (padding, padding)], mode='constant', constant_values=0)\n\n kernel_height, kernel_width = kernel.shape\n padded_height, padded_width = image.shape\n\n output_height = (padded_height - kernel_height) // stride + 1\n output_width = (padded_width - kernel_width) // stride + 1\n\n new_image = np.zeros((output_height, output_width)).astype(np.float32)\n\n for y in range(0, output_height):\n for x in range(0, output_width):\n new_image[y][x] = np.sum(image[y * stride:y * stride + kernel_height, x * stride:x * stride + kernel_width] * kernel).astype(np.float32)\n return new_image\n\n", "One of the most obvious is to hard code the kernel.\nimg = img.convert('L')\na = np.array(img)\nout = np.zeros([a.shape[0]-2, a.shape[1]-2], dtype='float')\nout += a[:-2, :-2]\nout += a[1:-1, :-2]\nout += a[2:, :-2]\nout += a[:-2, 1:-1]\nout += a[1:-1,1:-1]\nout += a[2:, 1:-1]\nout += a[:-2, 2:]\nout += a[1:-1, 2:]\nout += a[2:, 2:]\nout /= 9.0\nout = out.astype('uint8')\nimg = Image.fromarray(out)\n\nThis example does a box blur 3x3 completely unrolled. You can multiply the values where you have a different value and divide them by a different amount. But, if you honestly want the quickest and dirtiest method this is it. I think it beats Guillaume Mougeot's method by a factor of like 5. His method beating the others by a factor of 10.\nIt may lose a few steps if you're doing something like a gaussian blur. and need to multiply some stuff.\n", "Try to first round and then cast to uint8:\ndata = data.round().astype(np.uint8);\n\n", "I wrote this convolve_stride which uses numpy.lib.stride_tricks.as_strided. Moreover it supports both strides and dilation. It is also compatible to tensor with order > 2.\nimport numpy as np\nfrom numpy.lib.stride_tricks import as_strided\nfrom im2col import im2col\n\ndef conv_view(X, F_s, dr, std):\n X_s = np.array(X.shape)\n F_s = np.array(F_s)\n dr = np.array(dr)\n Fd_s = (F_s - 1) * dr + 1\n if np.any(Fd_s > X_s):\n raise ValueError('(Dilated) filter size must be smaller than X')\n std = np.array(std)\n X_ss = np.array(X.strides)\n Xn_s = (X_s - Fd_s) // std + 1\n Xv_s = np.append(Xn_s, F_s)\n Xv_ss = np.tile(X_ss, 2) * np.append(std, dr)\n return as_strided(X, Xv_s, Xv_ss, writeable=False)\n\ndef convolve_stride(X, F, dr=None, std=None):\n if dr is None:\n dr = np.ones(X.ndim, dtype=int)\n if std is None:\n std = np.ones(X.ndim, dtype=int)\n if not (X.ndim == F.ndim == len(dr) == len(std)):\n raise ValueError('X.ndim, F.ndim, len(dr), len(std) must be the same')\n Xv = conv_view(X, F.shape, dr, std)\n return np.tensordot(Xv, F, axes=X.ndim)\n\n%timeit -n 100 -r 10 convolve_stride(A, F)\n#31.2 ms ± 1.31 ms per loop (mean ± std. dev. of 10 runs, 100 loops each)\n\n", "Super simple and fast convolution using only basic numpy:\nimport numpy as np\n\ndef conv2d(image, kernel):\n # apply kernel to image, return image of the same shape\n # assume both image and kernel are 2D arrays\n # kernel = np.flipud(np.fliplr(kernel)) # optionally flip the kernel\n k = kernel.shape[0]\n width = k//2\n # place the image inside a frame to compensate for the kernel overlap\n a = framed(image, width)\n b = np.zeros(image.shape) # fill the output array with zeros; do not use np.empty()\n # shift the image around each pixel, multiply by the corresponding kernel value and accumulate the results\n for p, dp, r, dr in [(i, i + image.shape[0], j, j + image.shape[1]) for i in range(k) for j in range(k)]:\n b += a[p:dp, r:dr] * kernel[p, r]\n # or just write two nested for loops if you prefer\n # np.clip(b, 0, 255, out=b) # optionally clip values exceeding the limits\n return b\n\ndef framed(image, width):\n a = np.zeros((image.shape[0]+2*width, image.shape[1]+2*width))\n a[width:-width, width:-width] = image\n # alternatively fill the frame with ones or copy border pixels\n return a\n\nRun it:\nImage.fromarray(conv2d(image, kernel).astype('uint8'))\n\nInstead of sliding the kernel along the image and computing the transformation pixel by pixel, create a series of shifted versions of the image corresponding to each element in the kernel and apply the corresponding kernel value to each of the shifted image versions.\nThis is probably the fastest you can get using just basic numpy; the speed is already comparable to C implementation of scipy convolve2d and better than fftconvolve. The idea is similar to @Tatarize. This example works only for one color component; for RGB just repeat for each (or modify the algorithm accordingly).\n", "\nTypically, Convolution 2D is a misnomer. Ideally, under the hood,\nwhats being done is a correlation of 2 matrices.\npad == same\nreturns the output as the same as input dimension\n\nIt can also take asymmetric images. In order to perform correlation(convolution in deep learning lingo) on a batch of 2d matrices, one can iterate over all the channels, calculate the correlation for each of the channel slices with the respective filter slice.\nFor example: If image is (28,28,3) and filter size is (5,5,3) then take each of the 3 slices from the image channel and perform the cross correlation using the custom function above and stack the resulting matrix in the respective dimension of the output.\ndef get_cross_corr_2d(W, X, pad = 'valid'):\n\n if(pad == 'same'):\n pr = int((W.shape[0] - 1)/2)\n pc = int((W.shape[1] - 1)/2)\n conv_2d = np.zeros((X.shape[0], X.shape[1]))\n X_pad = np.zeros((X.shape[0] + 2*pr, X.shape[1] + 2*pc))\n X_pad[pr:pr+X.shape[0], pc:pc+X.shape[1]] = X\n for r in range(conv_2d.shape[0]):\n for c in range(conv_2d.shape[1]):\n conv_2d[r,c] = np.sum(np.inner(W, X_pad[r:r+W.shape[0], c:c+W.shape[1]]))\n return conv_2d\n \n else: \n pr = W.shape[0] - 1\n pc = W.shape[1] - 1\n conv_2d = np.zeros((X.shape[0] - W.shape[0] + 2*pr + 1,\n X.shape[1] - W.shape[1] + 2*pc + 1))\n X_pad = np.zeros((X.shape[0] + 2*pr, X.shape[1] + 2*pc))\n X_pad[pr:pr+X.shape[0], pc:pc+X.shape[1]] = X\n for r in range(conv_2d.shape[0]):\n for c in range(conv_2d.shape[1]):\n conv_2d[r,c] = np.sum(np.multiply(W, X_pad[r:r+W.shape[0], c:c+W.shape[1]]))\n return conv_2d\n\n" ]

[ 25, 6, 5, 2, 2, 1, 0, 0, 0, 0 ]

[ "This code incorrect:\nfor r in range(nr):\n data[r,:] = np.convolve(data[r,:], H_r, 'same')\n\nfor c in range(nc):\n data[:,c] = np.convolve(data[:,c], H_c, 'same')\n\nSee Nussbaumer transformation from multidimentional convolution to one dimentional.\n" ]

[ -2 ]

[ "convolution", "numpy", "python" ]

[ "you can just use google colab to modify your excel !\nyou can mount your csv or excel to google drive or just load the csv to the side bar!\nand copy path and paste it to your pandas read_csv or (read_excel is the same thing)!\nhttps://colab.research.google.com/\nfrom google.colab import files\nimport pandas as pd\n#So first you read from your original excel\ndf=pd.read_csv('path')\nlist1=df.name.tolist()\n##then create a variable to store your new name\nname= \"new name\" #@param {type:\"string\"}\n##append the new name to the list and return to pandas dataframe\nlist1.append(name)\ndf.name=list1\n\n##output to csv and download\ndf.to_csv('newsheet.csv',index=False)\nfiles.download('newsheet.csv')\n\n" ]

[ 0 ]

[]

[]

[ "pandas", "python" ]

[ "Are you getting any output at all? And did you give func arguments here?\ny = odeint(func,y0,t)\n\nAlso, you are missing some important imports for your code in the question. Maybe adding them to the code snippet will help you get a better answer.\nEdit: After adding the imports and trying the code out myself, a graph is outputted. This doesn't seem like a problem with your code.\n" ]

[ 0 ]

[]

[]

[ "matplotlib", "python" ]

[ "Try pip install -t target_directory to install directly into a specified folder\n" ]

[ 0 ]

[]

[]

[ "codespaces", "flask", "github_codespaces", "pip", "python" ]

[ "I did:\njupyter serverextension enable --py jupyterlab --user\n\nand\nconda install -c conda-forge nodejs\n\nIt's running now.\n", "If you are using Anaconda Navigator, install nodejs package within the Navigator. Once nodejs is installed, jupyterLab should be running without any error\n", "running jupyter lab in debug mode, suggests that you should first run:\njupyter lab build\n\n", "One reason this can happen is if you already have Jupyter running on the same port. In my case VS Code was automatically starting the jupyter daemon on the background so whenever I tried to spin up Jupyter outside of VS Code on port 8888 I would see the 404 page because my browser was actually navigating to the VS Code instance of Jupyter. One way to identify this is as follows:\n\nIn bash run lsof -i -P -n | grep \"8888 (LISTEN)\". You should see output like:\n\nPython 2085 <user> 9u IPv4 0xfa77315aec2b468b 0t0 TCP 127.0.0.1:8888 (LISTEN)\nPython 2085 <user> 10u IPv6 0xfa7731561f2fad13 0t0 TCP [::1]:8888 (LISTEN)\n\n\nThe second item is the process id, use ps u <pid> to inspect it:\n\n» ps u 2085\nUSER PID %CPU %MEM VSZ RSS TT STAT STARTED TIME COMMAND\n<user> 2085 0.0 0.3 409501984 94656 ?? S 3:34PM 0:02.23 /<path-to-python>/Python -m vscode_datascience_helpers.daemon --daemon-module=vscode_datascience_helpers.jupyter_daemon -v --\n\nTo fix this you can either try to kill the VS Code process (but this might mess up jupyter support in your VS Code environment) or you can simply start your external jupyter on a different port, e.g. jupyter lab --port=10000\n" ]

[ 10, 1, 1, 0 ]

[]

[]

[ "anaconda", "conda", "jupyter", "jupyter_lab", "python" ]

[ "you can try beautiful soup to extract URLs from page source or java script. following is the javascript version.\nresult = driver.execute_script('''\nallbikes=document.querySelectorAll(\".blaze-slider__description\") \nresult=[]\nfor (var i = 0; i < allbikes.length; i++) {\n let bike=allbikes[i]\n let bike_url=bike.getElementsByClassName(\"blaze-slider__button\")[0]\n //console.log(bike_url.getAttribute(\"href\"))\n result.push(bike_url.getAttribute(\"href\"))\n}\nreturn result\n''')\nfor bike in result:\n print(bike)\n #for each bike URL, access the page and then get the price\n\nJavascript: get all the slider divs, and then for each div, get the href attribute.\n" ]

[ 0 ]

[]

[]

[ "python", "selenium", "web_crawler", "web_scraping" ]

[ "use \"pandas\" to make schema\nfrom there you can make .csv\n" ]

[ 0 ]

[]

[]

[ "csv", "faker", "python", "python_3.x" ]

[ "Given names = [\"myKey_apples\", \"myKey_appleses\", \"myKey_oranges\", \"foo\", \"myKey_Banannas\"]\nAn O(n^2) solution I can think of is to find all possible substrings and storing them in a dictionary with the number of times they occur :\nsubstring_counts={}\n\nfor i in range(0, len(names)):\n for j in range(i+1,len(names)):\n string1 = names[i]\n string2 = names[j]\n match = SequenceMatcher(None, string1, string2).find_longest_match(0, len(string1), 0, len(string2))\n matching_substring=string1[match.a:match.a+match.size]\n if(matching_substring not in substring_counts):\n substring_counts[matching_substring]=1\n else:\n substring_counts[matching_substring]+=1\n\nprint(substring_counts) #{'myKey_': 5, 'myKey_apples': 1, 'o': 1, '': 3}\n\nAnd then picking the maximum occurring substring\nimport operator\nmax_occurring_substring=max(substring_counts.iteritems(), key=operator.itemgetter(1))[0]\nprint(max_occurring_substring) #myKey_\n\n", "Here's a overly verbose solution to your problem:\ndef find_matching_key(list_in, max_key_only = True):\n \"\"\"\n returns the longest matching key in the list * with the highest frequency\n \"\"\"\n keys = {}\n curr_key = ''\n\n # If n does not exceed max_n, don't bother adding\n max_n = 0\n\n for word in list(set(list_in)): #get unique values to speed up\n for i in range(len(word)):\n # Look up the whole word, then one less letter, sequentially\n curr_key = word[0:len(word)-i]\n # if not in, count occurance\n if curr_key not in keys.keys() and curr_key!='':\n n = 0\n for word2 in list_in:\n if curr_key in word2:\n n+=1\n # if large n, Add to dictionary\n if n > max_n:\n max_n = n\n keys[curr_key] = n\n # Finish the word\n # Finish for loop \n if max_key_only:\n return max(keys, key=keys.get)\n else:\n return keys \n\n# Create your \"from list\"\nFrom_List = [\n \"myKey_apples\",\n \"myKey_appleses\",\n \"myKey_oranges\",\n \"foo\",\n \"myKey_Banannas\"\n]\n\n# Use the function\nkey = find_matching_key(From_List, True)\n\n# Iterate over your list, replacing values\nnew_From_List = [x.replace(key,'') for x in From_List]\n\nprint(new_From_List)\n['apples', 'appleses', 'oranges', 'foo', 'Banannas']\n\n\nNeedless to say, this solution would look a lot neater with recursion. Thought I'd sketch out a rough dynamic programming solution for you though.\n", "I would first find the starting letter with the most occurrences. Then I would take each word having that starting letter, and take while all these words have matching letters. Then in the end I would remove the prefix that was found from each starting word:\nfrom collections import Counter\nfrom itertools import takewhile\n\nstrings = [\"myKey_apples\", \"myKey_appleses\", \"myKey_oranges\", \"berries\"]\n\ndef remove_mc_prefix(words):\n cnt = Counter()\n for word in words:\n cnt[word[0]] += 1\n first_letter = list(cnt)[0]\n\n filter_list = [word for word in words if word[0] == first_letter]\n filter_list.sort(key = lambda s: len(s)) # To avoid iob\n\n prefix = \"\"\n length = len(filter_list[0])\n for i in range(length):\n test = filter_list[0][i]\n if all([word[i] == test for word in filter_list]):\n prefix += test\n else: break\n return [word[len(prefix):] if word.startswith(prefix) else word for word in words]\n\nprint(remove_mc_prefix(strings))\n\n\nOut: ['apples', 'appleses', 'oranges', 'berries']\n\n", "To find the most-common-substring from list of python-string\nI already tested on python-3.10.5 I hope it will work for you.\nI have the same use case but a different kind of task, I just need to find one common-pattern-string from a list of more than 100s files. To use as a regular-expression.\nYour Basic example code is not working in my case. because 1st checking with 2nd, 2nd with 3rd, 3rd with 4th and so on. So, I change it to the most common substring and will check with each one.\nThe downside of this code is that if something is not common with the most common substring, the final most common substring will be an empty one.\nBut in my case, it is working.\n\nfrom difflib import SequenceMatcher\nfor i in range(1, len(names)):\n if i==1:\n string1, string2 = names[0], names[i]\n else:\n string1, string2 = most_common_substring, names[i]\n match = SequenceMatcher(None, string1, string2).find_longest_match(0, len(string1), 0, len(string2))\n most_common_substring = string1[match.a: match.a + match.size]\n\nprint(f\"most_common_substring : {most_common_substring}\")\n\n\npython python-3python-difflib\n" ]

[ 11, 1, 1, 0 ]

[]

[]

[ "python" ]

[ "Could be something like this, imagine dividing the problem into smaller sub-problems\ndef recursive_sum(a, b, res=0):\n if a > b:\n return res\n\n temp = 1\n for j in range(1, a+1):\n temp = temp * j\n res = res + temp\n\n return recursive_sum(a+1, b, res)\n\na = int(input(\"Please enter the first number: \")) \nb = int(input(\"Please enter the second number: \")) \n\nres = recursive_sum(a, b)\nprint(f\"Sum of products from 1 to each integer in the range {a} to {b} is: {res}\") \n\n\n", "a = int(input(\"Please enter the first number: \")) \nb = int(input(\"Please enter the second number: \")) \n\nres = sum([x for x in range(int(a), int(b)+1)])\n\nprint(res)\n\nMy question is why do you need it to be recursive?\nI ask that because this particular answer doesn't seem best approached through recursion.\nif you need to use recursion\ndef recursive_sum(m,n):\n if n <= m:\n return n\n else:\n return n+recursive_sum(m, n-1)\n\nEDIT:\nthe question asked included the sum of the factorial of a range, apologies for only including the sum portion.\ndef factorial(b):\n if (b==1 or b==0):\n return 1\n else:\n return (b * factorial(b - 1))\n\nres = sum(map(factorial, range(a,b+1)))\n\nThe original code you're multiplying each value in the range by the product of the previous and summing.\nrange(5,10) for instance\ntotal for the way the problem is written\nres comes to 4500198\nwhere the factorial sum = 4037880\nIf you print out just for value 5\nyou get 1+3+9+33+153 where !5=120\nWhich is the way you're trying to accomplish it?\n" ]

[ 0, 0 ]

[]

[]

[ "python" ]

[ "Function parameters must be identifiers, so l is fine, but len(l) is not.\nAlthough, l is a bad variable name since it looks like 1 and I; you could use lst instead.\nMore importantly, you don't actually need to pass the len() around. You can simply get it inside the function.\nHere's a fixed up version of your code. I added variables for values that are used more than once.\ndef prodListePos_rec(lst):\n n = len(lst)\n if n > 0:\n x = lst[n-1]\n if x > 0:\n product = prodListePos_rec(lst) * x\n else:\n product = 1\n return product\n\nlst = [1, -2, 5, 0, 6, -5]\nprodListePos_rec(lst)\n\nHowever, the code still doesn't work because it's possible for n > 0 and x <= 0, so product never gets defined. Error:\nTraceback (most recent call last):\n File \"/home/wja/testdir/tmp.py\", line 13, in <module>\n prodListePos_rec(lst)\n File \"/home/wja/testdir/tmp.py\", line 10, in prodListePos_rec\n return product\nUnboundLocalError: local variable 'product' referenced before assignment\n\n", "When you define function, you write names of parameters in parethesis.\nl is a name of parameter. When you call a function, python will \"replace\" l with it's value to calculate result of function.\nlen(l) is not a name, it's an expression. So you can't use it as a name.\nYou can change your function to this\ndef prodListePos_rec(l, len_l):\n if (len_l>0):\n if l[len_l-1] > 0:\n product = prodListePos_rec(l,len_l) * l[len_l-1]\n else:\n product = 1 \n return product\n\np = [1,-2, 5, 0, 6,-5]\nprodListePos_rec(p,len(p)) \n\nlen_l is a name of parameter. I changed l to p in function calling, to not confuse variables with parameters\nOr simply you can do that\ndef prodListePos_rec(l):\n if (len(l)>0):\n if l[len(l)-1] > 0:\n product = prodListePos_rec(l,len(l)) * l[len(l)-1]\n else:\n product = 1 \n return product\n\np = [1,-2, 5, 0, 6,-5]\nprodListePos_rec(p) \n\nIn this case len(l) is an expression, that calctulates length of a given list.\n", "\ndef prodListePos_rec(l, len(l)): ->> len(l) is inbuilt function to\nfind length of list, string, etc.\n\nwhich cannot be used as variable to define the attribute of defined\n\nfunction --> def prodListePos_rec(l, len(l)):\n\ninstead use\ndef prodListePos_rec(l, len_of_l):\n product = 1\n if (len_of_l)>0):\n if l[len_of_l)-1] > 0:\n product = prodListePos_rec(l,len_of_l)) * l[len_of_l)-1] \n return product\n\nl = [1,-2, 5, 0, 6,-5]\nprint(prodListePos_rec(l,len(l)))\n\nRemember: this is a recursive function. So, It will not enter else block.\n" ]

[ 2, 0, 0 ]

[]

[]

[ "function", "python", "recursion" ]

[ "Check that you are not at any point passing 'None' to doRequest()'s body parameter. You are trying to reassign a value to an object which is 'None', and that is what is causing your problem.\n" ]

[ 0 ]

[]

[]

[ "api", "python", "python_requests" ]

[ "you don't need numpy here:\nwith open(\"data.json\", \"r\") as f:\n data = json.load(f)\nfor item in data:\n if item['symbol'] == 'AUDCHF':\n # same for x2 and y2\n item['timeframe'][4]['x1'] = 1\n item['timeframe'][4]['y1'] = 1\n break\nelse: # this will only trigger if the loop finished without the break being called\n print(\"symbol 'AUDCHF' not found)\n exit(0)\nwith open(\"data_edited.json\", \"w\") as f:\n json.dump(data, f)\n\n" ]

[ 1 ]

[]

[]

[ "json", "python" ]

[ "You are in an infinite loop because you never break out of the while True loop. The break statement only breaks out of one loop at a time. See also How to break out of nested loops in python?\n" ]

[ 0 ]

[]

[]

[ "matplotlib", "physics", "python", "statistics" ]

[ "You may have a working implementation with slight errors as mentioned in your comments, but I propose that you:\n\nsplit by the delimiters\napply a capitalization for all but the first of the tokens\nrejoin the tokens\n\nMy implementation is:\ndef to_camel_case(text):\n s = text.replace(\"-\", \" \").replace(\"_\", \" \")\n s = s.split()\n if len(text) == 0:\n return text\n return s[0] + ''.join(i.capitalize() for i in s[1:])\n\nIMO it makes a bit more sense.\nThe output from running tests is:\n>>> to_camel_case(\"the_stealth_warrior\")\n'theStealthWarrior'\n>>> to_camel_case(\"The-Stealth-Warrior\")\n'TheStealthWarrior'\n>>> to_camel_case(\"A-B-C\")\n'ABC'\n\n", "from re import sub\n\ndef to_camelcase(s):\n s = sub(r\"(_|-)+\", \" \", s).title().replace(\" \", \"\").replace(\"*\",\"\")\n return ''.join([s[0].lower(), s[1:]])\n\nprint(to_camelcase('some_string_with_underscore'))\nprint(to_camelcase('Some string with Spaces'))\nprint(to_camelcase('some-string-with-dashes'))\nprint(to_camelcase('some string-with dashes_underscores and spaces'))\nprint(to_camelcase('some*string*with*asterisks'))\n\n", "I think first of you should change the syntax a little because 'i' is a string not an integer. It should be\nfor i in str:\n if (i == '-'):\n ...\n\n", "this is my simple way\ndef to_camel_case(text):\n #your code herdlfldfde\n s = text.replace(\"-\", \" \").replace(\"_\", \" \")\n s = s.split()\n if len(text) == 0:\n return text\n return s[0] + ' '.join(s[1:]).title().replace(\" \", \"\")\n\n", "Potential solution/package that supports pascal/snake conversion to camel.\n# pip install camelCasing\nfrom camelCasing import camelCasing as cc\n\nfor s in ['the_stealth_warrior', 'The-Stealth-Warrior', 'A-B-C']:\n print(cc.toCamelCase(s=s, user_acronyms=None))\n\ntheStealthWarrior\ntheStealthWarrior\nABC\n\n" ]

[ 13, 4, 1, 1, 0 ]

[]

[]

[ "python", "string" ]

[ "TL;DR\nBased on Carlos Horn's comment pd.json_normalize are perfect for this:\ndf_fixed = df.join(pd.json_normalize(df['colC'])).drop('colC', axis='columns')\n\nOld answer\ndf = df.drop('colC', axis=1).join(pd.DataFrame(df.colC.values.tolist()))\n\nElaborate (old) answer\nWe start by defining the DataFrame to work with, as well as importing Pandas:\nimport pandas as pd\n\n\ndf = pd.DataFrame(\n {\n 'colA': {0: 7, 1: 2, 2: 5, 3: 3, 4: 5},\n 'colB': {0: 7, 1: 8, 2: 10, 3: 2, 4: 5},\n 'colC': {\n 0: {'foo': 185, 'bar': 182, 'baz': 148},\n 1: {'foo': 117, 'bar': 103, 'baz': 155},\n 2: {'foo': 165, 'bar': 184, 'baz': 170},\n 3: {'foo': 121, 'bar': 151, 'baz': 187},\n 4: {'foo': 137, 'bar': 199, 'baz': 108},\n },\n }\n)\n\nThe column colC is a pd.Series of dicts, and we can turn it into a pd.DataFrame by turning each dict into a pd.Series:\npd.DataFrame(df.colC.values.tolist())\n# df.colC.apply(pd.Series). # this also works, but it is slow\n\nwhich gives the pd.DataFrame:\n foo bar baz\n0 154 190 171\n1 152 130 164\n2 165 125 109\n3 153 128 174\n4 135 157 188\n\nSo all we need to do is:\n\nTurn colC into a pd.DataFrame\nDelete the original colC from df\nJoin the convert colC with df\n\nThat can be done in a one-liner:\ndf = df.drop('colC', axis=1).join(pd.DataFrame(df.colC.values.tolist()))\n\nWith the contents of df now being the pd.DataFrame:\n colA colB foo bar baz\n0 2 4 154 190 171\n1 4 10 152 130 164\n2 4 10 165 125 109\n3 3 8 153 128 174\n4 10 9 135 157 188\n\n", "I faced the same challenge recently and I managed to do it manually using apply and join.\nimport pandas as pd\n\ndef expand_dict_column(df: pd.DataFrame, column) -> pd.DataFrame:\n df.drop(columns=[column], inplace=False).join(\n df.apply(lambda x: pd.Series(x[column].values(), index=x[column].keys()), axis=1))\n\nIn the case of the columns of the question it would look like this:\ndf.drop(columns=[\"colC\"], inplace=False).join(\n df.apply(lambda x: pd.Series(x[\"colC\"].values(), index=x[\"colC\"].keys()), axis=1))\n\n" ]

[ 20, 0 ]

[]

[]

[ "dataframe", "dictionary", "pandas", "python", "series" ]

[ "You need to verify that the chosen direction is valid before moving rooms.\nwhile user_move != 'exit':\n print(\"You are in the\", current_room)\n user_move = input(\"Choose a direction \")\n\n # is the move a valid choice?\n if user_move in rooms[current_room]:\n # yes it is valid, so move there\n current_room = rooms[current_room][user_move]\n print(current_room)\n else:\n # no, it was not a valid move\n print(\"Invalid move. Try again\")\n\nYour code was moving rooms before checking if the direction was valid.\n" ]

[ 2 ]

[]

[]

[ "if_statement", "python" ]

[ "As I posted in my comment, if you always want a positive value for your logarithm, you can use an absolute value:\nnp.abs(np.log2(74/571))\n# 2.948\n\nAlso, as suggested above, you don't need the NumPy library if you only want to use logarithms. You can accomplish the same with the math standard module and even with built-in functions:\nimport math\n\nabs(math.log2(74/571))\n# 2.948\n\n", "print(-np.log2(74/571))\n\n\n2.947893569733893\n\nif I correctly understand what you want.\n" ]

[ 1, 0 ]

[]

[]

[ "numpy", "python" ]

[ "you can use \"pinfo2\", https://ipython.readthedocs.io/en/stable/interactive/magics.html\nfor example\ndef test(a, b):\n import numpy as np\n cds = data.range(1000)\n cds = cds.random_shuffle()\n a = np.array([a])\n return a, b\n\n\nfrom IPython import get_ipython\nipython = get_ipython()\nipython.run_line_magic(\"pinfo2\", \"test\")\n\nit will print:\nSignature: test(a, b)\nDocstring: <no docstring>\nSource: \ndef test(a, b):\n import numpy as np\n cds = data.range(1000)\n cds = cds.random_shuffle()\n a = np.array([a])\n return a, b\nFile: ~/PycharmProjects/aib/<ipython-input-14-4adc6bbd758b>\nType: function\n\n" ]

[ 0 ]

[]

[]

[ "ipython", "python" ]

[ "What helped me is upgrading pip from 20.2.3 to the latest one (in my case 21.1.1)\n", "For Mac/Homebrew users.\nThe answer https://stackoverflow.com/a/72046110/5327611 is leading in the right direction. On a Mac with QT5 installed via Homebrew the qmake binary just needs to be added to the path. This can be achieved through\nexport PATH=\"/opt/homebrew/opt/qt5/bin:$PATH\"\n\n(of course depending on where the homebrew files are installed)\n", "Running on arm with python3.6 (ubuntu18 on nvidia Xavier):\nsudo apt install qt5-default\n\n", "For MacOS users.\nI am on Apple M1 silicon using Python 3.9.8. What worked for me was @Apaul's comment in the original question section. Install pyqt5-sip prior to pyqt5.\nI also have an Intel Mac and on that machine, I do not need to do this.\n", "Checking the binaries that PyQt5 provides in pypi for version 5.15.0 I see that it does not provide the binaries for python3.9 in windows, so pip is trying to compile using the source code which is complicated and can generate several dependency problems (for example you must have Qt 5.15 installed, etc). So my recommendation is to install a more updated version of PyQt5, for example 5.15.2 since if it provides the binaries for python3.9 on windows, in addition to being a wrapper of an LTS version of Qt then it will have solved several bugs.\npython -m pip install PyQt5==5.15.2\n\nAnother solution is to use python3.8 instead of python3.9 so that you can install pyqt5 5.15.0 from pypi without problems.\n", "Upgrading your pip enables you to install PyQt5. Personally, I had the same issue while installing PyQt6 and I upgraded my pip, and everything installed perfectly. I think both python and pip versions play an important role in installing PyQt so make sure you have later versions.\nThis is the command I used in Linux:\npip install --upgrade pip\n\n", "Since qt5-default was not available, I installed qt5-default's dependencies\nsudo apt-get install qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools\n\nafter that I installed pyqt5 via apt-get first and afterwards via pip\nsudo apt-get install pyqt5-dev\npip install pyqt5\n\nnow wheel seems to work\n\nside-note:\n\nI am not sure if sudo apt-get install pyqt5-dev is even necessary\n\n", "The error message thrown here is misleading - it's not an issue with a sipbuild.api attribute. Indeed, in this case program qmake is missing, see last line of the Python traceback. Have a look if it's installed on your system and add it to your PATH variable. Otherwise, install it. On Linux this would be done with\nsudo apt-get install qt5-qmake\n\n", "I had this problem on my M1 Mac using Python 3.9.12 when I was trying to install a library: pip install pixellib.\nThe first thing I did was: pip install pixellib --verbose to see the whole log, and there I noticed that PyQt5 was waiting for an input. So then I found someone else with that issue, and used pip install pyqt5 --config-settings --confirm-license= --verbose which took some time to compile, but worked!\n", "I could not get any of the above solutions to work but I managed to get it working using python3.9, PyQt5=5.15.2, pip=22.0.2 and sip=6.5.0 by using sudo apt-get install PyQt5. If you need it in a virtual environment, you can manually copy the PyQt5 folder from your default /usr/lib/python3/dist-packages to the site-packages folder in your virtual environment.\n", "To all those that are struggling with Apple M1 installation, here is a working solution, specifically addressing the problem of installing the pixellib library that depends on PyQt5 but you can apply it equally to other libs:\n\nPyQt5 is not supported on Apple M1, it needs qt6: https://www.reddit.com/r/learnpython/comments/o4w1ut/comment/h2jele3/?utm_source=share&utm_medium=web2x&context=3 , https://www.qt.io/product/qt6\nthis means you need to install PyQt6: python3 -m pip install PyQt6\ngo to the lib you need, in my case pixellib: https://pypi.org/project/pixellib/#files and\ndownload the wheel file\nget the wheel tool: pip install wheel\nunpack the wheel wheel unpack pixellib-0.7.1-py3-none-any.whl\nChange its dependency of PyQt5 to PyQt6\n\nedit pixellib-0.7.1/pixellib-0.7.1.dist-info/METADATA\npyQt5 => pyQt6\n\n\npack it back wheel pack pixellib-0.7.1\ninstall it: pip install pixellib-0.7.1-py3-none-any.whl\ntest in python: `\n\n# should work\nimport pixellib\n\nP.S. thanks to Terra and ChaOS for supporting work on the project underlying this report.\n" ]

[ 16, 11, 7, 7, 6, 2, 1, 1, 1, 0, 0 ]

[ "This can be resolved by switching to an environment with Python >= 3.8\n" ]

[ -7 ]

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

[ "The as_dcm() method of the Rotation class was deprecated in SciPy version 1.4.0 and removed from SciPy version 1.6.0. You'll have to use an older version of SciPy, or find out if there is a version of ratcave that works with the latest version of SciPy.\n" ]

[ 0 ]

[]

[]

[ "pyglet", "python", "ratcave", "scipy" ]

[ "According to the answer on github.\nUnfortunately, there is currently no way to remove <\\> on vscode-jupyter.\nBecause it is a button that appears on each output. It lets you change the renderer type for that output.\nYou can use jupyter notebook if you like. This symbol <\\> does not appear in my use of jupyter notebook.\n\n" ]

[ 0 ]

[]

[]

[ "jupyter_notebook", "python", "rich", "visual_studio_code" ]

[ "This is a solution that I've seen divide the python community. Some say that it's a feature and \"very pythonic\"; others say that it's a bad design choice we're stuck with now, and bad practice. I'm personally not a fan, but it is a way to solve this problem, so do with it what you will. :)\nPython function loops aren't a new scope; the loop variable persists even after the loop. So, either of these are a solution. Assuming that your list of dictionaries is stored as json_dict:\nfor target_dict in json_dict:\n if target_dict[\"ticker\"] == \"TESLA.US\":\n break\n\nAt this point, target_dict will be the dictionary you want.\n", "Try (mylist is your list of dictionaries)\nfor entry in mylist:\n print(entry['ticker'])\n\nThen try this to get what you want:\nfor entry in mylist:\n if entry['ticker'] == 'TSLA.US':\n print(entry)\n\n", "It is possible to iterate through a list of dictionaries using a for loop.\n for stock in list:\n if stock[\"ticker\"] == \"TSLA.US\":\n return stock[\"price\"]\n\n\nThis essentially loops through every item in the list, and for each item (which is a dictionary) looks for the key \"ticker\" and checks if its value is equal to \"TSLA.US\". If it is, then it returns the value associated with the \"price\" key.\n" ]

[ 1, 0, 0 ]

[]

[]

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

[ "I just tried your code in python3 and everything works normal, your code works.\nhere is the coded I tested, just remove some waitkeys.\nimport cv2 \n import numpy as np \n image = cv2.imread('1.png') \n\n gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) \n edged = cv2.Canny(gray, 30, 200) \n\n \n contours, hierarchy = cv2.findContours(edged, \n cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) \n \n cv2.imshow('Canny Edges After Contouring', edged) \n\n \n print(\"Number of Contours found = \" + str(len(contours))) \n cv2.drawContours(image, contours, -1, (0, 0, 255), 3) \n \n cv2.imshow('Contours', image) \n cv2.waitKey(0) \n cv2.destroyAllWindows() \n\nALso I changed the image for a jpg image, here are the results.\nenter image description here\nAs you can see the countours are drawed in red color.\nI have opencv 4.2 version, maybe yours are a bit older.\n" ]

[ 0 ]

[]

[]

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

[ "Because you have defined a variable named first, but it has no content. It can be of any type, so vscode won't provide any prompt.\nI guess that you want to define the string and first is it's content.\n\nYou can define x=\"first\", here the type of x is string, then x has the upper() method.\n" ]

[ 0 ]

[]

[]

[ "autocomplete", "python", "visual_studio_code" ]

[ "You can try to vectorized the operations instead of evaluate the scores in a loop.\nMake a df where the firse col ref is ref_list and the second col inp is each name in inp_list. Then call df.apply(lambda row:process.extractOne(row['inp'], row['ref']), axis=1). Finally you'll get the best match name and score in ref_list for each name in inp_list.\n", "The measures you are using are computationally demanding with a number of pairs of strings that high. Alternatively to fuzzywuzzy, you could try to use instead a library called string-grouper which exploits a faster Tf-idf method and the cosine similarity measure to find similar words. As an example:\nimport random, string, time\nimport pandas as pd\nfrom string_grouper import match_strings\n\nalphabet = list(string.ascii_lowercase)\nfrom_r, to_r = 0, len(alphabet)-1\n\nrandom_strings_1 = [\"\".join(alphabet[random.randint(from_r, to_r)]\n for i in range(6)) for j in range(5000)]\nrandom_strings_2 = [\"\".join(alphabet[random.randint(from_r, to_r)]\n for i in range(6)) for j in range(5000)]\n \nseries_1 = pd.Series(random_strings_1)\nseries_2 = pd.Series(random_strings_2)\n\nt_1 = time.time()\nmatches = match_strings(series_1, series_2,\n min_similarity=0.6)\nt_2 = time.time()\nprint(t_2 - t_1)\nprint(matches)\n\nIt takes less than one second to do 25.000.000 comparisons! For a surely more useful test of the library look here: https://bergvca.github.io/2017/10/14/super-fast-string-matching.html where it is claimed that\n\n\"Using this approach made it possible to search for near duplicates in\na set of 663,000 company names in 42 minutes using only a dual-core\nlaptop\".\n\nTo tune your matching algorithm further look at the **kwargs arguments you can give to the match_strings function above.\n" ]

[ 1, 0 ]

[]

[]

[ "fuzzywuzzy", "matching", "python" ]

[ "\nTry to create new env 3.10 using Anaconda, if Anaconda still doesn't have 3.11. The difference with 3.11 would be (I'm not guaranty, just a \"rumors\") ~+15%, depends...\n\nYou can build and install your version from source :\nbuild-python-from-source\n\n\nThis way you won't break anything and can to delete Python3.11 after experiments.\n\nYou can google the benchmark tests for overage performance comparison between <your.version> and <any.over.version> for very common understanding.\n\n" ]

[ 0 ]

[ "It's not recommended to have multiple versions of Python installed on the same system, as this can cause conflicts and problems with package compatibility. Instead of installing Python 3.11 directly, you can create a new virtual environment using conda and install Python 3.11 in that environment. This will allow you to use Python 3.11 without affecting your existing environment or installations.\nTo create a new conda environment with Python 3.11, first open a terminal or command prompt and run the following command:\nconda create -n py311 python=3.11\n\nThis will create a new environment called \"py311\" with Python 3.11 installed. To activate this environment, run the following command:\nconda activate py311\n\nOnce the environment is activated, you can use the python command to run Python 3.11, and any packages you install will be installed in this environment only. To deactivate the environment, run the following command:\nconda deactivate\n\nYou can also use the conda install command to install packages in the new environment, for example:\nconda install numpy scipy pandas\n\nThis will install the NumPy, SciPy, and pandas packages in the \"py311\" environment.\nAs for the IDE, you can use any IDE that supports Python 3.11, such as PyCharm or Visual Studio Code. These IDEs allow you to select the Python environment you want to use, so you can easily switch between your existing environment and the new \"py311\" environment.\n" ]

[ -4 ]

[ "anaconda", "ide", "performance", "python", "python_3.11" ]

[ "You can use SeasonAll, convert to pandas df, convert datetime and finally query.\nimport pandas as pd\nfrom nba_api.stats.endpoints import playergamelog\nfrom nba_api.stats.library.parameters import SeasonAll\nfrom nba_api.stats.static import players\n\n\nluka_id = next((x for x in players.get_players() if x.get(\"full_name\") == \"Luka Doncic\"), None).get(\"id\")\n\ngamelog_luka = pd.concat(playergamelog.PlayerGameLog(player_id=luka_id, season=SeasonAll.all).get_data_frames())\ngamelog_luka[\"GAME_DATE\"] = pd.to_datetime(gamelog_luka[\"GAME_DATE\"], format=\"%b %d, %Y\")\ngamelog_luka = gamelog_luka.query(\"GAME_DATE.dt.year in [2021, 2022]\")\nprint(gamelog_luka)\n\n" ]

[ 0 ]

[]

[]

[ "dataframe", "nba_api", "pandas", "python", "web_scraping" ]

[ "The problem is not with matplotlib, but instead the range of x values you chose. If you look at your own picture, the xvalues are ranging from around -2 to 2, so if I do the same and play with the plotting bounds I get:\nimport matplotlib.pyplot as plt\nimport numpy as np\n\n\nx=np.linspace(-2,2,101) \nfuncion=(56*(x**3))-(38.999*(x**2))+(4.196*x-0.15) \nplt.plot(x, funcion)\n\nplt.axvline(0, color = 'k')\nplt.axhline(0, color = 'k')\n\nplt.xlim([-0.8, 1.4])\nplt.ylim([-3.5, 3])\n\nwhich gives\n\n" ]

[ 1 ]

[]

[]

[ "calculus", "matplotlib", "plot", "python" ]

[ "There are multiple python environments on your machine, if you have created a virtual environment, you should run these commands after activation. If you execute the python command in a terminal where the virtual environment is not activated, the displayed version will be the one configured in the system environment variable path.\nThe correct way is:\n\nCreate a virtual environment\nActivate the virtual environment\nExecute python commands\n\nThere are two ways to activate a virtual environment:\n\nAfter creating the virtual environment use the following command to activate\n.venv\\scripts\\activate\n\n\nOr select the virtual environment interpreter in the select interpreter panel, and\nthen create a new terminal to automatically activate the environment.\n\n\n\nIn vscode, the interpreter version you choose for python will always be displayed in the lower right corner.\n\nSee the Environments documentation for more details.\n" ]

[ 1 ]

[]

[]

[ "python", "virtualenv", "visual_studio_code" ]

[ "Starting from Python 3.2 there is a built-in decorator:\[email protected]_cache(maxsize=100, typed=False)\n\nDecorator to wrap a function with a memoizing callable that saves up to the maxsize most recent calls. It can save time when an expensive or I/O bound function is periodically called with the same arguments.\n\nExample of an LRU cache for computing Fibonacci numbers:\nfrom functools import lru_cache\n\n@lru_cache(maxsize=None)\ndef fib(n):\n if n < 2:\n return n\n return fib(n-1) + fib(n-2)\n\n>>> print([fib(n) for n in range(16)])\n[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]\n\n>>> print(fib.cache_info())\nCacheInfo(hits=28, misses=16, maxsize=None, currsize=16)\n\n\nIf you are stuck with Python 2.x, here's a list of other compatible memoization libraries:\n\nfunctools32 | PyPI | Source code\nrepoze.lru | PyPI | Source code\npylru | PyPI | Source code\nbackports.functools_lru_cache | PyPI | Source code\n\n", "Python 3.8 functools.cached_property decorator\nhttps://docs.python.org/dev/library/functools.html#functools.cached_property\ncached_property from Werkzeug was mentioned at: https://stackoverflow.com/a/5295190/895245 but a supposedly derived version will be merged into 3.8, which is awesome.\nThis decorator can be seen as caching @property, or as a cleaner @functools.lru_cache for when you don't have any arguments.\nThe docs say:\n\[email protected]_property(func)\n\nTransform a method of a class into a property whose value is computed once and then cached as a normal attribute for the life of the instance. Similar to property(), with the addition of caching. Useful for expensive computed properties of instances that are otherwise effectively immutable.\nExample:\nclass DataSet:\n def __init__(self, sequence_of_numbers):\n self._data = sequence_of_numbers\n\n @cached_property\n def stdev(self):\n return statistics.stdev(self._data)\n\n @cached_property\n def variance(self):\n return statistics.variance(self._data)\n\nNew in version 3.8.\nNote This decorator requires that the dict attribute on each instance be a mutable mapping. This means it will not work with some types, such as metaclasses (since the dict attributes on type instances are read-only proxies for the class namespace), and those that specify slots without including dict as one of the defined slots (as such classes don’t provide a dict attribute at all).\n\n", "It sounds like you're not asking for a general-purpose memoization decorator (i.e., you're not interested in the general case where you want to cache return values for different argument values). That is, you'd like to have this:\nx = obj.name # expensive\ny = obj.name # cheap\n\nwhile a general-purpose memoization decorator would give you this:\nx = obj.name() # expensive\ny = obj.name() # cheap\n\nI submit that the method-call syntax is better style, because it suggests the possibility of expensive computation while the property syntax suggests a quick lookup.\n[Update: The class-based memoization decorator I had linked to and quoted here previously doesn't work for methods. I've replaced it with a decorator function.] If you're willing to use a general-purpose memoization decorator, here's a simple one:\ndef memoize(function):\n memo = {}\n def wrapper(*args):\n if args in memo:\n return memo[args]\n else:\n rv = function(*args)\n memo[args] = rv\n return rv\n return wrapper\n\nExample usage:\n@memoize\ndef fibonacci(n):\n if n < 2: return n\n return fibonacci(n - 1) + fibonacci(n - 2)\n\nAnother memoization decorator with a limit on the cache size can be found here.\n", "functools.cache has been released in Python 3.9 (docs):\nfrom functools import cache\n\n@cache\ndef factorial(n):\n return n * factorial(n-1) if n else 1\n\nIn previous Python versions, one of the early answers is still a valid solution: Using lru_cache as an ordinary cache without the limit and lru features. (docs)\n\nIf maxsize is set to None, the LRU feature is disabled and the cache\ncan grow without bound.\n\nHere is a prettier version of it:\ncache = lru_cache(maxsize=None)\n\n@cache\ndef func(param1):\n pass\n\n", "class memorize(dict):\n def __init__(self, func):\n self.func = func\n\n def __call__(self, *args):\n return self[args]\n\n def __missing__(self, key):\n result = self[key] = self.func(*key)\n return result\n\nSample uses:\n>>> @memorize\n... def foo(a, b):\n... return a * b\n>>> foo(2, 4)\n8\n>>> foo\n{(2, 4): 8}\n>>> foo('hi', 3)\n'hihihi'\n>>> foo\n{(2, 4): 8, ('hi', 3): 'hihihi'}\n\n", "Werkzeug has a cached_property decorator (docs, source)\n", "I coded this simple decorator class to cache function responses. I find it VERY useful for my projects:\nfrom datetime import datetime, timedelta \n\nclass cached(object):\n def __init__(self, *args, **kwargs):\n self.cached_function_responses = {}\n self.default_max_age = kwargs.get(\"default_cache_max_age\", timedelta(seconds=0))\n\n def __call__(self, func):\n def inner(*args, **kwargs):\n max_age = kwargs.get('max_age', self.default_max_age)\n if not max_age or func not in self.cached_function_responses or (datetime.now() - self.cached_function_responses[func]['fetch_time'] > max_age):\n if 'max_age' in kwargs: del kwargs['max_age']\n res = func(*args, **kwargs)\n self.cached_function_responses[func] = {'data': res, 'fetch_time': datetime.now()}\n return self.cached_function_responses[func]['data']\n return inner\n\nThe usage is straightforward:\nimport time\n\n@cached\ndef myfunc(a):\n print \"in func\"\n return (a, datetime.now())\n\n@cached(default_max_age = timedelta(seconds=6))\ndef cacheable_test(a):\n print \"in cacheable test: \"\n return (a, datetime.now())\n\n\nprint cacheable_test(1,max_age=timedelta(seconds=5))\nprint cacheable_test(2,max_age=timedelta(seconds=5))\ntime.sleep(7)\nprint cacheable_test(3,max_age=timedelta(seconds=5))\n\n", "DISCLAIMER: I'm the author of kids.cache.\nYou should check kids.cache, it provides a @cache decorator that works on python 2 and python 3. No dependencies, ~100 lines of code. It's very straightforward to use, for instance, with your code in mind, you could use it like this:\npip install kids.cache\n\nThen\nfrom kids.cache import cache\n...\nclass MyClass(object):\n ...\n @cache # <-- That's all you need to do\n @property\n def name(self):\n return 1 + 1 # supposedly expensive calculation\n\nOr you could put the @cache decorator after the @property (same result).\nUsing cache on a property is called lazy evaluation, kids.cache can do much more (it works on function with any arguments, properties, any type of methods, and even classes...). For advanced users, kids.cache supports cachetools which provides fancy cache stores to python 2 and python 3 (LRU, LFU, TTL, RR cache).\nIMPORTANT NOTE: the default cache store of kids.cache is a standard dict, which is not recommended for long running program with ever different queries as it would lead to an ever growing caching store. For this usage you can plugin other cache stores using for instance (@cache(use=cachetools.LRUCache(maxsize=2)) to decorate your function/property/class/method...)\n", "Ah, just needed to find the right name for this: \"Lazy property evaluation\".\nI do this a lot too; maybe I'll use that recipe in my code sometime.\n", "There is yet another example of a memoize decorator at Python Wiki:\nhttp://wiki.python.org/moin/PythonDecoratorLibrary#Memoize\nThat example is a bit smart, because it won't cache the results if the parameters are mutable. (check that code, it's very simple and interesting!)\n", "If you are using Django Framework, it has such a property to cache a view or response of API's\nusing @cache_page(time) and there can be other options as well.\nExample:\n@cache_page(60 * 15, cache=\"special_cache\")\ndef my_view(request):\n ...\n\nMore details can be found here.\n", "Try joblib\nhttps://joblib.readthedocs.io/en/latest/memory.html\nfrom joblib import Memory\nmemory = Memory(cachedir=cachedir, verbose=0)\[email protected]\n def f(x):\n print('Running f(%s)' % x)\n return x\n\n", "There is fastcache, which is \"C implementation of Python 3 functools.lru_cache. Provides speedup of 10-30x over standard library.\"\nSame as chosen answer, just different import:\nfrom fastcache import lru_cache\n@lru_cache(maxsize=128, typed=False)\ndef f(a, b):\n pass\n\nAlso, it comes installed in Anaconda, unlike functools which needs to be installed.\n", "Along with the Memoize Example I found the following python packages:\n\ncachepy; It allows to set up ttl and\\or the number of calls for cached functions; Also, one can use encrypted file-based cache...\npercache \n\n", "@lru_cache is not good with default attrs\nmy @mem decorator:\nimport inspect\nfrom copy import deepcopy\nfrom functools import lru_cache, wraps\nfrom typing import Any, Callable, Dict, Iterable\n\n\n# helper\ndef get_all_kwargs_values(f: Callable, kwargs: Dict[str, Any]) -> Iterable[Any]:\n default_kwargs = {\n k: v.default\n for k, v in inspect.signature(f).parameters.items()\n if v.default is not inspect.Parameter.empty\n }\n\n all_kwargs = deepcopy(default_kwargs)\n all_kwargs.update(kwargs)\n\n for key in sorted(all_kwargs.keys()):\n yield all_kwargs[key]\n\n\n# the best decorator\ndef mem(func: Callable) -> Callable:\n cache = dict()\n\n @wraps(func)\n def wrapper(*args, **kwargs) -> Any:\n all_kwargs_values = get_all_kwargs_values(func, kwargs)\n params = (*args, *all_kwargs_values)\n _hash = hash(params)\n\n if _hash not in cache:\n cache[_hash] = func(*args, **kwargs)\n\n return cache[_hash]\n\n return wrapper\n\n\n# some logic\ndef counter(*args) -> int:\n print(f'* not_cached:', end='\\t')\n return sum(args)\n\n\n@mem\ndef check_mem(a, *args, z=10) -> int:\n return counter(a, *args, z)\n\n\n@lru_cache\ndef check_lru(a, *args, z=10) -> int:\n return counter(a, *args, z)\n\n\ndef test(func) -> None:\n print(f'\\nTest {func.__name__}:')\n\n print('*', func(1, 2, 3, 4, 5))\n print('*', func(1, 2, 3, 4, 5))\n print('*', func(1, 2, 3, 4, 5, z=6))\n print('*', func(1, 2, 3, 4, 5, z=6))\n print('*', func(1))\n print('*', func(1, z=10))\n\n\ndef main():\n test(check_mem)\n test(check_lru)\n\n\nif __name__ == '__main__':\n main()\n\noutput:\nTest check_mem:\n* not_cached: * 25\n* 25\n* not_cached: * 21\n* 21\n* not_cached: * 11\n* 11\n\nTest check_lru:\n* not_cached: * 25\n* 25\n* not_cached: * 21\n* 21\n* not_cached: * 11\n* not_cached: * 11\n\n", "I implemented something like this, using pickle for persistance and using sha1 for short almost-certainly-unique IDs. Basically the cache hashed the code of the function and the hist of arguments to get a sha1 then looked for a file with that sha1 in the name. If it existed, it opened it and returned the result; if not, it calls the function and saves the result (optionally only saving if it took a certain amount of time to process).\nThat said, I'd swear I found an existing module that did this and find myself here trying to find that module... The closest I can find is this, which looks about right: http://chase-seibert.github.io/blog/2011/11/23/pythondjango-disk-based-caching-decorator.html\nThe only problem I see with that is it wouldn't work well for large inputs since it hashes str(arg), which isn't unique for giant arrays.\nIt would be nice if there were a unique_hash() protocol that had a class return a secure hash of its contents. I basically manually implemented that for the types I cared about.\n", "If you are using Django and want to cache views, see Nikhil Kumar's answer. \n\nBut if you want to cache ANY function results, you can use django-cache-utils.\nIt reuses Django caches and provides easy to use cached decorator:\nfrom cache_utils.decorators import cached\n\n@cached(60)\ndef foo(x, y=0):\n print 'foo is called'\n return x+y\n\n", "Function cache simple solution\nwith ttl (time to life) and max_entries\n\ndoesnt work when the decorated function takes unhashable types as input (e.g. dicts)\noptional parameter: ttl (time to live for every entry)\noptional parameter: max_entries (if too many cache argument combination to no clutter the storage)\nmake sure the function has no important side effects\n\nExample use\nimport time\n\n@cache(ttl=timedelta(minutes=3), max_entries=300)\ndef add(a, b):\n time.sleep(2)\n return a + b\n\n@cache()\ndef substract(a, b):\n time.sleep(2)\n return a - b\n\na = 5\n# function is called with argument combinations the first time -> it takes some time\nfor i in range(5):\n print(add(a, i))\n\n# function is called with same arguments again? -> will answer from cache\nfor i in range(5):\n print(add(a, i))\n\nCopy the decorator code\nfrom datetime import datetime, timedelta\n\ndef cache(**kwargs):\n def decorator(function):\n # static function variable for cache, lazy initialization\n try: function.cache\n except: function.cache = {}\n def wrapper(*args):\n # if nothing valid in cache, insert something\n if not args in function.cache or datetime.now() > function.cache[args]['expiry']:\n if 'max_entries' in kwargs:\n max_entries = kwargs['max_entries']\n if max_entries != None and len(function.cache) >= max_entries:\n now = datetime.now()\n # delete the the first expired entry that can be found (lazy deletion)\n for key in function.cache:\n if function.cache[key]['expiry'] < now:\n del function.cache[key]\n break\n # if nothing is expired that is deletable, delete the first\n if len(function.cache) >= max_entries:\n del function.cache[next(iter(function.cache))]\n function.cache[args] = {'result': function(*args), 'expiry': datetime.max if 'ttl' not in kwargs else datetime.now() + kwargs['ttl']}\n\n # answer from cache\n return function.cache[args]['result']\n return wrapper\n return decorator\n\n", "from functools import wraps\n\n\ndef cache(maxsize=128):\n cache = {}\n\n def decorator(func):\n @wraps(func)\n def inner(*args, no_cache=False, **kwargs):\n if no_cache:\n return func(*args, **kwargs)\n\n key_base = \"_\".join(str(x) for x in args)\n key_end = \"_\".join(f\"{k}:{v}\" for k, v in kwargs.items())\n key = f\"{key_base}-{key_end}\"\n\n if key in cache:\n return cache[key]\n\n res = func(*args, **kwargs)\n\n if len(cache) > maxsize:\n del cache[list(cache.keys())[0]]\n cache[key] = res\n\n return res\n\n return inner\n\n return decorator\n\n\ndef async_cache(maxsize=128):\n cache = {}\n\n def decorator(func):\n @wraps(func)\n async def inner(*args, no_cache=False, **kwargs):\n if no_cache:\n return await func(*args, **kwargs)\n\n key_base = \"_\".join(str(x) for x in args)\n key_end = \"_\".join(f\"{k}:{v}\" for k, v in kwargs.items())\n key = f\"{key_base}-{key_end}\"\n\n if key in cache:\n return cache[key]\n\n res = await func(*args, **kwargs)\n\n if len(cache) > maxsize:\n del cache[list(cache.keys())[0]]\n cache[key] = res\n\n return res\n\n return inner\n\n return decorator\n\nExample use\nimport asyncio\nimport aiohttp\n\n\n# Removes the aiohttp ClientSession instance warning.\nclass HTTPSession(aiohttp.ClientSession):\n \"\"\" Abstract class for aiohttp. \"\"\"\n \n def __init__(self, loop=None) -> None:\n super().__init__(loop=loop or asyncio.get_event_loop())\n\n def __del__(self) -> None:\n if not self.closed:\n self.loop.run_until_complete(self.close())\n self.loop.close()\n \n\n return \n \n\n \n\nsession = HTTPSession()\n\n@async_cache()\nasync def query(url, method=\"get\", res_method=\"text\", *args, **kwargs):\n async with getattr(session, method.lower())(url, *args, **kwargs) as res:\n return await getattr(res, res_method)()\n\n\nasync def get(url, *args, **kwargs):\n return await query(url, \"get\", *args, **kwargs)\n \n\nasync def post(url, *args, **kwargs):\n return await query(url, \"post\", *args, **kwargs)\n\nasync def delete(url, *args, **kwargs):\n return await query(url, \"delete\", *args, **kwargs)\n\n", "Create your own decorator and use it\nfrom django.core.cache import cache\nimport functools\n\ndef cache_returned_values(func):\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n key = \"choose a unique key here\"\n results = cache.get(key)\n if not results:\n results = func(*args, **kwargs)\n cache.set(key, results)\n return results\n\n return wrapper\n\nNow at the function side\n@cache_returned_values\ndef get_some_values(args):\n return x\n\n" ]

[ 278, 48, 39, 30, 27, 12, 10, 8, 7, 4, 4, 4, 4, 3, 3, 2, 2, 2, 1, 0 ]

[]

[]

[ "caching", "decorator", "memoization", "python" ]

[ "It's generally easier to assemble a new list that has only the items you want, instead of individually deleting the unwanted items from the old list.\nAnd then, if you like, you can replace the old list with the new list.\nA simple example of this:\nnumbers = [0,1,2,3,4,5,6,7,8,9]\n\n# replace numbers with a version of itself that only contains\n# numbers that are odd (i.e. n%2 is nonzero)\nnumbers = [n for n in numbers if n%2]\n\n# numbers is now [1,3,5,7,9]\n\nApplying this concept to your code would look something like this:\nfor feature in mydict[\"features\"]:\n if feature[\"geometry\"][\"type\"] == \"GeometryCollection\":\n feature[\"geometry\"][\"geometries\"] = [geom for geom in feature[\"geometry\"][\"geometries\"] if geom[\"type\"] == \"Polygon\" or geom[\"type\"] == \"Multipolygon\"]\n\n", "You could create a new list of just the things you want to keep and substitute it into the original data structure. In the example case, this could be done with a list comprehension, but I've written a procedural example because of the other work you'd like to do.\nimport json\n\ngeojson_obj = json.loads(json_str)\nfeatures = geojson_obj ['features']\n\nfor feature in features:\n if feature['geometry']['type'] == 'GeometryCollection':\n keep_geometries = []\n for geometry in feature['geometry']['geometries']:\n if geometry['type'] == 'MultiPolygon':\n keep_geometries.append(geometry)\n feature['geometry']['geometries'] = keep_geometries\n\n \n\n" ]

[ 1, 1 ]

[]

[]

[ "dictionary", "python" ]

[ "This has been asked before on opencv c++, there should be the same function on python3, hconcat, placing two images side by side, opencv 2.3, c++\n" ]

[ 0 ]

[]

[]

[ "image", "opencv", "python" ]

[ "Add couple of seconds wait before you enter correct captcha first time, that might work unless its designed otherwise.\n" ]

[ 0 ]

[]

[]

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

[ "Answering my own question.\nNormally setting tickon=boundaries should do the trick, but it doesn't seem to work in conjunction with tickmode=array and ticktext.\nThe solution for me was to create the labels array and provide it to the bar chart as the x parameter, something similar to this:\nfig = go.Figure(data=go.Bar(name='Trace1', x=['0-2kw', '2-4kw', '4-6kw', '6-8kw'], y=[0.2, 0.2, 0.2, 0.4]))\nfig.update_xaxes(showgrid=True, tickson='boundaries')\n\nDoing this in my code now the data bars are in between the grid lines:\n\n" ]

[ 0 ]

[]

[]

[ "plotly", "python" ]

[ "You can use pprint.pprint() for that. Something like this:\n>>> from pprint import pprint\n>>> d = [{'C1': 'a', 'C2': '2', 'C3': '3'}, {'C1': '4', 'C2': '5', 'C3': '6'}, {'C1': '7', 'C2': '8', 'C3': '9'}]\n>>> pprint(d, width=10)\n[{'C1': 'a',\n 'C2': '2',\n 'C3': '3'},\n {'C1': '4',\n 'C2': '5',\n 'C3': '6'},\n {'C1': '7',\n 'C2': '8',\n 'C3': '9'}]\n>>> \n\nAnd with the default width, the output is the following:\n>>> pprint(d)\n[{'C1': 'a', 'C2': '2', 'C3': '3'},\n {'C1': '4', 'C2': '5', 'C3': '6'},\n {'C1': '7', 'C2': '8', 'C3': '9'}]\n>>> \n\n" ]

[ 1 ]

[]

[]

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

[ "The direct answer to your question was answered by @Shmack in the comments. The code is simply\nfor i in range(1200):\n cap.read()\n\nGiven that your using the variable cap, I suspect that your using the OpenCV module. If that is the case, then you can simply set the frame you want to start at by using cap.set(1, 1200)\nThe .set function takes in its first parameter as the identifier, and for your case, you can simply leave that as 1. The second parameter is the frame you wish to start at. You can read more about cap.set() here\n" ]

[ 0 ]

[]

[]

[ "continuous", "for_loop", "function", "python", "repeat" ]

[ "I figured out i had to use getattr on the module object:\nfrom importlib import import_module\nimport sklearn\n\ndef all_regressors():\n regressors=[]\n for module in sklearn.__all__:\n try:\n module = import_module(f'sklearn.{module}')\n regressors.extend([getattr(module,cls) for cls in module.__all__ if 'Regress' in cls ])\n except:\n pass\n regressors.append(sklearn.svm.SVR)\n return regressors\nprint(all_regressors())\n\n[<class 'sklearn.ensemble.forest.RandomForestRegressor'>, <class \n'sklearn.ensemble.forest.ExtraTreesRegressor'>, <class \n'sklearn.ensemble.bagging.BaggingRegressor'>, <class \n'sklearn.ensemble.gradient_boosting.GradientBoostingRegressor'>,\n<class 'sklearn.ensemble.weight_boosting.AdaBoostRegressor'>, <class \n'sklearn.gaussian_process.gpr.GaussianProcessRegressor'>, <class \n'sklearn.isotonic.IsotonicRegression'>, <class \n'sklearn.linear_model.bayes.ARDRegression'>, <class \n'sklearn.linear_model.huber.HuberRegressor'>, <class \n'sklearn.linear_model.base.LinearRegression'>, <class \n'sklearn.linear_model.logistic.LogisticRegression'>, <class \n'sklearn.linear_model.logistic.LogisticRegressionCV'>, <class \n'sklearn.linear_model.passive_aggressive.PassiveAggressiveRegressor'>, \n<class 'sklearn.linear_model.randomized_l1.RandomizedLogisticRegression'>, <class \n'sklearn.linear_model.stochastic_gradient.SGDRegressor'>, <class \n'sklearn.linear_model.theil_sen.TheilSenRegressor'>, <class \n'sklearn.linear_model.ransac.RANSACRegressor'>, <class \n'sklearn.multioutput.MultiOutputRegressor'>, <class \n'sklearn.neighbors.regression.KNeighborsRegressor'>, <class \n'sklearn.neighbors.regression.RadiusNeighborsRegressor'>, <class \n'sklearn.neural_network.multilayer_perceptron.MLPRegressor'>, <class \n'sklearn.tree.tree.DecisionTreeRegressor'>, <class \n'sklearn.tree.tree.ExtraTreeRegressor'>, <class \n'sklearn.svm.classes.SVR'>]\n\n", "You can use all_estimators from sklearn.utils\nfrom sklearn.utils import all_estimators\n\ndef get_all_regressors_sklearn():\n from sklearn.utils import all_estimators\n\n estimators = all_estimators(type_filter='regressor')\n\n all_regs = []\n for name, RegClass in estimators:\n print('Appending', name)\n try:\n reg = RegClass()\n all_regs.append(reg)\n except Exception as e:\n pass\n return all_regs\n\nall_regs = get_all_regressors_sklearn()\nprint(all_regs)\n\nGives:\n[ARDRegression(), AdaBoostRegressor(), BaggingRegressor(), BayesianRidge(), CCA(), DecisionTreeRegressor(), DummyRegressor(), ElasticNet(), ElasticNetCV(), ExtraTreeRegressor(), ExtraTreesRegressor(), GammaRegressor(), GaussianProcessRegressor(), GradientBoostingRegressor(), HistGradientBoostingRegressor(), HuberRegressor(), IsotonicRegression(), KNeighborsRegressor(), KernelRidge(), Lars(), LarsCV(), Lasso(), LassoCV(), LassoLars(), LassoLarsCV(), LassoLarsIC(), LinearRegression(), LinearSVR(), MLPRegressor(), MultiTaskElasticNet(), MultiTaskElasticNetCV(), MultiTaskLasso(), MultiTaskLassoCV(), NuSVR(), OrthogonalMatchingPursuit(), OrthogonalMatchingPursuitCV(), PLSCanonical(), PLSRegression(), PassiveAggressiveRegressor(), PoissonRegressor(), QuantileRegressor(), RANSACRegressor(), RadiusNeighborsRegressor(), RandomForestRegressor(), Ridge(), RidgeCV(), SGDRegressor(), SVR(), TheilSenRegressor(), TransformedTargetRegressor(), TweedieRegressor()]\n\n" ]

[ 2, 0 ]

[]

[]

[ "python", "python_import", "scikit_learn" ]

[ "The code above requires the addition of the following line, in order to commit the DELETE statement.\nconnection.commit()\n\nThe commit method should be called after every transaction that modifies data, such as this one.\n" ]

[ 0 ]

[]

[]

[ "google_cloud_platform", "mysql", "pymysql", "python" ]

[ "You can perform the code as follows.\nCode\nfrom sympy import Symbol, diff, sympify\n\ndef newton_method(func, sym, x0, n = 10):\n diff_func = diff(func, x) # derivative of function\n \n root = x0\n for i in range(n):\n root = root - float(func.subs(x, root)/diff_func.subs(x, root))\n \n return root\n \n# Setup\nexpression = input('input function: ') # String expression corresponding to function\nf = sympify(expression) # string expression to sympy function\nx0 = float(input(\"Initial Value:\")) \nn = int(input(\"Number of interactions:\")) \n\n# Find root\nroot = newton_method(f, Symbol('x'), x0, n) # newton method with x as symbol\n\nprint('root:', root)\n\nTest\ninput function: x**2 - 2*x + 1\nInitial Value: 0\nNumber of interactions: 10\nroot: 0.9990234375\n\n" ]

[ 0 ]

[]

[]

[ "math", "python" ]

[ "You can use the clear_output() function to clear the output of the current cell in a Jupyter notebook. However, this will not clear the widgets that you have defined in your code. In order to clear the widgets, you will need to re-initialize them each time the on_clicker() function is called.\nOne way to do this would be to move the code that initializes the widgets inside the on_clicker() function, so that they are re-initialized each time the function is called.\nHere is an example of how you could modify your code to achieve this:\nfrom IPython.display import clear_output\n\ndef on_clicker(button):\n clear_output()\n # Define the widgets inside the on_clicker function\n dropdown = widgets.Dropdown(...)\n datepicker = widgets.DatePicker(...)\n @widgets.interact(dropdown=dropdown, datepicker=datepicker)\n def grapher(dropdown, datepicker):\n global recalculate\n ... some graphing stuff\n display(recalculate)\n recalculate.on_click(on_clicker)\n\nThis way, when the on_clicker() function is called, it will clear the output and re-initialize the widgets, which should solve your problem.\n" ]

[ 0 ]

[]

[]

[ "ipywidgets", "jupyter", "python" ]

[ "def pencil():\n return \"pencil\"\n\n\nprint(\"A\", pencil()) # A pencil\n\nOr\ndef pencil():\n print(\"pencil\")\n\n\nprint(\"A\") # A\npencil() # pencil\n\n", "When you do\nprint(\"A\", pencil())\n\nyou are basically asking python to print \"A\" and the return value of the function named pencil.\nBecause you do not specify a return statement in your function definition, python returns None, hence the unwanted result.\nAs stated by other people, you just need to return \"pencil\" from the function so that the desired outcome can be achieved\n", "The default return value of a function is None\nYour function doesn't have a return statement, so it will return None\nFurthermore, print returns None to as it prints its input to the sys.stdout stream. So returning print(\"pencil\") would also give you None\nIn order for you to get a value from a function you need to use the return statement and return a value. In your case \"pencil\":\ndef pencil():\n return \"pencil\"\n\nprint(\"A\", pencil())\n\n" ]

[ 1, 0, 0 ]

[]

[]

[ "python" ]

[ "You should use an if/elif/else structure. You don't need to make 2 functions for the 2 different values of z0.\ndef f(t,y):\n if 0 <= t <= 30:\n z0 = 6\n elif t > 30: \n z0 = 6 * np.exp(-0.5 * (t - 15))\n else:\n return f\"t value {t} is less than zero\"\n return z0 - y[0], 3 / y[0] - y[1]\n\nfsol = solve_ivp(f, (0,100), [3,350])\nplt.plot(fsol.t, fsol.y[0])\n\n" ]

[ 0 ]

[]

[]

[ "if_statement", "math", "ode", "python" ]

[ "Ok another option\nThis will create a dictionary 'state_dict' in the format per your question\n\nMissouri = \"search item 1, search item 2, search item 5, search item\n6\" \nIllinois = \"search item 3, search item 4\"\n\n...\nprint(\"\\nValue of fourth column\")\nstate_dict = {}\nfor row in sheet_object.iter_rows(min_row=2, max_row=sheet_object.max_row):\n k = row[3].value.split(',')[1].strip()\n v = row[0].value\n if k in state_dict:\n state_dict[k] += [v]\n else:\n state_dict[k] = [v]\n\n### Print values\nfor key, value in state_dict.items():\n print(f'{key}, Total {len(value)}', end='; ')\n for v in value:\n print(f'{v}', end=', ')\n print('')\n\nWill create the dictionary 'state_dict' as so;\n'Missouri' = {list: 4} ['search item 1', 'search item 2', 'search item 5', 'search item 6']\n'Illinois' = {list: 2} ['search item 3', 'search item 4']\n'Alabama' = {list: 1} ['search item 7']\n'Colorado' = {list: 1} ['search item 8']\n\nPrint output\nValue of fourth column\nMissouri = Total 4; search item 1, search item 2, search item 5, search item 6, \nIllinois = Total 2; search item 3, search item 4, \nAlabama = Total 1; search item 7, \nColorado = Total 1; search item 8, \n\n", "ranemirusG is right, there are several ways to obtain the same result. Here's another option...I attempted to preserve your thought process, good luck.\nprint(\"\\nValue of fourth column\")\n\nmissouri_list = [] # empty list\nillinois_list = [] # empty list\n\nfor i in range(2, row+1): # It didn't look like \"4, row+1\" captured the full sheet, try (2, row+1)\n cell_object = sheet_object.cell(row=i, column=4)\n keyword = sheet_object.cell(row=i, column=1)\n keyword_fmt = keyword.value # Captures values in Keyword column\n split_item_test = cell_object.value.split(\",\")\n split_item_test_result = split_item_test[1] # 1 captures states\n state = split_item_test_result\n print(state)\n\n # simple if statement to capture results in a list\n if 'Missouri' in state:\n missouri_list.append(keyword_fmt)\n if 'Illinois' in state:\n illinois_list.append(keyword_fmt)\nprint(missouri_list)\nprint(len(missouri_list)) # Counts the number of occurances\nprint(illinois_list)\nprint(len(illinois_list)) # Counts the number of occurances\nprint(\"All good\")\n\n", "Yes, it's possible with openpyxl.\nTo achieve your real goal try something like this:\nstates_and_keywords = {}\nfor i in range(4, row + 1):\n cell_object = sheet_object.cell(row=i, column=4)\n split_item_test = cell_object.value.split(\",\")\n split_item_test_result = split_item_test[1] #note that the element should be 1 for the state\n state = split_item_test_result.strip(\" \") #trim whitespace (after comma)\n keyword = cell_object.offset(0,-3).value #this gets the value of the keyword for that row\n if state not in states_and_keywords:\n states_and_keywords[state] = [keyword]\n else:\n states_and_keywords[state].append(keyword) \nprint(states_and_keywords)\n\n" ]

[ 1, 0, 0 ]

[]

[]

[ "excel", "loops", "openpyxl", "python" ]

[]

[]

[ "from your question, I understand that you need to create networks that compared the input and segmentations. There are techniques to create objects segmentation by auto-encoder, see the example images divided by color shades and background you can determine initial image components.\nFor the segmentation part you can apply networks or object segmentation where you can merged it back into a picture with labels and process for image recognition or other tasks. In the example is simply masking with regions and shadows.\nSample: My simple implementation is not too difficult than multi-head input networks categorize tasks, shadow images and regions is one label can be significant.\nimport os\nfrom os.path import exists\n\nimport tensorflow as tf\nimport tensorflow_io as tfio\n\nimport matplotlib.pyplot as plt\n\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n: Variables\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\nIMG_SHAPE = ( 32, 32, 1 ) \ntsk1_CLASSES_NUM = 2\ninitial_epochs = 5\n\nPATH = os.path.join('F:\\\\datasets\\\\downloads\\\\Actors_jpg\\\\train\\\\Pikaploy', '*.jpg')\nPATH_2 = os.path.join('F:\\\\datasets\\\\downloads\\\\Actors_jpg\\\\train\\\\Candidt Kibt', '*.jpg')\nfiles = tf.data.Dataset.list_files(PATH)\nfiles_2 = tf.data.Dataset.list_files(PATH_2)\n\nlist_file = []\nlist_file_actual = []\nlist_label = []\nlist_label_actual = [ 'Pikaploy', 'Pikaploy', 'Pikaploy', 'Pikaploy', 'Pikaploy', 'Candidt Kibt', 'Candidt Kibt', 'Candidt Kibt', 'Candidt Kibt', 'Candidt Kibt' ]\nfor file in files.take(5):\n image = tf.io.read_file( file )\n image = tf.io.decode_jpeg( image, channels=0, ratio=1, fancy_upscaling=True, try_recover_truncated=False, acceptable_fraction=1, dct_method='INTEGER_FAST', name=\"decode_jpeg\" )\n \n list_file_actual.append(image)\n image = tf.image.resize(image, [32,32], method='nearest')\n \n \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n : Image Masking\n \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n n_horizon = 64\n n_features = 16\n masking_layer = tf.keras.layers.Masking(mask_value=50, input_shape=(n_horizon, n_features))\n image = tf.constant( masking_layer(image)[:,:,0], shape=(32, 32, 1) )\n \n list_file.append(image)\n \n temp = tf.ones([ 20, 20 ]).numpy() * 0\n list_label.append( temp )\n \nfor file in files_2.take(5):\n image = tf.io.read_file( file )\n image = tf.io.decode_jpeg( image, channels=0, ratio=1, fancy_upscaling=True, try_recover_truncated=False, acceptable_fraction=1, dct_method='INTEGER_FAST', name=\"decode_jpeg\" )\n \n list_file_actual.append(image)\n image = tf.image.resize(image, [32,32], method='nearest')\n \n \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n : Image Masking\n \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n n_horizon = 64\n n_features = 16\n masking_layer = tf.keras.layers.Masking(mask_value=50, input_shape=(n_horizon, n_features))\n image = tf.constant( masking_layer(image)[:,:,0], shape=(32, 32, 1) )\n \n list_file.append(image)\n temp = tf.ones([ 20, 20 ]).numpy() * 9\n list_label.append( temp )\n \ncheckpoint_path = \"F:\\\\models\\\\checkpoint\\\\\" + os.path.basename(__file__).split('.')[0] + \"\\\\TF_DataSets_01.h5\"\ncheckpoint_dir = os.path.dirname(checkpoint_path)\n\nif not exists(checkpoint_dir) : \n os.mkdir(checkpoint_dir)\n print(\"Create directory: \" + checkpoint_dir)\n \n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n: Definition / Class\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\ndef build_model():\n\n branch_A_input = tf.keras.Input(shape=IMG_SHAPE)\n branch_A_rescale = tf.keras.layers.experimental.preprocessing.Rescaling(1./127.5, offset= -1)(branch_A_input)\n branch_A = tf.keras.layers.Dropout(0.3)(branch_A_rescale)\n branch_A = tf.keras.layers.Conv2D(filters = 128, kernel_size = 13, activation= 'swish', name = \"base_conv_A\")(branch_A)\n branch_A = tf.keras.layers.BatchNormalization(name = \"base_batch_normalization_A\")(branch_A)\n branch_A = tf.keras.Model(inputs=branch_A_input, outputs = branch_A)\n\n\n branch_B_input = tf.keras.Input(shape=IMG_SHAPE)\n branch_B_rescale = tf.keras.layers.experimental.preprocessing.Rescaling(1./127.5, offset= -1)(branch_B_input)\n branch_B = tf.keras.layers.Dropout(0.3)(branch_B_rescale)\n branch_B = tf.keras.layers.Conv2D(filters = 128, kernel_size = 13, activation= 'swish', name = \"base_conv_B\")(branch_B)\n branch_B = tf.keras.layers.BatchNormalization(name = \"base_batch_normalization_B\")(branch_B)\n branch_B = tf.keras.Model(inputs=branch_B_input, outputs = branch_B)\n\n merge = tf.keras.layers.Concatenate()([branch_A.output, branch_B.output])\n\n output_A = tf.keras.layers.Dense(tsk1_CLASSES_NUM, activation='softmax', name='4cls')(merge)\n output_B = tf.keras.layers.Dense(1, name='2cls')(merge)\n\n model = tf.keras.Model(inputs = [branch_A.input, branch_B.input] , outputs = [output_A, output_B], name=\"multi_task_model\")\n\n optimizer = tf.keras.optimizers.get('adam')\n optimizer.learning_rate = 0.001\n losses = {'4cls': tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),\n '2cls': tf.keras.losses.BinaryCrossentropy(from_logits=True)}\n\n mtrcs = {\n \"4cls\": 'accuracy',\n \"2cls\": 'accuracy',\n }\n model.compile(optimizer=optimizer, loss= losses, metrics=mtrcs)\n\n return model\n \n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n: DataSet / Input\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\nlist_label = tf.constant( list_label, shape=( 10, 20, 20, 1 ) )\nlist_file = tf.constant( tf.cast( list_file, dtype=tf.int64), shape=( 10, 32, 32, 1 ) )\n\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n: Task\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\nmodel = build_model()\nhistory = model.fit( [list_file, list_file], list_label, epochs=initial_epochs)\n\ninput( '...' )\n\nData preparation: Image masking background\n\nOutput:\n2022-12-02 09:39:30.019022: I tensorflow/stream_executor/cuda/cuda_dnn.cc:368] Loaded cuDNN version 8100\n1/1 [==============================] - ETA: 0s - loss: nan - 4cls_loss: nan - 2cls_loss: 0.7376 - 4cls_accuracy: 0.2632 1/1 [==============================] - 2s 2s/step - loss: nan - 4cls_loss: nan - 2cls_loss: 0.7376 - 4cls_accuracy: 0.2632 - 2cls_accuracy: 0.3570\nEpoch 2/5\n1/1 [==============================] - ETA: 0s - loss: nan - 4cls_loss: nan - 2cls_loss: nan - 4cls_accuracy: 0.5000 - 21/1 [==============================] - 0s 11ms/step - loss: nan - 4cls_loss: nan - 2cls_loss: nan - 4cls_accuracy: 0.5000 - 2cls_accuracy: 0.5000\n\n" ]

[ -2 ]

[ "conv_neural_network", "deep_learning", "neural_network", "python", "tensorflow" ]

[ "You should have different configurations for your app, depending if you are local / in production / executing unit tests. One configuration you can set is\nWTF_CSRF_ENABLED = False\n\nSee flask-wtforms documentation.\n", "Using py.test and a conftest.py recommended by Delightful testing with pytest and SQLAlchemy, here's a test that confirms the added category.\ndef test_add_category_post(app, session):\n \"\"\"Does add category post a new category?\"\"\"\n TESTEMAIL = \"[email protected]\"\n TESTUSER = \"Joe Test\"\n user = Users.query.filter(Users.email==TESTEMAIL).first()\n category = Category(name=\"Added Category\", users_id=user.id)\n form = CategoryForm(formdata=None, obj=category)\n with app.test_client() as c:\n with c.session_transaction() as sess:\n sess['email'] = TESTEMAIL\n sess['username'] = TESTUSER \n sess['users_id'] = user.id\n response = c.post(\n '/category/add', data=form.data, follow_redirects=True)\n assert response.status_code == 200\n added_category = Category.query.filter(\n Category.name==\"Added Category\").first()\n assert added_category\n session.delete(added_category)\n session.commit()\n\nNote that the new category is assigned to a variable and then used to create a form. The form's data is used in the post. \n", "Working on the comments of @mas I got to this solution which worked for me:\ntopic_name = \"test_topic\"\nresponse = fixt_client_logged_in.post('/create', data={\"value\":topic_name}, follow_redirects=True)\n\nI am using this form class:\nclass SimpleSubmitForm(FlaskForm):\n value = StringField(validators=[DataRequired()])\n submit = SubmitField()\n\nIn this html file:\n{{form.hidden_tag()}}\n\n{{form.value.label(\"Topic\", class=\"form-label\")}}\n{{form.value(value=topic_name, class=\"form-control\")}}\n<br/>\n{{form.submit(value=\"submit\", class=\"btn btn-primary\")}}\n\nNote that I am using the hidden_tag for the CSRF security, however when testing I have this extra line that de-activates it:\napp.config['WTF_CSRF_ENABLED']=False\n\nI have no idea how it actually works under the hood but my hypothesis is this: The wtform FlaskForm object looks at the \"data\" attribute of the request, which should be a dict. It then looks for keys in that dict that have the same name as its attributes. If it finds a key with the same name then it assigns that value to its attribute.\n" ]

[ 5, 2, 0 ]

[]

[]

[ "flask_wtforms", "python", "python_2.7", "wtforms" ]

[ "First you need to create the tree from your dict of \"relationship\" data, there are many ways to do this but here's an example:\nfrom anytree import Node\n\nnodes = {}\nfor k, v in data.items():\n nk = nodes[k] = nodes.get(k) or Node(k)\n nv = nodes[v] = nodes.get(v) or Node(v)\n nk.parent = nv\n\nNow you need to identify the root node, in your case it is the unique node which has no parent (Udo).\n[root] = [n for n in nodes.values() if n.parent is None]\n\n# Or, if you don't need the validation that there is a unique root:\nroot = <any node>\nwhile root.parent is not None:\n root = root.parent\n\n# Or, if you already knew the root node's name then just:\nroot = nodes[root_name]\n\nOnce you have the root node, you can render the tree like this:\n>>> from anytree import RenderTree\n>>> print(RenderTree(root).by_attr())\nUdo\n├── Marc\n│ └── Lian\n└── Dan\n ├── Jet\n ├── Jan\n └── Joe\n\nThe anytree API is richer than rich, so it's a little more complicated with rich.tree:\n>>> import rich.tree\n>>> nodes = {}\n... for k, v in data.items():\n... nk = nodes[k] = nodes.get(k) or rich.tree.Tree(k)\n... nv = nodes[v] = nodes.get(v) or rich.tree.Tree(v)\n... nv.children.append(nk)\n... nk.parent = nv\n... \n>>> [root] = [n for n in nodes.values() if getattr(n, \"parent\", None) is None]\n>>> rich.print(root)\nUdo\n├── Marc\n│ └── Lian\n└── Dan\n ├── Jet\n ├── Jan\n └── Joe\n\n" ]

[ 1 ]

[]

[]

[ "anytree", "python", "rich", "treelib" ]