def subf(pattern, format, string, count=0, flags=0, pos=None, endpos=None, concurrent=None, **kwargs):
"""Wrapper for subf."""
return regex.subf(
_apply_search_backrefs(pattern, flags), format, string,
count, flags, pos, endpos, concurrent, **kwargs
)
def nba_scraper(url, headers, n_years, verbose):
# Initiate variables for the for loop
df = pd.DataFrame()
season_list = past_seasons(n_years)
i = 1
for season in season_list:
# Creating the new url for the this season, scraping data, and saving it
url = re.subf(r'Season=[-\d]+', 'Season={}'.format(season), url)
result = requests.get(url, headers=headers)
columns = result.json()['resultSets'][0]['headers']
df = pd.concat([
df,
pd.DataFrame(result.json()['resultSets'][0]['rowSet'],
columns=columns)
],
axis=0)
# Updating the user and getting ready to scrape again
if verbose > 0:
print('Completed Scrape {} of {}'.format(i, len(season_list)))
i += 1
time.sleep(5)
return df
def subf(pattern, format, string, count=0, flags=0, pos=None, endpos=None, concurrent=None, **kwargs):
"""Wrapper for subf."""
return regex.subf(
_apply_search_backrefs(pattern, flags), format, string,
count, flags, pos, endpos, concurrent, **kwargs
)
def cut(self, text, flags=DEFAULT_FLAGS):
"""Perform tokenization and filter results according to given flags.
"""
if not self.compiled:
self.compile()
self._log(0, 'Original text: \033[7m{}\033[0m'.format(repr(text)))
if self.init:
text = regex.sub(self.initx, '{}'.format(FIRST_WORD), text)
self._log(
0, 'Sentence-intial words marked: \033[7m{}\033[0m'.format(
repr(text)))
if self.abbr:
text = regex.subf(self.abbrx,
'{}{{}}{}'.format(COVER_BEGIN, COVER_END), text)
self._log(0,
'Abbreviations marked: \033[7m{}\033[0m'.format(repr(text)))
pos = 0
for token, tag, level in self._cut_rec(text):
token = regex.sub('[' + FIRST_WORD + COVER_BEGIN + COVER_END + ']',
'', token)
oldpos = pos
pos += len(token)
if not flags & WHITESPACE_TOKENS and tag == WHITESPACE_TAG:
continue
if token == '' and (not flags & EMPTY_TOKENS
or tag == WHITESPACE_TAG):
continue
yield (token, tag, level, oldpos, pos)
def get_ad_tree(self):
"""Запрашивает из AD distinguishedName для всех UO,
возвращает список из списков элементов DN"""
try:
query = pyad.adquery.ADQuery()
query.execute_query(
attributes=["distinguishedName", "description"],
where_clause="objectClass = 'organizationalUnit'")
except Exception as e:
raise Exception(str(e))
else:
domain = False
ous = []
for row in query.get_results():
while domain is False:
self.domainList = row["distinguishedName"].split(
",DC=", maxsplit=1)[1].split(",DC=")
domain = ".".join(self.domainList)
self.logBrowser.append(
"Подключено к домену: {}".format(domain))
pathList = regex.subf(
"^OU=", "",
row["distinguishedName"].split(",DC=")[0]).split(",OU=")
reversedPathList = list(reversed(pathList))
ous += [reversedPathList]
return sorted(ous)
def __clean_data(self, strText):
sentences = []
strText = strText.lower()
strText = regex.subf(self.__bracket, "", strText)
strText = re.sub(self.__reSub0, " ", strText)
strText = re.sub(self.__reSub1, " ", strText)
for sentence in re.split("\.[^a-z0-9]|[,:?!;\n\r]", strText):
word_sen = word_token(sentence)
if (len(word_sen) > 2):
sentences.append(u" ".join(word_sen) + "\n")
return sentences
def login_templating(self, f, i, o):
"""Генерирует и возвращает логин из ФИО по шаблону"""
fLat = utilities.translit(f)
iLat = utilities.translit(i)
oLat = utilities.translit(o)
template = self.loginTemplate.text()
template = regex.subf(r'([fio])(\d*)', '{{{1}:.{2}}}', template)
template = template.replace(":.}", "}")
login = self.loginPrefix.text() + template.format(
f=fLat, i=iLat, o=oLat)
return login
def __clean_data(self, strText):
sentences = []
strText = strText.lower()
if self.usage_scenario == "phrase":
strText = regex.subf(self.__bracket, "", strText)
strText = re.sub(self.__reSub0, " ", strText)
strText = re.sub(self.__reSub1, " ", strText)
for sub in set(re.findall(self.__rePlus, strText)):
strText = strText.replace(sub, sub[0] + " " + sub[2])
for sentence in re.split(self.__resplit, strText):
word_sen = word_token(sentence)
if (len(word_sen) > self.__minNum):
sentences.append(u" ".join(word_sen) + "\n")
return sentences
def bball_reference_scraper(url, n_years, stat, verbose):
# Initiate variables for the for loop
season_list = [str(year) for year in range(2018, 2018 - n_years, -1)]
i = 1
# Creating the blank data frame
df = pd.DataFrame()
# Looping over all seasons
for season in season_list:
# Determining the url for the season
url = re.subf(r'NBA_[\d]+', 'NBA_{}'.format(season), url)
# Calling the scraper according to the stat input
if stat == 'assists_value':
df = pd.concat([df, assists_value_scraper(url, season)],
axis=0,
sort=False)
elif stat == 'standings':
df = pd.concat([df, standings_scraper(url, season)],
axis=0,
sort=False)
else:
print("We don't have that scraper, yet!")
# Updating the user and getting ready to scrape again
if verbose > 0:
print('Completed Scrape {} of {}'.format(i, len(season_list)))
i += 1
if i < len(season_list):
time.sleep(5)
return df
def wfs(i = [0]):
return regex.subf(r"wfs", "wfs" + indices(i), "(?P<wfs>" + Quantifiers([i[0],1]) + "(?:<((?&wfs))[&V-]((?&wfs))>" + "|" + Term([i[0],1]) + "=" + Term([i[0],2]) + "))")
def Term(i = [0]):
return regex.subf(r"Term", "Term" + indices(i), "(?P<Term>S*(?:\(((?&Term))[.+]((?&Term))\)" + "|" + Numeral + "|" + Variable + "))")
def Quantifiers(i = [0]):
return regex.subf(r"Quantifiers", "Quantifiers" + indices(i), "(?P<Quantifiers>"+ "(?:~|E"+ Variable + ":" + "|A" + Variable + ":" + ")*" + ")")
def dynamic_pattern(pattern):
regex.subf(pattern, replacement, input) # OK
subf(pattern, replacement, input) # OK
def main():
os.chdir(os.path.dirname(__file__))
gcc_command = list(["gcc", "-C", "-E"])
for include in INCLUDES:
gcc_command.append('-I')
gcc_command.append(include)
gcc_command.append(
"extern/tes3mp/apps/openmw-mp/Script/ScriptFunctions.hpp")
parser = PrimitiveHeaderParser()
with subprocess.Popen(gcc_command, stdout=subprocess.PIPE) as p:
out, err = p.communicate()
for line in out.splitlines():
parser.parse_line(line.decode())
raw = f"#[no_mangle]\npub static mut prefix: [u8; {len(PREFIX)}] = *b\"{PREFIX}\";\n"
fancy = ""
for func_name in parser.functions:
ref = parser.functions[func_name]
func = parser.classes[ref[0]].functions[ref[1]]
args = ', '.join([TYPE_TRANSLATION[arg[1]] for arg in func.args])
ret = ""
if func.return_type in ['const char*', 'const char *']:
ret = " -> *const c_char"
elif func.return_type != "void":
ret = f" -> {TYPE_TRANSLATION[func.return_type]}"
place_holder = "|" + ', '.join(['_'] * len(func.args)) + f'| {{ unreachable!("{func_name} was called before ' \
f'set by TES3MP"); }};'
func_def = f"#[no_mangle]\npub static mut {PREFIX}{func_name}: fn({args}){ret} = {place_holder}"
if '<REMOVE>' in func_def:
continue
raw += func_def + "\n"
fancy_name = normalize_var(func_name)
fancy_args = []
for arg in func.args:
fancy_arg = normalize_var(arg[0])
fancy_arg = fancy_arg.replace('__', '_')
if arg[1] in ['const char*', 'const char *']:
fancy_args.append((
fancy_arg, '&str',
f'CString::new({fancy_arg}).unwrap_or_default().as_ptr()'))
else:
fancy_args.append(
(fancy_arg, TYPE_TRANSLATION[arg[1]], fancy_arg))
ret = ""
if func.return_type in ['const char*', 'const char *']:
ret = " -> String"
elif func.return_type != "void":
ret = f" -> {TYPE_TRANSLATION[func.return_type]}"
func_args = ', '.join([f"{x[0]}: {x[1]}" for x in fancy_args])
call_args = ', '.join([x[2] for x in fancy_args])
if func.comment is not None:
comment = ""
for line in func.comment.strip().splitlines():
line = line.strip()
m = regex.match(RE_COMMENT_PREFIX, line)
comment += ("///" + (' ' * len(m[1])) + m[2]).rstrip() + "\n"
comment = regex.sub(RE_BRIEF, '', comment)
def replace_param(m):
return f"`{normalize_var(m[1])}`"
def replace_return(m):
return f"\n/// Returns {m[1].lower()}"
comment = regex.sub(RE_PARAM_PREFIX, replace_param, comment)
comment = regex.sub(RE_RETURN, replace_return, comment)
comment = regex.subf(RE_COMMENT_NEWLINE, '{1} \n///{2}', comment)
comment = comment.replace('"[Script]:"', '`[Script]:`')
fancy += comment
fancy += f"pub fn {fancy_name}({func_args}){ret} {{\n"
fancy += " unsafe {\n"
if func.return_type in ['const char*', 'const char *']:
fancy += f" CStr::from_ptr(raw::{PREFIX}{func_name}({call_args}))\n"
fancy += f" .to_str()\n"
fancy += f" .unwrap_or_default()\n"
fancy += f" .to_string()\n"
else:
fancy += f" raw::{PREFIX}{func_name}({call_args})\n"
fancy += " }\n"
fancy += "}\n\n"
whole = "use std::ffi::{CStr, CString};\nuse std::os::raw::*;\n\n"
whole += "#[allow(non_upper_case_globals)]\npub mod raw {\n use std::os::raw::*;\n"
for line in raw.splitlines():
whole += " " + line + "\n"
whole += "}\n\n"
whole += fancy
with open("tes3mp-plugin/src/plugin/generated.rs", "w") as f:
f.write(whole)
def dynamic_pattern(pattern):
regex.subf(pattern, replacement, input) # Noncompliant
subf(pattern, replacement, input) # Noncompliant
def dynamic_pattern(pattern):
regex.subf(pattern, replacement, input) # Noncompliant
subf(pattern, replacement, input) # Noncompliant