diff --git "a/5355.jsonl" "b/5355.jsonl" new file mode 100644--- /dev/null +++ "b/5355.jsonl" @@ -0,0 +1,36 @@ +{"seq_id":"86055395","text":"from mysql.connector import MySQLConnection, Error\nfrom python_mysql_dbconfig import read_db_config\nimport json\nimport sys\nimport os\nimport array as arr\nimport ast\nimport subprocess\n\ndef show_config(config):\n try:\n dbconfig = read_db_config()\n conn = MySQLConnection(**dbconfig)\n cursor = conn.cursor()\n show_conf = \"select * from directory_configurations where `conf` = %s\" \n cursor.execute(show_conf, (config,))\n row_headers=[x[0] for x in cursor.description]\n rows = cursor.fetchall()\n json_data=[]\n\n if cursor.rowcount == 0:\n print('fail#{\"error\":\"No entry\"}', end='')\n else:\n for row in rows:\n json_data.append(dict(zip(row_headers,row)))\n\n print(\"OK#\" + json.dumps(json_data[0]))\n\n except Error as e:\n print('fail#[\"Duplicate entry\"]', end='')\n \n finally:\n cursor.close()\n conn.close()\n \ntry:\n if sys.argv[1]:\n passwd = sys.argv[1]\n basedn = sys.argv[2]\n config = sys.argv[3]\n\n show_config(config)\n# my_json_string = json.dumps(attributes_id)\n# print(\"OK#\" + attributes_id, end='')\nexcept:\n print('fail#[]', end='')\n","sub_path":"db/eventlog_showConfig.py","file_name":"eventlog_showConfig.py","file_ext":"py","file_size_in_byte":1218,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"505056805","text":"import os\nimport sqlite3\n\nfrom flask import Flask, flash, redirect, render_template, request, session\nfrom flask_session import Session\nfrom tempfile import mkdtemp\nfrom werkzeug.exceptions import default_exceptions, HTTPException, InternalServerError\nfrom werkzeug.security import check_password_hash, generate_password_hash\nfrom collections import defaultdict\n\nfrom helpers import login_required, lookup, usd\n\n# Configure application\napp = Flask(__name__)\n\n# Ensure templates are auto-reloaded\napp.config[\"TEMPLATES_AUTO_RELOAD\"] = True\n\n\n# Ensure responses aren't cached\n@app.after_request\ndef after_request(response):\n response.headers[\"Cache-Control\"] = \"no-cache, no-store, must-revalidate\"\n response.headers[\"Expires\"] = 0\n response.headers[\"Pragma\"] = \"no-cache\"\n return response\n\n\n# Custom filter\napp.jinja_env.filters[\"usd\"] = usd\n\n# Configure session to use filesystem (instead of signed cookies)\n# app.config[\"SESSION_FILE_DIR\"] = mkdtemp()\napp.config[\"SESSION_PERMANENT\"] = False\napp.config[\"SESSION_TYPE\"] = \"filesystem\"\nSession(app)\n\n# Make sure API key is set\nif not os.environ.get(\"API_KEY\"):\n raise RuntimeError(\"API_KEY not set\")\n\n\n@app.route(\"/\")\n@login_required\ndef index():\n \"\"\"Show portfolio of stocks\"\"\"\n\n user_id = session[\"user_id\"] # store current user's id\n\n # Connect to database\n con = sqlite3.connect(\"finance.db\")\n cur = con.cursor()\n\n # query that returns list items, each which represents a row in the table displayed for the user\n cur.execute(\"\"\"SELECT SUM(shares) AS shares, company, SUM(total_amount) AS total_amount FROM transactions \n WHERE user_id = :id AND type = 'purchase' GROUP BY user_id, company\"\"\", {'id': user_id})\n desc = cur.description\n column_names = [col[0] for col in desc]\n user_purchase_rows = [dict(zip(column_names, row)) \n for row in cur.fetchall()]\n cur.execute(\"\"\"SELECT SUM(shares) AS shares, company, SUM(total_amount) AS total_amount FROM transactions \n WHERE user_id = :id AND type = 'sale' GROUP BY user_id, company\"\"\", {'id': user_id})\n desc = cur.description\n column_names = [col[0] for col in desc]\n user_sale_rows = [dict(zip(column_names, row)) \n for row in cur.fetchall()]\n\n # send user to page to buy stocks\n if len(user_purchase_rows) == 0:\n return redirect(\"/buy\")\n\n # add other necessary data to display to each dictionary in the list user_rows\n companies_qty = 0\n\n # populate dict of purchases with the right values\n for data_row in user_purchase_rows:\n symbol = data_row[\"company\"]\n price = float(lookup(symbol)[\"price\"])\n stock_value = price * data_row[\"shares\"]\n data_row[\"stock_value\"] = stock_value\n companies_qty += 1 # increment number of distinct companies where a purchased occured by the user\n\n # get the user's available cash\n cur.execute(\"SELECT cash FROM users WHERE id = :id\", {'id': user_id})\n desc = cur.description\n row = cur.fetchone()\n cash_query = [dict(zip([c[0] for c in desc], row))]\n cash = usd(cash_query[0][\"cash\"])\n account_value = 0 # initialize variable to store the total account value\n\n # initialize variable to store user information, using a dict for each company a purchase was made,\n # each company dict will have a dict to store info specific to that company's shares\n user_rows = defaultdict(dict)\n\n # loop which calculates and stores data into the user_rows variable\n for i in range(companies_qty):\n for data_row in user_purchase_rows:\n user_rows[i][\"symbol\"] = user_purchase_rows[i][\"company\"] # symbol\n if len(user_sale_rows) == 0 or i > len(user_sale_rows) - 1: # if no stock sales were recorded for the user for this particular company\n user_rows[i][\"shares\"] = user_purchase_rows[i][\"shares\"] # shares\n user_rows[i][\"value\"] = user_purchase_rows[i][\"stock_value\"] # value of stock the user owns\n else:\n cur.execute(\"SELECT SUM(shares) AS shares FROM transactions WHERE company = :company AND type = 'sale'\", {'company': user_rows[i][\"symbol\"]})\n desc = cur.description\n column_names = [col[0] for col in desc]\n this_shares_sales_query = [dict(zip(column_names, row)) \n for row in cur.fetchall()]\n this_shares_sales = this_shares_sales_query[0][\"shares\"]\n user_rows[i][\"shares\"] = user_purchase_rows[i][\"shares\"] - this_shares_sales # shares\n share_price = lookup(user_rows[i][\"symbol\"])[\"price\"]\n user_rows[i][\"value\"] = user_rows[i][\"shares\"] * share_price # value of stock the user owns\n account_value += user_rows[i][\"value\"] # increment the total account value by the value of shares the user owns from this company\n user_rows[i][\"value\"] = usd(user_rows[i][\"value\"]) # convert to $ format\n symbol = user_rows[i][\"symbol\"]\n price = float(lookup(symbol)[\"price\"]) # get price of a share\n user_rows[i][\"price\"] = usd(price) # add price in $ format to dict\n\n # add user's available cash to the total account value and convert it to a $ format\n account_value += cash_query[0][\"cash\"]\n account_value = usd(account_value)\n\n # get the number of companies the user purchased a stock from for html iteration\n user_rows_length = len(user_rows)\n\n # close database connection\n con.close()\n\n return render_template(\"index.html\", user_rows=user_rows, user_rows_length=user_rows_length, cash=cash, account_value=account_value)\n\n\n@app.route(\"/buy\", methods=[\"GET\", \"POST\"])\n@login_required\ndef buy():\n \"\"\"Buy shares of stock\"\"\"\n if request.method == \"POST\":\n # handles # of shares field not being a positive integer\n num_shares = request.form.get(\"shares\")\n if not num_shares.isnumeric():\n return render_template(\"error.html\", errmsg=\"# of shares has to be an integer\", errcode=409)\n\n user_id = session[\"user_id\"] # store the user's id\n selected_symbol = request.form.get(\"symbol\") # store the inputted symbol\n price = lookup(selected_symbol)[\"price\"] # price of the stock to buy\n\n # query to create the table to store purchases\n # CREATE TABLE transactions (transaction_id INTEGER UNIQUE, user_id INTEGER NOT NULL, type VARCHAR(10), shares INTEGER NOT NULL,\n # company CHAR(4) NOT NULL, total_amount NUMERIC, date TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,\n # PRIMARY KEY(transaction_id), FOREIGN KEY (user_id) REFERENCES users (id));\n # CREATE TABLE users (id INTEGER, username TEXT NOT NULL, hash TEXT NOT NULL, cash NUMERIC NOT NULL DEFAULT 10000.00, PRIMARY KEY(id));\n # Queries ran to create indexes forsignificant columns\n # CREATE INDEX type ON transactions (type);\n # CREATE INDEX shares ON transactions (shares);\n # CREATE INDEX company ON transactions (company);\n # CREATE INDEX total_amount ON transactions (total_amount);\n\n # Connect to database\n con = sqlite3.connect(\"finance.db\")\n cur = con.cursor()\n\n cur.execute(\"SELECT cash FROM users WHERE id = :id\", {'id': user_id}) # store the cash in the current user's account\n desc = cur.description\n row = cur.fetchone()\n user_cash = [dict(zip([c[0] for c in desc], row))]\n user_balance = user_cash[0][\"cash\"]\n transaction_amount = float(price) * int(num_shares) # store the total value of shares being bought\n if user_balance < transaction_amount:\n return render_template(\"error.html\", errmsg=\"Not enough funds\", errcode=403)\n # add row for the purchase in the purchases table\n cur.execute(\"INSERT INTO transactions (user_id, type, shares, company, total_amount) VALUES (?, ?, ?, ?, ?)\", (user_id, \"purchase\", num_shares, selected_symbol, transaction_amount))\n con.commit()\n # subtract the transaction amount from the user's cash\n new_balance = user_balance - transaction_amount # user's balance after the transaction is processed\n cur.execute(\"UPDATE users SET cash = ? WHERE id = ?\", (new_balance, user_id))\n con.commit()\n\n # close database connection\n con.close()\n\n flash(\"Successful transaction!\")\n\n return redirect(\"/\")\n\n\n return render_template(\"buy.html\")\n\n\n@app.route(\"/history\")\n@login_required\ndef history():\n \"\"\"Show history of transactions\"\"\"\n\n user_id = session[\"user_id\"] # store current user's id\n\n # Connect to database\n con = sqlite3.connect(\"finance.db\")\n cur = con.cursor()\n\n # store all of user's past transactions in a variable\n cur.execute(\"SELECT type, company, (total_amount / shares) AS transaction_price, shares, date(date) AS date, strftime('%H:%M:%S', date) AS time FROM transactions WHERE user_id = ?\", (user_id,))\n desc = cur.description\n column_names = [col[0] for col in desc]\n transactions = [dict(zip(column_names, row)) \n for row in cur.fetchall()]\n\n # iterate through transactions to update all \"transaction_price\" fields to be formatted in $\n for transaction in transactions:\n transaction[\"transaction_price\"] = usd(transaction[\"transaction_price\"])\n\n # close database connection\n con.close()\n\n return render_template(\"history.html\", transactions=transactions)\n\n\n@app.route(\"/login\", methods=[\"GET\", \"POST\"])\ndef login():\n \"\"\"Log user in\"\"\"\n\n # Forget any user_id\n session.clear()\n\n # Connect to database\n con = sqlite3.connect(\"finance.db\")\n cur = con.cursor()\n\n # User reached route via POST (as by submitting a form via POST)\n if request.method == \"POST\":\n\n # Ensure username was submitted\n if not request.form.get(\"username\"):\n return render_template(\"error.html\", errmsg=\"must provide username\", errcode=403)\n\n # Ensure password was submitted\n elif not request.form.get(\"password\"):\n return render_template(\"error.html\", errmsg=\"must provide password\", errcode=403)\n\n # Query database for username\n cur.execute(\"SELECT * FROM users WHERE username = ?\", (request.form.get(\"username\"),))\n rows_tuple = cur.fetchone()\n desc = cur.description\n rows = [dict(zip([c[0] for c in desc], rows_tuple))]\n\n # Ensure username exists and password is correct\n if len(rows) != 1 or not check_password_hash(rows[0][\"hash\"], request.form.get(\"password\")):\n return render_template(\"error.html\", errmsg=\"invalid username and/or password\", errcode=403)\n\n # Remember which user has logged in\n session[\"user_id\"] = rows[0][\"id\"]\n\n flash(\"Welcome!\")\n\n # close database connection\n con.close()\n\n # Redirect user to home page\n return redirect(\"/\")\n\n # User reached route via GET (as by clicking a link or via redirect)\n else:\n return render_template(\"login.html\")\n\n\n@app.route(\"/logout\")\ndef logout():\n \"\"\"Log user out\"\"\"\n\n # Forget any user_id\n session.clear()\n\n # Redirect user to login form\n return redirect(\"/\")\n\n\n@app.route(\"/quote\", methods=[\"GET\", \"POST\"])\n@login_required\ndef quote():\n \"\"\"Get stock quote.\"\"\"\n if request.method == \"POST\":\n data = lookup(request.form.get(\"symbol\"))\n return render_template(\"quoted.html\", data=data)\n return render_template(\"quote.html\")\n\n\n@app.route(\"/register\", methods=[\"GET\", \"POST\"])\ndef register():\n \"\"\"Register user\"\"\"\n if request.method == \"POST\":\n\n # Connect to database\n con = sqlite3.connect(\"finance.db\")\n cur = con.cursor()\n\n # handles username existing\n cur.execute(\"SELECT username FROM users\")\n desc = cur.description\n column_names = [col[0] for col in desc]\n usernames = [dict(zip(column_names, row)) \n for row in cur.fetchall()]\n for username in usernames:\n if username == request.form.get(\"username\"):\n return render_template(\"error.html\", errmsg=\"username already exists\", errcode=409)\n # handles username or password fields being blank\n if request.form.get(\"username\") == \"\" or request.form.get(\"password\") == \"\" or request.form.get(\"confirmation\") == \"\":\n return render_template(\"error.html\", errmsg=\"input cannot be blank\", errcode=411)\n # handles password and confirmation not being the same\n elif request.form.get(\"password\") != request.form.get(\"confirmation\"):\n return render_template(\"error.html\", errmsg=\"password and confirmation do not match\", errcode=409)\n # succesful registering\n else:\n hashed_password = generate_password_hash(request.form.get(\"password\")) # hash password\n cur.execute(\"INSERT INTO users (username, hash) VALUES (?, ?)\", (request.form.get(\"username\"), hashed_password)) # add to database\n con.commit()\n flash(\"Successfully logged in!\")\n # close database connection\n con.close()\n return login() #login newly registered user\n\n return render_template(\"register.html\")\n\n\n@app.route(\"/sell\", methods=[\"GET\", \"POST\"])\n@login_required\ndef sell():\n \"\"\"Sell shares of stock\"\"\"\n\n user_id = session[\"user_id\"] # store current user's id\n\n # Connect to database\n con = sqlite3.connect(\"finance.db\")\n cur = con.cursor()\n\n cur.execute(\"SELECT company FROM transactions WHERE user_id = ? GROUP BY company\", (user_id,)) # store symbol of each stock owned by the user\n desc = cur.description\n column_names = [col[0] for col in desc]\n owned_symbols = [dict(zip(column_names, row)) \n for row in cur.fetchall()]\n # handles POST request\n if request.method == \"POST\":\n symbol = request.form.get(\"symbol\")\n if symbol == None:\n return render_template(\"error.html\", errmsg=\"Symbol input is invalid\", errcode=409)\n else:\n pass\n shares_to_sell = int(request.form.get(\"shares\"))\n # get user's shares\n cur.execute(\"SELECT SUM(shares) AS shares FROM transactions WHERE user_id = ? AND type = 'purchase' AND company = ?\", (user_id, symbol))\n desc = cur.description\n column_names = [col[0] for col in desc]\n shares_purchased_query = [dict(zip(column_names, row)) \n for row in cur.fetchall()]\n shares_purchased = shares_purchased_query[0][\"shares\"]\n cur.execute(\"SELECT SUM(shares) AS shares FROM transactions WHERE user_id = ? AND type = 'sale' AND company = ?\", (user_id, symbol))\n desc = cur.description\n column_names = [col[0] for col in desc]\n shares_sold_query = [dict(zip(column_names, row)) \n for row in cur.fetchall()]\n shares_sold = shares_sold_query[0][\"shares\"]\n if shares_sold == None:\n shares_owned = shares_purchased\n else:\n shares_owned = shares_purchased - shares_sold\n\n # if user doesn't have enough shares, return apology with 409\n if shares_to_sell > shares_owned:\n return render_template(\"error.html\", errmsg=\"Not enough shares\", errcode=409)\n\n # calculate transaction amount and store it in total_amount\n price_per_share = lookup(symbol)[\"price\"]\n total_amount = round(price_per_share * shares_to_sell, 2)\n\n # INSERT INTO transactions\n cur.execute(\"INSERT INTO transactions (user_id, type, shares, company, total_amount) VALUES (?, ?, ?, ?, ?)\", (user_id, 'sale', shares_to_sell, symbol, total_amount))\n con.commit()\n # UPDATE user's cash\n cur.execute(\"UPDATE users SET cash = (SELECT cash FROM users WHERE id = ?) + ? WHERE id = ?\", (user_id, total_amount, user_id))\n con.commit()\n\n # close database connection\n con.close()\n\n flash(\"Successful transaction!\")\n\n return redirect(\"/\")\n\n return render_template(\"sell.html\", symbols=owned_symbols)\n\n\ndef errorhandler(e):\n \"\"\"Handle error\"\"\"\n if not isinstance(e, HTTPException):\n e = InternalServerError()\n return render_template(\"error.html\", errmsg=e.name, errcode=e.code)\n\n\n# Listen for errors\nfor code in default_exceptions:\n app.errorhandler(code)(errorhandler)\n\n\nif __name__ == '__main__':\n app.run(debug=True)\n\n\n\n# Query returning multiple rows\n # cur.execute(\"SELECT * FROM users\")\n # desc = cur.description\n # column_names = [col[0] for col in desc]\n # dataDict = [dict(zip(column_names, row)) \n # for row in cur.fetchall()]\n \n# Query returning one row\n # soly = request.form.get(\"username\")\n # cur.execute(\"SELECT * FROM users WHERE username = :id\", {'id': soly})\n # desc = cur.description\n # row = cur.fetchone()\n # rowDict = [dict(zip([c[0] for c in desc], row))]\n","sub_path":"app.py","file_name":"app.py","file_ext":"py","file_size_in_byte":16876,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"595611529","text":"from stable_baselines3.common.torch_layers import BaseFeaturesExtractor\nimport gym\nimport torch as th\n\nclass EmbeddinsFeatureExtractor(BaseFeaturesExtractor):\n \"\"\"\n :param observation_space: (gym.Space)\n :param features_dim: (int) Number of features extracted.\n This corresponds to the number of unit for the last layer.\n \"\"\"\n\n def __init__(self, observation_space: gym.spaces.Box, EMBEDDING_DIM=2, features_dim: int = 256, ):\n super(EmbeddinsFeatureExtractor, self).__init__(observation_space, features_dim)\n # We assume CxHxW images (channels first)\n # Re-ordering will be done by pre-preprocessing or wrapper\n self.base_embeding = th.nn.Embedding(4, EMBEDDING_DIM)\n\n self.linear_1 = th.nn.Sequential(th.nn.Linear(EMBEDDING_DIM * observation_space.shape[0], features_dim), th.nn.ReLU())\n\n def forward(self, observations: th.Tensor) -> th.Tensor:\n \n return self.linear_1(self.base_embeding(observations.int()).flatten(start_dim=1))","sub_path":"models.py","file_name":"models.py","file_ext":"py","file_size_in_byte":1006,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"231776523","text":"import numpy as np\nimport random\n\nprint(\"------------- Matriz Simetrica -------------\")\nx = int(input(\"Ordem da matriz: \"))\ny=x*x\n\nmat = np.arange(y).reshape(x,x)\n\nfor i in range(x):\n\tfor j in range(x):\n\t\tmat[i][j] = mat[j][i] = random.randint(0,9)\n\t\t\nprint()\nfor i in range(x):\n\tfor j in range(x):\n\t\tprint(mat[i][j], end=\" \")\n\tprint()\n","sub_path":"1c.py","file_name":"1c.py","file_ext":"py","file_size_in_byte":336,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"24215269","text":"\nimport gym\n\nimport logging\nimport os\nimport numpy as np\nimport neat\nimport pickle\n\nepisodes = 2\n\n\ndef eval_genome(genome, config):\n # TODO can we actually get away with only one env? it seems like they'd all step on each other\n env = gym.make('Acrobot-v1')\n scale = env.observation_space.high\n net = neat.nn.FeedForwardNetwork.create(genome, config)\n\n fitnesses = []\n\n for runs in range(episodes):\n fitness = 0.0\n\n observation = env.reset()\n\n # run until gym says to stop\n while True:\n scaled_input = observation / scale\n\n output = net.activate(scaled_input)\n action = np.argmax(output)\n observation, reward, done, info = env.step(action)\n fitness += reward\n\n if done:\n break\n\n fitnesses.append(fitness)\n\n return sum(fitnesses) / len(fitnesses)\n\n\ndef eval_genomes(genomes, config):\n for genome_id, genome in genomes:\n genome.fitness = eval_genome(genome, config)\n\n\ndef run():\n # Load the config file, which is assumed to live in\n # the same directory as this script.\n local_dir = os.path.dirname(__file__)\n config_path = os.path.join(local_dir, 'config-feedforward-acrobot')\n config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,\n neat.DefaultSpeciesSet, neat.DefaultStagnation,\n config_path)\n\n pop = neat.Population(config)\n stats = neat.StatisticsReporter()\n pop.add_reporter(stats)\n pop.add_reporter(neat.StdOutReporter(True))\n pop.add_reporter(neat.Checkpointer(5))\n\n pe = neat.ParallelEvaluator(8, eval_genome)\n winner = pop.run(pe.evaluate, 200)\n\n # winner = pop.run(eval_genomes, 300)\n\n # Save the winner.\n with open('winner-feedforward', 'wb') as f:\n pickle.dump(winner, f)\n\n print(winner)\n\n net = neat.nn.FeedForwardNetwork.create(winner, config)\n\n visualize_winner(net)\n\n\ndef visualize_winner(net):\n fitness = 0.0\n env = gym.make('Acrobot-v1')\n scale = env.observation_space.high\n observation = env.reset()\n while True:\n scaled_input = observation / scale\n env.render()\n output = net.activate(scaled_input)\n action = np.argmax(output)\n\n observation, reward, done, info = env.step(action)\n fitness += reward\n\n if done:\n break\n print(\"Fitness\", fitness)\n\n\nif __name__ == '__main__':\n # quiet\n logger = logging.getLogger('gym.envs.registration')\n logger.setLevel(logging.ERROR)\n\n train = True\n\n if train:\n run()\n else:\n with open('winner-feedforward', 'rb') as f:\n c = pickle.load(f)\n\n print('Loaded genome:')\n print(c)\n\n local_dir = os.path.dirname(__file__)\n config_path = os.path.join(local_dir, 'config-feedforward-acrobot')\n config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,\n neat.DefaultSpeciesSet, neat.DefaultStagnation,\n config_path)\n\n net = neat.nn.FeedForwardNetwork.create(c, config)\n\n visualize_winner(net)\n","sub_path":"evolve_openai_acrobot.py","file_name":"evolve_openai_acrobot.py","file_ext":"py","file_size_in_byte":3140,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"487329205","text":"import asyncio\nimport binascii\nimport collections\nimport mimetypes\nimport cgi\nimport http.cookies\nimport io\nimport json\nimport re\nimport os\n\nfrom urllib.parse import urlsplit, parse_qsl, unquote, urlencode\n\nfrom .abc import AbstractRouter, AbstractMatchInfo\nfrom .multidict import (CaseInsensitiveMultiDict,\n CaseInsensitiveMutableMultiDict,\n MultiDict,\n MutableMultiDict)\nfrom .protocol import Response as ResponseImpl, HttpVersion, HttpVersion11\nfrom .server import ServerHttpProtocol\nfrom .streams import EOF_MARKER\n\n\n__all__ = [\n 'Application',\n 'HttpVersion',\n 'Request',\n 'StreamResponse',\n 'Response',\n 'UrlDispatcher',\n 'UrlMappingMatchInfo',\n 'HTTPException',\n 'HTTPError',\n 'HTTPRedirection',\n 'HTTPSuccessful',\n 'HTTPOk',\n 'HTTPCreated',\n 'HTTPAccepted',\n 'HTTPNonAuthoritativeInformation',\n 'HTTPNoContent',\n 'HTTPResetContent',\n 'HTTPPartialContent',\n 'HTTPMultipleChoices',\n 'HTTPMovedPermanently',\n 'HTTPFound',\n 'HTTPSeeOther',\n 'HTTPNotModified',\n 'HTTPUseProxy',\n 'HTTPTemporaryRedirect',\n 'HTTPClientError',\n 'HTTPBadRequest',\n 'HTTPUnauthorized',\n 'HTTPPaymentRequired',\n 'HTTPForbidden',\n 'HTTPNotFound',\n 'HTTPMethodNotAllowed',\n 'HTTPNotAcceptable',\n 'HTTPProxyAuthenticationRequired',\n 'HTTPRequestTimeout',\n 'HTTPConflict',\n 'HTTPGone',\n 'HTTPLengthRequired',\n 'HTTPPreconditionFailed',\n 'HTTPRequestEntityTooLarge',\n 'HTTPRequestURITooLong',\n 'HTTPUnsupportedMediaType',\n 'HTTPRequestRangeNotSatisfiable',\n 'HTTPExpectationFailed',\n 'HTTPServerError',\n 'HTTPInternalServerError',\n 'HTTPNotImplemented',\n 'HTTPBadGateway',\n 'HTTPServiceUnavailable',\n 'HTTPGatewayTimeout',\n 'HTTPVersionNotSupported',\n ]\n\n\nsentinel = object()\n\n\nclass HeadersMixin:\n\n _content_type = None\n _content_dict = None\n _stored_content_type = sentinel\n\n def _parse_content_type(self, raw):\n self._stored_content_type = raw\n if raw is None:\n # default value according to RFC 2616\n self._content_type = 'application/octet-stream'\n self._content_dict = {}\n else:\n self._content_type, self._content_dict = cgi.parse_header(raw)\n\n @property\n def content_type(self):\n \"\"\"The value of content part for Content-Type HTTP header.\"\"\"\n raw = self.headers.get('Content-Type')\n if self._stored_content_type != raw:\n self._parse_content_type(raw)\n return self._content_type\n\n @property\n def charset(self):\n \"\"\"The value of charset part for Content-Type HTTP header.\"\"\"\n # Assumes that charset is UTF8 if not specified\n raw = self.headers.get('Content-Type')\n if self._stored_content_type != raw:\n self._parse_content_type(raw)\n return self._content_dict.get('charset')\n\n @property\n def content_length(self):\n \"\"\"The value of Content-Length HTTP header.\"\"\"\n l = self.headers.get('Content-Length')\n if l is None:\n return None\n else:\n return int(l)\n\n\nFileField = collections.namedtuple('Field', 'name filename file content_type')\n\n\n############################################################\n# HTTP Request\n############################################################\n\n\nclass Request(HeadersMixin):\n\n def __init__(self, app, message, payload, transport, writer,\n keep_alive_timeout):\n self._app = app\n self._version = message.version\n self._transport = transport\n self._writer = writer\n self._method = message.method\n self._host = message.headers.get('HOST')\n path = unquote(message.path)\n self._path_qs = path\n res = urlsplit(path)\n self._path = res.path\n self._query_string = res.query\n self._get = None\n self._post = None\n self._post_files_cache = None\n self._headers = CaseInsensitiveMultiDict._from_uppercase_multidict(\n message.headers)\n\n if self._version < HttpVersion11:\n self._keep_alive = False\n elif message.should_close:\n self._keep_alive = False\n else:\n self._keep_alive = bool(keep_alive_timeout)\n\n # matchdict, route_name, handler\n # or information about traversal lookup\n self._match_info = None # initialized after route resolving\n\n self._payload = payload\n self._cookies = None\n\n @property\n def method(self):\n \"\"\"Read only property for getting HTTP method.\n\n The value is upper-cased str like 'GET', 'POST', 'PUT' etc.\n \"\"\"\n return self._method\n\n @property\n def version(self):\n \"\"\"Read only property for getting HTTP version of request.\n\n Returns aiohttp.protocol.HttpVersion instance.\n \"\"\"\n return self._version\n\n @property\n def host(self):\n \"\"\"Read only property for getting *HOST* header of request.\n\n Returns str or None if HTTP request has no HOST header.\n \"\"\"\n return self._host\n\n @property\n def path_qs(self):\n \"\"\"The URL including PATH_INFO and the query string.\n\n E.g, /app/blog?id=10\n \"\"\"\n return self._path_qs\n\n @property\n def path(self):\n \"\"\"The URL including *PATH INFO* without the host or scheme.\n\n E.g., ``/app/blog``\n \"\"\"\n return self._path\n\n @property\n def query_string(self):\n \"\"\"The query string in the URL.\n\n E.g., id=10\n \"\"\"\n return self._query_string\n\n @property\n def GET(self):\n \"\"\"A multidict with all the variables in the query string.\n\n Lazy property.\n \"\"\"\n if self._get is None:\n self._get = MultiDict(parse_qsl(self._query_string))\n return self._get\n\n @property\n def headers(self):\n \"\"\"A case-insensitive multidict with all headers.\n\n Lazy property.\n \"\"\"\n return self._headers\n\n @property\n def keep_alive(self):\n \"\"\"Is keepalive enabled by client?\"\"\"\n return self._keep_alive\n\n @property\n def match_info(self):\n \"\"\"Result of route resolving.\"\"\"\n return self._match_info\n\n @property\n def app(self):\n \"\"\"Application instance.\"\"\"\n return self._app\n\n @property\n def transport(self):\n \"\"\"Transport used for request processing.\"\"\"\n return self._transport\n\n @property\n def cookies(self):\n \"\"\"Return request cookies.\n\n A read-only dictionary-like object.\n \"\"\"\n if self._cookies is None:\n raw = self.headers.get('COOKIE', '')\n parsed = http.cookies.SimpleCookie(raw)\n self._cookies = MultiDict({key: val.value\n for key, val in parsed.items()})\n return self._cookies\n\n @property\n def payload(self):\n \"\"\"Return raw paiload stream.\"\"\"\n return self._payload\n\n @asyncio.coroutine\n def release(self):\n \"\"\"Release request.\n\n Eat unread part of HTTP BODY if present.\n \"\"\"\n chunk = yield from self._payload.readany()\n while chunk is not EOF_MARKER or chunk:\n chunk = yield from self._payload.readany()\n\n @asyncio.coroutine\n def read(self):\n \"\"\"Read request body if present.\n\n Returns bytes object with full request content.\n \"\"\"\n\n body = bytearray()\n while True:\n chunk = yield from self._payload.readany()\n body.extend(chunk)\n if chunk is EOF_MARKER:\n break\n return bytes(body)\n\n @asyncio.coroutine\n def text(self):\n \"\"\"Return BODY as text using encoding from .charset.\"\"\"\n bytes_body = yield from self.read()\n encoding = self.charset or 'utf-8'\n return bytes_body.decode(encoding)\n\n @asyncio.coroutine\n def json(self, *, loader=json.loads):\n \"\"\"Return BODY as JSON.\"\"\"\n body = yield from self.text()\n return loader(body)\n\n @asyncio.coroutine\n def POST(self):\n \"\"\"Return POST parameters.\"\"\"\n if self._post is not None:\n return self._post\n if self.method not in ('POST', 'PUT', 'PATCH'):\n self._post = MultiDict()\n return self._post\n content_type = self.content_type\n if (content_type not in ('',\n 'application/x-www-form-urlencoded',\n 'multipart/form-data')):\n self._post = MultiDict()\n return self._post\n\n body = yield from self.read()\n content_charset = self.charset or 'utf-8'\n\n environ = {'REQUEST_METHOD': self.method,\n 'CONTENT_LENGTH': str(len(body)),\n 'QUERY_STRING': '',\n 'CONTENT_TYPE': self.headers.get('CONTENT-TYPE')}\n\n fs = cgi.FieldStorage(fp=io.BytesIO(body),\n environ=environ,\n keep_blank_values=True,\n encoding=content_charset)\n\n supported_tranfer_encoding = {\n 'base64': binascii.a2b_base64,\n 'quoted-printable': binascii.a2b_qp\n }\n out = MutableMultiDict()\n for field in fs.list or ():\n transfer_encoding = field.headers.get('Content-Transfer-Encoding',\n None)\n if field.filename:\n ff = FileField(field.name,\n field.filename,\n field.file, # N.B. file closed error\n field.type)\n if self._post_files_cache is None:\n self._post_files_cache = {}\n self._post_files_cache[field.name] = field\n out.add(field.name, ff)\n else:\n value = field.value\n if transfer_encoding in supported_tranfer_encoding:\n # binascii accepts bytes\n value = value.encode('utf-8')\n value = supported_tranfer_encoding[\n transfer_encoding](value)\n out.add(field.name, value)\n self._post = MultiDict(out.items(getall=True))\n return self._post\n\n # @asyncio.coroutine\n # def start_websocket(self):\n # \"\"\"Upgrade connection to websocket.\n\n # Returns (reader, writer) pair.\n # \"\"\"\n\n # upgrade = 'websocket' in message.headers.get('UPGRADE', '').lower()\n # if not upgrade:\n # pass\n\n\n############################################################\n# HTTP Response classes\n############################################################\n\n\nclass StreamResponse(HeadersMixin):\n\n def __init__(self, request, *, status=200, reason=None):\n self._request = request\n self._headers = CaseInsensitiveMutableMultiDict()\n self.set_status(status, reason)\n self._cookies = http.cookies.SimpleCookie()\n self._keep_alive = request.keep_alive\n\n self._resp_impl = None\n self._eof_sent = False\n\n def _copy_cookies(self):\n for cookie in self._cookies.values():\n value = cookie.output(header='')[1:]\n self.headers.add('Set-Cookie', value)\n\n @property\n def request(self):\n return self._request\n\n @property\n def status(self):\n return self._status\n\n @property\n def reason(self):\n return self._reason\n\n def set_status(self, status, reason=None):\n self._status = int(status)\n if reason is None:\n reason = ResponseImpl.calc_reason(status)\n self._reason = reason\n\n @property\n def keep_alive(self):\n return self._keep_alive\n\n def force_close(self):\n self._keep_alive = False\n\n @property\n def headers(self):\n return self._headers\n\n @property\n def cookies(self):\n return self._cookies\n\n def set_cookie(self, name, value, *, expires=None,\n domain=None, max_age=None, path=None,\n secure=None, httponly=None, version=None):\n \"\"\"Set or update response cookie.\n\n Sets new cookie or updates existent with new value.\n Also updates only those params which are not None.\n \"\"\"\n\n old = self._cookies.get(name)\n if old is not None and old.coded_value == '':\n # deleted cookie\n self._cookies.pop(name, None)\n\n self._cookies[name] = value\n c = self._cookies[name]\n if expires is not None:\n c['expires'] = expires\n if domain is not None:\n c['domain'] = domain\n if max_age is not None:\n c['max-age'] = max_age\n if path is not None:\n c['path'] = path\n if secure is not None:\n c['secure'] = secure\n if httponly is not None:\n c['httponly'] = httponly\n if version is not None:\n c['version'] = version\n\n def del_cookie(self, name, *, domain=None, path=None):\n \"\"\"Delete cookie.\n\n Creates new empty expired cookie.\n \"\"\"\n # TODO: do we need domain/path here?\n self._cookies.pop(name, None)\n self.set_cookie(name, '', max_age=0, domain=domain, path=path)\n\n @property\n def content_length(self):\n # Just a placeholder for adding setter\n return super().content_length\n\n @content_length.setter\n def content_length(self, value):\n if value is not None:\n value = int(value)\n # TODO: raise error if chunked enabled\n self.headers['Content-Length'] = str(value)\n elif 'Content-Length' in self.headers:\n del self.headers['Content-Length']\n\n @property\n def content_type(self):\n # Just a placeholder for adding setter\n return super().content_type\n\n @content_type.setter\n def content_type(self, value):\n self.content_type # read header values if needed\n self._content_type = str(value)\n self._generate_content_type_header()\n\n @property\n def charset(self):\n # Just a placeholder for adding setter\n return super().charset\n\n @charset.setter\n def charset(self, value):\n ctype = self.content_type # read header values if needed\n if ctype == 'application/octet-stream':\n raise RuntimeError(\"Setting charset for application/octet-stream \"\n \"doesn't make sense, setup content_type first\")\n if value is None:\n self._content_dict.pop('charset', None)\n else:\n self._content_dict['charset'] = str(value)\n self._generate_content_type_header()\n\n def _generate_content_type_header(self):\n params = '; '.join(\"%s=%s\" % i for i in self._content_dict.items())\n if params:\n ctype = self._content_type + '; ' + params\n else:\n ctype = self._content_type\n self.headers['Content-Type'] = ctype\n\n def send_headers(self):\n if self._resp_impl is not None:\n raise RuntimeError(\"HTTP headers are already sent\")\n\n resp_impl = self._resp_impl = ResponseImpl(\n self._request._writer,\n self._status,\n self._request.version,\n not self._keep_alive,\n self._reason)\n\n self._copy_cookies()\n\n headers = self.headers.items(getall=True)\n for key, val in headers:\n resp_impl.add_header(key, val)\n\n resp_impl.send_headers()\n\n def write(self, data):\n if not isinstance(data, (bytes, bytearray, memoryview)):\n raise TypeError('data argument must be byte-ish (%r)',\n type(data))\n\n if self._eof_sent:\n raise RuntimeError(\"Cannot call write() after write_eof()\")\n if self._resp_impl is None:\n self.send_headers()\n\n if data:\n return self._resp_impl.write(data)\n else:\n return ()\n\n @asyncio.coroutine\n def write_eof(self):\n if self._eof_sent:\n return\n if self._resp_impl is None:\n raise RuntimeError(\"No headers has been sent\")\n\n yield from self._resp_impl.write_eof()\n self._eof_sent = True\n\n\nclass Response(StreamResponse):\n\n def __init__(self, request, body=None, *,\n status=200, reason=None, headers=None):\n super().__init__(request, status=status, reason=reason)\n self.body = body\n if headers is not None:\n self.headers.extend(headers)\n\n @property\n def body(self):\n return self._body\n\n @body.setter\n def body(self, body):\n if body is not None and not isinstance(body, bytes):\n raise TypeError('body argument must be bytes (%r)',\n type(body))\n self._body = body\n if body is not None:\n self.content_length = len(body)\n else:\n self.content_length = 0\n\n @asyncio.coroutine\n def write_eof(self):\n body = self._body\n if self._resp_impl is None:\n self.send_headers()\n if body is not None:\n self.write(body)\n yield from super().write_eof()\n\n############################################################\n# HTTP Exceptions\n############################################################\n\n\nclass HTTPException(Response, Exception):\n\n # You should set in subclasses:\n # status = 200\n\n status_code = None\n\n def __init__(self, request, *, headers=None, reason=None):\n Response.__init__(self, request, status=self.status_code,\n headers=headers, reason=reason)\n Exception.__init__(self, self.reason)\n self.body = \"{}: {}\".format(self.status, self.reason).encode('utf-8')\n\n\nclass HTTPError(HTTPException):\n \"\"\"Base class for exceptions with status codes in the 400s and 500s.\"\"\"\n\n\nclass HTTPRedirection(HTTPException):\n \"\"\"Base class for exceptions with status codes in the 300s.\"\"\"\n\n\nclass HTTPSuccessful(HTTPException):\n \"\"\"Base class for exceptions with status codes in the 200s.\"\"\"\n\n\nclass HTTPOk(HTTPSuccessful):\n status_code = 200\n\n\nclass HTTPCreated(HTTPSuccessful):\n status_code = 201\n\n\nclass HTTPAccepted(HTTPSuccessful):\n status_code = 202\n\n\nclass HTTPNonAuthoritativeInformation(HTTPSuccessful):\n status_code = 203\n\n\nclass HTTPNoContent(HTTPSuccessful):\n status_code = 204\n\n\nclass HTTPResetContent(HTTPSuccessful):\n status_code = 205\n\n\nclass HTTPPartialContent(HTTPSuccessful):\n status_code = 206\n\n\n############################################################\n# 3xx redirection\n############################################################\n\n\nclass _HTTPMove(HTTPRedirection):\n\n def __init__(self, request, location, *, headers=None, reason=None):\n if not location:\n raise ValueError(\"HTTP redirects need a location to redirect to.\")\n super().__init__(request, headers=headers, reason=reason)\n self.headers['Location'] = location\n self.location = location\n\n\nclass HTTPMultipleChoices(_HTTPMove):\n status_code = 300\n\n\nclass HTTPMovedPermanently(_HTTPMove):\n status_code = 301\n\n\nclass HTTPFound(_HTTPMove):\n status_code = 302\n\n\n# This one is safe after a POST (the redirected location will be\n# retrieved with GET):\nclass HTTPSeeOther(_HTTPMove):\n status_code = 303\n\n\nclass HTTPNotModified(HTTPRedirection):\n # FIXME: this should include a date or etag header\n status_code = 304\n\n\nclass HTTPUseProxy(_HTTPMove):\n # Not a move, but looks a little like one\n status_code = 305\n\n\nclass HTTPTemporaryRedirect(_HTTPMove):\n status_code = 307\n\n\n############################################################\n# 4xx client error\n############################################################\n\n\nclass HTTPClientError(HTTPError):\n pass\n\n\nclass HTTPBadRequest(HTTPClientError):\n status_code = 400\n\n\nclass HTTPUnauthorized(HTTPClientError):\n status_code = 401\n\n\nclass HTTPPaymentRequired(HTTPClientError):\n status_code = 402\n\n\nclass HTTPForbidden(HTTPClientError):\n status_code = 403\n\n\nclass HTTPNotFound(HTTPClientError):\n status_code = 404\n\n\nclass HTTPMethodNotAllowed(HTTPClientError):\n status_code = 405\n\n def __init__(self, request, method, allowed_methods, *,\n headers=None, reason=None):\n allow = ','.join(sorted(allowed_methods))\n super().__init__(request, headers=headers, reason=reason)\n self.headers['Allow'] = allow\n self.allowed_methods = allowed_methods\n self.method = method.upper()\n\n\nclass HTTPNotAcceptable(HTTPClientError):\n status_code = 406\n\n\nclass HTTPProxyAuthenticationRequired(HTTPClientError):\n status_code = 407\n\n\nclass HTTPRequestTimeout(HTTPClientError):\n status_code = 408\n\n\nclass HTTPConflict(HTTPClientError):\n status_code = 409\n\n\nclass HTTPGone(HTTPClientError):\n status_code = 410\n\n\nclass HTTPLengthRequired(HTTPClientError):\n status_code = 411\n\n\nclass HTTPPreconditionFailed(HTTPClientError):\n status_code = 412\n\n\nclass HTTPRequestEntityTooLarge(HTTPClientError):\n status_code = 413\n\n\nclass HTTPRequestURITooLong(HTTPClientError):\n status_code = 414\n\n\nclass HTTPUnsupportedMediaType(HTTPClientError):\n status_code = 415\n\n\nclass HTTPRequestRangeNotSatisfiable(HTTPClientError):\n status_code = 416\n\n\nclass HTTPExpectationFailed(HTTPClientError):\n status_code = 417\n\n\n############################################################\n# 5xx Server Error\n############################################################\n# Response status codes beginning with the digit \"5\" indicate cases in\n# which the server is aware that it has erred or is incapable of\n# performing the request. Except when responding to a HEAD request, the\n# server SHOULD include an entity containing an explanation of the error\n# situation, and whether it is a temporary or permanent condition. User\n# agents SHOULD display any included entity to the user. These response\n# codes are applicable to any request method.\n\n\nclass HTTPServerError(HTTPError):\n pass\n\n\nclass HTTPInternalServerError(HTTPServerError):\n status_code = 500\n\n\nclass HTTPNotImplemented(HTTPServerError):\n status_code = 501\n\n\nclass HTTPBadGateway(HTTPServerError):\n status_code = 502\n\n\nclass HTTPServiceUnavailable(HTTPServerError):\n status_code = 503\n\n\nclass HTTPGatewayTimeout(HTTPServerError):\n status_code = 504\n\n\nclass HTTPVersionNotSupported(HTTPServerError):\n status_code = 505\n\n\n############################################################\n# UrlDispatcher implementation\n############################################################\n\n\nclass UrlMappingMatchInfo(dict, AbstractMatchInfo):\n\n def __init__(self, match_dict, entry):\n super().__init__(match_dict)\n self._entry = entry\n\n @property\n def handler(self):\n return self._entry.handler\n\n @property\n def endpoint(self):\n return self._entry.endpoint\n\n\nBaseEntry = collections.namedtuple('BaseEntry',\n 'regex method handler endpoint path type')\n\n\nclass Entry(BaseEntry):\n DYNAMIC = \"DYNAMIC\"\n STATIC = \"STATIC\"\n PLAIN = \"PLAIN\"\n\n\nclass UrlDispatcher(AbstractRouter):\n\n DYN = re.compile(r'^\\{[a-zA-Z][_a-zA-Z0-9]*\\}$')\n GOOD = r'[^{}/]+'\n PLAIN = re.compile('^'+GOOD+'$')\n\n METHODS = {'POST', 'GET', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'}\n\n def __init__(self):\n super().__init__()\n self._urls = []\n self._endpoints = {}\n\n @asyncio.coroutine\n def resolve(self, request):\n path = request.path\n method = request.method\n allowed_methods = set()\n for entry in self._urls:\n match = entry.regex.match(path)\n if match is None:\n continue\n if entry.method != method:\n allowed_methods.add(entry.method)\n else:\n break\n else:\n if allowed_methods:\n raise HTTPMethodNotAllowed(request, method, allowed_methods)\n else:\n raise HTTPNotFound(request)\n\n matchdict = match.groupdict()\n return UrlMappingMatchInfo(matchdict, entry)\n\n @asyncio.coroutine\n def reverse(self, method, endpoint, *, parts=None, filename=None,\n query=None):\n method = method.upper()\n entry = self._endpoints.get((method, endpoint))\n if entry is None:\n raise KeyError(\"[{}] {!r} endpoint not found\"\n .format(method, endpoint))\n\n if filename is not None and entry.type is not Entry.STATIC:\n raise ValueError(\"Cannot use filename with non-static route\")\n\n if entry.type is Entry.DYNAMIC:\n if parts is None:\n raise ValueError(\n \"Dynamic endpoint requires nonempty parts parameter\")\n url = entry.path.format_map(parts)\n elif entry.type is Entry.PLAIN:\n if parts:\n raise ValueError(\n \"Plain endpoint doesn't allow parts parameter\")\n url = entry.path\n elif entry.type is Entry.STATIC:\n if filename is None:\n raise ValueError(\n \"filename must be not empty for static routes\")\n while filename.startswith('/'):\n filename = filename[1:]\n url = entry.path + filename\n else:\n raise ValueError(\n \"Not supported endpoint type {}\".format(entry.type))\n\n if query is not None:\n qs = \"?\" + urlencode(query)\n else:\n qs = \"\"\n return url + qs\n\n def _register_endpoint(self, new_entry):\n endpoint = new_entry.endpoint\n method = new_entry.method\n if endpoint is not None:\n key = (method, endpoint)\n if key in self._endpoints:\n entry = self._endpoints[key]\n raise ValueError('Duplicate endpoint {!r}, '\n 'already handled by [{}] {} -> {!r}'\n .format(endpoint,\n entry.method,\n entry.path,\n entry.handler))\n else:\n self._endpoints[key] = new_entry\n self._urls.append(new_entry)\n\n def add_route(self, method, path, handler, *, endpoint=None):\n assert path.startswith('/')\n assert callable(handler), handler\n method = method.upper()\n assert method in self.METHODS, method\n regexp = []\n entry_type = Entry.PLAIN\n for part in path.split('/'):\n if not part:\n continue\n if self.DYN.match(part):\n regexp.append('(?P<'+part[1:-1]+'>'+self.GOOD+')')\n entry_type = Entry.DYNAMIC\n elif self.PLAIN.match(part):\n regexp.append(re.escape(part))\n else:\n raise ValueError(\"Invalid path '{}'['{}']\".format(path, part))\n pattern = '/' + '/'.join(regexp)\n if path.endswith('/') and pattern != '/':\n pattern += '/'\n compiled = re.compile('^' + pattern + '$')\n new_entry = Entry(compiled, method, handler,\n endpoint, path, entry_type)\n self._register_endpoint(new_entry)\n\n def _static_file_handler_maker(self, path):\n @asyncio.coroutine\n def _handler(request):\n resp = StreamResponse(request)\n filename = request.match_info['filename']\n filepath = os.path.join(path, filename)\n if '..' in filename:\n raise HTTPNotFound(request)\n if not os.path.exists(filepath) or not os.path.isfile(filepath):\n raise HTTPNotFound(request)\n\n ct = mimetypes.guess_type(filename)[0]\n if not ct:\n ct = 'application/octet-stream'\n resp.content_type = ct\n\n resp.headers['transfer-encoding'] = 'chunked'\n resp.send_headers()\n\n with open(filepath, 'rb') as f:\n chunk = f.read(1024)\n while chunk:\n resp.write(chunk)\n chunk = f.read(1024)\n\n yield from resp.write_eof()\n return resp\n\n return _handler\n\n def add_static(self, prefix, path, *, endpoint=None):\n \"\"\"\n Adds static files view\n :param prefix - url prefix\n :param path - folder with files\n \"\"\"\n assert prefix.startswith('/')\n assert os.path.exists(path), 'Path does not exist %s' % path\n path = os.path.abspath(path)\n method = 'GET'\n suffix = r'(?P.*)' # match everything after static prefix\n if not prefix.endswith('/'):\n prefix += '/'\n compiled = re.compile('^' + prefix + suffix + '$')\n new_entry = Entry(\n compiled, method,\n self._static_file_handler_maker(path),\n endpoint, prefix, Entry.STATIC)\n self._register_endpoint(new_entry)\n\n\n############################################################\n# Application implementation\n############################################################\n\n\nclass RequestHandler(ServerHttpProtocol):\n\n def __init__(self, app, **kwargs):\n super().__init__(**kwargs)\n self._app = app\n\n @asyncio.coroutine\n def handle_request(self, message, payload):\n request = Request(self._app, message, payload,\n self.transport, self.writer, self.keep_alive_timeout)\n try:\n match_info = yield from self._app.router.resolve(request)\n\n assert isinstance(match_info, AbstractMatchInfo), match_info\n\n request._match_info = match_info\n handler = match_info.handler\n\n resp = handler(request)\n if (asyncio.iscoroutine(resp) or\n isinstance(resp, asyncio.Future)):\n resp = yield from resp\n if not isinstance(resp, StreamResponse):\n raise RuntimeError((\"Handler should return response \"\n \"instance, got {!r}\")\n .format(type(resp)))\n except HTTPException as exc:\n resp = exc\n\n yield from resp.write_eof()\n if resp.keep_alive:\n # Don't need to read request body if any on closing connection\n yield from request.release()\n self.keep_alive(resp.keep_alive)\n\n\nclass Application(dict):\n\n def __init__(self, *, loop=None, router=None, **kwargs):\n # TODO: explicitly accept *debug* param\n if loop is None:\n loop = asyncio.get_event_loop()\n self._kwargs = kwargs\n if router is None:\n router = UrlDispatcher()\n assert isinstance(router, AbstractRouter), router\n self._router = router\n self._loop = loop\n self._finish_callbacks = []\n\n @property\n def router(self):\n return self._router\n\n @property\n def loop(self):\n return self._loop\n\n def make_handler(self):\n return RequestHandler(self, loop=self._loop, **self._kwargs)\n\n @asyncio.coroutine\n def finish(self):\n for (cb, args, kwargs) in self._finish_callbacks:\n try:\n res = cb(*args, **kwargs)\n if (asyncio.iscoroutine(res) or\n isinstance(res, asyncio.Future)):\n yield from res\n except Exception as exc:\n self._loop.call_exception_handler({\n 'message': \"Error in finish callback\",\n 'exception': exc,\n 'application': self,\n })\n\n def register_on_finish(self, func, *args, **kwargs):\n self._finish_callbacks.insert(0, (func, args, kwargs))\n","sub_path":"aiohttp/web.py","file_name":"web.py","file_ext":"py","file_size_in_byte":32030,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"381800870","text":"# coding=utf8\r\n\r\n\"\"\"\r\nEncode E Daa im Narrehüs in TEI based on hOCR output.\r\n\"\"\"\r\n\r\nfrom importlib import reload\r\nfrom lxml import etree\r\nimport os\r\nimport re\r\nimport roman\r\nimport sys\r\n\r\nsys.path.append(\"../..\")\r\n\r\nimport add_characters as ac\r\nimport config as cf\r\nimport oconfig as ocf\r\nimport play_parsing as pp\r\nimport utils.utils as ut\r\n#import verse\r\n\r\nDBG = False\r\n\r\n\r\ndef get_par_text(pe):\r\n \"\"\"Extract text from par element `pe`\"\"\"\r\n toks = pe.xpath(\".//span[@class='ocrx_word']//text()\")\r\n return \" \".join(toks)\r\n\r\n\r\ndef create_pb(ma, xl):\r\n xl.append((\"\".format(int(ma.group(1)))))\r\n\r\n\r\ndef create_sp(ma, xl, pidx=None):\r\n \"\"\"\r\n Create sp element, tagging stage directions.\r\n `ma` is a match object with the speaker string as group 1 and the\r\n p text as group 2. `pidx` is the paragraph index in its page.\r\n \"\"\"\r\n speaker = f\"{ma.group(1).strip()}\"\r\n ptext = f\"

{ma.group(2).strip()}

\"\r\n speaker_has_stage = re.search(pp.stage_reg, speaker)\r\n clean_speaker = speaker\r\n if speaker_has_stage:\r\n clean_speaker = re.sub(pp.stage_reg, \"\", speaker)\r\n clean_speaker = clean_speaker.strip().replace(\r\n \"\",\r\n f\"{speaker_has_stage.group(1)}\")\r\n clean_p = re.sub(pp.stage_reg, r\"\\1\", ptext).strip()\r\n xl.append(f\"{clean_speaker}{clean_p}\")\r\n\r\n\r\ndef attach_text_to_last_sp(text, xml_list):\r\n \"\"\"\r\n Attach to the last sp/p paragraph text that don't start with a speaker.\r\n The last sp/p index depends on whether a pb element intervenes or not.\r\n \"\"\"\r\n if \"\\1\", text)\r\n xml_list[-2] = xml_list[-2].replace(\"

\", \"\")\r\n xml_list[-2] = \" \".join((xml_list[-2], xml_list[-1], f\" {clean_text}

\"))\r\n xml_list.pop()\r\n else:\r\n xml_list[-1] = xml_list[-1].replace(\"

\", \"\")\r\n clean_text = re.sub(pp.stage_reg, r\" \\1 \", text)\r\n xml_list[-1] = \" \".join((xml_list[-1], f\" {clean_text}

\"))\r\n\r\n\r\ndef process_paragraph(pe, pes, xl, idx, actual_idx, fn):\r\n \"\"\"\r\n Trigger a processing for each type of paragraph depending on cues in it.\r\n\r\n Note\r\n ----\r\n Mixes play-specific and generic processing.\r\n\r\n Parameters\r\n ----------\r\n pe : :obj:`lxml._Element`\r\n Paragraph to start processing at\r\n pes : list\r\n List of :obj:`lxml._Element` for each `

` on file `fn`\r\n xl : list\r\n List of strings representing XML. The result of processing the `

`\r\n element is appended to it.\r\n idx : int\r\n Index of the `

` in its page (based on xpath that retrieves them)\r\n actual_idx : int\r\n Processing starts at index `idx` but may cover several paragraphs,\r\n updating the value of `actual_idx`, which is returned so that further\r\n processing picks up there.\r\n fn : str\r\n Filename, used to determine page number\r\n\r\n Returns\r\n -------\r\n int\r\n Index of next paragraph that needs to be processed\r\n \"\"\"\r\n increment = True\r\n txt = get_par_text(pes[actual_idx])\r\n\r\n # for verse line treatment\r\n #lstart2text = verse.find_ocr_line_bbox_start_and_text(pe)\r\n #poem_offset, poem_end = verse.find_verse_column_for_page(fn, pes, actual_idx)\r\n\r\n is_div_scene_head = re.search(re.compile(\"([0-9]+)\\. UFFTRITT\\.\"), txt)\r\n is_div_act_head = re.search(re.compile(\"([IVX]+)\\. AKT\\.\"), txt)\r\n has_pb = re.search(pp.pb_reg, txt)\r\n has_sp = re.search(pp.sp_reg, txt)\r\n\r\n # final line (play-specific)\r\n # skip printer line\r\n #if \"Buckdruckerei\" in txt:\r\n # return actual_idx + 1\r\n if re.match(r\"ende\\.\", txt.strip().lower()):\r\n xl.append(f\"{txt}\")\r\n\r\n # act start\r\n elif is_div_act_head:\r\n if int(roman.fromRoman(is_div_act_head.group(1))) > 1:\r\n # close act and also scene\r\n xl.append(f\"

{txt}\")\r\n else:\r\n xl.append(f\"
{txt}\")\r\n \r\n # scene start\r\n elif is_div_scene_head:\r\n if int(is_div_scene_head.group(1)) > 1:\r\n xl.append(f\"
{txt}\")\r\n else:\r\n xl.append(f\"
{txt}\")\r\n\r\n # page breaks\r\n elif has_pb:\r\n create_pb(has_pb, xl)\r\n \r\n # sp\r\n elif has_sp:\r\n\r\n create_sp(has_sp, xl, idx)\r\n \r\n # sp\r\n else:\r\n if DBG:\r\n print(\"Texte : \", txt)\r\n\r\n # character stage directions\r\n x_size = float(re.search(pp.x_size_reg, pe.xpath(\".//span[@class='ocr_line']\")[0].attrib[\"title\"]).group(1))\r\n if DBG:\r\n print(x_size)\r\n if x_size < 0 and ((not \":\" in txt) or (\"Qouic\" in txt) or (txt.startswith(\"Jetz singe mr noch\"))):\r\n xl.append(f\"{txt}\")\r\n # speech across page break\r\n else:\r\n attach_text_to_last_sp(txt, xl)\r\n\r\n # verse treatment\r\n #verse.create_verse_elements_for_ocr_line(xl, lstart2text, poem_offset)\r\n\r\n if DBG:\r\n pnbr = int(fn.replace(\".html\", \"\")) - 3\r\n print(\" ## {} ##\".format(pnbr), txt)\r\n\r\n if increment:\r\n actual_idx += 1\r\n return actual_idx\r\n\r\n\r\ndef manual_cleanups(st):\r\n # around pb[@n=\"8\"]\r\n st = re.sub(r\"

\\s*\\s*()\\s*\\s*\", r\" \\1 \", st)\r\n st = re.sub(r\"\\s*

\\s*(«\\sSage mir)\", r\" \\1\", st)\r\n # around pb[@n=\"15\"]\r\n st = re.sub(r\"

\\s*\\s*()\\s*\\s*([^<]+)\",\r\n r\" \\1 \\2\", st)\r\n st = re.sub(r\"

\\s*(Mon Dieu.\\s*Au noch die S)\", r\" \\1\", st)\r\n # added pr 2020-10-23\r\n st = st.replace(\"d’ Cabine\", \"d’Cabine\")\r\n st = st.replace(\"(trätt wietig vor lütt):\",\r\n \"(trätt wietig vor ; lütt):\")\r\n st = st.replace(\"ich nitt here ! .\", \"ich nitt here !\")\r\n st = re.sub(re.compile(r\"\"\"\\s*ADDES - EDDES \\(pfeifen die Melodie:\\s*

« D’r Hans im Schnokeloch »

\\s*\\s*und schlagen im Takt auf den Klopfstein\\).\"\"\",\r\n re.DOTALL),\r\n \"ADDES - EDDES (pfeifen die Melodie: « D’r Hans im Schnokeloch » und schlagen im Takt auf den Klopfstein).\",\r\n st)\r\n st = re.sub(re.compile(\"\"\"

\\s*\\s*\\s*läwe, drej Käs hoch, vive!\"\"\",\r\n re.DOTALL),\r\n \"\"\"läwe, drej Käs hoch, vive!

\"\"\",\r\n st)\r\n #st = re.sub(re.compile(\"\"\"\\s*(6. UFFTRITT) (Drohtspitz, 50jährig, stupfelbärtig, den Hut auf einem Ohr, grosse Zigarre im Mund, bleibt an der Mitteltüre stehn.) (DROHTSPITZ:)\"\"\"),\r\n # r\"
\\1\\2\\3\", st)\r\n #breakpoint()\r\n #st = st.replace(\"\", \"\")\r\n #st = st.replace(\"16\", \"\")\r\n #st = re.sub(\r\n # r\"\"\"(D’ Madam Drohtspitz hett’s)

\\s*\\s*(?:\\s*)?\\s*\"\"\",\r\n # r\"\\1\", st)\r\n # st = re.sub(re.compile(r\"\"\"

\\s*()(nimi notwendig Gäns ze stopfe, diss isch guet for Proletarier.) \"\"\", re.DOTALL),\r\n # r\"\\2 \\1\", st)\r\n #st = re.sub(r\"\"\"16\\s*\\s*\"\"\", \"\", st)\r\n\r\n return st\r\n\r\n\r\ndef create_xml(xml_list):\r\n # breakpoint()\r\n # body\r\n body_text = \"\".join(xml_list)\r\n body_text = ut.simple_dehyphenation(body_text)\r\n body_text = ut.strip_speakers(body_text)\r\n # body_text = ut.tag_foreign_expressions_with_list(body_text, cf.foreign_expressions)\r\n body_text = ut.add_space_around_stage_directions(body_text)\r\n body_text = ut.change_apos_to_squo_str(body_text)\r\n body_text = ut.change_lsquo_to_rsquo_str(body_text)\r\n body_text = ut.general_cleanup_str(body_text)\r\n body_text = body_text.replace(\"\"\"

 nimi notwendig Gäns ze stopfe, diss isch guet for Proletarier. ADDES:\"\"\",\r\n \"nimi notwendig Gäns ze stopfe, diss isch guet for Proletarier.

ADDESXXX\")\r\n body_text = manual_cleanups(body_text)\r\n # teiHeader\r\n # workbook also contains header info (and characters)\r\n md_all = ut.read_header_info(cf.cast_list_data)\r\n md = ut.get_play_metadata_by_id(md_all, cf.play_id)\r\n hdr = ut.create_tei_header(md, other={\"respStmt\": ocf.respStmt,\r\n \"availability\": ocf.availability[\"ccby\"]})\r\n hdr_str = etree.tostring(hdr)\r\n #print(hdr_str)\r\n # all\r\n global xml_str\r\n xml_str = \"\\n\".join(\r\n ['', hdr_str.decode(), \"
\", body_text, \"
\"])\r\n if cf.has_acts:\r\n xml_str = xml_str.replace(\"
\", \"\")\r\n xml_str = xml_str.replace(\"\", \"
\")\r\n # create back element\r\n #xml_str = ut.create_back_with_text(xml_str, cf.back_text)\r\n parser_x = etree.XMLParser(remove_blank_text=True)\r\n if DBG:\r\n print(xml_str)\r\n elem = etree.XML(xml_str, parser=parser_x)\r\n ser = etree.tostring(elem, xml_declaration=True, pretty_print=True, encoding=\"UTF-8\")\r\n ser = ut.change_apos_to_squo_b(ser)\r\n # remove empty

\r\n ser = re.sub(b\"

\", b\"\", ser)\r\n # ser = re.sub(re.compile(r\"\"\"

\\s*()(nimi notwendig Gäns ze stopfe, diss isch guet for Proletarier.) \"\"\".encode(), re.DOTALL),\r\n # rb\"\\2 \\1\", ser)\r\n ser = ser.replace('nimi notwendig Gäns ze stopfe, diss isch guet for Proletarier. ADDES:'.encode(),\r\n 'nimi notwendig Gäns ze stopfe, diss isch guet for Proletarier. ADDES:'.encode())\r\n\r\n return ser\r\n\r\n\r\ndef write_out(otree):\r\n with open(\"{}\".format(cf.oufn), mode=\"wb\") as of:\r\n of.write(otree)\r\n #if cf.format_initial_xml:\r\n # os.system(\"xmllint --noblanks {} > bli ; xmllint --format bli > bla ; mv bla {} ; rm bli\".format(\r\n #os.system(\"xmllint {} > bli ; xmllint --format bli > bla ; mv bla {} ; rm bli\".format(\r\n # cf.oufn, cf.oufn))\r\n #os.system(\r\n # \"\"\"sed -i.bak -e 's%%%g' {}\"\"\".format(\r\n # cf.oufn))\r\n #os.system(\r\n # \"\"\"sed -i.bak -e 's%%\\\\n%g' {}\"\"\".format(\r\n # cf.oufn))\r\n #os.system(f\"xmllint --noout {cf.oufn}\")\r\n\r\n\r\nif __name__ == \"__main__\":\r\n for mdl in cf, ocf, ut, ac:\r\n reload(mdl)\r\n # list to keep strings that represent xml\r\n xl = []\r\n for fn in sorted(os.listdir(cf.hocr_dir)):\r\n if not fn.endswith(\"html\"):\r\n continue\r\n if (int(fn.replace(\".html\", \"\")) < cf.body_start_filename or\r\n int(fn.replace(\".html\", \"\")) > cf.body_end_filename):\r\n continue\r\n ffn = os.path.join(cf.hocr_dir, fn)\r\n print(fn)\r\n tree = etree.parse(ffn)\r\n pars = tree.xpath(\"//p[@class='ocr_par']\")\r\n todo_idx = 0\r\n # iterate over paragraphs and process each\r\n try:\r\n for idx, par in enumerate(pars):\r\n # more than one p may be processed in one process_paragraph call\r\n # which is why todo_idx is returned: the next call picks up there\r\n todo_idx = process_paragraph(par, pars, xl, idx, todo_idx, fn)\r\n except IndexError:\r\n # last paragraph\r\n continue\r\n # create xml object and serialize\r\n ser_xml = create_xml(xl)\r\n write_out(ser_xml)\r\n # create file with characters\r\n ac.add_characters(cf.cast_list_data, cf.oufn, cf.oufn_with_characters)\r\n # validation\r\n if cf.add_css:\r\n txt = open(cf.oufn_with_characters).read()\r\n if not \"tei-drama.css\" in txt:\r\n os.system(\r\n \"\"\"sed -i.bak -e 's%%\\\\n%g' {}\"\"\".format(\r\n cf.oufn_with_characters))\r\n if cf.validate_rng:\r\n ut.validate_tei_with_relaxng(cf.oufn_with_characters, rng_path=ocf.tei_rng)\r\n if cf.indent:\r\n # os.system(f\"xmllint --format {cf.oufn_with_characters} > .t ; mv .t {cf.oufn_with_characters}\")\r\n # os.system(f\"xmlindent {cf.oufn_with_characters} -i 2 -l 120 > .t ; mv .t {cf.oufn_with_characters}\")\r\n os.system(f\"tidy --indent auto -wrap 114 -xml {cf.oufn_with_characters} 2> /dev/null | \"\r\n rf\"perl -p -e 's/<\\/seg>(\\w)/<\\/seg> \\1/g' | \"\r\n rf\"perl -p -e 's/(\\w)/\\1 /g' | \"\r\n # use \\p{L} to catch accented characters\r\n rf\"perl -p -e 's/<\\/stage>([\\p{{L}}’„])/<\\/stage> \\1/g' | \"\r\n rf\"perl -p -e 's/utf-8/UTF-8/g' > .t ; \"\r\n f\"mv .t {cf.oufn_with_characters}\")","sub_path":"methal-work-master/play-encoding/plays/045_013_maischter_hett_gewunne/create_tei.py","file_name":"create_tei.py","file_ext":"py","file_size_in_byte":13494,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"19033305","text":"# Define a function that can accept an integer number as input and print the \"It is an even number\" if the number is even, otherwise print \"It is an odd number\".\ndef eve(n):\n if(n%2==0):\n print(\"It is even\")\n else: \n print(\"It is Odd\")\n \n return \" \" \n\nn=int(input(\"Enter a number: \"))\nprint(eve(n))\n","sub_path":"number.py","file_name":"number.py","file_ext":"py","file_size_in_byte":326,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"358277407","text":"# -*- coding: utf-8 -*-\n\nimport pymysql\nimport sys\n\n\ndef create_table(conn):\n sql_drop_table = \"drop table if EXISTS lift_details_notd;\"\n sql_create_table = \"create table if not exists lift_details_notd(\" \\\n \"_id int auto_increment,\" \\\n \"device_id varchar(16),\" \\\n \"r_device_category varchar(64),\" \\\n \"r_rated_load varchar(64),\" \\\n \"r_layer_number varchar(64),\" \\\n \"r_rated_speed varchar(64),\" \\\n \"r_maintenance_name varchar(64),\" \\\n \"r_maintenance_phone varchar(64),\" \\\n \"r_put_into_use_date varchar(64),\" \\\n \"r_manufacture_unit varchar(64),\" \\\n \"r_installation_unit varchar(64),\" \\\n \"r_using_unit varchar(64),\" \\\n \"r_examination_date varchar(64),\" \\\n \"r_examination_result varchar(64),\" \\\n \"r_examination_report varchar(64),\" \\\n \"r_effective_expiration_date varchar(64),\" \\\n \"r_buffer_form varchar(64),\" \\\n \"r_door_opening_mode varchar(64),\" \\\n \"r_heavy_blocks_number varchar(64),\" \\\n \"r_top_height varchar(64),\" \\\n \"r_pit_depth varchar(64),\" \\\n \"r_motor_category varchar(64),\" \\\n \"r_motor_type varchar(64),\" \\\n \"r_motor_power varchar(64),\" \\\n \"r_rated_current varchar(64),\" \\\n \"primary key(_id)\" \\\n \")\"\n cursor = conn.cursor()\n try:\n cursor.execute(sql_drop_table)\n cursor.execute(sql_create_table)\n conn.commit()\n except:\n conn.rollback()\n\n\ndef load_data(conn, data_path):\n cursor = conn.cursor()\n sql_load_data = 'load data local infile \\'{0}\\' into table lift_details_notd ' \\\n 'fields terminated by \\';\\' enclosed by \\'\"\\' ' \\\n 'lines terminated by \\'\\n\\' ' \\\n '(device_id,r_device_category,r_rated_load,r_layer_number,r_rated_speed,r_maintenance_name,r_maintenance_phone,' \\\n 'r_put_into_use_date,r_manufacture_unit,r_installation_unit,r_using_unit,r_examination_date,r_examination_result,' \\\n 'r_examination_report,r_effective_expiration_date,r_buffer_form,r_door_opening_mode,r_heavy_blocks_number,r_top_height,' \\\n 'r_pit_depth,r_motor_category,r_motor_type,r_motor_power,r_rated_current)'.format(data_path)\n try:\n cursor.execute(sql_load_data)\n conn.commit()\n except:\n print(\"Unexpected error:\", sys.exc_info()[0])\n conn.rollback()\n\n\nif __name__ == '__main__':\n connection = pymysql.connect(\"localhost\", \"root\", \"root\", \"lift_detail\", local_infile=1)\n create_table(connection)\n path = 'lift_details.txt'\n load_data(connection, path)\n connection.close()\n","sub_path":"lift/data/mysql_from_txt_notd.py","file_name":"mysql_from_txt_notd.py","file_ext":"py","file_size_in_byte":3071,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"275052473","text":"# -*- coding: utf-8 -*-\n\"\"\"\n強化学習エージェントクラス\n\n\"\"\"\n\nimport numpy as np\n\nclass ReinforcementLearningAgent:\n \"\"\" 強化学習のエージェントクラス \"\"\"\n epsilon = 0.25 \n alpha = 0.8 # 学習率\n gamma = 0.9 # 割引率\n \n def __init__(self, action_list=[], state_list=[]):\n # 取れる行動の選択肢\n self.__a_lst = action_list\n # 全状態リスト\n self.__s_lst = state_list\n # Q関数（Qtable）\n self.__q_table = {s:{a: 0 for a in action_list} for s in state_list}\n \n \n def select_action_on_policy(self, state, episode):\n \"\"\" 政策piに従って行動を選択する \"\"\"\n \"\"\" ε-greedy探索を用いる \"\"\"\n eps = np.random.uniform(0, 1)\n a_idx = 0\n if 1-eps > self.epsilon: # 1-εで最適な行動\n q_val_arr = list(self.__q_table[state].values())\n a_idx = np.argmax(q_val_arr)\n else: # εでランダムに選択\n a_idx = np.random.randint(4)\n\n return self.__a_lst[a_idx]\n \n \n def update_Q_table_by_SARSA(self, st, act, rwd, st_n, act_n ):\n \"\"\" SARSA法でQtableを更新する \"\"\"\n \"\"\" Q(st,at) <- (1-α)Q(st,at) + α(rt+1 + γQ(st+1, at+1)) \"\"\"\n # 現在のQ値を取得\n q_curr = self.__q_table[st][act]\n # 1ステップ先のQ値を取得\n q_new = self.__q_table[st_n][act_n]\n # 更新\n self.__q_table[st][act] = (1-self.alpha)*q_curr + self.alpha*(rwd + self.gamma*q_new)\n \n \n def show_Q_table(self):\n \"\"\" Qtableの内部を見せる \"\"\"\n a_header = 'action'\n for a in self.__a_lst:\n a_header += f'\\t{a}'\n print(a_header)\n \n for s in self.__s_lst:\n s_row = f'{s}'\n for a in self.__a_lst:\n s_row += '\\t{:.4g}'.format(self.__q_table[s][a])\n print(s_row)\n ","sub_path":"src/RL_agent.py","file_name":"RL_agent.py","file_ext":"py","file_size_in_byte":1949,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"28521566","text":"import csv\r\nimport collections \r\nfrom collections import Counter\r\n\r\n#full playlists\r\nfilename = \"C:/Users/Юлия/Desktop/Eurecom/Courses/Semester_project/data/track_uri_seq.csv\"\r\n\r\nwith open(filename, 'r') as csvfile:\r\n csvreader = csv.reader(csvfile, delimiter = ';')\r\n\r\n Rows_full = []\r\n Songs_full = []\r\n \r\n for playlist in csvreader:\r\n Rows_full.append(playlist)\r\n print('Number of Rows_full:', len(Rows_full)) \r\n #Number of Rows_full: 1000001\r\n\r\n for playlist in Rows_full:\r\n for name in playlist:\r\n Songs_full.append(name)\r\n print('Number of Songs_full:', len(Songs_full))\r\n #Number of Songs_full: 66346428\r\n\r\n counter = collections.Counter(Songs_full)\r\n r = counter.most_common(100)\r\n #print('Frequency of 100 most popular songs:', r)\r\n Popular_songs = [name for name, name_count in r]\r\n #print('First 100 popular songs:', Popular_songs)\r\n\r\n#isoalated playlists with first 100 popular songs\r\nfilename2 = \"C:/Users/Юлия/Desktop/Eurecom/Courses/Semester_project/data/Newlist100.csv\"\r\n\r\nwith open(filename2, 'r') as csvfile2:\r\n csvreader2 = csv.reader(csvfile2, delimiter = ';')\r\n\r\n Rows = []\r\n Songs = []\r\n \r\n for playlist in csvreader2:\r\n Rows.append(playlist)\r\n print('Number of Rows:', len(Rows)) \r\n #Number of playlists: 175068\r\n\r\n for playlist in Rows:\r\n for name in playlist:\r\n Songs.append(name)\r\n print('Number of songs:', len(Songs))\r\n #Number of songs: 15066464\r\n\r\n \r\n l = []\r\n for name in Popular_songs:\r\n\r\n start = 0\r\n middle = 0\r\n end = 0\r\n \r\n for playlist in Rows:\r\n split_point = len(playlist)//3\r\n \r\n if name in playlist[:split_point]:\r\n start += 1 \r\n if name in playlist[split_point:split_point*2]:\r\n middle +=1 \r\n if name in playlist[split_point*2:]:\r\n end += 1\r\n \r\n k = [start, middle, end] \r\n #print ('song position', k)\r\n l.append(k)\r\n print('Song position full list:', l)\r\n\r\n\r\n #Summarize the values of each song from a list l\r\n sum_equal = [sum(name) for name in zip(*l)]\r\n print('sum_equal', sum_equal)\r\n\r\n #Calculate the song's weight \r\n Song_P = []\r\n for name in Popular_songs:\r\n f = Songs.count(name)\r\n p = f/len(Songs)\r\n #print('p', p)\r\n Song_P.append(p) \r\n print('Song_weight', Song_P)\r\n\r\n #Multiply the values in a list with normalized song’s weight one by one \r\n norm = [[Song_P[i] * j for j in playlist] \r\n for i, playlist in enumerate(l)]\r\n print(\"The list after multiplication: \", norm)\r\n\r\n #Summarize the values of each song from a list norm\r\n sum_norm = [sum(name) for name in zip(*norm)]\r\n print('sum_norm', sum_norm)\r\n\r\n\r\n\r\n\r\n\r\n\r\n \r\n","sub_path":"Part2 (Song position in the playlist).py","file_name":"Part2 (Song position in the playlist).py","file_ext":"py","file_size_in_byte":2906,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"250803698","text":"'''\n@author: viet\nThis file contains basic image processing methods\nand a method to compose methods\n'''\n\nimport pickle\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom models import view_image\nimport pandas as pd\nimport cv2 as cv\nfrom skimage.restoration import denoise_tv_chambolle\nfrom PIL import Image\nimport imgaug as ia\nfrom imgaug import augmenters as iaa\n\ndef to3chan(img_array):\n new_array = []\n for i in range(len(img_array)):\n e = img_array[i][0]\n new_image = [e,e,e] # 3 channels\n new_array.append(new_image)\n return np.array(new_array, dtype=np.uint8)\n\ndef threshold_background(image_array, threshold=240):\n print(\"Thresholding background...\")\n new_array = []\n for image in image_array:\n image = (image >= threshold)*255\n new_array.append(image)\n return np.array(new_array, dtype=np.uint8)\n\ndef compose(image_array, functions):\n 'Composes a bunch of bs together to make a bigger bs'\n new_array = image_array\n for f in functions:\n new_array = f(new_array)\n return np.array(new_array, dtype=np.uint8)\n\ndef thin(image_array): \n print(\"Thinning image...\")\n image_array = image_array.astype(np.uint8)\n new_array = []\n for image in image_array:\n new_array.append(cv.ximgproc.thinning(image, thinningType=1))\n return np.array(new_array, dtype=np.uint8)\n\ndef flatten(image_array: np.ndarray):\n print(\"Flattening...\")\n new_array = []\n for image in image_array:\n new_array.append(image.flatten())\n return np.array(new_array)\n\ndef augment_tf_out_of_them(image_array: np.ndarray):\n print(\"Augmenting...\")\n ia.seed(np.random.randint(0, 500))\n sometimes = lambda aug: iaa.Sometimes(0.8, aug)\n seq = iaa.Sequential([\n iaa.Crop(percent=(0, 0.1)), # random crops\n iaa.Dropout(p=0.1, per_channel=True),\n # Make some images brighter and some darker.\n # In 20% of all cases, we sample the multiplier once per channel,\n # which can end up changing the color of the images.\n iaa.Multiply((0.87, 1.3), per_channel=0.2),\n # Apply affine transformations to each image.\n # Scale/zoom them, translate/move them, rotate them and shear them.\n iaa.Affine(\n scale={\"x\": (0.9, 1.1), \"y\": (0.9, 1.1)},\n translate_percent={\"x\": (-0.2, 0.2), \"y\": (-0.2, 0.2)},\n rotate=(-15, 15),\n shear=(-5, 5)\n ),\n iaa.Emboss(alpha=1, strength=0.5)\n ], random_order=True) # apply augmenters in random order\n image_array = np.transpose(image_array, (0,2,3,1))\n augmented = seq.augment_images(image_array)\n augmented = np.transpose(augmented, (0,3,1,2))\n print(\"Augmented!\")\n return augmented\n\n","sub_path":"models/img_processing.py","file_name":"img_processing.py","file_ext":"py","file_size_in_byte":2732,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"159333007","text":"import networkx as nx\r\n\r\nentrada = input()\r\nentrada = [int(i) for i in entrada.strip('\\n').strip(' ').split(' ')]\r\n\r\nN, E = entrada\r\n\r\nwhile ( N != 0 and E != 0 ):\r\n G = nx.DiGraph()\r\n cont = E\r\n while ( cont > 0 ):\r\n entrada = input()\r\n entrada = [int(i) for i in entrada.strip('\\n').strip(' ').split(' ')]\r\n\r\n X,Y,H = entrada\r\n G.add_edge(X,Y, weight = H)\r\n cont -= 1\r\n\r\n K = int(input())\r\n cont = K\r\n\r\n while ( cont > 0 ):\r\n entrada = input()\r\n entrada = [int(i) for i in entrada.strip('\\n').strip(' ').split(' ')]\r\n\r\n O,D = entrada\r\n M = 9999999999\r\n try:\r\n caminhos = nx.shortest_simple_paths(G, O, D)\r\n for caminho in list(caminhos):\r\n soma = 0\r\n for node in range(len(caminho)-1):\r\n if(not(nx.has_path(G, caminho[node+1], caminho[node]))):\r\n soma += G[caminho[node]][caminho[node+1]]['weight']\r\n if soma < M: M = soma\r\n except Exception as ex:\r\n print(\"Nao e possivel entregar a carta\")\r\n cont -= 1\r\n continue\r\n\r\n print(M)\r\n cont -= 1\r\n\r\n print()\r\n entrada = input()\r\n entrada = [int(i) for i in entrada.strip('\\n').strip(' ').split(' ')]\r\n N, E = entrada\r\n","sub_path":"5th/LPA/Provas/Prova2 da outra sala/paises/paises.py","file_name":"paises.py","file_ext":"py","file_size_in_byte":1327,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"378850325","text":"class Solution:\n def reorderList(self, head: ListNode) -> None:\n \"\"\"\n Do not return anything, modify head in-place instead.\n \"\"\"\n length = 0\n current = head\n while current is not None:\n length += 1\n current = current.next\n if length <= 2:\n return head\n half = length // 2\n current = head\n for i in range(half):\n prev = current\n current = current.next\n prev.next = None\n first = head\n second = self.reverse_list(current)\n current = first\n while first is not None:\n current = first\n first = first.next\n current.next = second\n temp = second.next\n second.next = first\n second = temp\n if (length % 2) != 0:\n second.next = None\n current.next.next = second\n return head\n\n def reverse_list(self, head: ListNode) -> ListNode:\n current = head\n while current is not None:\n temp = current.next\n current.next = head\n head = current\n current = temp\n return head\n","sub_path":"assignments/week2/day3/Daniel_Zabari_LC_140.py","file_name":"Daniel_Zabari_LC_140.py","file_ext":"py","file_size_in_byte":1181,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"508218239","text":"list1=[i for i in range(100) if i%3==0]\nprint(list1)\n\ndict1={i:f\"item{i}\" for i in range(10)}\ndict1={value:key for key,value in dict1.items()}\nprint(dict1)\n\nset1={st1 for st1 in ['dress1','dress2','dress1','dress2','dress1','dress2','dress1','dress2']}\n\nprint(set1)\n\n#generator comprehension\n\nevens=(i for i in range(100) if i%2==0)\n\nprint(evens.__next__())\nprint(evens.__next__())\n\nlist1=[]\n\na=int(input(\"Enter the limit of the list = \"))\n\nfor i in range(a):\n d=input(f\"enter the {i+1} element = \")\n list1.append(d)\na=int(input(\"1-List\\n2-Set\\n3-Dictionary\"))\n\nif(a==1):\n list2=[i for i in list1]\n print(type(list2))\n print(list2)\nelif (a==2):\n set1={i for i in list1}\n print(type(set1))\n print(set1)\nelif(a==3):\n dict1={i:f\"item{i}\" for i in list1}\n print(type(dict1))\n print(dict1)\n\n\n","sub_path":"comprehensions.py","file_name":"comprehensions.py","file_ext":"py","file_size_in_byte":820,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"151420112","text":"import numpy as np\r\n\r\nimport sqlalchemy\r\nfrom sqlalchemy.ext.automap import automap_base\r\nfrom sqlalchemy.orm import Session\r\nfrom sqlalchemy import create_engine, func\r\n\r\nfrom flask import Flask, jsonify\r\nfrom flask_cors import CORS, cross_origin\r\n\r\n#################################################\r\n# Database Setup\r\n#################################################\r\nengine = create_engine(\"postgres://iwmrxujo:3y_paPbLw9au1C16kHoCOJgz5aY-F63r@ruby.db.elephantsql.com:5432/iwmrxujo\")\r\n\r\n# reflect an existing database into a new model\r\nBase = automap_base()\r\n# reflect the tables\r\nBase.prepare(engine, reflect=True)\r\n\r\n# Save reference to the table\r\nprint(list(Base.classes))\r\nSongs = Base.classes[\"Top200Worldwide\"]\r\n\r\n#################################################\r\n# Flask Setup\r\n#################################################\r\napp = Flask(__name__)\r\ncors = CORS(app)\r\napp.config['CORS_HEADERS'] = 'Content-Type'\r\n\r\n#################################################\r\n# Flask Routes\r\n#################################################\r\n\r\n@app.route(\"/artist\")\r\n@cross_origin()\r\ndef top_artist():\r\n conn = engine.connect()\r\n sql = \"\"\"\r\n select * FROM (\r\n\tselect\r\n\t\tcountry, artist, total_streams,\r\n\t\tRANK() OVER (PARTITION BY country ORDER BY total_streams DESC) AS country_rank\r\n\t\tFROM (\r\n\t\t\tselect\r\n\t\t\t\tt.\"Country\" AS country, t.\"Artist\" as artist, TRUNC(SUM(t.\"Streams\"),0) AS total_streams\r\n\t\t\t\tfrom\r\n\t\t\t\t\t\"Top200Worldwide\" AS t\r\n\t\t\tGROUP BY t.\"Country\", t.\"Artist\"\r\n\t\t) AS query\r\n\t) AS ranks\r\n WHERE country_rank = 1\r\n \"\"\"\r\n results = conn.execute(sql)\r\n top_streams = []\r\n\r\n for artist in results:\r\n artist_streams = {}\r\n artist_streams[\"country\"] = artist.country\r\n artist_streams[\"artist\"] = artist.artist\r\n artist_streams[\"streams\"] = artist.total_streams\r\n top_streams.append(artist_streams)\r\n\r\n conn.close()\r\n return jsonify(top_streams)\r\n\r\n\r\n\r\n # for artist in results:\r\n # print(f\"{artist['artist']} had {artist['total_streams']} streams in {artist['country']}\")\r\n # session.close()\r\n # return \"yay\"\r\n\r\n@app.route(\"/spotify\")\r\n@cross_origin()\r\ndef spotify():\r\n session = Session(engine)\r\n results = session.query(Songs).all()\r\n songs = []\r\n\r\n for song in results:\r\n new_song = {}\r\n new_song[\"country\"] = song.Country\r\n new_song[\"track_name\"] = song.TrackName\r\n new_song[\"artist\"] = song.Artist\r\n new_song[\"streams\"] = song.Streams\r\n new_song[\"url\"] = song.URL\r\n new_song[\"position\"] = song.Position\r\n new_song[\"id\"] = song.pk\r\n songs.append(new_song)\r\n\r\n session.close()\r\n return jsonify(songs)\r\n\r\n# @app.route(\"/globe\")\r\n# def globe():\r\n# session = Session(engine)\r\n# results = session.query(Globe).all()\r\n# globe = []\r\n\r\n# pd.read_sql_query('select streams from artist', con=engine).head()\r\n\r\n\r\n\r\n# streams from\r\n# table\r\n# group by artist_name\r\n# order by streams desc\r\n# limit 1\r\n\r\n\r\n\r\n# @app.route(\"/api/v1.0/names\")\r\n# def names():\r\n# # Create our session (link) from Python to the DB\r\n# session = Session(engine)\r\n\r\n \"\"\"Return a list of all passenger names\"\"\"\r\n # Query all passengers\r\n results = session.query(Songs.name).all()\r\n\r\n session.close()\r\n\r\n\r\nif __name__ == '__main__':\r\n app.run(debug=True)","sub_path":"spotifyproject1/app.py","file_name":"app.py","file_ext":"py","file_size_in_byte":3333,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"154485396","text":"from algorithmes.tabou import tabouCalcul\nfrom algorithmes.bayesienne import findUsingBaye, trainBaye\nfrom database import db\nfrom algorithmes.utile import centrageSolo\nimport random\nimport copy\n\ndef evaluateBayesienne(hyperparameters):\n global testData\n succes = 0\n for data in testData:\n find = findUsingBaye(centrageSolo(data[\"data\"], 6, 8), hyperparameters)\n succes += 1 if find == int(data[\"solution\"]) else 0\n return succes\n\ndef trainBayesienne():\n tmp = db.getAllDataTrain()\n data = [centrageSolo(t['data'], 6, 8) for t in tmp]\n trainBaye(data, [t[\"solution\"] for t in tmp])\n tabouCalcul(96, evaluateBayesienne)\n\n\ntestData = db.getAllDataTest() + db.getAllDataTrain()\n\ntrainBayesienne()","sub_path":"Serveur/python-flask-server/swagger_server/train_baye.py","file_name":"train_baye.py","file_ext":"py","file_size_in_byte":731,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"108768633","text":"import random\nimport sched\nimport threading\nimport time\nfrom collections import defaultdict\nfrom datetime import datetime, timedelta\n\nimport psycopg2\nfrom psycopg2.extras import execute_values\n\ndbconn = None\n\n\ndef connect_to_db(name, user, host, psw):\n global dbconn\n dbconn = psycopg2.connect(database=name, user=user, host=host, password=psw)\n\n\nSTART_TIME = (12, 00)\nEND_TIME = (18, 00)\nFRIDAY = 4\n\nSAVE_ALL = 1\nSAVE_LAST = 2\nSAVE_NOTHING = 3\n\n\ndef shifted_timestamp(timestamp, shift):\n return timestamp - shift * 60 * 60\n\n\ndef next_event_time(time_shift):\n now = datetime.now()\n days_ahead = FRIDAY - now.weekday()\n if days_ahead <= 0:\n days_ahead += 7\n next_friday = now + timedelta(days_ahead)\n start = next_friday.replace(hour=START_TIME[0], minute=START_TIME[1])\n end = next_friday.replace(hour=END_TIME[0], minute=END_TIME[1])\n start_ts = shifted_timestamp(int(start.timestamp()), time_shift)\n end_ts = shifted_timestamp(int(end.timestamp()), time_shift)\n new_timets = random.randint(start_ts, end_ts)\n new_time = datetime.fromtimestamp(new_timets)\n return new_time\n\n\ndef fmt_choice(choice_name, count):\n return '{} ----> {}'.format(choice_name, count)\n\n\nclass Events(object):\n def __init__(self, bot):\n self.scheduler = sched.scheduler(timefunc=time.time)\n self.bot = bot\n\n def new_event(self, chat_info):\n event_time = chat_info.init_event()\n self.scheduler.enterabs(event_time.timestamp(), 1, self._process_event, (chat_info,))\n\n def _process_event(self, chat_info):\n chat_info.update()\n voting, created = Voting.get_or_create(chat_info)\n if created:\n self.bot.send_message(chat_id=chat_info.chat_id, text=voting.force_start_msg())\n self.new_event(chat_info)\n\n def start(self):\n self.scheduler.run()\n\n\nclass ChatInfo(object):\n def __init__(self, chat_id, save_mode, event_time, time_shift, users):\n self.chat_id = chat_id\n self.save_mode = save_mode\n self.event_time = event_time\n self.time_shift = time_shift\n self.users = users\n self.choices = self._get_choices()\n\n def update(self):\n (self.save_mode, self.event_time, self.time_shift, self.users), _ = self._prepare_data(self.chat_id)\n self.choices = self._get_choices()\n\n def init_event(self):\n event_time = self.event_time\n current_time = datetime.now()\n if current_time >= event_time:\n new_event_time = next_event_time(self.time_shift)\n with dbconn, dbconn.cursor() as cursor:\n cursor.execute('''UPDATE settings SET event_time=%s WHERE chat_id=%s;''',\n [new_event_time, self.chat_id])\n event_time = new_event_time\n return event_time\n\n @classmethod\n def _prepare_data(cls, chat_id):\n with dbconn, dbconn.cursor() as cursor:\n cursor.execute('''LOCK TABLE settings IN SHARE ROW EXCLUSIVE MODE;''')\n cursor.execute('''SELECT save_mode,event_time,time_shift,users FROM settings WHERE chat_id =%s;''',\n [chat_id])\n settings = cursor.fetchone()\n created = False\n if settings is None:\n cursor.execute('''\n INSERT INTO settings (chat_id) VALUES (%s) RETURNING save_mode,event_time,time_shift,users;\n ''', [chat_id])\n settings = cursor.fetchone()\n created = True\n return settings, created\n\n @classmethod\n def get_or_create(cls, chat_id):\n (save_mode, event_time, time_shift, users), created = cls._prepare_data(chat_id)\n return cls(chat_id, save_mode, event_time, time_shift, users), created\n\n @classmethod\n def get_all(cls):\n with dbconn, dbconn.cursor() as cursor:\n cursor.execute('''SELECT chat_id, save_mode,event_time,time_shift,users FROM settings;''')\n rows = cursor.fetchall()\n results = [cls(chat_id, save_mode, event_time, time_shift, users)\n for chat_id, save_mode, event_time, time_shift, users in rows]\n return results\n\n def _get_choices(self):\n with dbconn, dbconn.cursor() as cursor:\n cursor.execute('''SELECT choice FROM choices WHERE chat_id=%s;''', [self.chat_id])\n choices = [row[0] for row in cursor.fetchall()]\n return choices\n\n\ndef get_stats(chat_id):\n with dbconn, dbconn.cursor() as cursor:\n cursor.execute('''SELECT choice,count FROM stats WHERE chat_id=%s ORDER BY COUNT DESC;''', [chat_id])\n stats = cursor.fetchall()\n if not stats:\n return \"Пока никих муток не было.\"\n lines = [\"Ваши мутки:\"]\n for choice_name, count in stats:\n lines.append(fmt_choice(choice_name, count))\n return str.join('\\n', lines)\n\n\ndef _set_saving_mode(chat_id, save_mode):\n with dbconn, dbconn.cursor() as cursor:\n cursor.execute('''\n INSERT INTO settings (chat_id, save_mode) VALUES (%s, %s)\n ON CONFLICT (chat_id)\n DO UPDATE SET save_mode = %s;\n ''', [chat_id, save_mode, save_mode])\n voting = Voting.get(chat_id)\n if voting is not None:\n voting.set_save_mode(save_mode)\n\n\ndef enable_saving(chat_id):\n _set_saving_mode(chat_id, SAVE_ALL)\n\n\ndef save_only_last(chat_id):\n _set_saving_mode(chat_id, SAVE_LAST)\n\n\ndef disable_saving(chat_id):\n _set_saving_mode(chat_id, SAVE_NOTHING)\n\n\ndef change_timezone(chat_id, time_shift):\n with dbconn, dbconn.cursor() as cursor:\n cursor.execute('''\n INSERT INTO settings (chat_id, time_shift) VALUES (%s, %s)\n ON CONFLICT (chat_id)\n DO UPDATE SET time_shift = %s;\n ''', [chat_id, time_shift, time_shift])\n\n\ndef delete_all_choices(chat_id):\n with dbconn, dbconn.cursor() as cursor:\n cursor.execute('''\n DELETE FROM choices where chat_id=%s;\n ''', [chat_id])\n\n\ndef update_chat_users(chat_id, users):\n with dbconn, dbconn.cursor() as cursor:\n cursor.execute('''\n INSERT INTO settings (chat_id, users) VALUES (%s, %s)\n ON CONFLICT (chat_id)\n DO UPDATE SET users = %s;\n ''', [chat_id, users, users])\n voting = Voting.get(chat_id)\n if voting is not None:\n voting.set_users(users)\n\n\n# noinspection SqlResolve\nclass Voting(object):\n AMOUNT_OF_TOP = 3\n DoesNotExist = \"Даже не начинали мутить.\"\n _all_votes = {}\n _pool_lock = threading.Lock()\n ADDICTS_MESSAGES = (\n \"Наркоманы, без калика не могут\",\n \"Друзья мои наркоманы, опять в кальянную пойдут\",\n \"Опять калик курить, заебали\",\n \"Калик заебал уже\"\n )\n\n def __init__(self, chat_info):\n self.chat_id = chat_info.chat_id\n self.save_mode = chat_info.save_mode\n self.users = chat_info.users\n self._users_lock = threading.Lock()\n self._choices = defaultdict(set, **{name: set() for name in chat_info.choices})\n self._choices_lock = threading.Lock()\n\n def set_save_mode(self, save_mode):\n self.save_mode = save_mode\n\n def set_users(self, users):\n self._users_lock.acquire()\n self.users = users\n self._users_lock.release()\n\n @classmethod\n def get(cls, chat_id):\n voting = cls._all_votes.get(chat_id)\n return voting\n\n @classmethod\n def get_or_create(cls, chat_info):\n cls._pool_lock.acquire()\n voting = cls._all_votes.get(chat_info.chat_id)\n if voting is not None:\n cls._pool_lock.release()\n return voting, False\n voting = cls(chat_info)\n cls._all_votes[chat_info.chat_id] = voting\n cls._pool_lock.release()\n return voting, True\n\n def vote_for_choice(self, choice_name, user_id):\n self._choices_lock.acquire()\n for users in self._choices.values():\n users.discard(user_id)\n self._choices[choice_name].add(user_id)\n self._choices_lock.release()\n return fmt_choice(choice_name, len(self._choices[choice_name]))\n\n def end_of_voting(self):\n self._pool_lock.acquire()\n if self.save_mode == SAVE_ALL:\n self._save_choices()\n elif self.save_mode == SAVE_LAST:\n self._save_current_choices()\n\n top_choice = None\n rating = self._choices_rating()\n if rating:\n choice_name, choice_count = rating[0]\n if choice_count > 0:\n top_choice = choice_name\n if top_choice is not None:\n self._save_top_choice(top_choice)\n self._all_votes.pop(self.chat_id)\n self._pool_lock.release()\n\n def _save_choices(self):\n with dbconn, dbconn.cursor() as cursor:\n execute_values(cursor, '''\n INSERT INTO choices (chat_id, choice) VALUES %s\n ON CONFLICT (chat_id, choice)\n DO NOTHING\n ''', [(self.chat_id, choice_name) for choice_name in self._choices.keys()])\n\n def _save_current_choices(self):\n with dbconn, dbconn.cursor() as cursor:\n cursor.execute('''DELETE FROM choices WHERE chat_id = %s;''', [self.chat_id])\n execute_values(cursor, '''\n INSERT INTO choices (chat_id, choice) VALUES %s\n ON CONFLICT (chat_id, choice)\n DO NOTHING\n ''', [(self.chat_id, choice_name) for choice_name, voted_users in self._choices.items() if voted_users])\n\n def _save_top_choice(self, choice_name):\n with dbconn, dbconn.cursor() as cursor:\n cursor.execute('''\n INSERT INTO stats (chat_id, choice, count) VALUES (%s,%s,1)\n ON CONFLICT (chat_id, choice)\n DO UPDATE SET count = stats.count + 1;\n ''', [self.chat_id, choice_name])\n\n def _choices_rating(self):\n rating = [(tup[0], len(tup[1])) for tup in\n sorted(self._choices.items(), key=lambda tup: len(tup[1]), reverse=True)]\n return rating\n\n @classmethod\n def _combine_lines(cls, lines):\n return str.join('\\n', lines)\n\n def force_start_msg(self):\n phrase_beginning = \"Пятница епта, че мутим?\"\n if not self._choices:\n return phrase_beginning\n lines = [phrase_beginning + \" Есть следующие варики:\"]\n for choice in sorted(self._choices.keys()):\n lines.append(choice)\n return self._combine_lines(lines)\n\n def start_msg(self):\n phrase_beginning = \"Начались новые мутки, \"\n if not self._choices:\n return phrase_beginning + \"вариков пока нет.\"\n lines = [phrase_beginning + \"есть следующие варики:\"]\n for choice in sorted(self._choices.keys()):\n lines.append(choice)\n return self._combine_lines(lines)\n\n def _add_abstained_line(self, lines, users_count, votes_count):\n self._users_lock.acquire()\n if self.users is not None:\n abstained = self.users - votes_count\n else:\n abstained = users_count - votes_count - 1 # minus this bot\n self._users_lock.release()\n if abstained > 0:\n lines.append(\"{} вообще не голосовало.\".format(abstained))\n\n def during_msg(self, users_count):\n if not self._choices:\n return \"Вариков пока нет.\"\n lines = [\"Варики:\"]\n rating = self._choices_rating()\n votes_count = 0\n for choice_name, count in rating:\n lines.append(fmt_choice(choice_name, count))\n votes_count += count\n self._add_abstained_line(lines, users_count, votes_count)\n return self._combine_lines(lines)\n\n def addicts_text(self):\n rating = self._choices_rating()\n if not rating:\n return None\n choice_name, count = rating[0]\n if count == 0 or not ('калик' in choice_name or 'кальян' in choice_name):\n return None\n return random.choice(self.ADDICTS_MESSAGES)\n\n def end_msg(self, users_count):\n rating = self._choices_rating()\n rating = [(choice_name, count) for choice_name, count in rating if count > 0]\n phrase_beginning = \"Мутки окончены, \"\n if not rating:\n return phrase_beginning + \"нихуя не выбрали.\"\n lines = [phrase_beginning + \"топ {}:\".format(self.AMOUNT_OF_TOP)]\n for i, (choice_name, count) in enumerate(rating):\n if i >= self.AMOUNT_OF_TOP:\n break\n lines.append(fmt_choice(choice_name, count))\n votes_count = sum(count for _, count in rating)\n self._add_abstained_line(lines, users_count, votes_count)\n return self._combine_lines(lines)\n","sub_path":"models.py","file_name":"models.py","file_ext":"py","file_size_in_byte":12934,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"188887175","text":"import subprocess\nimport os\n\nall_files = \"curl http://0.0.0.0:8101/files/0/all\"\ndelete = [\"curl http://0.0.0.0:8101/files/0/test.txt -X DELETE -v\", \"curl http://0.0.0.0:8101/files/1/test.json -X DELETE -v\"]\nread_file = \"curl http://0.0.0.0:8101/data/0/test.txt -X GET -v\"\ncreate_file = \"curl http://0.0.0.0:8101/data/0/test.txt -d data='TEXTDATA' -X POST -v\"\nupload_file = \"curl -i -X POST -F files=@input.txt http://0.0.0.0:8101/upload/1/pi.json\"\nshow_db = \"curl http://0.0.0.0:8101/db -X GET -v\"\n\ncur_dir = \"/Users/Amar/Desktop/ugradproj/server/pythonserver/test2\"\n\n\"\"\" File functions \"\"\"\n\ndef show_all_files():\n\tsubprocess.call([\"curl\", \"http://0.0.0.0:8101/files/0/all\", \"-v\"], shell=False)\n\ndef delete_file(file_name, db=False):\n\tif db:\n\t\turl = \"http://0.0.0.0:8101/files/1/%s\" % file_name\n\telse:\n\t\turl = \"http://0.0.0.0:8101/files/0/%s\" % file_name\n\t\n\tsubprocess.call([\"curl\", url, \"-X\", \"DELETE\", \"-v\"], shell=False)\n\ndef read_file(file_name):\n\turl = \"http://0.0.0.0:8101/data/0/%s\" % file_name\n\tsubprocess.call([\"curl\", url, \"-X\", \"GET\", \"-v\"], shell=False)\n\ndef create_file(file_name, data, db=False):\n\tif db:\n\t\turl = \"http://0.0.0.0:8101/data/1/%s\" % file_name\n\telse:\n\t\turl = \"http://0.0.0.0:8101/data/0/%s\" % file_name\n\t\n\tdata = \"data=%s\" % data\n\tsubprocess.call([\"curl\", url, \"-d\", data, \"-X\", \"POST\", \"-v\"], shell=False)\t\n\ndef upload_file(file_name, upload_file_name, cur_dir, db=False):\n\tif db:\n\t\turl = \"http://0.0.0.0:8101/upload/1/%s\" % upload_file_name\n\telse:\n\t\turl = \"http://0.0.0.0:8101/upload/0/%s\" % upload_file_name\n\n\tos.chdir(cur_dir)\n\tlocal_file = \"files=@%s\" % file_name\n\tsubprocess.call([\"curl\", \"-i\", \"-X\", \"POST\", \"-F\", local_file, url], shell=False)\n\n\n\"\"\" Database funtions \"\"\"\n\ndef get_collection():\n\turl = \"http://0.0.0.0:8101/db\"\n\tsubprocess.call([\"curl\", url, \"-X\", \"GET\", \"-v\"], shell=False)\t\n\n#def check_if_real_mac(mac):\n#\t#mac = \"F0:FB:FB:01:FA:21\" \n#\tmac = str(mac)\n#\tmac_new = mac.replace(\":\", \"%3A\")\n#\turl = \"http://api.macvendors.com/\" + mac_new\n#\tvendor = subprocess.check_output([\"curl\", url, \"-s\"], shell=False)\t\n#\t\n#\tif len(vendor):\n#\t\treturn vendor\n#\telse:\n#\t\treturn False \n\n# show_all_files()\n# delete_file(\"test.txt\")\n# delete_file(\"test.json\", db=True)\n# read_file(\"test.txt\")\n# create_file(\"test.txt\", \"This is simple text file!\")\n# upload_file(\"pi.json\", \"test.json\", cur_dir, db=True)\n\n# get_collection()\n#check_real_mac()\n","sub_path":"pythonserver/test2/curl_test.py","file_name":"curl_test.py","file_ext":"py","file_size_in_byte":2375,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"598510924","text":"#!/usr/bin/env python\n# install_twisted_rector must be called before importing and using the reactor\nfrom kivy.support import install_twisted_reactor\ninstall_twisted_reactor()\n\nSTUDY_SITE = 'TAU' #'TAU' # MIT\n\nif STUDY_SITE == 'MIT':\n from tega import Tega\nelif STUDY_SITE == 'TAU':\n from nao import Nao\n\nfrom twisted.internet import reactor\nfrom twisted.internet import protocol\n\nimport rospy\nfrom std_msgs.msg import String\n\nimport json\n\n\nclass EchoProtocol(protocol.Protocol):\n\n def dataReceived(self, data):\n #called when the client sends a message to the server\n print(\"dataReceived\", data)\n response = self.factory.app.handle_message(data, self)\n\n def sendMessage(self, msg):\n #called when sending a message back to the client\n print(\"sendMessage\",msg)\n self.transport.write(msg)\n\n\nclass EchoFactory(protocol.Factory):\n\n def __init__(self, app):\n self.app = app\n self.protocol = EchoProtocol\n\n\nfrom kivy.app import App\nfrom kivy.uix.label import Label\n\n\nclass TwistedServerApp(App):\n publishers = {}\n factory = None\n label = None\n protocols = {} # {ip1:protocol, ip2:protocol, ip3:protocol}\n\n def build(self):\n self.label = Label(text=\"server started\\n\")\n self.factory = EchoFactory(self)\n reactor.listenTCP(8000, self.factory)\n rospy.init_node('twisted_node')\n #rospy.Subscriber(\"to_twisted\", String, self.transmit_msg) #not using this\n rospy.Subscriber(\"to_tablet\", String, self.callback_to_tablet)\n # if STUDY_SITE == 'MIT':\n # self.publishers['tega'] = Tega(self)\n # elif STUDY_SITE == 'TAU':\n # self.publishers['nao'] = Nao(self)\n # return self.label\n\n def handle_message(self, msg, protocol_in):\n print(\"twisted_server_ros: handle_message\")\n #print(\"protocol_in.ip:\", protocol_in.ip)\n #protocol_in_vars = vars(protocol_in)\n # JUST DID THAT TO FIND WHERE THE CLIENT IP IS\n # for item in protocol_in_vars.items():\n # print(\"item:\", item)\n #\n # factory = protocol_in.factory\n # for itemFactory in vars(factory).items():\n # print(\"itemFactory\",itemFactory)\n #\n # transport = protocol_in.transport\n # for itemTransport in vars(transport).items():\n # print(\"itemTransport\", itemTransport)\n #\n client_ip = protocol_in.transport.client[0] #this is how to find the client ip\n print(\"client_ip\", client_ip)\n #if client_ip not in self.protocols_ip:\n # print(\"added new protocol\")\n # self.protocols_ip.append (client_ip)\n self.protocols[client_ip]=protocol_in #if the client_ip is not in the dictionary it will be added to it.\n\n\n print('self.protocol', self.protocols)\n self.label.text = \"received: %s\\n\" % msg\n try:\n print(\"msg\", msg)\n # print(\"msg json\", json.loads(str(msg)))\n msgs = []\n spl = msg.split('}{')\n print(spl)\n for k in range(0, len(spl)):\n the_msg = spl[k]\n if k > 0:\n the_msg = '{' + the_msg\n if k < (len(spl)-1):\n the_msg = the_msg + '}'\n json_msg = json.loads(the_msg)\n msgs.append(json_msg)\n print (msgs)\n for m in msgs:\n for topic, message in m.items():\n topic = str(topic)\n message[\"client_ip\"] = client_ip #I'm adding ip so that on callback_nao_state I can send the message to the correct client\n message = json.dumps(message)\n #print(\"message\",message, \"message type\", type(message))\n self.send_message(topic, message)\n except:\n print(\"err\")\n if 'from_twisted' not in self.publishers:\n self.publishers['from_twisted'] = rospy.Publisher('from_twisted', String, queue_size=10)\n self.publishers['from_twisted'].publish(msg)\n self.label.text += \"published: %s\\n\" % msg\n\n # remove when tega is connected\n # self.protocol.sendMessage(msg)\n return msg\n\n def send_message(self, topic, message):\n print(\"twisted_server_ros: send_message\")\n if topic != 'tega' and topic != 'nao':\n message = str(message)\n if topic not in self.publishers:\n self.publishers[topic] = rospy.Publisher(topic, String, queue_size=10)\n self.publishers[topic].publish(message)\n print('published to ', topic, message)\n\n\n # def transmit_msg(self, data):\n # print('twisted_server_ros: transmit_msg', data.data)\n # self.label.text = 'transmitting ' + str(data.data)\n # try:\n # # if self.protocol:\n # # self.protocol.sendMessage(data.data)\n # message_json = json.loads(data.data)\n # client_ip = str(message_json[\"client_ip\"])\n # self.protocols[client_ip].sendMessage(str(json.dumps(message_json)))\n # except:\n # print(\"failed to transmit_msg\")\n\n def callback_to_tablet (self, data):\n print('twisted_server_ros: transmit_msg', data.data)\n self.label.text = 'transmitting ' + str(data.data)\n try:\n #if self.protocol:\n # self.protocol.sendMessage(data.data)\n message_json = json.loads(data.data)\n client_ip = str(message_json[\"client_ip\"])\n self.protocols[client_ip].sendMessage(str(json.dumps(message_json)))\n except:\n print(\"failed to transmit_msg\")\nif __name__ == '__main__':\n TwistedServerApp().run()","sub_path":"nao_comm/twisted_server_ros.py","file_name":"twisted_server_ros.py","file_ext":"py","file_size_in_byte":5721,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"334954213","text":"# Copyright (C) 2011 Computation Institute\n#\n__author__ = 'vas@ci.uchicago.edu (Vas Vasiliadis)'\n\n# Set debug flag for testing purposes\n_GO_DEBUG = True\n\n# Contact details\nif _GO_DEBUG:\n _ADMIN_NOTIFY_EMAIL = 'vas@exordium.com'\n _FEEDBACK_EMAIL = 'vas@exordium.com'\nelse:\n _ADMIN_NOTIFY_EMAIL = 'vas@ci.uchicago.edu'\n _FEEDBACK_EMAIL = 'vas@ci.uchicago.edu'\n\n# Names of static content pages/templates (don't include .html extension]\n_STATIC_PAGES = ['contact_us', 'faq', 'feedback', 'privacy', 'quickstart', 'terms',]\n\n# General application settings and defaults\n_DEFAULT_PAGE_SIZE = 20 # Number of records to display on table pages; must be user configurable\n\n# User Profile status codes\n_USER_PENDING = 'Pending' # User profile has been created but not verified\n_USER_ACTIVE = 'Active' # user profile verified and active\n_USER_INACTIVE = 'Inactive'\n","sub_path":"zgo_globals.py","file_name":"zgo_globals.py","file_ext":"py","file_size_in_byte":921,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"30425055","text":"# path importanti /home/zluca/Documents/tensorflow/models/research\n# path importanti /home/zluca/Documents/tensorflow/models/research/slim\n\n#add the tensorflow object detection\nimport sys\nsys.path.append(\"/home/zluca/Documents/tensorflow/models/research/\")\nsys.path.append(\"/home/zluca/Documents/tensorflow/models/research/slim/\")\nsys.path.append(\"..\")\n\n#utilities \nfrom object_detection.utils import label_map_util\nfrom object_detection.utils import visualization_utils as vis_util\n\n#import of python stuff\nimport numpy as np\nimport os\nimport six.moves.urllib as urllib\nimport tarfile\nimport tensorflow as tf\nimport zipfile\n \n#collection stuff \nfrom collections import defaultdict\nfrom io import StringIO\nfrom matplotlib import pyplot as plt\nfrom PIL import Image\n\n#opencv \nimport cv2 as cv \ncap = cv.VideoCapture(0)\n\n#define frame\nFRAME = 0 \n\n#file \nout = open('/home/zluca/Documents/labInternship/Output/outputVideo.txt', \"w\")\n\nif(sys.argv is '1'): \n\n MODEL_NAME = 'ssd_mobilenet_v1_coco_11_06_2017'\n MODEL_FILE = MODEL_NAME + '.tar.gz'\n DOWNLOAD_BASE = 'http://download.tensorflow.org/models/object_detection/'\n \n # Path to frozen detection graph. This is the actual model that is used for the object detection.\n PATH_TO_CKPT = MODEL_NAME + '/frozen_inference_graph.pb'\n \n # List of the strings that is used to add correct label for each box.\n #PATH_TO_LABELS = os.path.join('data', 'mscoco_label_map.pbtxt')\n PATH_TO_LABELS = '/home/zluca/Documents/tensorflow/models/research/object_detection/data/mscoco_label_map.pbtxt'\n \n NUM_CLASSES = 90\n\n #here I dowload the model \n opener = urllib.request.URLopener() \n opener.retrieve(DOWNLOAD_BASE + MODEL_FILE, MODEL_FILE)\n tar_file = tarfile.open(MODEL_FILE)\n for file in tar_file.getmembers():\n file_name = os.path.basename(file.name)\n if 'frozen_inference_graph.pb' in file_name:\n tar_file.extract(file, os.getcwd())\nelse: \n PATH_TO_CKPT = '/home/zluca/Documents/labInternship/pre_trained_coco/ssdMobileNet_v1/frozen_inference_graph.pb'\n PATH_TO_LABELS = '/home/zluca/Documents/tensorflow/models/research/object_detection/data/mscoco_label_map.pbtxt' \n NUM_CLASSES = 90\n\n#before starting write information to file \nout.writelines(\"Video detection\\n\")\nout.writelines(\"Path to model: \" + PATH_TO_CKPT + \"\\n\")\nout.writelines(\"Path to label: \" + PATH_TO_LABELS + \"\\n\")\nout.writelines(\"Classes: \" + str(NUM_CLASSES) + \"\\n\\n\")\n\n\n#start to create the model \ndetection_graph = tf.Graph()\nwith detection_graph.as_default():\n od_graph_def = tf.GraphDef()\n with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:\n serialized_graph = fid.read()\n od_graph_def.ParseFromString(serialized_graph)\n tf.import_graph_def(od_graph_def, name='')\n\n#try to give name to object \nlabel_map = label_map_util.load_labelmap(PATH_TO_LABELS)\ncategories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=NUM_CLASSES, use_display_name=True)\ncategory_index = label_map_util.create_category_index(categories)\n\nwith detection_graph.as_default():\n with tf.Session(graph=detection_graph) as sess:\n while True:\n ret, image_np = cap.read()\n #try to expand dim\n image_np_expanded = np.expand_dims(image_np, axis=0)\n image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')\n boxes = detection_graph.get_tensor_by_name('detection_boxes:0')\n scores = detection_graph.get_tensor_by_name('detection_scores:0')\n classes = detection_graph.get_tensor_by_name('detection_classes:0')\n num_detections = detection_graph.get_tensor_by_name('num_detections:0')\n\n #detection\n (boxes, scores, classes, num_detections) = sess.run(\n [boxes, scores, classes, num_detections],\n feed_dict={image_tensor: image_np_expanded})\n\n out.writelines(\"Frame number: \" + str(FRAME) + \"\\n\")\n out.writelines(\"Number of Detection \" + str(num_detections) + \"\\n\")\n out.writelines(\"Score: \" + str(scores) + \"\\n\")\n out.writelines(\"class: \" + str(classes) + \"\\n\")\n out.writelines(\"############\" + \"\\n\\n\")\n FRAME = FRAME + 1\n\n #visual \n vis_util.visualize_boxes_and_labels_on_image_array(\n image_np,\n np.squeeze(boxes),\n np.squeeze(classes).astype(np.int32),\n np.squeeze(scores),\n category_index,\n use_normalized_coordinates=True,\n line_thickness=8)\n \n cv.imshow('object detection', cv.resize(image_np, (800,600)))\n if cv.waitKey(25) & 0xFF == ord('q'):\n cv.destroyAllWindows()\n out.close()\n break\n\n\n","sub_path":"videoDetect.py","file_name":"videoDetect.py","file_ext":"py","file_size_in_byte":4531,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"132494347","text":"# -*-coding: utf-8-*-\nimport numpy as np\nimport glob\nfrom tqdm import *\nimport os\nimport sys\n\ndef Motion_Data_Preprocessing(time_step=100, seed_timestep=20, batch_Frame=5 ,TEST=False , Model=1):\n \n np.set_printoptions(threshold=1000000)\n\n if TEST==False:\n file_directory = glob.glob(\"Dataset/Training/*.bvh\")\n else:\n file_directory = glob.glob(\"Dataset/Test/Model{}/*.bvh\".format(Model))\n if file_directory == list():\n print(\"Data does not exist\")\n sys.exit(0)\n\n time_step = time_step\n seed_timestep = seed_timestep\n batch_Frame = batch_Frame\n xyz_position = 3\n complexity = False\n Data = []\n train_label_motion = []\n\n '''data normalization'''\n Normalization_factor = 1\n dtype = \"int\"\n\n\n for file_name, i in tqdm(zip(file_directory, range(len(file_directory)))):\n # time.sleep(0.01)\n Raw = []\n Mdata = []\n MOTION = False\n '''1.basic - Motion data preprocessing'''\n print('Processed Data : {}'.format(i + 1))\n try:\n with open(file_name, 'r') as f:\n while True:\n line = f.readline()\n if line == 'MOTION' + \"\\n\" or MOTION:\n MOTION = True\n Raw.append(line)\n if not line:\n break\n for raw in Raw[3:]:\n # Xposition Yposition Zposition 는 제외\n if dtype == \"int\":\n temp = raw.split()[xyz_position:]\n if complexity:\n temp = [np.float32(i) * Normalization_factor for i in temp]\n else: # complexity = False\n temp = [np.floor(np.float32(i)) * Normalization_factor for i in temp]\n else: # dtype=\"str\"\n temp = raw.split()[xyz_position:]\n Mdata.append(temp)\n # Remove the blank line..\n Mdata.pop()\n\n '''2. Motion data preprocessing - easy for deeplearning'''\n\n # data padding\n if len(Mdata) < time_step:\n frame = np.zeros(shape=(time_step - len(Mdata), len(Mdata[0])))\n for i in range(time_step - len(Mdata)):\n frame[i] = Mdata[-1]\n Mdata = np.concatenate((Mdata, frame), axis=0)\n else:\n Mdata = Mdata[:time_step]\n Data.append(Mdata)\n except Exception as e:\n raise e\n\n '''3.final - Motion data preprocessing'''\n for i in range(len(file_directory)):\n train_label_motion.append(Data[i][seed_timestep:])\n\n print(\"-------------------Data Shape--------------------\")\n print(\"train_motion shape = {}\".format(np.shape(Data)))\n print(\"train_label_motion shape = {}\".format(np.shape(train_label_motion)))\n print(\"\\n\")\n\n train_motion = np.reshape(Data, (len(file_directory), int(time_step / batch_Frame), len(Data[0][0]) * batch_Frame))\n train_label_motion = np.reshape(train_label_motion, (len(file_directory), int((time_step-seed_timestep) / batch_Frame), len(Data[0][0]) * batch_Frame))\n\n print(\"-------------------Transform Data Shape--------------------\")\n print(\"transform_motion shape = {}\".format(np.shape(train_motion)))\n print(\"transform_label_motion shape = {}\".format(np.shape(train_label_motion)))\n print(\"\\n\")\n\n return Normalization_factor, train_motion, train_label_motion, int(seed_timestep / batch_Frame), int(\n (time_step - seed_timestep) / batch_Frame), len(train_motion[0][0]), file_directory\n\nif __name__ == \"__main__\":\n\n print('Motion_Data_Preprocessing_Starting In Main')\n Normalization_factor, train_motion, train_label_motion, seed_timestep, pre_timestep, column, file_directory = Motion_Data_Preprocessing(time_step=100, seed_timestep=20, batch_Frame=1 , TEST=False)\n\n print(\"new seed_timestep : {}\".format(seed_timestep))\n print(\"new prediction_timestep : {}\".format(pre_timestep))\n print(\"new Motion_rotation_data : {}\".format(column))\n\nelse:\n print(\"Motion_Data_Preprocessing_Imported\")\n","sub_path":"DeepHumanPrediction/Code/Master_Thesis/Human Motion Analysis/Motion Generation/bvh_reader.py","file_name":"bvh_reader.py","file_ext":"py","file_size_in_byte":4125,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"328068193","text":"# -*- coding: utf-8 -*-\n\"\"\"Ce module contient la classe Echiquier, une classe regroupant diverses pièces sur un plateau de jeu.\n\n\"\"\"\nimport pychecs\nfrom pychecs.piece import Pion, Tour, Fou, Cavalier, Dame, Roi\n\nfrom pychecs2.echecs.exception import (AucunePieceAPosition, MauvaiseCouleurPiece, ErreurDeplacement)\n\n\nclass Echiquier:\n \"\"\"Classe Echiquier, implémentée avec un dictionnaire de pièces.\n\n Attributes:\n dictionnaire_pieces (dict): Un dictionnaire dont les clés sont des positions, suivant le format suivant:\n Une position est une chaîne de deux caractères.\n Le premier caractère est une lettre entre a et h, représentant la colonne de l'échiquier.\n Le second caractère est un chiffre entre 1 et 8, représentant la rangée de l'échiquier.\n chiffres_rangees (list): Une txtListe contenant, dans l'ordre, les chiffres représentant les rangées.\n lettres_colonnes (list): Une txtListe contenant, dans l'ordre, les lettres représentant les colonnes.\n\n \"\"\"\n def __init__(self):\n # Le dictionnaire de pièces, vide au départ, mais ensuite rempli par la méthode initialiser_echiquier_depart().\n self.dictionnaire_pieces = {}\n\n # Ces listes pourront être utilisées dans les autres méthodes, par exemple pour valider une position.\n self.chiffres_rangees = ['1', '2', '3', '4', '5', '6', '7', '8']\n self.lettres_colonnes = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']\n\n self.initialiser_echiquier_depart()\n\n def position_est_valide(self, position):\n \"\"\"Vérifie si une position est valide (dans l'échiquier). Une position est une concaténation d'une lettre de\n colonne et d'un chiffre de rangée, par exemple 'a1' ou 'h8'.\n\n Args:\n position (str): La position à valider.\n\n Returns:\n bool: True si la position est valide, False autrement.\n\n \"\"\"\n if len(position) != 2:\n return False\n\n if position[0] not in self.lettres_colonnes:\n return False\n\n if position[1] not in self.chiffres_rangees:\n return False\n\n return True\n\n def recuperer_piece_a_position(self, position):\n \"\"\"Retourne la pièce qui est située à une position particulière, reçue en argument. Si aucune pièce n'est\n située à cette position, retourne None.\n\n Args:\n position (str): La position où récupérer la pièce.\n\n Returns:\n Piece or None: Une instance de type Piece si une pièce était située à cet endroit, et None autrement.\n\n \"\"\"\n if position not in self.dictionnaire_pieces:\n return None\n\n return self.dictionnaire_pieces[position]\n\n def couleur_piece_a_position(self, position):\n \"\"\"Retourne la couleur de la pièce située à la position reçue en argument, et une chaîne vide si aucune\n pièce n'est à cet endroit.\n\n Args:\n position (str): La position où récupérer la couleur de la pièce.\n\n Returns:\n str: La couleur de la pièce s'il y en a une, et '' autrement.\n\n \"\"\"\n piece = self.recuperer_piece_a_position(position)\n if piece is None:\n return ''\n\n return piece.couleur\n\n def rangees_entre(self, rangee_debut, rangee_fin):\n \"\"\"Retourne la txtListe des rangées qui sont situées entre les deux rangées reçues en argument, exclusivement.\n Attention de conserver le bon ordre.\n\n Args:\n rangee_debut (str): Le caractère représentant la rangée de début, par exemple '1'.\n rangee_fin (str): Le caractère représentant la rangée de fin, par exemple '4'.\n\n Exemple:\n >>> echiquer.rangees_entre('1', '1')\n []\n >>> echiquier.rangees_entre('2', '3')\n []\n >>> echiquier.rangees_entre('2', '8')\n ['3', '4', '5', '6', '7']\n >>> echiquier.rangees_entre('8', '3')\n ['7', '6', '5', '4']\n\n Indice:\n Utilisez self.chiffres_rangees pour obtenir une txtListe des rangées valides.\n\n Returns:\n list: Une txtListe des rangées (en str) entre le début et la fin, dans le bon ordre.\n\n \"\"\"\n index_debut = self.chiffres_rangees.index(rangee_debut)\n index_fin = self.chiffres_rangees.index(rangee_fin)\n if index_debut <= index_fin:\n direction = 1\n else:\n direction = -1\n\n return self.chiffres_rangees[index_debut+direction:index_fin:direction]\n\n def colonnes_entre(self, colonne_debut, colonne_fin):\n \"\"\"Retourne la txtListe des colonnes qui sont situées entre les deux colonnes reçues en argument, exclusivement.\n Attention de conserver le bon ordre.\n\n Args:\n colonne_debut (str): Le caractère représentant la colonne de début, par exemple 'a'.\n colonne_fin (str): Le caractère représentant la colonne de fin, par exemple 'h'.\n\n Exemple:\n >>> echiquer.colonnes_entre('a', 'a')\n []\n >>> echiquier.colonnes_entre('b', 'c')\n []\n >>> echiquier.colonnes_entre('b', 'h')\n ['c', 'd', 'e', 'f', 'g']\n >>> echiquier.colonnes_entre('h', 'c')\n ['g', 'f', 'e', 'd']\n\n Indice:\n Utilisez self.lettres_colonnes pour obtenir une txtListe des colonnes valides.\n\n Returns:\n list: Une txtListe des colonnes (en str) entre le début et la fin, dans le bon ordre.\n\n \"\"\"\n index_debut = self.lettres_colonnes.index(colonne_debut)\n index_fin = self.lettres_colonnes.index(colonne_fin)\n if index_debut <= index_fin:\n direction = 1\n else:\n direction = -1\n\n return self.lettres_colonnes[index_debut+direction:index_fin:direction]\n\n def chemin_libre_entre_positions(self, position_source, position_cible):\n \"\"\"Vérifie si la voie est libre entre deux positions, reçues en argument. Cette méthode sera pratique\n pour valider les déplacements: la plupart des pièces ne peuvent pas \"sauter\" par dessus d'autres pièces,\n il faut donc s'assurer qu'il n'y a pas de pièce dans le chemin.\n\n On distingue quatre possibilités (à déterminer dans votre code): Soit les deux positions sont sur la même\n rangée, soit elles sont sur la même colonne, soit il s'agit d'une diagonale, soit nous sommes dans une\n situation où nous ne pouvons pas chercher les positions \"entre\" les positions source et cible. Dans les trois\n premiers cas, on fait la vérification et on retourne True ou False dépendamment la présence d'une pièce ou non.\n Dans la dernière situation, on considère que les positions reçues sont invalides et on retourne toujours False.\n\n Args:\n position_source (str): La position source.\n position_cible (str): La position cible.\n\n Warning:\n Il ne faut pas vérifier les positions source et cible, puisqu'il peut y avoir des pièces à cet endroit.\n Par exemple, si une tour \"mange\" un pion ennemi, il y aura une tour sur la position source et un pion\n sur la position cible.\n\n Returns:\n bool: True si aucune pièce n'est située entre les deux positions, et False autrement (ou si les positions\n ne permettaient pas la vérification).\n\n \"\"\"\n colonne_source, colonne_cible = position_source[0], position_cible[0]\n rangee_source, rangee_cible = position_source[1], position_cible[1]\n\n # Si les colonnes source et cible sont la même, on vérifie si le champs est libre pour chaque rangée.\n if colonne_source == colonne_cible:\n for rangee in self.rangees_entre(rangee_source, rangee_cible):\n if self.recuperer_piece_a_position('{}{}'.format(colonne_source, rangee)) is not None:\n return False\n\n return True\n\n # Si les rangées source et cible sont la même, on vérifie si le champs est libre pour chaque colonne.\n if rangee_source == rangee_cible:\n for colonne in self.colonnes_entre(colonne_source, colonne_cible):\n if self.recuperer_piece_a_position('{}{}'.format(colonne, rangee_source)) is not None:\n return False\n\n return True\n\n # Si on se rend ici, c'est soit une diagonale, soit quelque chose d'invalide.\n colonnes = self.colonnes_entre(colonne_source, colonne_cible)\n rangees = self.rangees_entre(rangee_source, rangee_cible)\n if len(colonnes) != len(rangees):\n # Erreur, ce n'est ni une ligne, ni une diagonale\n return False\n\n i = 0\n while i < len(rangees):\n if self.recuperer_piece_a_position('{}{}'.format(colonnes[i], rangees[i])) is not None:\n return False\n i += 1\n\n return True\n\n def deplacement_est_valide(self, position_source, position_cible):\n \"\"\"Vérifie si un déplacement serait valide dans l'échiquier actuel. Notez que chaque type de\n pièce se déplace de manière différente, vous voudrez probablement utiliser le polymorphisme :-).\n\n Règles pour qu'un déplacement soit valide:\n 1. Il doit y avoir une pièce à la position source.\n 2. La position cible doit être valide (dans l'échiquier).\n 3. Si la pièce ne peut pas sauter, le chemin doit être libre entre les deux positions.\n 4. S'il y a une pièce à la position cible, elle doit être de couleur différente.\n 5. Le déplacement doit être valide pour cette pièce particulière.\n\n Args:\n position_source (str): La position source du déplacement.\n position_cible (str): La position cible du déplacement.\n\n Returns:\n bool: True si le déplacement est valide, et False autrement.\n\n \"\"\"\n # On s'assure que la position source contient une pièce.\n piece = self.recuperer_piece_a_position(position_source)\n\n if piece is None:\n return False\n\n # On s'assure que la position cible est valide (dans l'échiquier)\n if not self.position_est_valide(position_cible):\n return False\n\n # Si la pièce sélectionnée ne peut pas sauter, on vérifie si le chemin\n # est libre entre les deux positions.\n if not piece.peut_sauter:\n if not self.chemin_libre_entre_positions(position_source, position_cible):\n return False\n\n piece_cible = self.recuperer_piece_a_position(position_cible)\n if piece_cible is not None:\n if piece_cible.couleur == piece.couleur:\n return False\n\n else:\n return piece.peut_faire_une_prise_vers(position_source, position_cible)\n\n return piece.peut_se_deplacer_vers(position_source, position_cible)\n\n def deplacer(self, position_source, position_cible):\n \"\"\"Effectue le déplacement d'une pièce en position source, vers la case en position cible. Vérifie d'abord\n si le déplacement est valide, et ne fait rien (puis retourne False) dans ce cas. Si le déplacement est valide,\n il est effectué (dans l'échiquier actuel) et la valeur True est retournée.\n\n Args:\n position_source (str): La position source.\n position_cible (str): La position cible.\n\n Returns:\n bool: True si le déplacement était valide et a été effectué, et False autrement.\n\n \"\"\"\n\n\n\n if not self.deplacement_est_valide(position_source, position_cible):\n raise ErreurDeplacement('Déplacement invalide')\n\n self.dictionnaire_pieces[position_cible] = self.dictionnaire_pieces[position_source]\n del self.dictionnaire_pieces[position_source]\n\n\n def roi_de_couleur_est_dans_echiquier(self, couleur):\n \"\"\"Vérifie si un roi de la couleur reçue en argument est présent dans l'échiquier.\n\n Args:\n couleur (str): La couleur (blanc ou noir) du roi à rechercher.\n\n Returns:\n bool: True si un roi de cette couleur est dans l'échiquier, et False autrement.\n\n \"\"\"\n for piece in self.dictionnaire_pieces.values():\n if isinstance(piece, Roi):\n if piece.couleur == couleur:\n return True\n\n return False\n\n def initialiser_echiquier_depart(self):\n \"\"\"Initialise l'échiquier à son contenu initial. Pour faire vos tests pendant le développement,\n nous vous suggérons de vous fabriquer un échiquier plus simple, en modifiant l'attribut\n dictionnaire_pieces de votre instance d'Echiquier.\n\n \"\"\"\n self.dictionnaire_pieces = {\n 'a1': Tour('blanc'),\n 'b1': Cavalier('blanc'),\n 'c1': Fou('blanc'),\n 'd1': Dame('blanc'),\n 'e1': Roi('blanc'),\n 'f1': Fou('blanc'),\n 'g1': Cavalier('blanc'),\n 'h1': Tour('blanc'),\n 'a2': Pion('blanc'),\n 'b2': Pion('blanc'),\n 'c2': Pion('blanc'),\n 'd2': Pion('blanc'),\n 'e2': Pion('blanc'),\n 'f2': Pion('blanc'),\n 'g2': Pion('blanc'),\n 'h2': Pion('blanc'),\n 'a7': Pion('noir'),\n 'b7': Pion('noir'),\n 'c7': Pion('noir'),\n 'd7': Pion('noir'),\n 'e7': Pion('noir'),\n 'f7': Pion('noir'),\n 'g7': Pion('noir'),\n 'h7': Pion('noir'),\n 'a8': Tour('noir'),\n 'b8': Cavalier('noir'),\n 'c8': Fou('noir'),\n 'd8': Dame('noir'),\n 'e8': Roi('noir'),\n 'f8': Fou('noir'),\n 'g8': Cavalier('noir'),\n 'h8': Tour('noir'),\n }\n\n def __repr__(self):\n \"\"\"Affiche l'échiquier à l'écran. Utilise des codes Unicode, si la constante UTILISER_UNICODE est à True dans\n le module piece. Sinon, utilise seulement des caractères standards.\n\n Vous n'avez pas à comprendre cette partie du code.\n\n \"\"\"\n chaine = \"\"\n if pychecs.piece.UTILISER_UNICODE:\n chaine += ' \\u250c' + '\\u2500\\u2500\\u2500\\u252c' * 7 + '\\u2500\\u2500\\u2500\\u2510\\n'\n else:\n chaine += ' +' + '----+' * 8 + '\\n'\n\n for rangee in range(7, -1, -1):\n if pychecs.piece.UTILISER_UNICODE:\n chaine += '{} \\u2502 '.format(self.chiffres_rangees[rangee])\n else:\n chaine += '{} | '.format(self.chiffres_rangees[rangee])\n for colonne in range(8):\n piece = self.dictionnaire_pieces.get('{}{}'.format(self.lettres_colonnes[colonne], self.chiffres_rangees[rangee]))\n if piece is not None:\n if pychecs.piece.UTILISER_UNICODE:\n chaine += str(piece) + ' \\u2502 '\n else:\n chaine += str(piece) + ' | '\n else:\n if pychecs.piece.UTILISER_UNICODE:\n chaine += ' \\u2502 '\n else:\n chaine += ' | '\n\n if rangee != 0:\n if pychecs.piece.UTILISER_UNICODE:\n chaine += '\\n \\u251c' + '\\u2500\\u2500\\u2500\\u253c' * 7 + '\\u2500\\u2500\\u2500\\u2524\\n'\n else:\n chaine += '\\n +' + '----+' * 8 + '\\n'\n\n if pychecs.piece.UTILISER_UNICODE:\n chaine += '\\n \\u2514' + '\\u2500\\u2500\\u2500\\u2534' * 7 + '\\u2500\\u2500\\u2500\\u2518\\n'\n else:\n chaine += '\\n +' + '----+' * 8 + '\\n'\n\n chaine += ' '\n for colonne in range(8):\n if pychecs.piece.UTILISER_UNICODE:\n chaine += self.lettres_colonnes[colonne] + ' '\n else:\n chaine += self.lettres_colonnes[colonne] + ' '\n chaine += '\\n'\n return chaine\n","sub_path":"TP4/pychecs/echiquier.py","file_name":"echiquier.py","file_ext":"py","file_size_in_byte":16059,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"477114152","text":"from django.conf import settings\nfrom django.contrib.auth.views import redirect_to_login\nfrom django.core.exceptions import ImproperlyConfigured, PermissionDenied\n\nfrom .models import Article\n\n\nclass PublicArticlesMixin(object):\n \"\"\"\n include this mixin to only have public articles available\n \"\"\"\n queryset = Article.objects.filter(public=True)\n\n\nclass AuthRequiredMixin(object):\n \"\"\"\n require that a user is authenticated. If the user is not authenticated\n send them to the login page.\n \"\"\"\n login_url = settings.LOGIN_URL\n\n def dispatch(self, request, *args, **kwargs):\n \"\"\"\n check if the user is authenticated. If they are authenticated return the\n normal dispatch. If not, redirect them to login page.\n \"\"\"\n if not request.user.is_authenticated():\n return redirect_to_login(request.get_full_path(), self.login_url)\n\n return super(AuthRequiredMixin, self).dispatch(\n request, *args, **kwargs)\n\n\nclass UserAuthorMixin(AuthRequiredMixin):\n \"\"\"\n Checks that the user is the author of the article. If they are not, return a\n 403 error\n \"\"\"\n def dispatch(self, request, *args, **kwargs):\n if request.user.is_authenticated() and request.user.id is not self.get_object().author.id:\n raise PermissionDenied\n\n return super(UserAuthorMixin, self).dispatch(\n request, *args, **kwargs)\n","sub_path":"blog-example/articles/mixins.py","file_name":"mixins.py","file_ext":"py","file_size_in_byte":1423,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"248626874","text":"import tensorflow as tf\nfrom tensorflow.keras.layers import (\n BatchNormalization,\n Concatenate,\n Conv2D,\n Conv2DTranspose,\n Dropout,\n ELU,\n LeakyReLU,\n Multiply,\n ReLU,\n Softmax,\n Add,\n MaxPooling2D,\n)\nfrom tensorflow.compat.v1.keras.initializers import he_uniform\nfrom functools import partial\n\n\ndef _get_conv_activation_layer(params):\n \"\"\"\n :param params:\n :returns: Required Activation function.\n \"\"\"\n conv_activation = params.get('conv_activation')\n if conv_activation == 'ReLU':\n return ReLU()\n elif conv_activation == 'ELU':\n return ELU()\n return LeakyReLU(0.2)\n\n\ndef _get_deconv_activation_layer(params):\n \"\"\"\n :param params:\n :returns: Required Activation function.\n \"\"\"\n deconv_activation = params.get('deconv_activation')\n if deconv_activation == 'LeakyReLU':\n return LeakyReLU(0.2)\n elif deconv_activation == 'ELU':\n return ELU()\n return ReLU()\n\n\nclass Model:\n def __init__(\n self,\n input_tensor,\n cout=1,\n num_layers=6,\n num_initial_filters=16,\n output_mask_logit=False,\n logging=False,\n dropout=0.5,\n training=True,\n ):\n conv_activation_layer = _get_conv_activation_layer({})\n deconv_activation_layer = _get_deconv_activation_layer({})\n kernel_initializer = he_uniform(seed=50)\n\n conv2d_factory = partial(\n Conv2D,\n strides=(2, 2),\n padding='same',\n kernel_initializer=kernel_initializer,\n )\n\n conv2d_transpose_factory = partial(\n Conv2DTranspose,\n strides=(2, 2),\n padding='same',\n kernel_initializer=kernel_initializer,\n )\n\n def resnet_block(input_tensor, filter_size):\n\n res = conv2d_factory(\n filter_size, (1, 1), strides=(1, 1), use_bias=False\n )(input_tensor)\n conv1 = conv2d_factory(filter_size, (5, 5), strides=(1, 1))(\n input_tensor\n )\n batch1 = BatchNormalization(axis=-1)(conv1, training=training)\n rel1 = conv_activation_layer(batch1)\n conv2 = conv2d_factory(filter_size, (5, 5), strides=(1, 1))(rel1)\n batch2 = BatchNormalization(axis=-1)(conv2, training=training)\n resconnection = Add()([res, batch2])\n rel2 = conv_activation_layer(resconnection)\n return MaxPooling2D(padding='same')(rel2)\n\n enc_outputs = []\n current_layer = input_tensor\n for i in range(num_layers):\n\n if i < num_layers - 1:\n current_layer = resnet_block(\n current_layer, num_initial_filters * (2 ** i)\n )\n enc_outputs.append(current_layer)\n else:\n current_layer = conv2d_factory(\n num_initial_filters * (2 ** i), (5, 5)\n )(current_layer)\n\n if logging:\n print(current_layer)\n\n for i in range(num_layers - 1):\n\n current_layer = conv2d_transpose_factory(\n num_initial_filters * (2 ** (num_layers - i - 2)), (5, 5)\n )((current_layer))\n current_layer = deconv_activation_layer(current_layer)\n current_layer = BatchNormalization(axis=-1)(\n current_layer, training=training\n )\n if i < 3:\n current_layer = Dropout(dropout)(\n current_layer, training=training\n )\n current_layer = Concatenate(axis=-1)(\n [enc_outputs[-i - 1], current_layer]\n )\n if logging:\n print(current_layer)\n\n current_layer = conv2d_transpose_factory(1, (5, 5), strides=(2, 2))(\n (current_layer)\n )\n current_layer = deconv_activation_layer(current_layer)\n current_layer = BatchNormalization(axis=-1)(\n current_layer, training=training\n )\n\n if not output_mask_logit:\n last = Conv2D(\n cout,\n (4, 4),\n dilation_rate=(2, 2),\n activation='sigmoid',\n padding='same',\n kernel_initializer=kernel_initializer,\n )((current_layer))\n output = Multiply()([last, input_tensor])\n self.logits = output\n else:\n self.logits = Conv2D(\n cout,\n (4, 4),\n dilation_rate=(2, 2),\n padding='same',\n kernel_initializer=kernel_initializer,\n )((current_layer))\n","sub_path":"malaya_speech/train/model/resnet_unet/model.py","file_name":"model.py","file_ext":"py","file_size_in_byte":4664,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"211386617","text":"import xml.etree.ElementTree as ET\nfrom typing import Dict, Union, Optional\n\nimport pandas as pd\n\n\ndef parse(\n element,\n parsed: Optional[Dict[str, str]],\n arg,\n gh,\n gie4,\n gggggggggggggggggggggggggggg,\n) -> Dict[str, str]:\n if parsed is None:\n parsed = dict()\n for key in element.keys():\n parsed[key] = element.attrib.get(key)\n if element.text:\n s = \"\"\n parsed[element.tag] = element.text\n for child in list(element):\n parse(child, parsed)\n return parsed\n\n\ndef _main():\n print(\"\"\"\"\"\")\n xml_data = open(\"films.xml\").read()\n root = ET.XML(xml_data)\n data = pd.DataFrame([parse(chil) for chil in iter(root)])\n data.to_csv(\"notcsv.csv\")\n\n\nif __name__ == \"__main__\":\n _main()\n","sub_path":"code.py","file_name":"code.py","file_ext":"py","file_size_in_byte":783,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"612806847","text":"# -*- coding: utf-8 -*-\n\nfrom odoo import models, fields, api\nfrom odoo.tools import float_is_zero, float_compare\nfrom num2words import num2words\nimport base64\nimport re\n\nclass customerinvoicereport(models.AbstractModel):\n _name = 'report.dmc_reports.account_move_order_report'\n _description = 'DMC New invoice Reports'\n\n @api.model\n def _get_report_values(self, docids, data=None):\n # report_obj = self.env['report']\n # report = report_obj._get_report_from_name('ioud_new_invoice.purchase_order_report_report')\n records = self.env['account.move'].browse(docids)\n\n lisst = []\n count = 0\n for x in records.invoice_line_ids:\n count = count + 1\n\n lenght = 4 - count\n\n for x in range(count + 1, lenght + 2):\n lisst.append(x)\n\n def number_to_spell(attrb):\n word = num2words((\"%.2f\" % attrb))\n word = word.title()\n return str(word).replace('Point', 'Riyal') + ' Hallah'\n\n arab = 0\n # if records.partner_id.ext_arabic_name:\n # arab = 1\n\n def get_arabic(attr):\n trans = self.env['ir.translation'].search([('src', '=', attr)])\n if trans:\n trans = trans[-1]\n return trans.value\n\n def get_arebic_total_word(attrb):\n # like .... attrb = 16,537.50\n word = num2words(float(\"%.2f\" % attrb), lang='ar')\n word = word.title()\n Warr = str((\"%.2f\" % attrb)).split('.')\n AR = ' ريال' if str(Warr[1]) == '00' else ' هلله'\n Rword = str(word).replace(',', ' ريال و ') + AR\n Rword = str(Rword).replace('ريال و ', 'فاصلة')\n\n return Rword\n\n docargs = {\n 'doc_ids': docids,\n 'doc_model': 'account.move',\n 'docs': records,\n 'lisst': lisst,\n 'number_to_spell': number_to_spell,\n # 'arab': arab,\n 'get_arabic': get_arabic,\n 'get_arebic_total_word': get_arebic_total_word,\n }\n\n return docargs\n\nclass StockPicking(models.Model):\n _inherit = \"stock.picking\"\n\n def get_project(self, origin):\n for rec in self:\n so = self.env['sale.order'].search([('name', '=', rec.origin)])\n for rec in so:\n origin = rec.partner_invoice_id.name\n return origin\n","sub_path":"dmc/internal/dmc_reports/models/model.py","file_name":"model.py","file_ext":"py","file_size_in_byte":2423,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"260818878","text":"# AUTHOR : James Gadoury\n# CONTACT: gadouryjames@gmail.com\n# GUI application developed using Tkinter and Python3\n# Dreams in Text : Text game with a fantastical setting\n# relies on playgame.py, game.py, interactables.py, and items.py\n\nfrom interactables import *\n\ninteractions = ['take', 'punch', 'kick', 'break', 'drop', 'climb', 'open', 'attack', 'shoot', 'pick up']\n\nfor action in interactions[:]:\n interactions.append(action + ' the')\n\n\nclass Inventory:\n def __init__(self):\n self._inventory = []\n\n def add_item(self, item):\n self._inventory.append(item)\n\n def remove_item(self, item):\n self._inventory.remove(item)\n\n @property\n def inventory(self):\n return [item for item in self._inventory]\n\n def show_inventory(self):\n if len(self.inventory) > 0:\n print(\"You are currently holding: \")\n for i, item in enumerate(self.inventory, 1):\n print(f'[{i}] {item}')\n else:\n print(\"You don't have anything!\")\n\n\nclass Interactable:\n def __init__(self):\n pass\n\n def interact_with_object(self, ui):\n self._ui = ui.rsplit(' ', 1)[0]\n\n @property\n def ui(self):\n return self._ui.lower()\n\n\nclass Lamp(Interactable):\n lampInteractionList = ['take', 'break', 'punch', 'kick', 'drop', 'pick up']\n for i in range(len(lampInteractionList)):\n lampInteractionList.append(lampInteractionList[i] + ' the')\n\n def __init__(self):\n Interactable.__init__(self)\n self.usable = True\n\n def breaks(self, object_dictionary):\n self.usable = False\n object_dictionary['i'].remove_item('lamp')\n\n def engage_lamp(self, UI, object_dictionary):\n self.interact_with_object(UI)\n if self.ui in self.lampInteractionList:\n if self.ui == 'take' or self.ui == 'take the' or self.ui == 'pick up' or self.ui == 'pick up the':\n if 'lamp' not in object_dictionary['i'].inventory:\n if self.usable:\n print(\"You pick up the lamp.\")\n object_dictionary['i'].add_item('lamp')\n else:\n print(\"The lamp is broken. It is useless now.\")\n else:\n print(\"You are currently holding the lamp!\")\n elif self.ui == 'drop' or self.ui == 'drop the':\n if 'lamp' in object_dictionary['i'].inventory:\n print(\"You drop the lamp.\")\n print(\"It shatters on the ground.\")\n self.breaks()\n object_dictionary['i'].remove_item('lamp')\n else:\n print(\"You are not holding the lamp!\")\n elif self.ui == 'break' or self.ui == 'break the':\n if 'lamp' in object_dictionary['i'].inventory:\n print(\"You break the lamp.\")\n self.breaks()\n object_dictionary['i'].remove_item('lamp')\n else:\n print(\"You are not holding the lamp!\")\n else:\n error()\n\n else:\n error()\n\n def use_lamp(self, ui, object_dictionary):\n\n self.interact_with_object(ui)\n\n if 'lamp' not in object_dictionary['i'].inventory:\n print(\"You are not holding the lamp!\")\n else:\n if self.ui == 'break window with' or self.ui == 'break the window with':\n object_dictionary['w'].engage_window('break window with lamp x', object_dictionary)\n elif self.ui == 'break door with' or self.ui == 'break the door with':\n object_dictionary['d'].engageDoor('break door with lamp x', object_dictionary)\n elif self.ui == 'attack robot with' or self.ui == 'attack the robot with':\n object_dictionary['r'].engage_robot('attack robot with lamp x', object_dictionary)\n else:\n error()\n\n\nclass Gun(Interactable):\n\n def __init__(self):\n Interactable.__init__(self)\n self.usable = True\n self.bullet_count = 3\n\n def shoot_gun(self):\n self.bullet_count -= 1\n if not self.bullet_count:\n self.usable = False\n return self.bullet_count\n\n def engage_pistol(self, ui, object_dictionary):\n self.interact_with_object(ui)\n if self.ui in interactions:\n if self.ui == 'take' or self.ui == 'take the' or self.ui == 'pick up' or self.ui == 'pick up the':\n if object_dictionary['r'].awake:\n print(\"You reach to take the pistol from the robot's side...\")\n\n if not object_dictionary['r'].can_be_commanded:\n print(\"The robot covers the pistol with its large hand.\")\n\n print(\"'No...no. I can't let you take this. I may need it.', the robot patronizes.\")\n else:\n self.take_pistol(object_dictionary)\n elif 'gun' not in object_dictionary['i'].inventory:\n self.take_pistol(object_dictionary)\n else:\n print(\"You are currently holding the pistol!\")\n elif self.ui == 'drop' or self.ui == 'drop the':\n if 'pistol' in object_dictionary['i'].inventory:\n print(\"You drop the pistol.\")\n object_dictionary['i'].remove_item('pistol')\n else:\n print(\"You are not holding the pistol!\")\n elif self.ui == 'break' or self.ui == 'break the':\n if 'pistol' in object_dictionary['i'].inventory:\n print(\"You can't break the pistol.\")\n else:\n print(\"You are not holding the pistol!\")\n else:\n error()\n\n else:\n error()\n\n def take_pistol(self, object_dictionary):\n if self.usable:\n print(\"You pick up the pistol.\")\n\n print(\"It has two bullets in the clip and one in the chamber.\")\n object_dictionary['i'].add_item('pistol')\n else:\n print(\"The pistol is out of bullets. It is useless now.\")\n\n def use_pistol(self, UI, object_dictionary):\n\n self.interact_with_object(UI)\n\n if 'pistol' not in object_dictionary['i'].inventory:\n print(\"You are not holding the pistol!\")\n elif not self.usable:\n print(\"The pistol is out of bullets. It is useless now.\")\n else:\n if self.ui in ('break window with', 'break the window with', 'shoot window with', 'shoot the window with'):\n self.shoot_gun()\n object_dictionary['w'].engage_window('shoot window with pistol x', object_dictionary)\n elif self.ui in ('break door with', 'break the door with', 'shoot door with', 'shoot the door with'):\n self.shoot_gun()\n object_dictionary['d'].engageDoor('shoot door with pistol x', object_dictionary)\n elif self.ui in ('attack robot with', 'attack the robot with', 'shoot robot with', 'shoot the robot with'):\n self.shoot_gun()\n object_dictionary['r'].engage_robot('attack robot with pistol x', object_dictionary)\n else:\n error()\n\n\ndef error():\n print(\"*You can't do that*\")\n print(\"type HELP if confused.\")\n","sub_path":"items.py","file_name":"items.py","file_ext":"py","file_size_in_byte":7373,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"79678926","text":"\"\"\"\nMerge Sorted Array\n\nYou are given two integer arrays nums1 and nums2, sorted in non-decreasing order, and two integers m and n, representing the number of elements in nums1 and nums2 respectively.\n\nMerge nums1 and nums2 into a single array sorted in non-decreasing order.\n\nThe final sorted array should not be returned by the function, but instead be stored inside the array nums1. To accommodate this, nums1 has a length of m + n, where the first m elements denote the elements that should be merged, and the last n elements are set to 0 and should be ignored. nums2 has a length of n.\n\nInput: nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3\nOutput: [1,2,2,3,5,6]\nExplanation: The arrays we are merging are [1,2,3] and [2,5,6].\nThe result of the merge is [1,2,2,3,5,6] with the underlined elements coming from nums1.\n\nInput: nums1 = [1], m = 1, nums2 = [], n = 0\nOutput: [1]\nExplanation: The arrays we are merging are [1] and [].\nThe result of the merge is [1].\n\nInput: nums1 = [0], m = 0, nums2 = [1], n = 1\nOutput: [1]\nExplanation: The arrays we are merging are [] and [1].\nThe result of the merge is [1].\nNote that because m = 0, there are no elements in nums1. The 0 is only there to ensure the merge result can fit in nums1.\n\ni = 2, j = 1, k = 5\n\nnums1[k] = max(nums1[i], nums2[j])\n\n[1,2,2,3,5,6] m = 3, n = 3\n[2,5,6]\n\n[10,11,12, 10,11,12]\n[1,2,3]\n\"\"\"\n\nfrom typing import List\n\n\ndef mergeArrays(nums1: List[int], nums2: List[int], m: int, n: int):\n i, j, k = m-1, n-1, m+n-1\n\n while j >= 0:\n if i >= 0 and nums1[i] > nums2[j]:\n nums1[k] = nums1[i]\n i -= 1\n else:\n nums1[k] = nums2[j]\n j -= 1\n k -= 1\n\nnums1 = [1,2,3,0,0,0]\nm = 3\nnums2 = [2,5,6]\nn = 3\nmergeArrays(nums1, nums2, m, n)\nprint(nums1)\n\nnums1 = [1]\nm = 1\nnums2 = []\nn = 0\nmergeArrays(nums1, nums2, m, n)\nprint(nums1)\n\nnums1 = [0]\nm = 0\nnums2 = [1]\nn = 1\nmergeArrays(nums1, nums2, m, n)\nprint(nums1)\n\nnums1 = [10,11,12,0,0,0]\nnums2 = [1,2,3]\nm = 3\nn = 3\nmergeArrays(nums1, nums2, m, n)\nprint(nums1)","sub_path":"merge_sorted_array.py","file_name":"merge_sorted_array.py","file_ext":"py","file_size_in_byte":2043,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"607140134","text":"import random\n\nfrom copy import deepcopy\n\n\nclass Matrix:\n\n def __init__(self, nrows, ncols):\n \"\"\"Construct a (nrows X ncols) matrix\"\"\"\n self.a = []\n self.nrows = nrows\n self.ncols = ncols\n for i in range(self.nrows):\n b = []\n self.a.append(b) \n for j in range(self.ncols):\n b.append(random.randint(0,9)) \n\n def add(self, m):\n \"\"\"return a new Matrix object after summation\"\"\"\n matrix = Matrix(self.nrows,self.ncols)\n a = []\n self.matrix2 = m\n for i in range(self.nrows):\n b = []\n a.append(b)\n for j in range(self.ncols):\n #x = self.a[i][j] + self.matrix2[i][j]\n b.append(self.a[i][j] + self.matrix2[i][j])\n #print(x)\n self.a = a\n\n return matrix\n \n def sub(self, m):\n \"\"\"return a new Matrix object after substraction\"\"\"\n matrix = Matrix(self.nrows,self.ncols)\n a = []\n self.matrix2 = m\n for i in range(self.nrows):\n b = []\n a.append(b)\n for j in range(self.ncols):\n x = self.a[i][j] - self.matrix2[i][j]\n b.append(self.a[i][j] - self.matrix2[i][j])\n #print(x)\n self.a = a\n return matrix\n\n def mul(self, m):\n \"\"\"return a new Matrix object after multiplication\"\"\"\n matrix = Matrix(self.nrows,self.ncols)\n self.matrix2 = m\n a = []\n self.mul_sum = []\n for i in range (len(self.a)):\n b = []\n a.append(b)\n for j in range (len(self.matrix2[0])):\n self.z = 0\n for k in range (len(self.a[0])):\n self.z = self.z + self.a[i][k] * self.matrix2[k][j]\n #print(z)\n b.append(self.z)\n self.a = a\n # print(self.mul_sum,end=\"\")\n return matrix\n\n \n\n def transpose(self):\n \"\"\"return a new Matrix object after transpose\"\"\"\n matrix = Matrix(self.nrows,self.ncols)\n a = []\n for i in range (len(self.a)):\n b = []\n a.append(b)\n for j in range (len(self.a[0])):\n b.append(self.a[j][i])\n self.a = a\n return matrix\n\n \n def display(self):\n \"\"\"Display the content in the matrix\"\"\"\n for i in range (len(self.a)):\n for j in range (len(self.a[0])):\n print(self.a[i][j], end=\" \")\n print(\"\")\n print(\"\")\n # print(len(self.a))\n # print(len(self.a[0]))\n# nrows = 3\n# ncols = 3\n# b = []\n# for i in range (nrows):\n# a = []\n# b.append(a)\n# #print(b)\n# for j in range (ncols):\n# a.append(random.randint(0,9))\n#print(b)\n# # print(b[2][1])\n# y = []\n# for i in range (nrows):\n# z = []\n# y.append(z)\n# for j in range(ncols):\n# x = b[i][j] + b[i][j]\n# print(x)\n# z.append(x) \n\n# print(y)\n\na1 = int(input(\"Enter A matrix's rows:\" ))\nb1 = int(input(\"Enter A matrix's cols:\" ))\na2 = int(input(\"Enter B matrix's rows:\" ))\nb2 = int(input(\"Enter B matrix's cols:\" ))\nmatrix1 = Matrix(a1,b1)\nmatrix2 = Matrix(a2,b2)\nmatrix1.display()\nmatrix2.display()\nmatrix1.add(matrix2.a)\nprint(type(matrix1.add(matrix2.a)))\nmatrix1.display()\nmatrix1.sub(matrix2.a)\nmatrix1.sub(matrix2.a)\nmatrix1.display()\nmatrix1.add(matrix2.a)\nmatrix1.mul(matrix2.a)\nmatrix1.display()\nmatrix1.transpose()\nmatrix1.display()\n","sub_path":"matrix.py","file_name":"matrix.py","file_ext":"py","file_size_in_byte":3536,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"12780765","text":"## Updated to new environment\n################################# Day 1 #################################\n## Fuel required to launch a given module is based on its mass. Specifically, to find the fuel\n## required for a module, take its mass, divide by three, round down, and subtract 2.\n## Import needed libraries\nimport Advent_of_Code_2019.Day_1.aoc_fuel_functions as aoc_fuel_functions\n\n## Load fuel data\nmodule_data = aoc_fuel_functions.load_module_data('module_inputs.txt')\n\n## Call calculate_fuel function\nfuel_needed = aoc_fuel_functions.calculate_fuel_for_modules(module_data)\n\n## Print required fuel\nprint(\"Required Fuel for Modules: {0}\".format(sum(fuel_needed)))\n\n## What is the sum of the fuel requirements for all of the modules on your spacecraft when\n## also taking into account the mass of the added fuel? (Calculate the fuel requirements\n## for each module separately, then add them all up at the end.)\nfuel_needed_all = aoc_fuel_functions.calculate_fuel_for_modules_all(module_data)\n\n## Print new required fuel value\nprint(\"Required Fuel after accounting for weight of fuel: {0}\".format(sum(fuel_needed_all)))\n\n################################# Day 2 #################################\n## An Intcode program is a list of integers separated by commas (like 1,0,0,3,99). To run one, start by looking\n## at the first integer (called position 0). Here, you will find an opcode - either 1, 2, or 99. The opcode\n## indicates what to do; for example, 99 means that the program is finished and should immediately halt.\n# Encountering an unknown opcode means something went wrong.\n## Import needed libraries\nimport Advent_of_Code_2019.Day_2.aoc_computer_functions as aoc_computer_functions\n\n## Load up gravity program\ngravity_program = aoc_computer_functions.load_gravity_program('gravity_program.txt')\n\n## Run program\ncode = aoc_computer_functions.run_gravity_program(gravity_program)\n\n## Print code that restores gravity\nprint(\"Gravity Restored: {0}\".format(code))\n\n## Find the input noun (address 1) and verb (address 2) that cause the program to produce the output 19690720.\n## What is 100 * noun + verb? (For example, if noun=12 and verb=2, the answer would be 1202.)\n## Values can be between 0 - 99 for both addresses\n## Load up gravity program\ngravity_program = aoc_computer_functions.load_gravity_program('gravity_program.txt')\n\n## Run program - Brute force method\nnoun,verb, result = aoc_computer_functions.execute_gravity_assist(gravity_program)\n\n################################# Day 3 #################################\n# ...........\n# .+-----+...\n# .|.....|...\n# .|..+--X-+.\n# .|..|..|.|.\n# .|.-X--+.|.\n# .|..|....|.\n# .|.......|.\n# .o-------+.\n# ...........\n# These wires cross at two locations (marked X), but the lower-left one is closer to the central port: its distance is 3 + 3 = 6.\n\n# Here are a few more examples:\n# R75,D30,R83,U83,L12,D49,R71,U7,L72\n# U62,R66,U55,R34,D71,R55,D58,R83 = distance 159\n# R98,U47,R26,D63,R33,U87,L62,D20,R33,U53,R51\n# U98,R91,D20,R16,D67,R40,U7,R15,U6,R7 = distance 135\n# What is the Manhattan distance from the central port to the closest intersection?\n## Import needed libraries\nimport Advent_of_Code_2019.Day_3.aoc_wire_functions as aoc_wire_functions\n\n## Load up the wire data\nwire_1, wire_2 = aoc_wire_functions.load_wires()\n\n## Process the data into points for plotting\nwire_1_points = aoc_wire_functions.create_wire_points(wire_1)\nwire_2_points = aoc_wire_functions.create_wire_points(wire_2)\n\n## Calculate overlapping points\n\n\n## Determine closest and calculate manhattan distance","sub_path":"aoc_main.py","file_name":"aoc_main.py","file_ext":"py","file_size_in_byte":3543,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"8402401","text":"#Mandelbrot hot() colored set in terms of log(iteration)#\n#500*500 with max 200 iterations#\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport math\n\na = np.empty([500, 500], float)\nx = np.linspace(-2, 2, 500)\ny = np.linspace(-2, 2, 500)\n\ndef mand(ite, c):\n\tz = 0\n\ti = 0\n\tfor i in range(ite):\n\t\tz = z**2 + c\n\t\ti += 1\n\t\tif np.abs(z) > 2:\n\t\t\treturn math.log(i)\n\treturn math.log(ite)\n\nk = q = 0\nfor k in range(500):\n\tfor q in range(500):\n\t\ta[q, k] = mand(200, x[k] + y[q]*1j)\n\t\tq+=1\n\tk = k + 1\n\tq = 0\n\nplt.imshow(a, origin=\"lower\", extent=[-2,2,-2,2])\nplt.hot()\nplt.show()\n\n\n\n","sub_path":"37p6.py","file_name":"37p6.py","file_ext":"py","file_size_in_byte":579,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"253118893","text":"import re # for rstrip()\n\n#f=open(\"0_E_1.000000\",\"r\")\nf=open(\"1_E_1.071429\",\"r\")\n\ntt = f.readlines()\nf.close()\n#len(tt)\nt_len = len(tt)/2 # drop the first half of data\nt_len = int(t_len) # cast to int type\n\nt_len = int(5000)\nt_rest = tt[t_len:]\n\n#len(t_rest)\n\nt_removeNL=[]\nt_removeNL=[x.rstrip() for x in t_rest] # remove the \"\\n\" for each line\n#len(t_removeNL)\n\n \ntu_int = list(map(lambda x:(float(x.split(\"\\t\")[0]),float(x.split(\"\\t\")[1])), t_removeNL)) #\nstep = [x[0] for x in tu_int]\nE = [x[1] for x in tu_int] # only E, use x[] not x()\n\nE_avg = sum(E) / float(len(E))\n\nprint(\"E_avg is: %s\" % E_avg)\n\nimport pylab as pl\n\npl.plot(step,E)\n\npl.show()\n","sub_path":"Mean_E.py","file_name":"Mean_E.py","file_ext":"py","file_size_in_byte":656,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"68846802","text":"import numpy as np\n\ndef read_file(filename, separator = \" \"):\n content = []\n with open(filename, \"r\") as file_to_load:\n while True:\n line = file_to_load.readline()\n if not line:\n break\n content_tmp = [float(i) for i in line.split(separator)]\n content.append(content_tmp)\n content = np.array(content)\n X = np.array([[]])\n Y = np.array([[]])\n if content != []:\n X = content[:, 0:-1].T\n Y = content[:, -1].reshape(1, X.shape[1])\n return X, Y\n\ndef read_csv(filename): \n content = [] \n titles = [] \n with open(filename, \"r\") as file_to_load: \n titles = file_to_load.readline().split(\",\") \n while True: \n line = file_to_load.readline() \n if not line: \n break \n content.append([float(i) for i in line.split(\",\")]) \n content = np.array(content) \n X = np.array([[]]) \n Y = np.array([[]]) \n titles.pop(-1)\n if content != []: \n X = content[:, 0:-1].T \n Y = content[:, -1].T.reshape(1, X.shape[1])\n return X, Y, titles ","sub_path":"loadFile.py","file_name":"loadFile.py","file_ext":"py","file_size_in_byte":1119,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"} +{"seq_id":"233039404","text":"'''\nThis file will be used to process the packets that are received from the ground. Before the packets reach this file, they will be sent to the radio and then over UART to the pi.\nThe pythonInterrupt.py file monitors the UART buffer, and when data is received it will gather the data byte by byte and then parse the data for the header and footer that should be located on either end of our packets.\nThe header and footer is the Hex representation of 'GASPACS'. The pythonInterrupt.py takes the packet data located in between the header and footer and then calls the processPacket() method located in this file, passing in an argument containing the packet data.\nprocessPacket() will convert the packet data to binary, and then go through bit by bit and perform the functionality specified in the packet.\n'''\n# NOTE: This code is not asyncronous currently.\nimport sys\nsys.path.append('../')\nimport time\nimport os.path\nfrom os import system\nfrom Drivers.camera import Camera\nimport Drivers.boomDeployer as boomDeployer\nimport smbus\nimport hmac\n\ndef processAX25(AX25): #Placeholder function\n\t#Check AX25 Transmission flag, if it is OK then open a pyserial connection and transmit the content of the packet\n\tpass\n\nasync def processPacket(packetData):\n\tprint('Processing packet')\n\t# Packet data comes in as hex, need to convet to binary to parse\n\tbinaryDataLength = len(packetData) * 4\n\tprint('bin data len' + str(binaryDataLength))\n\tbinaryData = format(int(packetData,16), 'b').zfill(binaryDataLength)\n\tsecretKey = b'SECRETKEY'\n\n\tif binaryData[0:8] == '00000000':\n\t\t# This is a TX Schedule packet.\n\t\tprint(\"TX Schedule Packet\")\n\n\t\t# Get window start delta T\n\t\twindowStartBinary = binaryData[8:40]\n\t\twindowStartDecimal = int(windowStartBinary,2)\n\t\tprint(\"Window start in seconds: \", windowStartDecimal)\n\n\t\t# Get window duration\n\t\twindowDurationBinary = binaryData[40:56]\n\t\twindowDurationDecimal = int(windowDurationBinary,2)\n\t\tprint(\"Window duration in seconds: \", windowDurationDecimal)\n\n\t\t# Get data type\n\t\tdataTypeBinary = binaryData[56:64]\n\t\tdataTypeDecimal = int(dataTypeBinary,2)\n\t\tprint(\"Data type: \", dataTypeDecimal)\n\n\t\t# Get picture number\n\t\tpictureNumberBinary = binaryData[64:80]\n\t\tpictureNumberDecimal = int(pictureNumberBinary,2)\n\t\tprint(\"Picture number: \", pictureNumberDecimal)\n\n\t\t# Get \"Start From Beginning\"\n\t\tstartFromBeginning = binaryData[80:88]\n\t\tprint(\"Start from beginning: \", startFromBeginning)\n\n\t\t# Get the appended hash - it is a 16 byte (128 bit) value\n\t\treceivedHash = binaryData[88:]\n\t\tprint(\"Received Hash: \", receivedHash)\n\n\t\t# Generated hash from received data\n\t\tgeneratedHash = hmac.new(secretKey, bytes(binaryData[0:88], 'utf-8'))\n\t\tgeneratedHashHex = generatedHash.hexdigest()\n\t\tgeneratedHashLength = len(generatedHashHex) * 4\n\t\tgeneratedHashBinary = format(int(generatedHashHex,16), 'b').zfill(generatedHashLength)\n\t\tprint(\"Generated hash: \", generatedHashBinary)\n\t\tif receivedHash == generatedHashBinary:\n\t\t\tprint(\"Hashes match! Writing window\")\n\t\t\twriteTXWindow(windowStartDecimal, windowDurationDecimal, dataTypeDecimal, pictureNumberDecimal, startFromBeginning)\n\n\t\telse:\n\t\t\tprint(\"Hashes do not match, will not save window!\")\n\n\telse:\n\t\t# This is a command packet\n\t\tprint(\"Command packet\")\n\n\t\t# Validate HMAC Hash\n\t\t# Note, hash is 16 bytes (128 bits). Command packet is 1 byte (8 bits)\n\t\treceivedHash = binaryData[56:185]\n\t\tprint(\"Received Hash: \", receivedHash)\n\n\t\t# Generated hash from received data\n\t\tgeneratedHash = hmac.new(secretKey, bytes(binaryData[0:56], 'utf-8'))\n\t\tgeneratedHashHex = generatedHash.hexdigest()\n\t\tgeneratedHashLength = len(generatedHashHex) * 4\n\t\tgeneratedHashBinary = format(int(generatedHashHex,16), 'b').zfill(generatedHashLength)\n\t\tprint(\"Generated hash: \", generatedHashBinary)\n\t\tif receivedHash == generatedHashBinary:\n\t\t\tprint(\"Hashes match! Executing commands\")\n\n\t\t\tif binaryData[8:16] == '00000000':\n\t\t\t\t# Turn off Transmitter\n\t\t\t\tprint(\"Turn off Transmissions\")\n\t\t\t\tdisableTransmissions()\n\t\t\telse:\n\t\t\t\t#Turn on Transmitter\n\t\t\t\tprint(\"Turn on Transmitter\")\n\t\t\t\tenableTransmissions()\n\n\t\t\tif binaryData[16:24] == '00000000':\n\t\t\t\t# DO NOT Clear TX Schedule and Progress\n\t\t\t\tprint(\"Do NOT Clear TX Schedule and Progress\")\n\t\t\telse:\n\t\t\t\t# Clear TX Schedule & Progress\n\t\t\t\tprint(\"Clear TX Schedule and Progress\")\n\t\t\t\tclearTXFile()\n\t\t\t\tclearTXProgress()\n\n\t\t\tif binaryData[24:32] == '00000000':\n\t\t\t\t# Do not take picture\n\t\t\t\tprint(\"Do not take picture\")\n\t\t\telse:\n\t\t\t\t# Take picture\n\t\t\t\tprint(\"Take picture\")\n\t\t\t\tcam = Camera()\n\t\t\t\tcam.takePicture()\n\n\t\t\tif binaryData[32:40] == '00000000':\n\t\t\t\t# Do not deploy boom\n\t\t\t\tprint(\"Do not deploy boom\")\n\t\t\telse:\n\t\t\t\t# Deploy boom\n\t\t\t\tprint(\"Deploy boom\")\n\t\t\t\tdeployer = boomDeployer.BoomDeployer()\n\t\t\t\tawait deployer.deploy()\n\n\t\t\tif binaryData[40:48] == '00000000':\n\t\t\t\t# Do not reboot\n\t\t\t\tprint(\"Do not reboot\")\n\t\t\telse:\n\t\t\t\t#Send reboot command to Beetle\n\t\t\t\tprint(\"Reboot\")\n\t\t\t\tbus = smbus.SMBus(1)\n\t\t\t\taddress = 0x08\n\t\t\t\tbus.write_byte(address, 1)\n\n\t\t\tif binaryData[48:56] == '00000000':\n\t\t\t\t# Turn off AX25\n\t\t\t\tprint(\"Turn off AX25\")\n\t\t\t\tdisableAX25()\n\t\t\telse:\n\t\t\t\t#Turn on AX25\n\t\t\t\tprint(\"Turn on AX25\")\n\t\t\t\tenableAX25()\n\t\telse:\n\t\t\tprint(\"Hashes do not match, will not execute commands!\")\n\n\ndef writeTXWindow(windowStart, windowDuration, dataType, pictureNumber, startFromBeginning):\n\t# This function will write the TX window packet information to a file. Pass in the window start (delta T), window duration, data type, picture number, and Start From Beginning (1/0).\n\t# Note that this function saves the window start as an actual time, not a delta T - this is critical.\n\n\t# Convert window start from delta T to seconds since epoch\n\twindowStartTime = windowStart + int(time.time())\n\tprint(\"Current time: \", int(time.time()))\n\tprint(\"Start time: \", windowStartTime)\n\t\n\tTXWindow_File = open(\"/home/pi/Integration/CubeWorks/TXISR/data/txWindows.txt\", \"a+\")\n \n\t#write the data to the file,\n\tTXWindow_File.write(str(windowStartTime)+',')\n\tTXWindow_File.write(str(windowDuration)+',')\n\tTXWindow_File.write(str(dataType)+',')\n\tTXWindow_File.write(str(pictureNumber)+',')\n\tTXWindow_File.write(str(startFromBeginning))\n\tTXWindow_File.write('\\n')\n\t\n\t# close file\n\tTXWindow_File.close()\n\t\ndef disableTransmissions():\n\t# This function will set a flag that will disable the radio transmissions. We will check the flag before making any transmissions.\n\ttransmissionFlag_File = open(\"/home/pi/Integration/CubeWorks/TXISR/data/transmissionFlag.txt\", \"w\")\n\t\n\t# write the data to the file,\n\ttransmissionFlag_File.write(\"Disabled\")\n\t\n\t# close the file\n\ttransmissionFlag_File.close()\n\t\ndef enableTransmissions():\n\t# This function will set a flag that will disable the radio transmissions. We will check the flag before making any transmissions.\n\ttransmissionFlag_File = open(\"/home/pi/Integration/CubeWorks/TXISR/data/transmissionFlag.txt\", \"w\")\n\t\n\t# write the data to the file,\n\ttransmissionFlag_File.write(\"Enabled\")\n\t\n\t# close file\n\ttransmissionFlag_File.close()\n\t\ndef disableAX25():\n\t# This function will set a flag that will disable the radio transmissions. We will check the flag before making any transmissions.\n\tAX25Flag_File = open(\"/home/pi/Integration/CubeWorks/TXISR/data/AX25Flag.txt\", \"w\")\n\t\n\t# write the data to the file,\n\tAX25Flag_File.write(\"Disabled\")\n\t\n\t# close the file\n\tAX25Flag_File.close()\n\t\ndef enableAX25():\n\t# This function will set a flag that will disable the radio transmissions. We will check the flag before making any transmissions.\n\tAX25Flag_File = open(\"/home/pi/Comms/CubeWorks/TXISR/data/AX25Flag.txt\", \"w\")\n\t\n\t# write the data to the file,\n\tAX25Flag_File.write(\"Enabled\")\n\t\n\t# close file\n\tAX25Flag_File.close()\n\t\ndef clearTXFile():\n\t# This function clears the TX windows file\n\ttransmissionFlag_File = open(\"/home/pi/Integration/CubeWorks/TXISR/data/txWindows.txt\", \"w\")\n\t\n\t# close file\n\ttransmissionFlag_File.close()\n\t\ndef clearTXProgress():\n\t# This function will clear the file that saves which timestamp has been transmitted most recently for each data type\n\tprint(\"I don't know which file to clear!!!\")\n\tprogressFile = open(\"/home/pi/Integration/CubeWorks/TXISR/data/flagsFile.txt\", \"w\")\n\tprogressFile.write('0\\n')\n\tprogressFile.write('0\\n')\n\tprogressFile.write('0\\n')\n\tprogressFile.write('0\\n')\n\tprogressFile.write('0\\n')\n\n# Command packet\n# processPacket('C8')\n# TX Window Packet\n#processPacket('0000000F007801000000')\n","sub_path":"TXISR/packetProcessing.py","file_name":"packetProcessing.py","file_ext":"py","file_size_in_byte":8363,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"92"}